worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/forma/world/sensitivity.d.ts

@@ -0,0 +1,3 @@
+import type * as IR from "../../world-ir/types.generated.js";
+import type { SourceFile } from "./compile.js";
+export declare const sensitivitySourceDiagnostics: (files: readonly SourceFile[]) => IR.Diagnostic[];

package/dist/_internal/forma/world/sensitivity.js

@@ -0,0 +1,118 @@
+import { sourceSyntax } from "./source-syntax.js";
+import {} from "@forma-language/forma/reader";
+import { sensitivityOfType, sensitiveTypeHelp, sensitiveSealHelp } from "../../ir-checks/index.js";
+import { headOf, items, isSym, spanOf, symName, mapPairs, option } from "./lowering/syntax.js";
+/** Source maps are inspected before lowering can lose an unsupported type shape. */
+const reference = (node) => {
+    if (isSym(node))
+        return node.name;
+    if (node._tag === "List" || node._tag === "Vector")
+        return node.items.map(reference);
+    if (node._tag === "Map")
+        return ["Record", ...node.pairs.map(([key, value]) => [reference(key), reference(value)])];
+    return "Literal";
+};
+export const sensitivitySourceDiagnostics = (files) => {
+    if (!files.some((f) => f.text.includes("Sensitive")))
+        return [];
+    const forms = files.flatMap((file) => {
+        const parsed = sourceSyntax(file);
+        return parsed.errors.length ? [] : parsed.forms.map((node) => ({ file, node }));
+    });
+    const definitions = forms
+        .filter(({ node }) => headOf(node) === "type")
+        .map(({ file, node }) => {
+        const parts = items(node), name = parts[1], body = parts[2];
+        return {
+            file,
+            node,
+            name: symName(name) ?? symName(items(name)[0]) ?? "",
+            body,
+            generic: !isSym(name),
+        };
+    })
+        .filter((d) => d.body && d.name);
+    const aliases = definitions.map((d) => ({
+        name: d.name,
+        type: reference(d.body),
+        at: spanOf(d.file.id, d.node),
+    }));
+    const errors = [];
+    const fail = (file, node, code, message) => errors.push({
+        code,
+        severity: "error",
+        message,
+        at: spanOf(file.id, node),
+        help: code === "E_UNSEALED_SENSITIVE" ? sensitiveSealHelp : sensitiveTypeHelp,
+    });
+    const containsMap = (node) => node._tag === "Map" || items(node).some(containsMap);
+    const shape = (file, node) => {
+        const parts = items(node);
+        if (headOf(node) === "Sensitive") {
+            const c = parts[1];
+            if (parts.length !== 3) {
+                fail(file, node, "E_SENSITIVE_TYPE", "Sensitive needs exactly a classification and base type.");
+                return;
+            }
+            const result = sensitivityOfType(["Sensitive", c ? reference(c) : "", "String"], []);
+            if (!result.ok) {
+                fail(file, c ?? node, "E_SENSITIVE_TYPE", result.message);
+                return;
+            }
+            if (parts[2]._tag !== "Sym" && parts[2]._tag !== "List" && parts[2]._tag !== "Vector")
+                fail(file, parts[2], "E_SENSITIVE_TYPE", "The sensitive base needs a representable canonical type.");
+        }
+        if (node._tag === "Map")
+            node.pairs.forEach(([, v]) => shape(file, v));
+        else
+            parts.forEach((p) => shape(file, p));
+    };
+    for (const d of definitions) {
+        shape(d.file, d.body);
+        const classification = sensitivityOfType(reference(d.body), aliases);
+        if (d.name === "Sensitive")
+            fail(d.file, d.node, "E_SENSITIVE_TYPE", "Sensitive is a reserved type constructor.");
+        else if (classification.ok &&
+            classification.classes.length &&
+            (d.generic || containsMap(d.body)))
+            fail(d.file, d.node, "E_SENSITIVE_TYPE", "This alias shape cannot preserve sensitive classification in canonical IR.");
+    }
+    if (errors.length)
+        return errors;
+    const fields = (file, node, sealed = new Set()) => {
+        for (const [key, type] of mapPairs(node)) {
+            shape(file, type);
+            const result = sensitivityOfType(reference(type), aliases);
+            if (result.ok && result.classes.length && !sealed.has((symName(key) ?? "").replace(/^:/, "")))
+                fail(file, type, "E_UNSEALED_SENSITIVE", "Sensitive data needs a supported sealing policy.");
+        }
+    };
+    for (const { file, node } of forms) {
+        const head = headOf(node);
+        if (["role", "entity", "evidence"].includes(head ?? "")) {
+            const fieldMap = items(node)
+                .filter((n) => n._tag === "Map")
+                .at(-1);
+            const seal = option(node, "sealed-by");
+            const sealed = new Set((head === "evidence" && seal ? mapPairs(fieldMap) : mapPairs(seal)).map(([key]) => (symName(key) ?? "").replace(/^:/, "")));
+            fields(file, items(node)
+                .filter((n) => n._tag === "Map")
+                .at(-1), sealed);
+        }
+        if (head === "component") {
+            fields(file, option(node, "inputs"));
+            fields(file, option(node, "params"));
+        }
+        if (head === "derive") {
+            fields(file, option(node, "params"));
+            const returns = option(node, "returns");
+            if (returns) {
+                shape(file, returns);
+                const result = sensitivityOfType(reference(returns), aliases);
+                if (result.ok && result.classes.length)
+                    fail(file, returns, "E_UNSEALED_SENSITIVE", "A sensitive derived value needs a supported sealing policy.");
+            }
+        }
+    }
+    return errors;
+};

package/dist/_internal/forma/world/source-syntax.d.ts

@@ -0,0 +1,6 @@
+import type { SourceFile } from "./compile.js";
+/** Share reader work within a compile; edits to a reused source object invalidate it. */
+export declare const sourceSyntax: (file: SourceFile) => {
+    errors: readonly import("@forma-language/forma/reader").ParseError[];
+    readonly forms: readonly import("@forma-language/forma/reader").SExpr[];
+};

package/dist/_internal/forma/world/source-syntax.js

@@ -0,0 +1,27 @@
+import { parse, toSExprMany } from "@forma-language/forma/reader";
+const cache = new WeakMap();
+const read = (text) => {
+    let parsed = parse(text);
+    const errors = parsed.errors;
+    let forms;
+    return {
+        errors,
+        // Some located checks intentionally inspect the reader's recovered tree before elaboration.
+        get forms() {
+            if (!forms) {
+                forms = toSExprMany(parsed.redTree);
+                parsed = undefined;
+            }
+            return forms;
+        },
+    };
+};
+/** Share reader work within a compile; edits to a reused source object invalidate it. */
+export const sourceSyntax = (file) => {
+    const old = cache.get(file);
+    if (old?.text === file.text)
+        return old.result;
+    const result = read(file.text);
+    cache.set(file, { text: file.text, result });
+    return result;
+};

package/dist/_internal/forma/world/status-handling.d.ts

@@ -0,0 +1,3 @@
+import type * as IR from "../../world-ir/types.generated.js";
+/** Conservative branch checking, not a proof engine. Built-in output folds retain all statuses. */
+export declare const statusHandlingDiagnostics: (ir: IR.WorldIR) => readonly IR.Diagnostic[];

package/dist/_internal/forma/world/status-handling.js

@@ -0,0 +1,143 @@
+const exceptional = ["Unknown", "NotApplicable"];
+const keyOf = (e) => JSON.stringify(e, (key, value) => (key === "at" ? undefined : value));
+/** Conservative branch checking, not a proof engine. Built-in output folds retain all statuses. */
+export const statusHandlingDiagnostics = (ir) => {
+    const components = new Map(ir.components.map((c) => [c.name, c])), diagnostics = new Map();
+    const unwrap = (t, seen = new Set()) => {
+        if (typeof t === "string") {
+            const alias = ir.types.find((a) => a.name === t);
+            if (alias && !seen.has(t))
+                return unwrap(alias.type, new Set([...seen, t]));
+        }
+        if (Array.isArray(t) && (t[0] === "Option" || t[0] === "Brand"))
+            return unwrap(t[1], seen);
+        return t;
+    };
+    const reference = (t) => {
+        const type = unwrap(t);
+        return Array.isArray(type) && type[0] === "Id" && typeof type[1] === "string"
+            ? type[1]
+            : undefined;
+    };
+    const typeOf = (e, scope) => {
+        if (e.k === "var")
+            return scope.get(e.name);
+        if (e.k === "inst") {
+            const target = components.get(reference(typeOf(e.of, scope)) ?? "");
+            return [...(target?.inputs ?? []), ...(target?.params ?? [])].find((f) => f.name === e.field)
+                ?.type;
+        }
+        if (e.k === "read")
+            return ir.roles.find((r) => r.name === e.role)?.fields.find((f) => f.name === e.field)?.type;
+        if (e.k === "attr")
+            return ir.entities
+                .find((r) => e.attr.startsWith(r.ns + "/"))
+                ?.fields.find((f) => f.attr === e.attr)?.type;
+        if (e.k === "list")
+            return ["List", e.items[0] ? (typeOf(e.items[0], scope) ?? "Unknown") : "Unknown"];
+        if (e.k === "if") {
+            const a = typeOf(e.then, scope), b = typeOf(e.else, scope);
+            return JSON.stringify(a) === JSON.stringify(b) ? a : undefined;
+        }
+        if (e.k === "call") {
+            if (e.fn === "filter")
+                return e.args[1] ? typeOf(e.args[1], scope) : undefined;
+            return ir.derives.find((d) => d.name === e.fn)?.returns;
+        }
+        return undefined;
+    };
+    const outputRead = (e, scope) => {
+        if (e.k !== "inst" || (e.of.k === "var" && e.of.name === "self"))
+            return false;
+        const target = components.get(reference(typeOf(e.of, scope)) ?? "");
+        return target
+            ? target.outputs.some((o) => o.name === e.field)
+            : ir.components.some((c) => c.outputs.some((o) => o.name === e.field));
+    };
+    const mark = (handled, key, statuses) => new Map([...handled, [key, new Set([...(handled.get(key) ?? []), ...statuses])]]);
+    const walk = (e, scope, handled) => {
+        if (outputRead(e, scope)) {
+            const missing = exceptional.filter((status) => !handled.get(keyOf(e))?.has(status));
+            if (missing.length)
+                diagnostics.set(JSON.stringify(e.at), {
+                    code: "W_UNHANDLED_STATUS",
+                    severity: "warning",
+                    message: `Custom child-output expression does not explicitly handle ${missing.join(" and ")}.`,
+                    at: e.at,
+                    help: "Use all-of/any-of/status-of for output folds, or branch with (status-is? child.output :Unknown) and (status-is? child.output :NotApplicable) before consuming that same output. Helper expressions need the same branches; unsupported control flow is conservatively warned. No automatic fix can choose the intended result.",
+                });
+        }
+        if (e.k === "if") {
+            const test = e.test;
+            if (test.k === "call" &&
+                test.fn === "status-is?" &&
+                test.args.length === 2 &&
+                outputRead(test.args[0], scope) &&
+                test.args[1].k === "kw" &&
+                (test.args[1].v === "Unknown" || test.args[1].v === "NotApplicable")) {
+                const key = keyOf(test.args[0]), status = test.args[1].v;
+                walk(test, scope, mark(handled, key, exceptional));
+                walk(e.then, scope, mark(handled, key, exceptional));
+                walk(e.else, scope, mark(handled, key, [status]));
+            }
+            else {
+                walk(test, scope, handled);
+                walk(e.then, scope, handled);
+                walk(e.else, scope, handled);
+            }
+        }
+        else if (e.k === "call") {
+            for (const [i, arg] of e.args.entries()) {
+                if (arg.k === "fn" && i === 0 && (e.fn === "map" || e.fn === "filter")) {
+                    const list = unwrap(e.args[1] ? typeOf(e.args[1], scope) : undefined), inner = new Map(scope);
+                    arg.params.forEach((p) => inner.set(p, Array.isArray(list) && list[0] === "List" ? list[1] : "Unknown"));
+                    walk(arg.body, inner, new Map());
+                }
+                else
+                    walk(arg, scope, handled);
+            }
+        }
+        else if (e.k === "fn") {
+            const inner = new Map(scope);
+            e.params.forEach((p) => inner.delete(p));
+            walk(e.body, inner, new Map());
+        }
+        else if (e.k === "list")
+            e.items.forEach((item) => walk(item, scope, handled));
+        else if (e.k === "read" || e.k === "attr" || e.k === "inst")
+            walk(e.of, scope, handled);
+    };
+    const visit = (value, scope) => {
+        if (!value || typeof value !== "object")
+            return;
+        if ("k" in value)
+            walk(value, scope, new Map());
+        else
+            for (const [key, child] of Object.entries(value))
+                if (key !== "at")
+                    visit(child, scope);
+    };
+    for (const component of ir.components) {
+        const scope = new Map([...component.inputs, ...component.params].map((f) => [f.name, f.type]));
+        scope.set("self", ["Id", component.name]);
+        scope.set("attached", ["List", ["Id", ir.libraries[0].subject]]);
+        visit(component, scope);
+        for (const d of ir.decisions ?? [])
+            if (d.of === component.name)
+                visit(d, scope);
+        for (const evidence of ir.evidence)
+            if (evidence.of === component.name) {
+                const fields = new Map([
+                    ...scope,
+                    ...evidence.fields.map((f) => [f.name, f.type]),
+                ]);
+                visit(evidence, fields);
+                for (const interaction of ir.interactions)
+                    if (interaction.produces === evidence.name)
+                        visit(interaction, fields);
+            }
+    }
+    for (const d of ir.derives)
+        walk(d.body, new Map(d.params.map((p) => [p.name, p.type])), new Map());
+    return [...diagnostics.values()];
+};

package/dist/_internal/forma/world/surface.d.ts

@@ -0,0 +1,30 @@
+import type { SourceFile } from "./compile.js";
+import type * as IR from "../../world-ir/types.generated.js";
+export declare const DIAGNOSTIC_RENAMES: Readonly<Record<string, string>>;
+export declare const diagnosticCode: (code: string, severity: string) => string;
+export declare const OLD_OPERATORS: Readonly<Record<string, string>>;
+export interface SurfaceFix {
+    readonly src: string;
+    readonly from: number;
+    readonly to: number;
+    readonly text: string;
+    readonly expected: string;
+}
+export type SurfaceDiagnostic = IR.Diagnostic & {
+    readonly fix?: SurfaceFix;
+};
+/** One-release migration errors. Reader nodes keep strings, comments and identifiers untouched. */
+export declare const operatorDiagnostics: (files: readonly SourceFile[]) => SurfaceDiagnostic[];
+/** Forma expands Bool and/or/not before inference. Adapt Truth calls for that boundary,
+ * then map its locations back to the authored text. Lowering always reads original source. */
+export declare const elaborationSource: (file: SourceFile) => {
+    source: string;
+    span: <T extends {
+        startOffset: number;
+        endOffset: number;
+    }>(span: T) => T;
+};
+/** Inspect declaration positions only: expression calls and scenario data are not forms. */
+export declare const coreDiagnostics: (files: readonly SourceFile[]) => IR.Diagnostic[];
+/** Keep operator spellings in canonical IR display text stable across source migrations. */
+export declare const canonicalConditionText: (text: string) => string;

package/dist/_internal/forma/world/surface.js

@@ -0,0 +1,213 @@
+import { CHILD_FORMS, TOP_LEVEL_FORMS } from "./authoring-help.js";
+import { sourceSyntax } from "./source-syntax.js";
+import { headOf, items, spanOf, option, symName } from "./lowering/syntax.js";
+export const DIAGNOSTIC_RENAMES = Object.fromEntries([
+    "read/syntax",
+    "parse/syntax",
+    "surface/invalid-form",
+    "artifact/untyped-runtime-declaration",
+    ...[
+        "unknown-form",
+        "hole-type",
+        "unknown-reference",
+        "reference-type",
+        "missing-slot",
+        "invalid-slot-value",
+        "malformed-form",
+        "duplicate-declaration",
+        "form-check",
+        "missing-identifier",
+        "validation-failed",
+        "action-definition",
+        "construct-failed",
+        "expansion-failed",
+        "form-definition",
+        "no-construct-hook",
+        "result-type-failed",
+        "unsupported-form",
+    ].map((s) => `elaborate/${s}`),
+].map((code) => [code, `E_${code.toUpperCase().replaceAll(/[/-]/g, "_")}`]));
+export const diagnosticCode = (code, severity) => (Object.hasOwn(DIAGNOSTIC_RENAMES, code) ? DIAGNOSTIC_RENAMES[code] : undefined) ??
+    (/^[a-z]/.test(code)
+        ? `${severity === "warning" ? "W" : severity === "info" ? "I" : "E"}_${code.toUpperCase().replaceAll(/[^A-Z0-9]/g, "_")}`
+        : code);
+export const OLD_OPERATORS = {
+    "all?": "and",
+    "any?": "or",
+    negate: "not",
+    "not=": "!=",
+};
+/** One-release migration errors. Reader nodes keep strings, comments and identifiers untouched. */
+export const operatorDiagnostics = (files) => {
+    const diagnostics = [];
+    for (const file of files) {
+        const walk = (node) => {
+            const head = headOf(node), replacement = head && Object.hasOwn(OLD_OPERATORS, head) && OLD_OPERATORS[head];
+            if (replacement) {
+                const xs = items(node), name = xs[0];
+                const vector = xs.length === 2 && xs[1]?._tag === "Vector" && (head === "all?" || head === "any?")
+                    ? xs[1]
+                    : undefined;
+                const at = spanOf(file.id, vector ? node : name);
+                const text = vector
+                    ? file.text.slice(node.loc.start, name.loc.start) +
+                        replacement +
+                        file.text.slice(name.loc.end, vector.loc.start) +
+                        file.text.slice(vector.loc.start + 1, vector.loc.end - 1) +
+                        file.text.slice(vector.loc.end, node.loc.end)
+                    : replacement;
+                diagnostics.push({
+                    code: "E_RENAMED_OPERATOR",
+                    severity: "error",
+                    message: `${head} was renamed to ${replacement}.`,
+                    help: `Use ${replacement} in both requirements and properties.`,
+                    at,
+                    fix: {
+                        src: file.id,
+                        from: at.from,
+                        to: at.to,
+                        text,
+                        expected: file.text.slice(at.from, at.to),
+                    },
+                });
+            }
+            if (node._tag === "List" || node._tag === "Vector")
+                node.items.forEach(walk);
+            if (node._tag === "Map")
+                node.pairs.forEach(([k, v]) => {
+                    walk(k);
+                    walk(v);
+                });
+        };
+        sourceSyntax(file).forms.forEach(walk);
+    }
+    return diagnostics;
+};
+/** Forma expands Bool and/or/not before inference. Adapt Truth calls for that boundary,
+ * then map its locations back to the authored text. Lowering always reads original source. */
+export const elaborationSource = (file) => {
+    const edits = [];
+    const walk = (node, bool = false) => {
+        const head = headOf(node), xs = items(node);
+        if (head === "property" || head === "scenario" || head === "type")
+            return;
+        if (node._tag === "List" && !bool && ["and", "or", "not"].includes(head ?? "")) {
+            edits.push({
+                from: xs[0].loc.start,
+                to: xs[0].loc.end,
+                text: head === "and" ? "all?" : head === "or" ? "any?" : "negate",
+            });
+            if (head !== "not") {
+                const collection = xs.length === 2;
+                if (!collection) {
+                    const start = xs[1]?.loc.start ?? xs[0].loc.end;
+                    edits.push({ from: start, to: start, text: xs[1] ? "[" : " [" });
+                    edits.push({ from: node.loc.end - 1, to: node.loc.end - 1, text: "]" });
+                }
+            }
+        }
+        if (node._tag === "List" || node._tag === "Vector")
+            node.items.forEach((child, i) => walk(child, (head === "if" && (i === 1 || bool)) ||
+                (head === "filter" && i === 1) ||
+                (bool && ["and", "or", "not", "fn"].includes(head ?? ""))));
+        if (node._tag === "Map")
+            node.pairs.forEach(([k, v]) => {
+                walk(k);
+                walk(v);
+            });
+    };
+    sourceSyntax(file).forms.forEach((f) => {
+        if (headOf(f) === "derive" && symName(option(f, "returns")) === "Bool") {
+            const body = items(f).at(-1);
+            if (body)
+                walk(body, true);
+        }
+        else
+            walk(f);
+    });
+    edits.sort((a, b) => a.from - b.from || a.to - b.to);
+    let source = "", cursor = 0;
+    const offsets = [];
+    const append = (text, start, original) => {
+        for (let i = 0; i < text.length; i++)
+            offsets.push(start + (original ? i : 0));
+        source += text;
+    };
+    for (const edit of edits) {
+        append(file.text.slice(cursor, edit.from), cursor, true);
+        append(edit.text, edit.from, false);
+        cursor = edit.to;
+    }
+    append(file.text.slice(cursor), cursor, true);
+    offsets.push(file.text.length);
+    const offset = (n) => offsets[n] ?? file.text.length;
+    const location = (n) => {
+        const before = file.text.slice(0, n), lines = before.split("\n");
+        return { line: lines.length, col: lines.at(-1).length + 1 };
+    };
+    return {
+        source,
+        span: (span) => {
+            const startOffset = offset(span.startOffset), endOffset = offset(span.endOffset);
+            const start = location(startOffset), end = location(endOffset);
+            return {
+                ...span,
+                startOffset,
+                endOffset,
+                startLine: start.line,
+                startColumn: start.col,
+                endLine: end.line,
+                endColumn: end.col,
+            };
+        },
+    };
+};
+/** Inspect declaration positions only: expression calls and scenario data are not forms. */
+export const coreDiagnostics = (files) => {
+    const diagnostics = [];
+    for (const file of files) {
+        const visit = (node, metadata) => {
+            const head = headOf(node), form = metadata.find((m) => m.name === head);
+            if (!form)
+                return;
+            if (form.tier === "extended")
+                diagnostics.push({
+                    code: "I_EXTENDED_FORM",
+                    severity: "info",
+                    message: `${head} is an extended form.`,
+                    help: "The core forms are source, entity, evidence, component, requirement, action, output, decision, scenario and property. See AUTHORING.md for extended forms.",
+                    at: spanOf(file.id, items(node)[0]),
+                });
+            const children = CHILD_FORMS.metadata.get(head);
+            if (children)
+                items(node)
+                    .slice(1)
+                    .forEach((child) => visit(child, children));
+        };
+        sourceSyntax(file).forms.forEach((form) => visit(form, TOP_LEVEL_FORMS.metadata));
+    }
+    return diagnostics;
+};
+/** Keep operator spellings in canonical IR display text stable across source migrations. */
+export const canonicalConditionText = (text) => {
+    const file = { id: "condition", text: elaborationSource({ id: "condition", text }).source };
+    const edits = [];
+    const visit = (node) => {
+        if (headOf(node) === "!=") {
+            const head = items(node)[0];
+            edits.push({ from: head.loc.start, to: head.loc.end });
+        }
+        if (node._tag === "List" || node._tag === "Vector")
+            node.items.forEach(visit);
+        if (node._tag === "Map")
+            node.pairs.forEach(([k, v]) => {
+                visit(k);
+                visit(v);
+            });
+    };
+    sourceSyntax(file).forms.forEach(visit);
+    let result = file.text;
+    for (const edit of edits.sort((a, b) => b.from - a.from))
+        result = result.slice(0, edit.from) + "not=" + result.slice(edit.to);
+    return result;
+};

package/dist/_internal/forma/world/table-expressions.d.ts

@@ -0,0 +1,3 @@
+import { SimpleSemanticEnvironment } from "@forma-language/forma/descriptor";
+/** Forma's public environment hook keeps native inference and lexical child scopes. */
+export declare const tableEnvironment: (env?: SimpleSemanticEnvironment) => SimpleSemanticEnvironment;

package/dist/_internal/forma/world/table-expressions.js

@@ -0,0 +1,41 @@
+import { SimpleSemanticEnvironment } from "@forma-language/forma/descriptor";
+/** Only the inference view is sugar: authored syntax/spans remain the lowering input. */
+const checkingView = (e) => {
+    const list = (items) => ({ _tag: "List", items, loc: e.loc });
+    const sym = (name) => ({ _tag: "Sym", name, loc: e.loc });
+    if (e._tag === "List" && e.items[0]?._tag === "Sym" && e.items[0].name === "table") {
+        const selector = e.items[1], rows = e.items.slice(2);
+        if (!selector || !rows.length || rows.length % 2)
+            return e;
+        // The checker visits every branch; runtime lookup (including unmatched/Unknown) is separate.
+        // Table Boolean literals denote Truth; use true? for a Bool result.
+        const branch = (value) => value._tag === "Bool"
+            ? list([sym("="), value, { _tag: "Bool", value: true, loc: value.loc }])
+            : checkingView(value);
+        let result = branch(rows.at(-1));
+        for (let i = rows.length - 4; i >= 0; i -= 2)
+            result = list([
+                sym("if"),
+                list([sym("true?"), list([sym("="), checkingView(selector), rows[i]])]),
+                branch(rows[i + 1]),
+                result,
+            ]);
+        return result;
+    }
+    if (e._tag === "List" || e._tag === "Vector" || e._tag === "Set") {
+        const items = e.items.map(checkingView);
+        return items.every((item, i) => item === e.items[i]) ? e : { ...e, items };
+    }
+    if (e._tag === "Map") {
+        const pairs = e.pairs.map(([k, v]) => [k, checkingView(v)]);
+        return pairs.every((pair, i) => pair[1] === e.pairs[i][1]) ? e : { ...e, pairs };
+    }
+    return e;
+};
+/** Forma's public environment hook keeps native inference and lexical child scopes. */
+export const tableEnvironment = (env = new SimpleSemanticEnvironment()) => {
+    const infer = env.inferExpression.bind(env), child = env.childScope.bind(env);
+    env.inferExpression = (e) => infer(checkingView(e));
+    env.childScope = () => tableEnvironment(child());
+    return env;
+};

package/dist/_internal/forma-tools/index.d.ts

@@ -0,0 +1,17 @@
+/** Lossless token spelling and UTF-16 spans, including comments, from Forma's reader. */
+export interface Syntax {
+    readonly kind: string;
+    readonly text: string;
+    readonly from: number;
+    readonly to: number;
+    readonly children: readonly Syntax[];
+}
+export declare const readForma: (source: string) => {
+    forms: readonly Syntax[];
+    valid: boolean;
+};
+/** Two spaces, 100 columns (soft for indivisible strings/tokens), LF and a final newline.
+ * Comments are kept verbatim on their own lines. Keyword/value and map pairs share a line.
+ * Invalid source is rejected so a formatter never silently repairs or drops a token.
+ */
+export declare const formatForma: (source: string) => string;