worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/reconciler/graph.js

@@ -0,0 +1,298 @@
+import { compositionParameters } from "./parameters.js";
+import { policyParameter } from "./policies.js";
+import { contextOf } from "./context.js";
+import { observeBasis, ReadSet } from "./dependencies.js";
+import { evaluateIn, instanceId, isUnknown, selectedAddition, truth, vars } from "./evaluation.js";
+import { Unknown, } from "./model.js";
+import { structuralObservation } from "./provenance.js";
+import { semanticJson } from "./result-digest.js";
+import { timed } from "./scheduling.js";
+export const rankCache = new WeakMap();
+export const componentRanks = (p) => {
+    const cached = rankCache.get(p);
+    if (cached !== undefined)
+        return cached;
+    const reachable = new Set(p.roots.map((r) => r.component));
+    for (const name of reachable)
+        for (const slot of p.components.get(name).slots)
+            reachable.add(slot.component);
+    const incoming = new Map([...reachable].map((name) => [name, 0]));
+    for (const name of reachable)
+        for (const slot of p.components.get(name).slots)
+            incoming.set(slot.component, incoming.get(slot.component) + 1);
+    const ready = [...reachable].filter((name) => incoming.get(name) === 0);
+    const ranks = new Map();
+    for (let i = 0; i < ready.length; i++) {
+        const name = ready[i];
+        ranks.set(name, i);
+        for (const slot of p.components.get(name).slots) {
+            const remaining = incoming.get(slot.component) - 1;
+            incoming.set(slot.component, remaining);
+            if (remaining === 0)
+                ready.push(slot.component);
+        }
+    }
+    const result = ranks.size === reachable.size ? ranks : null;
+    rankCache.set(p, result);
+    return result;
+};
+export const make = (ctx, p, component, key, inputs, cycle, parameters) => {
+    const id = instanceId(component, key, cycle);
+    let inst = ctx.instances.get(id);
+    if (!inst) {
+        inst = {
+            id,
+            account: p.account.name,
+            component,
+            key,
+            inputs,
+            ...(parameters ? { params: parameters } : {}),
+            cycle,
+            attached: [],
+            parents: new Set(),
+            children: [],
+            prior: cycle > 1 ? instanceId(component, key, cycle - 1) : null,
+        };
+        ctx.instances.set(id, inst);
+        ctx.programOf.set(id, p);
+    }
+    return inst;
+};
+export const truthOf = (cx, e) => {
+    if (!e)
+        return { truth: true, reason: "Always applies" };
+    const v = evaluateIn(cx, e);
+    return {
+        truth: truth(v),
+        reason: isUnknown(v) ? `Unknown: ${v.why}` : v === true ? "true" : "false",
+    };
+};
+export const bindKey = (ctx, cx, slot, child) => {
+    const bindings = timed(ctx, cx, ["slot", slot.name, "bind"], `${slot.name}: bindings change`, (active) => slot.bind.map((binding) => [binding.input, evaluateIn(active, binding.expr)]), semanticJson, { discovery: true });
+    const inputs = new Map(bindings);
+    return { inputs, key: child.key.map((k) => inputs.get(k) ?? new Unknown(k)) };
+};
+export const unresolvedKey = (parent, slot, key) => {
+    const missing = key.filter(isUnknown);
+    if (missing.length === 0)
+        return false;
+    parent.children[parent.children.indexOf(slot)] = {
+        ...slot,
+        applies: "unknown",
+        reason: `Unresolved key: ${missing.map((v) => v.why).join("; ")}`,
+    };
+    return true;
+};
+export const cyclesOf = (ctx, p, component, attached, inputs, reads, parameters) => {
+    if (!component.cycle)
+        return [attached];
+    const env = vars([
+        ...inputs,
+        ...component.params.map((param) => [param.name, parameters?.get(param.name) ?? p.params.get(param.name) ?? null]),
+        ["attached", attached],
+    ]);
+    const spells = timed(ctx, { p, b: observeBasis(ctx.b, reads), inst: undefined, env, k: ctx.state, reads }, ["composition", "cycle"], `${component.name}: cycle membership changes`, (active) => {
+        if (!component.paramBounds?.length)
+            return evaluateIn(active, component.cycle);
+        const inst = {
+            id: instanceId(component.name, component.key.map((name) => inputs.get(name)), 1),
+            account: p.account.name,
+            component: component.name,
+            key: component.key.map((name) => inputs.get(name)),
+            inputs,
+            ...(parameters ? { params: parameters } : {}),
+            cycle: 1,
+            attached: [...attached],
+            parents: new Set(),
+            children: [],
+            prior: null,
+        };
+        const cx = { ...active, inst };
+        return evaluateIn({
+            ...cx,
+            env: vars(component.params.map((param) => [
+                param.name,
+                policyParameter(cx, param.name, parameters?.get(param.name) ?? p.params.get(param.name)),
+            ]), env),
+        }, component.cycle);
+    }, semanticJson, {
+        discovery: true,
+        instance: instanceId(component.name, component.key.map((name) => inputs.get(name)), 1),
+    });
+    return Array.isArray(spells) ? spells : [attached];
+};
+export const slotFor = (slot, applies) => ({
+    name: slot.name,
+    component: slot.component,
+    mode: slot.mode,
+    applies: applies.truth,
+    reason: applies.reason,
+    instances: [],
+});
+export const membersOf = (group) => {
+    const members = [...group.members];
+    if (group.links.some((link) => link.parent !== group.links[0].parent))
+        members.sort();
+    return members;
+};
+export const buildInstanceGraph = (ctx) => {
+    const recursive = ctx.programs.some((p) => componentRanks(p) === null);
+    let previous = new Map();
+    while (true) {
+        ctx.instances.clear();
+        ctx.programOf.clear();
+        ctx.contexts.clear();
+        ctx.observations.clear();
+        ctx.results.clear();
+        ctx.evaluating.clear();
+        ctx.resolvingOutputs.clear();
+        ctx.roots.length = 0;
+        ctx.rootFocus.clear();
+        ctx.blockedTotal = 0;
+        ctx.temporalJobs.length = 0;
+        ctx.discoveryJobs.length = 0;
+        const groups = new Map();
+        const seeds = [];
+        const buckets = Array.from({
+            length: recursive
+                ? 1
+                : Math.max(0, ...ctx.programs.map((p) => componentRanks(p).size)) + 1,
+        }, () => []);
+        const addGroup = (p, component, key, inputs, members) => {
+            const id = `${p.account.name}|${instanceId(component.name, key, 1)}`;
+            let group = groups.get(id);
+            if (!group) {
+                group = {
+                    id,
+                    p,
+                    component,
+                    key,
+                    inputs,
+                    members: new Set(),
+                    links: [],
+                    resolved: [],
+                    root: false,
+                };
+                groups.set(id, group);
+                buckets[recursive ? 0 : componentRanks(p).get(component.name)].push(group);
+            }
+            members.forEach((member) => group.members.add(member));
+            return group;
+        };
+        for (const p of ctx.programs)
+            for (const root of p.roots) {
+                const component = p.components.get(root.component);
+                const subjects = ctx.scope
+                    ? ctx.scope.subjects(component.name, root.namespaces)
+                    : root.namespaces.flatMap((ns) => ctx.b.entities(ns)).sort();
+                for (const subject of subjects) {
+                    const group = addGroup(p, component, [subject], new Map([[component.key[0], subject]]), [
+                        subject,
+                    ]);
+                    group.root = true;
+                    seeds.push({ group, subject });
+                }
+            }
+        // A DAG can collect every parent before visiting its children. Recursive definitions
+        // rebuild from the preceding membership solution, so late paths can also add or remove cycles.
+        for (const bucket of buckets)
+            for (let cursor = 0; cursor < bucket.length; cursor++) {
+                const group = bucket[cursor];
+                const { p, component, key, inputs } = group;
+                const members = (recursive ? previous.get(group.id) : undefined) ?? membersOf(group);
+                const parameters = compositionParameters(p, component, group.links.flatMap((link) => link.with ?? []));
+                const cycleReads = new ReadSet();
+                const cycles = group.root
+                    ? [members]
+                    : cyclesOf(ctx, p, component, members, inputs, cycleReads, parameters);
+                group.resolved = cycles.map((attached, index) => {
+                    const inst = make(ctx, p, component.name, key, inputs, index + 1, parameters);
+                    inst.attached.push(...attached);
+                    const reads = new ReadSet();
+                    reads.merge(cycleReads.entries());
+                    ctx.observations.set(inst.id, reads);
+                    return inst;
+                });
+                if (!group.root && component.cycle)
+                    ctx.discoveryJobs.push(() => {
+                        // A cycle can be empty now; its parents must still retain the reads that can create it.
+                        const ids = [
+                            ...group.resolved.map((inst) => inst.id),
+                            ...group.links.map((link) => link.parent.id),
+                        ];
+                        for (const id of ids)
+                            ctx.observations.get(id).merge(cycleReads.entries(), structuralObservation);
+                    });
+                for (const parent of group.resolved) {
+                    if (!component.slots.length)
+                        continue;
+                    const cx = contextOf(ctx, parent);
+                    for (const slot of component.slots) {
+                        const applies = timed(ctx, cx, ["slot", slot.name, "applies"], `${slot.name}: applicability changes`, (active) => {
+                            const addition = slot.discretionary
+                                ? selectedAddition(active, slot.name, (date) => active.temporal?.add(date))
+                                : null;
+                            if (slot.discretionary && !addition)
+                                return { truth: false, reason: "No standing addition" };
+                            const applies = truthOf(active, slot.appliesWhen);
+                            return addition
+                                ? {
+                                    ...applies,
+                                    reason: `${applies.reason}; added by ${addition.record.by} on ${addition.record.at} (${addition.record.id})`,
+                                }
+                                : applies;
+                        }, (value) => (slot.discretionary ? semanticJson(value) : String(value.truth)), { discovery: true });
+                        const childSlot = slotFor(slot, applies);
+                        parent.children.push(childSlot);
+                        if (childSlot.applies !== true)
+                            continue;
+                        const child = p.components.get(slot.component);
+                        const bound = bindKey(ctx, cx, slot, child);
+                        if (unresolvedKey(parent, childSlot, bound.key))
+                            continue;
+                        addGroup(p, child, bound.key, bound.inputs, parent.attached).links.push({
+                            parent,
+                            slot: childSlot,
+                            members: parent.attached,
+                            ...(slot.with ? { with: slot.with } : {}),
+                        });
+                    }
+                }
+            }
+        if (recursive) {
+            const current = new Map([...groups].map(([id, group]) => [id, membersOf(group)]));
+            if (current.size !== previous.size ||
+                [...current].some(([id, members]) => JSON.stringify(members) !== JSON.stringify(previous.get(id)))) {
+                previous = current;
+                continue;
+            }
+        }
+        for (const group of groups.values())
+            for (const inst of group.resolved) {
+                const attached = new Set(inst.attached);
+                for (const link of group.links)
+                    if (link.members.some((member) => attached.has(member))) {
+                        inst.parents.add(link.parent.id);
+                        if (!link.slot.instances.includes(inst.id))
+                            link.slot.instances.push(inst.id);
+                    }
+            }
+        for (const { group, subject } of seeds)
+            for (const inst of group.resolved)
+                if (inst.attached.includes(subject)) {
+                    ctx.roots.push({ subject, account: group.p.account.name, instance: inst.id });
+                    ctx.rootFocus.set(inst.id, subject);
+                }
+        ctx.discoveryReadSets = new Map([...ctx.contexts].map(([id, cx]) => [id, cx.reads]));
+        for (const [id, cx] of ctx.contexts)
+            ctx.observations.get(id).merge(cx.reads.entries(), structuralObservation);
+        // Applicability can read a parent's requirements while discovering slots. Those partial
+        // projections must not survive the final membership and link graph.
+        ctx.results.clear();
+        ctx.evaluating.clear();
+        ctx.contexts.clear();
+        ctx.blockedTotal = 0;
+        ctx.temporalJobs.length = 0;
+        break;
+    }
+};

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

@@ -0,0 +1,6 @@
+import type { EvaluationContext } from "./context.js";
+import type * as IR from "../world-ir/types.generated.js";
+import type { Cx, HoldResult } from "./model.js";
+export declare const evaluateHolds: (ctx: EvaluationContext, cx: Cx, component: IR.Component) => HoldResult[];
+/** Missing authority to proceed conservatively pauses work; facts can resolve it later. */
+export declare const activeHolds: (holds: readonly HoldResult[], policy: IR.Hold["pauses"][number]) => HoldResult[];

package/dist/_internal/reconciler/holds.js

@@ -0,0 +1,18 @@
+import { evaluateIn, isUnknown, truth } from "./evaluation.js";
+import { timed } from "./scheduling.js";
+export const evaluateHolds = (ctx, cx, component) => (component.holds ?? []).map((hold, index) => {
+    const read = timed(ctx, cx, ["hold", String(index), hold.name], `${hold.label ?? hold.name}: hold changes`, (c) => {
+        const value = evaluateIn(c, hold.while);
+        return { condition: truth(value), unknown: isUnknown(value) ? value.why : null };
+    });
+    return {
+        name: hold.name,
+        label: hold.label ?? hold.name,
+        ...read,
+        pauses: hold.pauses,
+        ...(hold.cites ? { cites: hold.cites } : {}),
+        at: hold.at,
+    };
+});
+/** Missing authority to proceed conservatively pauses work; facts can resolve it later. */
+export const activeHolds = (holds, policy) => holds.filter((hold) => hold.condition !== false && hold.pauses.includes(policy));

package/dist/_internal/reconciler/home-definitions.d.ts

@@ -0,0 +1,11 @@
+import type * as IR from "../world-ir/types.generated.js";
+export interface HomeDefinitions {
+    readonly ir: {
+        readonly roles: readonly Pick<IR.Role, "name">[];
+        readonly entities: readonly Pick<IR.Entity, "name">[];
+    };
+    readonly components: ReadonlyMap<string, Pick<IR.Component, "key" | "inputs">>;
+}
+export declare const inferEntityHome: (p: HomeDefinitions, component: string, seen?: Set<string>) => Extract<IR.Home, {
+    readonly kind: "input";
+}> | undefined;

package/dist/_internal/reconciler/home-definitions.js

@@ -0,0 +1,25 @@
+export const inferEntityHome = (p, component, seen = new Set()) => {
+    if (seen.has(component))
+        return undefined;
+    const c = p.components.get(component);
+    const first = c.key[0];
+    const targetOf = (t) => {
+        if (!Array.isArray(t))
+            return undefined;
+        return t[0] === "Option"
+            ? targetOf(t[1])
+            : t[0] === "Id" && typeof t[1] === "string"
+                ? t[1]
+                : undefined;
+    };
+    const target = targetOf(c.inputs.find((f) => f.name === first)?.type);
+    if (first &&
+        target &&
+        (p.ir.roles.some((r) => r.name === target) || p.ir.entities.some((e) => e.name === target)))
+        return { kind: "input", path: [first] };
+    if (first && target && p.components.has(target)) {
+        const nested = inferEntityHome(p, target, new Set([...seen, component]));
+        return nested ? { kind: "input", path: [first, ...nested.path] } : undefined;
+    }
+    return undefined;
+};

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

@@ -0,0 +1,6 @@
+import { type Instance, type Program, type SubjectHome } from "./model.js";
+export { inferEntityHome } from "./home-definitions.js";
+export declare const homesCache: WeakMap<Program, ReadonlyMap<string, readonly string[]>>;
+export declare const entityHomes: (p: Program) => ReadonlyMap<string, readonly string[]>;
+/** A missing home input stays unresolved; it does not acquire a different owner. */
+export declare const occurrenceHome: (p: Program, inst: Instance, instances: ReadonlyMap<string, Instance>) => SubjectHome | null;

package/dist/_internal/reconciler/homes.js

@@ -0,0 +1,32 @@
+import { isInst } from "./evaluation.js";
+import {} from "./model.js";
+import { inferEntityHome } from "./home-definitions.js";
+export { inferEntityHome } from "./home-definitions.js";
+export const homesCache = new WeakMap();
+export const entityHomes = (p) => {
+    const cached = homesCache.get(p);
+    if (cached)
+        return cached;
+    const homes = new Map();
+    for (const name of p.components.keys()) {
+        const home = inferEntityHome(p, name);
+        if (!home || home.kind !== "input")
+            throw new Error(`E_NO_HOME: ${name} must have an entity-reference first key. Republish this model.`);
+        homes.set(name, home.path);
+    }
+    homesCache.set(p, homes);
+    return homes;
+};
+/** A missing home input stays unresolved; it does not acquire a different owner. */
+export const occurrenceHome = (p, inst, instances) => {
+    const path = entityHomes(p).get(inst.component);
+    let value = { inst: inst.id };
+    for (const field of path) {
+        if (!value || !isInst(value))
+            return null;
+        value = instances.get(value.inst)?.inputs.get(field);
+    }
+    if (typeof value === "string")
+        return { kind: "entity", id: value };
+    return null;
+};

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

@@ -0,0 +1,42 @@
+export { sensitivePayload, sensitivityOfType } from "../ir-checks/index.js";
+export { operationsFor, invokeOperation, type OperationTarget, type OperationRequest, type OperationResult, type PublicOperation, } from "./component-operations.js";
+export * from "./reconcile.js";
+export * from "./basis.js";
+export { collectionTasks, collectFacts, type CollectionTask, type CollectionField, } from "./collections.js";
+export { projectInteractionFields } from "./interaction-fields.js";
+export * from "./memory.js";
+export { recordMilestones } from "./milestones.js";
+export * from "./discovery.js";
+export * from "./dates.js";
+export * from "./instants.js";
+export * as IR from "./wire.js";
+export { Compiled, WorldIR, decodeCompiled } from "./wire.js";
+export { dependencyKey, type Dependency } from "./dependencies.js";
+export { sha256 } from "./sha256.js";
+export { canonicalJson, canonicalResult, resultDigest } from "./result-digest.js";
+export { subjectChanged } from "./change-detection.js";
+export { createScenarioRunner, type ScenarioRunner, runScenario, runScenarios, type ScenarioResult, type ScenarioFailure, type ScenarioCommandOutcome, } from "./scenarios.js";
+export { log, perform, signal, command, validEvidence, type Perform, type WorkActor, type Command, } from "./commands.js";
+export { evaluateProperty } from "./property-eval.js";
+export { generatePropertyCase, validatePropertyOptions, type PropertyOptions, } from "./property-generator.js";
+export { checkProperty, checkProperties, type PropertyResult, type PropertyFailure, } from "./properties.js";
+export { shrinkPropertyFailure, type ShrunkPropertyFailure } from "./property-shrink.js";
+export { createCoverageCollector, type RequirementCoverage, type CoverageOutcomes, type CoverageTruth, type CoverageReference, } from "./coverage.js";
+export { decide, type DecisionRequest, type DecisionResult } from "./decide.js";
+export { priorCycleDecisionName, priorCycleOperationName, reuseDecisionName, } from "../ir-checks/index.js";
+export { previewPolicyParameters, type PolicyParameterPreview } from "./policy-edits.js";
+export { workItems, type ProjectedWork, type WorkMember } from "./work.js";
+export { bundleFor, type BundleItem, type BundleSession } from "./bundles.js";
+export { fileDigest, fileAllowed, factFileAllowed } from "./files.js";
+export { validFact } from "./fact-validation.js";
+export { documentIntents, type DocumentIntent, type DocumentCorrection } from "./documents.js";
+export { noticeProjection, type NoticeCopy } from "./notices.js";
+export { signatureValid, type SignatureTrail } from "./signatures.js";
+export { amendEvidence } from "./commands.js";
+export { resourceProjection, resourceIntentKey, type ResourceView } from "./resources.js";
+export type { LifecycleRecord, ResourceRecord, ResourceIntent } from "./basis.js";
+export { resourceProgramDigest } from "./resource-generation.js";
+export { amendmentAction } from "./amendments.js";
+export { dataReadInfo, agentReadInfo, agentReadDiagnostics, type DataReadSelector, type AgentReadPermission, } from "../ir-checks/index.js";
+export type { Missing } from "./missing.js";
+export { resourceMachineScope } from "./resource-generation.js";

package/dist/_internal/reconciler/index.js

@@ -0,0 +1,58 @@
+export { sensitivePayload, sensitivityOfType } from "../ir-checks/index.js";
+export { operationsFor, invokeOperation, } from "./component-operations.js";
+// world-ir owns generated wire schemas/types; wire preserves the public decode boundary.
+// Kernel map: model/context define the explicit evaluation state; linking/homes resolve
+// scopes; graph discovers instances; requirements/actions/outputs evaluate them;
+// decision-evaluation/decision-records select standing human grants and additions;
+// escalations derives finite due-relative intents with visible Unknown/hold projections;
+// policies adds cited account constraints and authority intersections; policy-linking checks bounds/releases;
+// effective applies fixed release windows with located proof and boundary wakeups;
+// recurrence derives anchored periods directly, with period-local proof and bounded wakeups;
+// reuse queries indexed immutable proof scopes and standing human confirmations;
+// evidence-validity reads signed expiry fields and deadline-keyed early renewal work;
+// milestones projects immutable first reaches and visible later regression findings;
+// holds overlays occurrence-local dispatch/reminders without changing deadlines;
+// interaction-fields projects missing, known and path-bound facts through observed reads;
+// action-intents derives dispatch and ineligibility policy without storing work;
+// bundles orders supplied actor-scoped work for presentation without changing eligibility;
+// work projects identity/provenance and suppresses conflicting multi-target dispatch;
+// scheduling/projections/proofs retain wakeups, dependencies and digests; invariants/upgrades
+// handle write admission and release planning. reconcile preserves the public entry points.
+export * from "./reconcile.js";
+export * from "./basis.js";
+export { collectionTasks, collectFacts, } from "./collections.js";
+export { projectInteractionFields } from "./interaction-fields.js";
+export * from "./memory.js";
+export { recordMilestones } from "./milestones.js";
+export * from "./discovery.js";
+export * from "./dates.js";
+export * from "./instants.js";
+export * as IR from "./wire.js";
+export { Compiled, WorldIR, decodeCompiled } from "./wire.js";
+export { dependencyKey } from "./dependencies.js";
+export { sha256 } from "./sha256.js";
+export { canonicalJson, canonicalResult, resultDigest } from "./result-digest.js";
+export { subjectChanged } from "./change-detection.js";
+export { createScenarioRunner, runScenario, runScenarios, } from "./scenarios.js";
+export { log, perform, signal, command, validEvidence, } from "./commands.js";
+export { evaluateProperty } from "./property-eval.js";
+export { generatePropertyCase, validatePropertyOptions, } from "./property-generator.js";
+export { checkProperty, checkProperties, } from "./properties.js";
+export { shrinkPropertyFailure } from "./property-shrink.js";
+export { createCoverageCollector, } from "./coverage.js";
+export { decide } from "./decide.js";
+export { priorCycleDecisionName, priorCycleOperationName, reuseDecisionName, } from "../ir-checks/index.js";
+export { previewPolicyParameters } from "./policy-edits.js";
+export { workItems } from "./work.js";
+export { bundleFor } from "./bundles.js";
+export { fileDigest, fileAllowed, factFileAllowed } from "./files.js";
+export { validFact } from "./fact-validation.js";
+export { documentIntents } from "./documents.js";
+export { noticeProjection } from "./notices.js";
+export { signatureValid } from "./signatures.js";
+export { amendEvidence } from "./commands.js";
+export { resourceProjection, resourceIntentKey } from "./resources.js";
+export { resourceProgramDigest } from "./resource-generation.js";
+export { amendmentAction } from "./amendments.js";
+export { dataReadInfo, agentReadInfo, agentReadDiagnostics, } from "../ir-checks/index.js";
+export { resourceMachineScope } from "./resource-generation.js";

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

@@ -0,0 +1,17 @@
+import { type LocalDate } from "./dates.js";
+export { isInstant, normalizeInstant } from "../ir-checks/index.js";
+export type Instant = string;
+export type TimePoint = LocalDate | Instant;
+export type TimeUnit = "minutes" | "hours" | "days" | "months" | "years";
+/** Mixed ordering treats a date as its UTC midnight; it never rewrites the stored date. */
+export declare const compareTime: (a: TimePoint, b: TimePoint) => -1 | 0 | 1;
+/** The current in-memory clock has a UTC date projection; per-worksite zones are separate. */
+export declare const localDateAt: (point: TimePoint) => LocalDate;
+export declare const isPastDeadline: (now: TimePoint, due: TimePoint) => boolean;
+export declare const shiftTime: (point: TimePoint, n: number, unit: TimeUnit) => TimePoint;
+/** Next representable predicate boundary; stop at the supported calendar's end. */
+export declare const nextTime: (point: TimePoint) => TimePoint | null;
+/** Host/command timestamps are normalized; preserve the old date-only hot path. */
+export declare const timeOrder: (a: TimePoint, b: TimePoint) => -1 | 0 | 1;
+/** Date deadlines include their final millisecond; instant deadlines keep their exact end. */
+export declare const deadlineOrder: (a: TimePoint, b: TimePoint) => -1 | 0 | 1;

package/dist/_internal/reconciler/instants.js

@@ -0,0 +1,56 @@
+import { isInstant, isLocalDate, timePointKey } from "../ir-checks/index.js";
+import { addDays, addMonths, addYears } from "./dates.js";
+export { isInstant, normalizeInstant } from "../ir-checks/index.js";
+const checked = (value) => {
+    if (!isLocalDate(value) && !isInstant(value))
+        throw new RangeError("Expected a local date or canonical UTC millisecond instant");
+    return value;
+};
+/** Mixed ordering treats a date as its UTC midnight; it never rewrites the stored date. */
+export const compareTime = (a, b) => {
+    const left = timePointKey(a), right = timePointKey(b);
+    return left === right ? 0 : left < right ? -1 : 1;
+};
+/** The current in-memory clock has a UTC date projection; per-worksite zones are separate. */
+export const localDateAt = (point) => checked(point).slice(0, 10);
+export const isPastDeadline = (now, due) => isLocalDate(due) ? localDateAt(now) > due : compareTime(now, due) > 0;
+export const shiftTime = (point, n, unit) => {
+    checked(point);
+    if (!Number.isSafeInteger(n))
+        throw new RangeError("Time offsets must be safe integers");
+    const date = point.slice(0, 10), instant = point.length !== 10;
+    if (!instant && (unit === "minutes" || unit === "hours"))
+        throw new RangeError("Sub-day offsets require an instant");
+    let result;
+    if (unit === "years" || unit === "months" || (!instant && unit === "days")) {
+        const shifted = unit === "years"
+            ? addYears(date, n)
+            : unit === "months"
+                ? addMonths(date, n)
+                : addDays(date, n);
+        result = instant ? `${shifted}${point.slice(10)}` : shifted;
+    }
+    else {
+        const scale = unit === "minutes" ? 60_000 : unit === "hours" ? 3_600_000 : 86_400_000;
+        result = new Date(Date.parse(point) + n * scale).toISOString();
+    }
+    return checked(result);
+};
+/** Next representable predicate boundary; stop at the supported calendar's end. */
+export const nextTime = (point) => {
+    checked(point);
+    try {
+        return point.length === 10
+            ? shiftTime(point, 1, "days")
+            : checked(new Date(Date.parse(point) + 1).toISOString());
+    }
+    catch (error) {
+        if (!(error instanceof RangeError))
+            throw error;
+        return null;
+    }
+};
+/** Host/command timestamps are normalized; preserve the old date-only hot path. */
+export const timeOrder = (a, b) => a.length === b.length ? (a === b ? 0 : a < b ? -1 : 1) : compareTime(a, b);
+/** Date deadlines include their final millisecond; instant deadlines keep their exact end. */
+export const deadlineOrder = (a, b) => timeOrder(a.length === 10 ? `${a}T23:59:59.999Z` : a, b.length === 10 ? `${b}T23:59:59.999Z` : b);

package/dist/_internal/reconciler/interaction-fields.d.ts

@@ -0,0 +1,10 @@
+import type { Basis } from "./basis.js";
+import type { TimePoint } from "./instants.js";
+import type * as IR from "../world-ir/types.generated.js";
+import type { InteractionField, Program, Value } from "./model.js";
+export declare const bindingReadOnly: (p: Program, binding: IR.InteractionBinding) => boolean;
+/** The caller supplies its observed evaluation context, keeping fact reads in the proof. */
+export declare const projectInteractionFields: (p: Program, interaction: IR.Interaction, read: (expr: IR.Expr) => Value, source?: {
+    readonly basis: Basis;
+    readonly temporal?: Set<TimePoint>;
+}) => readonly InteractionField[];

package/dist/_internal/reconciler/interaction-fields.js

@@ -0,0 +1,30 @@
+import { collectionState } from "./collection-rules.js";
+import { isUnknown } from "./evaluation.js";
+export const bindingReadOnly = (p, binding) => {
+    const expr = binding.target ?? binding.from;
+    return (expr?.k === "attr" && !!expr.meta.via && (p.bindings.get(expr.meta.via)?.attrs.length ?? 0) > 1);
+};
+/** The caller supplies its observed evaluation context, keeping fact reads in the proof. */
+export const projectInteractionFields = (p, interaction, read, source) => (p.evidence.get(interaction.produces)?.fields ?? [])
+    .filter(({ name }) => !interaction.fixes?.some((fixed) => fixed.field === name))
+    .map(({ name: field }) => {
+    const binding = interaction.binds.find((b) => b.field === field);
+    const expr = binding?.from ?? binding?.target;
+    const value = expr ? read(expr) : null;
+    const known = typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+    const entity = source && expr?.k === "attr" && p.ir.collects?.length ? read(expr.of) : null;
+    const collection = source && expr?.k === "attr" && typeof entity === "string"
+        ? collectionState(p, source.basis, entity, expr.attr, source.temporal)
+        : undefined;
+    return {
+        ...(collection ? { collection } : {}),
+        field,
+        mode: binding && bindingReadOnly(p, binding) ? "read-only" : known ? "confirm" : "ask",
+        value: known ? value : null,
+        ...(isUnknown(value)
+            ? { unknown: value.why }
+            : expr && !known
+                ? { unknown: `${field} has no scalar fact value` }
+                : {}),
+    };
+});

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

@@ -0,0 +1,8 @@
+import { type Basis } from "./basis.js";
+import { type LocalDate } from "./dates.js";
+import { type Violation, type WorldReconciliation } from "./model.js";
+/** Would a command of `kind` against `subject` violate a declared invariant at `now`? */
+export declare const admit: (recon: WorldReconciliation, b: Basis, now: LocalDate, command: {
+    readonly kind: string;
+    readonly subject: string;
+}) => readonly Violation[];