functionalscript 0.43.0 → 0.44.0

package/fjs/media/json/tokenizer/proof.f.js

@@ -1,417 +0,0 @@
-import { tokenize } from './module.f.js';
-import { toArray } from '../../../types/list/module.f.js';
-import { stringifyAsTree } from '../../../djs/serializer/module.f.js';
-import { sort } from '../../../types/object/module.f.js';
-import { stringToList } from '../../../text/utf16/module.f.js';
-const tokenizeString = s => toArray(tokenize(stringToList(s)));
-const stringify = stringifyAsTree(sort);
-export const proof = {
-    json: [
-        () => {
-            const result = stringify(tokenizeString(''));
-            if (result !== '[{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('{'));
-            if (result !== '[{"kind":"{"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('}'));
-            if (result !== '[{"kind":"}"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString(':'));
-            if (result !== '[{"kind":":"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString(','));
-            if (result !== '[{"kind":","},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('['));
-            if (result !== '[{"kind":"["},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString(']'));
-            if (result !== '[{"kind":"]"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('ᄑ'));
-            if (result !== '[{"kind":"error","message":"unexpected character"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('{ \t\n\r}'));
-            if (result !== '[{"kind":"{"},{"kind":"}"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('""'));
-            if (result !== '[{"kind":"string","value":""},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('"value"'));
-            if (result !== '[{"kind":"string","value":"value"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('"value'));
-            if (result !== '[{"kind":"error","message":"\\" are missing"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('"value1" "value2"'));
-            if (result !== '[{"kind":"string","value":"value1"},{"kind":"string","value":"value2"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('"'));
-            if (result !== '[{"kind":"error","message":"\\" are missing"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('"\\\\"'));
-            if (result !== '[{"kind":"string","value":"\\\\"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('"\\""'));
-            if (result !== '[{"kind":"string","value":"\\""},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('"\\/"'));
-            if (result !== '[{"kind":"string","value":"/"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('"\\x"'));
-            if (result !== '[{"kind":"error","message":"unescaped character"},{"kind":"string","value":"x"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('"\\'));
-            if (result !== '[{"kind":"error","message":"\\" are missing"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('"\\b\\f\\n\\r\\t"'));
-            if (result !== '[{"kind":"string","value":"\\b\\f\\n\\r\\t"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('"\\u1234"'));
-            if (result !== '[{"kind":"string","value":"ሴ"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('"\\uaBcDEeFf"'));
-            if (result !== '[{"kind":"string","value":"ꯍEeFf"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('"\\uEeFg"'));
-            if (result !== '[{"kind":"error","message":"invalid hex value"},{"kind":"string","value":"g"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('0'));
-            if (result !== '[{"bf":[0n,0],"kind":"number","value":"0"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('[0]'));
-            if (result !== '[{"kind":"["},{"bf":[0n,0],"kind":"number","value":"0"},{"kind":"]"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('00'));
-            if (result !== '[{"kind":"error","message":"invalid number"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('0abc,'));
-            if (result !== '[{"kind":"error","message":"invalid number"},{"kind":"error","message":"invalid token"},{"kind":","},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('123456789012345678901234567890'));
-            if (result !== '[{"bf":[123456789012345678901234567890n,0],"kind":"number","value":"123456789012345678901234567890"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('{90}'));
-            if (result !== '[{"kind":"{"},{"bf":[90n,0],"kind":"number","value":"90"},{"kind":"}"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('1 2'));
-            if (result !== '[{"bf":[1n,0],"kind":"number","value":"1"},{"bf":[2n,0],"kind":"number","value":"2"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('0. 2'));
-            if (result !== '[{"kind":"error","message":"invalid number"},{"bf":[2n,0],"kind":"number","value":"2"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('10-0'));
-            if (result !== '[{"bf":[10n,0],"kind":"number","value":"10"},{"bf":[0n,0],"kind":"number","value":"-0"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('9a:'));
-            if (result !== '[{"kind":"error","message":"invalid number"},{"kind":"error","message":"invalid token"},{"kind":":"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('-10'));
-            if (result !== '[{"bf":[-10n,0],"kind":"number","value":"-10"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('-'));
-            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('--'));
-            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('---'));
-            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"error","message":"invalid token"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('-0'));
-            if (result !== '[{"bf":[0n,0],"kind":"number","value":"-0"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('-00'));
-            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"error","message":"invalid number"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('-.123'));
-            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"error","message":"invalid token"},{"bf":[123n,0],"kind":"number","value":"123"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('0.01'));
-            if (result !== '[{"bf":[1n,-2],"kind":"number","value":"0.01"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('-0.9'));
-            if (result !== '[{"bf":[-9n,-1],"kind":"number","value":"-0.9"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('-0.'));
-            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"error","message":"invalid number"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('-0.]'));
-            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"error","message":"invalid number"},{"kind":"]"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('12.34'));
-            if (result !== '[{"bf":[1234n,-2],"kind":"number","value":"12.34"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('-12.00'));
-            if (result !== '[{"bf":[-1200n,-2],"kind":"number","value":"-12.00"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('-12.'));
-            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"error","message":"invalid number"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('12.]'));
-            if (result !== '[{"kind":"error","message":"invalid number"},{"kind":"]"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('0e1'));
-            if (result !== '[{"bf":[0n,1],"kind":"number","value":"0e1"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('0e+2'));
-            if (result !== '[{"bf":[0n,2],"kind":"number","value":"0e+2"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('0e-0'));
-            if (result !== '[{"bf":[0n,0],"kind":"number","value":"0e-0"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('12e0000'));
-            if (result !== '[{"bf":[12n,0],"kind":"number","value":"12e0000"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('-12e-0001'));
-            if (result !== '[{"bf":[-12n,-1],"kind":"number","value":"-12e-0001"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('-12.34e1234'));
-            if (result !== '[{"bf":[-1234n,1232],"kind":"number","value":"-12.34e1234"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('0e'));
-            if (result !== '[{"kind":"error","message":"invalid number"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('0e-'));
-            if (result !== '[{"kind":"error","message":"invalid number"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('1234567890n'));
-            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('0n'));
-            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('[-1234567890n]'));
-            if (result !== '[{"kind":"["},{"kind":"error","message":"invalid token"},{"kind":"error","message":"invalid token"},{"kind":"]"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-    ],
-    id: [
-        () => {
-            const result = stringify(tokenizeString('err'));
-            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('{e}'));
-            if (result !== '[{"kind":"{"},{"kind":"error","message":"invalid token"},{"kind":"}"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('tru'));
-            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('break'));
-            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-    ],
-    keywords: [
-        () => {
-            const result = stringify(tokenizeString('true'));
-            if (result !== '[{"kind":"true"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('false'));
-            if (result !== '[{"kind":"false"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('null'));
-            if (result !== '[{"kind":"null"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(tokenizeString('[null]'));
-            if (result !== '[{"kind":"["},{"kind":"null"},{"kind":"]"},{"kind":"eof"}]') {
-                throw result;
-            }
-        },
-    ]
-};

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

@@ -1,119 +0,0 @@
-/**
- * Media-type detection entry point: dialect-tagged JSON recognition layered
- * on top of the byte-signature / UTF-8 detector.
- *
- * `fjs/media/type` classifies raw bytes (magic-byte signatures, UTF-8
- * text-vs-binary) with no notion of a JSON dialect. `detect` here adds one
- * more classification step in front of it: when the whole blob is
- * whole-blob-valid UTF-8 text (as `fjs/media/type` already determined), parse
- * it as JSON and match the parsed value against the dialects the caller
- * registered. A match reports that dialect's derived media type; anything that
- * isn't valid JSON, or matches no registered dialect, falls through to the
- * `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.
- *
- * Detection is semantic, not syntactic: any JSON that satisfies a dialect's
- * schema is recognized regardless of key order, whitespace, or any other
- * serialization detail — there is no byte-level shortcut such as a
- * `{"dialect":` prefix check. The text is parsed **once**, and each entry's
- * `match` runs on the same parsed value, so N dialects cost N schema walks
- * rather than N parses.
- *
- * A reported `mime_type` is a claim about a blob's *shape*, not a promise that
- * decoding it succeeds: how strict detection is, is the dialect's own call (see
- * {@link dialectEntry}'s `extraValidate`). Never route a decode decision
- * through this verdict — a caller that intends to decode calls its dialect's
- * decoder, which stays the authority.
- *
- * This only classifies an already-buffered `Vec` (`detectVec`'s single-`Vec`
- * form), because dialect validation needs the whole parsed value. A single
- * `Vec` already caps at `maxLength` bits (128 KiB — the same bound as the
- * existing inline-content cap), so dialect detection is naturally
- * size-bounded. The unbounded streaming detector (`fjs/media/type`
- * `detectStream`) is untouched and stays a pure byte-signature/UTF-8
- * classifier with no dialect awareness.
- *
- * @module
- */
-import type { Vec } from '../types/bit_vec/module.f.ts';
-import { type DetectMeta } from './type/module.f.ts';
-import type { Struct } from '../types/rtti/module.f.ts';
-import type { Ts, Unknown } from '../types/rtti/ts/module.f.ts';
-/**
- * One registered dialect: the name it tags itself with, and a predicate
- * deciding whether an already-parsed value is one of its blobs.
- *
- * `match` takes rtti's `Unknown` — the encoding-neutral one, admitting
- * `bigint` and `undefined` — not `fjs/media/json`'s JSON-only `Unknown`, so an
- * entry stays usable by a future non-JSON detector over the same dialects.
- *
- * The type is deliberately not opaque: a caller may write the struct by hand.
- * The list is that caller's own declaration of what it wants recognized,
- * passed to its own `detect` call, so a fabricated entry mislabels only that
- * caller's results — there is no trust boundary between a caller and entries it
- * writes itself. The boundary that does exist, untrusted blob content, is on
- * the other side of `match`.
- */
-export type DialectEntry = {
-    readonly dialect: string;
-    readonly match: (_: Unknown) => boolean;
-};
-/**
- * Registers a dialect for detection: its rtti schema, plus whatever rtti can't
- * say about it.
- *
- * The dialect name is read out of the schema's own `dialect` member — that
- * member is a string const in a dialect schema, which is what makes the schema
- * self-discriminating, so a separate name alongside it would be a second copy
- * that can disagree with the first. It follows that no registration can claim
- * one dialect while validating another's blobs. The media type is likewise
- * derived rather than supplied: `application/${dialect}+json`, the mechanical
- * derivation `fjs/media/revision/README.md` documents.
- *
- * `extraValidate` runs *after* structural validation, on the dialect's own
- * decoded type, and closes the gap rtti leaves — "this string is
- * cbase32-decodable", "this number is a non-negative safe integer". It returns
- * `boolean`, so it has no error channel and nothing to report but yes or no,
- * and it never sees the raw bytes: parsing and the schema walk stay with the
- * detector. Omitting it gets classification (what a blob claims to be and
- * structurally looks like); supplying it gets detection as strict as the
- * dialect's own decoder.
- *
- * **The name is neither grammar-checked nor allowlisted.** A schema saying
- * `dialect: 'foo'` yields `application/foo+json`, and that is intended:
- * `vnd.fjs.*` is this repo's convention for its *own* formats, not a constraint
- * on what a caller may detect — another vendor's `vnd.*` blob, or a widely used
- * name not under `vnd.` at all, is a legitimate thing to register. The name is
- * not attacker-controlled either: it comes from a schema a programmer wrote and
- * passed here, never from the blob being classified, so no untrusted string
- * reaches `mime_type` along this path. (A detector that read the name *out of*
- * a blob would need the RFC 6838 grammar check and an allowlist; this one does
- * 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`
- * (`() => ['const', 'x']`) is a perfectly valid rtti schema, it just is not
- * registerable — write the string directly, as `revisionSchema` does.
- */
-export declare const dialectEntry: <T extends Struct>(type: T, extraValidate?: (_: Ts<T>) => boolean) => DialectEntry;
-/**
- * Classifies a whole buffered `Vec` against `dialects`, returning the same
- * three-way `{ length, mime_type, type }` shape as `fjs/media/type`
- * `detectVec`, but with dialect-tagged JSON recognized ahead of the plain
- * `text/plain` fallback. The first entry whose `match` accepts the parsed value
- * wins; entries that overlap are the registrant's own business, since matching
- * `dialect` as an exact literal already makes structural validation reject
- * every other dialect's blob.
- */
-export declare const detect: (dialects: readonly DialectEntry[]) => (bytes: Vec) => DetectMeta;

package/fjs/media/module.f.js

@@ -1,88 +0,0 @@
-import { fromVec } from '../text/utf8/module.f.js';
-import { detectVec } from './type/module.f.js';
-import { parse } from './json/module.f.js';
-import { assert, assertNotNullish } from '../asserts/module.f.js';
-import { validate } from '../types/rtti/validate/module.f.js';
-/** The default refinement: structural validation alone decides the match. */
-const always = () => true;
-/** Structural validation followed by the dialect's own refinement. */
-const matchWith = (v) => (extraValidate) => (u) => {
-    const [tag, value] = v(u);
-    return tag === 'ok' && extraValidate(value);
-};
-/**
- * Registers a dialect for detection: its rtti schema, plus whatever rtti can't
- * say about it.
- *
- * The dialect name is read out of the schema's own `dialect` member — that
- * member is a string const in a dialect schema, which is what makes the schema
- * self-discriminating, so a separate name alongside it would be a second copy
- * that can disagree with the first. It follows that no registration can claim
- * one dialect while validating another's blobs. The media type is likewise
- * derived rather than supplied: `application/${dialect}+json`, the mechanical
- * derivation `fjs/media/revision/README.md` documents.
- *
- * `extraValidate` runs *after* structural validation, on the dialect's own
- * decoded type, and closes the gap rtti leaves — "this string is
- * cbase32-decodable", "this number is a non-negative safe integer". It returns
- * `boolean`, so it has no error channel and nothing to report but yes or no,
- * and it never sees the raw bytes: parsing and the schema walk stay with the
- * detector. Omitting it gets classification (what a blob claims to be and
- * structurally looks like); supplying it gets detection as strict as the
- * dialect's own decoder.
- *
- * **The name is neither grammar-checked nor allowlisted.** A schema saying
- * `dialect: 'foo'` yields `application/foo+json`, and that is intended:
- * `vnd.fjs.*` is this repo's convention for its *own* formats, not a constraint
- * on what a caller may detect — another vendor's `vnd.*` blob, or a widely used
- * name not under `vnd.` at all, is a legitimate thing to register. The name is
- * not attacker-controlled either: it comes from a schema a programmer wrote and
- * passed here, never from the blob being classified, so no untrusted string
- * reaches `mime_type` along this path. (A detector that read the name *out of*
- * a blob would need the RFC 6838 grammar check and an allowlist; this one does
- * 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`
- * (`() => ['const', 'x']`) is a perfectly valid rtti schema, it just is not
- * registerable — write the string directly, as `revisionSchema` does.
- */
-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) };
-};
-/**
- * Classifies a whole buffered `Vec` against `dialects`, returning the same
- * three-way `{ length, mime_type, type }` shape as `fjs/media/type`
- * `detectVec`, but with dialect-tagged JSON recognized ahead of the plain
- * `text/plain` fallback. The first entry whose `match` accepts the parsed value
- * wins; entries that overlap are the registrant's own business, since matching
- * `dialect` as an exact literal already makes structural validation reject
- * every other dialect's blob.
- */
-export const detect = (dialects) => (bytes) => {
-    const base = detectVec(bytes);
-    // Only whole-blob-valid UTF-8 text can possibly be JSON; a magic-byte hit
-    // or binary fallback is never a dialect match.
-    if (base.type !== 'text') {
-        return base;
-    }
-    // `detectVec`'s `type: 'text'` verdict already means `bytes` is byte-aligned,
-    // whole-blob-valid UTF-8 — the same two conditions `fromVec` checks, via the
-    // same decoder — so `fromVec` cannot return `null` here.
-    const text = assertNotNullish(fromVec(bytes), 'detect: type text implies fromVec succeeds');
-    const [tag, value] = parse(text);
-    if (tag === 'error') {
-        return base;
-    }
-    const matched = dialects.find(({ match }) => match(value));
-    return matched === undefined
-        ? base
-        : { ...base, mime_type: `application/${matched.dialect}+json` };
-};

package/fjs/media/nix/module.f.d.ts

@@ -1,30 +0,0 @@
-/**
- * A minimal, checked eDSL for constructing and serializing Nix expressions.
- *
- * The tree deliberately models syntax rather than evaluated Nix values. String
- * expressions are escaped double-quoted strings; the other supported forms are
- * represented by tagged tuples.
- *
- * @module
- */
-import { type List as ChunkList } from '../../types/list/module.f.ts';
-type Identifier = string;
-type AttributeName = string;
-type AttributePath = readonly [AttributeName, ...AttributeName[]];
-type Binding = readonly ['=', AttributePath, Expression];
-type Reference = readonly ['ref', Identifier, ...AttributeName[]];
-type AttributeSet = readonly ['set', ...Binding[]];
-type NixList = readonly ['list', ...Reference[]];
-type ApplicationArgument = Reference | AttributeSet;
-type Application = readonly ['apply', Reference, ...ApplicationArgument[]];
-type OpenSetPattern = readonly ['open-set-pattern', ...Identifier[]];
-type Lambda = readonly ['lambda', OpenSetPattern, Expression];
-type Let = readonly ['let', readonly Binding[], Expression];
-type IndentedString = readonly ['indented-string', string];
-/** The Nix syntax supported by the serializer. */
-export type Expression = string | Reference | AttributeSet | NixList | Application | Lambda | Let | IndentedString;
-/** Serializes an expression into composable chunks, or rejects an invalid identifier. */
-export declare const nix: (expression: Expression) => ChunkList<string> | undefined;
-/** Serializes an expression with exactly one trailing newline on success. */
-export declare const nixToString: (expression: Expression) => string | undefined;
-export {};