functionalscript 0.46.0 → 0.47.0

package/fjs/js/string_escape/proof.f.mjs

@@ -0,0 +1,68 @@
+import { assertEq, assertStructurallySame } from '../../asserts/module.f.mjs'
+import {
+    backspace,
+    cr,
+    ff,
+    ht,
+    latinSmallLetterB,
+    latinSmallLetterF,
+    latinSmallLetterN,
+    latinSmallLetterR,
+    latinSmallLetterT,
+    latinSmallLetterU,
+    lf,
+    quotationMark,
+    reverseSolidus,
+    solidus,
+} from '../../text/ascii/module.f.mjs'
+import {
+    codePointToEscape,
+    escapeToCodePoint,
+    optionalEscape,
+    simpleEscapes,
+} from './module.f.mjs'
+
+/**
+ * The escapes spelled out independently of the table, so the proof compares
+ * two statements of the set rather than the table against itself.
+ *
+ * @type {readonly (readonly [number, number])[]}
+ */
+const expected = [
+    [quotationMark, quotationMark],
+    [reverseSolidus, reverseSolidus],
+    [solidus, solidus],
+    [latinSmallLetterB, backspace],
+    [latinSmallLetterF, ff],
+    [latinSmallLetterN, lf],
+    [latinSmallLetterR, cr],
+    [latinSmallLetterT, ht],
+]
+
+export const proof = {
+    simpleEscapes: () => assertStructurallySame(simpleEscapes, expected),
+    // Every letter decodes to its code point, and — apart from the optional
+    // one — every code point encodes back to its letter. Round-tripping both
+    // ways is what the two derived views are for.
+    roundTrip: () => expected.forEach(([letter, codePoint]) => {
+        assertEq(escapeToCodePoint(letter), codePoint, letter)
+        assertEq(codePointToEscape(codePoint), codePoint === optionalEscape ? null : letter, codePoint)
+    }),
+    // `\/` is accepted and never produced: the one asymmetry between the views.
+    optionalEscape: [
+        () => assertEq(escapeToCodePoint(optionalEscape), solidus),
+        () => assertEq(codePointToEscape(optionalEscape), null),
+    ],
+    // `u` is a letter the grammar accepts after a backslash, but its meaning
+    // comes from the digits that follow, so it is deliberately absent here.
+    unicodeEscapeIsNotSimple: () => assertEq(escapeToCodePoint(latinSmallLetterU), null),
+    // A code point with no simple escape, from either side.
+    noEscape: [
+        () => assertEq(escapeToCodePoint(0x61), null), // `a`
+        () => assertEq(codePointToEscape(0x61), null),
+        () => assertEq(codePointToEscape(0x00), null), // NUL: a control, but no short form
+    ],
+    // The letters are distinct — a repeated letter would silently shadow an
+    // entry in the decode view, and the table is small enough to say so.
+    lettersAreDistinct: () => assertEq(new Set(simpleEscapes.map(([letter]) => letter)).size, simpleEscapes.length),
+}

package/fjs/js/tokenizer/module.f.mjs

@@ -22,15 +22,14 @@ import { strictEqual } from '../../types/function/operator/module.f.mjs'
 import { merge, fromRange, get } from '../../types/range_map/module.f.mjs'
 import { empty, stateScan, flat, toArray, reduce as listReduce, scan, map as listMap } from '../../types/list/module.f.mjs'
 import { keywords } from '../keywords/module.f.mjs'
+import { simpleEscapes } from '../string_escape/module.f.mjs'
 import { at, fromEntries } from '../../types/ordered_map/module.f.mjs'
 import { one } from '../../types/range/module.f.mjs'
 import {
     range,
     //
-    backspace,
     ht,
     lf,
-    ff,
     cr,
     //
     exclamationMark,
@@ -70,12 +69,8 @@ import {
     lowLine,
     //
     latinSmallLetterRange,
-    latinSmallLetterB,
     latinSmallLetterE,
-    latinSmallLetterF,
     latinSmallLetterN,
-    latinSmallLetterR,
-    latinSmallLetterT,
     latinSmallLetterU,
     //
     leftCurlyBracket,
@@ -501,14 +496,21 @@ const parseEscapeDefault = state => input => {
     return [{ first: { kind: 'error', message: 'unescaped character' }, tail: next[0] }, next[1]]
 }
 
+/**
+ * One dispatch entry per simple escape, appending the code point the letter
+ * denotes. The three self-denoting escapes are not special-cased: `\"` appends
+ * `"` because that is what the table pairs it with.
+ *
+ * @type {readonly _RangeFunc<_ParseEscapeCharState>[]}
+ */
+const simpleEscapeFuncs = simpleEscapes.map(([letter, codePoint]) =>
+    rangeFunc(one(letter))(state => () => [empty, { kind: 'string', value: appendChar(state.value)(codePoint) }]))
+
 /** @type {(state: _ParseEscapeCharState) => (input: number) => readonly [List<JsToken>, _TokenizerState]} */
 const parseEscapeCharStateOp = create(parseEscapeDefault)([
-    rangeSetFunc([one(quotationMark), one(reverseSolidus), one(solidus)])(state => input => [empty, { kind: 'string', value: appendChar(state.value)(input) }]),
-    rangeFunc(one(latinSmallLetterB))(state => () => [empty, { kind: 'string', value: appendChar(state.value)(backspace) }]),
-    rangeFunc(one(latinSmallLetterF))(state => () => [empty, { kind: 'string', value: appendChar(state.value)(ff) }]),
-    rangeFunc(one(latinSmallLetterN))(state => () => [empty, { kind: 'string', value: appendChar(state.value)(lf) }]),
-    rangeFunc(one(latinSmallLetterR))(state => () => [empty, { kind: 'string', value: appendChar(state.value)(cr) }]),
-    rangeFunc(one(latinSmallLetterT))(state => () => [empty, { kind: 'string', value: appendChar(state.value)(ht) }]),
+    ...simpleEscapeFuncs,
+    // `\u` is the one escape whose meaning is not a lookup: the four hex
+    // digits that follow decide it, so it starts a state instead.
     rangeFunc(one(latinSmallLetterU))(state => () => [empty, { kind: 'unicodeChar', value: state.value, unicode: 0, hexIndex: 0 }]),
 ])
 

package/fjs/mcp/cas/module.f.d.mts

@@ -116,7 +116,7 @@ import type { Key } from '../../effects/memory/types.ts';
 /** Arguments for `cas_add`: content to store, with optional encoding type. */
 export declare const casAddArgs: {
     readonly content: import("../../types/rtti/types.ts")._Type0<"string">;
-    readonly type: import("../../types/rtti/types.ts").Or<["text", "base64", undefined]>;
+    readonly type: import("../../types/rtti/types.ts").Or<readonly ["text", "base64", undefined]>;
 };
 /** Arguments for `cas_get`: the cBase32 hash to look up; optionally request inline content. */
 export declare const casGetArgs: {
@@ -131,12 +131,6 @@ export type _Meta = {
     readonly type: 'text' | 'base64';
     readonly uri: string;
 };
-/** @typedef {{
- *   readonly length: number
- *   readonly mimeType: string
- *   readonly type: 'text' | 'base64'
- *   readonly uri: string
- * }} _Meta */
 /**
  * Registry of all CAS tools, bound to `home` and the Evo cache at
  * `cacheKey`. `cas_add` is the only tool that writes, so it is the only one

package/fjs/mcp/cas/module.f.mjs

@@ -123,7 +123,7 @@ import { noteDialect } from '../../media/note/module.f.mjs'
 import { maxLengthBytes } from '../../types/bit_vec/module.f.mjs'
 import { ok } from '../../types/result/module.f.mjs'
 import {
-    toolEntry, errorResult, okResult,
+    toolEntry, errorResult, okResult, toolResultStep,
 } from '../../protocol/mcp/module.f.mjs'
 import { collectRead, fileCas } from '../../cas/module.f.mjs'
 import { errorSummary } from '../../effects/node/module.f.mjs'
@@ -135,11 +135,15 @@ import { syncRevision } from '../../cas/evo/module.f.mjs'
 import { assertNotNullish } from '../../asserts/module.f.mjs'
 
 // ── Argument schemas (declared once, used for both inputSchema and validate) ─────
+//
+// Closed, as the bare form says: a tool's argument list is a vocabulary this
+// server defines rather than a format a client extends, and the JSON Schema
+// derived from these now advertises exactly what the validator enforces.
 
 /** Arguments for `cas_add`: content to store, with optional encoding type. */
 export const casAddArgs = /** @type {const} */ ({
     content: string,
-    type: or(/** @type {const} */ ('text'), /** @type {const} */ ('base64'), undefined)
+    type: or('text', 'base64', undefined)
 })
 
 /** Arguments for `cas_get`: the cBase32 hash to look up; optionally request inline content. */
@@ -170,6 +174,14 @@ const detectDialect = detect([revisionDialect, lockDialect, noteDialect])
  *   readonly uri: string
  * }} _Meta */
 
+/**
+ * Maps a media-type detector verdict to the `cas_get` wire metadata.
+ *
+ * @type {(uri: string) => (detected: { readonly length: bigint, readonly mime_type: string, readonly type: 'text' | 'base64' }) => _Meta}
+ */
+const toMeta = uri => ({ length, mime_type: mimeType, type }) =>
+    ({ length: Number(length), mimeType, type, uri })
+
 /**
  * Registry of all CAS tools, bound to `home` and the Evo cache at
  * `cacheKey`. `cas_add` is the only tool that writes, so it is the only one
@@ -220,21 +232,21 @@ export const casToolRegistry = home => cacheKey => {
                     return pureOk(errorResult(`invalid cBase32 hash: ${r.hash}`))
                 }
                 const uri = c.url(key)
+                const meta = toMeta(uri)
                 return resultStep(
                     detectStream(c.read(key)),
                     ([tag, detected]) => {
                         if (tag === 'error') {
                             return pureOk(errorResult(`no such hash: ${r.hash}`))
                         }
-                        const { length, mime_type: mimeType, type } = detected
-                        /** @type {_Meta} */
-                        const meta = { length: Number(length), mimeType, type, uri }
+                        const { length, type } = detected
+                        const detectedMeta = meta(detected)
                         if (r.content !== true) {
                             // A dialect match can only be decided from the whole parsed blob;
                             // only attempt the extra bounded read when it stands a chance
                             // (whole-blob text within the same cap `content: true` allows).
                             if (type !== 'text' || length > maxLengthBytes) {
-                                return pureOk(okResult(toJson(meta)))
+                                return pureOk(okResult(toJson(detectedMeta)))
                             }
                             return resultStep(
                                 collectRead(c.read(key)),
@@ -242,9 +254,9 @@ export const casToolRegistry = home => cacheKey => {
                                     // Already known to fit from the streaming pass above, so an
                                     // error here means the hash vanished between reads; fall back
                                     // to the streaming verdict rather than fail the whole request.
-                                    if (collectTag === 'error') { return pureOk(okResult(toJson(meta))) }
+                                    if (collectTag === 'error') { return pureOk(okResult(toJson(detectedMeta))) }
                                     const refined = detectDialect(value)
-                                    return pureOk(okResult(toJson({ ...meta, mimeType: refined.mime_type })))
+                                    return pureOk(okResult(toJson(meta(refined))))
                                 }
                             )
                         }
@@ -267,8 +279,7 @@ export const casToolRegistry = home => cacheKey => {
                                 // hand — is reflected in the inline result too, not just the
                                 // streaming guess.
                                 const refined = detectDialect(value)
-                                /** @type {_Meta} */
-                                const refinedMeta = { length: Number(refined.length), mimeType: refined.mime_type, type: refined.type, uri }
+                                const refinedMeta = meta(refined)
                                 if (refined.type === 'text') {
                                     // `type: 'text'` means the detector validated `value` as
                                     // whole-blob UTF-8 with a byte-aligned length (see
@@ -295,12 +306,10 @@ export const casToolRegistry = home => cacheKey => {
             'cas_list',
             'List all stored content hashes (cBase32), one per line.',
             casListArgs,
-            () => resultStep(
+            () => toolResultStep(
                 c.list(),
-                r => pureOk(r[0] === 'error'
-                    ? errorResult(errorSummary(r[1]))
-                    : okResult(r[1].map(vecToCBase32).join('\n')))
-            ),
+                hs => hs.map(vecToCBase32).join('\n'),
+                errorSummary),
         ),
     ]
 }

package/fjs/mcp/evo/module.f.mjs

@@ -51,15 +51,16 @@
 
 import { string, option, array } from '../../types/rtti/module.f.mjs'
 import { lockField } from '../../media/revision/module.f.mjs'
-import { pureOk, resultStep } from '../../effects/module.f.mjs'
 import { evoSummary } from '../../cas/evo/module.f.mjs'
-import {
-    toolEntry, errorResult, okResult,
-} from '../../protocol/mcp/module.f.mjs'
+import { toolEntry, toolResultStep } from '../../protocol/mcp/module.f.mjs'
 import { stringify } from '../../media/json/module.f.mjs'
 import { identity } from '../../types/function/module.f.mjs'
 
 // ── Argument schemas (declared once, used for both inputSchema and validate) ─────
+//
+// Closed, as the bare form says, for the reason `../cas/module.f.mjs` gives:
+// a tool's argument list is a vocabulary this server defines rather than a
+// format a client extends.
 
 /**
  * Arguments for `evo_list`: an optional status filter, forwarded unchanged to
@@ -125,23 +126,13 @@ export const evoToolRegistry = e => [
         // A cache slot the runner cannot reach is a tool-level error, not a
         // panic: the client asked a question the server could not answer, and
         // saying so is an ordinary `isError` result.
-        (({ archived }) => resultStep(
-            e.list(archived),
-            r => pureOk(r[0] === 'error'
-                ? errorResult(evoSummary(r[1]))
-                : okResult(toJson(r[1])))
-        )),
+        ({ archived }) => toolResultStep(e.list(archived), toJson, evoSummary),
     ),
     toolEntry(
         'evo_head',
         'List the current head hashes (cBase32) of a subject, one per line. Empty when the subject is unknown.',
         evoHeadArgs,
-        ({ subject }) => resultStep(
-            e.head(subject),
-            r => pureOk(r[0] === 'error'
-                ? errorResult(evoSummary(r[1]))
-                : okResult(r[1].join('\n'))),
-        ),
+        ({ subject }) => toolResultStep(e.head(subject), hs => hs.join('\n'), evoSummary),
     ),
     toolEntry(
         'evo_revision',
@@ -152,10 +143,7 @@ export const evoToolRegistry = e => [
         // the transport's `-32603`, not a tool-level error — see "Result size"
         // in the module doc.
 
-        (({ hash }) => resultStep(
-            e.revision(hash),
-            r => pureOk(r[0] === 'error' ? errorResult(evoSummary(r[1])) : okResult(toJson(r[1])))
-        )),
+        ({ hash }) => toolResultStep(e.revision(hash), toJson, evoSummary),
     ),
     toolEntry(
         'evo_add',
@@ -166,9 +154,6 @@ export const evoToolRegistry = e => [
         // it can read. They stay distinguishable by tag — `evoSummary` is the
         // renderer that switches on it — so telling them apart never needed
         // them to arrive in separate layers.
-        input => resultStep(
-            e.add(input),
-            r => pureOk(r[0] === 'error' ? errorResult(evoSummary(r[1])) : okResult(r[1]))
-        ),
+        input => toolResultStep(e.add(input), identity, evoSummary),
     ),
 ]

package/fjs/mcp/module.f.d.mts

@@ -50,7 +50,9 @@ import type { Key } from '../effects/memory/types.ts';
 export declare const casMcpHandlers: (home: string) => (cacheKey: Key<Cache>) => McpHandlers<FileCasOperation | MemOp>;
 /**
  * Static MCP configuration for the CAS server: advertises the `tools`
- * capability, identifies the server, and pins the protocol version.
+ * capability, identifies the server, and lists the protocol revisions it
+ * speaks — one, so every client is answered with `2024-11-05`, whether that is
+ * an echo or a counter-proposal.
  * @type {McpConfig}
  */
 export declare const casConfig: McpConfig;

package/fjs/mcp/module.f.mjs

@@ -62,13 +62,15 @@ export const casMcpHandlers = home => cacheKey =>
 
 /**
  * Static MCP configuration for the CAS server: advertises the `tools`
- * capability, identifies the server, and pins the protocol version.
+ * capability, identifies the server, and lists the protocol revisions it
+ * speaks — one, so every client is answered with `2024-11-05`, whether that is
+ * an echo or a counter-proposal.
  * @type {McpConfig}
  */
 export const casConfig = {
     serverInfo: { name: 'functionalscript-cas', version: '0.30.0' },
     capabilities: { tools: {} },
-    protocolVersion: '2024-11-05',
+    protocolVersions: ['2024-11-05'],
 }
 
 // ── Server ──────────────────────────────────────────────────────────────────────

package/fjs/media/json/rtti/module.f.d.mts

@@ -12,12 +12,12 @@
  *
  * The TypeScript counterparts live in the sibling
  * [`../types.ts`](../types.ts), which pins them against these schemas with
- * `Assert<Equal<Unknown, Ts<typeof unknown>>>`.
+ * `Assert<Check<Unknown, typeof unknown>>`.
  *
  * @module
  */
 /** rtti schema matching any JSON primitive: `null`, `boolean`, `number`, or `string`. */
-export declare const primitive: import("../../../types/rtti/types.ts").Or<[null, import("../../../types/rtti/types.ts")._Type0<"boolean">, import("../../../types/rtti/types.ts")._Type0<"number">, import("../../../types/rtti/types.ts")._Type0<"string">]>;
+export declare const primitive: import("../../../types/rtti/types.ts").Or<readonly [null, import("../../../types/rtti/types.ts")._Type0<"boolean">, import("../../../types/rtti/types.ts")._Type0<"number">, import("../../../types/rtti/types.ts")._Type0<"string">]>;
 /**
  * rtti schema matching any JSON value: a primitive, an array of JSON values,
  * or an object whose values are JSON values. Self-referential via a thunk;

package/fjs/media/json/rtti/module.f.mjs

@@ -12,7 +12,7 @@
  *
  * The TypeScript counterparts live in the sibling
  * [`../types.ts`](../types.ts), which pins them against these schemas with
- * `Assert<Equal<Unknown, Ts<typeof unknown>>>`.
+ * `Assert<Check<Unknown, typeof unknown>>`.
  *
  * @module
  */

package/fjs/media/json/schema/module.f.d.mts

@@ -19,13 +19,15 @@
  *
  * @import { Type as RttiType } from '../../../types/rtti/types.ts'
  * @import { ArraySet, Data, KindSet, Node, ObjectSet, RuleSet, UnionSet } from '../../../types/rtti/data/types.ts'
- * @import { Ts } from '../../../types/rtti/ts/types.ts'
+ * @import { Ts, Check } from '../../../types/rtti/ts/types.ts'
  * @import { Phantom } from '../../../types/phantom/types.ts'
+ * @import { Assert } from '../../../asserts/types.ts'
  */
 import type { Type as RttiType } from '../../../types/rtti/types.ts';
 import type { Data } from '../../../types/rtti/data/types.ts';
-import type { Ts } from '../../../types/rtti/ts/types.ts';
+import type { Ts, Check } from '../../../types/rtti/ts/types.ts';
 import type { Phantom } from '../../../types/phantom/types.ts';
+import type { Assert } from '../../../asserts/types.ts';
 /** @type {() => readonly ['const', typeof unknownConst]} */
 declare const unknownThunk: () => readonly ['const', typeof unknownConst];
 /**
@@ -33,18 +35,26 @@ declare const unknownThunk: () => readonly ['const', typeof unknownConst];
  * @type {Phantom<typeof unknownThunk, _UnknownConst>}
  */
 export declare const unknown: Phantom<typeof unknownThunk, _UnknownConst>;
+export type _UnknownCheck0 = Assert<Check<_UnknownConst, typeof unknownThunk>>;
+export type _UnknownCheck1 = Assert<Check<_UnknownConst, typeof unknown>>;
 export type Unknown = Ts<typeof unknown>;
+/**
+ * Checked against the un-annotated thunk, so a wrong `_UnknownConst` above
+ * would be caught here instead of silently trusted via the `Phantom` lie.
+ * @typedef {Assert<Check<_UnknownConst, typeof unknownThunk>>} _UnknownCheck0
+ */
+/** @typedef {Assert<Check<_UnknownConst, typeof unknown>>} _UnknownCheck1 */
 /** A JSON Schema (draft 2020-12) document — the subset of keywords that `toJsonSchema` emits. */
 /** @typedef {Ts<typeof unknown>} Unknown */
 declare const unknownConst: {
     readonly $schema: import("../../../types/rtti/types.ts").Or<readonly [import("../../../types/rtti/types.ts")._Type0<"string">, undefined]>;
     readonly $ref: import("../../../types/rtti/types.ts").Or<readonly [import("../../../types/rtti/types.ts")._Type0<"string">, undefined]>;
     readonly $defs: import("../../../types/rtti/types.ts").Or<readonly [import("../../../types/rtti/types.ts").Type1<"record", Phantom<() => readonly ['const', typeof unknownConst], _UnknownConst>>, undefined]>;
-    readonly type: import("../../../types/rtti/types.ts").Or<["boolean", "number", "string", "integer", "array", "object", undefined]>;
+    readonly type: import("../../../types/rtti/types.ts").Or<readonly ["boolean", "number", "string", "integer", "array", "object", undefined]>;
     readonly const: import("../../../types/rtti/types.ts").Or<readonly [() => readonly ['or', typeof import("../rtti/module.f.mjs").primitive, typeof import("../rtti/module.f.mjs").object, typeof import("../rtti/module.f.mjs").array], undefined]>;
     readonly not: import("../../../types/rtti/types.ts").Or<readonly [Phantom<() => readonly ['const', typeof unknownConst], _UnknownConst>, undefined]>;
     readonly anyOf: import("../../../types/rtti/types.ts").Or<readonly [import("../../../types/rtti/types.ts").Type1<"array", Phantom<() => readonly ['const', typeof unknownConst], _UnknownConst>>, undefined]>;
-    readonly items: import("../../../types/rtti/types.ts").Or<[Phantom<() => readonly ['const', typeof unknownConst], _UnknownConst>, false, undefined]>;
+    readonly items: import("../../../types/rtti/types.ts").Or<readonly [Phantom<() => readonly ['const', typeof unknownConst], _UnknownConst>, false, undefined]>;
     readonly prefixItems: import("../../../types/rtti/types.ts").Or<readonly [import("../../../types/rtti/types.ts").Type1<"array", Phantom<() => readonly ['const', typeof unknownConst], _UnknownConst>>, undefined]>;
     readonly minItems: import("../../../types/rtti/types.ts").Or<readonly [import("../../../types/rtti/types.ts")._Type0<"number">, undefined]>;
     readonly properties: import("../../../types/rtti/types.ts").Or<readonly [import("../../../types/rtti/types.ts").Type1<"record", Phantom<() => readonly ['const', typeof unknownConst], _UnknownConst>>, undefined]>;
@@ -95,7 +105,7 @@ export declare const dataToJsonSchema: (data: Data) => Unknown;
  * | `bigint` const                                | `{ "const": Number(value) }` (lossy for \|value\| > MAX_SAFE_INTEGER)               |
  * | `undefined` const                             | `{ "not": {} }`                                                                     |
  * | struct `{ a: T, … }`                          | `{ "type": "object", "properties": { "a": …T… }, "required": [non-optional keys] }` |
- * | tuple `[A, B]`                                | `{ "type": "array", "prefixItems": […A…, …B…], "minItems": 2, "items": false }`     |
+ * | tuple `[A, B]`                                | `{ "type": "array", "prefixItems": […A…, …B…], "minItems": 2, "items": {} }`        |
  * | `array(T)`                                    | `{ "type": "array", "items": …T… }`                                                 |
  * | `record(T)`                                   | `{ "type": "object", "additionalProperties": …T… }`                                 |
  * | `or(...types)`                                | `{ "anyOf": […each…] }`, normalized and in canonical kind order                     |

package/fjs/media/json/schema/module.f.mjs

@@ -19,8 +19,9 @@
  *
  * @import { Type as RttiType } from '../../../types/rtti/types.ts'
  * @import { ArraySet, Data, KindSet, Node, ObjectSet, RuleSet, UnionSet } from '../../../types/rtti/data/types.ts'
- * @import { Ts } from '../../../types/rtti/ts/types.ts'
+ * @import { Ts, Check } from '../../../types/rtti/ts/types.ts'
  * @import { Phantom } from '../../../types/phantom/types.ts'
+ * @import { Assert } from '../../../asserts/types.ts'
  */
 
 import { assert, assertNotNullish } from '../../../asserts/module.f.mjs'
@@ -38,6 +39,13 @@ const unknownThunk = () => ['const', unknownConst]
  */
 export const unknown = unknownThunk
 
+/**
+ * Checked against the un-annotated thunk, so a wrong `_UnknownConst` above
+ * would be caught here instead of silently trusted via the `Phantom` lie.
+ * @typedef {Assert<Check<_UnknownConst, typeof unknownThunk>>} _UnknownCheck0
+ */
+/** @typedef {Assert<Check<_UnknownConst, typeof unknown>>} _UnknownCheck1 */
+
 /** A JSON Schema (draft 2020-12) document — the subset of keywords that `toJsonSchema` emits. */
 /** @typedef {Ts<typeof unknown>} Unknown */
 
@@ -165,22 +173,41 @@ const unitSchemas = bits => [
 ]
 
 /**
- * A set of arrays: `prefixItems` for the tuple prefix, `items` for the
- * elements past it — `false` when the length is exact, so a tuple admits
- * nothing beyond its prefix and the empty tuple is `{ "items": false }`.
- * `prefixItems` alone constrains only elements that exist (draft 2020-12
- * implies no minimum length), so a non-empty prefix also emits `minItems`.
+ * The length below which the array would leave a declared position that
+ * excludes `undefined` unfilled: one past the last such position, and zero
+ * when every position admits absence. The array counterpart of the `required`
+ * key list — an absent element reads as `undefined` just as an absent key
+ * does — and, arrays being contiguous, one number says it for every position.
+ *
+ * @type {(rules: RuleSet) => (prefix: readonly Node[]) => number}
+ */
+const minLength = rules => prefix =>
+    prefix.findLastIndex(n => !admitsUndefined(rules)(n)) + 1
+
+/**
+ * A set of arrays: `prefixItems` for the declared positions, `items` for what
+ * may follow — `false` when nothing may, which is what makes the exact-length
+ * pattern exact. `prefixItems` alone constrains only elements that exist
+ * (draft 2020-12 implies no minimum length), so the required length is
+ * `minItems`, and a position past it — one the array may simply end before —
+ * has `undefined` stripped from its schema, absence being expressed by
+ * `minItems` already. Both are the object side's `required` /
+ * {@link stripUndefined} pair, one kind over.
  *
  * @type {(rules: RuleSet) => (p: ArraySet) => Unknown}
  */
-const arraySetSchema = rules => p => ({
-    type: 'array',
-    ...(p.prefix.length === 0 ? {} : {
-        prefixItems: p.prefix.map(nodeSchema(rules)),
-        minItems: p.prefix.length,
-    }),
-    items: p.rest === undefined ? false : nodeSchema(rules)(p.rest),
-})
+const arraySetSchema = rules => p => {
+    const minItems = minLength(rules)(p.prefix)
+    return {
+        type: 'array',
+        ...(p.prefix.length === 0 ? {} : {
+            prefixItems: p.prefix.map(
+                (n, i) => nodeSchema(rules)(i < minItems ? n : stripUndefined(n))),
+        }),
+        ...(minItems === 0 ? {} : { minItems }),
+        items: p.rest === undefined ? false : nodeSchema(rules)(p.rest),
+    }
+}
 
 /** Whether the node's value set admits `undefined` — its unit bit, read
  * through a reference if needed.
@@ -282,7 +309,7 @@ export const dataToJsonSchema = ([rules, entry]) => {
  * | `bigint` const                                | `{ "const": Number(value) }` (lossy for \|value\| > MAX_SAFE_INTEGER)               |
  * | `undefined` const                             | `{ "not": {} }`                                                                     |
  * | struct `{ a: T, … }`                          | `{ "type": "object", "properties": { "a": …T… }, "required": [non-optional keys] }` |
- * | tuple `[A, B]`                                | `{ "type": "array", "prefixItems": […A…, …B…], "minItems": 2, "items": false }`     |
+ * | tuple `[A, B]`                                | `{ "type": "array", "prefixItems": […A…, …B…], "minItems": 2, "items": {} }`        |
  * | `array(T)`                                    | `{ "type": "array", "items": …T… }`                                                 |
  * | `record(T)`                                   | `{ "type": "object", "additionalProperties": …T… }`                                 |
  * | `or(...types)`                                | `{ "anyOf": […each…] }`, normalized and in canonical kind order                     |

package/fjs/media/json/schema/proof.f.d.mts

@@ -28,12 +28,19 @@ export declare const proof: {
     array: () => void;
     record: () => void;
     or: () => void;
-    tuple: () => void;
+    tuple: {
+        allRequired: () => void;
+        withOptional: () => void;
+        allOptional: () => void;
+        open: () => void;
+    };
     struct: {
         allRequired: () => void;
         withOptional: () => void;
         allOptional: () => void;
         empty: () => void;
+        openEmpty: () => void;
+        open: () => void;
         orOptional: () => void;
         withConst: () => void;
         optionalOfEveryKind: () => void;
@@ -52,7 +59,9 @@ export declare const proof: {
         duplicateLiteral: () => void;
         never: () => void;
         emptyTuple: () => void;
+        openEmptyTuple: () => void;
         coverageCollapse: () => void;
+        noCollapseWhenClosed: () => void;
         commutative: () => void;
     };
     recursion: {