functionalscript 0.46.0 → 0.47.0

package/fjs/types/rtti/parse/proof.f.mjs

@@ -2,12 +2,14 @@
  * @import { ValidationError } from '../common/types.ts'
  * @import { Equal } from '../../ts/types.ts'
  * @import { Ts } from '../ts/types.ts'
+ * @import { Parse } from './types.ts'
  * @import { Unknown as DjsUnknown } from '../../../djs/types.ts'
  * @import { Assert } from '../../../asserts/types.ts'
+ * @import { Phantom } from '../../phantom/types.ts'
  */
 
 import { parse } from './module.f.mjs'
-import { boolean, number, string, bigint, unknown, array, record, or, option } from '../module.f.mjs'
+import { boolean, number, string, bigint, unknown, array, open, record, rest, or, option } from '../module.f.mjs'
 import {
     assert,
     assertEq,
@@ -30,6 +32,23 @@ const unwrap = r => {
     return /** @type {T} */ (r[1])
 }
 
+/** A container that contains itself: `[number, node?]`. */
+/** @typedef {readonly [number, _Node | undefined]} _Node */
+
+const _node = () => /** @type {const} */ (['const', [number, option(_node)]])
+
+/** @type {Phantom<typeof _node, _Node>} */
+const node = _node
+
+/** A struct whose every undeclared key holds another one of these. */
+/** @typedef {() => readonly ['rest', { readonly a: typeof number }, _Nest]} _Nest */
+
+/** @type {_Nest} */
+const _nest = () => ['rest', { a: number }, _nest]
+
+/** @type {Phantom<_Nest, { readonly a: number }>} */
+const nest = _nest
+
 /** @type {(expected: readonly string[]) => (r: readonly [string, unknown]) => void} */
 const assertErrorPath = expected =>
     r => {
@@ -105,15 +124,15 @@ export const proof = {
             error: () => assertError(parse(undefined)(null)),
         },
         number: {
-            ok: () => assertOk(parse(/** @type {const} */ (42))(42)),
-            error: () => assertError(parse(/** @type {const} */ (42))(43)),
+            ok: () => assertOk(parse(42)(42)),
+            error: () => assertError(parse(42)(43)),
         },
         nan: {
             ok: () => assertOk(parse(NaN)(NaN)),
             error: () => {
                 assertError(parse(NaN)(0))
-                assertError(parse(/** @type {const} */ (0))(NaN))
-                assertError(parse(/** @type {const} */ (42))(NaN))
+                assertError(parse(0)(NaN))
+                assertError(parse(42)(NaN))
             },
         },
         infinity: {
@@ -129,44 +148,39 @@ export const proof = {
         signedZero: {
             // `Object.is` distinguishes +0 and -0; `===` treats them equal.
             distinct: () => {
-                assertError(parse(/** @type {const} */ (0))(-0))
+                assertError(parse(0)(-0))
                 assertError(parse(-0)(0))
             },
             self: () => {
-                assertOk(parse(/** @type {const} */ (0))(0))
+                assertOk(parse(0)(0))
                 assertOk(parse(-0)(-0))
             },
         },
         string: {
-            ok: () => assertOk(parse(/** @type {const} */ ('hello'))('hello')),
-            error: () => assertError(parse(/** @type {const} */ ('hello'))('world')),
+            ok: () => assertOk(parse('hello')('hello')),
+            error: () => assertError(parse('hello')('world')),
         },
         bigint: {
-            ok: () => assertOk(parse(/** @type {const} */ (7n))(7n)),
-            error: () => assertError(parse(/** @type {const} */ (7n))(8n)),
+            ok: () => assertOk(parse(7n)(7n)),
+            error: () => assertError(parse(7n)(8n)),
         },
         boolean: {
-            ok: () => assertOk(parse(/** @type {const} */ (true))(true)),
-            error: () => assertError(parse(/** @type {const} */ (true))(false)),
+            ok: () => assertOk(parse(true)(true)),
+            error: () => assertError(parse(true)(false)),
         },
         tuple: {
             ok: () => {
-                const t = /** @type {const} */ ([42, 'hello'])
-                const r = parse(t)([42, 'hello'])
+                const r = parse([42, 'hello'])([42, 'hello'])
                 assertStructurallySame(unwrap(r), [42, 'hello'])
             },
-            // A tuple is OPEN: a longer array is accepted, and the extras are
-            // absent from what `parse` builds. This is deliberate — see
-            // "Structs and tuples are open" in ../README.md. Do not add a
-            // length check here on the strength of `Ts<readonly [42]>` being
-            // an exact tuple; that mapping is exact only because TypeScript
-            // could not express the open one (see ../ts/types.ts `TupleTs`),
-            // and reading it as a design decision is what produced #1622.
-            extraItemsAcceptedAndDropped: () => {
-                const r = parse(/** @type {const} */ ([42]))([42, 'extra'])
-                assertStructurallySame(unwrap(r), [42])
-                const long = parse(/** @type {const} */ ([42]))([42, 1, 2, 3])
-                assertStructurallySame(unwrap(long), [42])
+            // A tuple is CLOSED: a longer array is not one of its values —
+            // see "Structs and tuples are closed" in ../README.md. Under
+            // `open` it is accepted, and the extras are absent from what
+            // `parse` builds.
+            extraItemsRejected: () => {
+                assertError(parse([42])([42, 'extra']))
+                assertStructurallySame(unwrap(parse(open([42]))([42, 'extra'])), [42])
+                assertStructurallySame(unwrap(parse(open([42]))([42, 1, 2, 3])), [42])
             },
             // An absent member reads as `undefined`, so a position is required
             // exactly when its set excludes `undefined` — the same rule the
@@ -176,28 +190,32 @@ export const proof = {
                 assertStructurallySame(unwrap(r), [42, undefined])
             },
             error: () => {
-                assertError(parse(/** @type {const} */ ([42]))([99]))
-                assertError(parse(/** @type {const} */ ([42]))({}))
+                assertError(parse([42])([99]))
+                assertError(parse([42])({}))
                 // `42` excludes `undefined`, so position 0 is required.
-                assertError(parse(/** @type {const} */ ([42]))([]))
+                assertError(parse([42])([]))
             },
         },
         struct: {
+            // `parse` takes a `const` type parameter, so a struct literal keeps
+            // its literal members without an `@type {const}` cast at the call
+            // site: this is a reader for `{ a: 42, b: 'hello' }`, not for
+            // `{ a: number, b: string }`. Dropping the modifier is what makes
+            // the assertion fail.
             ok: () => {
-                const t = /** @type {const} */ ({ a: 42, b: 'hello' })
-                const r = parse(t)({ a: 42, b: 'hello' })
-                assertStructurallySame(unwrap(r), { a: 42, b: 'hello' })
+                const p = parse({ a: 42, b: 'hello' })
+                /** @typedef {Assert<Equal<typeof p, Parse<{ readonly a: 42, readonly b: 'hello' }>>>} _ConstParameter */
+                assertStructurallySame(unwrap(p({ a: 42, b: 'hello' })), { a: 42, b: 'hello' })
             },
-            // A struct is OPEN, on the same terms as a tuple: undeclared
-            // properties are accepted and absent from what `parse` builds.
-            // See "Structs and tuples are open" in ../README.md.
-            extraKeysAcceptedAndDropped: () => {
-                const r = parse(/** @type {const} */ ({ a: /** @type {const} */ (42) }))({ a: 42, b: 'extra' })
-                assertStructurallySame(unwrap(r), { a: 42 })
+            // A struct is CLOSED, on the same terms as a tuple. See "Structs
+            // and tuples are closed" in ../README.md.
+            extraKeysRejected: () => {
+                assertError(parse({ a: 42 })({ a: 42, b: 'extra' }))
+                assertStructurallySame(unwrap(parse(open({ a: 42 }))({ a: 42, b: 'extra' })), { a: 42 })
             },
             error: () => {
-                assertError(parse(/** @type {const} */ ({ a: 42 }))({ a: 99 }))
-                assertError(parse(/** @type {const} */ ({ a: 42 }))([]))
+                assertError(parse({ a: 42 })({ a: 99 }))
+                assertError(parse({ a: 42 })([]))
             },
         },
     },
@@ -262,13 +280,13 @@ export const proof = {
     or: {
         consts: {
             ok: () => {
-                const t = or(.../** @type {const} */ ([false, 42, 'hello']))
+                const t = or(false, 42, 'hello')
                 assertOk(parse(t)(false))
                 assertOk(parse(t)(42))
                 assertOk(parse(t)('hello'))
             },
             error: () => {
-                const t = or(.../** @type {const} */ ([false, 42, 'hello']))
+                const t = or(false, 42, 'hello')
                 assertError(parse(t)(true))
                 assertError(parse(t)(43))
                 assertError(parse(t)('world'))
@@ -289,10 +307,11 @@ export const proof = {
         },
         // First matching variant wins; the freshly-constructed value comes from that variant.
         firstMatchWins: () => {
-            const t = or(/** @type {const} */ ([number]), array(number))
+            const t = or(open([number]), array(number))
             /** @type {readonly number[]} */
             const out = unwrap(parse(t)([1, 2, 3]))
-            // The const tuple `[number]` matches first and returns a length-1 result.
+            // The open tuple `open([number])` matches first and returns a
+            // length-1 result; the closed `[number]` would not match at all.
             assertStructurallySame(out, [1])
         },
     },
@@ -319,10 +338,10 @@ export const proof = {
             parse(array(array(number)))([[1, 'x'], [2, 3]])
         ),
         tupleIndex: () => assertErrorPath(['1'])(
-            parse(/** @type {const} */ ([number, number]))([1, 'two'])
+            parse([number, number])([1, 'two'])
         ),
         structKey: () => assertErrorPath(['b'])(
-            parse(/** @type {const} */ ({ a: number, b: number }))({ a: 1, b: 'two' })
+            parse({ a: number, b: number })({ a: 1, b: 'two' })
         ),
         deepStruct: () => {
             const schema = /** @type {const} */ ({ user: { name: string, age: number } })
@@ -359,4 +378,109 @@ export const proof = {
             assertError(v({ a: 42 }))
         },
     },
+    // A bare container is closed, and a stated rest widens acceptance without
+    // changing construction at all: the result carries the declared members
+    // either way. `../validate/proof.f.mjs` runs the acceptance half of this
+    // through all three readers.
+    closed: {
+        tuple: {
+            exact: () => {
+                const p = parse([number, string])
+                /** @typedef {Assert<Equal<typeof p, Parse<readonly [typeof number, typeof string]>>>} _ConstParameter */
+                assertStructurallySame(unwrap(p([1, 'a'])), [1, 'a'])
+            },
+            // The whole point of the default: `open` is what accepts this.
+            extraRejected: () => {
+                assertError(parse([number])([1, 2]))
+                assertStructurallySame(unwrap(parse(open([number]))([1, 2])), [1])
+            },
+            // A hole past the prefix is no member, so length is what catches it.
+            holePastThePrefixRejected: () => assertError(parse([number])([1, ,])),
+            // Nor is a key that is no position at all.
+            nonIndexKeyRejected: () =>
+                assertError(parse([number])(Object.assign([1], { foo: 2 }))),
+            // The rule for a missing member is unchanged: an absent position
+            // reads as `undefined`.
+            shortArray: () => {
+                assertError(parse([number])([]))
+                assertStructurallySame(unwrap(parse([number, option(string)])([1])), [1, undefined])
+            },
+            empty: () => {
+                assertStructurallySame(unwrap(parse([])([])), [])
+                assertError(parse([])([1]))
+            },
+            notAnArray: () => assertError(parse([number])({})),
+        },
+        struct: {
+            exact: () => assertStructurallySame(unwrap(parse({ a: number })({ a: 1 })), { a: 1 }),
+            extraRejected: () => {
+                assertError(parse({ a: number })({ a: 1, b: 2 }))
+                assertOk(parse(open({ a: number }))({ a: 1, b: 2 }))
+            },
+            // A key declared as `unknown` is a member the schema *has*, so a
+            // closed struct still admits it — the canonical form may not drop
+            // it the way an `open` struct's is dropped.
+            unknownMemberIsStillDeclared: () => {
+                assertOk(parse({ a: unknown })({ a: 1 }))
+                assertError(parse({ a: unknown })({ a: 1, b: 2 }))
+            },
+            empty: () => {
+                assertStructurallySame(unwrap(parse({})({})), {})
+                assertError(parse({})({ a: 1 }))
+            },
+            notAnObject: () => assertError(parse({ a: number })([])),
+        },
+        // With a `rest`, an undeclared member is legal when it belongs to it —
+        // and still not carried into what `parse` builds. `rest` says what an
+        // undeclared member must be, not that the reader should keep it.
+        rest: {
+            checkedAndDropped: () => {
+                assertStructurallySame(unwrap(parse(rest({ a: number }, string))({ a: 1, b: 'x' })), { a: 1 })
+                assertStructurallySame(unwrap(parse(rest([number], string))([1, 'x', 'y'])), [1])
+            },
+            rejected: () => {
+                assertErrorPath(['b'])(parse(rest({ a: number }, string))({ a: 1, b: 2 }))
+                assertErrorPath(['1'])(parse(rest([number], string))([1, 2]))
+            },
+            // An unconstrained rest is `open`.
+            unknownRestIsOpen: () => assertOk(parse(rest([number], unknown))([1, 'x'])),
+            // An empty one is the bare form: the length bound comes back.
+            emptyRestBoundsTheLength: () => {
+                assertError(parse(rest([number], or()))([1, ,]))
+                assertStructurallySame(unwrap(parse(rest([number], or()))([1])), [1])
+            },
+        },
+        // The declared members are read the same way whatever the rest is,
+        // error paths included.
+        path: () => {
+            assertErrorPath(['1'])(parse([number, number])([1, 'two']))
+            assertErrorPath(['a', '0'])(parse({ a: [number] })({ a: ['x'] }))
+        },
+        // A cycle through a container terminates. The schema is
+        // `Phantom`-wrapped for the usual reason (`Ts<>`'s structural walk
+        // would not terminate over a recursive container — see
+        // `../ts/types.ts`); it is the *value* half under test here.
+        recursive: () => {
+            const p = parse(node)
+            assertStructurallySame(unwrap(p([1])), [1, undefined])
+            assertStructurallySame(unwrap(p([1, [2]])), [1, [2, undefined]])
+            assertError(p([1, [2], 3]))
+        },
+        // A cycle through the `rest` itself: every key other than `a` holds
+        // another one of these.
+        recursiveRest: () => {
+            const p = parse(nest)
+            assertStructurallySame(unwrap(p({ a: 1, b: { a: 2 } })), { a: 1 })
+            assertError(p({ a: 1, b: { a: 'x' } }))
+            assertError(p({ a: 1, b: 2 }))
+        },
+    },
+    arrayOptional: () => {
+        const a = /** @type {const} */([number, option(string)])
+        const v = parse(a)
+        assertOk(v([5]))
+        assertError(v(["n"]))
+        assertOk(v([6, "3"]))
+        assertError(v([6, 9]))
+    }
 }

package/fjs/types/rtti/proof.f.d.mts

@@ -1,10 +1,16 @@
 /**
  * @import { StringMap } from '../object/types.ts'
+ * @import { Assert } from '../../asserts/types.ts'
+ * @import { Equal } from '../ts/types.ts'
+ * @import { Or, Rest, Type1, Unknown } from './types.ts'
  */
 import type { StringMap } from '../object/types.ts';
 export type _Tests = StringMap<readonly unknown[]>;
+declare const constInference: () => void;
 export declare const proof: {
+    constInference: typeof constInference;
     typeof: {
         [k: string]: (() => void)[];
     };
 };
+export {};

package/fjs/types/rtti/proof.f.mjs

@@ -1,8 +1,12 @@
 /**
  * @import { StringMap } from '../object/types.ts'
+ * @import { Assert } from '../../asserts/types.ts'
+ * @import { Equal } from '../ts/types.ts'
+ * @import { Or, Rest, Type1, Unknown } from './types.ts'
  */
 
-import { assertNotNullish } from '../../asserts/module.f.mjs'
+import { assertNotNullish, assertStructurallySame } from '../../asserts/module.f.mjs'
+import { array, number, open, option, or, record, rest, string, unknown } from './module.f.mjs'
 
 /** @typedef {StringMap<readonly unknown[]>} _Tests */
 
@@ -17,7 +21,44 @@ const tests = {
     function: [() => undefined]
 }
 
+// `or`, `option`, `array`, `record`, `rest` and `open` take `const` type
+// parameters, so a literal written at the call site stays a literal: `or(42, string)`
+// describes `42 | string`, not `number | string`. Without the modifier a caller
+// has to pin every literal with an `@type {const}` cast, and the assertions
+// below are what fail if one of the modifiers is dropped. Each is paired with
+// the thunk's own output, so the schema a call *builds* is checked next to the
+// type it is given.
+const constInference = () => {
+    const orConst = or(42, string)
+    /** @typedef {Assert<Equal<typeof orConst, Or<readonly [42, typeof string]>>>} _OrConst */
+    assertStructurallySame(orConst(), ['or', 42, string])
+
+    const optionConst = option([42, string])
+    /** @typedef {Assert<Equal<typeof optionConst, Or<readonly [readonly [42, typeof string], undefined]>>>} _OptionConst */
+    assertStructurallySame(optionConst(), ['or', [42, string], undefined])
+
+    const arrayConst = array('hello')
+    /** @typedef {Assert<Equal<typeof arrayConst, Type1<'array', 'hello'>>>} _ArrayConst */
+    assertStructurallySame(arrayConst(), ['array', 'hello'])
+
+    const recordConst = record({ a: number })
+    /** @typedef {Assert<Equal<typeof recordConst, Type1<'record', { readonly a: typeof number }>>>} _RecordConst */
+    assertStructurallySame(recordConst(), ['record', { a: number }])
+
+    const restConst = rest({ a: 42 }, string)
+    /** @typedef {Assert<Equal<typeof restConst, Rest<{ readonly a: 42 }, typeof string>>>} _RestConst */
+    assertStructurallySame(restConst(), ['rest', { a: 42 }, string])
+
+    // `open` needs the modifier of its own — it is not `rest` partially
+    // applied, so dropping it there widens `[42, string]` to `Type[]` while
+    // every assertion above still passes.
+    const openConst = open([42, string])
+    /** @typedef {Assert<Equal<typeof openConst, Rest<readonly [42, typeof string], Unknown>>>} _OpenConst */
+    assertStructurallySame(openConst(), ['rest', [42, string], unknown])
+}
+
 export const proof = {
+    constInference,
     typeof: Object.fromEntries(Object.entries(tests).map(([k, a]) => [k, assertNotNullish(a).map(v => () => {
         if (typeof v !== k) { throw `typeof ${v} !== ${k}` }
     })])),

package/fjs/types/rtti/ts/module.f.d.mts

@@ -64,9 +64,14 @@ export declare const dataToTs: (mut?: true) => (data: Data) => readonly [readonl
  * definitions the expression references; a schema with no reference cycles
  * needs none.
  *
- * **Note:** the `unknown` schema produces the string `'unknown'`
- * (TypeScript's built-in), whereas `Ts<>` maps it to `DjsUnknown` from
- * `djs/module.f.ts`.
+ * **Two notes where this and `Ts<>` differ.** The `unknown` schema produces
+ * the string `'unknown'` (TypeScript's built-in), whereas `Ts<>` maps it to
+ * `DjsUnknown` from `djs/module.f.ts`. And this printer recognizes an empty
+ * rest **semantically** — the data form has already normalized one away — so
+ * `rest([42], [or()])` prints the exact `readonly[42]`, where `Ts<>` keeps a
+ * tail it cannot see through (`RestTs` in `./types.ts` says why, and in which
+ * direction). Both print the same thing for every rest a schema states
+ * directly.
  *
  * @example
  * ```js
@@ -78,6 +83,7 @@ export declare const dataToTs: (mut?: true) => (data: Data) => readonly [readonl
  * toTs(42)                         // '42'
  * toTs('hello')                    // '"hello"'
  * toTs([boolean, number])          // 'readonly[boolean,number]'
+ * toTs(open([boolean, number]))    // 'readonly[boolean,number,...readonly(unknown)[]]'
  * toTs({ x: string })              // '{readonly"x":string}'
  *
  * const list = () => ['array', list]

package/fjs/types/rtti/ts/module.f.mjs

@@ -22,7 +22,7 @@ import { assertNotNullish } from '../../../asserts/module.f.mjs'
 import { reservedWords, strictModeReservedWords } from '../../../js/keywords/module.f.mjs'
 import { at, definedEntries } from '../../object/module.f.mjs'
 import { primitive, union, printer as tsPrinter } from '../../ts/module.f.mjs'
-import { cmp, toData, unitBit, unknown as top } from '../data/module.f.mjs'
+import { cmp, never as bottom, toData, unitBit, unknown as top } from '../data/module.f.mjs'
 
 const nullBit = unitBit(null)
 const undefinedBit = unitBit(undefined)
@@ -145,28 +145,69 @@ const unitToTs = bits => [
 /**
  * A tuple prints its prefix, an array its element type, and a
  * tuple-with-rest combines them with a rest element:
- * `readonly[A,...readonly(R)[]]`.
+ * `readonly[A,...readonly(R|undefined)[]]`.
+ *
+ * A position the array may simply end before prints optional — the trailing
+ * run whose sets admit `undefined`, which is exactly what the array may stop
+ * at, arrays being contiguous. It mirrors the optional key `objectSetToTs`
+ * prints, and keeps the union rather than stripping `undefined` from it, as
+ * that one does.
+ *
+ * The **tail** admits `undefined` on top of what the `rest` states, because a
+ * hole past the prefix is no member: the readers check each present member
+ * against the `rest` and skip an absent one, so `rest([42], string)` accepts
+ * `[42, , ]` and index 1 reads `undefined`. `Ts<>` renders the same tail for
+ * the same reason (see `RestTs` in `./types.ts`). The open case pays nothing —
+ * `unknown` already admits `undefined` — and an empty rest never reaches here,
+ * the data form having normalized it away into the exact-length pattern.
+ *
+ * A pattern with **no prefix** is the uniform array, which `Ts<>` renders as
+ * `ArrayTs` — `readonly Ts<R>[]` — and this mirrors. A hole is no member there
+ * either, so that rendering has the same gap one element wider; it is
+ * `ArrayTs`'s to close, not this printer's, and closing it here alone would
+ * put the two renderers at odds on the commonest schema there is.
  *
  * @type {(ctx: _Ctx) => (p: ArraySet) => string}
  */
 const arraySetToTs = ctx => p => {
-    const items = p.prefix.map(nodeToTs(ctx))
+    const required = p.prefix.findLastIndex(n => !admitsUndefined(ctx)(n)) + 1
+    const items = p.prefix.map((n, i) => {
+        const ts = nodeToTs(ctx)(n)
+        return i < required ? ts : `(${ts})?`
+    })
     const { rest } = p
     if (rest === undefined) { return ctx.ts.tuple(items) }
-    const restTs = ctx.ts.array(nodeToTs(ctx)(rest))
-    return items.length === 0 ? restTs : ctx.ts.tuple([...items, `...${restTs}`])
+    const restTs = nodeToTs(ctx)(rest)
+    if (items.length === 0) { return ctx.ts.array(restTs) }
+    const tail = ctx.ts.array(admitsUndefined(ctx)(rest)
+        ? restTs
+        : union(dedup([primitive(undefined), restTs])))
+    return ctx.ts.tuple([...items, `...${tail}`])
 }
 
 /**
- * Whether the node's value set admits `undefined` — its unit bit, read
- * through a reference (own-property only) if needed.
+ * The node's own union, read through a reference (own-property only) if
+ * needed.
+ *
+ * @type {(ctx: _Ctx) => (n: Node) => UnionSet}
+ */
+const resolveNode = ctx => n =>
+    typeof n === 'string' ? assertNotNullish(at(n)(ctx.rules)) : n
+
+/**
+ * Whether the node's value set admits `undefined` — its unit bit.
  *
  * @type {(ctx: _Ctx) => (n: Node) => boolean}
  */
-const admitsUndefined = ctx => n => {
-    const u = typeof n === 'string' ? assertNotNullish(at(n)(ctx.rules)) : n
-    return ((u.unit ?? 0) & undefinedBit) !== 0
-}
+const admitsUndefined = ctx => n =>
+    ((resolveNode(ctx)(n).unit ?? 0) & undefinedBit) !== 0
+
+/**
+ * Whether the node's value set is empty.
+ *
+ * @type {(ctx: _Ctx) => (n: Node) => boolean}
+ */
+const isNever = ctx => n => cmp([{}, resolveNode(ctx)(n)])([{}, bottom]) === 0
 
 /** @type {(list: readonly string[]) => readonly string[]} */
 const dedup = list => list.filter((s, i) => list.indexOf(s) === i)
@@ -179,6 +220,12 @@ const dedup = list => list.filter((s, i) => list.indexOf(s) === i)
  * declared keys too, so the index type widens to the union of the rest and
  * the declared value types — the closest expressible supertype.
  *
+ * An **empty** rest — what a bare, closed struct carries — prints as the
+ * fields alone. TypeScript object types are structurally open, so "and no
+ * other key" has no spelling there and the index signature would say the
+ * opposite of what is meant; the fields are the closest expressible
+ * supertype, exactly as `Ts<>` renders them.
+ *
  * @type {(ctx: _Ctx) => (p: ObjectSet) => string}
  */
 const objectSetToTs = ctx => p => {
@@ -188,7 +235,7 @@ const objectSetToTs = ctx => p => {
         return admitsUndefined(ctx)(v) ? [k, ts, true] : [k, ts]
     })
     const { rest } = p
-    if (rest === undefined) { return ctx.ts.struct(fields) }
+    if (rest === undefined || isNever(ctx)(rest)) { return ctx.ts.struct(fields) }
     const restTs = ctx.ts.record(union(dedup([...fields.map(([, v]) => v), nodeToTs(ctx)(rest)])))
     return fields.length === 0 ? restTs : `${ctx.ts.struct(fields)}&${restTs}`
 }
@@ -257,9 +304,14 @@ export const dataToTs = mut => ([rules, entry]) => {
  * definitions the expression references; a schema with no reference cycles
  * needs none.
  *
- * **Note:** the `unknown` schema produces the string `'unknown'`
- * (TypeScript's built-in), whereas `Ts<>` maps it to `DjsUnknown` from
- * `djs/module.f.ts`.
+ * **Two notes where this and `Ts<>` differ.** The `unknown` schema produces
+ * the string `'unknown'` (TypeScript's built-in), whereas `Ts<>` maps it to
+ * `DjsUnknown` from `djs/module.f.ts`. And this printer recognizes an empty
+ * rest **semantically** — the data form has already normalized one away — so
+ * `rest([42], [or()])` prints the exact `readonly[42]`, where `Ts<>` keeps a
+ * tail it cannot see through (`RestTs` in `./types.ts` says why, and in which
+ * direction). Both print the same thing for every rest a schema states
+ * directly.
  *
  * @example
  * ```js
@@ -271,6 +323,7 @@ export const dataToTs = mut => ([rules, entry]) => {
  * toTs(42)                         // '42'
  * toTs('hello')                    // '"hello"'
  * toTs([boolean, number])          // 'readonly[boolean,number]'
+ * toTs(open([boolean, number]))    // 'readonly[boolean,number,...readonly(unknown)[]]'
  * toTs({ x: string })              // '{readonly"x":string}'
  *
  * const list = () => ['array', list]

package/fjs/types/rtti/ts/proof.f.d.mts

@@ -1,8 +1,30 @@
 /**
- * @import { Type } from '../types.ts'
+ * @import { Or, Type } from '../types.ts'
  * @import { Data } from '../data/types.ts'
+ * @import { Ts, TupleTs } from './types.ts'
+ * @import { Assert } from '../../../asserts/types.ts'
+ * @import { Equal } from '../../ts/types.ts'
  */
-import { number, string } from '../module.f.mjs';
+import type { Or } from '../types.ts';
+import type { Ts, TupleTs } from './types.ts';
+import type { Assert } from '../../../asserts/types.ts';
+import type { Equal } from '../../ts/types.ts';
+import { boolean, number, string, bigint } from '../module.f.mjs';
+export type _NonFixedLength = Assert<Equal<Ts<readonly (typeof number | typeof bigint)[]>, readonly (number | bigint)[]>>;
+export type _OptionBoolean = Or<readonly [typeof boolean, undefined]>;
+export type _OptionString = Or<readonly [typeof string, undefined]>;
+export type _VariadicSchema = readonly [...(typeof number)[], _OptionString];
+export type _VariadicPrefixRejectsMixedPrefix = Assert<readonly [1, 'x', 2] extends Ts<_VariadicSchema> ? false : true>;
+export type _VariadicPrefixAdmitsItsOwnShape = Assert<readonly [1, 2, 'x'] extends Ts<_VariadicSchema> ? true : false>;
+export type _RestTuple = Assert<Equal<Ts<readonly [typeof number, ...(typeof string)[]]>, readonly [number, ...string[]]>>;
+export type _OptionalMember = Assert<Equal<Ts<readonly [typeof number, (typeof string)?]>, readonly [number, string?]>>;
+export type _BranchA = readonly [typeof number, _OptionString];
+export type _BranchB = readonly [typeof string, _OptionBoolean, _OptionNumber];
+export type _OptionNumber = Or<readonly [typeof number, undefined]>;
+export type _UnionKeepsBranchCorrelation = Assert<readonly [1, true] extends TupleTs<_BranchA | _BranchB> ? false : true>;
+export type _UnionAdmitsItsOwnBranches = Assert<readonly [1, 'x'] extends TupleTs<_BranchA | _BranchB> ? true : false>;
+export type _OptionalTail = Assert<Equal<Ts<readonly [typeof number, typeof bigint, _OptionBoolean, _OptionString]>, readonly [number, bigint, (boolean | undefined)?, (string | undefined)?]>>;
+export type _InteriorStaysRequired = Assert<Equal<Ts<readonly [_OptionString, typeof number]>, readonly [string | undefined, number]>>;
 export type _List = () => readonly ['array', _List];
 export type _Tree = () => readonly ['or', typeof number, _Forest];
 export type _Forest = () => readonly ['array', _Tree];
@@ -42,7 +64,10 @@ export declare const proof: {
         bigint: () => void;
         emptyTuple: () => void;
         tuple: () => void;
+        optionalTuplePosition: () => void;
+        allOptionalTuple: () => void;
         emptyStruct: () => void;
+        unknownProp: () => void;
         struct: () => void;
         nestedStruct: () => void;
         quotedKey: () => void;
@@ -59,7 +84,21 @@ export declare const proof: {
         thunks: () => void;
         mixed: () => void;
     };
+    open: {
+        emptyTuple: () => void;
+        unconstrainedTuple: () => void;
+        tuple: () => void;
+        emptyStruct: () => void;
+        struct: () => void;
+        unknownProp: () => void;
+        tupleRest: () => void;
+        structRest: () => void;
+        openIsAnUnconstrainedRest: () => void;
+        emptyRestIsTheBareForm: () => void;
+        mut: () => void;
+    };
     never: () => void;
+    arrayOfNever: () => void;
     option: () => void;
     normalization: {
         booleanFromConsts: () => void;
@@ -86,6 +125,7 @@ export declare const proof: {
     };
     data: {
         tupleWithRest: () => void;
+        exactLengthTuple: () => void;
         structWithRest: () => void;
         optionalByReference: () => void;
         wholeKinds: () => void;