worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/ir-checks/read-classification.d.ts

@@ -0,0 +1,12 @@
+import type * as IR from "../world-ir/types.generated.js";
+import type { AgentReadPermission } from "./agent-reads.js";
+export type DataReadSelector = {
+    readonly kind: "fact";
+    readonly declaration: string;
+    readonly attribute: string;
+} | {
+    readonly kind: "evidence" | "document" | "notice";
+    readonly declaration: string;
+};
+/** Resolve declarations, not caller-supplied public/private labels. A seal is never declassification. */
+export declare const dataReadInfo: (ir: IR.WorldIR, source: DataReadSelector) => readonly AgentReadPermission[] | undefined;

package/dist/_internal/ir-checks/read-classification.js

@@ -0,0 +1,67 @@
+import { readTypeModel } from "./read-types.js";
+import { sensitiveClasses, sensitivityOfType } from "./sensitivity.js";
+const one = (xs) => (xs.length === 1 ? xs[0] : undefined);
+/** Resolve declarations, not caller-supplied public/private labels. A seal is never declassification. */
+export const dataReadInfo = (ir, source) => {
+    const known = readTypeModel(ir);
+    const sealed = (fields, seal) => {
+        const classes = new Set();
+        for (const f of fields) {
+            if (!known(f.type))
+                return undefined;
+            const c = sensitivityOfType(f.type, ir.types);
+            if (!c.ok)
+                return undefined;
+            c.classes.forEach((v) => classes.add(v));
+        }
+        if (!seal)
+            return classes.size ? undefined : [];
+        const vault = one((ir.vaults ?? []).filter((v) => v.name === seal.vault));
+        if (!vault || !vault.holds.length || vault.holds.some((c) => !sensitiveClasses.includes(c)))
+            return undefined;
+        if (!classes.size)
+            vault.holds.forEach((c) => classes.add(c));
+        if ([...classes].some((c) => !vault.holds.includes(c)))
+            return undefined;
+        return [...classes].sort().map((c) => ({ class: c, vault: vault.name }));
+    };
+    const evidence = (name) => {
+        const e = one(ir.evidence.filter((e) => e.name === name));
+        return e && sealed(e.fields, e.sealedBy);
+    };
+    const document = (name) => {
+        const d = one((ir.documents ?? []).filter((d) => d.name === name));
+        if (!d || !d.sources.length)
+            return undefined;
+        const permissions = d.sources.map(evidence);
+        if (permissions.some((p) => !p || p.some((g) => g.vault !== d.sealedBy?.vault)))
+            return undefined;
+        const own = sealed([], d.sealedBy);
+        return (own && [
+            ...new Map([...permissions.flatMap((p) => p), ...own].map((p) => [`${p.class}:${p.vault}`, p])).values(),
+        ]);
+    };
+    switch (source.kind) {
+        case "fact": {
+            const entity = one(ir.entities.filter((e) => e.name === source.declaration));
+            const field = entity &&
+                one(entity.fields.filter((f) => f.attr === source.attribute && f.attr === `${entity.ns}/${f.name}`));
+            const unique = ir.entities
+                .flatMap((e) => e.fields)
+                .filter((f) => f.attr === source.attribute);
+            return field && unique.length === 1 ? sealed([field], field.sealedBy) : undefined;
+        }
+        case "evidence":
+            return evidence(source.declaration);
+        case "document":
+            return document(source.declaration);
+        case "notice": {
+            const n = one((ir.notices ?? []).filter((n) => n.name === source.declaration));
+            const inherited = n && document(n.document);
+            const own = n && sealed([], n.sealedBy);
+            return inherited && own && inherited.every((p) => p.vault === n.sealedBy?.vault)
+                ? [...new Map([...inherited, ...own].map((p) => [`${p.class}:${p.vault}`, p])).values()]
+                : undefined;
+        }
+    }
+};

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

@@ -0,0 +1,2 @@
+import type * as IR from "../world-ir/types.generated.js";
+export declare const readTypeModel: (ir: IR.WorldIR) => (type: IR.TypeRef, seen?: Set<string>) => boolean;

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

@@ -0,0 +1,40 @@
+import { sensitivePayload } from "./sensitivity.js";
+export const readTypeModel = (ir) => {
+    const known = (type, seen = new Set()) => {
+        if (typeof type === "string") {
+            const aliases = ir.types.filter((t) => t.name === type);
+            if (aliases.length)
+                return (aliases.length === 1 &&
+                    !seen.has(type) &&
+                    known(aliases[0].type, new Set([...seen, type])));
+            return (type.startsWith(":") ||
+                [
+                    "String",
+                    "Keyword",
+                    "Bool",
+                    "Int",
+                    "Float",
+                    "Date",
+                    "Instant",
+                    "File",
+                    "Group",
+                    "Truth",
+                    "Status",
+                    "Duration",
+                    "Machine",
+                    "Unit",
+                ].includes(type));
+        }
+        const payload = sensitivePayload(type);
+        if (payload)
+            return known(payload, seen);
+        if (["Option", "Brand", "List"].includes(String(type[0])))
+            return type.length === 2 && known(type[1], seen);
+        if (type[0] === "Union")
+            return type.length > 1 && type.slice(1).every((t) => known(t, seen));
+        return (type[0] === "Id" &&
+            type.length === 2 &&
+            [...ir.roles, ...ir.entities, ...ir.components].filter((t) => t.name === type[1]).length === 1);
+    };
+    return known;
+};

package/dist/_internal/ir-checks/resource-proofs.d.ts

@@ -0,0 +1,4 @@
+import type * as IR from "../world-ir/types.generated.js";
+/** A case-bound proof has one explicitly generation-cycled producer. */
+export declare const resourceProofRequirement: (c: IR.Component, resource: string, evidence: string) => IR.Requirement | undefined;
+export declare const resourceProofDiagnostics: (ir: IR.WorldIR) => IR.Diagnostic[];

package/dist/_internal/ir-checks/resource-proofs.js

@@ -0,0 +1,98 @@
+/** A case-bound proof has one explicitly generation-cycled producer. */
+export const resourceProofRequirement = (c, resource, evidence) => {
+    const contains = (e) => e.k === "call" &&
+        ((e.fn === "attested" &&
+            e.args[0]?.k === "ref" &&
+            e.args[0].kind === "evidence" &&
+            e.args[0].name === evidence) ||
+            (["all?", "any?"].includes(e.fn) &&
+                e.args.some((a) => a.k === "list" && a.items.some(contains))));
+    const producers = c.requirements.filter((r) => r.cycle?.k === "call" &&
+        r.cycle.fn === "resource-generation" &&
+        r.cycle.args.length === 1 &&
+        r.cycle.args[0]?.k === "var" &&
+        r.cycle.args[0].name === resource &&
+        contains(r.satisfiedBy));
+    return producers.length === 1 ? producers[0] : undefined;
+};
+const proofForms = {
+    "entered-at": {
+        target: "a machine and one of its declared states",
+        help: "Use (entered-at machine :state) with a machine declared by this component, including a connector-owned machine, and a state declared by its protocol.",
+    },
+    "resource-generation": {
+        target: "a managed resource",
+        help: "Use (resource-generation machine) with a managed resource declared by this component.",
+    },
+    "attested-for": {
+        target: "a managed resource and its generation-bound evidence producer",
+        help: "Use (attested-for machine Evidence) with a managed resource declared by this component and owned evidence with exactly one producer cycled by (resource-generation machine).",
+    },
+};
+export const resourceProofDiagnostics = (ir) => {
+    const errors = [];
+    const scan = (v, c) => {
+        if (Array.isArray(v)) {
+            v.forEach((x) => scan(x, c));
+            return;
+        }
+        if (!v || typeof v !== "object")
+            return;
+        const e = v;
+        if (e.k === "call") {
+            let code;
+            if (["resource-generation", "entered-at", "attested-for"].includes(e.fn)) {
+                const machine = e.args[0], name = machine?.k === "var" ? machine.name : "";
+                let valid = e.fn === "entered-at"
+                    ? !!c?.machines.some((m) => m.name === name)
+                    : !!c?.resources?.some((r) => r.name === name);
+                if (e.fn === "resource-generation")
+                    valid &&= e.args.length === 1;
+                if (e.fn === "entered-at") {
+                    const state = e.args[1], protocol = ir.machines.find((m) => m.name === c?.machines.find((m) => m.name === name)?.protocol);
+                    valid &&=
+                        e.args.length === 2 &&
+                            state?.k === "kw" &&
+                            !!protocol?.states.some((s) => s.name === state.v);
+                }
+                if (e.fn === "attested-for") {
+                    const proof = e.args[1];
+                    valid &&=
+                        e.args.length === 2 &&
+                            proof?.k === "ref" &&
+                            proof.kind === "evidence" &&
+                            ir.evidence.some((x) => x.name === proof.name && x.of === c?.name) &&
+                            !!c &&
+                            !!resourceProofRequirement(c, name, proof.name);
+                }
+                if (!valid)
+                    code = "E_RESOURCE_PROOF";
+            }
+            if (["notice-delivered?", "notice-acknowledged?"].includes(e.fn)) {
+                const ref = e.args[0];
+                if (e.args.length !== 1 ||
+                    ref?.k !== "ref" ||
+                    ref.kind !== "notice" ||
+                    !ir.notices?.some((n) => n.name === ref.name && n.of === c?.name))
+                    code = "E_NOTICE_PROOF";
+            }
+            if (code)
+                errors.push({
+                    code,
+                    severity: "error",
+                    message: `${e.fn} must name ${proofForms[e.fn]?.target ?? "a notice"} of the current component.`,
+                    help: `${proofForms[e.fn]?.help ?? "Use a notice owned by this component."} Keep these context reads directly in component expressions.`,
+                    at: e.at,
+                });
+        }
+        for (const [key, x] of Object.entries(v))
+            if (key !== "at")
+                scan(x, c);
+    };
+    ir.components.forEach((c) => scan(c, c));
+    // Other declaration contexts have no component-owned machine or notice scope.
+    for (const [key, value] of Object.entries(ir))
+        if (key !== "components" && key !== "scenarios" && key !== "properties")
+            scan(value);
+    return errors;
+};

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

@@ -0,0 +1,3 @@
+import type * as IR from "../world-ir/types.generated.js";
+export declare const resourceHelp = "Declare a unique resource over its same-named machine, use capabilities of that machine's owning connector, and expose an owned acquisition action as a public operation.";
+export declare const resourceDiagnostics: (ir: Pick<IR.WorldIR, "components" | "connectors" | "componentContracts" | "machines">) => IR.Diagnostic[];

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

@@ -0,0 +1,30 @@
+import { componentOperationNames } from "./component-operations.js";
+export const resourceHelp = "Declare a unique resource over its same-named machine, use capabilities of that machine's owning connector, and expose an owned acquisition action as a public operation.";
+export const resourceDiagnostics = (ir) => ir.components.flatMap((c) => {
+    const seen = new Set(), actionsUsed = new Set();
+    return (c.resources ?? []).flatMap((r) => {
+        const error = (code, message, at = r.at) => [
+            { code, severity: "error", message, at, help: resourceHelp },
+        ];
+        if (seen.has(r.name))
+            return error("E_RESOURCE_NAME", "Duplicate resource name.");
+        seen.add(r.name);
+        const machine = c.machines.find((m) => m.name === r.name);
+        if (!machine || !ir.machines.some((m) => m.name === machine.protocol))
+            return error("E_RESOURCE_MACHINE", "A resource needs a same-named declared machine.");
+        for (const call of [r.acquire, r.release]) {
+            const connector = ir.connectors.find((x) => x.name === call.connector);
+            if (!connector?.capabilities.includes(call.capability) ||
+                !connector.owns.includes(machine.protocol))
+                return error("E_RESOURCE_CAPABILITY", "Resource calls must be capabilities of the protocol's owning connector.", call.at);
+        }
+        const actions = c.actions.filter((a) => a.via.kind === "connector" &&
+            a.via.connector === r.acquire.connector &&
+            a.via.capability === r.acquire.capability &&
+            componentOperationNames(ir, c).includes(a.name));
+        if (actions.length !== 1 || actionsUsed.has(actions[0].name))
+            return error("E_RESOURCE_ACTION", "A resource needs one unambiguous owned public acquisition action.", r.acquire.at);
+        actionsUsed.add(actions[0].name);
+        return [];
+    });
+});

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

@@ -0,0 +1,10 @@
+import type { Component, Requirement, Decision, WorldIR } from "../world-ir/types.generated.js";
+export declare const reuseDecisionName: (component: string, requirement: string, choice: "accepted" | "declined") => string;
+export declare const reuseDecisions: (component: Component, requirement: Requirement) => readonly Decision[];
+/** Recheck raw IR before activation; no data-dependent discovery can repair an unsafe scope. */
+export declare const reuseProblem: (ir: WorldIR) => {
+    code: string;
+    message: string;
+    at: Requirement["at"];
+    help: string;
+} | undefined;

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

@@ -0,0 +1,99 @@
+import { principalKinds, principalActionKey } from "./principals.js";
+export const reuseDecisionName = (component, requirement, choice) => `${choice === "accepted" ? "accept" : "decline"}-reuse:${component}/${requirement}`;
+export const reuseDecisions = (component, requirement) => {
+    const reuse = requirement.reuse;
+    if (!reuse?.confirm)
+        return [];
+    return ["accepted", "declined"].map((choice) => ({
+        name: reuseDecisionName(component.name, requirement.name, choice),
+        doc: `${choice === "accepted" ? "Accept" : "Decline"} scoped evidence for ${component.name}/${requirement.name}.`,
+        of: component.name,
+        applies: requirement.name,
+        by: reuse.confirm,
+        byKind: reuse.confirmKind === "entity" ? "individual" : "group",
+        effect: choice === "accepted" ? "accept" : "reject",
+        reason: ["Option", "String"],
+        ...(requirement.cites ? { cites: requirement.cites } : {}),
+        at: reuse.at,
+    }));
+};
+const semantic = (value) => JSON.stringify(value, (key, value) => key === "at"
+    ? undefined
+    : value && typeof value === "object" && !Array.isArray(value)
+        ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)))
+        : value);
+/** Recheck raw IR before activation; no data-dependent discovery can repair an unsafe scope. */
+export const reuseProblem = (ir) => {
+    for (const component of ir.components)
+        for (const r of component.requirements) {
+            const reuse = r.reuse;
+            if (!reuse)
+                continue;
+            const error = (code, message) => ({
+                code,
+                message,
+                at: reuse.at,
+                help: "Republish direct owned evidence with a stable home-containing key scope, positive fixed window and a keyed confirmation principal.",
+            });
+            const names = reuse.scope.map((e) => (e.k === "var" ? e.name : ""));
+            if (!names.length ||
+                names.some((n) => !n || !component.key.includes(n)) ||
+                new Set(names).size !== names.length ||
+                component.home.path.length !== 1 ||
+                !names.includes(component.home.path[0]))
+                return error("E_REUSE_SCOPE", "Invalid evidence reuse scope");
+            if (!Number.isSafeInteger(reuse.within.n) ||
+                reuse.within.n <= 0 ||
+                !["days", "years", "hours", "minutes"].includes(reuse.within.unit))
+                return error("E_REUSE_INTERVAL", "Invalid evidence reuse window");
+            const proof = r.satisfiedBy;
+            const evidenceName = proof.k === "call" && proof.args[0]?.k === "ref" ? proof.args[0].name : undefined;
+            if (proof.k !== "call" ||
+                !["attested", "valid"].includes(proof.fn) ||
+                proof.args.length !== 1 ||
+                proof.args[0]?.k !== "ref" ||
+                proof.args[0].kind !== "evidence" ||
+                ir.evidence.find((e) => e.name === evidenceName)?.of !== component.name ||
+                r.accepts ||
+                r.cycle ||
+                r.recur ||
+                r.renewWithin)
+                return error("E_REUSE_TARGET", "Invalid evidence reuse proof context");
+            if (reuse.confirm) {
+                const path = (e) => e.k === "var"
+                    ? component.key.includes(e.name)
+                    : e.k === "read" || e.k === "attr"
+                        ? path(e.of)
+                        : false;
+                const expr = reuse.confirm, target = expr.k === "call" && expr.fn === "members" && expr.args.length === 1
+                    ? expr.args[0]
+                    : expr;
+                const kinds = principalKinds({
+                    ...ir,
+                    components: [
+                        {
+                            ...component,
+                            actions: [{ name: "$reuse", assignee: expr, assigneeKind: reuse.confirmKind }],
+                        },
+                    ],
+                    decisions: [],
+                }, true);
+                if (!path(target) ||
+                    kinds.diagnostics.length ||
+                    kinds.assignees.get(principalActionKey(component.name, "$reuse")) !== reuse.confirmKind)
+                    return error("E_REUSE_CONFIRM", "Invalid evidence reuse confirmation principal");
+            }
+            else if (reuse.confirmKind)
+                return error("E_REUSE_CONFIRM", "Confirmation kind without a principal");
+            const contracts = reuseDecisions(component, r);
+            for (const d of ir.decisions ?? [])
+                if (d.of === component.name &&
+                    d.applies === r.name &&
+                    (d.effect === "accept" || contracts.some((c) => c.name === d.name))) {
+                    const expected = contracts.find((c) => c.name === d.name);
+                    if (!expected || semantic(d) !== semantic(expected))
+                        return error("E_REUSE_CONFIRM", "Scoped evidence confirmation must use its declared contract");
+                }
+        }
+    return undefined;
+};

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

@@ -0,0 +1,14 @@
+import type * as IR from "../world-ir/types.generated.js";
+import type { Sensitivity } from "./sensitivity.js";
+export type Classify = (type: IR.TypeRef) => Sensitivity;
+export declare const derivedLeakHelp = "Preserve every source classification and vault through aliases and generated artifacts. Use an explicitly sealed human snapshot for a separately retained copy; public expressions cannot declassify private values.";
+export declare const sealingModel: (ir: IR.WorldIR) => {
+    unwrap: (type: IR.TypeRef | undefined, seen?: Set<string>) => IR.TypeRef | undefined;
+    reference: (type: IR.TypeRef | undefined) => string | undefined;
+    field: (type: IR.TypeRef | undefined, name: string) => IR.Field | undefined;
+    binding: (entity: IR.Entity, b: IR.Binding) => {
+        owner: IR.Entity;
+        field: IR.EntityField;
+    } | undefined;
+};
+export declare const sealingDiagnostics: (ir: IR.WorldIR, classify: Classify) => IR.Diagnostic[];

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

@@ -0,0 +1,123 @@
+export const derivedLeakHelp = "Preserve every source classification and vault through aliases and generated artifacts. Use an explicitly sealed human snapshot for a separately retained copy; public expressions cannot declassify private values.";
+export const sealingModel = (ir) => {
+    const unwrap = (type, seen = new Set()) => {
+        if (typeof type === "string") {
+            const alias = ir.types.find((a) => a.name === type);
+            if (alias && !seen.has(type))
+                return unwrap(alias.type, new Set([...seen, type]));
+        }
+        if (Array.isArray(type) && ["Option", "Brand"].includes(String(type[0])))
+            return unwrap(type[1], seen);
+        return type;
+    };
+    const reference = (type) => {
+        const t = unwrap(type);
+        return Array.isArray(t) && t[0] === "Id" && typeof t[1] === "string" ? t[1] : undefined;
+    };
+    const field = (type, name) => {
+        const target = reference(type), component = ir.components.find((c) => c.name === target);
+        if (component) {
+            const slot = component.slots.find((s) => s.name === name);
+            if (slot)
+                return { name, type: ["Id", slot.component] };
+            if (name === "attached")
+                return { name, type: ["List", ["Id", ir.libraries[0]?.subject ?? "Unknown"]] };
+            if ([...component.outputs, ...component.requirements].some((f) => f.name === name))
+                return { name, type: "Status" };
+            return [...component.inputs, ...component.params].find((f) => f.name === name);
+        }
+        return [...ir.roles, ...ir.entities]
+            .find((r) => r.name === target)
+            ?.fields.find((f) => f.name === name);
+    };
+    const binding = (entity, b) => {
+        if (b.attrs.length !== b.path.length)
+            return undefined;
+        let owner = entity;
+        for (const [i, name] of b.path.entries()) {
+            const f = owner.fields.find((f) => f.name === name);
+            if (!f || f.attr !== b.attrs[i])
+                return undefined;
+            if (i === b.path.length - 1)
+                return { owner, field: f };
+            const next = ir.entities.find((e) => e.name === reference(f.type));
+            if (!next)
+                return undefined;
+            owner = next;
+        }
+        return undefined;
+    };
+    return { unwrap, reference, field, binding };
+};
+export const sealingDiagnostics = (ir, classify) => {
+    const diagnostics = [], model = sealingModel(ir);
+    const report = (code, message, at) => diagnostics.push({ code, severity: "error", message, at, help: derivedLeakHelp });
+    const classes = (f) => {
+        const r = classify(f.type);
+        return r.ok ? r.classes : [];
+    };
+    const compatible = (fields, seal, at, scope) => {
+        const held = fields.flatMap(classes), vault = ir.vaults?.find((v) => v.name === seal?.vault);
+        if (held.length && (!vault || held.some((c) => !vault.holds.includes(c))))
+            report("E_UNSEALED_SENSITIVE", "Sensitive data needs a vault holding every declared class.", seal?.at ?? at);
+        if (vault && !scope(vault))
+            report("E_VAULT_SCOPE", "The seal does not belong to this subject or occurrence.", seal.at);
+    };
+    const entityScope = (entity, v) => v.key.kind === "subject" && entity.implements.some((b) => b.role === v.key.target);
+    for (const role of ir.roles)
+        for (const f of role.fields) {
+            compatible([f], f.sealedBy, role.at, (v) => {
+                if (v.key.kind !== "subject")
+                    return false;
+                if (v.key.target === role.name)
+                    return true;
+                const aliases = ir.entities.flatMap((e) => e.implements
+                    .filter((b) => b.role === role.name && b.field === f.name)
+                    .map((b) => model.binding(e, b)));
+                return aliases.length > 0 && aliases.every((b) => b && entityScope(b.owner, v));
+            });
+        }
+    for (const entity of ir.entities) {
+        for (const f of entity.fields)
+            compatible([f], f.sealedBy, entity.at, (v) => entityScope(entity, v));
+        for (const b of entity.implements) {
+            const declared = ir.roles
+                .find((r) => r.name === b.role)
+                ?.fields.find((f) => f.name === b.field), actual = model.binding(entity, b);
+            if (!declared || !actual) {
+                report("E_DERIVED_LEAK", "A role binding needs an exact declared entity path and attribute chain.", b.at);
+                continue;
+            }
+            if (JSON.stringify(classes(declared)) !== JSON.stringify(classes(actual.field)) ||
+                declared.sealedBy?.vault !== actual.field.sealedBy?.vault)
+                report("E_DERIVED_LEAK", "Role aliases must preserve the concrete field's classification and exact vault.", b.at);
+        }
+        const display = entity.fields.find((f) => f.name === entity.display);
+        if (display && classes(display).length)
+            report("E_DERIVED_LEAK", "Public display names cannot expose sensitive fields.", entity.at);
+    }
+    for (const evidence of ir.evidence) {
+        const component = ir.components.find((c) => c.name === evidence.of);
+        compatible(evidence.fields, evidence.sealedBy, evidence.at, (v) => {
+            if (v.key.kind === "occurrence")
+                return v.key.target === evidence.of;
+            let type = component ? ["Id", component.name] : undefined;
+            for (const segment of component?.home.path ?? [])
+                type = model.field(type, segment)?.type;
+            return model.reference(type) === v.key.target;
+        });
+        for (const f of evidence.fields)
+            if (f.sealedBy && f.sealedBy.vault !== evidence.sealedBy?.vault)
+                report("E_DERIVED_LEAK", "A record field cannot substitute another vault for its whole-record seal.", f.sealedBy.at);
+    }
+    const inherit = (seal, sources, at) => {
+        const expected = [...new Set(sources.flatMap((s) => (s ? [s.vault] : [])))];
+        if (expected.some((v) => v !== seal?.vault))
+            report("E_DERIVED_LEAK", "A generated artifact must retain every source vault.", seal?.at ?? at);
+    };
+    for (const d of ir.documents ?? [])
+        inherit(d.sealedBy, d.sources.map((s) => ir.evidence.find((e) => e.name === s)?.sealedBy), d.at);
+    for (const n of ir.notices ?? [])
+        inherit(n.sealedBy, [ir.documents?.find((d) => d.name === n.document)?.sealedBy], n.at);
+    return diagnostics;
+};

package/dist/_internal/ir-checks/sensitive-flow.d.ts

@@ -0,0 +1,4 @@
+import type * as IR from "../world-ir/types.generated.js";
+import { type Classify } from "./sealing.js";
+/** All branches and call arguments participate; no operation implicitly declassifies data. */
+export declare const sensitiveFlowDiagnostics: (ir: IR.WorldIR, classify: Classify) => IR.Diagnostic[];