functionalscript 0.46.1 → 0.47.0

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

@@ -8,11 +8,13 @@ import {
     array,
     bigint,
     boolean,
+    open,
     never as neverRtti,
     number,
     option,
     or,
     record,
+    rest,
     string,
     unknown as unknownRtti,
 } from '../module.f.mjs'
@@ -114,10 +116,34 @@ const identityRec = f => f
 /** @type {_Rec} */
 const anon = identityRec(() => ['array', anon])
 
+/** A cycle through a closed tuple: `_ClosedNode = [number, readonly _ClosedNode[]]`. */
+/** @typedef {() => readonly ['const', readonly [typeof number, _ClosedChildren]]} _ClosedNode */
+/** @typedef {() => readonly ['array', _ClosedNode]} _ClosedChildren */
+/** @type {_ClosedNode} */
+const closedNode = () => ['const', [number, closedChildren]]
+/** @type {_ClosedChildren} */
+const closedChildren = () => ['array', closedNode]
+
+/** A cycle through a struct's stated `rest`. */
+/** @typedef {() => readonly ['rest', { readonly a: typeof number }, _NestedRest]} _NestedRest */
+/** @type {_NestedRest} */
+const nestedRest = () => ['rest', { a: number }, nestedRest]
+
 const tupleNumber = /** @type {const} */ ([number])
 const tupleString = /** @type {const} */ ([string])
+const tupleNumberNumber = /** @type {const} */ ([number, number])
 const emptyTuple = /** @type {const} */ ([])
 
+/**
+ * The exact-length array patterns — what a bare, closed `Tuple` converts to,
+ * and what an `open` one never reaches. Written as data as well so the
+ * `rest`-less arm of every array operation is exercised from both ends.
+ */
+/** @type {Data} */
+const exactlyOneNumber = [{}, { array: [{ prefix: [{ number: true }] }] }]
+/** @type {Data} */
+const exactlyTwoNumbers = [{}, { array: [{ prefix: [{ number: true }, { number: true }] }] }]
+
 export const proof = {
     withoutUnits: [
         // Removing the last unit bit removes the key: an empty kind is an
@@ -176,16 +202,83 @@ export const proof = {
             assertData(toData(record(unknownRtti)))([{}, { object: true }])
             assertData(toData(array(neverRtti)))([{}, { array: [{ prefix: [] }] }])
             assertData(toData(record(neverRtti)))([{}, { object: [{ props: {}, rest: {} }] }])
-            assertData(toData(emptyTuple))([{}, { array: [{ prefix: [] }] }])
-            assertData(toData(/** @type {const} */ ([number, 42])))(
-                [{}, { array: [{ prefix: [{ number: true }, { number: [42] }] }] }])
-            assertData(toData({}))([{}, { object: true }])
-            assertData(toData({ b: string, a: number }))(
+            // both const containers are closed, so each carries the `rest`
+            // that says so — `never`, on either kind. `open` is what supplies
+            // the `unknown` one, which the two kinds spell differently: a
+            // `rest: unknown` past a tuple's prefix, and no `rest` at all on a
+            // struct. An open tuple declaring nothing is therefore every array
+            // — and so is one whose every position restates that `rest`, which
+            // is trimmed away so that one set keeps one spelling
+            assertData(toData(open(emptyTuple)))([{}, { array: true }])
+            assertData(toData(open(/** @type {const} */ ([unknownRtti]))))([{}, { array: true }])
+            assertData(toData(open(/** @type {const} */ ([unknownRtti, unknownRtti]))))([{}, { array: true }])
+            assertData(toData(open(/** @type {const} */ ([number, unknownRtti]))))(toData(open(tupleNumber)))
+            assertData(toData(open(/** @type {const} */ ([number, 42]))))(
+                [{}, { array: [{ prefix: [{ number: true }, { number: [42] }], rest: unknown }] }])
+            assertData(toData(open({})))([{}, { object: true }])
+            assertData(toData(open({ b: string, a: number })))(
                 [{}, { object: [{ props: { a: { number: true }, b: { string: true } } }] }])
-            assertData(toData({ a: unknownRtti }))([{}, { object: true }])
+            assertData(toData(open({ a: unknownRtti })))([{}, { object: true }])
             assertData(toData(/** @type {const} */ ([neverRtti])))([{}, never])
             assertData(toData({ a: neverRtti }))([{}, never])
         },
+        // `rest` needs no new concept underneath: it is the schema-form
+        // spelling of a `rest` the data form already carries — `never` for the
+        // bare, closed container, `R` for a stated one — and `open` is the
+        // `unknown` one.
+        rest: () => {
+            assertData(toData(tupleNumber))(exactlyOneNumber)
+            assertData(toData(tupleNumberNumber))(exactlyTwoNumbers)
+            assertData(toData(emptyTuple))([{}, { array: [{ prefix: [] }] }])
+            assertData(toData({ a: number }))(
+                [{}, { object: [{ props: { a: { number: true } }, rest: never }] }])
+            assertData(toData({}))([{}, { object: [{ props: {}, rest: never }] }])
+            // the bare form and an explicit empty rest are one set
+            assertData(toData(tupleNumber))(toData(rest(tupleNumber, neverRtti)))
+            // a stated rest is that rest
+            assertData(toData(rest(tupleNumber, string)))(
+                [{}, { array: [{ prefix: [{ number: true }], rest: { string: true } }] }])
+            assertData(toData(rest({ a: number }, string)))(
+                [{}, { object: [{ props: { a: { number: true } }, rest: { string: true } }] }])
+            // an unconstrained rest is `open`, and normalizes the same way on
+            // both kinds
+            assertData(toData(rest(tupleNumber, unknownRtti)))(toData(open(tupleNumber)))
+            assertData(toData(rest({ a: number }, unknownRtti)))(toData(open({ a: number })))
+            // a `never` member empties the whole pattern, whatever the rest
+            assertData(toData(/** @type {const} */ ([neverRtti])))([{}, never])
+            assertData(toData({ a: neverRtti }))([{}, never])
+            // an unconstrained key is dropped only once the rest is gone: with
+            // one present, "anything at `a`" says strictly more than leaving
+            // `a` out, which `open({ a: unknown })` alone does not
+            assertData(toData(open({ a: unknownRtti })))([{}, { object: true }])
+            assertData(toData({ a: unknownRtti }))(
+                [{}, { object: [{ props: { a: unknown }, rest: never }] }])
+            // the same container bare and opened are two sets, so the
+            // by-identity memo for const containers must not answer for both
+            assert(!equal(toData(/** @type {const} */ ([tupleNumber, open(tupleNumber)])))(
+                toData(/** @type {const} */ ([tupleNumber, tupleNumber]))))
+        },
+        // A cycle closes through a stated `rest` the same way it closes
+        // through a bare container: the enclosing thunk is what becomes the
+        // named rule.
+        restRecursion: () => {
+            assertData(toData(closedNode))([
+                {
+                    closedNode: {
+                        array: [{
+                            prefix: [
+                                { number: true },
+                                { array: [{ prefix: [], rest: 'closedNode' }] },
+                            ],
+                        }],
+                    },
+                },
+                'closedNode',
+            ])
+            // and a cycle whose recursive position is the rest itself
+            assertData(toData(nestedRest))(
+                [{ nestedRest: { object: [{ props: { a: { number: true } }, rest: 'nestedRest' }] } }, 'nestedRest'])
+        },
         constSchemas: () => {
             assertData(toData(() => /** @type {const} */ (['const', 42])))([{}, { number: [42] }])
             assertData(toData(() => /** @type {const} */ (['const', null])))([{}, { unit: unitBit(null) }])
@@ -242,11 +335,16 @@ export const proof = {
             ])
             assertData(toData({ p: list }))([
                 { list: { array: [{ prefix: [], rest: 'list' }] } },
-                { object: [{ props: { p: 'list' } }] },
+                { object: [{ props: { p: 'list' }, rest: never }] },
             ])
             assertData(toData(a2))([
                 {
-                    a2: { array: [{ prefix: [], rest: { array: [{ prefix: ['a2', 'b2'] }] } }] },
+                    a2: {
+                        array: [{
+                            prefix: [],
+                            rest: { array: [{ prefix: ['a2', 'b2'] }] },
+                        }],
+                    },
                     b2: { array: [{ prefix: [], rest: 'b2' }] },
                 },
                 'a2',
@@ -312,24 +410,43 @@ export const proof = {
             assertData(toData(anon))([{ '': { array: [{ prefix: [], rest: '' }] } }, ''])
         },
         collapse: () => {
-            // readonly [number] ⊂ readonly number[] — the tuple pattern is dropped
-            assertData(toData(or(tupleNumber, array(number))))(toData(array(number)))
-            // the empty tuple is a member of every uniform array set
-            assertData(toData(or(emptyTuple, array(number))))(toData(array(number)))
-            assertData(toData(or(array(number), emptyTuple)))(toData(array(number)))
-            // kept when neither pattern subsumes the other
-            assertData(toData(or(tupleNumber, tupleString)))(
-                [{}, { array: [{ prefix: [{ string: true }] }, { prefix: [{ number: true }] }] }])
+            // a longer tuple pattern is included in a shorter one when both
+            // are open — the array counterpart of a wider struct in a narrower
+            // one. Closed, neither includes the other: they differ in length.
+            assertData(toData(or(open(tupleNumberNumber), open(tupleNumber))))(toData(open(tupleNumber)))
+            // the empty-array pattern is a member of every uniform array set
+            assertData(toData(or(array(neverRtti), array(number))))(toData(array(number)))
+            assertData(toData(or(array(number), array(neverRtti))))(toData(array(number)))
+            // an open tuple declaring nothing absorbs the whole kind
+            assertData(toData(or(open(emptyTuple), array(number))))(toData(array(unknownRtti)))
+            // kept when neither pattern subsumes the other: an open `[number]`
+            // admits `[1, 'x']`, which `readonly number[]` does not, and the
+            // uniform set admits `[]`, which the tuple does not
+            assertData(toData(or(open(tupleNumber), array(number))))([{}, {
+                array: [
+                    { prefix: [], rest: { number: true } },
+                    { prefix: [{ number: true }], rest: unknown },
+                ],
+            }])
+            assertData(toData(or(open(tupleNumber), open(tupleString))))([{}, {
+                array: [
+                    { prefix: [{ string: true }], rest: unknown },
+                    { prefix: [{ number: true }], rest: unknown },
+                ],
+            }])
             // the collapse recurses into inline positions
-            assertData(toData(array(or(tupleNumber, array(number)))))(toData(array(array(number))))
-            assertData(toData(record(or(tupleNumber, array(number)))))(toData(record(array(number))))
-            assertData(toData({ a: or(tupleNumber, array(number)) }))(toData({ a: array(number) }))
+            assertData(toData(array(or(open(tupleNumberNumber), open(tupleNumber)))))(
+                toData(array(open(tupleNumber))))
+            assertData(toData(record(or(open(tupleNumberNumber), open(tupleNumber)))))(
+                toData(record(open(tupleNumber))))
+            assertData(toData({ a: or(open(tupleNumberNumber), open(tupleNumber)) }))(
+                toData({ a: open(tupleNumber) }))
             // collapsing innards can make two patterns identical — deduplicated
-            assertData(toData(or(array(or(tupleNumber, array(number))), array(array(number)))))(
-                toData(array(array(number))))
+            assertData(toData(or(array(or(open(tupleNumberNumber), open(tupleNumber))), array(open(tupleNumber)))))(
+                toData(array(open(tupleNumber))))
             // subsumed object patterns are dropped, `true` absorbs patterns
             assertData(toData(or({ a: 42 }, { a: number })))(toData({ a: number }))
-            assertData(toData(or({ a: number }, {})))(toData({}))
+            assertData(toData(or(open({ a: number }), open({}))))(toData(open({})))
         },
         serializable: () => {
             const d = toData(or(string, array(number), null))
@@ -363,6 +480,16 @@ export const proof = {
             assert(cmp(toData(number))(toData(list)) < 0)
             assert(cmp(toData(list))(toData(number)) > 0)
         },
+        // Two spellings of one set must not compare unequal, and two sets must
+        // not compare equal — the data form is content-addressed.
+        rest: () => {
+            assertEq(cmp(toData(tupleNumber))(toData(rest(tupleNumber, neverRtti))), 0)
+            assertEq(cmp(toData(rest(tupleNumber, unknownRtti)))(toData(open(tupleNumber))), 0)
+            assert(cmp(toData(tupleNumber))(toData(open(tupleNumber))) !== 0)
+            assert(cmp(toData({ a: number }))(toData(open({ a: number }))) !== 0)
+            assert(cmp(toData(tupleNumber))(toData(rest(tupleNumber, string))) !== 0)
+            assert(equal(toData(tupleNumber))(exactlyOneNumber))
+        },
         restOrder: () => {
             // a pattern without a rest sorts before one with a rest
             /** @type {Data} */
@@ -383,7 +510,7 @@ export const proof = {
             assertData(toData(or(record(number), record(string))))(
                 [{}, { object: [{ props: {}, rest: { string: true } }, { props: {}, rest: { number: true } }] }])
             // fewer props sort before more props
-            assertData(toData(or({ a: number }, record(number))))(
+            assertData(toData(or(open({ a: number }), record(number))))(
                 [{}, { object: [{ props: {}, rest: { number: true } }, { props: { a: { number: true } } }] }])
         },
         rules: () => {
@@ -412,37 +539,110 @@ export const proof = {
             assert(subset(toData(or(number, string)))(toData(unknownRtti)))
         },
         arrays: () => {
-            assert(subset(toData(tupleNumber))(toData(array(number))))
-            assert(!subset(toData(array(number)))(toData(tupleNumber)))
+            // a longer open tuple is included in a shorter one, and neither is
+            // included in the uniform set: an open `[number]` admits `[1, 'x']`
+            assert(subset(toData(open(tupleNumberNumber)))(toData(open(tupleNumber))))
+            assert(!subset(toData(open(tupleNumber)))(toData(open(tupleNumberNumber))))
+            assert(!subset(toData(open(tupleNumber)))(toData(array(number))))
+            assert(!subset(toData(array(number)))(toData(open(tupleNumber))))
+            // the exact-length pattern — the bare, closed tuple — is the one
+            // the uniform set contains
+            assert(subset(exactlyOneNumber)(toData(array(number))))
+            assert(subset(exactlyOneNumber)(toData(open(tupleNumber))))
+            // and, admitting one length only, contains just its own
+            assert(subset(exactlyOneNumber)(exactlyOneNumber))
+            assert(!subset(exactlyOneNumber)(exactlyTwoNumbers))
+            assert(!subset(toData(open(tupleNumber)))(exactlyOneNumber))
             assert(subset(toData(array(number)))(toData(unknownRtti)))
             assert(!subset(toData(array(unknownRtti)))(toData(array(number))))
             assert(subset(toData(array(number)))(toData(array(or(number, string)))))
-            assert(!subset(toData(tupleNumber))(toData(tupleString)))
-            assert(!subset(toData(tupleNumber))(toData(/** @type {const} */ ([number, number]))))
+            assert(!subset(toData(open(tupleNumber)))(toData(open(tupleString))))
         },
         arrayRest: () => {
             /** @type {Data} */
             const oneOrMoreNumbers = [{}, { array: [{ prefix: [{ number: true }], rest: { number: true } }] }]
+            // a position restating a `rest` that excludes `undefined` is not
+            // redundant — it is what makes this "one or more" rather than the
+            // uniform set, so nothing trims it away
             assert(subset(oneOrMoreNumbers)(toData(array(number))))
             assert(!subset(toData(array(number)))(oneOrMoreNumbers))
-            assert(subset(toData(/** @type {const} */ ([number, number])))(oneOrMoreNumbers))
-            assert(!subset(toData(emptyTuple))(oneOrMoreNumbers))
+            assert(subset(exactlyTwoNumbers)(oneOrMoreNumbers))
+            // the open tuple of two numbers admits a third element of any kind
+            assert(!subset(toData(open(tupleNumberNumber)))(oneOrMoreNumbers))
+            // an open tuple declaring nothing is the whole kind
+            assert(!subset(toData(open(emptyTuple)))(oneOrMoreNumbers))
             /** @type {Data} */
             const oneNumberThenStrings = [{}, { array: [{ prefix: [{ number: true }], rest: { string: true } }] }]
             assert(!subset(oneOrMoreNumbers)(oneNumberThenStrings))
         },
+        // The closed default makes a `rest`-less array pattern and an object
+        // pattern with an empty `rest` the *ordinary* output of the thunk
+        // form, where hand-written data used to be the only way to reach
+        // either. Both directions of each.
+        rest: () => {
+            // closed is included in open, never the other way round
+            assert(subset(toData(tupleNumber))(toData(open(tupleNumber))))
+            assert(!subset(toData(open(tupleNumber)))(toData(tupleNumber)))
+            assert(subset(toData({ a: number }))(toData(open({ a: number }))))
+            assert(!subset(toData(open({ a: number })))(toData({ a: number })))
+            // an exact length is its own, and contains no other
+            assert(subset(toData(tupleNumber))(toData(tupleNumber)))
+            assert(!subset(toData(tupleNumber))(toData(tupleNumberNumber)))
+            assert(!subset(toData(tupleNumberNumber))(toData(tupleNumber)))
+            // a stated rest widens it, and an unconstrained one is openness
+            assert(subset(toData(tupleNumber))(toData(rest(tupleNumber, string))))
+            assert(!subset(toData(rest(tupleNumber, string)))(toData(tupleNumber)))
+            assert(subset(toData(rest(tupleNumber, string)))(toData(rest(tupleNumber, unknownRtti))))
+            assert(subset(toData({ a: number }))(toData(rest({ a: number }, string))))
+            assert(!subset(toData(rest({ a: number }, string)))(toData({ a: number })))
+            assert(subset(toData(rest({ a: number }, number)))(toData(record(number))))
+            assert(!subset(toData(record(number)))(toData(rest({ a: number }, number))))
+            // and the members are still compared pointwise
+            assert(subset(toData(/** @type {const} */ ([42])))(toData(tupleNumber)))
+            assert(!subset(toData(tupleNumber))(toData(tupleString)))
+            assert(subset(toData(closedNode))(toData(closedNode)))
+        },
+        // A key present holding `undefined` and a key absent are two different
+        // objects, and the two sides of a pattern read them differently: a
+        // declared key constrains the value *read* at it, so absence passes
+        // when its set holds `undefined`; an undeclared key is checked as an
+        // *entry*, so a present `undefined` must belong to `rest` itself.
+        //
+        // One "read set" of `rest ∪ undefined` folded the two together, which
+        // stayed sound only while a struct's `rest` was `unknown` and failed
+        // the trailing rest check. A bare struct now supplies `never` there,
+        // so the fold is reachable from every schema and answered `true` for a
+        // non-inclusion.
+        presenceIsNotAbsence: () => {
+            const p = toData({ a: option(number) })
+            const q = toData(record(number))
+            assert(!subset(p)(q))
+            // the witness, and the acceptance that makes it one
+            assertEq(validate(p)({ a: undefined })[0], 'ok')
+            assertEq(validate(q)({ a: undefined })[0], 'error')
+            // both halves of the per-key check are load-bearing, and neither
+            // implies the other: this pair agrees on every present value and
+            // differs only on whether the key may be missing
+            assert(!subset(toData(record(number)))(toData(rest({ a: number }, number))))
+            assertEq(validate(toData(record(number)))({})[0], 'ok')
+            assertEq(validate(toData(rest({ a: number }, number)))({})[0], 'error')
+            // and the open-struct spelling, which was sound before, still is
+            assert(!subset(toData({ a: option(number) }))(toData(record(number))))
+        },
         objects: () => {
-            assert(subset(toData({ a: number }))(toData({})))
+            assert(subset(toData(open({ a: number })))(toData(open({}))))
             assert(subset(toData({ a: 42 }))(toData({ a: number })))
             assert(!subset(toData({ a: number }))(toData({ a: 42 })))
-            assert(subset(toData({ a: number, b: string }))(toData({ a: number })))
+            assert(subset(toData(open({ a: number, b: string })))(toData(open({ a: number }))))
             assert(subset(toData(record(number)))(toData(record(or(number, string)))))
             assert(!subset(toData(record(or(number, string))))(toData(record(number))))
             // a record's keys may be absent, a required key excludes that
-            assert(!subset(toData(record(number)))(toData({ a: number })))
-            assert(subset(toData(record(number)))(toData({ a: option(number) })))
-            // a struct leaves undeclared keys unconstrained, a record does not
-            assert(!subset(toData({ a: number }))(toData(record(number))))
+            assert(!subset(toData(record(number)))(toData(open({ a: number }))))
+            assert(subset(toData(record(number)))(toData(open({ a: option(number) }))))
+            // an open struct leaves undeclared keys unconstrained, a record
+            // does not — while a closed one names them all, so it is included
+            assert(!subset(toData(open({ a: number })))(toData(record(number))))
+            assert(subset(toData({ a: number }))(toData(record(number))))
             // a key inherited from Object.prototype is not a declared prop
             assert(!subset(toData({ a: number }))(toData({ toString: number })))
             assert(subset(toData({ toString: /** @type {const} */ (42) }))(toData({ toString: number })))
@@ -517,10 +717,43 @@ export const proof = {
             assertEq(
                 JSON.stringify(v([1, 'x'])),
                 '["error",{"path":["1"],"message":"unexpected value"}]')
-            const vt = validate(toData(/** @type {const} */ ([number, string])))
+            // an open tuple admits a longer array, and a position is required
+            // exactly when its set excludes `undefined`, so a shorter one is a
+            // member whenever the positions past its end admit absence
+            const vt = validate(toData(open(/** @type {const} */ ([number, string]))))
             assertEq(vt([1, 'a'])[0], 'ok')
-            assertEq(vt([1])[0], 'error')
-            assertEq(vt([1, 'a', 2])[0], 'error')
+            assertEq(vt([1, 'a', 2])[0], 'ok')
+            assertEq(
+                JSON.stringify(vt([1])),
+                '["error",{"path":["1"],"message":"unexpected value"}]')
+            const vo = validate(toData(open(/** @type {const} */ ([number, option(string)]))))
+            assertEq(vo([1])[0], 'ok')
+            assertEq(vo([1, 'a'])[0], 'ok')
+            assertEq(vo([])[0], 'error')
+            // the exact-length pattern admits neither, and counts a hole past
+            // the prefix: not an entry, but the array is still that long
+            const vx = validate(exactlyOneNumber)
+            assertEq(vx([1])[0], 'ok')
+            assertEq(vx([1, 2])[0], 'error')
+            assertEq(vx([])[0], 'error')
+            assertEq(vx([1, , ])[0], 'error')
+            assertEq(validate(toData(array(neverRtti)))([, ])[0], 'error')
+            assertEq(validate(toData(array(neverRtti)))([])[0], 'ok')
+            assertEq(validate(toData(array(neverRtti)))([1])[0], 'error')
+            // an enumerable non-index key is an entry the prefix has not
+            // spoken for, like an index past it: the `rest` answers it, and
+            // an exact-length pattern, having no `rest`, rejects it
+            assertEq(validate(toData(array(number)))(Object.assign([1], { foo: 2 }))[0], 'ok')
+            assertEq(validate(toData(array(number)))(Object.assign([1], { foo: 'x' }))[0], 'error')
+            assertEq(validate(toData(array(neverRtti)))(Object.assign([], { foo: 'x' }))[0], 'error')
+            assertEq(validate(exactlyOneNumber)(Object.assign([1], { foo: 1 }))[0], 'error')
+            // only the canonical spelling of a non-negative integer is a
+            // position; every other key is a property of the array object,
+            // whatever `Number` makes of it
+            for (const k of ['-1', '01', '1.5', ' 1', '1e0']) {
+                assertEq(validate(toData(array(number)))(Object.assign([1], { [k]: 'x' }))[0], 'error')
+                assertEq(validate(exactlyTwoNumbers)(Object.assign([1, 2], { [k]: 2 }))[0], 'error')
+            }
             /** @type {Data} */
             const onePlus = [{}, { array: [{ prefix: [{ number: true }], rest: { string: true } }] }]
             const vp = validate(onePlus)
@@ -536,7 +769,7 @@ export const proof = {
                 '["error",{"path":[],"message":"no match"}]')
         },
         objects: () => {
-            const v = validate(toData({ a: number, b: option(string) }))
+            const v = validate(toData(open({ a: number, b: option(string) })))
             assertEq(v({ a: 1 })[0], 'ok')
             assertEq(v({ a: 1, b: 's' })[0], 'ok')
             assertEq(v({ a: 1, extra: true })[0], 'ok')

package/fjs/types/rtti/data/types.d.ts

@@ -19,14 +19,21 @@ export type KindSet<T> = true | readonly T[];
 /**
  * A set of arrays: a tuple with an optional rest.
  *
- * - `prefix` constrains the value set of each leading position.
- * - `rest` present: the array may be any length `>= prefix.length`, and every
- *   element past the prefix belongs to `rest`.
- * - `rest` absent: the array length is exactly `prefix.length`.
+ * - `prefix` constrains, per leading position, the value *read* at that
+ *   position — a position past the array's end reads as `undefined`, so a
+ *   position is required exactly when its set excludes `undefined`. This is
+ *   the array half of the rule {@link ObjectSet} states for keys.
+ * - `rest` present: the value at every position past the prefix belongs to
+ *   `rest`.
+ * - `rest` absent: there is nothing past the prefix.
  *
- * A tuple schema is `{ prefix }`; a uniform array schema is
- * `{ prefix: [], rest }`. Both are points of the same kind, so
- * `readonly [number] ⊂ readonly number[]` is a plain pattern inclusion.
+ * A bare tuple schema is `{ prefix }` alone — the exact-length set, since
+ * tuples are closed (see "Structs and tuples are closed" in `../README.md`) —
+ * an `open` one is `{ prefix, rest: unknown }`, and a uniform array schema is
+ * `{ prefix: [], rest }`.
+ * All are points of the same kind, so a longer tuple pattern included in a
+ * shorter one is a plain pattern inclusion, the array counterpart of a wider
+ * struct included in a narrower one.
  */
 export type ArraySet = {
     readonly prefix: readonly Node[];

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

@@ -0,0 +1,33 @@
+/**
+ * The rtti readers against values **FunctionalScript cannot build**.
+ *
+ * A `proof.mjs` rather than a `proof.f.mjs`, and deliberately: the fixtures
+ * here need in-place mutation — `Object.setPrototypeOf` to give an array a
+ * prototype that supplies an index, `Object.assign` to put a key past the
+ * index range on one — which [`../../AGENTS.md`](../../AGENTS.md) §3.1 forbids
+ * in authored FunctionalScript. `shouldLoad` in
+ * [`../../dev/module.f.mjs`](../../dev/module.f.mjs) makes a plain
+ * `proof.mjs` the opt-in home for exactly that, so the mutation stays out of
+ * the `.f.mjs` proofs rather than being smuggled through them.
+ *
+ * The values are worth pinning even though the subset cannot express them: a
+ * caller in ordinary JavaScript can hand one to an exported reader, and both
+ * are cases where reading a member by *entry* and reading it by *index*
+ * disagree — which is what these readers had wrong.
+ *
+ * @module
+ *
+ * @import { Type } from './types.ts'
+ * @import { ValidateE } from './common/types.ts'
+ * @import { Unknown } from './ts/types.ts'
+ */
+export declare const proof: {
+    undeclaredMembers: {
+        inheritedIndexIsAMember: () => void;
+        shadowedIndexIsTheOwnOne: () => void;
+        beyondTheIndexRangeIsAMember: () => void;
+    };
+    readersAgree: () => void;
+    inheritedIndexMeetsTheRest: () => void;
+    beyondTheIndexRangeIsAMember: () => void;
+};