functionalscript 0.45.0 → 0.46.0

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

@@ -1,12 +1,13 @@
 /**
  * TypeScript counterparts of the JSON data model: `Primitive`, `Unknown`,
- * `Object`, and `Array`.
+ * `Object`, and `Array`, plus the leaf-parameterized `Tree` they instantiate.
  *
  * `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
- * descriptions of the same data model from drifting apart.
+ * descriptions of the same data model from drifting apart — and it holds the
+ * `Tree<Primitive>` spelling to the same data model the schemas describe.
  *
  * @module
  */
@@ -14,12 +15,37 @@ import type { Entry as ObjectEntry } from '../../types/object/types.ts';
 import type { Ts } from '../../types/rtti/ts/types.ts';
 import type { primitive } from './rtti/module.f.mjs';
 import type { List } from '../../types/list/types.ts';
-export type Primitive = Ts<typeof primitive>;
-export type Unknown = Object | Array | Primitive;
-export type Object = {
-    readonly [k in string]?: Unknown;
+/**
+ * A recursive JSON-shaped tree over a leaf type `P`: JSON's container
+ * structure with its primitive set left open.
+ *
+ * The parser and the serializer are written once against this shape and are
+ * instantiated per numeric policy — `Tree<Primitive>` is ordinary JSON,
+ * `Tree<ExtendedPrimitive>` (see
+ * [`./extended/types.ts`](./extended/types.ts)) adds `bigint` to the leaves.
+ *
+ * `TreeObject`'s index signature is **optional** on purpose: reading an
+ * arbitrary key off a JSON-shaped object yields `undefined` when the property
+ * is absent, and `undefined` is not a leaf of any of these trees. A required
+ * index signature would type every missing property as a value.
+ */
+export type Tree<P> = P | TreeObject<P> | TreeArray<P>;
+export type TreeObject<P> = {
+    readonly [k in string]?: Tree<P>;
 };
-export type Array = readonly Unknown[];
-export type Entry = ObjectEntry<Unknown>;
-export type _Entries = List<Entry>;
-export type _MapEntries = (entries: _Entries) => _Entries;
+export type TreeArray<P> = readonly Tree<P>[];
+export type Primitive = Ts<typeof primitive>;
+export type Unknown = Tree<Primitive>;
+export type Object = TreeObject<Primitive>;
+export type Array = TreeArray<Primitive>;
+export type TreeEntry<P> = ObjectEntry<Tree<P>>;
+export type TreeEntries<P> = List<TreeEntry<P>>;
+/**
+ * How a serializer orders an object's entries — `sort` for canonical output,
+ * `identity` to keep insertion order. It is a per-leaf-type alias only because
+ * the entries it reorders carry the tree's own leaves.
+ */
+export type TreeMapEntries<P> = (entries: TreeEntries<P>) => TreeEntries<P>;
+export type Entry = TreeEntry<Primitive>;
+export type _Entries = TreeEntries<Primitive>;
+export type _MapEntries = TreeMapEntries<Primitive>;

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

@@ -0,0 +1,100 @@
+/**
+ * `vnd.fjs.lock` — a lock map as a BLOB of its own, so several revisions can
+ * point at one agreed resolution instead of each carrying a copy.
+ *
+ * `vnd.fjs.revision`'s `lock` is an inline map, which keeps a revision
+ * interpretable in isolation but re-serializes the whole map into a new blob
+ * every time anything else about the revision changes — CAS deduplicates whole
+ * blobs, not fragments. This dialect is that map, alone: no `subject`,
+ * `parents`, `generation`, or `archived`, because it is a **value**, not a
+ * step. History for lock content, when someone wants it, is an ordinary
+ * revision whose `snapshot` is one of these blobs, so no second history
+ * mechanism appears and `revision` stays the only one.
+ *
+ * The `lock` schema and its semantic check are **imported** from
+ * `fjs/media/revision`, not restated: one recursive schema, one hash check,
+ * one canonical serialization, so a map means the same thing inline and shared
+ * and the two forms cannot drift (`proof.f.mjs` pins the bytes).
+ *
+ * Like its sibling, this module is the pure format only: the rtti schema, the
+ * `dialect` tag, and decode/validate. Whether a referenced blob exists, and
+ * what its bindings mean once fetched, stay a resolver's business.
+ *
+ * See `README.md` for the full spec.
+ *
+ * @module
+ *
+ * @import { Unknown } from '../json/types.ts'
+ * @import { Result } from '../../types/result/types.ts'
+ * @import { DialectEntry } from '../types.ts'
+ * @import { Lock, LockError } from './types.ts'
+ */
+import type { Unknown } from '../json/types.ts';
+import type { Result } from '../../types/result/types.ts';
+import type { DialectEntry } from '../types.ts';
+import type { Lock, LockError } from './types.ts';
+/**
+ * Format tag: names the dialect of this BLOB. The media type it is served
+ * with is derived mechanically: `application/` + `dialect` + `+json`.
+ */
+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.
+ *
+ * `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
+ * value domain.
+ *
+ * The field is **required** and may be `{}`: an absent map and an empty one
+ * would otherwise be two spellings of one blob, and a blob whose only purpose
+ * is to hold a map has nothing to say when it does not. It is also never a
+ * hash — a lock blob does not reference further lock blobs (see the README's
+ * [Composition](./README.md#composition)), so following a reference always
+ * terminates in one step.
+ */
+export declare const lockSchema: {
+    readonly dialect: "vnd.fjs.lock";
+    readonly lock: import("../revision/types.ts").LockSchema;
+};
+/** Serializes a lock blob canonically, recursively sorting every object's property names.
+ * @type {(lock: Lock) => string}
+ */
+export declare const encodeText: (lock: Lock) => string;
+/**
+ * Checks the semantic refinement the structural schema can't express on an
+ * already shape-valid lock blob: every direct value at every depth of the map
+ * must decode as a cbase32 hash. This is `fjs/media/revision`'s own
+ * `lockMapError`, so a map rejected inline is rejected here and vice versa.
+ *
+ * Exported separately from {@link validate} for callers holding an
+ * already-typed `Lock` — the same split, for the same reason, as the revision
+ * dialect's `checkReferences`.
+ *
+ * @type {(l: Lock) => Result<Lock, string>}
+ */
+export declare const checkReferences: (l: Lock) => Result<Lock, string>;
+/**
+ * Validates an already-parsed JSON value as a `lock` BLOB: structural (rtti)
+ * validation followed by the hash semantic check.
+ *
+ * @type {(value: Unknown) => Result<Lock, LockError>}
+ */
+export declare const validate: (value: Unknown) => Result<Lock, LockError>;
+/**
+ * Decodes `text` as a `lock` BLOB: JSON-parses it, then validates it per
+ * {@link validate}. Detection is semantic, not syntactic — any JSON that
+ * satisfies the schema is a lock blob, regardless of key order or whitespace.
+ *
+ * @type {(text: string) => Result<Lock, LockError>}
+ */
+export declare const decodeText: (text: string) => Result<Lock, LockError>;
+/**
+ * This dialect as a registry entry for `fjs/media`'s `detect`. It carries the
+ * semantic check too, so a blob is detected as `vnd.fjs.lock` exactly when
+ * {@link decodeText} would accept it.
+ *
+ * @type {DialectEntry}
+ */
+export declare const lockDialect: DialectEntry;

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

@@ -0,0 +1,125 @@
+/**
+ * `vnd.fjs.lock` — a lock map as a BLOB of its own, so several revisions can
+ * point at one agreed resolution instead of each carrying a copy.
+ *
+ * `vnd.fjs.revision`'s `lock` is an inline map, which keeps a revision
+ * interpretable in isolation but re-serializes the whole map into a new blob
+ * every time anything else about the revision changes — CAS deduplicates whole
+ * blobs, not fragments. This dialect is that map, alone: no `subject`,
+ * `parents`, `generation`, or `archived`, because it is a **value**, not a
+ * step. History for lock content, when someone wants it, is an ordinary
+ * revision whose `snapshot` is one of these blobs, so no second history
+ * mechanism appears and `revision` stays the only one.
+ *
+ * The `lock` schema and its semantic check are **imported** from
+ * `fjs/media/revision`, not restated: one recursive schema, one hash check,
+ * one canonical serialization, so a map means the same thing inline and shared
+ * and the two forms cannot drift (`proof.f.mjs` pins the bytes).
+ *
+ * Like its sibling, this module is the pure format only: the rtti schema, the
+ * `dialect` tag, and decode/validate. Whether a referenced blob exists, and
+ * what its bindings mean once fetched, stay a resolver's business.
+ *
+ * See `README.md` for the full spec.
+ *
+ * @module
+ *
+ * @import { Unknown } from '../json/types.ts'
+ * @import { Result } from '../../types/result/types.ts'
+ * @import { DialectEntry } from '../types.ts'
+ * @import { Lock, LockError } from './types.ts'
+ */
+
+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'
+import { dialectEntry } from '../module.f.mjs'
+import { sort } from '../../types/object/module.f.mjs'
+import { lock, lockMapError } from '../revision/module.f.mjs'
+
+/**
+ * Format tag: names the dialect of this BLOB. The media type it is served
+ * with is derived mechanically: `application/` + `dialect` + `+json`.
+ */
+export const dialect = /** @type {const} */ ('vnd.fjs.lock')
+
+/** The media type derived from {@link dialect}: `application/vnd.fjs.lock+json`. */
+export const mediaType = /** @type {const} */ (`application/${dialect}+json`)
+
+/**
+ * rtti schema for a `lock` BLOB: the dialect tag and the map, nothing else.
+ *
+ * `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
+ * value domain.
+ *
+ * The field is **required** and may be `{}`: an absent map and an empty one
+ * would otherwise be two spellings of one blob, and a blob whose only purpose
+ * is to hold a map has nothing to say when it does not. It is also never a
+ * hash — a lock blob does not reference further lock blobs (see the README's
+ * [Composition](./README.md#composition)), so following a reference always
+ * terminates in one step.
+ */
+export const lockSchema = /** @type {const} */ ({
+    dialect,
+    lock,
+})
+
+/** Serializes a lock blob canonically, recursively sorting every object's property names.
+ * @type {(lock: Lock) => string}
+ */
+export const encodeText = stringify(sort)
+
+/** Structural-only validator: checks the shape, not the hash semantics. */
+const validateShape = rttiParse(lockSchema)
+
+/**
+ * Checks the semantic refinement the structural schema can't express on an
+ * already shape-valid lock blob: every direct value at every depth of the map
+ * must decode as a cbase32 hash. This is `fjs/media/revision`'s own
+ * `lockMapError`, so a map rejected inline is rejected here and vice versa.
+ *
+ * Exported separately from {@link validate} for callers holding an
+ * already-typed `Lock` — the same split, for the same reason, as the revision
+ * dialect's `checkReferences`.
+ *
+ * @type {(l: Lock) => Result<Lock, string>}
+ */
+export const checkReferences = l => {
+    const message = lockMapError(l.lock)
+    return message === null ? ok(l) : error(message)
+}
+
+/**
+ * Validates an already-parsed JSON value as a `lock` BLOB: structural (rtti)
+ * validation followed by the hash semantic check.
+ *
+ * @type {(value: Unknown) => Result<Lock, LockError>}
+ */
+export const validate = value => okThen(checkReferences)(validateShape(value))
+
+/**
+ * Decodes `text` as a `lock` BLOB: JSON-parses it, then validates it per
+ * {@link validate}. Detection is semantic, not syntactic — any JSON that
+ * satisfies the schema is a lock blob, regardless of key order or whitespace.
+ *
+ * @type {(text: string) => Result<Lock, LockError>}
+ */
+export const decodeText = text => okThen(validate)(parseJson(text))
+
+/** {@link checkReferences} as the `boolean` refinement a {@link DialectEntry} takes.
+ * @type {(l: Lock) => boolean}
+ */
+const isValidLock = l => {
+    const [tag] = checkReferences(l)
+    return tag === 'ok'
+}
+
+/**
+ * This dialect as a registry entry for `fjs/media`'s `detect`. It carries the
+ * semantic check too, so a blob is detected as `vnd.fjs.lock` exactly when
+ * {@link decodeText} would accept it.
+ *
+ * @type {DialectEntry}
+ */
+export const lockDialect = dialectEntry(lockSchema, isValidLock)

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

@@ -0,0 +1,33 @@
+/**
+ * @import { Object as JsonObject } from '../json/types.ts'
+ * @import { LockMap } from './types.ts'
+ */
+export declare const proof: {
+    dialectAndMediaType: () => void;
+    validate: {
+        flatMapAccepted: () => void;
+        emptyMapAccepted: () => void;
+        nestedMapAccepted: () => void;
+        missingLockRejected: () => void;
+        referenceLockRejected: () => void;
+        malformedMapRejected: () => void;
+        invalidHashRejected: () => void;
+        revisionFieldsIgnored: () => void;
+        revisionBlobRejected: () => void;
+    };
+    checkReferences: {
+        valid: () => void;
+        invalid: () => void;
+    };
+    decodeText: {
+        validJson: () => void;
+        keyOrderIndependent: () => void;
+        malformedJsonRejected: () => void;
+        ordinaryJsonRejected: () => void;
+    };
+    encodeText: {
+        recursivelySortsObjectsLexicographically: () => void;
+        equivalentOrdersConverge: () => void;
+    };
+    inlineAndSharedSerializeIdentically: () => void;
+};

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

@@ -0,0 +1,196 @@
+/**
+ * @import { Object as JsonObject } from '../json/types.ts'
+ * @import { LockMap } from './types.ts'
+ */
+
+import { assert, assertEq } from '../../asserts/module.f.mjs'
+import { dialect, mediaType, checkReferences, validate, decodeText, encodeText } from './module.f.mjs'
+import {
+    dialect as revisionDialect,
+    encodeText as revisionEncodeText,
+    validate as revisionValidate,
+} from '../revision/module.f.mjs'
+import { stringify } from '../json/module.f.mjs'
+import { sort } from '../../types/object/module.f.mjs'
+
+// Valid cbase32 hashes (round-tripped in fjs/basen/cbase32/proof.f.mjs): single
+// cbase32 symbols, cheap to write inline here.
+const h1 = '8'
+const h2 = 'r'
+
+/** A shape-valid lock blob holding `lock`.
+ * @type {(lock: JsonObject) => JsonObject}
+ */
+const lockOf = lock => ({ dialect, lock })
+
+/**
+ * The one map both forms are asked to carry — nested, so the claim covers
+ * every depth rather than just the top level.
+ * @type {LockMap}
+ */
+const sharedMap = { C: { D: h2, C: h1 }, B: { D: h1 } }
+
+/** The canonical rendering of a lock map on its own, independent of either blob. */
+const canonicalMap = stringify(sort)
+
+export const proof = {
+    dialectAndMediaType: () => {
+        assertEq(dialect, 'vnd.fjs.lock')
+        assertEq(mediaType, 'application/vnd.fjs.lock+json')
+    },
+
+    validate: {
+        // The ordinary case: a flat map of subject-to-content bindings.
+        flatMapAccepted: () => {
+            const r = validate(lockOf({ dependency: h1 }))
+            assert(r[0] === 'ok', ['expected ok', r])
+            assertEq(r[1].lock.dependency, h1)
+        },
+
+        // An empty map is a lock blob that records no bindings — distinct from
+        // a revision omitting `lock`, and the reason the field is required.
+        emptyMapAccepted: () => {
+            const r = validate(lockOf({}))
+            assert(r[0] === 'ok', ['expected ok', r])
+            assertEq(Object.keys(r[1].lock).length, 0)
+        },
+
+        // Nesting is the revision dialect's, unchanged: scopes to any depth.
+        nestedMapAccepted: () => {
+            const [t] = validate(lockOf({ B: { C: { D: { E: h1 } } }, empty: {} }))
+            assertEq(t, 'ok')
+        },
+
+        // `lock` is required: a blob carrying only the tag is not one.
+        missingLockRejected: () => {
+            const [t] = validate({ dialect })
+            assertEq(t, 'error')
+        },
+
+        // The field is a map, never a hash — a lock blob does not reference
+        // further lock blobs, so following a reference terminates in one step.
+        referenceLockRejected: () => {
+            const [t] = validate({ dialect, lock: h1 })
+            assertEq(t, 'error')
+        },
+
+        // A value must be a string or a map: a number fails structurally.
+        malformedMapRejected: () => {
+            const [t] = validate(lockOf({ dependency: 1 }))
+            assertEq(t, 'error')
+        },
+
+        // The semantic check is the revision dialect's own, so a non-hash
+        // string is rejected here with the same path-naming message.
+        invalidHashRejected: () => {
+            const r = validate(lockOf({ B: { D: 'https://example.com/x' } }))
+            assert(r[0] === 'error', ['expected error', r])
+            assertEq(r[1], 'lock value for B/D is not a valid hash: https://example.com/x')
+        },
+
+        // No `subject`, `parents`, `generation` or `archived`: this dialect is
+        // a value, not a step. rtti structs are open, so such fields are
+        // ignored rather than rejected — the additive forward-compatibility
+        // path, the same one the revision dialect relies on.
+        revisionFieldsIgnored: () => {
+            const [t] = validate({ dialect, lock: {}, subject: h1, parents: [], generation: 0 })
+            assertEq(t, 'ok')
+        },
+
+        // A revision blob is not a lock blob: the tag is matched as an exact
+        // literal, so the two dialects never validate each other's content.
+        revisionBlobRejected: () => {
+            const [t] = validate({
+                dialect: revisionDialect,
+                subject: h1,
+                parents: [],
+                snapshot: h2,
+                generation: 0,
+                lock: {},
+            })
+            assertEq(t, 'error')
+        },
+    },
+
+    // The already-typed entry point, for callers that assembled a `Lock`
+    // themselves and need only the semantic half.
+    checkReferences: {
+        valid: () => {
+            const [t] = checkReferences({ dialect, lock: { dependency: h1 } })
+            assertEq(t, 'ok')
+        },
+        invalid: () => {
+            const [t] = checkReferences({ dialect, lock: { dependency: 'not a hash!' } })
+            assertEq(t, 'error')
+        },
+    },
+
+    decodeText: {
+        validJson: () => {
+            const r = decodeText(JSON.stringify(lockOf({ dependency: h1 })))
+            assert(r[0] === 'ok', ['expected ok', r])
+            assertEq(r[1].lock.dependency, h1)
+        },
+
+        // Key order carries no meaning: the JSON is parsed and the parsed
+        // value validated, so `dialect` need not come first.
+        keyOrderIndependent: () => {
+            const [t] = decodeText(`{"lock":{"dependency":"${h1}"},"dialect":"${dialect}"}`)
+            assertEq(t, 'ok')
+        },
+
+        malformedJsonRejected: () => {
+            const [t] = decodeText('{not json')
+            assertEq(t, 'error')
+        },
+
+        ordinaryJsonRejected: () => {
+            const [t] = decodeText('{"hello":"world"}')
+            assertEq(t, 'error')
+        },
+    },
+
+    encodeText: {
+        recursivelySortsObjectsLexicographically: () => {
+            const decoded = validate(lockOf({ scope: { '2': h2, '10': h1 }, '2': h2, '10': h1 }))
+            assert(decoded[0] === 'ok', ['expected ok', decoded])
+            assertEq(
+                encodeText(decoded[1]),
+                `{"dialect":"${dialect}","lock":{"10":"${h1}","2":"${h2}","scope":{"10":"${h1}","2":"${h2}"}}}`,
+            )
+        },
+
+        // Two blobs differing only in property order converge on one byte
+        // sequence, so they address the same CAS blob — which is the whole
+        // point of sharing one.
+        equivalentOrdersConverge: () => {
+            const a = validate(lockOf({ B: { B: h1, D: h2 }, C: { D: h1 } }))
+            const b = validate(lockOf({ C: { D: h1 }, B: { D: h2, B: h1 } }))
+            assert(a[0] === 'ok', ['expected ok', a])
+            assert(b[0] === 'ok', ['expected ok', b])
+            assertEq(encodeText(a[1]), encodeText(b[1]))
+        },
+    },
+
+    // The point of importing `lock` rather than restating it: one map, one
+    // canonical rendering, whether it is held inline by a revision or shared
+    // as a blob of its own. The two dialects have different field sets, so the
+    // surrounding bytes differ — the map's do not, and a resolver reading
+    // either form sees the identical bytes under `lock`.
+    inlineAndSharedSerializeIdentically: () => {
+        const fragment = `"lock":${canonicalMap(sharedMap)}`
+        const shared = validate(lockOf(sharedMap))
+        assert(shared[0] === 'ok', ['expected ok', shared])
+        const inline = revisionValidate({
+            dialect: revisionDialect,
+            subject: h1,
+            parents: [],
+            snapshot: h2,
+            generation: 0,
+            lock: sharedMap,
+        })
+        assert(inline[0] === 'ok', ['expected ok', inline])
+        assert(encodeText(shared[1]).includes(fragment), encodeText(shared[1]))
+        assert(revisionEncodeText(inline[1]).includes(fragment), revisionEncodeText(inline[1]))
+    },
+}

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

@@ -0,0 +1,15 @@
+/**
+ * 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.
+ */
+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. */
+export type LockError = ValidationError | string;

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

@@ -12,11 +12,12 @@
  * `fjs/media/type` verdict unchanged.
  *
  * The dialect set is a **parameter**, not an import: `detect(dialects)(bytes)`.
- * This module therefore knows no dialect of its own — `fjs/media/revision`
- * exports its own {@link DialectEntry} (`revisionDialect`), and a caller passes
- * the list it wants recognized. Any format following the `vnd.fjs.<name>`
- * convention (see `fjs/media/revision/README.md`), in this repo or downstream,
- * is registerable the same way.
+ * This module therefore knows no dialect of its own — `fjs/media/revision`,
+ * `fjs/media/lock`, and `fjs/media/note` each export their own
+ * {@link DialectEntry} (`revisionDialect`, `lockDialect`, `noteDialect`), and
+ * a caller passes the list it wants recognized. Any format following the `vnd.fjs.<name>` convention (see
+ * `fjs/media/revision/README.md`), in this repo or downstream, is registerable
+ * the same way.
  *
  * Detection is semantic, not syntactic: any JSON that satisfies a dialect's
  * schema is recognized regardless of key order, whitespace, or any other

package/fjs/media/module.f.mjs

@@ -12,11 +12,12 @@
  * `fjs/media/type` verdict unchanged.
  *
  * The dialect set is a **parameter**, not an import: `detect(dialects)(bytes)`.
- * This module therefore knows no dialect of its own — `fjs/media/revision`
- * exports its own {@link DialectEntry} (`revisionDialect`), and a caller passes
- * the list it wants recognized. Any format following the `vnd.fjs.<name>`
- * convention (see `fjs/media/revision/README.md`), in this repo or downstream,
- * is registerable the same way.
+ * This module therefore knows no dialect of its own — `fjs/media/revision`,
+ * `fjs/media/lock`, and `fjs/media/note` each export their own
+ * {@link DialectEntry} (`revisionDialect`, `lockDialect`, `noteDialect`), and
+ * a caller passes the list it wants recognized. Any format following the `vnd.fjs.<name>` convention (see
+ * `fjs/media/revision/README.md`), in this repo or downstream, is registerable
+ * the same way.
  *
  * Detection is semantic, not syntactic: any JSON that satisfies a dialect's
  * schema is recognized regardless of key order, whitespace, or any other
@@ -53,7 +54,7 @@ import { fromVec } from '../text/utf8/module.f.mjs'
 import { detectVec } from './type/module.f.mjs'
 import { parse } from './json/module.f.mjs'
 import { assert, assertNotNullish } from '../asserts/module.f.mjs'
-import { validate } from '../types/rtti/validate/module.f.mjs'
+import { parse as rttiParse } from '../types/rtti/parse/module.f.mjs'
 
 /** The default refinement: structural validation alone decides the match. */
 const always = () => true
@@ -119,7 +120,7 @@ const matchWith = v => extraValidate => u => {
 export const dialectEntry = (type, extraValidate = always) => {
     const { dialect } = type
     assert(typeof dialect === 'string', 'dialectEntry: schema has no direct string `dialect` member')
-    return { dialect, match: matchWith(validate(type))(extraValidate) }
+    return { dialect, match: matchWith(rttiParse(type))(extraValidate) }
 }
 
 /**