effect-grammar 0.4.0 → 0.5.0

package/README.md

@@ -1,106 +1,194 @@
 # effect-grammar
 
-```bash
-pnpm add effect-grammar
-```
+Write a grammar once, then use it to parse text, print values, or derive an
+Effect Schema codec. Grammars are bidirectional by design, with explicit
+round-trip checking when you need an invertibility guarantee.
+
+## Install
 
-Invertible grammar combinators and parser-printers for Effect.
+`effect` is a peer dependency:
 
-A `Grammar<A>` supports four operations:
+```sh
+npm install effect effect-grammar
+```
 
-- `parse`: read a string and return a `Result<A, ParseError>`
-- `print`: write an `A` as canonical text and return a
-  `Result<string, PrintError>`
-- `codec`: combine the grammar with an Effect Schema to make a string codec
-- `render`: return a readable description of the grammar
+## Quick start
 
 ```ts
 import { Schema } from "effect"
 import * as G from "effect-grammar"
 
-const frame = G.gen(function* () {
-  const kind = yield* G.choice(
-    G.literal("text").pipe(G.as("text")),
-    G.literal("bits").pipe(G.as("bits")),
-  )
-  yield* G.literal("/")
-  const size = yield* G.integer
+const endpoint = G.gen(function* () {
+  yield* G.literal("https://")
+  const host = yield* G.regex(/[^:/?#]+/, "host")
   yield* G.literal(":")
-  const body = yield* G.match(kind, {
-    text: G.take(size),
-    bits: G.repeat(G.regex(/[01]/, "bit"), size),
-  })
-  return { kind, size, body }
-})
-
-const FrameValue = Schema.Struct({
-  kind: Schema.Literals(["text", "bits"]),
-  size: Schema.Number,
-  body: Schema.Union([Schema.String, Schema.Array(Schema.String)]),
+  const port = yield* G.integer
+  return { host, port }
 })
 
-const Frame = G.codec(frame, FrameValue, { identifier: "Frame" })
-const decode = Schema.decodeSync(Frame)
-const encode = Schema.encodeSync(Frame)
-```
-
-The grammar and its Schema codec use the same parser and printer:
-
-```text
-decode("text/5:hello") → { kind: "text", size: 5, body: "hello" }
-decode("bits/4:1010") → { kind: "bits", size: 4, body: ["1", "0", "1", "0"] }
+const Endpoint = G.codec(
+  endpoint,
+  Schema.Struct({
+    host: Schema.NonEmptyString,
+    port: Schema.Int,
+  }),
+)
 
-encode({ kind: "text", size: 2, body: "hi" }) → "text/2:hi"
-encode({ kind: "bits", size: 4, body: ["1", "0", "1", "0"] }) → "bits/4:1010"
+Schema.decodeSync(Endpoint)("https://effect.website:443")
+// { host: "effect.website", port: 443 }
 
-parse("bits/4:1020") → line 1, column 10: expected bit, found "2"
-print({ kind: "text", size: 2, body: "hello" }) → .body: expected 2 UTF-16 code units, got "hello"
-
-render(frame) → kind:("text" | "bits") "/" size:<integer> ":" body:match(kind){"text" => <char>{size} | "bits" => (<bit>){size}}
+Schema.encodeSync(Endpoint)({ host: "effect.website", port: 443 })
+// "https://effect.website:443"
 ```
 
-## Schema integration
-
-`codec` combines a grammar with an Effect Schema. Decoding parses the text and
-then checks the value. Encoding checks the value and then prints it. The example
-above shows the full integration in one code block.
+## Operations
+
+- `parse(grammar, text)` interprets from cursor zero and succeeds only after
+  consuming the whole string.
+- `print(grammar, value)` runs the grammar's printer. It validates local printer
+  requirements but does not verify that the result parses back to the same
+  value.
+- `printChecked(grammar, value)` prints, reparses the whole output, and compares
+  the result with Effect's equality. It fails when that value round trip does
+  not hold.
+- `prepare(grammar)` runs the library's static validation once, then returns
+  `parse`, `print`, and `printChecked` functions bound to the grammar, plus its
+  rendering and fidelity audit. It is not compilation or optimization; runtime
+  failures remain possible.
+- `codec(grammar, schema)` creates an Effect Schema codec. Encoding uses checked
+  printing by default; `{ roundTrip: "off" }` selects unchecked printing.
+
+`regex(re, name)` stores the source and flags without `g` or `y`. During parsing
+it uses a fresh sticky matcher at the current cursor, so `^`, `$`, lookarounds,
+and flags retain JavaScript `RegExp` semantics relative to the original full
+input. Printing requires the value itself to be a string matched in full. The
+caller's `RegExp` and `lastIndex` are not mutated.
+
+## Composition and correctness
+
+`choice` parses branches in order and prints with the first printer that accepts
+the value. `checkedChoice` uses the first accepting branch whose produced text
+reparses to an equal value. `choiceOn(tag, cases)` instead dispatches printing
+from an existing discriminant field; parsing is still ordered and can remain
+ambiguous. `taggedChoice(tag, cases)` wraps each branch's value as
+`{ [tag]: key, value }` and dispatches by that generated tag.
+`literals(...strings)` is a choice of strings whose value is the string that
+matched. It tries longer strings first, so `literals(">", ">=")` still reads
+`>=`.
+
+For explicit branch order or number/boolean discriminants, use
+`choiceOnEntries(tag, entries)` with an array of `[key, grammar]` entries.
+`choiceOn` and `taggedChoice` reject JavaScript array-index keys because object
+enumeration can reorder them.
+
+`gen` result objects are exact printer patterns: printing rejects missing,
+extra, symbol, or otherwise unexpected own keys. Arrays must have exactly the
+expected length.
+
+`many`, `sepBy`, and exact `repeat` require every successfully parsed item to
+advance the cursor; zero-width items fail rather than loop. `validate`/`prepare`
+report repetitions whose item can be proved to match empty input, but validation
+is intentionally not a proof of all behavior.
+
+`take(count)` reads a fixed number of UTF-16 code units and
+`repeat(item, count)` a fixed number of items; the count is a number or a ref
+bound earlier in the same `gen`. `lengthPrefixed(length)` and
+`countPrefixed(item, count)` parse a prefix and then that many UTF-16 code units
+or items, and derive the prefix from the value when printing, so the value does
+not carry it. `filter(predicate, name)` keeps a grammar's value only when the
+predicate accepts it, in both directions.
+
+`merge(...parts)` sequences grammars that produce objects and flattens their
+fields into one object. Each part must have statically known fields: a `struct`,
+a `gen` that returns an object, another `merge`, `Binary.bits`, or a `filter`
+over any of these. A general transform is rejected, because its fields cannot be
+known. Printing splits the value by those fields, so errors keep flat paths.
+Duplicate fields are rejected on construction.
+
+`suspend(() => grammar)` enables recursive definitions. Its thunk is evaluated
+lazily on first resolution and the resolved grammar is cached. Direct left
+recursion at the same parse position and recursive printing that does not
+consume a value are rejected; recursive grammars must be productive.
+
+Transforms state different fidelity intentions:
+
+- `transform` and `transformOrFail` make no inverse claim.
+- `iso` records the author's inverse claim; the library does not prove it.
+- `partialIso` records a fallible pair intended to agree where both directions
+  succeed.
+- `auditFidelity` lists transforms without a full inverse claim; an empty list
+  is not proof of a round trip.
+
+Use `printChecked` or the helpers from `effect-grammar/testing` to test the
+values and accepted texts relevant to your grammar. These are properties to
+verify, not laws guaranteed for every grammar.
+
+## Binary
+
+`effect-grammar/Binary` applies the same grammars to a `Uint8Array`. Bytes pass
+through the engine as a binary string with one code unit per byte, so every core
+combinator composes with the byte-oriented ones.
 
-See the [endpoint example](./examples/endpoint.ts) for a complete Schema.
-
-## Main building blocks
-
-| Purpose                     | Combinators                                              |
-| --------------------------- | -------------------------------------------------------- |
-| Text                        | `literal`, `regex`, `integer`, `take`, `repeat`          |
-| Sequences and products      | `gen`, `seq`, `struct`, `tuple`                          |
-| Delimiters                  | `prefix`, `suffix`, `between`, `wrap`                    |
-| Repetition and options      | `optional`, `many`, `sepBy`                              |
-| Alternatives                | `choice`, `taggedChoice`, `match`, `matchValue`          |
-| Value conversion            | `transform`, `transformOrFail`, `decodeTo`, `as`, `flag` |
-| Defaults and ignored values | `defaulted`, `skip`                                      |
-| Whitespace                  | `lexeme`, `symbol`, `space`, `spaces`, `trivia`          |
-| Recursion                   | `suspend`                                                |
-
-Most delimiter and repetition combinators support data-first and data-last
-calls, so they also work with `pipe`.
-
-## Results, errors, and rendering
-
-`parse` and `print` return `Result` values. Parse errors report the furthest
-text position, the expected forms, and the line and column. Print errors contain
-a `PrintIssue` tree with paths, missing fields, failed branches, and value
-mismatches. `PrintError.format` converts that tree to text.
-
-`render` describes a complete grammar. `describe` returns a short grammar name.
-
-## More examples
+```ts
+import { Schema } from "effect"
+import * as Grammar from "effect-grammar"
+import * as Binary from "effect-grammar/Binary"
+
+const header = Grammar.merge(
+  Grammar.struct({ id: Binary.uint16 }),
+  Binary.bits({ qr: 1, opcode: 4, aa: 1, tc: 1, rd: 1, ra: 1, z: 3, rcode: 4 }),
+  Grammar.struct({ qdcount: Binary.uint16 }),
+)
+
+const Header = Binary.codec(
+  header,
+  Schema.Struct({
+    id: Binary.Uint16,
+    qr: Binary.Bit,
+    opcode: Binary.Uint(4),
+    aa: Binary.Bit,
+    tc: Binary.Bit,
+    rd: Binary.Bit,
+    ra: Binary.Bit,
+    z: Binary.Uint(3),
+    rcode: Binary.Uint(4),
+    qdcount: Binary.Uint16,
+  }),
+)
+
+Schema.decodeSync(Header)(Uint8Array.of(0xbe, 0xef, 0x01, 0x00, 0x00, 0x01))
+// { id: 48879, qr: 0, opcode: 0, aa: 0, tc: 0, rd: 1, ra: 0, z: 0, rcode: 0, qdcount: 1 }
+```
 
-- [Postgres connection string](./examples/connection-string.ts): optional parts,
-  query parameters, Schema checks, encoding, and round trips
-- [JSON](./examples/json.ts): a recursive grammar and Schema codec
-- [Scheme](./examples/scheme.ts): recursive expressions, tokens, and canonical
-  whitespace
-- [GitHub search](./examples/github-search.ts): a larger search-query DSL
-- [IP address](./examples/ip.ts): transforms and Schema refinements
-- [Printing showcase](./examples/printing.ts): parsing, printing, rendering, and
-  print failures
+- `uint8` to `uint64`, `int8` to `int64`, `float32`, and `float64` are
+  big-endian; the `le` suffix, as in `uint16le`, reads little-endian. 64-bit
+  integers are bigints. `float32` prints only numbers that single precision
+  holds exactly.
+- `varuint` is unsigned LEB128 within the safe integer range, and `varint` its
+  zigzag-encoded signed form for integers from `-(2 ** 52)` to `2 ** 52 - 1`.
+  Parsing accepts padded encodings of any length; printing writes the shortest
+  one.
+- `bits(layout)` splits a whole number of bytes into named fields, first field
+  highest. A one-bit field has type `0 | 1`; wider fields are numbers of up to
+  53 bits. Printing rejects a field that does not fit its width.
+- `bytes(count)` reads a `Uint8Array` of a constant or previously bound length,
+  `lengthPrefixed(length)` derives its prefix, a byte count, when printing, and
+  `literal(...bytes)` matches a fixed sequence such as a magic number.
+- `ascii` and `utf8` turn a `Uint8Array` grammar into a string grammar. Invalid
+  bytes fail to parse and unencodable strings fail to print; `auditFidelity`
+  lists `utf8` as partial.
+- `Bit`, `Uint(bits)` and `Int(bits)` for 1 to 53 bits, `Uint8` to `Uint64`, and
+  `Int8` to `Int64` are schemas for the values these grammars produce, and
+  `hex(bytes)` formats a `Uint8Array` for display.
+- `parse`, `print`, `printChecked`, and `codec` mirror the text operations over
+  `Uint8Array`. Parse failures report a byte offset and the byte found; input
+  that ends inside a fixed-width field fails at the end of the input.
+
+A grammar that prints a character above `0xff` cannot be encoded and fails to
+print.
+
+## Examples
+
+The `examples/` directory includes endpoint and connection-string grammars,
+JSON, HTTP ranges, IP addresses, recursive Scheme syntax, contextual printing,
+Schema error integration, and a binary DNS message codec.

package/dist/binary.d.ts

@@ -0,0 +1,64 @@
+import { Result, Schema } from "effect";
+import { type CodecOptions } from "./codec.ts";
+import { type Grammar, type Ref, type Silent } from "./core.ts";
+import { PrintError } from "./errors.ts";
+export { hex } from "./errors.ts";
+export declare const Bit: Schema.Literals<readonly [0, 1]>;
+export declare const Uint: (size: number) => Schema.Int;
+export declare const Int: (size: number) => Schema.Int;
+export declare const Uint8: Schema.Int;
+export declare const Uint16: Schema.Int;
+export declare const Uint32: Schema.Int;
+export declare const Int8: Schema.Int;
+export declare const Int16: Schema.Int;
+export declare const Int32: Schema.Int;
+export declare const Uint64: Schema.BigInt;
+export declare const Int64: Schema.BigInt;
+declare const ParseError_base: Schema.Class<ParseError, Schema.TaggedStruct<"BinaryParseError", {
+    readonly offset: Schema.Finite;
+    readonly expected: Schema.$Array<Schema.String>;
+    readonly found: Schema.UndefinedOr<Schema.Finite>;
+}>, import("effect/Cause").YieldableError>;
+export declare class ParseError extends ParseError_base {
+    get message(): string;
+}
+export declare const uint8: Grammar<number>;
+export declare const uint16: Grammar<number>;
+export declare const uint32: Grammar<number>;
+export declare const uint64: Grammar<bigint>;
+export declare const uint16le: Grammar<number>;
+export declare const uint32le: Grammar<number>;
+export declare const uint64le: Grammar<bigint>;
+export declare const int8: Grammar<number>;
+export declare const int16: Grammar<number>;
+export declare const int32: Grammar<number>;
+export declare const int64: Grammar<bigint>;
+export declare const int16le: Grammar<number>;
+export declare const int32le: Grammar<number>;
+export declare const int64le: Grammar<bigint>;
+export declare const float32: Grammar<number>;
+export declare const float64: Grammar<number>;
+export declare const float32le: Grammar<number>;
+export declare const float64le: Grammar<number>;
+/**
+ * Unsigned LEB128 within the safe integer range. Parsing accepts padded
+ * encodings of any length; printing writes the shortest one.
+ */
+export declare const varuint: Grammar<number>;
+/** Zigzag-encoded LEB128, as in protobuf `sint64`, for integers from -(2 ** 52) to 2 ** 52 - 1. */
+export declare const varint: Grammar<number>;
+export type BitLayout = Readonly<Record<string, number>>;
+export type Bits<Layout extends BitLayout> = {
+    readonly [K in keyof Layout]: Layout[K] extends 1 ? 0 | 1 : number;
+};
+export declare const bits: <const Layout extends BitLayout>(layout: Layout) => Grammar<Bits<Layout>>;
+export declare const bytes: (count: Ref<number> | number) => Grammar<Uint8Array>;
+export declare const lengthPrefixed: (length: Grammar<number>) => Grammar<Uint8Array>;
+export declare const literal: (...values: ReadonlyArray<number>) => Silent;
+export declare const ascii: (inner: Grammar<Uint8Array<ArrayBufferLike>>) => Grammar<string>;
+export declare const utf8: (inner: Grammar<Uint8Array<ArrayBufferLike>>) => Grammar<string>;
+export declare const parse: <A>(grammar: Grammar<A>, input: Uint8Array) => Result.Result<A, ParseError>;
+export declare const print: <A>(grammar: Grammar<A>, value: A) => Result.Result<Uint8Array, PrintError>;
+export declare const printChecked: typeof print;
+export declare const codec: <S extends Schema.Top, A extends S["Encoded"]>(grammar: Grammar<A>, target: S, options?: CodecOptions) => Schema.decodeTo<S, Schema.Codec<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>, never, never>, never, never>;
+//# sourceMappingURL=binary.d.ts.map

package/dist/binary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../src/binary.ts"],"names":[],"mappings":"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"}

package/dist/binary.js

@@ -0,0 +1,246 @@
+import { Function as F, Predicate, Result, Schema } from "effect";
+import { codecFrom } from "./codec.js";
+import { iso, partialIso, prefixedBy, regex, takeBytes, withKeys } from "./combinators.js";
+import { silent, } from "./core.js";
+import { isCount, nonByte, toBytes } from "./env.js";
+import { describeExpected, hex, PrintError } from "./errors.js";
+import { parse as parseText } from "./parse.js";
+import { printCheckedUnknown, printUnknown } from "./print.js";
+export { hex } from "./errors.js";
+const isWidth = (size) => Number.isInteger(size) && size >= 1 && size <= 53;
+const assertWidth = (name, size) => {
+    if (!isWidth(size)) {
+        throw new RangeError(`${name}: expected a width of 1 to 53 bits, got ${size}`);
+    }
+};
+export const Bit = Schema.Literals([0, 1]);
+export const Uint = (size) => {
+    assertWidth("Uint", size);
+    return Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 2 ** size - 1 }));
+};
+export const Int = (size) => {
+    assertWidth("Int", size);
+    return Schema.Int.check(Schema.isBetween({ minimum: -(2 ** (size - 1)), maximum: 2 ** (size - 1) - 1 }));
+};
+export const Uint8 = Uint(8);
+export const Uint16 = Uint(16);
+export const Uint32 = Uint(32);
+export const Int8 = Int(8);
+export const Int16 = Int(16);
+export const Int32 = Int(32);
+export const Uint64 = Schema.BigInt.check(Schema.isBetweenBigInt({ minimum: 0n, maximum: 2n ** 64n - 1n }));
+export const Int64 = Schema.BigInt.check(Schema.isBetweenBigInt({ minimum: -(2n ** 63n), maximum: 2n ** 63n - 1n }));
+export class ParseError extends Schema.TaggedError()("BinaryParseError", {
+    offset: Schema.Finite,
+    expected: Schema.Array(Schema.String),
+    found: Schema.UndefinedOr(Schema.Finite),
+}) {
+    get message() {
+        const found = this.found === undefined ? "end of input" : `0x${hex(Uint8Array.of(this.found))}`;
+        return `byte ${this.offset}: expected ${describeExpected(this.expected)}, found ${found}`;
+    }
+}
+const toText = (bytes) => {
+    let binary = "";
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return binary;
+};
+const word = (size, name, littleEndian = false) => takeBytes(size, name).pipe(iso({
+    decode: (binary) => {
+        const bytes = littleEndian ? toBytes(binary).reverse() : toBytes(binary);
+        return bytes.reduce((value, byte) => (value << 8n) | BigInt(byte), 0n);
+    },
+    // A negative value is written as its two's complement.
+    encode: (value) => {
+        const bytes = Uint8Array.from({ length: size }, (_, index) => Number(BigInt.asUintN(8, value >> BigInt(8 * (size - 1 - index)))));
+        return toText(littleEndian ? bytes.reverse() : bytes);
+    },
+}));
+const integer = (size, name, schema, decode, littleEndian) => word(size, name, littleEndian).pipe(iso({ name, decode, encode: BigInt, is: Schema.is(schema) }));
+const uint = (size, name, littleEndian = false) => integer(size, name, Uint(8 * size), Number, littleEndian);
+const int = (size, name, littleEndian = false) => integer(size, name, Int(8 * size), (value) => Number(BigInt.asIntN(8 * size, value)), littleEndian);
+const uint64Of = (name, littleEndian = false) => integer(8, name, Uint64, F.identity, littleEndian);
+const int64Of = (name, littleEndian = false) => integer(8, name, Int64, (value) => BigInt.asIntN(64, value), littleEndian);
+// Floats are read and written through one shared view, so a value costs no allocation.
+const scratch = new DataView(new ArrayBuffer(8));
+/**
+ * Every NaN prints as the quiet NaN the engine writes, so a payload or a
+ * signalling NaN in the input does not survive parsing and printing again.
+ */
+const float = (size, name, littleEndian = false) => takeBytes(size, name).pipe(iso({
+    name,
+    // A float32 holds only the numbers that survive rounding to single precision.
+    is: (value) => Predicate.isNumber(value) && (size === 8 || Object.is(Math.fround(value), value)),
+    decode: (binary) => {
+        for (let index = 0; index < size; index++)
+            scratch.setUint8(index, binary.charCodeAt(index));
+        return size === 4
+            ? scratch.getFloat32(0, littleEndian)
+            : scratch.getFloat64(0, littleEndian);
+    },
+    encode: (value) => {
+        if (size === 4)
+            scratch.setFloat32(0, value, littleEndian);
+        else
+            scratch.setFloat64(0, value, littleEndian);
+        let binary = "";
+        for (let index = 0; index < size; index++) {
+            binary += String.fromCharCode(scratch.getUint8(index));
+        }
+        return binary;
+    },
+}));
+export const uint8 = uint(1, "uint8");
+export const uint16 = uint(2, "uint16");
+export const uint32 = uint(4, "uint32");
+export const uint64 = uint64Of("uint64");
+export const uint16le = uint(2, "uint16le", true);
+export const uint32le = uint(4, "uint32le", true);
+export const uint64le = uint64Of("uint64le", true);
+export const int8 = int(1, "int8");
+export const int16 = int(2, "int16");
+export const int32 = int(4, "int32");
+export const int64 = int64Of("int64");
+export const int16le = int(2, "int16le", true);
+export const int32le = int(4, "int32le", true);
+export const int64le = int64Of("int64le", true);
+export const float32 = float(4, "float32");
+export const float64 = float(8, "float64");
+export const float32le = float(4, "float32le", true);
+export const float64le = float(8, "float64le", true);
+// No length cap: a value too wide for a number is left for decoding to reject by range.
+const leb128 = (name) => regex(/[\x80-\xff]*[\0-\x7f]/, name);
+/** The encoded number, or a value outside the safe integer range when it is too large to hold. */
+const fromLeb128 = (binary) => {
+    let value = 0;
+    for (let index = binary.length - 1; index >= 0; index--) {
+        value = value * 128 + (binary.charCodeAt(index) & 0x7f);
+    }
+    return value;
+};
+const toLeb128 = (value) => {
+    let binary = "";
+    let rest = value;
+    while (rest >= 128) {
+        binary += String.fromCharCode((rest % 128) | 0x80);
+        rest = Math.floor(rest / 128);
+    }
+    return binary + String.fromCharCode(rest);
+};
+/**
+ * Unsigned LEB128 within the safe integer range. Parsing accepts padded
+ * encodings of any length; printing writes the shortest one.
+ */
+export const varuint = leb128("varuint").pipe(partialIso({
+    name: "varuint",
+    decode: (binary) => {
+        const value = fromLeb128(binary);
+        return Number.isSafeInteger(value)
+            ? Result.succeed(value)
+            : Result.fail({ message: "a varuint within the safe integer range" });
+    },
+    encode: (value) => isCount(value)
+        ? Result.succeed(toLeb128(value))
+        : Result.fail({ message: "expected a non-negative safe integer" }),
+}));
+/** Zigzag-encoded LEB128, as in protobuf `sint64`, for integers from -(2 ** 52) to 2 ** 52 - 1. */
+export const varint = leb128("varint").pipe(partialIso({
+    name: "varint",
+    decode: (binary) => {
+        const value = fromLeb128(binary);
+        return Number.isSafeInteger(value)
+            ? Result.succeed(value % 2 === 0 ? value / 2 : -(value + 1) / 2)
+            : Result.fail({ message: "a varint from -(2 ** 52) to 2 ** 52 - 1" });
+    },
+    encode: (value) => Number.isSafeInteger(value) && value >= -(2 ** 52) && value < 2 ** 52
+        ? Result.succeed(toLeb128(value < 0 ? -2 * value - 1 : 2 * value))
+        : Result.fail({ message: "expected an integer from -(2 ** 52) to 2 ** 52 - 1" }),
+}));
+export const bits = (layout) => {
+    const fields = Object.entries(layout);
+    const name = fields.map(([key, size]) => `${key}:${size}`).join(" ");
+    const width = fields.reduce((total, [, size]) => total + size, 0);
+    if (width % 8 !== 0 || fields.some(([key, size]) => /^\d+$/.test(key) || !isWidth(size))) {
+        throw new RangeError(`bits: expected non-integer field names, widths of 1 to 53 bits, and a whole number of bytes, got ${name}`);
+    }
+    let shift = BigInt(width);
+    const slots = fields.map(([key, size]) => ({
+        key,
+        size,
+        shift: (shift -= BigInt(size)),
+        fits: Schema.is(Uint(size)),
+    }));
+    const grammar = word(width / 8, name).pipe(iso({
+        name,
+        decode: (value) => 
+        // SAFETY: slots holds every key of the layout, each within its declared width.
+        Object.fromEntries(slots.map(({ key, size, shift }) => [key, Number(BigInt.asUintN(size, value >> shift))])),
+        encode: (value) => {
+            const extra = Reflect.ownKeys(value).find((key) => !Object.hasOwn(layout, key));
+            if (extra !== undefined)
+                throw new RangeError(`unexpected field ${String(extra)}`);
+            return slots.reduce((result, { key, size, shift, fits }) => {
+                const field = value[key];
+                if (!fits(field)) {
+                    throw new RangeError(`${key} must be an integer from 0 to ${2 ** size - 1}`);
+                }
+                return result | (BigInt(field) << shift);
+            }, 0n);
+        },
+    }));
+    return withKeys(grammar, Object.keys(layout));
+};
+const asBytes = iso({
+    name: "bytes",
+    is: Predicate.isUint8Array,
+    decode: toBytes,
+    encode: toText,
+});
+export const bytes = (count) => takeBytes(count).pipe(asBytes);
+export const lengthPrefixed = (length) => prefixedBy(length, takeBytes).pipe(asBytes);
+export const literal = (...values) => {
+    if (values.some((value) => !Schema.is(Uint8)(value))) {
+        throw new RangeError(`literal: expected bytes, got ${values.join(", ")}`);
+    }
+    return silent({
+        _tag: "Literal",
+        value: toText(Uint8Array.from(values)),
+        name: values.map((value) => `0x${hex(Uint8Array.of(value))}`).join(" "),
+    });
+};
+export const ascii = iso({
+    name: "ascii",
+    is: (value) => Predicate.isString(value) && /^[\0-\x7f]*$/.test(value),
+    decode: toText,
+    encode: toBytes,
+});
+export const utf8 = partialIso({
+    name: "utf8",
+    decode: (value) => {
+        try {
+            return Result.succeed(new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(value));
+        }
+        catch {
+            return Result.fail({ message: "valid UTF-8" });
+        }
+    },
+    encode: (value) => value.isWellFormed()
+        ? Result.succeed(new TextEncoder().encode(value))
+        : Result.fail({ message: "expected a string without lone surrogates" }),
+});
+export const parse = (grammar, input) => Result.mapError(parseText(grammar, toText(input)), ({ pos, expected, found }) => new ParseError({ offset: pos, expected, found: found?.charCodeAt(0) }));
+const printBytes = (printer) => (grammar, value) => Result.flatMap(printer(grammar, value), (binary) => nonByte.test(binary)
+    ? Result.fail(new PrintError({
+        issue: { _tag: "InvalidValue", expected: "only bytes to be printed", actual: value },
+    }))
+    : Result.succeed(toBytes(binary)));
+const printUnchecked = printBytes(printUnknown);
+const printVerified = printBytes(printCheckedUnknown);
+export const print = printUnchecked;
+export const printChecked = printVerified;
+export const codec = (grammar, target, options) => {
+    const printer = options?.roundTrip === "off" ? printUnchecked : printVerified;
+    return codecFrom(Schema.Uint8Array, target, grammar, options?.identifier, (input) => parse(grammar, input), (value) => printer(grammar, value));
+};
+//# sourceMappingURL=binary.js.map

package/dist/binary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary.js","sourceRoot":"","sources":["../src/binary.ts"],"names":[],"mappings":"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"}

package/dist/codec.d.ts

@@ -0,0 +1,17 @@
+import { type Result, Schema } from "effect";
+import type { GrammarInternal } from "./core.ts";
+import { PrintError } from "./errors.ts";
+export interface CodecOptions {
+    readonly identifier?: string;
+    /**
+     * - `verify` (default): encoding prints, then parses the output back and
+     *   fails if it decodes to a different value, so a codec never encodes a
+     *   valid value into text that decodes as another. Reparses on every encode.
+     * - `off`: encoding prints without the check.
+     */
+    readonly roundTrip?: "verify" | "off";
+}
+export declare const codecFrom: <I, S extends Schema.Top>(source: Schema.Codec<I>, target: S, grammar: GrammarInternal, identifier: string | undefined, parse: (input: I) => Result.Result<S["Encoded"], {
+    readonly message: string;
+}>, print: (value: S["Encoded"]) => Result.Result<I, PrintError>) => Schema.decodeTo<S, Schema.Codec<I, I, never, never>, never, never>;
+//# sourceMappingURL=codec.d.ts.map