functionalscript 0.46.1 → 0.47.0

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

@@ -3,7 +3,7 @@
  * @import { Data } from '../../../types/rtti/data/types.ts'
  */
 
-import { boolean, number, string, bigint, never, unknown, array, record, or, option } from '../../../types/rtti/module.f.mjs'
+import { boolean, number, string, bigint, never, unknown, array, open, record, or, option } from '../../../types/rtti/module.f.mjs'
 import { stringify } from '../module.f.mjs'
 import { dataToJsonSchema, toJsonSchema, unknown as schemaUnknown } from './module.f.mjs'
 import { unitBit } from '../../../types/rtti/data/module.f.mjs'
@@ -80,37 +80,77 @@ export const proof = {
     record: eq(record(string), { type: 'object', additionalProperties: { type: 'string' } }),
     // `anyOf` members follow the canonical kind order, not the operand order
     or: eq(or(string, number), { anyOf: [{ type: 'number' }, { type: 'string' }] }),
-    tuple: eq(/** @type {const} */ ([number, string]), {
-        type: 'array',
-        prefixItems: [{ type: 'number' }, { type: 'string' }],
-        minItems: 2,
-        items: false,
-    }),
+    // A bare tuple is closed, which JSON Schema spells `items: false`; a
+    // position admitting `undefined` may be absent instead, which is
+    // `minItems`. `open` is what admits what follows the prefix, and prints
+    // the unconstrained `items: {}`.
+    tuple: {
+        allRequired: eq(/** @type {const} */ ([number, string]), {
+            type: 'array',
+            prefixItems: [{ type: 'number' }, { type: 'string' }],
+            minItems: 2,
+            items: false,
+        }),
+        withOptional: eq(/** @type {const} */ ([number, option(string)]), {
+            type: 'array',
+            prefixItems: [{ type: 'number' }, { type: 'string' }],
+            minItems: 1,
+            items: false,
+        }),
+        allOptional: eq(/** @type {const} */ ([option(number)]), {
+            type: 'array',
+            prefixItems: [{ type: 'number' }],
+            items: false,
+        }),
+        open: eq(open(/** @type {const} */ ([number, string])), {
+            type: 'array',
+            prefixItems: [{ type: 'number' }, { type: 'string' }],
+            minItems: 2,
+            items: {},
+        }),
+    },
+    // The same on the other kind: a bare struct names every key it admits,
+    // which is `additionalProperties: { not: {} }`.
     struct: {
         allRequired: eq(/** @type {const} */ ({ x: number, y: string }), {
             type: 'object',
             properties: { x: { type: 'number' }, y: { type: 'string' } },
             required: ['x', 'y'],
+            additionalProperties: { not: {} },
         }),
         withOptional: eq(/** @type {const} */ ({ x: number, y: option(string) }), {
             type: 'object',
             properties: { x: { type: 'number' }, y: { type: 'string' } },
             required: ['x'],
+            additionalProperties: { not: {} },
         }),
         allOptional: eq(/** @type {const} */ ({ x: option(number) }), {
             type: 'object',
             properties: { x: { type: 'number' } },
+            additionalProperties: { not: {} },
+        }),
+        // a closed struct declaring nothing is the empty object
+        empty: eq(/** @type {const} */ ({}), {
+            type: 'object',
+            additionalProperties: { not: {} },
         }),
         // an unconstrained struct is the whole object kind
-        empty: eq(/** @type {const} */ ({}), { type: 'object' }),
+        openEmpty: eq(open(/** @type {const} */ ({})), { type: 'object' }),
+        open: eq(open(/** @type {const} */ ({ x: number, y: string })), {
+            type: 'object',
+            properties: { x: { type: 'number' }, y: { type: 'string' } },
+            required: ['x', 'y'],
+        }),
         orOptional: eq(/** @type {const} */ ({ x: or(string, number, undefined) }), {
             type: 'object',
             properties: { x: { anyOf: [{ type: 'number' }, { type: 'string' }] } },
+            additionalProperties: { not: {} },
         }),
         withConst: eq(/** @type {const} */ ({ x: null, y: string }), {
             type: 'object',
             properties: { x: { const: null }, y: { type: 'string' } },
             required: ['x', 'y'],
+            additionalProperties: { not: {} },
         }),
         optionalOfEveryKind: eq(/** @type {const} */ ({
             a: option(number),
@@ -129,6 +169,7 @@ export const proof = {
                 e: { type: 'object', additionalProperties: { type: 'string' } },
                 f: { const: null },
             },
+            additionalProperties: { not: {} },
         }),
     },
     schemaUnknownTag: () => {
@@ -140,7 +181,7 @@ export const proof = {
             type: 'array',
             items: { type: 'object', additionalProperties: { type: 'boolean' } },
         }),
-        orWithConst: eq(or(null, string, /** @type {const} */ (42)), {
+        orWithConst: eq(or(null, string, 42), {
             anyOf: [{ const: null }, { const: 42 }, { type: 'string' }],
         }),
         structWithOr: eq(/** @type {const} */ ({ id: or(string, number), name: option(string) }), {
@@ -150,7 +191,10 @@ export const proof = {
                 name: { type: 'string' },
             },
             required: ['id'],
+            additionalProperties: { not: {} },
         }),
+        // the top position is required — the array cannot end before the
+        // `number` after it — so its `undefined` is not stripped away
         topInsideTuple: eq(/** @type {const} */ ([unknown, number]), {
             type: 'array',
             prefixItems: [{}, { type: 'number' }],
@@ -163,15 +207,41 @@ export const proof = {
         unitMembers: eq(or(null, undefined, true), {
             anyOf: [{ const: null }, { not: {} }, { const: true }],
         }),
-        literalAbsorbed: eq(or(/** @type {const} */ (42), number), { type: 'number' }),
-        duplicateLiteral: eq(or(/** @type {const} */ (1), /** @type {const} */ (1)), { const: 1 }),
+        literalAbsorbed: eq(or(42, number), { type: 'number' }),
+        duplicateLiteral: eq(or(1, 1), { const: 1 }),
         never: eq(never, { not: {} }),
+        // a closed tuple declaring nothing is the empty array
         emptyTuple: eq(/** @type {const} */ ([]), { type: 'array', items: false }),
-        // `readonly [number] ⊂ readonly number[]` — the tuple pattern is dropped
-        coverageCollapse: eq(or(/** @type {const} */ ([number]), array(number)), {
-            type: 'array',
-            items: { type: 'number' },
-        }),
+        // an open one declaring nothing is the whole array kind
+        openEmptyTuple: eq(open(/** @type {const} */ ([])), { type: 'array' }),
+        // a longer tuple pattern is included in a shorter one when both are
+        // open; closed, the two lengths are disjoint and both patterns stay
+        coverageCollapse: eq(
+            or(open([number, number]), open([number])),
+            {
+                type: 'array',
+                prefixItems: [{ type: 'number' }],
+                minItems: 1,
+                items: {},
+            }),
+        noCollapseWhenClosed: eq(
+            or(/** @type {const} */ ([number, number]), /** @type {const} */ ([number])),
+            {
+                anyOf: [
+                    {
+                        type: 'array',
+                        prefixItems: [{ type: 'number' }],
+                        minItems: 1,
+                        items: false,
+                    },
+                    {
+                        type: 'array',
+                        prefixItems: [{ type: 'number' }, { type: 'number' }],
+                        minItems: 2,
+                        items: false,
+                    },
+                ],
+            }),
         commutative: () => {
             const a = serialize(toJsonSchema(or(string, number)))
             const b = serialize(toJsonSchema(or(number, string)))
@@ -193,6 +263,7 @@ export const proof = {
         optionalRecursiveProperty: eq(/** @type {const} */ ({ p: option(list) }), {
             type: 'object',
             properties: { p: { type: 'array', items: listRef } },
+            additionalProperties: { not: {} },
             $defs: { list: listDef },
         }),
         revisionLock: eq(lock, {
@@ -215,6 +286,7 @@ export const proof = {
                 type: 'object',
                 properties: { name: { type: 'string' } },
                 required: ['name'],
+                additionalProperties: { not: {} },
             }
             eq(/** @type {const} */ ([person, person]), {
                 type: 'array',

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

@@ -24,36 +24,14 @@ import { codePointToString, stringToCodePointList } from '../../../text/utf16/mo
 import { errorMask } from '../../../text/code_point/module.f.mjs'
 import { definedEntries, isObject } from '../../../types/object/module.f.mjs'
 import { compose, fn } from '../../../types/function/module.f.mjs'
-import {
-    backspace,
-    cr,
-    ff,
-    hexDigitCodePoint,
-    ht,
-    lf,
-    quotationMark,
-    reverseSolidus,
-    space,
-} from '../../../text/ascii/module.f.mjs'
+import { hexDigitCodePoint, space } from '../../../text/ascii/module.f.mjs'
+import { codePointToEscape } from '../../../js/string_escape/module.f.mjs'
+import { map as nullableMap } from '../../../types/nullable/module.f.mjs'
 
 const jsonStringify = JSON.stringify
 
 const { fromCharCode } = String
 
-/**
- * The code points JSON gives a two-character escape. Every other code point
- * below `space` has no short form and goes through `unicodeEscape` instead.
- */
-const escapeTable = /** @type {const} */ ({
-    [backspace]: '\\b',
-    [ht]: '\\t',
-    [lf]: '\\n',
-    [ff]: '\\f',
-    [cr]: '\\r',
-    [quotationMark]: '\\"',
-    [reverseSolidus]: '\\\\',
-})
-
 /** @type {(value: number) => string} */
 const hexDigit = value => fromCharCode(hexDigitCodePoint(value))
 
@@ -65,6 +43,16 @@ const hexDigit = value => fromCharCode(hexDigitCodePoint(value))
 const unicodeEscape = unit =>
     `\\u${hexDigit(unit >> 12 & 0xf)}${hexDigit(unit >> 8 & 0xf)}${hexDigit(unit >> 4 & 0xf)}${hexDigit(unit & 0xf)}`
 
+/**
+ * The two-character escape a letter spells, projected over the lookup's
+ * `null`. Bound here rather than inside `escapeCodePoint`: it depends on
+ * nothing that varies per code point, and `escapeCodePoint` runs once per
+ * character of every string serialized.
+ *
+ * @type {(letter: number | null) => string | null}
+ */
+const simpleEscape = nullableMap(letter => `\\${codePointToString(letter)}`)
+
 /**
  * Escapes one decoded code point. A code point tagged with `errorMask` is an
  * unpaired surrogate, which well-formed JSON stringification (ES2019) emits as
@@ -76,7 +64,7 @@ const unicodeEscape = unit =>
 const escapeCodePoint = codePoint =>
     (codePoint & errorMask) !== 0
         ? unicodeEscape(codePoint & 0xffff)
-        : escapeTable[codePoint]
+        : simpleEscape(codePointToEscape(codePoint))
             ?? (codePoint < space ? unicodeEscape(codePoint) : codePointToString(codePoint))
 
 /**

package/fjs/media/json/types.d.ts

@@ -5,7 +5,7 @@
  * `Unknown` is written by hand rather than derived, so that the recursion
  * reads directly, and is then pinned against the rtti schemas in the sibling
  * [`./rtti/module.f.mjs`](./rtti/module.f.mjs) with
- * `Assert<Equal<Unknown, Ts<typeof unknown>>>`. The pin is what keeps the two
+ * `Assert<Check<Unknown, typeof unknown>>`. The pin is what keeps the two
  * descriptions of the same data model from drifting apart — and it holds the
  * `Tree<Primitive>` spelling to the same data model the schemas describe.
  *

package/fjs/media/lock/module.f.d.mts

@@ -41,7 +41,12 @@ export declare const dialect: 'vnd.fjs.lock';
 /** The media type derived from {@link dialect}: `application/vnd.fjs.lock+json`. */
 export declare const mediaType: "application/vnd.fjs.lock+json";
 /**
- * rtti schema for a `lock` BLOB: the dialect tag and the map, nothing else.
+ * rtti schema for a `lock` BLOB: the dialect tag and the map.
+ *
+ * `open`, and deliberately so: a bare struct is closed, so an older reader
+ * would reject a blob a newer writer had added a field to, and the versioning
+ * rule in `../revision/README.md` — additive extension keeps the tag — needs
+ * that older reader to accept it. Do not drop the wrapper.
  *
  * `lock` is `fjs/media/revision`'s own schema, so the shared form admits
  * exactly the maps the inline form does, to the same depth, with the same
@@ -54,10 +59,10 @@ export declare const mediaType: "application/vnd.fjs.lock+json";
  * [Composition](./README.md#composition)), so following a reference always
  * terminates in one step.
  */
-export declare const lockSchema: {
+export declare const lockSchema: import("../../types/rtti/types.ts").Rest<{
     readonly dialect: "vnd.fjs.lock";
     readonly lock: import("../revision/types.ts").LockSchema;
-};
+}, import("../../types/rtti/types.ts").Unknown>;
 /** Serializes a lock blob canonically, recursively sorting every object's property names.
  * @type {(lock: Lock) => string}
  */

package/fjs/media/lock/module.f.mjs

@@ -30,6 +30,7 @@
  * @import { Lock, LockError } from './types.ts'
  */
 
+import { open } from '../../types/rtti/module.f.mjs'
 import { parse as rttiParse } from '../../types/rtti/parse/module.f.mjs'
 import { parse as parseJson, stringify } from '../json/module.f.mjs'
 import { error, ok, okThen } from '../../types/result/module.f.mjs'
@@ -47,7 +48,12 @@ export const dialect = /** @type {const} */ ('vnd.fjs.lock')
 export const mediaType = /** @type {const} */ (`application/${dialect}+json`)
 
 /**
- * rtti schema for a `lock` BLOB: the dialect tag and the map, nothing else.
+ * rtti schema for a `lock` BLOB: the dialect tag and the map.
+ *
+ * `open`, and deliberately so: a bare struct is closed, so an older reader
+ * would reject a blob a newer writer had added a field to, and the versioning
+ * rule in `../revision/README.md` — additive extension keeps the tag — needs
+ * that older reader to accept it. Do not drop the wrapper.
  *
  * `lock` is `fjs/media/revision`'s own schema, so the shared form admits
  * exactly the maps the inline form does, to the same depth, with the same
@@ -60,10 +66,10 @@ export const mediaType = /** @type {const} */ (`application/${dialect}+json`)
  * [Composition](./README.md#composition)), so following a reference always
  * terminates in one step.
  */
-export const lockSchema = /** @type {const} */ ({
+export const lockSchema = open(/** @type {const} */ ({
     dialect,
     lock,
-})
+}))
 
 /** Serializes a lock blob canonically, recursively sorting every object's property names.
  * @type {(lock: Lock) => string}

package/fjs/media/lock/proof.f.d.mts

@@ -1,6 +1,6 @@
 /**
  * @import { Object as JsonObject } from '../json/types.ts'
- * @import { LockMap } from './types.ts'
+ * @import { LockMap } from '../revision/types.ts'
  */
 export declare const proof: {
     dialectAndMediaType: () => void;

package/fjs/media/lock/proof.f.mjs

@@ -1,6 +1,6 @@
 /**
  * @import { Object as JsonObject } from '../json/types.ts'
- * @import { LockMap } from './types.ts'
+ * @import { LockMap } from '../revision/types.ts'
  */
 
 import { assert, assertEq } from '../../asserts/module.f.mjs'
@@ -89,7 +89,7 @@ export const proof = {
         },
 
         // No `subject`, `parents`, `generation` or `archived`: this dialect is
-        // a value, not a step. rtti structs are open, so such fields are
+        // a value, not a step. `lockSchema` says `open`, so such fields are
         // ignored rather than rejected — the additive forward-compatibility
         // path, the same one the revision dialect relies on.
         revisionFieldsIgnored: () => {

package/fjs/media/lock/types.d.ts

@@ -2,13 +2,11 @@
  * Type-level API for `fjs/media/lock/module.f.mjs`: `Lock` and `LockError`.
  *
  * The map type itself is not restated here — it is `fjs/media/revision`'s
- * `LockMap`, re-exported so a consumer of the shared form needs only one
- * import, and so nothing can define a second, drifting spelling of it.
+ * `LockMap`; import it from there directly rather than through this module.
  */
 import type { ValidationError } from '../../types/rtti/common/types.ts';
 import type { Ts } from '../../types/rtti/ts/types.ts';
 import type { lockSchema } from './module.f.mjs';
-export type { LockMap } from '../revision/types.ts';
 /** The TypeScript type derived from `lockSchema` — the single source of truth. */
 export type Lock = Ts<typeof lockSchema>;
 /** Either a structural validation error or a semantic (hash) error message. */

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

@@ -44,14 +44,14 @@
  *
  * @import { Vec } from '../types/bit_vec/types.ts'
  * @import { DetectMeta } from './type/types.ts'
- * @import { Struct } from '../types/rtti/types.ts'
+ * @import { Rest, Struct, Type } from '../types/rtti/types.ts'
  * @import { Ts, Unknown } from '../types/rtti/ts/types.ts'
- * @import { Validate } from '../types/rtti/common/types.ts'
+ * @import { ValidateE } from '../types/rtti/common/types.ts'
  * @import { DialectEntry } from './types.ts'
  */
 import type { Vec } from '../types/bit_vec/types.ts';
 import type { DetectMeta } from './type/types.ts';
-import type { Struct } from '../types/rtti/types.ts';
+import type { Rest, Struct, Type } from '../types/rtti/types.ts';
 import type { Ts } from '../types/rtti/ts/types.ts';
 import type { DialectEntry } from './types.ts';
 /**
@@ -87,21 +87,28 @@ import type { DialectEntry } from './types.ts';
  * not.) Registering a name that is not a valid RFC 6838 restricted-name yields
  * a malformed media type in the registrant's own results, and nowhere else.
  *
- * The constraint is `Struct` — every member must be a real rtti `Type`, which
- * is what rejects a member like `() => 42` at compile time (rtti would read it
- * as a thunk and `match` would *throw* on the first blob rather than return
- * `false`). TypeScript cannot also require a direct string `dialect` member
- * under that constraint, so that half is asserted here instead: loudly, once,
- * when the entry is constructed. A thunk-form `dialect`
+ * The container's constraint is `Struct` — every member must be a real rtti
+ * `Type`, which is what rejects a member like `() => 42` at compile time (rtti
+ * would read it as a thunk and `match` would *throw* on the first blob rather
+ * than return `false`). TypeScript cannot also require a direct string
+ * `dialect` member under that constraint, so that half is asserted here
+ * instead: loudly, once, when the entry is constructed. A thunk-form `dialect`
  * (`() => ['const', 'x']`) is a perfectly valid rtti schema, it just is not
  * registerable — write the string directly, as `revisionSchema` does.
  *
- * @template {Struct} T
- * @param {T} type
- * @param {(_: Ts<T>) => boolean} [extraValidate]
+ * The schema is a **container with a stated rest** rather than a bare struct,
+ * and every dialect in this repo states `open`. A bare struct is closed, so an
+ * older reader would reject a blob a newer writer had added a field to, which
+ * is precisely the fail-closed misread the additive-extension rule in
+ * `./revision/README.md` exists to avoid. Requiring the wrapper here is what
+ * makes that a decision a registrant states rather than one they inherit.
+ *
+ * @template {Struct} S
+ * @param {Rest<S, Type>} type
+ * @param {(_: Ts<S>) => boolean} [extraValidate]
  * @returns {DialectEntry}
  */
-export declare const dialectEntry: <T extends Struct>(type: T, extraValidate?: (_: Ts<T>) => boolean) => DialectEntry;
+export declare const dialectEntry: <S extends Struct>(type: Rest<S, Type>, extraValidate?: (_: Ts<S>) => boolean) => DialectEntry;
 /**
  * Classifies a whole buffered `Vec` against `dialects`, returning the same
  * three-way `{ length, mime_type, type }` shape as `fjs/media/type`

package/fjs/media/module.f.mjs

@@ -44,9 +44,9 @@
  *
  * @import { Vec } from '../types/bit_vec/types.ts'
  * @import { DetectMeta } from './type/types.ts'
- * @import { Struct } from '../types/rtti/types.ts'
+ * @import { Rest, Struct, Type } from '../types/rtti/types.ts'
  * @import { Ts, Unknown } from '../types/rtti/ts/types.ts'
- * @import { Validate } from '../types/rtti/common/types.ts'
+ * @import { ValidateE } from '../types/rtti/common/types.ts'
  * @import { DialectEntry } from './types.ts'
  */
 
@@ -61,9 +61,13 @@ const always = () => true
 
 /**
  * Structural validation followed by the dialect's own refinement.
- * @template {Struct} T
- * @param {Validate<T>} v
- * @returns {(extraValidate: (_: Ts<T>) => boolean) => (u: Unknown) => boolean}
+ *
+ * Typed over the **erased** `ValidateE`: a `T extends Type` template would
+ * instantiate `Ts<Type>` here and raise TS2589. {@link dialectEntry} states
+ * the precise `extraValidate` type its callers are held to.
+ *
+ * @param {ValidateE} v
+ * @returns {(extraValidate: (_: any) => boolean) => (u: Unknown) => boolean}
  */
 const matchWith = v => extraValidate => u => {
     const [tag, value] = v(u)
@@ -103,24 +107,33 @@ const matchWith = v => extraValidate => u => {
  * not.) Registering a name that is not a valid RFC 6838 restricted-name yields
  * a malformed media type in the registrant's own results, and nowhere else.
  *
- * The constraint is `Struct` — every member must be a real rtti `Type`, which
- * is what rejects a member like `() => 42` at compile time (rtti would read it
- * as a thunk and `match` would *throw* on the first blob rather than return
- * `false`). TypeScript cannot also require a direct string `dialect` member
- * under that constraint, so that half is asserted here instead: loudly, once,
- * when the entry is constructed. A thunk-form `dialect`
+ * The container's constraint is `Struct` — every member must be a real rtti
+ * `Type`, which is what rejects a member like `() => 42` at compile time (rtti
+ * would read it as a thunk and `match` would *throw* on the first blob rather
+ * than return `false`). TypeScript cannot also require a direct string
+ * `dialect` member under that constraint, so that half is asserted here
+ * instead: loudly, once, when the entry is constructed. A thunk-form `dialect`
  * (`() => ['const', 'x']`) is a perfectly valid rtti schema, it just is not
  * registerable — write the string directly, as `revisionSchema` does.
  *
- * @template {Struct} T
- * @param {T} type
- * @param {(_: Ts<T>) => boolean} [extraValidate]
+ * The schema is a **container with a stated rest** rather than a bare struct,
+ * and every dialect in this repo states `open`. A bare struct is closed, so an
+ * older reader would reject a blob a newer writer had added a field to, which
+ * is precisely the fail-closed misread the additive-extension rule in
+ * `./revision/README.md` exists to avoid. Requiring the wrapper here is what
+ * makes that a decision a registrant states rather than one they inherit.
+ *
+ * @template {Struct} S
+ * @param {Rest<S, Type>} type
+ * @param {(_: Ts<S>) => boolean} [extraValidate]
  * @returns {DialectEntry}
  */
 export const dialectEntry = (type, extraValidate = always) => {
-    const { dialect } = type
+    const [, container] = type()
+    const { dialect } = /** @type {Struct} */ (container)
     assert(typeof dialect === 'string', 'dialectEntry: schema has no direct string `dialect` member')
-    return { dialect, match: matchWith(rttiParse(type))(extraValidate) }
+    const v = /** @type {ValidateE} */ (rttiParse(type))
+    return { dialect, match: matchWith(v)(extraValidate) }
 }
 
 /**

package/fjs/media/note/module.f.d.mts

@@ -5,10 +5,10 @@
  * The format is deliberately minimal: the dialect tag, the text, and
  * optionally the subjects the item depends on and a priority. Everything
  * else a richer item needs — a title, tags, dates, a status — is a future
- * **optional** field:
- * rtti structs are open, so additive extension keeps the tag (see the
- * versioning rule in `fjs/media/revision/README.md`), and starting minimal is
- * what keeps every extension additive.
+ * **optional** field: {@link noteSchema} says `open`, so an older reader
+ * accepts a blob a newer writer has added fields to and additive extension
+ * keeps the tag (see the versioning rule in `fjs/media/revision/README.md`),
+ * and starting minimal is what keeps every extension additive.
  *
  * Like `vnd.fjs.lock`, a note is a **value**, not a step: no timestamps, no
  * author, no history of its own. Edits over time are ordinary
@@ -85,12 +85,19 @@ export declare const mediaType: "application/vnd.fjs.note+json";
  * rather than misreading it.
  */
 export declare const priorities: readonly ['P1', 'P2', 'P3', 'P4', 'P5'];
-export declare const noteSchema: {
+/**
+ * `open`, and that is the extension strategy rather than a default: a bare
+ * struct is closed, so an older reader would reject a blob a newer writer had
+ * added a field to, and the versioning rule in
+ * `../revision/README.md` — additive extension keeps the tag — depends on the
+ * older reader accepting it. Do not drop the wrapper.
+ */
+export declare const noteSchema: import("../../types/rtti/types.ts").Rest<{
     readonly dialect: "vnd.fjs.note";
     readonly text: import("../../types/rtti/types.ts")._Type0<"string">;
     readonly dependencies: import("../../types/rtti/types.ts").Or<readonly [import("../../types/rtti/types.ts").Type1<"array", import("../../types/rtti/types.ts")._Type0<"string">>, undefined]>;
-    readonly priority: import("../../types/rtti/types.ts").Or<readonly [import("../../types/rtti/types.ts").Or<["P1", "P2", "P3", "P4", "P5"]>, undefined]>;
-};
+    readonly priority: import("../../types/rtti/types.ts").Or<readonly [import("../../types/rtti/types.ts").Or<readonly ["P1", "P2", "P3", "P4", "P5"]>, undefined]>;
+}, import("../../types/rtti/types.ts").Unknown>;
 /** Serializes a note canonically, sorting every object's property names.
  * @type {(note: Note) => string}
  */

package/fjs/media/note/module.f.mjs

@@ -5,10 +5,10 @@
  * The format is deliberately minimal: the dialect tag, the text, and
  * optionally the subjects the item depends on and a priority. Everything
  * else a richer item needs — a title, tags, dates, a status — is a future
- * **optional** field:
- * rtti structs are open, so additive extension keeps the tag (see the
- * versioning rule in `fjs/media/revision/README.md`), and starting minimal is
- * what keeps every extension additive.
+ * **optional** field: {@link noteSchema} says `open`, so an older reader
+ * accepts a blob a newer writer has added fields to and additive extension
+ * keeps the tag (see the versioning rule in `fjs/media/revision/README.md`),
+ * and starting minimal is what keeps every extension additive.
  *
  * Like `vnd.fjs.lock`, a note is a **value**, not a step: no timestamps, no
  * author, no history of its own. Edits over time are ordinary
@@ -32,7 +32,7 @@
  * @import { Note, NoteError } from './types.ts'
  */
 
-import { array, option, or, string } from '../../types/rtti/module.f.mjs'
+import { array, open, option, or, string } from '../../types/rtti/module.f.mjs'
 import { parse as rttiParse } from '../../types/rtti/parse/module.f.mjs'
 import { parse as parseJson, stringify } from '../json/module.f.mjs'
 import { okThen } from '../../types/result/module.f.mjs'
@@ -91,12 +91,19 @@ export const mediaType = /** @type {const} */ (`application/${dialect}+json`)
  */
 export const priorities = /** @type {const} */ (['P1', 'P2', 'P3', 'P4', 'P5'])
 
-export const noteSchema = /** @type {const} */ ({
+/**
+ * `open`, and that is the extension strategy rather than a default: a bare
+ * struct is closed, so an older reader would reject a blob a newer writer had
+ * added a field to, and the versioning rule in
+ * `../revision/README.md` — additive extension keeps the tag — depends on the
+ * older reader accepting it. Do not drop the wrapper.
+ */
+export const noteSchema = open(/** @type {const} */ ({
     dialect,
     text: string,
     dependencies: option(array(string)),
     priority: option(or(...priorities)),
-})
+}))
 
 /** Serializes a note canonically, sorting every object's property names.
  * @type {(note: Note) => string}

package/fjs/media/note/proof.f.mjs

@@ -89,7 +89,7 @@ export const proof = {
             assertEq(t, 'error')
         },
 
-        // rtti structs are open, so unknown fields are ignored rather than
+        // `noteSchema` says `open`, so unknown fields are ignored rather than
         // rejected — the additive forward-compatibility path every future
         // extension (title, tags, dates, …) relies on.
         unknownFieldsIgnored: () => {

package/fjs/media/proof.f.mjs

@@ -8,7 +8,7 @@ import { detect, dialectEntry } from './module.f.mjs'
 import { dialect, revisionDialect } from './revision/module.f.mjs'
 import { dialect as lockDialectName, lockDialect } from './lock/module.f.mjs'
 import { dialect as noteDialectName, noteDialect } from './note/module.f.mjs'
-import { number, string } from '../types/rtti/module.f.mjs'
+import { number, open, string } from '../types/rtti/module.f.mjs'
 
 // All test strings here are ASCII, so char code === UTF-8 byte value.
 /** @type {(s: string) => Vec} */
@@ -24,10 +24,10 @@ const dialects = [revisionDialect, lockDialect, noteDialect]
 const detectRevision = detect(dialects)
 
 /** A dialect name outside `vnd.fjs.*` — registerable, and detected as itself. */
-const gadgetSchema = /** @type {const} */ ({
+const gadgetSchema = open(/** @type {const} */ ({
     dialect: 'application.gadget',
     size: number,
-})
+}))
 
 /** @type {DialectEntry} */
 const gadgetDialect = dialectEntry(gadgetSchema)
@@ -170,9 +170,9 @@ export const proof = {
         // The `dialect` member must be a direct string const. A thunk-form one
         // is a valid rtti schema but is not registerable, and `dialectEntry`
         // says so at registration rather than per blob.
-        thunkDialectMember: () => dialectEntry({ dialect: string }),
+        thunkDialectMember: () => dialectEntry(open({ dialect: string })),
 
         // A schema with no `dialect` member at all is likewise refused.
-        noDialectMember: () => dialectEntry({ text: string }),
+        noDialectMember: () => dialectEntry(open({ text: string })),
     },
 }