functionalscript 0.43.1 → 0.45.0

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

@@ -0,0 +1,96 @@
+/**
+ * Tokenizer for JSON lexical analysis.
+ *
+ * @module
+ *
+ * @import { StateScan } from '../../../types/function/operator/types.ts'
+ * @import { List } from '../../../types/list/types.ts'
+ * @import { JsToken } from '../../../js/tokenizer/types.ts'
+ * @import { JsonToken, _ScanState, _ScanInput } from './types.ts'
+ */
+
+import { concat, empty, flat, stateScan, toArray } from '../../../types/list/module.f.mjs'
+import { multiply } from '../../../types/bigfloat/module.f.mjs'
+import { tokenize as jsTokenize } from '../../../js/tokenizer/module.f.mjs'
+import { assertEq } from '../../../asserts/module.f.mjs'
+
+/** @type {(input: JsToken) => List<JsonToken>} */
+const mapToken = input => {
+    switch (input.kind) {
+        case '{':
+        case '}':
+        case ':':
+        case ',':
+        case '[':
+        case ']':
+        case 'true':
+        case 'false':
+        case 'null':
+        case 'string':
+        case 'number':
+        case 'eof':
+        case 'error': return [input]
+        case 'ws':
+        case 'nl': return empty
+        default: return [{ kind: 'error', message: 'invalid token' }]
+    }
+}
+
+/** @type {(input: _ScanInput) => readonly [List<JsonToken>, _ScanState]} */
+const parseDefaultState = input => {
+    if (input === null) return [empty, { kind: 'def' }]
+    switch (input.token.kind) {
+        case '-': return [empty, { kind: '-' }]
+        default: return [mapToken(input.token), { kind: 'def' }]
+    }
+}
+
+/** @type {(input: _ScanInput) => readonly [List<JsonToken>, _ScanState]} */
+const parseMinusState = input => {
+    if (input === null) return [[{ kind: 'error', message: 'invalid token' }], { kind: 'def' }]
+    switch (input.token.kind) {
+        case '-': return [[{ kind: 'error', message: 'invalid token' }], { kind: '-' }]
+        case 'number': return [[{ kind: 'number', bf: multiply(input.token.bf)(-1n), value: `-${input.token.value}` }], { kind: 'def' }]
+        default: return [{ first: { kind: 'error', message: 'invalid token' }, tail: mapToken(input.token) }, { kind: 'def' }]
+    }
+}
+
+/** @type {StateScan<_ScanInput, _ScanState, List<JsonToken>>} */
+const scanToken = (input, state) => {
+    switch (state.kind) {
+        case '-': return parseMinusState(input)
+        default: return parseDefaultState(input)
+    }
+}
+
+/**
+ * Converts a stream of UTF-8 bytes into JSON tokens.
+ *
+ * The tokenizer accepts only JSON-compatible JavaScript tokens, ignores
+ * whitespace/newline tokens, and reports invalid token sequences as
+ * `{ kind: 'error' }` tokens.
+ *
+ * @type {(input: List<number>) => List<JsonToken>}
+ */
+export const tokenize = input => {
+    /** @type {List<_ScanInput>} */
+    const jsTokens = jsTokenize(input)('')
+    return flat(stateScan(scanToken)({ kind: 'def' })(concat(jsTokens)([null])))
+}
+
+export const proof = {
+    // `parseMinusState` only sees `null` if the JSON tokenizer's own EOF
+    // sentinel arrives while still in state '-' — i.e. input ends right after
+    // a lone `-`. Unreachable through the public `tokenize`: the underlying
+    // JS tokenizer always emits its own `eof` token first, and consuming that
+    // (the default branch, any kind other than '-' or 'number') resets state
+    // to 'def' before the sentinel `null` is ever seen. Call the private
+    // state handler directly to cover the branch anyway.
+    parseMinusStateEof: () => {
+        const [tokens, state] = parseMinusState(null)
+        assertEq(state.kind, 'def')
+        const a = toArray(tokens)
+        assertEq(a.length, 1)
+        assertEq(a[0].kind, 'error')
+    },
+}

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

@@ -0,0 +1,8 @@
+/**
+ * @import { JsonToken } from './types.ts'
+ */
+export declare const proof: {
+    json: (() => void)[];
+    id: (() => void)[];
+    keywords: (() => void)[];
+};

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

@@ -0,0 +1,291 @@
+/**
+ * @import { JsonToken } from './types.ts'
+ */
+
+import { tokenize } from './module.f.mjs'
+import { toArray } from '../../../types/list/module.f.mjs'
+import { stringifyAsTree } from '../../../djs/serializer/module.f.mjs'
+import { sort } from '../../../types/object/module.f.mjs'
+import { stringToList } from '../../../text/utf16/module.f.mjs'
+
+/** @type {(s: string) => readonly JsonToken[]} */
+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/json/tokenizer/types.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Types for the JSON tokenizer.
+ *
+ * @module
+ */
+import type { StringToken, NumberToken, ErrorToken, EofToken, JsTokenWithMetadata } from '../../../js/tokenizer/types.ts';
+export type JsonToken = {
+    readonly kind: 'true' | 'false' | 'null';
+} | {
+    readonly kind: '{' | '}' | ':' | ',' | '[' | ']';
+} | StringToken | NumberToken | ErrorToken | EofToken;
+/** @internal */
+export type _ScanState = {
+    readonly kind: 'def' | '-';
+};
+/** @internal */
+export type _ScanInput = JsTokenWithMetadata | null;

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

@@ -0,0 +1,25 @@
+/**
+ * TypeScript counterparts of the JSON data model: `Primitive`, `Unknown`,
+ * `Object`, and `Array`.
+ *
+ * `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.
+ *
+ * @module
+ */
+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;
+};
+export type Array = readonly Unknown[];
+export type Entry = ObjectEntry<Unknown>;
+export type _Entries = List<Entry>;
+export type _MapEntries = (entries: _Entries) => _Entries;

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

@@ -0,0 +1,116 @@
+/**
+ * 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 { Vec } from '../types/bit_vec/types.ts'
+ * @import { DetectMeta } from './type/types.ts'
+ * @import { Struct } from '../types/rtti/types.ts'
+ * @import { Ts, Unknown } from '../types/rtti/ts/types.ts'
+ * @import { Validate } 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 { Ts } from '../types/rtti/ts/types.ts';
+import type { DialectEntry } from './types.ts';
+/**
+ * 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.
+ *
+ * @template {Struct} T
+ * @param {T} type
+ * @param {(_: Ts<T>) => boolean} [extraValidate]
+ * @returns {DialectEntry}
+ */
+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.
+ *
+ * @param {readonly DialectEntry[]} dialects
+ * @returns {(bytes: Vec) => DetectMeta}
+ */
+export declare const detect: (dialects: readonly DialectEntry[]) => (bytes: Vec) => DetectMeta;