worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/reconciler/requirements.js

@@ -0,0 +1,331 @@
+import { readReuse, reuseDecisionName } from "./reuse.js";
+import { actionTargets } from "./work.js";
+import { policyRequirements } from "./policies.js";
+import { timeOrder, isPastDeadline, deadlineOrder, nextTime } from "./instants.js";
+import { readRenewal } from "./evidence-validity.js";
+import { evaluateMilestones } from "./milestones.js";
+import { evaluateEscalations } from "./escalations.js";
+import { evaluateActions } from "./actions.js";
+import {} from "./basis.js";
+import { contextOf } from "./context.js";
+import {} from "./dates.js";
+import { evaluateIn, timeOf, and, isDuration, isUnknown, legacyAcceptance, plus, selectedDecision, selectedAddition, truth, } from "./evaluation.js";
+import { truthOf } from "./graph.js";
+import { activeHolds, evaluateHolds } from "./holds.js";
+import {} from "./model.js";
+import { outputStatus, outputText } from "./outputs.js";
+import { semanticJson } from "./result-digest.js";
+import { readEffective } from "./effective.js";
+import { readRecurrence } from "./recurrence.js";
+import { Unknown } from "./model.js";
+import { timed } from "./scheduling.js";
+export function evaluate(ctx, inst) {
+    const done = ctx.results.get(inst.id);
+    if (done)
+        return done;
+    const p = ctx.programOf.get(inst.id);
+    const component = p.components.get(inst.component);
+    const cx = contextOf(ctx, inst);
+    const partial = new Map();
+    ctx.evaluating.set(inst.id, partial);
+    let requirements = evaluateRequirements(ctx, inst, cx, component, partial);
+    // Children before outputs: outputs read child statuses.
+    for (const slot of inst.children)
+        for (const id of slot.instances)
+            if (!ctx.evaluating.has(id))
+                evaluate(ctx, ctx.instances.get(id));
+    const outputs = component.outputs.map((o) => ({
+        name: o.name,
+        label: o.label ?? o.name,
+        expr: outputText(o),
+        status: outputStatus(ctx, inst, o),
+        at: o.at,
+    }));
+    const milestones = evaluateMilestones(ctx, cx, component);
+    for (const resource of component.resources ?? [])
+        timed(ctx, cx, ["resource", resource.name], `${resource.name}: release condition changes`, (c) => truth(evaluateIn(c, resource.releaseWhen)), String);
+    const holds = evaluateHolds(ctx, cx, component);
+    if (activeHolds(holds, "remind").length)
+        requirements = requirements.map((r) => (r.remindAt ? { ...r, remindAt: null } : r));
+    const escalations = evaluateEscalations(ctx, inst, cx, component, requirements, holds);
+    const { actions, workIntents } = evaluateActions(ctx, inst, cx, component, requirements, holds);
+    const blocked = requirements
+        .filter((r) => (r.status === "Open" || r.status === "Overdue") &&
+        !r.awaits &&
+        !actions.some((a) => actionTargets(a).includes(r.name)))
+        .map((r) => ({
+        requirement: r.name,
+        reason: `${r.label} is open and no declared action advances it`,
+    }));
+    ctx.blockedTotal += blocked.length;
+    let retention = null;
+    if (component.retention) {
+        const trace = { steps: [] };
+        retention = timed(ctx, { ...cx, trace }, ["retention"], "Retention becomes eligible for review", (c) => {
+            const value = evaluateIn(c, component.retention.until);
+            const until = isUnknown(value) ? null : String(value);
+            if (until)
+                c.temporal?.add(until);
+            return {
+                until,
+                eligible: until === null ? null : timeOrder(c.b.now, until) >= 0,
+                steps: c.trace?.steps ?? [],
+                unknown: isUnknown(value) ? value.why : null,
+                disposal: component.retention.disposal,
+            };
+        }, (value) => semanticJson([value.until, value.eligible]));
+    }
+    const result = {
+        ...(milestones.length ? { milestones } : {}),
+        ...(escalations.length ? { escalations } : {}),
+        ...(holds.length ? { holds } : {}),
+        instance: inst.id,
+        component: inst.component,
+        requirements,
+        outputs,
+        actions,
+        workIntents,
+        blocked,
+        wakeAt: null,
+        wakeReason: "",
+        retention,
+    };
+    ctx.evaluating.delete(inst.id);
+    ctx.results.set(inst.id, result);
+    return result;
+}
+export const evaluateRequirements = (ctx, inst, baseCx, component, partial) => {
+    const requirements = [];
+    for (const r of component.requirements) {
+        const effective = r.effective
+            ? timed(ctx, baseCx, ["requirement", r.name, "effective"], `${r.label ?? r.name}: effective window changes`, (c) => readEffective(c, r.effective))
+            : null;
+        const recurrence = r.recur
+            ? timed(ctx, baseCx, ["requirement", r.name, "recurrence"], `${r.label ?? r.name}: recurrence boundary`, (c) => readRecurrence(c, r.recur))
+            : null;
+        const cx = recurrence?.period
+            ? {
+                ...baseCx,
+                proofPeriod: recurrence.period,
+                occurrence: `${inst.id}/${r.name}@${recurrence.period.start}`,
+            }
+            : baseCx;
+        const b = cx.b;
+        const trace = { steps: [] };
+        const traced = { ...cx, trace };
+        const label = r.label ?? r.name;
+        const decision = (cx.p.ir.decisions ?? []).some((d) => d.of === inst.component && d.applies === (r.accepts?.with ?? r.name) && d.effect !== "add")
+            ? timed(ctx, cx, ["requirement", r.name, "decision"], `${label}: decision changes`, (c) => selectedDecision(c, r.name, (date) => c.temporal?.add(date)), semanticJson)
+            : null;
+        const addition = r.discretionary
+            ? timed(ctx, cx, ["requirement", r.name, "addition"], `${label}: addition changes`, (c) => selectedAddition(c, r.name, (date) => c.temporal?.add(date)), semanticJson)
+            : null;
+        const cycleValue = r.recur
+            ? (recurrence?.period?.start ?? new Unknown(recurrence.reason))
+            : r.cycle
+                ? timed(ctx, traced, ["requirement", r.name, "cycle"], `${label}: cycle changes`, (c) => evaluateIn(c, r.cycle), semanticJson, { enabled: () => applies.truth === true })
+                : null;
+        const occurrence = `${inst.id}/${r.name}${cycleValue !== null && !isUnknown(cycleValue) ? `@${String(cycleValue)}` : ""}`;
+        const applies = timed(ctx, traced, ["requirement", r.name, "applies"], `${label}: applicability changes`, (c) => {
+            const applicable = r.discretionary && !selectedAddition(c, r.name, (date) => c.temporal?.add(date))
+                ? { truth: false, reason: "No standing addition" }
+                : truthOf(c, r.appliesWhen);
+            return r.recur || r.effective
+                ? {
+                    ...applicable,
+                    truth: and([
+                        applicable.truth,
+                        r.recur ? readRecurrence(c, r.recur).truth : true,
+                        r.effective ? readEffective(c, r.effective).truth : true,
+                    ]),
+                }
+                : applicable;
+        }, (v) => String(v.truth));
+        const reasons = [];
+        if (effective)
+            reasons.push({
+                label: "Effective window",
+                outcome: effective.truth === true ? "passed" : effective.truth === false ? "failed" : "unknown",
+                detail: effective.reason,
+                at: r.effective.at,
+            });
+        if (recurrence)
+            reasons.push({
+                label: "Recurrence",
+                outcome: recurrence.truth === true ? "passed" : recurrence.truth === false ? "failed" : "unknown",
+                detail: recurrence.reason,
+                at: r.recur.at,
+            });
+        if (r.discretionary) {
+            if (addition)
+                for (const record of addition.votes ?? [addition.record])
+                    reasons.push({
+                        label: "Added work",
+                        outcome: "passed",
+                        detail: `${record.id}: added by ${record.by} on ${record.at}${record.reason === null ? "" : ` (${record.reason})`}`,
+                        at: addition.definition.at,
+                    });
+            else
+                reasons.push({
+                    label: "Added work",
+                    outcome: "failed",
+                    detail: "No standing addition",
+                    at: r.at,
+                });
+        }
+        if (r.appliesWhen)
+            reasons.push({
+                label: "Applies when",
+                outcome: applies.truth === true ? "passed" : applies.truth === false ? "failed" : "unknown",
+                detail: applies.reason,
+                at: r.appliesWhen.at,
+            });
+        let status;
+        let due = null;
+        let dueUnknown = null;
+        let dueSteps = [];
+        let remindAt = null;
+        let evidence = null;
+        let evidenceType = null;
+        let via = "";
+        let awaits = null;
+        if (applies.truth === false)
+            status = "NotApplicable";
+        else if (applies.truth === "unknown")
+            status = "Unknown";
+        else {
+            const acceptedFrom = legacyAcceptance(cx, r);
+            let sat;
+            let detail;
+            if ((decision?.definition.effect === "reject" &&
+                (!r.reuse ||
+                    decision.definition.name !== reuseDecisionName(inst.component, r.name, "declined"))) ||
+                (decision?.definition.effect === "accept" && !r.reuse)) {
+                sat = decision.definition.effect === "accept";
+                via = `decision:${decision.record.id}`;
+                detail = `Decision ${decision.record.id} by ${decision.record.by}: ${decision.definition.effect}`;
+            }
+            else if (acceptedFrom?.decision === "accepted") {
+                sat = true;
+                via = "acceptance";
+                detail = `Carried over from ${acceptedFrom.from}, confirmed by ${acceptedFrom.by}`;
+            }
+            else {
+                const satTrace = { steps: [] };
+                const value = timed(ctx, { ...cx, trace: satTrace, occurrence }, ["requirement", r.name, "satisfied"], `${label}: satisfaction changes`, (c) => {
+                    const value = evaluateIn(c, r.satisfiedBy);
+                    return truth(value) === true || !r.reuse ? value : readReuse(c, r);
+                }, (v) => String(truth(v)));
+                sat = truth(value);
+                evidence = satTrace.witness?.evidence ?? null;
+                evidenceType = satTrace.witness?.type ?? null;
+                via = satTrace.witness?.via ?? "";
+                awaits = satTrace.awaits ?? null;
+                detail =
+                    satTrace.witness?.detail ??
+                        (isUnknown(value) ? `Unknown: ${value.why}` : sat === true ? "true" : "false");
+                if (sat !== true && evidence?.status === "attested")
+                    evidence = null;
+            }
+            const lawSat = sat;
+            const policies = timed(ctx, cx, ["requirement", r.name, "policies"], `${label}: policy changes`, policyRequirements);
+            for (const { truth: _truth, ...reason } of policies)
+                reasons.push(reason);
+            sat = and([sat, ...policies.map((p) => p.truth)]);
+            reasons.push({
+                label: "Satisfied by",
+                outcome: lawSat === true ? "passed" : lawSat === false ? "failed" : "unknown",
+                detail,
+                at: r.satisfiedBy.at,
+            });
+            if (r.due) {
+                const dueTrace = { steps: [] };
+                const value = timed(ctx, { ...cx, trace: dueTrace }, ["requirement", r.name, "due"], `${label}: due date changes`, (c) => evaluateIn(c, r.due), semanticJson, { enabled: () => sat === false });
+                dueSteps = dueTrace.steps;
+                if (isUnknown(value))
+                    dueUnknown = value.why;
+                else {
+                    const point = timeOf(value);
+                    if (isUnknown(point))
+                        dueUnknown = point.why;
+                    else
+                        due = point;
+                }
+            }
+            if (due &&
+                decision?.definition.effect === "defer" &&
+                decision.record.deferredUntil &&
+                deadlineOrder(decision.record.deferredUntil, due) > 0)
+                due = decision.record.deferredUntil;
+            status =
+                decision?.definition.effect === "waive"
+                    ? "Waived"
+                    : sat === true
+                        ? "Satisfied"
+                        : sat === "unknown"
+                            ? "Unknown"
+                            : due !== null && isPastDeadline(b.now, due)
+                                ? "Overdue"
+                                : "Open";
+            if (r.remind && due) {
+                const remind = timed(ctx, traced, ["requirement", r.name, "reminder"], `${label}: reminder before due`, (c) => {
+                    const duration = evaluateIn(c, r.remind);
+                    const at = isDuration(duration) ? plus(due, duration, -1) : null;
+                    if (at)
+                        c.temporal?.add(at);
+                    return { at, ready: at !== null && timeOrder(c.b.now, at) >= 0 };
+                }, semanticJson, { enabled: () => status === "Open" || status === "Overdue" });
+                remindAt = remind.at;
+            }
+        }
+        if (decision)
+            for (const record of decision.votes ?? [decision.record])
+                reasons.push({
+                    label: "Decision",
+                    outcome: decision.definition.effect === "reject" ? "failed" : "passed",
+                    detail: `${record.id}: ${decision.definition.effect} by ${record.by}${record.reason === null ? "" : ` (${record.reason})`}`,
+                    at: decision.definition.at,
+                });
+        const renewal = r.renewWithin && applies.truth === true
+            ? timed(ctx, cx, ["requirement", r.name, "renewal"], `${label}: renewal window changes`, (c) => readRenewal(c, r, occurrence))
+            : null;
+        // Open -> Overdue matters even when every action stays eligible and no consumer forecasts it.
+        const deadlineWake = status === "Open" && due ? nextTime(due) : null;
+        if (deadlineWake && timeOrder(deadlineWake, b.now) > 0)
+            cx.reads.add({
+                kind: "time",
+                instance: inst.id,
+                path: ["requirement", r.name, "deadline"],
+                value: { at: deadlineWake, why: `${label}: deadline passes` },
+            });
+        const result = {
+            ...(r.renewWithin ? { renewal } : {}),
+            ...(r.recur ? { recurrence: recurrence.period } : {}),
+            ...(addition
+                ? {
+                    addition: addition.record,
+                    ...(addition.votes ? { additionVotes: addition.votes } : {}),
+                }
+                : {}),
+            ...(decision ? { decision: decision.record } : {}),
+            ...(decision?.votes ? { decisionVotes: decision.votes } : {}),
+            name: r.name,
+            label,
+            occurrence,
+            status,
+            due,
+            dueSteps,
+            dueUnknown,
+            remindAt,
+            reasons,
+            evidence,
+            evidenceType,
+            via,
+            awaits,
+            at: r.at,
+        };
+        partial.set(r.name, result);
+        requirements.push(result);
+    }
+    return requirements;
+};

package/dist/_internal/reconciler/resource-generation.d.ts

@@ -0,0 +1,9 @@
+import type { Basis } from "./basis.js";
+import type { Instance, Program } from "./model.js";
+export declare const resourceProgramDigest: (p: Program) => string;
+export declare const resourceGeneration: (p: Program, b: Basis, inst: Instance) => number;
+export declare const resourceMachineScope: (p: Program, b: Basis, inst: Instance, machine: string) => {
+    account: string;
+    generation: number;
+} | undefined;
+export declare const resourceProofRecords: (p: Program, b: Basis, inst: Instance, resource: string, type: string) => import("./basis.js").EvidenceRecord[];

package/dist/_internal/reconciler/resource-generation.js

@@ -0,0 +1,17 @@
+import { resourceProofRequirement, contentDigest } from "../ir-checks/index.js";
+export const resourceProgramDigest = (p) => contentDigest({ libraries: p.ir.libraries.map((l) => l.digest), account: p.account });
+export const resourceGeneration = (p, b, inst) => {
+    const record = b.lifecycle?.(p.account.name, inst.id);
+    return record ? record.generation + (record.active ? 0 : 1) : 1;
+};
+export const resourceMachineScope = (p, b, inst, machine) => p.components.get(inst.component)?.resources?.some((r) => r.name === machine)
+    ? { account: p.account.name, generation: resourceGeneration(p, b, inst) }
+    : undefined;
+export const resourceProofRecords = (p, b, inst, resource, type) => {
+    const producer = resourceProofRequirement(p.components.get(inst.component), resource, type);
+    return producer
+        ? b
+            .evidence(`${inst.id}/${producer.name}@${resourceGeneration(p, b, inst)}`)
+            .filter((e) => e.type === type)
+        : [];
+};

package/dist/_internal/reconciler/resource-scenarios.d.ts

@@ -0,0 +1,26 @@
+import type * as IR from "../world-ir/types.generated.js";
+import { type World } from "./memory.js";
+import { type WorldReconciliation } from "./reconcile.js";
+/** Finite authored fixture observations; no provider execution or host authority is implied. */
+export declare const scenarioResources: (recon: WorldReconciliation, world: World, date: string) => {
+    program: import("./model.js").Program;
+    home: string;
+    recon: import("./model.js").SubjectReconciliation;
+    projection: {
+        readonly intents: readonly import("./basis.js").ResourceIntent[];
+        readonly views: readonly import("./resources.js").ResourceView[];
+        readonly lifecycleChanges: readonly import("./basis.js").LifecycleRecord[];
+        readonly dependsOn: ReadonlyMap<string, import("./dependencies.js").Dependency>;
+        readonly wakeAt: string | null;
+    };
+}[];
+export declare const observeScenarioLifecycles: (recon: WorldReconciliation, world: World, date: string) => World;
+export declare const scenarioResourceObservation: (recon: WorldReconciliation, world: World, date: string, account: string, id: string, request: Extract<IR.ScenarioCommand, {
+    kind: "resource";
+}>, commandId: string) => {
+    world: World;
+    outcome: {
+        accepted: boolean;
+        codes: readonly string[];
+    };
+};

package/dist/_internal/reconciler/resource-scenarios.js

@@ -0,0 +1,78 @@
+import { basis } from "./memory.js";
+import { reconcileSubject } from "./reconcile.js";
+import { occurrenceHome } from "./homes.js";
+import { resourceProjection } from "./resources.js";
+import { invokeOperation, operationsFor } from "./component-operations.js";
+import { signal } from "./commands.js";
+/** Finite authored fixture observations; no provider execution or host authority is implied. */
+export const scenarioResources = (recon, world, date) => recon.programs.flatMap((p) => {
+    const homes = new Set([
+        ...(world.lifecycles ?? []).filter((r) => r.account === p.account.name).map((r) => r.home),
+        ...(world.resources ?? []).filter((r) => r.account === p.account.name).map((r) => r.home),
+        ...[...recon.instances.values()].flatMap((i) => i.account === p.account.name && p.components.get(i.component)?.resources?.length
+            ? [occurrenceHome(p, i, recon.instances)?.id].filter((h) => !!h)
+            : []),
+    ]), b = basis(world, date);
+    return [...homes].map((home) => {
+        const subject = reconcileSubject(p, b, home);
+        return {
+            program: p,
+            home,
+            recon: subject,
+            projection: resourceProjection(subject, b, { account: p.account.name, home }),
+        };
+    });
+});
+export const observeScenarioLifecycles = (recon, world, date) => {
+    const changes = scenarioResources(recon, world, date).flatMap((s) => s.projection.lifecycleChanges);
+    return changes.length
+        ? { ...world, lifecycles: [...(world.lifecycles ?? []), ...changes] }
+        : world;
+};
+export const scenarioResourceObservation = (recon, world, date, account, id, request, commandId) => {
+    const found = scenarioResources(recon, world, date).find((s) => s.program.account.name === account &&
+        s.projection.intents.some((i) => i.instance === id && i.resource === request.name && i.phase === request.phase)), intent = found?.projection.intents.find((i) => i.instance === id && i.resource === request.name && i.phase === request.phase);
+    if (!found || !intent || (request.phase === "release" && intent.handle !== request.handle))
+        return { world, outcome: { accepted: false, codes: ["resource-stale"] } };
+    if (request.phase === "acquire") {
+        const inst = found.recon.instances.get(id), c = found.program.components.get(inst.component), ops = operationsFor(found.recon, account, { instance: id }).operations, action = c.actions.find((a) => ops.some((o) => o.name === a.name) &&
+            a.via.kind === "connector" &&
+            a.via.connector === intent.connector &&
+            a.via.capability === intent.capability), projected = found.recon.results.get(id).actions.find((a) => a.action === action.name);
+        const admitted = invokeOperation(found.recon, world, date, {
+            id: commandId,
+            account,
+            target: { instance: id },
+            operation: action.name,
+            actor: { id: projected.assigneeId ?? "", kind: "service", groups: [] },
+        });
+        if (!admitted.accepted)
+            return { world: admitted.world, outcome: { accepted: false, codes: admitted.codes } };
+        world = admitted.world;
+    }
+    world = {
+        ...world,
+        resources: [
+            ...(world.resources ?? []),
+            {
+                ...intent,
+                handle: request.handle,
+                state: request.phase === "acquire" ? "acquired" : "released",
+                at: date,
+                by: request.by.k === "entity"
+                    ? request.by.name
+                    : request.by.k === "literal"
+                        ? String(request.by.value)
+                        : "scenario:resource-observation",
+            },
+        ],
+    };
+    if (request.state)
+        world = signal(found.recon, world, date, {
+            instance: id,
+            machine: request.name,
+            state: request.state,
+            by: intent.connector,
+        });
+    return { world, outcome: { accepted: true, codes: [] } };
+};

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

@@ -0,0 +1,24 @@
+import type { Basis, LifecycleRecord, ResourceIntent, ResourceRecord } from "./basis.js";
+import { type Dependency } from "./dependencies.js";
+import type { SubjectReconciliation } from "./model.js";
+export interface ResourceView {
+    readonly instance: string;
+    readonly resource: string;
+    readonly generation: number;
+    readonly state: ResourceRecord["state"] | "waiting" | "unknown";
+    readonly handle?: string;
+    readonly reason: string;
+}
+/** Phase identity includes only pinned protocol metadata, never dynamic business values. */
+export declare const resourceIntentKey: (base: Pick<ResourceIntent, "account" | "home" | "instance" | "resource" | "generation" | "policy" | "programDigest">, phase: ResourceIntent["phase"]) => string;
+/** Passive desired work. Hosts record observations and execute these identities after commit. */
+export declare const resourceProjection: (recon: SubjectReconciliation, snapshot: Basis, scope: {
+    readonly account: string;
+    readonly home: string;
+}) => {
+    readonly intents: readonly ResourceIntent[];
+    readonly views: readonly ResourceView[];
+    readonly lifecycleChanges: readonly LifecycleRecord[];
+    readonly dependsOn: ReadonlyMap<string, Dependency>;
+    readonly wakeAt: string | null;
+};

package/dist/_internal/reconciler/resources.js

@@ -0,0 +1,178 @@
+import { componentOperationNames, contentDigest } from "../ir-checks/index.js";
+import { observeBasis, ReadSet } from "./dependencies.js";
+import { assertSnapshot, evaluateIn, instanceContext, truth } from "./evaluation.js";
+import { occurrenceHome } from "./homes.js";
+import { resourceGeneration, resourceProgramDigest } from "./resource-generation.js";
+import { sha256 } from "./sha256.js";
+import { canonicalJson } from "./result-digest.js";
+const identity = (instance, resource, generation) => JSON.stringify([instance, resource, generation]);
+/** Phase identity includes only pinned protocol metadata, never dynamic business values. */
+export const resourceIntentKey = (base, phase) => sha256(canonicalJson({
+    account: base.account,
+    home: base.home,
+    instance: base.instance,
+    resource: base.resource,
+    generation: base.generation,
+    policy: contentDigest(base.policy),
+    programDigest: base.programDigest,
+    phase,
+}));
+const intent = (base, phase) => ({
+    account: base.account,
+    home: base.home,
+    instance: base.instance,
+    resource: base.resource,
+    generation: base.generation,
+    policy: base.policy,
+    programDigest: base.programDigest,
+    ...(base.handle ? { handle: base.handle } : {}),
+    phase,
+    connector: base.policy[phase].connector,
+    capability: base.policy[phase].capability,
+    key: resourceIntentKey(base, phase),
+});
+/** Passive desired work. Hosts record observations and execute these identities after commit. */
+export const resourceProjection = (recon, snapshot, scope) => {
+    assertSnapshot(snapshot, recon.now);
+    if (recon.home.id !== scope.home || recon.programs.some((p) => p.account.name !== scope.account))
+        throw new Error("Resource projection requires its reconciled home and account.");
+    const reads = new ReadSet();
+    reads.merge(recon.dependsOn);
+    const routing = [
+        ...new Map([...recon.dependsOn.values()].flatMap((d) => d.kind === "matching"
+            ? d.value.map((entity) => [
+                JSON.stringify([entity, d.attribute]),
+                { entity, attribute: d.attribute },
+            ])
+            : [])).values(),
+    ].sort((a, b) => canonicalJson(a) < canonicalJson(b) ? -1 : canonicalJson(a) > canonicalJson(b) ? 1 : 0);
+    const b = observeBasis(snapshot, reads), records = b.resourceRecords?.(scope.account, scope.home) ?? [], lifecycles = b.lifecycleRecords?.(scope.account, scope.home) ?? [], latest = new Map(), instances = new Map([...recon.instances].filter(([, i]) => i.account === scope.account &&
+        occurrenceHome(recon.programs.find((p) => p.account.name === scope.account), i, recon.instances)?.id === scope.home)), unresolved = recon.applicabilityUnknown ||
+        [...instances.values()].some((i) => i.children.some((s) => s.applies === "unknown")), lifecycleChanges = [], intents = [], views = [], visited = new Set();
+    for (const record of records)
+        if (record.account === scope.account && record.home === scope.home)
+            latest.set(identity(record.instance, record.resource, record.generation), record);
+    const stop = (record, unknown) => {
+        const view = {
+            instance: record.instance,
+            resource: record.resource,
+            generation: record.generation,
+            state: unknown && record.state !== "released" ? "unknown" : record.state,
+            ...(record.handle ? { handle: record.handle } : {}),
+            reason: record.state === "released"
+                ? "Cleanup confirmed"
+                : unknown
+                    ? "Applicability is unknown"
+                    : "The acquisition generation requires cleanup",
+        };
+        views.push(view);
+        if (record.state === "released")
+            return;
+        if (!unknown && record.state === "acquiring")
+            intents.push(intent(record, "acquire"));
+        if (!unknown && record.handle && !["uncertain", "timed-out"].includes(record.state))
+            intents.push(intent(record, "release"));
+    };
+    const lifecycle = (instance, generation, active) => {
+        const previous = b.lifecycle?.(scope.account, instance);
+        if (previous && previous.generation > generation)
+            return;
+        const captured = active ? routing : (previous?.routing ?? []);
+        if ((previous?.generation !== generation ||
+            previous.active !== active ||
+            (active && canonicalJson(previous.routing ?? []) !== canonicalJson(captured))) &&
+            !lifecycleChanges.some((r) => r.instance === instance && r.generation === generation && r.active === active))
+            lifecycleChanges.push({
+                ...scope,
+                instance,
+                generation,
+                active,
+                at: b.now,
+                ...(captured.length ? { routing: captured } : {}),
+            });
+    };
+    for (const inst of instances.values()) {
+        const p = recon.programs.find((p) => p.account.name === inst.account), defs = p.components.get(inst.component).resources ?? [];
+        if (!defs.length)
+            continue;
+        const generation = resourceGeneration(p, b, inst), programDigest = resourceProgramDigest(p);
+        lifecycle(inst.id, generation, true);
+        for (const policy of defs) {
+            const id = identity(inst.id, policy.name, generation), current = latest.get(id);
+            visited.add(id);
+            const predecessors = [...latest.values()].filter((r) => r.instance === inst.id && r.resource === policy.name && r.generation < generation);
+            let waiting = false;
+            for (const previous of predecessors) {
+                visited.add(identity(previous.instance, previous.resource, previous.generation));
+                stop(previous, false);
+                if (previous.state !== "released" && !(previous.state === "failed" && !previous.handle))
+                    waiting = true;
+            }
+            const condition = truth(evaluateIn(instanceContext(recon, b, inst, reads), policy.releaseWhen)), pinned = current &&
+                (current.programDigest !== programDigest ||
+                    contentDigest(current.policy) !== contentDigest(policy));
+            if (current && condition === true && !pinned && !unresolved) {
+                stop(current, false);
+                continue;
+            }
+            const action = p.components
+                .get(inst.component)
+                .actions.find((a) => componentOperationNames(p.ir, p.components.get(inst.component)).includes(a.name) &&
+                a.via.kind === "connector" &&
+                a.via.connector === policy.acquire.connector &&
+                a.via.capability === policy.acquire.capability), projected = recon.results.get(inst.id)?.actions.find((a) => a.action === action.name), unknown = condition === "unknown" || !!pinned || !!unresolved;
+            views.push({
+                instance: inst.id,
+                resource: policy.name,
+                generation,
+                state: unknown ? "unknown" : (current?.state ?? "waiting"),
+                ...(current?.handle ? { handle: current.handle } : {}),
+                reason: unknown
+                    ? "The pinned policy or release condition is unknown"
+                    : waiting
+                        ? "A prior generation needs cleanup"
+                        : "Current lifecycle",
+            });
+            if (current?.state === "acquiring" && !waiting && !unknown)
+                intents.push(intent(current, "acquire"));
+            if (current?.state === "releasing" && current.handle && !unknown)
+                intents.push(intent(current, "release"));
+            if (!current &&
+                !waiting &&
+                !unknown &&
+                condition === false &&
+                projected &&
+                ["eligible", "dispatched"].includes(projected.state))
+                intents.push(intent({
+                    ...scope,
+                    instance: inst.id,
+                    resource: policy.name,
+                    generation,
+                    policy,
+                    programDigest,
+                }, "acquire"));
+        }
+    }
+    for (const previous of lifecycles)
+        if (previous.active &&
+            !instances.has(previous.instance) &&
+            !unresolved &&
+            !previous.routing?.some((r) => !b.fact(r.entity, r.attribute)))
+            lifecycle(previous.instance, previous.generation, false);
+    for (const [id, record] of latest)
+        if (!visited.has(id)) {
+            const inst = instances.get(record.instance), previous = b.lifecycle?.(scope.account, record.instance), unknown = !inst &&
+                previous?.active !== false &&
+                (unresolved || !!previous?.routing?.some((r) => !b.fact(r.entity, r.attribute)));
+            stop(record, unknown);
+            if (!inst && !unknown)
+                lifecycle(record.instance, record.generation, false);
+        }
+    return {
+        intents: intents.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0)),
+        views,
+        lifecycleChanges,
+        dependsOn: reads.snapshot(),
+        wakeAt: recon.wakeAt,
+    };
+};