functionalscript 0.35.2 → 0.37.0

package/fs/media/json/module.f.d.ts

@@ -0,0 +1,50 @@
+/**
+ * JSON value types, rtti schemas, and utilities: `serialize`, `stringify`,
+ * `parse`, and `setProperty` for immutable nested updates.
+ *
+ * The JSON value types (`Unknown`, `Primitive`) are derived from the rtti
+ * schemas defined here, so the schema is the single source of truth — no
+ * hand-written types to keep in sync.
+ *
+ * @module
+ */
+import { type List } from '../../types/list/module.f.ts';
+import { type Entry as ObjectEntry } from '../../types/object/module.f.ts';
+import type { Ts } from '../../types/rtti/ts/module.f.ts';
+/** rtti schema matching any JSON primitive: `null`, `boolean`, `number`, or `string`. */
+export declare const primitive: import("../../types/rtti/module.f.ts").Or<[null, import("../../types/rtti/module.f.ts").Boolean, import("../../types/rtti/module.f.ts").Number, import("../../types/rtti/module.f.ts").String]>;
+/**
+ * rtti schema matching any JSON value: a primitive, an array of JSON values,
+ * or an object whose values are JSON values. Self-referential via a thunk;
+ * rtti instantiates array/record item validators lazily so recursion terminates
+ * on acyclic input.
+ *
+ * A struct field typed `unknown` is **required when present** — unlike rtti
+ * core's `unknown`, the JSON `unknown` excludes `undefined`.
+ */
+export declare const unknown: () => readonly ['or', import("../../types/rtti/module.f.ts").Or<[null, import("../../types/rtti/module.f.ts").Boolean, import("../../types/rtti/module.f.ts").Number, import("../../types/rtti/module.f.ts").String]>, import("../../types/rtti/module.f.ts").Type1<"record", () => readonly ['or', import("../../types/rtti/module.f.ts").Or<[null, import("../../types/rtti/module.f.ts").Boolean, import("../../types/rtti/module.f.ts").Number, import("../../types/rtti/module.f.ts").String]>, import("../../types/rtti/module.f.ts").Type1<"record", /*elided*/ any>, import("../../types/rtti/module.f.ts").Type1<"array", /*elided*/ any>]>, import("../../types/rtti/module.f.ts").Type1<"array", () => readonly ['or', import("../../types/rtti/module.f.ts").Or<[null, import("../../types/rtti/module.f.ts").Boolean, import("../../types/rtti/module.f.ts").Number, import("../../types/rtti/module.f.ts").String]>, import("../../types/rtti/module.f.ts").Type1<"record", any>, import("../../types/rtti/module.f.ts").Type1<"array", any>]>];
+/**
+ * rtti schema matching a JSON object: `{ readonly [k: string]?: Unknown }`.
+ */
+export declare const object: import("../../types/rtti/module.f.ts").Type1<"record", typeof unknown>;
+/** rtti schema matching a JSON array: `readonly Unknown[]`. */
+export declare const array: import("../../types/rtti/module.f.ts").Type1<"array", typeof unknown>;
+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 declare const setProperty: (value: Unknown) => (path: List<string>) => (src: Unknown) => Unknown;
+export type Entry = ObjectEntry<Unknown>;
+type Entries = List<Entry>;
+type MapEntries = (entries: Entries) => Entries;
+export declare const serialize: (mapEntries: MapEntries) => (value: Unknown) => List<string>;
+/**
+ * The standard `JSON.stringify` rules determined by
+ * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
+ * https://tc39.es/ecma262/#sec-serializejsonproperty
+ */
+export declare const stringify: (mapEntries: MapEntries) => (value: Unknown) => string;
+export declare const parse: (value: string) => Unknown;
+export {};

package/fs/{json → media/json}/module.f.js

@@ -8,12 +8,12 @@
  *
  * @module
  */
-import { next, flat, map } from "../types/list/module.f.js";
-import { concat } from "../types/string/module.f.js";
-import { at, definedEntries } from "../types/object/module.f.js";
-import { compose, fn } from "../types/function/module.f.js";
-import { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } from "./serializer/module.f.js";
-import { boolean as rttiBoolean, number as rttiNumber, string as rttiString, or, record, array as rttiArray } from "../types/rtti/module.f.js";
+import { next, flat, map } from '../../types/list/module.f.js';
+import { concat } from '../../types/string/module.f.js';
+import { at, definedEntries } from '../../types/object/module.f.js';
+import { compose, fn } from '../../types/function/module.f.js';
+import { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } from './serializer/module.f.js';
+import { boolean as rttiBoolean, number as rttiNumber, string as rttiString, or, record, array as rttiArray } from '../../types/rtti/module.f.js';
 // ── rtti schemas ──────────────────────────────────────────────────────────────
 /** rtti schema matching any JSON primitive: `null`, `boolean`, `number`, or `string`. */
 export const primitive = or(null, rttiBoolean, rttiNumber, rttiString);
@@ -54,7 +54,7 @@ export const serialize = sort => {
         f(v)
     ]);
     const mapPropertySerialize = map(propertySerialize);
-    const objectSerialize = fn((definedEntries))
+    const objectSerialize = fn(definedEntries)
         .map(sort)
         .map(mapPropertySerialize)
         .map(objectWrap)

package/fs/{json → media/json}/parser/module.f.d.ts

@@ -3,8 +3,8 @@
  *
  * @module
  */
-import { type Result } from '../../types/result/module.f.ts';
-import { type List } from '../../types/list/module.f.ts';
+import { type Result } from '../../../types/result/module.f.ts';
+import { type List } from '../../../types/list/module.f.ts';
 import { type JsonToken } from '../tokenizer/module.f.ts';
 import { type Unknown } from '../module.f.ts';
 /**

package/fs/{json → media/json}/parser/module.f.js

@@ -3,13 +3,13 @@
  *
  * @module
  */
-import { error, ok } from "../../types/result/module.f.js";
-import { fold, first, drop, toArray, concat } from "../../types/list/module.f.js";
-import {} from "../../types/function/operator/module.f.js";
-import {} from "../tokenizer/module.f.js";
-import { setReplace } from "../../types/ordered_map/module.f.js";
-import {} from "../module.f.js";
-import { fromMap } from "../../types/object/module.f.js";
+import { error, ok } from '../../../types/result/module.f.js';
+import { fold, first, drop, toArray, concat } from '../../../types/list/module.f.js';
+import {} from '../../../types/function/operator/module.f.js';
+import {} from '../tokenizer/module.f.js';
+import { setReplace } from '../../../types/ordered_map/module.f.js';
+import {} from '../module.f.js';
+import { fromMap } from '../../../types/object/module.f.js';
 const addKeyToObject = obj => key => ({ kind: 'object', values: obj.values, key: key });
 const addValueToObject = obj => value => ({ kind: 'object', values: setReplace(obj.key)(value)(obj.values), key: '' });
 const addToArray = array => value => ({ kind: 'array', values: concat(array.values)([value]) });

package/fs/{json → media/json}/parser/proof.f.js

@@ -1,9 +1,9 @@
-import { parse } from "./module.f.js";
-import { tokenize } from "../tokenizer/module.f.js";
-import { toArray } from "../../types/list/module.f.js";
-import { stringify as jsonStringify } from "../module.f.js";
-import { sort } from "../../types/object/module.f.js";
-import { stringToList } from "../../text/utf16/module.f.js";
+import { parse } from './module.f.js';
+import { tokenize } from '../tokenizer/module.f.js';
+import { toArray } from '../../../types/list/module.f.js';
+import { stringify as jsonStringify } from '../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 = jsonStringify(sort);
 export const proof = {
@@ -155,6 +155,24 @@ export const proof = {
                 throw result;
             }
         },
+        // A literal control character inside a string is not valid JSON (RFC
+        // 8259 §7) even though the shared tokenizer would otherwise accept it.
+        () => {
+            const tokenList = tokenizeString('"\t"');
+            const obj = parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('{"a":"\t"}');
+            const obj = parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
         () => {
             const tokenList = tokenizeString('[,]');
             const obj = parse(tokenList);

package/fs/{json → media/json}/proof.f.js

@@ -1,7 +1,7 @@
-import { setProperty, stringify } from "./module.f.js";
-import { sort } from "../types/object/module.f.js";
-import { identity } from "../types/function/module.f.js";
-import { assertEq } from "../asserts/module.f.js";
+import { setProperty, stringify } from './module.f.js';
+import { sort } from '../../types/object/module.f.js';
+import { identity } from '../../types/function/module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 export const proof = {
     setProperty: [
         () => {

package/fs/media/json/rpc/module.f.d.ts

@@ -0,0 +1,114 @@
+import type { Ts } from '../../../types/rtti/ts/module.f.ts';
+import type { Result } from '../../../types/result/module.f.ts';
+import { unknown, type Unknown } from '../module.f.ts';
+export declare const jsonrpc: '2.0';
+/** Request/response identifier: a string, a number, or `null`. */
+declare const id: import("../../../types/rtti/module.f.ts").Or<[import("../../../types/rtti/module.f.ts").String, import("../../../types/rtti/module.f.ts").Number, null]>;
+/**
+ * A request or notification envelope. `id` present → request (a response is
+ * expected); `id` absent → notification (no response). `params` is optional.
+ *
+ * https://www.jsonrpc.org/specification#request_object
+ */
+export declare const request: {
+    readonly jsonrpc: "2.0";
+    readonly method: import("../../../types/rtti/module.f.ts").String;
+    readonly params: import("../../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
+    readonly id: import("../../../types/rtti/module.f.ts").Or<readonly [import("../../../types/rtti/module.f.ts").Or<[import("../../../types/rtti/module.f.ts").String, import("../../../types/rtti/module.f.ts").Number, null]>, undefined]>;
+};
+/** The JSON-RPC error object. */
+export declare const error: {
+    readonly code: import("../../../types/rtti/module.f.ts").Number;
+    readonly message: import("../../../types/rtti/module.f.ts").String;
+    readonly data: import("../../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
+};
+export type Id = Ts<typeof id>;
+export type Request = Ts<typeof request>;
+export type RpcError = Ts<typeof error>;
+export declare const successResponse: {
+    readonly jsonrpc: "2.0";
+    readonly result: typeof unknown;
+    readonly id: import("../../../types/rtti/module.f.ts").Or<[import("../../../types/rtti/module.f.ts").String, import("../../../types/rtti/module.f.ts").Number, null]>;
+};
+export declare const errorResponse: {
+    readonly jsonrpc: "2.0";
+    readonly error: {
+        readonly code: import("../../../types/rtti/module.f.ts").Number;
+        readonly message: import("../../../types/rtti/module.f.ts").String;
+        readonly data: import("../../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
+    };
+    readonly id: import("../../../types/rtti/module.f.ts").Or<[import("../../../types/rtti/module.f.ts").String, import("../../../types/rtti/module.f.ts").Number, null]>;
+};
+/**
+ * A response envelope: either a success (`result`) or an error (`error`).
+ * Derived from the rtti schema via `Ts<>` — the same declaration is the
+ * runtime decoder and the static type, with no drift. rtti structs are open
+ * (extra keys allowed), so "result XOR error" is not enforced at runtime; in
+ * practice the dispatcher only ever constructs one or the other.
+ *
+ * https://www.jsonrpc.org/specification#response_object
+ */
+export declare const response: import("../../../types/rtti/module.f.ts").Or<[{
+    readonly jsonrpc: "2.0";
+    readonly result: typeof unknown;
+    readonly id: import("../../../types/rtti/module.f.ts").Or<[import("../../../types/rtti/module.f.ts").String, import("../../../types/rtti/module.f.ts").Number, null]>;
+}, {
+    readonly jsonrpc: "2.0";
+    readonly error: {
+        readonly code: import("../../../types/rtti/module.f.ts").Number;
+        readonly message: import("../../../types/rtti/module.f.ts").String;
+        readonly data: import("../../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
+    };
+    readonly id: import("../../../types/rtti/module.f.ts").Or<[import("../../../types/rtti/module.f.ts").String, import("../../../types/rtti/module.f.ts").Number, null]>;
+}]>;
+export type Response = Ts<typeof response>;
+/** Decodes an untrusted value as a JSON-RPC request / notification. */
+export declare const decodeRequest: import("../../../types/rtti/common/module.f.ts").Validate<{
+    readonly jsonrpc: "2.0";
+    readonly method: import("../../../types/rtti/module.f.ts").String;
+    readonly params: import("../../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
+    readonly id: import("../../../types/rtti/module.f.ts").Or<readonly [import("../../../types/rtti/module.f.ts").Or<[import("../../../types/rtti/module.f.ts").String, import("../../../types/rtti/module.f.ts").Number, null]>, undefined]>;
+}>;
+/** A method implementation: maps `params` to a result or an `RpcError`. */
+export type Handler = (params: Unknown | undefined) => Result<Unknown, RpcError>;
+/** A `method` name → `Handler` map. */
+export type Handlers = {
+    readonly [method: string]: Handler;
+};
+/** Builds an `RpcError` with the given `code` and `message` (no `data`). */
+export declare const rpcError: (code: number) => (message: string) => RpcError;
+export declare const parseError: import("../../../types/rtti/ts/module.f.ts").StructTs<{
+    readonly code: import("../../../types/rtti/module.f.ts").Number;
+    readonly message: import("../../../types/rtti/module.f.ts").String;
+    readonly data: import("../../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
+}>;
+export declare const invalidRequest: import("../../../types/rtti/ts/module.f.ts").StructTs<{
+    readonly code: import("../../../types/rtti/module.f.ts").Number;
+    readonly message: import("../../../types/rtti/module.f.ts").String;
+    readonly data: import("../../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
+}>;
+export declare const methodNotFound: import("../../../types/rtti/ts/module.f.ts").StructTs<{
+    readonly code: import("../../../types/rtti/module.f.ts").Number;
+    readonly message: import("../../../types/rtti/module.f.ts").String;
+    readonly data: import("../../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
+}>;
+export declare const invalidParams: import("../../../types/rtti/ts/module.f.ts").StructTs<{
+    readonly code: import("../../../types/rtti/module.f.ts").Number;
+    readonly message: import("../../../types/rtti/module.f.ts").String;
+    readonly data: import("../../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
+}>;
+export declare const internalError: import("../../../types/rtti/ts/module.f.ts").StructTs<{
+    readonly code: import("../../../types/rtti/module.f.ts").Number;
+    readonly message: import("../../../types/rtti/module.f.ts").String;
+    readonly data: import("../../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
+}>;
+/**
+ * Dispatches an already-parsed JSON-RPC value against `handlers`.
+ *
+ * - invalid envelope → `Invalid Request` (`-32600`) with `id: null`
+ * - notification (no `id`) → `null` (never a response)
+ * - unknown method → `Method not found` (`-32601`)
+ * - otherwise the handler's `ok` / `error` result becomes a success / error response
+ */
+export declare const dispatch: (handlers: Handlers) => (value: Unknown) => Response | null;
+export {};

package/fs/{json → media/json}/rpc/module.f.js

@@ -14,9 +14,9 @@
  *
  * @module
  */
-import { number, string, or, option } from "../../types/rtti/module.f.js";
-import { validate } from "../../types/rtti/validate/module.f.js";
-import { unknown } from "../module.f.js";
+import { number, string, or, option } from '../../../types/rtti/module.f.js';
+import { validate } from '../../../types/rtti/validate/module.f.js';
+import { unknown } from '../module.f.js';
 export const jsonrpc = '2.0';
 /** Request/response identifier: a string, a number, or `null`. */
 const id = or(string, number, null);

package/fs/{json → media/json}/rpc/proof.f.js

@@ -1,7 +1,7 @@
-import { assert, assertEq } from "../../asserts/module.f.js";
-import { ok, error } from "../../types/result/module.f.js";
-import { validate } from "../../types/rtti/validate/module.f.js";
-import { error as errorSchema, decodeRequest, dispatch, rpcError, parseError, invalidRequest, methodNotFound, invalidParams, internalError, } from "./module.f.js";
+import { assert, assertEq } from '../../../asserts/module.f.js';
+import { ok, error } from '../../../types/result/module.f.js';
+import { validate } from '../../../types/rtti/validate/module.f.js';
+import { error as errorSchema, decodeRequest, dispatch, rpcError, parseError, invalidRequest, methodNotFound, invalidParams, internalError, } from './module.f.js';
 const isOk = (r) => r[0] === 'ok';
 const handlers = {
     ping: () => ok('pong'),

package/fs/media/json/schema/module.f.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Converts an rtti schema to a JSON Schema (draft 2020-12) object.
+ *
+ * Mirrors the visitor structure of `fs/types/rtti/ts/module.f.ts` (`printer` / `toTs`),
+ * but emits a JSON Schema object instead of a TypeScript type string.
+ *
+ * @module
+ */
+import { type Type as RttiType } from '../../../types/rtti/module.f.ts';
+import type { Ts } from '../../../types/rtti/ts/module.f.ts';
+import type { Phantom } from '../../../types/phantom/module.f.ts';
+import { unknown as jsonUnknown } from '../module.f.ts';
+declare const unknownThunk: () => readonly ['const', {
+    readonly type: import("../../../types/rtti/module.f.ts").Or<["boolean", "number", "string", "integer", "array", "object", undefined]>;
+    readonly const: import("../../../types/rtti/module.f.ts").Or<readonly [typeof jsonUnknown, undefined]>;
+    readonly not: import("../../../types/rtti/module.f.ts").Or<readonly [Phantom<() => readonly ['const', /*elided*/ any], UnknownConst>, undefined]>;
+    readonly anyOf: import("../../../types/rtti/module.f.ts").Or<readonly [import("../../../types/rtti/module.f.ts").Type1<"array", Phantom<() => readonly ['const', any], UnknownConst>>, undefined]>;
+    readonly items: import("../../../types/rtti/module.f.ts").Or<[Phantom<() => readonly ['const', any], UnknownConst>, false, undefined]>;
+    readonly prefixItems: import("../../../types/rtti/module.f.ts").Or<readonly [import("../../../types/rtti/module.f.ts").Type1<"array", Phantom<() => readonly ['const', any], UnknownConst>>, undefined]>;
+    readonly properties: import("../../../types/rtti/module.f.ts").Or<readonly [import("../../../types/rtti/module.f.ts").Type1<"record", Phantom<() => readonly ['const', any], UnknownConst>>, undefined]>;
+    readonly required: import("../../../types/rtti/module.f.ts").Or<readonly [import("../../../types/rtti/module.f.ts").Type1<"array", import("../../../types/rtti/module.f.ts").String>, undefined]>;
+    readonly additionalProperties: import("../../../types/rtti/module.f.ts").Or<readonly [Phantom<() => readonly ['const', any], UnknownConst>, undefined]>;
+}];
+/** rtti schema for a JSON Schema (draft 2020-12) document. */
+export declare const unknown: Phantom<typeof unknownThunk, UnknownConst>;
+/** A JSON Schema (draft 2020-12) document — the subset of keywords that `toJsonSchema` emits. */
+export type Unknown = Ts<typeof unknown>;
+declare const unknownConst: {
+    readonly type: import("../../../types/rtti/module.f.ts").Or<["boolean", "number", "string", "integer", "array", "object", undefined]>;
+    readonly const: import("../../../types/rtti/module.f.ts").Or<readonly [typeof jsonUnknown, undefined]>;
+    readonly not: import("../../../types/rtti/module.f.ts").Or<readonly [Phantom<typeof unknownThunk, UnknownConst>, undefined]>;
+    readonly anyOf: import("../../../types/rtti/module.f.ts").Or<readonly [import("../../../types/rtti/module.f.ts").Type1<"array", Phantom<typeof unknownThunk, UnknownConst>>, undefined]>;
+    readonly items: import("../../../types/rtti/module.f.ts").Or<[Phantom<typeof unknownThunk, UnknownConst>, false, undefined]>;
+    readonly prefixItems: import("../../../types/rtti/module.f.ts").Or<readonly [import("../../../types/rtti/module.f.ts").Type1<"array", Phantom<typeof unknownThunk, UnknownConst>>, undefined]>;
+    readonly properties: import("../../../types/rtti/module.f.ts").Or<readonly [import("../../../types/rtti/module.f.ts").Type1<"record", Phantom<typeof unknownThunk, UnknownConst>>, undefined]>;
+    readonly required: import("../../../types/rtti/module.f.ts").Or<readonly [import("../../../types/rtti/module.f.ts").Type1<"array", import("../../../types/rtti/module.f.ts").String>, undefined]>;
+    readonly additionalProperties: import("../../../types/rtti/module.f.ts").Or<readonly [Phantom<typeof unknownThunk, UnknownConst>, undefined]>;
+};
+/**
+ * Hand-written base type used as the `$out` annotation on `unknown`.
+ *
+ * The `?` markers are required even though `Ts<>` already includes `undefined`
+ * in each field type. Without `?`, `Unknown = UnknownConst` would require all
+ * 9 fields to be present in every object literal returned by `toJsonSchema`,
+ * because TypeScript distinguishes "field absent" (`?`) from "field present but
+ * undefined" (`T | undefined`). JSON Schema objects only include the fields
+ * they need, so all fields must be optional.
+ */
+type UnknownConst = {
+    readonly type?: Ts<typeof unknownConst.type>;
+    readonly const?: Ts<typeof unknownConst.const>;
+    readonly not?: Ts<typeof unknownConst.not>;
+    readonly anyOf?: Ts<typeof unknownConst.anyOf>;
+    readonly items?: Ts<typeof unknownConst.items>;
+    readonly prefixItems?: Ts<typeof unknownConst.prefixItems>;
+    readonly properties?: Ts<typeof unknownConst.properties>;
+    readonly required?: Ts<typeof unknownConst.required>;
+    readonly additionalProperties?: Ts<typeof unknownConst.additionalProperties>;
+};
+/**
+ * Converts an rtti `Type` to a JSON Schema (draft 2020-12) object.
+ *
+ * | rtti                                          | JSON Schema                                                                         |
+ * |-----------------------------------------------|-------------------------------------------------------------------------------------|
+ * | `boolean` / `number` / `string`               | `{ "type": "..." }`                                                                 |
+ * | `bigint`                                      | `{ "type": "integer" }` (lossy; JSON integers are IEEE-754 doubles)                 |
+ * | `unknown`                                     | `{}` (always-true schema)                                                           |
+ * | primitive const (`42`, `'x'`, `true`, `null`) | `{ "const": <value> }`                                                              |
+ * | `bigint` const                                | `{ "const": Number(value) }` (lossy for \|value\| > MAX_SAFE_INTEGER)               |
+ * | `undefined` const                             | `{ "not": {} }` (no JSON value satisfies this)                                      |
+ * | struct `{ a: T, … }`                          | `{ "type": "object", "properties": { "a": …T… }, "required": [non-optional keys] }` |
+ * | tuple `[A, B]`                                | `{ "type": "array", "prefixItems": […A…, …B…], "items": false }`                    |
+ * | `array(T)`                                    | `{ "type": "array", "items": …T… }`                                                 |
+ * | `record(T)`                                   | `{ "type": "object", "additionalProperties": …T… }`                                 |
+ * | `or(...types)`                                | `{ "anyOf": […each…] }`                                                             |
+ */
+export declare const toJsonSchema: (rtti: RttiType) => Unknown;
+export {};

package/fs/{json → media/json}/schema/module.f.js

@@ -6,8 +6,8 @@
  *
  * @module
  */
-import { array, option, or, record, string } from "../../types/rtti/module.f.js";
-import { unknown as jsonUnknown } from "../module.f.js";
+import { array, option, or, record, string } from '../../../types/rtti/module.f.js';
+import { unknown as jsonUnknown } from '../module.f.js';
 const unknownThunk = () => ['const', unknownConst];
 /** rtti schema for a JSON Schema (draft 2020-12) document. */
 export const unknown = unknownThunk;

package/fs/{json → media/json}/schema/proof.f.js

@@ -1,6 +1,6 @@
-import { boolean, number, string, bigint, unknown, array, record, or, option } from "../../types/rtti/module.f.js";
-import { stringify } from "../module.f.js";
-import { toJsonSchema, unknown as schemaUnknown } from "./module.f.js";
+import { boolean, number, string, bigint, unknown, array, record, or, option } from '../../../types/rtti/module.f.js';
+import { stringify } from '../module.f.js';
+import { toJsonSchema, unknown as schemaUnknown } from './module.f.js';
 const serialize = (v) => stringify(e => e)(v);
 const eq = (rtti, expected) => () => {
     const result = serialize(toJsonSchema(rtti));

package/fs/{json → media/json}/serializer/module.f.d.ts

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { type List } from '../../types/list/module.f.ts';
+import { type List } from '../../../types/list/module.f.ts';
 /**
  * Serializes a string as a JSON string literal.
  */

package/fs/{json → media/json}/serializer/module.f.js

@@ -3,8 +3,8 @@
  *
  * @module
  */
-import { flat, reduce, empty } from "../../types/list/module.f.js";
-import {} from "../../types/function/operator/module.f.js";
+import { flat, reduce, empty } from '../../../types/list/module.f.js';
+import {} from '../../../types/function/operator/module.f.js';
 const jsonStringify = JSON.stringify;
 /**
  * Serializes a string as a JSON string literal.

package/fs/{json → media/json}/serializer/proof.f.js

@@ -1,5 +1,5 @@
-import { arrayWrap, boolSerialize, numberSerialize, objectWrap, stringSerialize } from "./module.f.js";
-import * as list from "../../types/list/module.f.js";
+import { arrayWrap, boolSerialize, numberSerialize, objectWrap, stringSerialize } from './module.f.js';
+import * as list from '../../../types/list/module.f.js';
 const { toArray } = list;
 export const proof = {
     arrayWrap: [

package/fs/{json → media/json}/tokenizer/module.f.d.ts

@@ -1,5 +1,5 @@
-import { type List } from '../../types/list/module.f.ts';
-import { type EofToken, type ErrorToken, type NumberToken, type StringToken } from '../../js/tokenizer/module.f.ts';
+import { type List } from '../../../types/list/module.f.ts';
+import { type EofToken, type ErrorToken, type NumberToken, type StringToken } from '../../../js/tokenizer/module.f.ts';
 export type JsonToken = {
     readonly kind: 'true' | 'false' | 'null';
 } | {

package/fs/{json → media/json}/tokenizer/module.f.js

@@ -3,10 +3,10 @@
  *
  * @module
  */
-import {} from "../../types/function/operator/module.f.js";
-import { concat, empty, flat, stateScan } from "../../types/list/module.f.js";
-import { multiply } from "../../types/bigfloat/module.f.js";
-import { tokenize as jsTokenize } from "../../js/tokenizer/module.f.js";
+import {} from '../../../types/function/operator/module.f.js';
+import { concat, empty, flat, stateScan } from '../../../types/list/module.f.js';
+import { multiply } from '../../../types/bigfloat/module.f.js';
+import { tokenize as jsTokenize } from '../../../js/tokenizer/module.f.js';
 const mapToken = input => {
     switch (input.kind) {
         case '{':

package/fs/{json → media/json}/tokenizer/proof.f.js

@@ -1,8 +1,8 @@
-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";
+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 = {

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

@@ -0,0 +1,37 @@
+/**
+ * Media-type detection entry point: dialect-tagged JSON recognition layered
+ * on top of the byte-signature / UTF-8 detector.
+ *
+ * `fs/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 `fs/media/type` already determined), try
+ * parsing it as JSON and validating it against a known dialect's rtti schema
+ * (currently just `vnd.fjs.revision` — see `fs/media/revision`). A match
+ * reports the dialect's derived media type; anything that isn't valid JSON,
+ * or doesn't validate against a known dialect, falls through to the
+ * `fs/media/type` verdict unchanged.
+ *
+ * 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.
+ *
+ * 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 (`fs/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';
+/**
+ * Classifies a whole buffered `Vec`, the same three-way `{ length, mime_type,
+ * type }` shape as `fs/media/type` `detectVec`, but with dialect-tagged JSON
+ * recognized ahead of the plain `text/plain` fallback.
+ */
+export declare const detect: (bytes: Vec) => DetectMeta;

package/fs/media/module.f.js

@@ -0,0 +1,24 @@
+import { fromVec } from '../text/utf8/module.f.js';
+import { detectVec } from './type/module.f.js';
+import { decodeText as decodeRevisionText, mediaType as revisionMediaType } from './revision/module.f.js';
+import { assert } from '../asserts/module.f.js';
+/**
+ * Classifies a whole buffered `Vec`, the same three-way `{ length, mime_type,
+ * type }` shape as `fs/media/type` `detectVec`, but with dialect-tagged JSON
+ * recognized ahead of the plain `text/plain` fallback.
+ */
+export const detect = (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;
+    }
+    const text = fromVec(bytes);
+    // `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.
+    assert(text !== null, 'detect: type text implies fromVec succeeds');
+    const [tag] = decodeRevisionText(text);
+    return tag === 'ok' ? { ...base, mime_type: revisionMediaType } : base;
+};

package/fs/media/proof.f.d.ts

@@ -0,0 +1,9 @@
+export declare const proof: {
+    validRevision: () => void;
+    keyOrderIndependent: () => void;
+    invalidRevisionFallsThrough: () => void;
+    ordinaryJsonFallsThrough: () => void;
+    plainTextFallsThrough: () => void;
+    binaryFallsThrough: () => void;
+    largeNonJsonWithinBound: () => void;
+};