worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/ir-checks/sensitive-flow.js

@@ -0,0 +1,240 @@
+import { sealingModel, derivedLeakHelp } from "./sealing.js";
+/** All branches and call arguments participate; no operation implicitly declassifies data. */
+export const sensitiveFlowDiagnostics = (ir, classify) => {
+    const diagnostics = [], model = sealingModel(ir);
+    const unique = (names, at) => {
+        if (new Set(names).size !== names.length)
+            diagnostics.push({
+                code: "E_DERIVED_LEAK",
+                severity: "error",
+                message: "Sensitive flow requires unambiguous declarations and data slots.",
+                at,
+                help: derivedLeakHelp + " Use unique declaration, field, parameter and entity-attribute names.",
+            });
+    };
+    for (const group of [ir.roles, ir.entities, ir.evidence, ir.components, ir.derives])
+        if (group.length)
+            unique(group.map((d) => d.name), group[0].at);
+    for (const owner of [...ir.roles, ...ir.entities, ...ir.evidence])
+        unique(owner.fields.map((f) => f.name), owner.at);
+    if (ir.entities.length)
+        unique(ir.entities.map((e) => e.ns), ir.entities[0].at);
+    for (const entity of ir.entities) {
+        unique(entity.fields.map((f) => f.attr), entity.at);
+        if (entity.fields.some((f) => f.attr !== `${entity.ns}/${f.name}`))
+            diagnostics.push({
+                code: "E_DERIVED_LEAK",
+                severity: "error",
+                message: "Sensitive flow requires canonical entity attributes.",
+                at: entity.at,
+                help: derivedLeakHelp + " Keep each attribute equal to its entity namespace and field name.",
+            });
+    }
+    for (const c of ir.components)
+        unique([...c.inputs, ...c.params].map((f) => f.name), c.at);
+    for (const d of ir.derives)
+        unique(d.params.map((f) => f.name), d.at);
+    if (diagnostics.length)
+        return diagnostics;
+    const value = (type) => {
+        const c = type ? classify(type) : undefined;
+        return {
+            ...(type ? { type } : {}),
+            classes: c?.ok ? c.classes : [],
+            ...(c && !c.ok ? { unknown: true } : {}),
+        };
+    };
+    const merge = (parts, type) => {
+        const result = value(type);
+        return {
+            ...result,
+            classes: [...new Set([...result.classes, ...parts.flatMap((p) => p.classes)])].sort(),
+            ...(parts.some((p) => p.unknown) ? { unknown: true } : {}),
+        };
+    };
+    const scope = (fields) => new Map(fields.map((f) => [f.name, value(f.type)]));
+    const componentScope = (c) => {
+        const result = scope([...c.inputs, ...c.params]);
+        result.set("self", value(["Id", c.name]));
+        result.set("attached", value(["List", ["Id", ir.libraries[0]?.subject ?? "Unknown"]]));
+        for (const f of [...c.requirements, ...c.outputs])
+            if (!result.has(f.name))
+                result.set(f.name, value("Status"));
+        for (const f of c.machines)
+            if (!result.has(f.name))
+                result.set(f.name, value("Machine"));
+        for (const f of c.slots)
+            if (!result.has(f.name))
+                result.set(f.name, value(["Id", f.component]));
+        return result;
+    };
+    const infer = (e, env, active = new Set()) => {
+        switch (e.k) {
+            case "lit":
+            case "kw":
+            case "ref":
+                return value();
+            case "var":
+                return (env.get(e.name) ??
+                    (["today", "now"].includes(e.name) ? value() : { classes: [], unknown: true }));
+            case "read":
+            case "attr":
+            case "inst": {
+                const receiver = infer(e.of, env, active), target = model.reference(receiver.type);
+                const field = e.k === "read"
+                    ? ir.roles.find((r) => r.name === e.role)?.fields.find((f) => f.name === e.field)
+                    : e.k === "attr"
+                        ? ir.entities.flatMap((r) => r.fields).find((f) => f.attr === e.attr)
+                        : model.field(receiver.type, e.field);
+                const receiverMatches = e.k === "read"
+                    ? target === e.role ||
+                        ir.entities.some((r) => r.name === target && r.implements.some((b) => b.role === e.role))
+                    : e.k === "attr"
+                        ? ir.entities.some((r) => r.name === target && r.fields.some((f) => f.attr === e.attr))
+                        : !!field;
+                const declarations = e.k === "attr"
+                    ? ir.entities.flatMap((r) => r.fields).filter((f) => f.attr === e.attr)
+                    : e.k === "read"
+                        ? ir.roles
+                            .filter((r) => r.name === e.role)
+                            .flatMap((r) => r.fields)
+                            .filter((f) => f.name === e.field)
+                        : [];
+                return merge([
+                    receiver,
+                    ...declarations.map((f) => value(f.type)),
+                    field && receiverMatches ? value(field.type) : { classes: [], unknown: true },
+                ], field?.type);
+            }
+            case "if": {
+                const yes = infer(e.then, env, active), no = infer(e.else, env, active);
+                return merge([infer(e.test, env, active), yes, no], JSON.stringify(yes.type) === JSON.stringify(no.type) ? yes.type : undefined);
+            }
+            case "list": {
+                const parts = e.items.map((x) => infer(x, env, active));
+                return merge(parts, ["List", parts[0]?.type ?? "Unknown"]);
+            }
+            case "fn": {
+                const inner = new Map(env);
+                e.params.forEach((p) => inner.delete(p));
+                return infer(e.body, inner, active);
+            }
+            case "call": {
+                const parts = e.args.map((arg, i) => {
+                    const callbackList = i === 0 && ["map", "filter"].includes(e.fn)
+                        ? e.args[1]
+                        : (i === 1 || i === 2) && e.fn === "spells"
+                            ? e.args[0]
+                            : undefined;
+                    if (!e.derive && arg.k === "fn" && callbackList) {
+                        const collection = infer(callbackList, env, active), type = model.unwrap(collection.type), inner = new Map(env);
+                        arg.params.forEach((p) => inner.set(p, merge([collection], Array.isArray(type) && type[0] === "List" ? type[1] : undefined)));
+                        return infer(arg.body, inner, active);
+                    }
+                    return infer(arg, env, active);
+                });
+                const d = ir.derives.find((d) => d.name === e.fn);
+                if (d) {
+                    if (active.has(d.name))
+                        return { classes: [], unknown: true };
+                    const inner = scope(d.params);
+                    d.params.forEach((p, i) => inner.set(p.name, merge([value(p.type), parts[i] ?? value()], p.type)));
+                    return merge([...parts, infer(d.body, inner, new Set([...active, d.name]))], d.returns);
+                }
+                if (e.derive)
+                    return { classes: [], unknown: true };
+                const type = e.fn === "spells"
+                    ? ["List", parts[0]?.type ?? "Unknown"]
+                    : e.fn === "filter"
+                        ? parts[1]?.type
+                        : e.fn === "map"
+                            ? ["List", parts[0]?.type ?? "Unknown"]
+                            : undefined;
+                const first = model.unwrap(parts[0]?.type);
+                return merge(parts, type ??
+                    (["first", "last"].includes(e.fn) && Array.isArray(first) && first[0] === "List"
+                        ? first[1]
+                        : undefined));
+            }
+        }
+    };
+    const check = (expr, env, allowed = []) => {
+        const result = infer(expr, env);
+        if (result.unknown || result.classes.some((c) => !allowed.includes(c)))
+            diagnostics.push({
+                code: "E_DERIVED_LEAK",
+                severity: "error",
+                message: result.unknown
+                    ? "Sensitive reads need a statically resolved receiver and field."
+                    : "This expression exposes sensitive data outside its sealed destination.",
+                at: expr.at,
+                help: derivedLeakHelp,
+            });
+    };
+    const visit = (node, env, allowed = []) => {
+        if (!node || typeof node !== "object")
+            return;
+        if ("k" in node)
+            check(node, env, allowed);
+        else
+            for (const [key, child] of Object.entries(node))
+                if (key !== "at")
+                    visit(child, env, allowed);
+    };
+    for (const d of ir.derives)
+        if (d.body)
+            check(d.body, scope(d.params));
+    for (const c of ir.components) {
+        const env = componentScope(c);
+        visit(c, env);
+        for (const d of ir.decisions ?? [])
+            if (d.of === c.name)
+                visit(d, env);
+        for (const a of ir.accounts)
+            for (const p of a.policies ?? [])
+                if (p.of === c.name)
+                    visit(p, env);
+    }
+    for (const e of ir.evidence) {
+        const c = ir.components.find((c) => c.name === e.of), env = c ? componentScope(c) : new Map();
+        const fields = scope(e.fields), allowed = e.fields.flatMap((f) => value(f.type).classes);
+        visit(e.rules, fields, allowed);
+        if (e.expires)
+            check(e.expires, fields);
+        for (const i of ir.interactions.filter((i) => i.produces === e.name)) {
+            for (const b of i.binds) {
+                const destination = e.fields.find((f) => f.name === b.field), classes = destination ? value(destination.type).classes : [];
+                if (b.from)
+                    check(b.from, env, classes);
+                if (b.target) {
+                    const target = infer(b.target, env);
+                    if (target.unknown || classes.some((c) => !target.classes.includes(c)))
+                        diagnostics.push({
+                            code: "E_DERIVED_LEAK",
+                            severity: "error",
+                            message: "A proposed write must preserve every signed field classification.",
+                            at: b.target.at,
+                            help: derivedLeakHelp,
+                        });
+                }
+            }
+            const layout = ir.layouts.find((l) => l.name === i.layout);
+            if (layout)
+                visit(layout, fields, allowed);
+        }
+    }
+    for (const n of ir.notices ?? []) {
+        const c = ir.components.find((c) => c.name === n.of);
+        check(n.to, c ? componentScope(c) : new Map());
+    }
+    for (const v of ir.vaults ?? []) {
+        const c = ir.components.find((c) => c.name === v.key.target), env = v.key.kind === "subject"
+            ? scope([{ name: "subject", type: ["Id", v.key.target] }])
+            : c
+                ? componentScope(c)
+                : new Map();
+        check(v.retain, env);
+        check(v.dispose.by, env);
+    }
+    return diagnostics;
+};

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

@@ -0,0 +1,19 @@
+import type * as IR from "../world-ir/types.generated.js";
+export declare const sensitiveClasses: readonly ["pii", "financial", "health", "immigration"];
+export type SensitiveClass = (typeof sensitiveClasses)[number];
+/** Value codecs inspect this payload without removing classification from the declared type. */
+export declare const sensitivePayload: (type: IR.TypeRef) => IR.TypeRef | undefined;
+export type Sensitivity = {
+    readonly ok: true;
+    readonly classes: readonly SensitiveClass[];
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+export declare const sensitiveTypeHelp = "Use (Sensitive :pii String), with one of :pii, :financial, :health or :immigration and exactly one base type. Keep classification in concrete canonical aliases/fields; do not hide it in unsupported record or generic aliases.";
+export declare const sensitiveSealHelp = "Declare a compatible cited retention-scoped vault and seal this field or record before publishing sensitive data. Changing the label to an ordinary public type is not a sealing policy.";
+export declare const sensitivityOfType: (type: IR.TypeRef, aliases: readonly IR.TypeAlias[]) => Sensitivity;
+/** An unknown attribute has no implicit public-data grant. */
+export declare const factSensitivity: (ir: Pick<IR.WorldIR, "types" | "entities">, attribute: string) => Sensitivity;
+/** Source publication and raw linking share admission and conservative flow checks. */
+export declare const sensitivityDiagnostics: (ir: Pick<IR.WorldIR, "types"> & Readonly<Record<string, unknown>>) => IR.Diagnostic[];

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

@@ -0,0 +1,133 @@
+import { sealingDiagnostics } from "./sealing.js";
+import { sensitiveFlowDiagnostics } from "./sensitive-flow.js";
+export const sensitiveClasses = ["pii", "financial", "health", "immigration"];
+/** Value codecs inspect this payload without removing classification from the declared type. */
+export const sensitivePayload = (type) => Array.isArray(type) &&
+    type[0] === "Sensitive" &&
+    type.length === 3 &&
+    sensitiveClasses.some((c) => type[1] === `:${c}`)
+    ? type[2]
+    : undefined;
+export const sensitiveTypeHelp = "Use (Sensitive :pii String), with one of :pii, :financial, :health or :immigration and exactly one base type. Keep classification in concrete canonical aliases/fields; do not hide it in unsupported record or generic aliases.";
+export const sensitiveSealHelp = "Declare a compatible cited retention-scoped vault and seal this field or record before publishing sensitive data. Changing the label to an ordinary public type is not a sealing policy.";
+const merge = (parts) => {
+    const invalid = parts.find((p) => !p.ok);
+    if (invalid)
+        return invalid;
+    return { ok: true, classes: [...new Set(parts.flatMap((p) => (p.ok ? p.classes : [])))].sort() };
+};
+/** Classification follows every container argument; cycles do not erase another sensitive branch. */
+const classifier = (aliases) => {
+    const definitions = new Map(aliases.map((a) => [a.name, a.type]));
+    const results = new Map();
+    const visit = (ref, seen) => {
+        if (typeof ref === "string") {
+            const alias = definitions.get(ref);
+            return alias && !seen.has(ref)
+                ? visit(alias, new Set([...seen, ref]))
+                : { ok: true, classes: [] };
+        }
+        if (ref[0] === "Sensitive") {
+            const classification = ref[1];
+            if (ref.length !== 3 || typeof classification !== "string" || !classification.startsWith(":"))
+                return {
+                    ok: false,
+                    message: "Sensitive needs a literal classification keyword and one base type.",
+                };
+            const value = classification.slice(1);
+            if (!sensitiveClasses.some((c) => c === value))
+                return { ok: false, message: "Unknown sensitive classification." };
+            return merge([{ ok: true, classes: [value] }, visit(ref[2], seen)]);
+        }
+        return merge(ref.map((r) => visit(r, seen)));
+    };
+    return (type) => {
+        const old = results.get(type);
+        if (old)
+            return old;
+        // Memoize only complete traversals: an alias cycle's partial result depends on its path.
+        const result = definitions.size !== aliases.length
+            ? { ok: false, message: "Duplicate type aliases cannot establish a classification." }
+            : visit(type, new Set());
+        results.set(type, result);
+        return result;
+    };
+};
+export const sensitivityOfType = (type, aliases) => classifier(aliases)(type);
+/** An unknown attribute has no implicit public-data grant. */
+export const factSensitivity = (ir, attribute) => {
+    const fields = ir.entities.flatMap((e) => e.fields).filter((f) => f.attr === attribute);
+    return fields.length
+        ? merge(fields.map((f) => sensitivityOfType(f.type, ir.types)))
+        : { ok: false, message: "The fact attribute has no declared classification." };
+};
+/** Source publication and raw linking share admission and conservative flow checks. */
+export const sensitivityDiagnostics = (ir) => {
+    const model = {
+        format: "worldvm/world-ir@1",
+        sources: [],
+        calendars: [],
+        connectors: [],
+        machines: [],
+        roles: [],
+        entities: [],
+        evidence: [],
+        components: [],
+        derives: [],
+        libraries: [],
+        interactions: [],
+        layouts: [],
+        accounts: [],
+        ...ir,
+    };
+    const classify = classifier(ir.types);
+    const diagnostics = [];
+    const stored = new Set([...model.roles, ...model.entities, ...model.evidence].flatMap((r) => r.fields));
+    const report = (result, at, label = "Data") => {
+        if (!result.ok || result.classes.length)
+            diagnostics.push({
+                code: result.ok ? "E_UNSEALED_SENSITIVE" : "E_SENSITIVE_TYPE",
+                severity: "error",
+                message: result.ok
+                    ? `${label} requires an explicit supported sealing policy.`
+                    : result.message,
+                ...(at ? { at } : {}),
+                help: result.ok ? sensitiveSealHelp : sensitiveTypeHelp,
+            });
+    };
+    for (const alias of ir.types) {
+        const result = classify(alias.type);
+        if (alias.name === "Sensitive")
+            report({ ok: false, message: "Sensitive is a reserved type constructor." }, alias.at);
+        else if (!result.ok)
+            report(result, alias.at);
+    }
+    const walk = (value, at, position = "other") => {
+        if (Array.isArray(value)) {
+            value.forEach((v) => walk(v, at, position));
+            return;
+        }
+        if (!value || typeof value !== "object")
+            return;
+        const node = value, location = node.at ?? at;
+        for (const slot of [node.type, node.returns])
+            if (typeof slot === "string" || Array.isArray(slot)) {
+                const result = classify(slot);
+                if (position !== "field" || !result.ok)
+                    report(result, location, typeof node.name === "string" ? node.name : "Data");
+            }
+        for (const [key, child] of Object.entries(node))
+            if (key !== "at")
+                walk(child, location, position === "owner" && key === "fields" ? "field" : "other");
+    };
+    for (const [key, value] of Object.entries(ir))
+        if (key !== "types" && key !== "componentContracts")
+            walk(value, undefined, ["roles", "entities", "evidence"].includes(key) ? "owner" : "other");
+    diagnostics.push(...sealingDiagnostics(model, classify));
+    if ([...stored].some((f) => {
+        const c = classify(f.type);
+        return c.ok && c.classes.length;
+    }))
+        diagnostics.push(...sensitiveFlowDiagnostics(model, classify));
+    return diagnostics;
+};

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

@@ -0,0 +1,4 @@
+import type * as IR from "../world-ir/types.generated.js";
+export declare const signatureHelp = "Use :covers :all with a fixed :method and :audit {:consent \"Electronic-records consent\" :intent \"Intent to sign\"}. Both statements must be nonempty literal strings of at most 2000 characters; no extra keys.";
+export declare const auditPolicyValid: (value: unknown) => value is IR.SignaturePolicy;
+export declare const signatureDiagnostics: (ir: Pick<IR.WorldIR, "evidence">) => IR.Diagnostic[];

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

@@ -0,0 +1,22 @@
+export const signatureHelp = 'Use :covers :all with a fixed :method and :audit {:consent "Electronic-records consent" :intent "Intent to sign"}. Both statements must be nonempty literal strings of at most 2000 characters; no extra keys.';
+export const auditPolicyValid = (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const policy = value;
+    return (Object.keys(policy).length === 2 &&
+        ["consent", "intent"].every((key) => typeof policy[key] === "string" &&
+            policy[key].trim().length > 0 &&
+            policy[key].length <= 2000));
+};
+export const signatureDiagnostics = (ir) => ir.evidence.flatMap((e) => e.attest?.audit !== undefined &&
+    (!auditPolicyValid(e.attest.audit) || e.attest.covers !== "all" || !e.attest.method.trim())
+    ? [
+        {
+            code: "E_ATTEST_AUDIT",
+            severity: "error",
+            message: "An audited attestation needs fixed consent, intent, method and complete coverage.",
+            at: e.at,
+            help: signatureHelp,
+        },
+    ]
+    : []);

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

@@ -0,0 +1,10 @@
+import type * as IR from "../world-ir/types.generated.js";
+export declare const vaultHelp = "Declare a unique cited vault with (per-occurrence Component) or (per-subject Role), nonempty held classes, finite retention, :held-until-retained or :on-request erasure, and an explicit (decision name :by principal :approvals positive-integer).";
+type Model = Pick<IR.WorldIR, "types" | "roles" | "entities" | "components" | "derives" | "references" | "vaults"> & Partial<Pick<IR.WorldIR, "evidence" | "documents" | "notices">>;
+export declare const vaultAuthority: (ir: Model, key: IR.VaultKey, by: IR.Expr) => {
+    kind: import("./principals.js").PrincipalKind | undefined;
+    diagnostics: import("./principals.js").PrincipalDiagnostic[];
+};
+/** Policies are checked before either source publication or raw-IR linking. */
+export declare const vaultDiagnostics: (ir: Model) => IR.Diagnostic[];
+export {};

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

@@ -0,0 +1,140 @@
+import { principalKinds } from "./principals.js";
+import { sensitiveClasses } from "./sensitivity.js";
+import { isLocalDate } from "./dates.js";
+export const vaultHelp = "Declare a unique cited vault with (per-occurrence Component) or (per-subject Role), nonempty held classes, finite retention, :held-until-retained or :on-request erasure, and an explicit (decision name :by principal :approvals positive-integer).";
+export const vaultAuthority = (ir, key, by) => {
+    const component = ir.components.find((c) => c.name === key.target), owner = key.kind === "occurrence"
+        ? component
+        : {
+            name: JSON.stringify(["vault-subject", key.target]),
+            inputs: [{ name: "subject", type: ["Id", key.target] }],
+            params: [],
+        };
+    const name = "vault-disposal", result = principalKinds({
+        ...ir,
+        components: [{ ...owner, actions: [], requirements: [] }],
+        decisions: [{ name, of: owner?.name, by }],
+    });
+    return { kind: result.authorities.get(name), diagnostics: result.diagnostics };
+};
+/** Policies are checked before either source publication or raw-IR linking. */
+export const vaultDiagnostics = (ir) => {
+    const diagnostics = [], names = new Set();
+    const report = (code, message, at, severity = "error") => diagnostics.push({ code, severity, message, at, help: vaultHelp });
+    for (const v of ir.vaults ?? []) {
+        if (!v.name.trim() || names.has(v.name))
+            report("E_VAULT_POLICY", "Vault names must be unique and nonempty.", v.at);
+        names.add(v.name);
+        const component = ir.components.find((c) => c.name === v.key.target), role = ir.roles.find((r) => r.name === v.key.target);
+        if (!(v.key.kind === "occurrence" ? component : v.key.kind === "subject" && role)) {
+            report("E_VAULT_SCOPE", "A vault key must name its declared component or role.", v.key.at);
+            continue;
+        }
+        if (!v.holds.length ||
+            new Set(v.holds).size !== v.holds.length ||
+            v.holds.some((c) => !sensitiveClasses.includes(c)))
+            report("E_VAULT_POLICY", "Held classes must be nonempty, unique and supported.", v.at);
+        if (!v.cites?.length ||
+            v.cites.some((c) => !c.clause.trim() || !ir.references?.some((s) => s.name === c.source)))
+            report("E_VAULT_UNCITED", "Vault retention needs a declared source and specific clause.", v.at);
+        if (!["on-request", "held-until-retained"].includes(v.erasure.kind))
+            report("E_VAULT_POLICY", "Choose a supported erasure policy.", v.erasure.at);
+        else if (v.erasure.kind === "on-request")
+            report("W_ERASURE_CONFLICT", "On-request erasure may conflict with cited retention; resolve the retention obligation before shredding.", v.erasure.at, "warning");
+        if (!v.dispose.name.trim() ||
+            !Number.isSafeInteger(v.dispose.approvals) ||
+            v.dispose.approvals < 1)
+            report("E_VAULT_POLICY", "Disposal needs an explicit name and positive fixed approval count.", v.dispose.at);
+        const authority = vaultAuthority(ir, v.key, v.dispose.by), expected = authority.kind === "entity" ? "individual" : "group";
+        if (authority.diagnostics.length || !authority.kind || v.dispose.byKind !== expected)
+            report("E_VAULT_AUTHORITY", "The disposal authority must have one proven principal kind.", v.dispose.by.at);
+        const scope = new Set(v.key.kind === "subject"
+            ? ["subject", "today", "now"]
+            : [
+                ...component.key,
+                ...component.params.map((p) => p.name),
+                "attached",
+                "self",
+                "today",
+                "now",
+            ]);
+        const scan = (e, bound, active) => {
+            if (e.k === "var" && !bound.has(e.name))
+                report("E_VAULT_SCOPE", "Vault expressions must stay within their declared key scope.", e.at);
+            if (e.k === "fn")
+                return scan(e.body, new Set([...bound, ...e.params]), active);
+            if (e.k === "call") {
+                if (e.derive) {
+                    const derive = ir.derives.find((d) => d.name === e.fn);
+                    if (!derive || active.has(e.fn))
+                        report("E_VAULT_RETENTION", "Vault expressions need declared acyclic derives.", e.at);
+                    else
+                        scan(derive.body, new Set(derive.params.map((p) => p.name)), new Set([...active, e.fn]));
+                }
+                e.args.forEach((a) => scan(a, bound, active));
+            }
+            if (e.k === "list")
+                e.items.forEach((a) => scan(a, bound, active));
+            if (e.k === "if")
+                [e.test, e.then, e.else].forEach((a) => scan(a, bound, active));
+            if (e.k === "read" || e.k === "attr" || e.k === "inst")
+                scan(e.of, bound, active);
+            if (e.k === "inst" &&
+                e.of.k === "var" &&
+                e.of.name === "self" &&
+                component?.inputs.some((i) => i.name === e.field) &&
+                !component.key.includes(e.field))
+                report("E_VAULT_SCOPE", "Vault expressions cannot read non-key inputs through self.", e.at);
+        };
+        scan(v.retain, scope, new Set());
+        scan(v.dispose.by, scope, new Set());
+        const unwrap = (t, seen = new Set()) => {
+            if (typeof t === "string") {
+                const alias = ir.types.find((a) => a.name === t);
+                return alias && !seen.has(t) ? unwrap(alias.type, new Set([...seen, t])) : t;
+            }
+            return Array.isArray(t) && ["Option", "Brand"].includes(String(t[0]))
+                ? unwrap(t[1], seen)
+                : t;
+        };
+        const date = (e) => {
+            if (e.k === "lit")
+                return e.v === null || (typeof e.v === "string" && isLocalDate(e.v));
+            if (e.k === "if")
+                return date(e.then) && date(e.else);
+            if (e.k === "var")
+                return (e.name === "today" ||
+                    unwrap([...(component?.inputs ?? []), ...(component?.params ?? [])].find((f) => f.name === e.name)?.type) === "Date");
+            if (e.k === "read")
+                return (unwrap(ir.roles.find((r) => r.name === e.role)?.fields.find((f) => f.name === e.field)?.type) === "Date");
+            if (e.k === "attr")
+                return (unwrap(ir.entities.flatMap((x) => x.fields).find((f) => f.attr === e.attr)?.type) ===
+                    "Date");
+            if (e.k === "call")
+                return e.derive
+                    ? unwrap(ir.derives.find((d) => d.name === e.fn)?.returns) === "Date"
+                    : [
+                        "years-after",
+                        "months-after",
+                        "days-after",
+                        "days-before",
+                        "business-days-after",
+                        "earliest",
+                        "latest",
+                        "asserted-at",
+                    ].includes(e.fn);
+            return false;
+        };
+        if (!date(v.retain))
+            report("E_VAULT_RETENTION", "Retention must produce a local date or an unknown date.", v.retain.at);
+    }
+    const seal = (value) => {
+        if (value && !names.has(value.vault))
+            report("E_VAULT_SEAL", "A seal must name a declared vault.", value.at);
+    };
+    for (const owner of [...ir.roles, ...ir.entities, ...(ir.evidence ?? [])])
+        owner.fields.forEach((f) => seal(f.sealedBy));
+    for (const owner of [...(ir.evidence ?? []), ...(ir.documents ?? []), ...(ir.notices ?? [])])
+        seal(owner.sealedBy);
+    return diagnostics;
+};