worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/reconciler/dependencies.js

@@ -0,0 +1,372 @@
+/** Tuple keys distinguish opaque ids and scalar types without delimiter collisions. */
+export const dependencyKey = (d) => {
+    switch (d.kind) {
+        case "lifecycle":
+            return JSON.stringify([d.kind, d.account, d.instance]);
+        case "lifecycles":
+        case "resources":
+            return JSON.stringify([d.kind, d.account, d.home]);
+        case "document":
+        case "notice-delivery":
+        case "notice-acknowledgment":
+            return JSON.stringify([d.kind, d.account, d.home, d.key]);
+        case "file":
+            return JSON.stringify([d.kind, d.account, d.home, d.digest]);
+        case "scoped-evidence":
+            return JSON.stringify([d.kind, d.scope]);
+        case "milestone":
+            return JSON.stringify([d.kind, d.instance, d.name]);
+        case "confirmation":
+        case "fact":
+            return JSON.stringify([d.kind, d.entity, d.attribute]);
+        case "entities":
+            return JSON.stringify([d.kind, d.namespace]);
+        case "matching":
+            return JSON.stringify([d.kind, d.attribute, d.where]);
+        case "namespace":
+            return JSON.stringify([d.kind, d.entity]);
+        case "evidence":
+            return JSON.stringify([d.kind, d.occurrence]);
+        case "instance-evidence":
+        case "decisions":
+        case "members":
+            return JSON.stringify([d.kind, d.instance]);
+        case "acceptance":
+            return JSON.stringify([d.kind, d.instance, d.requirement]);
+        case "signals":
+            return JSON.stringify([d.kind, d.instance, d.machine]);
+        case "dispatch":
+            return JSON.stringify([d.kind, d.key]);
+        case "clock":
+            return JSON.stringify([d.kind]);
+        case "time":
+            return JSON.stringify([d.kind, d.instance, ...d.path]);
+        case "program":
+            return JSON.stringify([d.kind, d.account]);
+        case "input":
+        case "status":
+        case "slot":
+            return JSON.stringify([d.kind, d.instance, d.name]);
+    }
+};
+const programDependencies = new WeakMap();
+export const programDependency = (p) => {
+    const cached = programDependencies.get(p);
+    if (cached)
+        return cached;
+    const dependency = {
+        kind: "program",
+        account: p.account.name,
+        value: {
+            library: p.library,
+            package: p.account.package,
+            params: p.account.params,
+            roots: p.account.forEach,
+            ...(p.account.policies?.length ? { policies: p.account.policies } : {}),
+            entities: p.ir.entities,
+        },
+    };
+    programDependencies.set(p, dependency);
+    return dependency;
+};
+export class ReadSet {
+    entriesByKey = new Map();
+    cached;
+    add(d, key = dependencyKey(d)) {
+        if (this.entriesByKey.get(key) === d)
+            return;
+        if (this.cached)
+            this.entriesByKey = new Map(this.entriesByKey);
+        this.entriesByKey.set(key, d);
+        this.cached = undefined;
+    }
+    merge(entries, keep) {
+        for (const [key, value] of entries)
+            if (!keep || keep(value))
+                this.add(value, key);
+    }
+    entries() {
+        return this.entriesByKey.entries();
+    }
+    values() {
+        return this.entriesByKey.values();
+    }
+    snapshot() {
+        if (!this.cached) {
+            this.entriesByKey = new Map([...this.entriesByKey].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
+            this.cached = this.entriesByKey;
+        }
+        return this.cached;
+    }
+}
+/** Internal projections can differ by consumer in cycles; keep them occurrence-local. */
+export const isLocalDependency = (d) => d.kind === "time" ||
+    d.kind === "input" ||
+    d.kind === "members" ||
+    d.kind === "status" ||
+    d.kind === "slot";
+/** Immutable union of sorted maps without copying shared observations into every result. */
+export class DependencyMap {
+    shared;
+    local;
+    constructor(shared, local) {
+        this.shared = shared;
+        this.local = local;
+    }
+    get size() {
+        let n = this.shared.size;
+        for (const key of this.local.keys())
+            if (!this.shared.has(key))
+                n++;
+        return n;
+    }
+    get(key) {
+        return this.local.get(key) ?? this.shared.get(key);
+    }
+    has(key) {
+        return this.local.has(key) || this.shared.has(key);
+    }
+    *entries() {
+        const left = this.shared.entries(), right = this.local.entries();
+        let a = left.next(), b = right.next();
+        while (!a.done || !b.done) {
+            if (b.done || (!a.done && a.value[0] < b.value[0])) {
+                yield a.value;
+                a = left.next();
+            }
+            else {
+                yield b.value;
+                if (!a.done && a.value[0] === b.value[0])
+                    a = left.next();
+                b = right.next();
+            }
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    *keys() {
+        for (const [key] of this)
+            yield key;
+    }
+    *values() {
+        for (const [, value] of this)
+            yield value;
+    }
+    forEach(callback, thisArg) {
+        for (const [key, value] of this)
+            callback.call(thisArg, value, key, this);
+    }
+    toJSON() {
+        return [...this].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    }
+}
+const pools = new WeakMap();
+const sameValue = (a, b) => a === b ||
+    (Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((v, i) => v === b[i]));
+/** Shared prototype methods avoid a set of query closures for every occurrence. */
+class ObservedBasis {
+    b;
+    reads;
+    pool;
+    constructor(b, reads) {
+        this.b = b;
+        this.reads = reads;
+        let pool = pools.get(b);
+        if (!pool) {
+            pool = new Map();
+            pools.set(b, pool);
+        }
+        this.pool = pool;
+    }
+    add(d) {
+        const key = dependencyKey(d), previous = this.pool.get(key);
+        if (previous && sameValue(previous.dependency.value, d.value))
+            this.reads.add(previous.dependency, previous.key);
+        else {
+            const canonicalKey = previous?.key ?? key;
+            this.pool.set(canonicalKey, { key: canonicalKey, dependency: d });
+            this.reads.add(d, canonicalKey);
+        }
+    }
+    get now() {
+        const value = this.b.now;
+        this.add({ kind: "clock", value });
+        return value;
+    }
+    lifecycle(account, instance) {
+        const value = this.b.lifecycle?.(account, instance);
+        this.add({ kind: "lifecycle", account, instance, value: value ?? null });
+        return value;
+    }
+    lifecycleRecords(account, home) {
+        const value = this.b.lifecycleRecords?.(account, home) ?? [];
+        this.add({ kind: "lifecycles", account, home, value });
+        return value;
+    }
+    resourceRecords(account, home) {
+        const value = this.b.resourceRecords?.(account, home) ?? [];
+        this.add({ kind: "resources", account, home, value });
+        return value;
+    }
+    document(account, home, key) {
+        const value = this.b.document?.(account, home, key);
+        this.add({ kind: "document", account, home, key, value: value ?? null });
+        return value;
+    }
+    noticeDelivery(account, home, key) {
+        const value = this.b.noticeDelivery?.(account, home, key);
+        this.add({ kind: "notice-delivery", account, home, key, value: value ?? null });
+        return value;
+    }
+    noticeAcknowledgment(account, home, key) {
+        const value = this.b.noticeAcknowledgment?.(account, home, key);
+        this.add({ kind: "notice-acknowledgment", account, home, key, value: value ?? null });
+        return value;
+    }
+    file(account, home, digest) {
+        const value = this.b.file?.(account, home, digest);
+        this.add({ kind: "file", account, home, digest, value: value ?? null });
+        return value;
+    }
+    fact(entity, attribute) {
+        const value = this.b.fact(entity, attribute);
+        this.add({ kind: "fact", entity, attribute, value: value ?? null });
+        return value;
+    }
+    confirmation(entity, attribute) {
+        const value = this.b.confirmation?.(entity, attribute);
+        this.add({ kind: "confirmation", entity, attribute, value: value ?? null });
+        return value;
+    }
+    entities(namespace) {
+        const value = this.b.entities(namespace);
+        this.add({ kind: "entities", namespace: namespace ?? null, value: [...value].sort() });
+        return value;
+    }
+    matching(attribute, where) {
+        const value = this.b.matching(attribute, where);
+        this.add({ kind: "matching", attribute, where, value: [...value].sort() });
+        return value;
+    }
+    nsOf(entity) {
+        const value = this.b.nsOf(entity);
+        this.add({ kind: "namespace", entity, value: value ?? null });
+        return value;
+    }
+    evidence(occurrence) {
+        const value = this.b.evidence(occurrence);
+        this.add({ kind: "evidence", occurrence, value });
+        return value;
+    }
+    evidenceIn(scope) {
+        const value = this.b.evidenceIn?.(scope) ?? [];
+        this.add({ kind: "scoped-evidence", scope, value });
+        return value;
+    }
+    evidenceOf(instance) {
+        const value = this.b.evidenceOf(instance);
+        this.add({ kind: "instance-evidence", instance, value });
+        return value;
+    }
+    milestone(instance, name) {
+        const value = this.b.milestone?.(instance, name);
+        this.add({ kind: "milestone", instance, name, value: value ?? null });
+        return value;
+    }
+    decisions(instance) {
+        const value = this.b.decisions?.(instance) ?? [];
+        this.add({ kind: "decisions", instance, value });
+        return value;
+    }
+    acceptance(instance, requirement) {
+        const value = this.b.acceptance(instance, requirement);
+        this.add({ kind: "acceptance", instance, requirement, value: value ?? null });
+        return value;
+    }
+    history(instance, machine) {
+        const value = this.b.history(instance, machine);
+        this.add({ kind: "signals", instance, machine, value });
+        return value;
+    }
+    dispatched(key) {
+        const value = this.b.dispatched(key);
+        this.add({ kind: "dispatch", key, value: value ?? null });
+        return value;
+    }
+}
+/** Observe every query, interning identical observations without caching query results. */
+export const observeBasis = (b, reads) => new ObservedBasis(b, reads);
+class ForecastBasis {
+    b;
+    now;
+    constructor(b, now) {
+        this.b = b;
+        this.now = now;
+    }
+    lifecycle(account, instance) {
+        return this.b.lifecycle?.(account, instance);
+    }
+    lifecycleRecords(account, home) {
+        return this.b.lifecycleRecords?.(account, home) ?? [];
+    }
+    resourceRecords(account, home) {
+        return this.b.resourceRecords?.(account, home) ?? [];
+    }
+    document(account, home, key) {
+        return this.b.document?.(account, home, key);
+    }
+    noticeDelivery(account, home, key) {
+        return this.b.noticeDelivery?.(account, home, key);
+    }
+    noticeAcknowledgment(account, home, key) {
+        return this.b.noticeAcknowledgment?.(account, home, key);
+    }
+    file(account, home, digest) {
+        return this.b.file?.(account, home, digest);
+    }
+    fact(entity, attribute) {
+        return this.b.fact(entity, attribute);
+    }
+    confirmation(entity, attribute) {
+        return this.b.confirmation?.(entity, attribute);
+    }
+    entities(namespace) {
+        return this.b.entities(namespace);
+    }
+    matching(attribute, where) {
+        return this.b.matching(attribute, where);
+    }
+    nsOf(entity) {
+        return this.b.nsOf(entity);
+    }
+    evidence(occurrence) {
+        return this.b.evidence(occurrence);
+    }
+    evidenceIn(scope) {
+        return this.b.evidenceIn?.(scope) ?? [];
+    }
+    evidenceOf(instance) {
+        return this.b.evidenceOf(instance);
+    }
+    milestone(instance, name) {
+        return this.b.milestone?.(instance, name);
+    }
+    decisions(instance) {
+        return this.b.decisions?.(instance) ?? [];
+    }
+    acceptance(instance, requirement) {
+        return this.b.acceptance(instance, requirement);
+    }
+    history(instance, machine) {
+        return this.b.history(instance, machine);
+    }
+    dispatched(key) {
+        return this.b.dispatched(key);
+    }
+}
+/** Forecast time over the current snapshot, retaining its actual clock observation. */
+export const forecastBasis = (b, now) => {
+    void b.now;
+    return new ForecastBasis(b, now);
+};

package/dist/_internal/reconciler/discovery.d.ts

@@ -0,0 +1,9 @@
+import type { Basis } from "./basis.js";
+import type { Program } from "./reconcile.js";
+export interface RootCandidate {
+    readonly subject: string;
+    readonly component: string;
+}
+/** Conservative root seeds for an entity id, reached through incoming typed references. Final home filtering
+ * belongs to occurrence discovery: an ordinary reference need not be a home binding. */
+export declare const rootCandidates: (p: Program, b: Basis, subject: string) => readonly RootCandidate[];

package/dist/_internal/reconciler/discovery.js

@@ -0,0 +1,65 @@
+const plans = new WeakMap();
+const referenceTypes = (type, aliases, seen = new Set()) => {
+    if (typeof type === "string") {
+        const alias = aliases.get(type);
+        return alias && !seen.has(type) ? referenceTypes(alias, aliases, new Set([...seen, type])) : [];
+    }
+    if (type[0] === "Id" && typeof type[1] === "string")
+        return [type[1]];
+    if (type[0] === "Option" || type[0] === "Union")
+        return type.slice(1).flatMap((t) => referenceTypes(t, aliases, seen));
+    return [];
+};
+const references = (p) => {
+    const cached = plans.get(p);
+    if (cached)
+        return cached;
+    const owned = p.ir.entities.filter((e) => e.ns.split(".")[0] === p.account.package.name);
+    const aliases = new Map(p.ir.types.map((t) => [t.name, t.type]));
+    const plan = [];
+    for (const source of owned)
+        for (const field of source.fields) {
+            const targets = referenceTypes(field.type, aliases);
+            if (targets.length === 0)
+                continue;
+            for (const entity of p.ir.entities)
+                if (targets.includes(entity.name) ||
+                    (owned.includes(entity) && entity.implements.some((b) => targets.includes(b.role))))
+                    plan.push({ attr: field.attr, source: source.ns, target: entity.ns });
+        }
+    plans.set(p, plan);
+    return plan;
+};
+/** Conservative root seeds for an entity id, reached through incoming typed references. Final home filtering
+ * belongs to occurrence discovery: an ordinary reference need not be a home binding. */
+export const rootCandidates = (p, b, subject) => {
+    const plan = references(p);
+    const queue = [{ id: subject, ns: b.nsOf(subject) }];
+    const visited = new Set();
+    const roots = new Map();
+    for (let cursor = 0; cursor < queue.length; cursor++) {
+        const { id, ns } = queue[cursor];
+        const key = JSON.stringify([id, ns]);
+        if (visited.has(key))
+            continue;
+        visited.add(key);
+        for (const root of p.roots)
+            if (ns !== undefined && root.namespaces.includes(ns)) {
+                let members = roots.get(root.component);
+                if (!members)
+                    roots.set(root.component, (members = new Set()));
+                members.add(id);
+            }
+        for (const ref of plan) {
+            if (ns !== undefined && ref.target !== ns)
+                continue;
+            for (const candidate of b.matching(ref.attr, id)) {
+                const actual = b.nsOf(candidate);
+                if (actual !== undefined && actual !== ref.source)
+                    continue;
+                queue.push({ id: candidate, ns: ref.source });
+            }
+        }
+    }
+    return [...new Set(p.roots.map((r) => r.component))].flatMap((component) => [...(roots.get(component) ?? [])].sort().map((subject) => ({ component, subject })));
+};

package/dist/_internal/reconciler/document-corrections.d.ts

@@ -0,0 +1,18 @@
+import type * as IR from "../world-ir/types.generated.js";
+import type { Basis, EvidenceRecord } from "./basis.js";
+import type { Program } from "./model.js";
+export interface DocumentCorrection {
+    readonly previous: Pick<EvidenceRecord, "id" | "type" | "by" | "at" | "signature">;
+    readonly previousDigest: string;
+    readonly evidence: string;
+    readonly by: string;
+    readonly at: string;
+    readonly reason: string;
+    readonly fields: readonly {
+        readonly label: string;
+        readonly before: string;
+        readonly after: string;
+    }[];
+}
+/** Historical values follow the same disclosure and type mapping as the current template. */
+export declare const documentCorrections: (p: Program, snapshot: Basis, document: IR.Document, evidence: readonly EvidenceRecord[]) => readonly DocumentCorrection[] | undefined;

package/dist/_internal/reconciler/document-corrections.js

@@ -0,0 +1,59 @@
+import { collectionValue } from "./collection-values.js";
+import { evidenceOccurrences } from "./evidence-history.js";
+import { signatureValid } from "./signatures.js";
+import { timeOrder } from "./instants.js";
+import { canonicalJson } from "./result-digest.js";
+import { sha256 } from "./sha256.js";
+/** Historical values follow the same disclosure and type mapping as the current template. */
+export const documentCorrections = (p, snapshot, document, evidence) => {
+    const corrections = [];
+    for (const source of evidence) {
+        let record = source;
+        const seen = new Set([record.id]), chain = [];
+        while (record.amendment) {
+            const link = record.amendment, matches = snapshot.evidence(record.occurrence).filter((e) => e.id === link.previous), previous = matches[0];
+            if (matches.length !== 1 ||
+                !previous ||
+                seen.has(previous.id) ||
+                previous.status !== "attested" ||
+                previous.type !== record.type ||
+                !signatureValid(previous) ||
+                !link.reason.trim() ||
+                link.reason.length > 2000 ||
+                timeOrder(previous.at, record.at) > 0 ||
+                JSON.stringify(evidenceOccurrences(previous)) !==
+                    JSON.stringify(evidenceOccurrences(record)) ||
+                link.previousDigest !== sha256(canonicalJson(previous)))
+                return;
+            const fields = [];
+            for (const mapping of document.fields.filter((f) => f.evidence === record.type)) {
+                const field = p.evidence.get(record.type).fields.find((f) => f.name === mapping.field), display = (e) => {
+                    const raw = e.values[mapping.field];
+                    return raw === undefined || raw === "" ? "" : collectionValue(p, field.type, raw);
+                }, before = display(previous), after = display(record);
+                if (before === undefined || after === undefined)
+                    return;
+                fields.push({ label: mapping.label, before: String(before), after: String(after) });
+            }
+            chain.push({
+                previous: {
+                    id: previous.id,
+                    type: previous.type,
+                    by: previous.by,
+                    at: previous.at,
+                    ...(previous.signature ? { signature: previous.signature } : {}),
+                },
+                previousDigest: link.previousDigest,
+                evidence: record.id,
+                by: record.by,
+                at: record.at,
+                reason: link.reason,
+                fields,
+            });
+            seen.add(previous.id);
+            record = previous;
+        }
+        corrections.push(...chain.reverse());
+    }
+    return corrections;
+};

package/dist/_internal/reconciler/documents.d.ts

@@ -0,0 +1,26 @@
+import type { Cx } from "./model.js";
+import type { Basis, EvidenceRecord } from "./basis.js";
+import type { WorldReconciliation } from "./model.js";
+import { type DocumentCorrection } from "./document-corrections.js";
+export type { DocumentCorrection } from "./document-corrections.js";
+export interface DocumentIntent {
+    readonly key: string;
+    readonly account: string;
+    readonly home: string;
+    readonly instance: string;
+    readonly document: string;
+    readonly edition: string;
+    readonly templateDigest: string;
+    readonly sourceDigest: string;
+    readonly title: string;
+    readonly signedAt: string;
+    readonly evidence: readonly EvidenceRecord[];
+    readonly corrections?: readonly DocumentCorrection[];
+    readonly fields: readonly {
+        readonly label: string;
+        readonly value: string;
+    }[];
+}
+/** Passive after-commit work: rendering and blob I/O belong to the host's Workflow Layers. */
+export declare const documentIntents: (recon: WorldReconciliation, snapshot: Basis, sourceIds?: readonly string[]) => readonly DocumentIntent[];
+export declare const documentIntentsFor: (cx: Cx, sourceIds?: readonly string[]) => readonly DocumentIntent[];

package/dist/_internal/reconciler/documents.js

@@ -0,0 +1,88 @@
+import { resourceProofRecords } from "./resource-generation.js";
+import { contentDigest } from "../ir-checks/index.js";
+import { assertSnapshot, attested, instanceContext } from "./evaluation.js";
+import { occurrenceHome } from "./homes.js";
+import { validEvidence } from "./commands.js";
+import { collectionValue } from "./collection-values.js";
+import { localDateAt, timeOrder } from "./instants.js";
+import { canonicalJson } from "./result-digest.js";
+import { sha256 } from "./sha256.js";
+import { documentCorrections } from "./document-corrections.js";
+/** Passive after-commit work: rendering and blob I/O belong to the host's Workflow Layers. */
+export const documentIntents = (recon, snapshot, sourceIds) => {
+    assertSnapshot(snapshot, recon.now);
+    const intents = [];
+    for (const inst of recon.instances.values()) {
+        intents.push(...documentIntentsFor(instanceContext(recon, snapshot, inst), sourceIds));
+    }
+    return intents.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+};
+export const documentIntentsFor = (cx, sourceIds) => {
+    if (!cx.inst || !cx.k)
+        return [];
+    // Document proof belongs to its declared sources, independent of the consuming requirement.
+    const { occurrence: _occurrence, proofPeriod: _period, ...sourceContext } = cx;
+    const inst = cx.inst, p = cx.p, snapshot = cx.b, intents = [], home = occurrenceHome(p, inst, cx.k.instances)?.id;
+    if (!home)
+        return [];
+    for (const document of p.ir.documents ?? []) {
+        if (document.of !== inst.component)
+            continue;
+        const evidence = [];
+        for (const type of document.sources) {
+            const scoped = document.resource
+                ? resourceProofRecords(p, snapshot, inst, document.resource.name, type)
+                : undefined;
+            const trace = { steps: [] };
+            if (attested({ ...sourceContext, trace }, type, sourceIds
+                ? (scoped ?? snapshot.evidenceOf(inst.id)).filter((e) => e.type === type && sourceIds.includes(e.id))
+                : scoped) !== true)
+                break;
+            const record = trace.witness?.evidence;
+            if (!record || !validEvidence(p, type, record.values, record.at))
+                break;
+            evidence.push(record);
+        }
+        if (evidence.length !== document.sources.length)
+            continue;
+        const signedAt = evidence.reduce((a, e) => (timeOrder(a, e.at) < 0 ? e.at : a), evidence[0].at), date = localDateAt(signedAt), window = document.effective;
+        if ((window.from && date < window.from) || (window.until && date >= window.until))
+            continue;
+        const fields = [];
+        for (const mapping of document.fields) {
+            const record = evidence.find((e) => e.type === mapping.evidence), field = p.evidence.get(mapping.evidence).fields.find((f) => f.name === mapping.field), raw = record.values[mapping.field], value = raw === undefined || raw === "" ? "" : collectionValue(p, field.type, raw);
+            if (value === undefined)
+                break;
+            fields.push({ label: mapping.label, value: String(value) });
+        }
+        if (fields.length !== document.fields.length)
+            continue;
+        const corrections = documentCorrections(p, snapshot, document, evidence);
+        if (!corrections)
+            continue;
+        const templateDigest = contentDigest(document), sourceDigest = sha256(canonicalJson(corrections.length ? { evidence, corrections } : evidence));
+        intents.push({
+            key: sha256(canonicalJson({
+                account: inst.account,
+                home,
+                instance: inst.id,
+                document: document.name,
+                templateDigest,
+                sourceDigest,
+            })),
+            account: inst.account,
+            home,
+            instance: inst.id,
+            document: document.name,
+            edition: document.edition,
+            templateDigest,
+            sourceDigest,
+            title: document.title,
+            signedAt,
+            evidence,
+            ...(corrections.length ? { corrections } : {}),
+            fields,
+        });
+    }
+    return intents.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+};

package/dist/_internal/reconciler/effective.d.ts

@@ -0,0 +1,6 @@
+import type * as IR from "../world-ir/types.generated.js";
+import type { Cx, Truth } from "./model.js";
+export declare const readEffective: (cx: Cx, window: IR.Effective) => {
+    truth: Truth;
+    reason: string;
+};

package/dist/_internal/reconciler/effective.js

@@ -0,0 +1,17 @@
+import { localDateAt } from "./instants.js";
+import { isLocalDate } from "../ir-checks/index.js";
+export const readEffective = (cx, window) => {
+    const { from, until } = window, now = localDateAt(cx.b.now);
+    if ((from === undefined && until === undefined) ||
+        (from !== undefined && !isLocalDate(from)) ||
+        (until !== undefined && !isLocalDate(until)) ||
+        (from && until && from >= until))
+        return { truth: "unknown", reason: "Invalid effective date metadata" };
+    for (const boundary of [from, until])
+        if (boundary && boundary > now)
+            cx.temporal?.add(boundary);
+    return {
+        truth: (!from || now >= from) && (!until || now < until),
+        reason: `From ${from ?? "unbounded"} (inclusive), until ${until ?? "unbounded"} (exclusive)`,
+    };
+};

package/dist/_internal/reconciler/escalations.d.ts

@@ -0,0 +1,4 @@
+import type { EvaluationContext } from "./context.js";
+import type * as IR from "../world-ir/types.generated.js";
+import type { Cx, EscalationResult, HoldResult, Instance, RequirementResult } from "./model.js";
+export declare const evaluateEscalations: (ctx: EvaluationContext, inst: Instance, cx: Cx, component: IR.Component, requirements: readonly RequirementResult[], holds: readonly HoldResult[]) => EscalationResult[];