worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/forma-tools/index.js

@@ -0,0 +1,124 @@
+import { parse, isRedNode } from "@forma-language/forma/reader";
+export const readForma = (source) => {
+    const parsed = parse(source);
+    const convert = (element) => {
+        if (!isRedNode(element)) {
+            const comments = element
+                .leadingTrivia()
+                .filter((t) => t.kind === "line-comment")
+                .map((t) => ({
+                kind: "Comment",
+                text: t.text.replace(/[\r\n]+$/, ""),
+                from: t.loc.start,
+                to: t.loc.end,
+                children: [],
+            }));
+            if (["lparen", "rparen", "lbracket", "rbracket", "lbrace", "rbrace", "eof"].includes(element.tokenType()))
+                return comments;
+            const span = element.span();
+            return [
+                ...comments,
+                { kind: "Atom", text: element.text(), from: span.start, to: span.end, children: [] },
+            ];
+        }
+        const children = element.children().flatMap(convert);
+        if (element.kind() === "Root")
+            return children;
+        if (!["List", "Vector", "Map", "Set"].includes(element.kind()))
+            return children;
+        const span = element.span();
+        // Leading comments on an opening delimiter belong before the collection.
+        const leading = [];
+        while (children[0]?.kind === "Comment" && children[0].from < span.start)
+            leading.push(children.shift());
+        return [
+            ...leading,
+            {
+                kind: element.kind(),
+                text: source.slice(span.start, span.end),
+                from: span.start,
+                to: span.end,
+                children,
+            },
+        ];
+    };
+    return { forms: convert(parsed.redTree), valid: parsed.errors.length === 0 };
+};
+const delimiters = {
+    List: ["(", ")"],
+    Vector: ["[", "]"],
+    Map: ["{", "}"],
+    Set: ["#{", "}"],
+};
+const flat = (node) => {
+    if (node.kind === "Comment")
+        return null;
+    const delimit = delimiters[node.kind];
+    if (!delimit)
+        return node.text.includes("\n") ? null : node.text;
+    const parts = node.children.map(flat);
+    return parts.some((p) => p === null) ? null : delimit[0] + parts.join(" ") + delimit[1];
+};
+/** 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 const formatForma = (source) => {
+    const { forms, valid } = readForma(source);
+    if (!valid)
+        throw new SyntaxError("Cannot format invalid Forma source.");
+    const render = (node, column) => {
+        const inline = flat(node);
+        if (inline !== null && column + inline.length <= 100)
+            return inline;
+        const delimit = delimiters[node.kind];
+        if (!delimit)
+            return node.text;
+        const indent = " ".repeat(column + 2);
+        const groups = [];
+        for (let i = 0; i < node.children.length; i++) {
+            const child = node.children[i];
+            const next = node.children[i + 1];
+            if (child.kind !== "Comment" &&
+                next &&
+                next.kind !== "Comment" &&
+                (node.kind === "Map" || (child.kind === "Atom" && child.text.startsWith(":")))) {
+                groups.push([child, next]);
+                i++;
+            }
+            else
+                groups.push([child]);
+        }
+        let result = delimit[0];
+        for (let i = 0; i < groups.length; i++) {
+            const group = groups[i];
+            const parts = [];
+            let col = column + 2;
+            for (const child of group) {
+                const part = render(child, col);
+                parts.push(part);
+                col = part.includes("\n")
+                    ? part.length - part.lastIndexOf("\n") - 1
+                    : col + part.length + 1;
+            }
+            const text = parts.join(" ");
+            // Keep a list's head and declared name together, as in existing worlds.
+            if (i === 0 && node.kind === "List" && group[0]?.kind === "Atom")
+                result += text;
+            else if (i === 1 &&
+                node.kind === "List" &&
+                group.length === 1 &&
+                group[0]?.kind === "Atom" &&
+                !group[0].text.startsWith(":"))
+                result += " " + text;
+            else
+                result += "\n" + indent + text;
+        }
+        if (node.children.at(-1)?.kind === "Comment")
+            result += "\n" + " ".repeat(column);
+        return result + delimit[1];
+    };
+    return (forms
+        .map((form, i) => render(form, 0) + (form.kind !== "Comment" && i < forms.length - 1 ? "\n" : ""))
+        .join("\n") + (forms.length ? "\n" : ""));
+};

package/dist/_internal/ir-checks/advances.d.ts

@@ -0,0 +1,7 @@
+import type { Action } from "../world-ir/types.generated.js";
+/** A scalar keeps its wire representation; consumers can uniformly inspect its targets. */
+export declare const advanceTargets: (action: Pick<Action, "advances">) => readonly string[];
+/** Shared work keys stay inside one home; changing non-key facts never renames work. */
+export declare const stableWorkIdentity: (component: {
+    readonly key: readonly string[];
+}, action: Pick<Action, "idempotency">) => boolean;

package/dist/_internal/ir-checks/advances.js

@@ -0,0 +1,6 @@
+/** A scalar keeps its wire representation; consumers can uniformly inspect its targets. */
+export const advanceTargets = (action) => typeof action.advances === "string" ? [action.advances] : action.advances;
+/** Shared work keys stay inside one home; changing non-key facts never renames work. */
+export const stableWorkIdentity = (component, action) => action.idempotency === undefined ||
+    (action.idempotency.every((e) => e.k === "var" && (e.name === "self" || component.key.includes(e.name))) &&
+        action.idempotency.some((e) => e.k === "var" && (e.name === "self" || e.name === component.key[0])));

package/dist/_internal/ir-checks/agent-reads.d.ts

@@ -0,0 +1,14 @@
+import type * as IR from "../world-ir/types.generated.js";
+import { type SensitiveClass } from "./sensitivity.js";
+export declare const agentReadHelp = "Use :of Component, :reads [input.field], and :may-read [{:class :pii :vault vault-name}]. Grant every source class in its exact vault; grants do not replace current read authority. Powers and execution remain M10.";
+export interface AgentReadPermission {
+    readonly class: SensitiveClass;
+    readonly vault: string;
+}
+export interface AgentReadInfo {
+    readonly path: string;
+    readonly permissions: readonly AgentReadPermission[];
+}
+/** Resolve authored paths, never caller-supplied classification or display-path hints. */
+export declare const agentReadInfo: (ir: IR.WorldIR, agent: IR.Agent, expr: IR.Expr) => AgentReadInfo | undefined;
+export declare const agentReadDiagnostics: (ir: IR.WorldIR) => IR.Diagnostic[];

package/dist/_internal/ir-checks/agent-reads.js

@@ -0,0 +1,118 @@
+import { readTypeModel } from "./read-types.js";
+import { sealingModel } from "./sealing.js";
+import { sensitiveClasses, sensitivityOfType } from "./sensitivity.js";
+export const agentReadHelp = "Use :of Component, :reads [input.field], and :may-read [{:class :pii :vault vault-name}]. Grant every source class in its exact vault; grants do not replace current read authority. Powers and execution remain M10.";
+const one = (values) => values.length === 1 ? values[0] : undefined;
+const only = (value, keys) => Object.keys(value).every((k) => keys.includes(k));
+/** Resolve authored paths, never caller-supplied classification or display-path hints. */
+export const agentReadInfo = (ir, agent, expr) => {
+    const owner = one(ir.components.filter((c) => c.name === agent.of));
+    if (!owner)
+        return undefined;
+    const model = sealingModel(ir);
+    const known = readTypeModel(ir);
+    const resolve = (e) => {
+        if (!e || typeof e !== "object")
+            return undefined;
+        if (e.k === "var") {
+            const field = one([...owner.inputs, ...owner.params].filter((f) => f.name === e.name));
+            return field ? { path: e.name, type: field.type, fields: [] } : undefined;
+        }
+        if (e.k !== "read" && e.k !== "attr")
+            return undefined;
+        const base = resolve(e.of), target = base && model.reference(base.type), record = one([...ir.roles, ...ir.entities].filter((r) => r.name === target));
+        if (!base || !record || !known(base.type))
+            return undefined;
+        let field;
+        if (e.k === "read") {
+            const role = one(ir.roles.filter((r) => r === record && r.name === e.role));
+            field = role && one(role.fields.filter((f) => f.name === e.field));
+        }
+        else {
+            const entity = one(ir.entities.filter((r) => r === record));
+            const matches = ir.entities.flatMap((r) => r.fields).filter((f) => f.attr === e.attr);
+            const found = entity && one(entity.fields.filter((f) => f.attr === e.attr));
+            field =
+                found && matches.length === 1 && found.attr === `${entity.ns}/${found.name}`
+                    ? found
+                    : undefined;
+        }
+        if (!field || !known(field.type))
+            return undefined;
+        const path = `${base.path}.${field.name}`;
+        return e.meta?.path === path
+            ? { path, type: field.type, fields: [...base.fields, field] }
+            : undefined;
+    };
+    const result = resolve(expr);
+    if (!result || !result.fields.length)
+        return undefined;
+    const permissions = new Map();
+    for (const field of result.fields) {
+        const classes = sensitivityOfType(field.type, ir.types);
+        if (!classes.ok)
+            return undefined;
+        for (const classification of classes.classes) {
+            const vault = one((ir.vaults ?? []).filter((v) => v.name === field.sealedBy?.vault));
+            if (!vault || !vault.holds.includes(classification))
+                return undefined;
+            permissions.set(`${classification}:${vault.name}`, {
+                class: classification,
+                vault: vault.name,
+            });
+        }
+    }
+    return { path: result.path, permissions: [...permissions.values()] };
+};
+export const agentReadDiagnostics = (ir) => {
+    const out = [], names = new Set();
+    const report = (message, at) => out.push({
+        code: "E_AGENT_SENSITIVE_READ",
+        severity: "error",
+        message,
+        at,
+        help: agentReadHelp,
+    });
+    for (const agent of ir.agents ?? []) {
+        if (!only(agent, ["name", "doc", "of", "reads", "mayRead", "at"]) ||
+            typeof agent.name !== "string" ||
+            !agent.name.trim() ||
+            names.has(agent.name) ||
+            !one(ir.components.filter((c) => c.name === agent.of)))
+            report("An agent needs a unique name and one declared owning component, with read options only.", agent.at);
+        names.add(agent.name);
+        if (!Array.isArray(agent.reads) || !agent.reads.length || !Array.isArray(agent.mayRead)) {
+            report("An agent needs nonempty reads and an explicit canonical grant list.", agent.at);
+            continue;
+        }
+        const grants = new Set();
+        for (const grant of agent.mayRead) {
+            if (!grant ||
+                !only(grant, ["class", "vault", "at"]) ||
+                !sensitiveClasses.includes(grant.class) ||
+                !one((ir.vaults ?? []).filter((v) => v.name === grant.vault))?.holds.includes(grant.class)) {
+                report("A read grant needs a declared class and a vault that holds it.", grant?.at ?? agent.at);
+                continue;
+            }
+            const key = `${grant.class}:${grant.vault}`;
+            if (grants.has(key))
+                report("Read grants must be unique class/vault pairs.", grant.at);
+            grants.add(key);
+        }
+        const paths = new Set();
+        for (const read of agent.reads) {
+            if (!read || typeof read !== "object") {
+                report("A read must be a concrete authored field path.", agent.at);
+                continue;
+            }
+            const info = agentReadInfo(ir, agent, read);
+            if (!info ||
+                paths.has(info.path) ||
+                info.permissions.some((p) => !grants.has(`${p.class}:${p.vault}`)))
+                report("Every requested path must be known, unique and covered by its exact class/vault grants.", read.at);
+            if (info)
+                paths.add(info.path);
+        }
+    }
+    return out;
+};

package/dist/_internal/ir-checks/amendments.d.ts

@@ -0,0 +1,3 @@
+import type * as IR from "../world-ir/types.generated.js";
+export declare const amendmentHelp = "Use (amend) on evidence with an all-values attestation and an owned public producing interaction action. Correct through that operation with a standing previous evidence ID, reason and fresh human attestation.";
+export declare const amendmentDiagnostics: (ir: Pick<IR.WorldIR, "evidence" | "components" | "interactions" | "componentContracts">) => IR.Diagnostic[];

package/dist/_internal/ir-checks/amendments.js

@@ -0,0 +1,21 @@
+import { componentOperationNames } from "./component-operations.js";
+export const amendmentHelp = "Use (amend) on evidence with an all-values attestation and an owned public producing interaction action. Correct through that operation with a standing previous evidence ID, reason and fresh human attestation.";
+export const amendmentDiagnostics = (ir) => ir.evidence.flatMap((e) => {
+    if (!e.amend)
+        return [];
+    const error = (code, message) => [
+        { code, severity: "error", message, at: e.amend.at, help: amendmentHelp },
+    ];
+    if (!e.attest || e.attest.covers !== "all")
+        return error("E_AMEND_EVIDENCE", "Amendments require an all-values attestation.");
+    const owner = ir.components.find((c) => c.name === e.of);
+    if (!owner ||
+        !owner.actions.some((a) => {
+            const via = a.via;
+            return (via.kind === "interaction" &&
+                componentOperationNames(ir, owner).includes(a.name) &&
+                ir.interactions.some((i) => i.name === via.name && i.produces === e.name));
+        }))
+        return error("E_AMEND_OPERATION", "Amendments require an owned public producing interaction action.");
+    return [];
+});

package/dist/_internal/ir-checks/canonical-json.d.ts

@@ -0,0 +1,3 @@
+/** Canonical JSON data: sorted object keys, ordered arrays, no silent non-JSON coercions. */
+export declare const canonicalJson: (value: unknown) => string;
+export declare const semanticJson: (value: unknown) => string;

package/dist/_internal/ir-checks/canonical-json.js

@@ -0,0 +1,85 @@
+const isSpan = (value) => {
+    if (!value || typeof value !== "object" || Object.keys(value).length !== 5)
+        return false;
+    const span = value;
+    return (typeof span.src === "string" &&
+        ["from", "to", "line", "col"].every((k) => typeof span[k] === "number"));
+};
+const encode = (value, ignoreSpans) => {
+    const active = new Set();
+    const memo = new WeakMap();
+    let numericKeys = false;
+    const visit = (item) => {
+        if (item === null || typeof item === "string" || typeof item === "boolean")
+            return item;
+        if (typeof item === "number" && Number.isFinite(item))
+            return item;
+        if (!item || typeof item !== "object" || active.has(item))
+            throw new TypeError("Cannot canonicalize non-JSON or cyclic value");
+        if (!Array.isArray(item) && Object.prototype.toString.call(item) !== "[object Object]")
+            throw new TypeError("Cannot canonicalize non-JSON object");
+        if (memo.has(item))
+            return memo.get(item);
+        active.add(item);
+        try {
+            // Captured lexical data is passive; resolving Env.get would read a different basis.
+            if (ignoreSpans &&
+                "params" in item &&
+                Array.isArray(item.params) &&
+                "body" in item &&
+                "env" in item &&
+                item.env &&
+                typeof item.env === "object" &&
+                "snapshot" in item.env &&
+                typeof item.env.snapshot === "function")
+                return visit({
+                    closure: { params: item.params, body: item.body, scope: item.env.snapshot() },
+                });
+            let normalized;
+            if (Array.isArray(item))
+                normalized = Array.from(item, visit);
+            else {
+                const record = item;
+                const out = {};
+                for (const key of Object.keys(record).sort()) {
+                    if (ignoreSpans && key === "at" && isSpan(record[key]))
+                        continue;
+                    // Native JSON reorders integer property names; those require lexical emission.
+                    const first = key.charCodeAt(0);
+                    if (first >= 48 &&
+                        first <= 57 &&
+                        String(Number(key) >>> 0) === key &&
+                        key !== "4294967295")
+                        numericKeys = true;
+                    const value = visit(record[key]);
+                    if (key === "__proto__")
+                        Object.defineProperty(out, key, { value, enumerable: true });
+                    else
+                        out[key] = value;
+                }
+                normalized = out;
+            }
+            memo.set(item, normalized);
+            return normalized;
+        }
+        finally {
+            active.delete(item);
+        }
+    };
+    const normalized = visit(value);
+    const lexical = (item) => {
+        if (!item || typeof item !== "object")
+            return JSON.stringify(item);
+        if (Array.isArray(item))
+            return `[${item.map(lexical).join(",")}]`;
+        const record = item;
+        return `{${Object.keys(record)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${lexical(record[key])}`)
+            .join(",")}}`;
+    };
+    return numericKeys ? lexical(normalized) : JSON.stringify(normalized);
+};
+/** Canonical JSON data: sorted object keys, ordered arrays, no silent non-JSON coercions. */
+export const canonicalJson = (value) => encode(value, false);
+export const semanticJson = (value) => encode(value, true);

package/dist/_internal/ir-checks/child-parameters.d.ts

@@ -0,0 +1,2 @@
+import type * as IR from "../world-ir/types.generated.js";
+export declare const childParameterDiagnostics: (ir: Pick<IR.WorldIR, "components" | "types">) => IR.Diagnostic[];

package/dist/_internal/ir-checks/child-parameters.js

@@ -0,0 +1,43 @@
+import { policyValueWithin, policyParameterType } from "./policy-bounds.js";
+export const childParameterDiagnostics = (ir) => {
+    const edges = ir.components.flatMap((parent) => parent.slots.filter((s) => s.with?.length).map((slot) => ({ parent, slot })));
+    if (!edges.length)
+        return [];
+    const result = [], report = (message, at) => result.push({
+        code: "E_PARAM_OUT_OF_BOUNDS",
+        severity: "error",
+        message,
+        at,
+        help: "Set only declared bounded child parameters with fixed safe Int/Duration values in their tightening interval and unit. Use an acyclic composition graph; use account/policy parameters for unsupported shapes.",
+    });
+    const components = new Map(ir.components.map((c) => [c.name, c]));
+    for (const { slot } of edges) {
+        const target = components.get(slot.component), seen = new Set();
+        for (const param of slot.with) {
+            const bound = target?.paramBounds?.find((b) => b.name === param.name), field = target?.params.find((p) => p.name === param.name), type = field ? policyParameterType(field.type, ir.types) : null;
+            if (seen.has(param.name) ||
+                !bound ||
+                !type ||
+                type !== (param.value.unit === "integer" ? "integer" : "duration") ||
+                !policyValueWithin(bound, param.value))
+                report(`${slot.name}/${param.name} is not a valid bounded child parameter.`, param.at);
+            seen.add(param.name);
+        }
+    }
+    const done = new Set(), active = new Set();
+    const cyclic = (name) => {
+        if (active.has(name))
+            return true;
+        if (done.has(name))
+            return false;
+        active.add(name);
+        if (components.get(name)?.slots.some((s) => cyclic(s.component)))
+            return true;
+        active.delete(name);
+        done.add(name);
+        return false;
+    };
+    if (ir.components.some((c) => cyclic(c.name)))
+        report("Models with child parameter overrides require acyclic component composition.", edges[0].slot.with[0].at);
+    return result;
+};

package/dist/_internal/ir-checks/clock-bindings.d.ts

@@ -0,0 +1,3 @@
+import type { ClockDiagnostic } from "./index.js";
+/** Raw IR hosts receive the same guard, at the containing declaration/function span. */
+export declare const clockBindingDiagnostics: (ir: unknown) => ClockDiagnostic[];

package/dist/_internal/ir-checks/clock-bindings.js

@@ -0,0 +1,43 @@
+/** Raw IR hosts receive the same guard, at the containing declaration/function span. */
+export const clockBindingDiagnostics = (ir) => {
+    const out = [];
+    const object = (v) => v && typeof v === "object" ? v : {};
+    const list = (v) => (Array.isArray(v) ? v : []);
+    const check = (names, at) => {
+        if (!names.some((n) => n === "today" || n === "now"))
+            return;
+        out.push({
+            code: "E_CLOCK_BINDING",
+            severity: "error",
+            message: "Clock names cannot be shadowed by runtime bindings.",
+            help: "Rename the binding; today and now are reserved clock expressions. Access role/entity fields through their paths.",
+            ...(at ? { at: at } : {}),
+        });
+    };
+    const root = object(ir);
+    for (const [group, fields] of [
+        ["components", ["inputs", "params"]],
+        ["derives", ["params"]],
+        ["evidence", ["fields"]],
+        ["accounts", ["params"]],
+    ])
+        for (const node of list(root[group]).map(object))
+            for (const field of fields)
+                check(list(node[field]).map((v) => object(v).name), node.at);
+    const walk = (value) => {
+        if (Array.isArray(value)) {
+            value.forEach(walk);
+            return;
+        }
+        if (!value || typeof value !== "object")
+            return;
+        const node = object(value);
+        if (node.k === "fn")
+            check(list(node.params), node.at);
+        for (const [key, v] of Object.entries(node))
+            if (key !== "at")
+                walk(v);
+    };
+    walk(ir);
+    return out;
+};

package/dist/_internal/ir-checks/collect-types.d.ts

@@ -0,0 +1,14 @@
+export type CollectionType = {
+    readonly kind: "String" | "Keyword" | "Bool" | "Int" | "Float" | "Date" | "Instant" | "File";
+} | {
+    readonly kind: "literal";
+    readonly value: string;
+} | {
+    readonly kind: "union";
+    readonly members: readonly CollectionType[];
+};
+/** Scalar collection contracts cannot silently accept relation or structured values. */
+export declare const collectionType: (type: unknown, aliases: readonly {
+    readonly name: string;
+    readonly type: unknown;
+}[], seen?: ReadonlySet<string>) => CollectionType | null;

package/dist/_internal/ir-checks/collect-types.js

@@ -0,0 +1,34 @@
+import { sensitivePayload } from "./sensitivity.js";
+/** Scalar collection contracts cannot silently accept relation or structured values. */
+export const collectionType = (type, aliases, seen = new Set()) => {
+    if (Array.isArray(type)) {
+        // This describes the payload; classification and sealing are checked independently.
+        if (type[0] === "Sensitive") {
+            const payload = sensitivePayload(type);
+            return payload ? collectionType(payload, aliases, seen) : null;
+        }
+        if (type[0] === "Option" || type[0] === "Brand")
+            return type[1] ? collectionType(type[1], aliases, seen) : null;
+        if (type[0] === "Union") {
+            const members = type.slice(1).map((t) => collectionType(t, aliases, seen));
+            return members.length && members.every((m) => m !== null)
+                ? { kind: "union", members }
+                : null;
+        }
+        return null;
+    }
+    if (typeof type !== "string")
+        return null;
+    if (type.startsWith(":"))
+        return { kind: "literal", value: type.slice(1) };
+    if (["String", "Keyword", "Bool", "Int", "Float", "Date", "Instant", "File"].includes(type))
+        return {
+            kind: type,
+        };
+    if (type === "Group")
+        return { kind: "String" };
+    const alias = aliases.find((a) => a.name === type);
+    return alias && !seen.has(type)
+        ? collectionType(alias.type, aliases, new Set([...seen, type]))
+        : null;
+};

package/dist/_internal/ir-checks/component-operations.d.ts

@@ -0,0 +1,4 @@
+import type * as IR from "../world-ir/types.generated.js";
+/** Pre-keyword contract lists remain declarations; omitted legacy components expose no public API. */
+export declare const componentOperationNames: (ir: Pick<IR.WorldIR, "componentContracts">, c: IR.Component) => readonly string[];
+export declare const operationDeclarationProblem: (ir: Pick<IR.WorldIR, "decisions">, c: IR.Component) => IR.Diagnostic | undefined;

package/dist/_internal/ir-checks/component-operations.js

@@ -0,0 +1,23 @@
+/** Pre-keyword contract lists remain declarations; omitted legacy components expose no public API. */
+export const componentOperationNames = (ir, c) => c.operations ?? [
+    ...new Set((ir.componentContracts ?? [])
+        .filter((x) => x.component === c.name)
+        .flatMap((x) => x.operations.map((o) => o.name))),
+];
+export const operationDeclarationProblem = (ir, c) => {
+    if (c.operations === undefined)
+        return;
+    const names = [
+        ...c.actions.map((a) => a.name),
+        ...(ir.decisions ?? []).filter((d) => d.of === c.name).map((d) => d.name),
+    ];
+    if (new Set(c.operations).size !== c.operations.length ||
+        c.operations.some((n) => names.filter((x) => x === n).length !== 1))
+        return {
+            code: "E_NOT_AN_OPERATION",
+            severity: "error",
+            message: `${c.name} declares an unknown or ambiguous public operation.`,
+            at: c.at,
+            help: "Expose only unique authored actions/decisions owned by this component; [] exposes none. Requirements, state and private helpers are not operations.",
+        };
+};

package/dist/_internal/ir-checks/content-digest.d.ts

@@ -0,0 +1,4 @@
+export { canonicalJson } from "./canonical-json.js";
+export declare const sha256: (text: string) => string;
+/** Content identity ignores `at` source spans: moving code is not a semantic change. */
+export declare const contentDigest: (value: unknown) => string;

package/dist/_internal/ir-checks/content-digest.js

@@ -0,0 +1,78 @@
+import { canonicalJson } from "./canonical-json.js";
+export { canonicalJson } from "./canonical-json.js";
+// Content digests for the IR: SHA-256 over canonical JSON (sorted keys). Synchronous, so the
+// compiler runs unchanged in Node, a browser worker and tests.
+// Resolve the pure synchronous primitive once; browser execution keeps the portable hash.
+const nativeHash = globalThis.process?.getBuiltinModule?.("node:crypto")?.hash;
+export const sha256 = (text) => nativeHash ? nativeHash("sha256", text, "hex") : portableSha256(text);
+const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+const portableSha256 = (text) => {
+    const bytes = new TextEncoder().encode(text);
+    const length = bytes.length;
+    const blocks = Math.ceil((length + 9) / 64);
+    const data = new Uint8Array(blocks * 64);
+    data.set(bytes);
+    data[length] = 0x80;
+    const view = new DataView(data.buffer);
+    view.setUint32(data.length - 8, Math.floor((length * 8) / 2 ** 32));
+    view.setUint32(data.length - 4, (length * 8) >>> 0);
+    const h = new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ]);
+    const w = new Uint32Array(64);
+    const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+    for (let block = 0; block < blocks; block++) {
+        for (let i = 0; i < 16; i++)
+            w[i] = view.getUint32(block * 64 + i * 4);
+        for (let i = 16; i < 64; i++) {
+            const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3);
+            const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);
+            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0;
+        }
+        let [a, b, c, d, e, f, g, hh] = h;
+        for (let i = 0; i < 64; i++) {
+            const t1 = (hh +
+                (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) +
+                ((e & f) ^ (~e & g)) +
+                K[i] +
+                w[i]) >>>
+                0;
+            const t2 = ((rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + ((a & b) ^ (a & c) ^ (b & c))) >>> 0;
+            hh = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        h[0] = (h[0] + a) >>> 0;
+        h[1] = (h[1] + b) >>> 0;
+        h[2] = (h[2] + c) >>> 0;
+        h[3] = (h[3] + d) >>> 0;
+        h[4] = (h[4] + e) >>> 0;
+        h[5] = (h[5] + f) >>> 0;
+        h[6] = (h[6] + g) >>> 0;
+        h[7] = (h[7] + hh) >>> 0;
+    }
+    return [...h].map((x) => x.toString(16).padStart(8, "0")).join("");
+};
+/** Content identity ignores `at` source spans: moving code is not a semantic change. */
+export const contentDigest = (value) => sha256(canonicalJson(value === undefined ? null : stripSpans(value)));
+const stripSpans = (value) => Array.isArray(value)
+    ? value.map(stripSpans)
+    : value && typeof value === "object"
+        ? Object.fromEntries(Object.entries(value)
+            .filter(([key]) => key !== "at")
+            .map(([key, item]) => [key, stripSpans(item)]))
+        : value;