Reference

• std/archivetar archives: [Bytes.untarred] reads what the tar programs in use write - POSIX ustar, pax (POSIX.1-2001) and GNU tar - and [List.tarred] writes ustar, with a pax header in front of an entry whose path or link does not fit ustar's fields.
• std/binaryBinary formats read and written: [ByteReader] and [ByteWriter] for numbers of every width in either byte order, IEEE 754 floats, LEB128 integers, runs of bytes and text; [BitReader] and [BitWriter] for numbers packed into bits in either [BitOrder].
• std/cipherAuthenticated encryption: [ChaCha20Poly1305], the AEAD of RFC 8439 section 2.8, in TorbScript with no native.
• std/cliCommand lines: a program with several commands, flags, options and positional arguments, its help text and its errors, declared once.
• std/collectionsThe collections.
• std/compressionCompressed bytes: DEFLATE (RFC 1951) with [Bytes.deflated] and [Bytes.inflated], gzip (RFC 1952) around it with [Bytes.gzipped] and [Bytes.gunzipped], and the [Bytes.crc32] gzip checks a member with; and the two byte-oriented block formats of the Snappy and LZ4 projects, [Bytes.snappyCompressed] with [Bytes.snappyDecompressed] and [Bytes.lz4BlockCompressed] with [Bytes.lz4BlockDecompressed].
• std/consoleWriting to the two standard streams.
• std/coreWhat every other package builds on: the types the language itself refers to - [Option] behind Value?, [Result] behind ?, [Range], [RangeFrom] and [RangeTo] behind a..b, [Array] as the inline storage a list literal adapts to, [Buffer] as the heap storage everything that grows stands on - the traits the operators and the conversions go through, and the control flow that is a function.
• std/digestMessage digests: [Sha256] and [Sha512] (FIPS 180-4), [Sha1] (FIPS 180-4 / RFC 3174) and [Md5] (RFC 1321, legacy - see its own doc comment), and the [Digest] all four answer.
• std/dnsThe Domain Name System as values: [DomainName] with IDNA and the comparison of RFC 4343, the records as a closed set of typed cases, and the wire format of RFC 1035 with name compression and EDNS0 - a [Message] from bytes and back, [query] for the bytes of a query, and [readResponse] for the response to it.
• std/ecs
• std/encodingEncoding and decoding: what other languages need reflection for (serialization, config mapping, database rows, schemas, --help texts).
• std/expressionQuoted expressions: [Expression], the typed tree a quoted parameter hands over, and [ExpressionNode], the plain data anyone can build, match and transform.
• std/fsThe file system: File, which is both a stream's reading end and its writing end, and IoError, what every operation here fails with.
• std/geometryThe shapes, and what they answer about each other: what contains a point, what two of them share, how far apart they are, and which axis-aligned box holds one.
• std/gradientAutomatic differentiation: the derivative of a function written in ordinary arithmetic, computed alongside its value and exact to the scalar's own precision, with no step size and no symbolic algebra.
• std/htmlHTML as the WHATWG standard reads it and as a program writes it, in TorbScript.
• std/httpHTTP/1.1, client and server, in TorbScript over std/network (docs/design/NETWORK.md sections 6 to 9).
• std/identifierIdentifiers: the trait [Identifier] and its two types, [Uuid] (RFC 9562, versions 4 and 7) and [Ulid], one [IdentifierError] for a text that is neither, and the urn:uuid: bridge to std/uri (docs/design/URI.md section 12).
• std/ioThe three streams every process is started with.
• std/ipThe addresses of the Internet Protocol as values: an IPv4 address, an IPv6 address, an address of either version, and a socket address - an address and a port.
• std/iterationLazy pipelines: the two traits everything is pulled through, the stages between them, and the collectors that end one.
• std/jsonJSON as a format, written in TorbScript: an Encoder that writes the text, a parser into an EncodedValue that the shared ValueDecoder of std/encoding reads a typed value out of, and [JsonValue] for a document whose shape is not known ahead of time.
• std/json-schemaJSON Schema as a format, written in TorbScript: [JsonSchema] reads a schema of the in-place keywords of draft 2020-12 from JSON and validates a [JsonValue] document against it.
• std/linearVectors, matrices, quaternions and angles, generic over the scalar they are made of.
• std/machineThe kernel the bytecode VM of torb run --vm runs on: raw 64-bit words, and the C runtime behind them (docs/design/VM.md section 6).
• std/markdownMarkdown as a document format, written in TorbScript: CommonMark with the tables of GitHub Flavored Markdown and front matter.
• std/networkThe network: name resolution, TCP - a listener that accepts connections and a stream whose two directions are a Source and a Sink of Bytes - UDP, a socket that sends and receives datagrams, and Unix domain sockets, the same listener and stream over a path of the file system.
• std/numberEvery numeric type of the language: [Numeric], [Signed], [Bits] and [Real], the traits their operators go through; the sized integer types and the two floating-point types; [Decimal]; the conversions between all of them; and [ByteSize], a number of bytes in its units.
• std/osWhat a program asks about the machine it runs on (docs/design/OS.md): the environment it was started with, which system and version it is, and where the user's files belong.
• std/parallelOne thing going faster: [Parallel], a pipeline whose stages run on the workers of the pool, the parallel() that starts one from anything that can be iterated, and [Cut], what a collection implements to be cut into chunks without being copied first.
• std/pathPath: a root and a list of components, and never a string.
• std/preludeThe prelude: what is in scope in every file of a project, unless its project.trb names another prelude.
• std/processThe process itself, and the child processes it starts: [Process] for arguments and exiting, [Process.run] for a program run to its end, [Child] for a running program's pipes, and [ProcessOutput] for what a finished one left behind.
• std/projectThe vocabulary of project.trb: [Project], [Dependencies], [Program], [ScriptFamily], [Profile], [Test], [Tasks], [Workspace], [Registry] and [Source].
• std/random[Random], a seedable, splittable generator of random numbers that is a value: the same seed makes the same numbers on every machine and in both back ends, and a generator handed to a function is how that function gets its randomness (docs/design/RANDOM.md).
• std/regexRegular expressions with the syntax and the semantics of RE2, written in TorbScript: [Regex] compiles a pattern once, and matching runs in time linear in the length of the text - there is no backtracking, so there are no backreferences and no lookaround, and no pattern can take a program down with a text it was handed.
• std/resourceFiles a program needs, named by a string literal where the signature says what kind of file it is (docs/design/RESOURCES.md): a [Resource] ships beside the program and is read while it runs, an [EmbeddedBytes] and an [EmbeddedText] are in the binary.
• std/sandboxLoads .trb files as sandboxed receiver closures - the mechanism behind project.trb and configuration scripts (see "Receiver Scripts and the Sandbox" in CONCEPT.md, and docs/design/SCRIPTS.md).
• std/signatureDigital signatures, in TorbScript with no native: Ed25519 of RFC 8032, and the verification of ECDSA over P-256 with SHA-256 (FIPS 186-5), which JOSE and WebAuthn call ES256.
• std/storageBytes at a reference, wherever the scheme of the reference reaches (docs/design/URI.md section 11).
• std/streamStreams: one flow in one direction, with a reading end and a writing end.
• std/taskConcurrent work: [Task], a computation that finishes later, and [Channel], a queue between two tasks.
• std/testTests are ordinary function calls in the .test.trb files of tests:
• std/textUTF-8 text and the Unicode scalar value it is made of: [Char], one Unicode scalar value, and [String], a sequence of them stored as UTF-8.
• std/timeTime: points in time (Instant), the spans between them (Duration), points on the wall clock (Timestamp), and Clock, which reads both clocks of the machine.
• std/tlsTLS over a TcpStream: [TlsStream.connect] for a client, [TlsStream.accept] with a [ServerIdentity] for a server, and a stream with the same two directions a TcpStream has (docs/design/NETWORK.md section 5).
• std/tomlTOML 1.0 and every later 1.x as a format, written in TorbScript: [Toml] reads and writes any Encode/Decode type, and [TomlValue] is the tree of a document, for one whose shape is not known ahead of time.
• std/uriUniform Resource Identifiers as values: [Uri] and [UriReference] after RFC 3986, read and normalized at construction, so ==, hash() and compare() are over the canonical form; IRIs (RFC 3987) read as the URI they stand for and shown back by iriText(); [Urn] after RFC 8141; [DataUri] after RFC 2397; [UriTemplate] after RFC 6570, typed against the fields it fills, and the routes of [TemplateRoutes] built from it; the file: bridge to Path after RFC 8089; and the application/x-www-form-urlencoded codec of HTML forms.
• std/xmlXML 1.0 (fifth edition) with Namespaces in XML 1.0 as a format, written in TorbScript: [Xml] reads a document into a tree of [XmlNode]s and writes that tree back.
• std/yamlYAML 1.2 and 1.1 as a format, written in TorbScript: [Yaml] reads and writes any Encode/Decode type, and [YamlNode] is the tree of a document as it was written - anchors, aliases, tags, styles and comments included - for a tool that changes one value of a file and writes the rest back as it was.