worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/reconciler/missing.js

@@ -0,0 +1,79 @@
+import { occurrenceHome } from "./homes.js";
+import { evaluateIn, isInst } from "./evaluation.js";
+// Instances grouped by account and subject home, built once per instance map and rebuilt
+// only when the map grows, so finding producers stays linear in the number of instances.
+const homeIndex = new WeakMap();
+const instancesByHome = (p, instances) => {
+    const cached = homeIndex.get(instances);
+    if (cached && cached.size === instances.size)
+        return cached.byHome;
+    const byHome = new Map();
+    for (const inst of instances.values()) {
+        const home = occurrenceHome(p, inst, instances);
+        if (!home)
+            continue;
+        const key = `${inst.account}\u0000${home.id}`;
+        const list = byHome.get(key);
+        if (list)
+            list.push(inst);
+        else
+            byHome.set(key, [inst]);
+    }
+    homeIndex.set(instances, { size: instances.size, byHome });
+    return byHome;
+};
+export const missingCondition = (cx, text, expr) => {
+    const other = { text, kind: "other" };
+    if (expr.k === "attr" || expr.k === "read")
+        return { text, kind: "fact", fact: expr.meta.path };
+    if (expr.k !== "call")
+        return other;
+    const arg = expr.args[0];
+    if (!arg)
+        return other;
+    if (["known?", "unknown?"].includes(expr.fn) && (arg.k === "attr" || arg.k === "read"))
+        return { text, kind: "fact", fact: arg.meta.path };
+    if (["satisfied?", "applies?", "met?", "not-applicable?"].includes(expr.fn)) {
+        const target = arg.k === "inst" ? evaluateIn(cx, arg.of) : null;
+        const instance = isInst(target) ? target.inst : arg.k === "var" ? cx.inst?.id : undefined;
+        const requirement = arg.k === "inst" ? arg.field : arg.k === "var" ? arg.name : undefined;
+        if (instance && requirement)
+            return { text, kind: "requirement", instance, requirement };
+    }
+    if (["attested", "valid"].includes(expr.fn) && arg.k === "ref" && arg.kind === "evidence") {
+        const produces = (e) => e.k === "list"
+            ? e.items.some(produces)
+            : e.k === "call" &&
+                ((["attested", "valid"].includes(e.fn) &&
+                    e.args[0]?.k === "ref" &&
+                    e.args[0].name === arg.name) ||
+                    (["and", "or", "all?", "any?"].includes(e.fn) && e.args.some(produces)));
+        const home = cx.inst && cx.k ? occurrenceHome(cx.p, cx.inst, cx.k.instances) : null;
+        const instances = !cx.inst
+            ? []
+            : home && cx.k
+                ? (instancesByHome(cx.p, cx.k.instances).get(`${cx.inst.account}\u0000${home.id}`) ?? [])
+                : [cx.inst];
+        const producedBy = instances
+            .flatMap((inst) => (cx.p.components.get(inst.component)?.requirements ?? [])
+            .filter((r) => produces(r.satisfiedBy))
+            .map((r) => ({ requirement: r.name, instance: inst.id })))
+            .sort((a, b) => a.instance.localeCompare(b.instance) || a.requirement.localeCompare(b.requirement));
+        return { text, kind: "evidence", evidence: arg.name, producedBy };
+    }
+    if (["in-state?", "started?", "final?"].includes(expr.fn)) {
+        const value = evaluateIn(cx, arg);
+        if (value && typeof value === "object" && "machine" in value) {
+            const states = expr.args[1] ? evaluateIn(cx, expr.args[1]) : null;
+            return {
+                text,
+                kind: "machine",
+                machine: value.machine,
+                ...(Array.isArray(states) && states.every((s) => typeof s === "string")
+                    ? { states: states }
+                    : {}),
+            };
+        }
+    }
+    return other;
+};

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

@@ -0,0 +1,350 @@
+import type { TimePoint } from "./instants.js";
+import { type Basis, type EvidenceRecord, type Scalar } from "./basis.js";
+import { type Calendar, type LocalDate } from "./dates.js";
+import { ReadSet, type Dependency } from "./dependencies.js";
+import type * as IR from "../world-ir/types.generated.js";
+export type Truth = true | false | "unknown";
+export type Status = "NotApplicable" | "Unknown" | "Open" | "Overdue" | "Satisfied" | "Waived";
+export interface Program {
+    /** Authored IR retained for validated edits; ir below contains account-resolved reads. */
+    readonly sourceIR: IR.WorldIR;
+    readonly ir: IR.WorldIR;
+    readonly account: IR.Account;
+    readonly library: IR.WorldIR["libraries"][number];
+    readonly release: string;
+    readonly components: ReadonlyMap<string, IR.Component>;
+    readonly derives: ReadonlyMap<string, IR.WorldIR["derives"][number]>;
+    readonly evidence: ReadonlyMap<string, IR.Evidence>;
+    readonly interactions: ReadonlyMap<string, IR.Interaction>;
+    readonly machines: ReadonlyMap<string, IR.Machine>;
+    readonly connectors: ReadonlyMap<string, IR.WorldIR["connectors"][number]>;
+    readonly calendars: ReadonlyMap<string, Calendar>;
+    /** Entity declarations by stored namespace, for display and writes. */
+    readonly entities: ReadonlyMap<string, IR.Entity>;
+    /** Role field → the attributes it reads in this account, and whether it can be written. */
+    readonly bindings: ReadonlyMap<string, {
+        readonly attrs: readonly string[];
+        readonly entity: string;
+    }>;
+    readonly params: ReadonlyMap<string, Value>;
+    readonly roots: ReadonlyArray<{
+        readonly component: string;
+        readonly namespaces: readonly string[];
+    }>;
+}
+export declare class Unknown {
+    readonly why: string;
+    constructor(why: string);
+}
+export interface InstRef {
+    readonly inst: string;
+}
+export interface MachineRef {
+    readonly machine: string;
+}
+export interface Duration {
+    readonly n: number;
+    readonly unit: "days" | "months" | "years" | "hours" | "minutes";
+}
+export interface Ref {
+    readonly ref: "evidence" | "calendar" | "decision" | "notice";
+    readonly name: string;
+}
+export interface Closure {
+    readonly params: readonly string[];
+    readonly body: IR.Expr;
+    readonly env: Env;
+}
+export type Value = Scalar | null | Unknown | readonly Value[] | InstRef | MachineRef | Duration | Ref | Closure;
+/** Names an expression can see. Instance scopes resolve lazily; nothing is copied per call. */
+export type StatusReader = (inst: Instance, name: string) => Status;
+export interface Env {
+    readonly get: (name: string, statusRead?: StatusReader, parameter?: (name: string, base: Value | undefined) => Value) => Value | undefined;
+    /** Passive lexical data for verification; never resolves lazy instance names. */
+    readonly snapshot: () => unknown;
+}
+export interface ChildSlot {
+    readonly name: string;
+    readonly component: string;
+    readonly mode: "child" | "attach";
+    readonly applies: Truth;
+    readonly reason: string;
+    readonly instances: string[];
+}
+export interface Instance {
+    readonly params?: ReadonlyMap<string, Value>;
+    readonly id: string;
+    readonly account: string;
+    readonly component: string;
+    readonly key: readonly Value[];
+    readonly inputs: ReadonlyMap<string, Value>;
+    readonly cycle: number;
+    /** The subjects (for-each entities) attached to this occurrence in this cycle. */
+    readonly attached: string[];
+    readonly parents: Set<string>;
+    readonly children: ChildSlot[];
+    readonly prior: string | null;
+}
+/** One step of a derivation, located in the source that computed it. */
+export interface Step {
+    readonly branch?: "true" | "false" | "Unknown";
+    readonly at: IR.Span;
+    readonly value: Value;
+    readonly note?: string;
+}
+export interface ReasonNode {
+    readonly label: string;
+    readonly outcome: "passed" | "failed" | "unknown";
+    readonly detail: string;
+    readonly at?: IR.Span;
+}
+export interface RecurrencePeriod {
+    readonly index: number;
+    readonly start: LocalDate;
+    readonly next: LocalDate | null;
+}
+export interface RenewalResult {
+    readonly evidence: string;
+    readonly expiresAt: LocalDate | null;
+    readonly availableAt: LocalDate | null;
+    readonly state: "waiting" | "ready" | "expired" | "unknown";
+    readonly unknown: string | null;
+}
+export interface RequirementResult {
+    readonly renewal?: RenewalResult | null;
+    readonly recurrence?: RecurrencePeriod | null;
+    readonly addition?: import("./basis.js").DecisionRecord;
+    readonly additionVotes?: readonly import("./basis.js").DecisionRecord[];
+    readonly decision?: import("./basis.js").DecisionRecord;
+    readonly decisionVotes?: readonly import("./basis.js").DecisionRecord[];
+    readonly name: string;
+    readonly label: string;
+    readonly occurrence: string;
+    readonly status: Status;
+    readonly due: TimePoint | null;
+    readonly dueSteps: readonly Step[];
+    readonly dueUnknown: string | null;
+    readonly remindAt: TimePoint | null;
+    readonly reasons: readonly ReasonNode[];
+    readonly evidence: EvidenceRecord | null;
+    readonly evidenceType: string | null;
+    readonly via: string;
+    readonly awaits: string | null;
+    readonly at: IR.Span;
+}
+export interface EscalationIntent {
+    readonly instance: string;
+    readonly requirement: string;
+    readonly occurrence: string;
+    readonly kind: "notify" | "reassign";
+    readonly availableAt: LocalDate;
+    readonly target: {
+        readonly id: string;
+        readonly kind: "entity" | "group";
+    };
+    readonly idempotencyKey: string;
+    readonly at: IR.Span;
+}
+export interface EscalationResult {
+    readonly kind: EscalationIntent["kind"];
+    readonly target: EscalationIntent["target"] | null;
+    readonly requirement: string;
+    readonly step: number;
+    readonly availableAt: LocalDate | null;
+    readonly state: "waiting" | "ready" | "held" | "unknown" | "inactive";
+    readonly unknown: string | null;
+    readonly heldBy: readonly string[];
+    readonly intent: EscalationIntent | null;
+    readonly at: IR.Span;
+}
+export interface HoldResult {
+    readonly name: string;
+    readonly label: string;
+    readonly condition: Truth;
+    readonly unknown: string | null;
+    readonly pauses: IR.Hold["pauses"];
+    readonly cites?: readonly IR.Citation[];
+    readonly at: IR.Span;
+}
+export interface FactCollection {
+    readonly key: string;
+    readonly entity: string;
+    readonly attribute: string;
+    readonly name: string;
+    readonly required: boolean;
+    readonly confirmAt: TimePoint | null;
+    readonly unknown?: string;
+}
+export interface InteractionField {
+    readonly collection?: FactCollection;
+    readonly field: string;
+    readonly mode: "ask" | "confirm" | "read-only";
+    readonly value: Scalar | null;
+    readonly unknown?: string;
+}
+export interface ActionResult {
+    readonly advancesAll?: readonly string[];
+    readonly authorityConstraints?: readonly import("./policies.js").AuthorityConstraint[];
+    readonly fields?: readonly InteractionField[];
+    readonly heldBy?: readonly string[];
+    readonly dispatch?: "auto" | "claim" | "manual";
+    readonly onIneligible?: "withdraw" | "keep" | "review";
+    readonly assigneeId?: string | null;
+    readonly action: string;
+    readonly label: string;
+    readonly advances: string;
+    readonly assignee: string;
+    /** Who the assignee is: a person (an entity), a group, or a connector. */
+    readonly assigneeKind: "entity" | "group" | "connector";
+    readonly via: string;
+    readonly kind: "interaction" | "connector" | "decision";
+    readonly interaction: string | null;
+    readonly idempotencyKey: string;
+    readonly state: "eligible" | "waiting" | "dispatched" | "held";
+    readonly missing: readonly import("./missing.js").Missing[];
+    readonly at: IR.Span;
+}
+export type WorkIntent = {
+    readonly instance: string;
+    readonly action: string;
+    readonly occurrence: string;
+    readonly idempotencyKey: string;
+    readonly at: IR.Span;
+} & ({
+    readonly kind: "open";
+    readonly occurrences?: readonly string[];
+    readonly authorityConstraints?: readonly import("./policies.js").AuthorityConstraint[];
+    readonly dispatch: "auto" | "claim" | "manual";
+    readonly onIneligible: "withdraw" | "keep" | "review";
+    readonly assignee: {
+        readonly id: string;
+        readonly kind: ActionResult["assigneeKind"];
+    };
+} | {
+    readonly kind: "withdraw" | "keep" | "review";
+});
+export interface OutputResult {
+    readonly name: string;
+    readonly label: string;
+    readonly status: Status;
+    readonly expr: string;
+    readonly at: IR.Span;
+}
+export interface MilestoneResult {
+    readonly name: string;
+    readonly label: string;
+    readonly condition: Truth;
+    readonly unknown: string | null;
+    readonly reached: boolean;
+    readonly pending: boolean;
+    readonly record: import("./basis.js").MilestoneRecord | null;
+    readonly finding: "regressed" | null;
+    readonly at: IR.Span;
+}
+export interface Reconciliation {
+    readonly milestones?: readonly MilestoneResult[];
+    readonly escalations?: readonly EscalationResult[];
+    readonly holds?: readonly HoldResult[];
+    /** Pure requested work changes; persisted lifecycle belongs to the host. */
+    readonly workIntents?: readonly WorkIntent[];
+    readonly digest: string;
+    readonly instance: string;
+    readonly component: string;
+    readonly requirements: readonly RequirementResult[];
+    readonly outputs: readonly OutputResult[];
+    readonly actions: readonly ActionResult[];
+    readonly blocked: ReadonlyArray<{
+        readonly requirement: string;
+        readonly reason: string;
+    }>;
+    readonly wakeAt: TimePoint | null;
+    readonly wakeReason: string;
+    /** Evaluation and structural discovery queries with their observed values. */
+    readonly dependsOn: ReadonlyMap<string, Dependency>;
+    readonly retention: {
+        readonly until: LocalDate | null;
+        readonly eligible: boolean | null;
+        readonly steps: readonly Step[];
+        readonly unknown: string | null;
+        readonly disposal: string;
+    } | null;
+}
+export interface WorldReconciliation {
+    readonly applicabilityUnknown?: boolean;
+    readonly releases: readonly string[];
+    readonly now: TimePoint;
+    readonly roots: ReadonlyArray<{
+        readonly subject: string;
+        readonly account: string;
+        readonly instance: string;
+    }>;
+    readonly instances: ReadonlyMap<string, Instance>;
+    readonly results: ReadonlyMap<string, Reconciliation>;
+    readonly blockedTotal: number;
+    readonly programs: readonly Program[];
+}
+export type EvaluationResult = Omit<Reconciliation, "digest" | "dependsOn">;
+export interface Trace {
+    steps: Step[];
+    witness?: {
+        evidence: EvidenceRecord | null;
+        via: string;
+        detail: string;
+        type?: string;
+    };
+    /** Per-item witnesses for lists consumed by all?/any?, including mapped lists. */
+    listWitnesses?: WeakMap<readonly Value[], readonly Trace["witness"][]>;
+    awaits?: string;
+}
+export interface Cx {
+    readonly p: Program;
+    readonly b: Basis;
+    readonly inst: Instance | undefined;
+    readonly env: Env;
+    readonly k?: KernelState;
+    readonly occurrence?: string;
+    readonly proofPeriod?: RecurrencePeriod;
+    readonly trace?: Trace;
+    readonly reads?: ReadSet;
+    readonly temporal?: Set<TimePoint>;
+    readonly statusRead?: StatusReader;
+    readonly policyGuard?: boolean;
+}
+export interface KernelState {
+    uncertainMembership?: boolean;
+    readonly instances: Map<string, Instance>;
+    readonly status: (inst: Instance, requirement: string) => Status;
+}
+export interface ReconcileScope {
+    readonly home: SubjectHome;
+    readonly reads: ReadSet;
+    readonly subjects: (component: string, namespaces: readonly string[]) => readonly string[];
+    readonly complete: (instances: ReadonlyMap<string, Instance>) => boolean;
+    readonly select: (instance: Instance) => boolean;
+}
+export interface SubjectHome {
+    readonly kind: "entity";
+    readonly id: string;
+}
+export interface SubjectReconciliation extends WorldReconciliation {
+    readonly home: SubjectHome;
+    /** Includes indexed discovery observations even when this home has no occurrences. */
+    readonly dependsOn: ReadonlyMap<string, Dependency>;
+    readonly wakeAt: TimePoint | null;
+    readonly wakeReason: string;
+}
+export interface Violation {
+    readonly instance: string;
+    readonly invariant: string;
+    readonly reason: string;
+    readonly at: IR.Span;
+}
+export interface UpgradeConsequence {
+    readonly account: string;
+    readonly occurrence: string;
+    readonly label: string;
+    readonly status: Status;
+    readonly policy: IR.Account["upgrade"];
+    readonly outcome: "keeps" | "replans" | "review" | "next-cycle" | "unchanged";
+    readonly detail: string;
+}

package/dist/_internal/reconciler/model.js

@@ -0,0 +1,9 @@
+import {} from "./basis.js";
+import {} from "./dates.js";
+import { ReadSet } from "./dependencies.js";
+export class Unknown {
+    why;
+    constructor(why) {
+        this.why = why;
+    }
+}

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

@@ -0,0 +1,14 @@
+import type { Basis, NoticeDeliveryRecord, NoticeAcknowledgmentRecord, NoticeIdentity } from "./basis.js";
+import type { Cx, WorldReconciliation } from "./model.js";
+import { type Dependency } from "./dependencies.js";
+export interface NoticeCopy extends NoticeIdentity {
+    readonly delivery: NoticeDeliveryRecord | null;
+    readonly acknowledgment: NoticeAcknowledgmentRecord | null;
+}
+/** Current exact copies and passive proof; delivery and authentication belong to the host. */
+export declare const noticeProjection: (recon: WorldReconciliation, snapshot: Basis) => {
+    readonly copies: readonly NoticeCopy[];
+    readonly dependsOn: ReadonlyMap<string, Dependency>;
+};
+/** The evaluator shares exact-copy validation without recursively reconciling the world. */
+export declare const noticeCopiesFor: (cx: Cx, name?: string) => readonly NoticeCopy[];

package/dist/_internal/reconciler/notices.js

@@ -0,0 +1,80 @@
+import { contentDigest, fileDigest } from "../ir-checks/index.js";
+import { assertSnapshot, evaluateIn, instanceContext } from "./evaluation.js";
+import { documentIntentsFor } from "./documents.js";
+import { observeBasis, programDependency, ReadSet } from "./dependencies.js";
+import { canonicalJson } from "./result-digest.js";
+import { sha256 } from "./sha256.js";
+import { timeOrder } from "./instants.js";
+/** Current exact copies and passive proof; delivery and authentication belong to the host. */
+export const noticeProjection = (recon, snapshot) => {
+    assertSnapshot(snapshot, recon.now);
+    const reads = new ReadSet(), b = observeBasis(snapshot, reads), copies = [];
+    for (const p of recon.programs)
+        reads.add(programDependency(p));
+    for (const inst of recon.instances.values())
+        copies.push(...noticeCopiesFor(instanceContext(recon, b, inst, reads)));
+    return {
+        copies: copies.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0)),
+        dependsOn: reads.snapshot(),
+    };
+};
+/** The evaluator shares exact-copy validation without recursively reconciling the world. */
+export const noticeCopiesFor = (cx, name) => {
+    const b = cx.b, copies = [];
+    for (const intent of documentIntentsFor(cx)) {
+        const inst = cx.inst, declarations = (cx.p.ir.notices ?? []).filter((n) => n.of === inst.component &&
+            n.document === intent.document &&
+            (name === undefined || n.name === name));
+        if (!declarations.length)
+            continue;
+        const document = b.document?.(intent.account, intent.home, intent.key);
+        if (!document ||
+            document.templateDigest !== intent.templateDigest ||
+            document.sourceDigest !== intent.sourceDigest ||
+            document.edition !== intent.edition ||
+            !fileDigest(document.digest) ||
+            canonicalJson(document.evidenceIds) !== canonicalJson(intent.evidence.map((e) => e.id)) ||
+            document.instance !== intent.instance ||
+            document.document !== intent.document ||
+            document.account !== intent.account ||
+            document.home !== intent.home ||
+            document.key !== intent.key)
+            continue;
+        for (const notice of declarations) {
+            const recipient = evaluateIn(cx, notice.to);
+            if (typeof recipient !== "string" || !recipient || !b.nsOf(recipient))
+                continue;
+            const identity = {
+                key: sha256(canonicalJson({
+                    account: intent.account,
+                    home: intent.home,
+                    instance: intent.instance,
+                    notice: contentDigest(notice),
+                    recipient,
+                    documentKey: intent.key,
+                    documentDigest: document.digest,
+                })),
+                account: intent.account,
+                home: intent.home,
+                instance: intent.instance,
+                notice: notice.name,
+                recipient,
+                documentKey: intent.key,
+                documentDigest: document.digest,
+            };
+            const matches = (record) => !!record &&
+                Object.entries(identity).every(([k, v]) => record[k] === v);
+            const delivered = b.noticeDelivery?.(identity.account, identity.home, identity.key), acknowledged = b.noticeAcknowledgment?.(identity.account, identity.home, identity.key), delivery = matches(delivered) && delivered.receipt && timeOrder(document.at, delivered.at) <= 0
+                ? delivered
+                : null, acknowledgment = delivery &&
+                matches(acknowledged) &&
+                acknowledged.by === recipient &&
+                acknowledged.deliveryReceipt === delivery.receipt &&
+                timeOrder(delivery.at, acknowledged.at) <= 0
+                ? acknowledged
+                : null;
+            copies.push({ ...identity, delivery, acknowledgment });
+        }
+    }
+    return copies.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+};

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

@@ -0,0 +1,3 @@
+import { type Instance, type Value, type WorldReconciliation } from "./reconcile.js";
+/** Resolve fully specified keys against a finite reconciled graph, preserving unknown keys. */
+export declare const findOccurrence: (recon: WorldReconciliation, account: string, component: string, key: readonly Value[], cycle?: number, attachedTo?: string) => Instance | undefined;

package/dist/_internal/reconciler/occurrences.js

@@ -0,0 +1,30 @@
+import { Unknown } from "./reconcile.js";
+const equalKey = (a, b) => {
+    if (a instanceof Unknown || b instanceof Unknown)
+        return false;
+    if (a === b)
+        return true;
+    return (!!a &&
+        !!b &&
+        typeof a === "object" &&
+        typeof b === "object" &&
+        "inst" in a &&
+        "inst" in b &&
+        a.inst === b.inst);
+};
+/** Resolve fully specified keys against a finite reconciled graph, preserving unknown keys. */
+export const findOccurrence = (recon, account, component, key, cycle, attachedTo) => {
+    let found;
+    for (const inst of recon.instances.values()) {
+        if (inst.account !== account ||
+            inst.component !== component ||
+            inst.key.length !== key.length ||
+            (cycle !== undefined && inst.cycle !== cycle) ||
+            (attachedTo !== undefined && !inst.attached.includes(attachedTo)) ||
+            !inst.key.every((v, i) => equalKey(v, key[i])))
+            continue;
+        if (!found || inst.cycle > found.cycle)
+            found = inst;
+    }
+    return found;
+};

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

@@ -0,0 +1,12 @@
+import { type EvaluationContext } from "./context.js";
+import { ReadSet } from "./dependencies.js";
+import type * as IR from "../world-ir/types.generated.js";
+import { type Instance, type Status } from "./model.js";
+export declare const allOf: (statuses: readonly Status[]) => Status;
+export declare const anyOf: (statuses: readonly Status[]) => Status;
+export declare const outputTexts: WeakMap<IR.Output, string>;
+export declare const outputText: (o: IR.Output) => string;
+export declare function requirementStatus(ctx: EvaluationContext, inst: Instance, name: string): Status;
+export declare function statusAt(ctx: EvaluationContext, owner: Instance, segments: readonly string[], focus: string | undefined, reads: ReadSet): Status;
+export declare function outputStatus(ctx: EvaluationContext, inst: Instance, output: IR.Output): Status;
+export declare const readStatus: (ctx: EvaluationContext, inst: Instance, name: string) => Status;