functionalscript 0.35.2 → 0.37.0

package/fs/media/proof.f.js

@@ -0,0 +1,57 @@
+import { assertEq } from '../asserts/module.f.js';
+import { msb, u8ListToVec, repeat, vec8 } from '../types/bit_vec/module.f.js';
+import { detect } from './module.f.js';
+import { dialect } from './revision/module.f.js';
+// All test strings here are ASCII, so char code === UTF-8 byte value.
+const utf8Bytes = (s) => u8ListToVec(msb)([...s].map(c => c.charCodeAt(0)));
+const revisionJson = `{"dialect":"${dialect}","subject":"8","parents":[]}`;
+export const proof = {
+    // A valid revision blob is recognized and reported under its derived media type.
+    validRevision: () => {
+        const m = detect(utf8Bytes(revisionJson));
+        assertEq(m.type, 'text');
+        assertEq(m.mime_type, 'application/vnd.fjs.revision+json');
+    },
+    // Key order carries no meaning: a valid revision whose `dialect` key is
+    // not first must still be detected.
+    keyOrderIndependent: () => {
+        const text = `{"parents":[],"subject":"8","dialect":"${dialect}"}`;
+        const m = detect(utf8Bytes(text));
+        assertEq(m.mime_type, 'application/vnd.fjs.revision+json');
+    },
+    // Structurally invalid revision (bad multi-parent snapshot rule) falls
+    // through to the ordinary text/plain classification.
+    invalidRevisionFallsThrough: () => {
+        const text = `{"dialect":"${dialect}","subject":"8","parents":["8","r"]}`;
+        const m = detect(utf8Bytes(text));
+        assertEq(m.type, 'text');
+        assertEq(m.mime_type, 'text/plain');
+    },
+    // Ordinary JSON with no `dialect` field at all falls through unchanged.
+    ordinaryJsonFallsThrough: () => {
+        const m = detect(utf8Bytes('{"hello":"world"}'));
+        assertEq(m.type, 'text');
+        assertEq(m.mime_type, 'text/plain');
+    },
+    // Plain (non-JSON) text is unaffected.
+    plainTextFallsThrough: () => {
+        const m = detect(utf8Bytes('hello'));
+        assertEq(m.type, 'text');
+        assertEq(m.mime_type, 'text/plain');
+    },
+    // Binary content (magic-byte hit) is unaffected by dialect detection.
+    binaryFallsThrough: () => {
+        const m = detect(u8ListToVec(msb)([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]));
+        assertEq(m.type, 'base64');
+        assertEq(m.mime_type, 'image/png');
+    },
+    // A large blob is still bounded by the single-`Vec` `maxLength` cap; this
+    // only exercises that dialect detection doesn't change size handling for
+    // non-JSON content within that bound.
+    largeNonJsonWithinBound: () => {
+        const a = repeat(1000n)(vec8(0x61n)); // 1,000 bytes of 'a'
+        const m = detect(a);
+        assertEq(m.type, 'text');
+        assertEq(m.mime_type, 'text/plain');
+    },
+};

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

@@ -0,0 +1,51 @@
+import { type ValidationError } from '../../types/rtti/validate/module.f.ts';
+import type { Ts } from '../../types/rtti/ts/module.f.ts';
+import type { Unknown } from '../json/module.f.ts';
+import { type Result } from '../../types/result/module.f.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.revision';
+/** The media type derived from {@link dialect}: `application/vnd.fjs.revision+json`. */
+export declare const mediaType: "application/vnd.fjs.revision+json";
+/**
+ * rtti schema for the snapshot-reference type: a cbase32 CAS hash string.
+ *
+ * This is `string` at the rtti (structural) level — rtti schemas can't
+ * express string-content refinements — so cbase32 decodability, and the
+ * rejection of `https://` bridge URLs and any other location-addressed
+ * reference form, is enforced by {@link isHash} / {@link validate} below,
+ * not by this schema on its own.
+ */
+export declare const hash: import("../../types/rtti/module.f.ts").String;
+/**
+ * rtti schema for a `revision` BLOB. See the README for the full semantics of
+ * each field; `dialect` is the type discriminant, matched here as an exact
+ * literal so structural validation alone rejects any other dialect's blob.
+ */
+export declare const revisionSchema: {
+    readonly dialect: "vnd.fjs.revision";
+    readonly subject: import("../../types/rtti/module.f.ts").String;
+    readonly parents: import("../../types/rtti/module.f.ts").Type1<"array", import("../../types/rtti/module.f.ts").String>;
+    readonly snapshot: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+    readonly generation: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Number, undefined]>;
+    readonly archived: import("../../types/rtti/module.f.ts").Or<readonly [true, undefined]>;
+};
+/** The TypeScript type derived from {@link revisionSchema} — the single source of truth. */
+export type Revision = Ts<typeof revisionSchema>;
+/** True when `s` decodes as a cbase32 CAS hash (rejects `https://` and any other non-cbase32 string). */
+export declare const isHash: (s: string) => boolean;
+/** Either a structural validation error or a semantic (snapshot-reference) error message. */
+export type RevisionError = ValidationError | string;
+/**
+ * Validates an already-parsed JSON value as a `revision` BLOB: structural
+ * (rtti) validation followed by the snapshot-reference semantic checks.
+ */
+export declare const validate: (value: Unknown) => Result<Revision, RevisionError>;
+/**
+ * Decodes `text` as a `revision` BLOB: JSON-parses it, then validates it per
+ * {@link validate}. Detection is semantic, not syntactic — any JSON that
+ * satisfies the schema is a revision, regardless of key order or whitespace.
+ */
+export declare const decodeText: (text: string) => Result<Revision, RevisionError>;

package/fs/media/revision/module.f.js

@@ -0,0 +1,110 @@
+/**
+ * `vnd.fjs.revision` — one step in the evolution of a mutable object on top
+ * of an immutable content-addressable store.
+ *
+ * A revision BLOB links back to its parent revision(s) (a DAG, not just a
+ * chain, so concurrent edits can merge) and carries the full materialized
+ * content of that step — never an incremental diff (see the versioning rule
+ * in the README). This module is the pure format only: the rtti schema, the
+ * `dialect` tag, and decode/validate. No store access, no effects — head
+ * resolution, materialization, and reverse indexes are a separate, deferred
+ * concern.
+ *
+ * See `README.md` for the full spec.
+ *
+ * @module
+ */
+import { array, number, option, string } from '../../types/rtti/module.f.js';
+import { validate as rttiValidate } from '../../types/rtti/validate/module.f.js';
+import { parse as jsonParse } from '../json/parser/module.f.js';
+import { tokenize as jsonTokenize } from '../json/tokenizer/module.f.js';
+import { stringToList } from '../../text/utf16/module.f.js';
+import { cBase32ToVec } from '../../basen/cbase32/module.f.js';
+import { error, ok } from '../../types/result/module.f.js';
+/**
+ * Format tag: names the dialect of this BLOB. The media type it is served
+ * with is derived mechanically: `application/` + `dialect` + `+json`.
+ */
+export const dialect = 'vnd.fjs.revision';
+/** The media type derived from {@link dialect}: `application/vnd.fjs.revision+json`. */
+export const mediaType = `application/${dialect}+json`;
+/**
+ * rtti schema for the snapshot-reference type: a cbase32 CAS hash string.
+ *
+ * This is `string` at the rtti (structural) level — rtti schemas can't
+ * express string-content refinements — so cbase32 decodability, and the
+ * rejection of `https://` bridge URLs and any other location-addressed
+ * reference form, is enforced by {@link isHash} / {@link validate} below,
+ * not by this schema on its own.
+ */
+export const hash = string;
+/**
+ * rtti schema for a `revision` BLOB. See the README for the full semantics of
+ * each field; `dialect` is the type discriminant, matched here as an exact
+ * literal so structural validation alone rejects any other dialect's blob.
+ */
+export const revisionSchema = {
+    dialect,
+    subject: string,
+    parents: array(hash),
+    snapshot: option(hash),
+    generation: option(number),
+    archived: option(true),
+};
+/** Structural-only validator: checks the shape, not the snapshot-reference semantics. */
+const validateShape = rttiValidate(revisionSchema);
+/** True when `s` decodes as a cbase32 CAS hash (rejects `https://` and any other non-cbase32 string). */
+export const isHash = (s) => cBase32ToVec(s) !== null;
+/**
+ * Checks the snapshot-reference semantics of an already shape-valid revision:
+ * every parent must be a hash; `snapshot`, when present, must be a hash;
+ * when `snapshot` is absent, zero parents fall back to `subject` (which must
+ * then be a hash), exactly one parent inherits that parent's snapshot, and
+ * more than one parent without an explicit `snapshot` is invalid — there is
+ * no single parent snapshot to inherit, and falling back to `subject` would
+ * silently lose the merge result.
+ */
+const checkReferences = (r) => {
+    for (const p of r.parents) {
+        if (!isHash(p)) {
+            return error(`parent is not a valid hash: ${p}`);
+        }
+    }
+    if (r.snapshot !== undefined) {
+        return isHash(r.snapshot) ? ok(r) : error(`snapshot is not a valid hash: ${r.snapshot}`);
+    }
+    if (r.parents.length === 0) {
+        return isHash(r.subject)
+            ? ok(r)
+            : error(`subject must be a valid hash when snapshot is absent and there are no parents: ${r.subject}`);
+    }
+    if (r.parents.length === 1) {
+        return ok(r);
+    }
+    return error('snapshot is required when a revision has more than one parent');
+};
+/**
+ * Validates an already-parsed JSON value as a `revision` BLOB: structural
+ * (rtti) validation followed by the snapshot-reference semantic checks.
+ */
+export const validate = (value) => {
+    const [t, v] = validateShape(value);
+    if (t === 'error') {
+        return error(v);
+    }
+    return checkReferences(v);
+};
+/** Parses `text` as JSON without relying on `JSON.parse` (the shared `fs/media/json` parser/tokenizer). */
+const parseJson = (text) => jsonParse(jsonTokenize(stringToList(text)));
+/**
+ * Decodes `text` as a `revision` BLOB: JSON-parses it, then validates it per
+ * {@link validate}. Detection is semantic, not syntactic — any JSON that
+ * satisfies the schema is a revision, regardless of key order or whitespace.
+ */
+export const decodeText = (text) => {
+    const [t, v] = parseJson(text);
+    if (t === 'error') {
+        return error(v);
+    }
+    return validate(v);
+};

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

@@ -0,0 +1,29 @@
+export declare const proof: {
+    dialectAndMediaType: () => void;
+    isHash: {
+        validHash: () => void;
+        httpsRejected: () => void;
+        arbitraryStringRejected: () => void;
+    };
+    validate: {
+        firstRevisionFallsBackToSubjectHash: () => void;
+        firstRevisionRejectsNonHashSubject: () => void;
+        explicitSnapshotAllowsArbitrarySubject: () => void;
+        singleParentInheritsSnapshot: () => void;
+        multiParentWithoutSnapshotRejected: () => void;
+        multiParentWithSnapshotAccepted: () => void;
+        httpsRejectedInParents: () => void;
+        httpsRejectedInSnapshot: () => void;
+        httpsRejectedAsFallbackSubject: () => void;
+        archivedAccepted: () => void;
+        wrongDialectRejected: () => void;
+        missingSubjectRejected: () => void;
+        extraFieldsAccepted: () => void;
+    };
+    decodeText: {
+        validJson: () => void;
+        keyOrderIndependent: () => void;
+        malformedJsonRejected: () => void;
+        ordinaryJsonRejected: () => void;
+    };
+};

package/fs/media/revision/proof.f.js

@@ -0,0 +1,119 @@
+import { assert, assertEq } from '../../asserts/module.f.js';
+import { dialect, mediaType, isHash, validate, decodeText } from './module.f.js';
+// Valid cbase32 hashes (round-tripped in fs/basen/cbase32/proof.f.ts): single
+// cbase32 symbols, cheap to write inline here.
+const h1 = '8';
+const h2 = 'r';
+const revisionOf = (extra) => ({
+    dialect,
+    subject: h1,
+    parents: [],
+    ...extra,
+});
+export const proof = {
+    dialectAndMediaType: () => {
+        assertEq(dialect, 'vnd.fjs.revision');
+        assertEq(mediaType, 'application/vnd.fjs.revision+json');
+    },
+    isHash: {
+        validHash: () => assert(isHash(h1)),
+        httpsRejected: () => assert(!isHash('https://example.com/blob/abc')),
+        arbitraryStringRejected: () => assert(!isHash('not-a-hash!')),
+    },
+    validate: {
+        // Zero parents, no `snapshot`: `subject` is the fallback snapshot
+        // reference and must itself be a hash.
+        firstRevisionFallsBackToSubjectHash: () => {
+            const [t] = validate(revisionOf({}));
+            assertEq(t, 'ok');
+        },
+        // Zero parents, no `snapshot`, `subject` is not a hash: invalid.
+        firstRevisionRejectsNonHashSubject: () => {
+            const [t] = validate(revisionOf({ subject: 'my-config' }));
+            assertEq(t, 'error');
+        },
+        // `snapshot` present: `subject` may be an arbitrary string.
+        explicitSnapshotAllowsArbitrarySubject: () => {
+            const [t] = validate(revisionOf({ subject: 'my-config', snapshot: h2 }));
+            assertEq(t, 'ok');
+        },
+        // Exactly one parent, no `snapshot`: the parent's snapshot is inherited,
+        // and `subject` may be an arbitrary string.
+        singleParentInheritsSnapshot: () => {
+            const [t] = validate(revisionOf({ subject: 'my-config', parents: [h2] }));
+            assertEq(t, 'ok');
+        },
+        // More than one parent with no `snapshot`: invalid — no single parent
+        // snapshot to inherit, and falling back to `subject` would silently
+        // lose the merge result.
+        multiParentWithoutSnapshotRejected: () => {
+            const [t] = validate(revisionOf({ subject: 'my-config', parents: [h1, h2] }));
+            assertEq(t, 'error');
+        },
+        // A merge revision with an explicit `snapshot` is valid.
+        multiParentWithSnapshotAccepted: () => {
+            const [t, v] = validate(revisionOf({ subject: 'my-config', parents: [h1, h2], snapshot: h2 }));
+            assertEq(t, 'ok');
+            assertEq(v.snapshot, h2);
+        },
+        // `https://` bridge URLs are rejected wherever a hash is required.
+        httpsRejectedInParents: () => {
+            const [t] = validate(revisionOf({ subject: 'my-config', parents: ['https://example.com/x'], snapshot: h2 }));
+            assertEq(t, 'error');
+        },
+        httpsRejectedInSnapshot: () => {
+            const [t] = validate(revisionOf({ subject: 'my-config', snapshot: 'https://example.com/x' }));
+            assertEq(t, 'error');
+        },
+        httpsRejectedAsFallbackSubject: () => {
+            const [t] = validate(revisionOf({ subject: 'https://example.com/x' }));
+            assertEq(t, 'error');
+        },
+        // `archived` follows the presence-only `option(true)` idiom.
+        archivedAccepted: () => {
+            const [t] = validate(revisionOf({ archived: true }));
+            assertEq(t, 'ok');
+        },
+        // Wrong dialect tag: structural validation rejects it outright.
+        wrongDialectRejected: () => {
+            const [t] = validate({ dialect: 'vnd.fjs.other', subject: h1, parents: [] });
+            assertEq(t, 'error');
+        },
+        // Missing required fields: rejected.
+        missingSubjectRejected: () => {
+            const [t] = validate({ dialect, parents: [] });
+            assertEq(t, 'error');
+        },
+        // rtti structs are open: extra fields don't break validation — the
+        // additive forward-compatibility path the versioning rule relies on.
+        extraFieldsAccepted: () => {
+            const [t] = validate(revisionOf({ future: 'field' }));
+            assertEq(t, 'ok');
+        },
+    },
+    decodeText: {
+        validJson: () => {
+            const [t, v] = decodeText(JSON.stringify(revisionOf({ generation: 0 })));
+            assertEq(t, 'ok');
+            assertEq(v.subject, h1);
+        },
+        // Key order carries no meaning: detection parses the JSON and
+        // validates the parsed value, so `dialect` need not be first.
+        keyOrderIndependent: () => {
+            const text = `{"parents":[],"subject":"${h1}","dialect":"${dialect}"}`;
+            const [t] = decodeText(text);
+            assertEq(t, 'ok');
+        },
+        malformedJsonRejected: () => {
+            const [t] = decodeText('{not json');
+            assertEq(t, 'error');
+        },
+        // Ordinary JSON that isn't a revision at all falls through as an error
+        // here — `fs/media`'s composed detector is what falls back to the
+        // ordinary detector; this module only reports validity.
+        ordinaryJsonRejected: () => {
+            const [t] = decodeText('{"hello":"world"}');
+            assertEq(t, 'error');
+        },
+    },
+};

package/fs/{mime → media/type}/module.f.d.ts

@@ -32,12 +32,12 @@
  *
  * @module
  */
-import { type Vec } from '../types/bit_vec/module.f.ts';
-import type { Nullable } from '../types/nullable/module.f.ts';
-import { type Effect, type Operation } from '../effects/module.f.ts';
-import type { List } from '../effects/list/module.f.ts';
-import type { IoResult } from '../effects/node/module.f.ts';
-import { type Utf8State } from '../text/utf8/module.f.ts';
+import { type Vec } from '../../types/bit_vec/module.f.ts';
+import type { Nullable } from '../../types/nullable/module.f.ts';
+import { type Effect, type Operation } from '../../effects/module.f.ts';
+import type { List } from '../../effects/list/module.f.ts';
+import type { IoResult } from '../../effects/node/module.f.ts';
+import { type Utf8State } from '../../text/utf8/module.f.ts';
 /**
  * Detects the MIME type of `bytes` from its leading magic-byte signature.
  *

package/fs/{mime → media/type}/module.f.js

@@ -32,12 +32,12 @@
  *
  * @module
  */
-import { msb, fromSentinel, length, u8List } from "../types/bit_vec/module.f.js";
-import { iterable } from "../types/list/module.f.js";
-import { pure } from "../effects/module.f.js";
-import { ok, error } from "../types/result/module.f.js";
-import { isValidCodePoint, isTextCodePoint } from "../text/code_point/module.f.js";
-import { utf8ByteToCodePointOp } from "../text/utf8/module.f.js";
+import { msb, fromSentinel, length, u8List } from '../../types/bit_vec/module.f.js';
+import { iterable } from '../../types/list/module.f.js';
+import { pure } from '../../effects/module.f.js';
+import { ok, error } from '../../types/result/module.f.js';
+import { isValidCodePoint, isTextCodePoint } from '../../text/code_point/module.f.js';
+import { utf8ByteToCodePointOp } from '../../text/utf8/module.f.js';
 const { startsWith, removeFront } = msb;
 // Each signature is written as a hex literal whose leading `1` nibble is a
 // sentinel marking the start of the byte run (so leading zero bytes survive)

package/fs/{mime → media/type}/proof.f.js

@@ -1,9 +1,9 @@
-import { assert, assertEq } from "../asserts/module.f.js";
-import { msb, u8ListToVec, vec8, repeat, empty } from "../types/bit_vec/module.f.js";
-import { decode } from "../effects/module.f.js";
-import { nonEmpty, empty as emptyList } from "../effects/list/module.f.js";
-import { ok } from "../types/result/module.f.js";
-import { detect, detectStream, detectVec } from "./module.f.js";
+import { assert, assertEq } from '../../asserts/module.f.js';
+import { msb, u8ListToVec, vec8, repeat, empty } from '../../types/bit_vec/module.f.js';
+import { decode } from '../../effects/module.f.js';
+import { nonEmpty, empty as emptyList } from '../../effects/list/module.f.js';
+import { ok } from '../../types/result/module.f.js';
+import { detect, detectStream, detectVec } from './module.f.js';
 // Builds a big-endian `Vec` from a list of byte values — mirrors how the CAS
 // store would hold the leading bytes of a stored blob.
 const bytes = (...b) => u8ListToVec(msb)(b);

package/fs/module.f.d.ts

@@ -0,0 +1,2 @@
+import { type NodeProgram } from './effects/node/module.f.ts';
+export declare const main: NodeProgram;

package/fs/{fjs/module.f.js → module.f.js}

@@ -3,14 +3,14 @@
  *
  * @module
  */
-import { compile } from "../djs/module.f.js";
-import { main as testMain } from "../emergent_testing/module.f.js";
-import { commands as casCommands } from "../cas/cli/module.f.js";
-import { main as ciMain } from "../ci/module.f.js";
-import { import_ } from "../effects/node/module.f.js";
-import { dispatch } from "../cli/module.f.js";
-import { casMcpServer } from "../cas/mcp/module.f.js";
-import { pure } from "../effects/module.f.js";
+import { compile } from './djs/module.f.js';
+import { main as testMain } from './emergent_testing/module.f.js';
+import { commands as casCommands } from './cas/cli/module.f.js';
+import { main as ciMain } from './ci/module.f.js';
+import { import_ } from './effects/node/module.f.js';
+import { dispatch } from './cli/module.f.js';
+import { casMcpServer } from './cas/mcp/module.f.js';
+import { pure } from './effects/module.f.js';
 const commands = [
     {
         names: ['test', 't'],

package/fs/module.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { main } from './module.f.js';
+import { run } from './effects/node/module.js';
+await run(main);

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

@@ -38,3 +38,9 @@ export declare const join: (...list: readonly string[]) => string;
  * E.g. `relativize('/repo', '/repo/fs/a.ts')` → `'./fs/a.ts'`.
  */
 export declare const relativize: (base: string, path: string) => string;
+/**
+ * Returns `true` when `prefix` is a strict ancestor of `path` in segment space:
+ * every segment of `prefix` matches the corresponding segment of `path`, and
+ * `path` has at least one additional segment.
+ */
+export declare const isProperPrefix: (prefix: readonly string[], path: readonly string[]) => boolean;

package/fs/path/module.f.js

@@ -1,5 +1,5 @@
-import { fold, last, take, length, concat as listConcat, toArray } from "../types/list/module.f.js";
-import { join as listJoin, concat as stringConcat } from "../types/string/module.f.js";
+import { fold, last, take, length, concat as listConcat, toArray } from '../types/list/module.f.js';
+import { join as listJoin, concat as stringConcat } from '../types/string/module.f.js';
 const foldNormalizeOp = input => state => {
     switch (input) {
         case '':
@@ -63,3 +63,9 @@ export const join = (...list) => list.join('/');
  * E.g. `relativize('/repo', '/repo/fs/a.ts')` → `'./fs/a.ts'`.
  */
 export const relativize = (base, path) => base !== '' && path.startsWith(base) ? `.${path.slice(base.length)}` : path;
+/**
+ * Returns `true` when `prefix` is a strict ancestor of `path` in segment space:
+ * every segment of `prefix` matches the corresponding segment of `path`, and
+ * `path` has at least one additional segment.
+ */
+export const isProperPrefix = (prefix, path) => prefix.length < path.length && prefix.every((seg, i) => seg === path[i]);

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

@@ -4,4 +4,5 @@ export declare const proof: {
     joinTest: (() => void)[];
     relativizeTest: (() => void)[];
     toPosixTest: (() => void)[];
+    isProperPrefixTest: (() => void)[];
 };

package/fs/path/proof.f.js

@@ -1,4 +1,4 @@
-import { concat, join, normalize, relativize, toPosix } from "./module.f.js";
+import { concat, isProperPrefix, join, normalize, relativize, toPosix } from "./module.f.js";
 const normalizeTest = [
     () => {
         const norm = normalize("dir/file.json");
@@ -129,4 +129,42 @@ const toPosixTest = [
         }
     },
 ];
-export const proof = { normalizeTest, concatTest, joinTest, relativizeTest, toPosixTest };
+const isProperPrefixTest = [
+    () => {
+        const r = isProperPrefix(['a', 'b'], ['a', 'b', 'c']);
+        if (r !== true) {
+            throw r;
+        }
+    },
+    () => {
+        const r = isProperPrefix(['a', 'b'], ['a', 'b']);
+        if (r !== false) {
+            throw r;
+        }
+    },
+    () => {
+        const r = isProperPrefix(['a', 'x'], ['a', 'b', 'c']);
+        if (r !== false) {
+            throw r;
+        }
+    },
+    () => {
+        const r = isProperPrefix(['a', 'b', 'c'], ['a', 'b']);
+        if (r !== false) {
+            throw r;
+        }
+    },
+    () => {
+        const r = isProperPrefix([], ['a']);
+        if (r !== true) {
+            throw r;
+        }
+    },
+    () => {
+        const r = isProperPrefix([], []);
+        if (r !== false) {
+            throw r;
+        }
+    },
+];
+export const proof = { normalizeTest, concatTest, joinTest, relativizeTest, toPosixTest, isProperPrefixTest };

package/fs/{fjs/proof.f.d.ts → proof.f.d.ts}

@@ -2,6 +2,7 @@ export declare const proof: {
     help: () => void;
     compileRequiresArgs: () => void;
     runModule: () => void;
+    mcp: () => void;
     throw: {
         runImportError: () => void;
     };

package/fs/{fjs/proof.f.js → proof.f.js}

@@ -1,7 +1,7 @@
-import { assert, assertEq } from "../asserts/module.f.js";
-import { pure } from "../effects/module.f.js";
-import { defaultNodeProgramOptions, emptyState, virtual } from "../effects/node/virtual/module.f.js";
-import { main } from "./module.f.js";
+import { assert, assertEq } from './asserts/module.f.js';
+import { pure } from './effects/module.f.js';
+import { defaultNodeProgramOptions, emptyState, virtual } from './effects/node/virtual/module.f.js';
+import { main } from './module.f.js';
 const makeOptions = (args) => ({ ...defaultNodeProgramOptions, args });
 const run = (root) => (args) => virtual({ ...emptyState, root })(main(makeOptions(args)));
 const appMain = ({ args }) => pure(args.length);
@@ -22,6 +22,12 @@ export const proof = {
         // `run` strips the command and file name, so `main` sees two arguments
         assertEq(code, 2);
     },
+    mcp: () => {
+        // stdin is empty in the virtual environment, so the server sees EOF
+        // immediately and shuts down cleanly, exercising the `mcp` handler.
+        const [, code] = run({})(['mcp']);
+        assertEq(code, 0);
+    },
     throw: {
         runImportError: () => {
             run({})(['run', 'missing.f.ts']);

package/fs/sul/id/module.f.js

@@ -5,15 +5,15 @@
  *
  * @module
  */
-import { toArray } from "../../types/list/module.f.js";
-import { length, msb, uint, uintChunkList, unpack, vec } from "../../types/bit_vec/module.f.js";
-import { assertEq } from "../../asserts/module.f.js";
-import { utf8 } from "../../text/module.f.js";
-import { secp256r1 } from "../../crypto/secp/module.f.js";
-import { base32 } from "../../crypto/sha2/module.f.js";
-import { literal3ToVec } from "../level/literal/module.f.js";
-import { log2 } from "../../types/bigint/module.f.js";
-import { asBase, asNominal } from "../../types/nominal/module.f.js";
+import { toArray } from '../../types/list/module.f.js';
+import { length, msb, uint, uintChunkList, unpack, vec } from '../../types/bit_vec/module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
+import { utf8 } from '../../text/module.f.js';
+import { secp256r1 } from '../../crypto/secp/module.f.js';
+import { base32 } from '../../crypto/sha2/module.f.js';
+import { literal3ToVec } from '../level/literal/module.f.js';
+import { log2 } from '../../types/bigint/module.f.js';
+import { asBase, asNominal } from '../../types/nominal/module.f.js';
 // 32 bytes = 256 bits.
 //
 //              0               1

package/fs/sul/id/proof.f.js

@@ -1,8 +1,8 @@
-import { assert, assertEq } from "../../asserts/module.f.js";
-import { mask } from "../../types/bigint/module.f.js";
-import { vec } from "../../types/bit_vec/module.f.js";
-import { compress, hashId, isHash, isRaw, level3Id, rawId } from "./module.f.js";
-import { asBase } from "../../types/nominal/module.f.js";
+import { assert, assertEq } from '../../asserts/module.f.js';
+import { mask } from '../../types/bigint/module.f.js';
+import { vec } from '../../types/bit_vec/module.f.js';
+import { compress, hashId, isHash, isRaw, level3Id, rawId } from './module.f.js';
+import { asBase } from '../../types/nominal/module.f.js';
 // literal3ToVec bit patterns for symbols used below:
 //   0  → vec(8n)(0n)     4  → vec(8n)(3n)
 //   1  → vec(8n)(1n)     10 → vec(8n)(5n)

package/fs/sul/level/hash/module.f.js

@@ -3,9 +3,9 @@
  *
  * @module
  */
-import { emptyState, patriciaTrie } from "../../../types/patricia_trie/module.f.js";
-import { compress } from "../../id/module.f.js";
-import { asBase } from "../../../types/nominal/module.f.js";
+import { emptyState, patriciaTrie } from '../../../types/patricia_trie/module.f.js';
+import { compress } from '../../id/module.f.js';
+import { asBase } from '../../../types/nominal/module.f.js';
 /**
  * Returns a streaming encoder for hash-level symbols.
  *