worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/reconciler/escalations.js

@@ -0,0 +1,76 @@
+import { shiftTime, timeOrder } from "./instants.js";
+import { evaluateIn, isUnknown } from "./evaluation.js";
+import { activeHolds } from "./holds.js";
+import { timed } from "./scheduling.js";
+const threshold = (due, days) => {
+    if (!due)
+        return null;
+    try {
+        const date = shiftTime(due, days, "days");
+        return date;
+    }
+    catch {
+        return null;
+    }
+};
+export const evaluateEscalations = (ctx, inst, cx, component, requirements, holds) => {
+    const heldBy = activeHolds(holds, "escalate").map((h) => h.name);
+    return component.requirements.flatMap((definition) => {
+        const requirement = requirements.find((r) => r.name === definition.name);
+        return (definition.escalate ?? []).map((step, index) => {
+            const availableAt = threshold(requirement.due, step.afterDays);
+            // Requirement/date/hold changes already have their own conservative wakeups.
+            return timed(ctx, cx, ["requirement", definition.name, "escalation", String(index)], `${requirement.label}: escalation ${index + 1}`, (c) => {
+                const result = {
+                    kind: step.kind,
+                    target: null,
+                    requirement: definition.name,
+                    step: index,
+                    availableAt,
+                    state: "inactive",
+                    unknown: null,
+                    heldBy,
+                    intent: null,
+                    at: step.at,
+                };
+                const unknown = (why) => ({
+                    ...result,
+                    state: "unknown",
+                    unknown: why,
+                });
+                if (requirement.status === "NotApplicable" ||
+                    requirement.status === "Satisfied" ||
+                    requirement.status === "Waived")
+                    return result;
+                if (requirement.status === "Unknown")
+                    return unknown("Requirement status is Unknown");
+                if (!availableAt)
+                    return unknown(requirement.dueUnknown ??
+                        "Escalation date is missing or outside the supported calendar");
+                c.temporal?.add(availableAt);
+                const who = evaluateIn(c, step.who);
+                if (isUnknown(who) || typeof who !== "string" || !who.length || !step.whoKind)
+                    return unknown(isUnknown(who) ? who.why : "Escalation target is Unknown");
+                const resolved = { ...result, target: { id: who, kind: step.whoKind } };
+                if (timeOrder(c.b.now, availableAt) < 0)
+                    return { ...resolved, state: "waiting" };
+                if (heldBy.length)
+                    return { ...resolved, state: "held" };
+                return {
+                    ...resolved,
+                    state: "ready",
+                    intent: {
+                        instance: inst.id,
+                        requirement: definition.name,
+                        occurrence: requirement.occurrence,
+                        kind: step.kind,
+                        availableAt,
+                        target: resolved.target,
+                        idempotencyKey: `escalation:${JSON.stringify([requirement.occurrence, index, step.kind, availableAt, step.whoKind, who])}`,
+                        at: step.at,
+                    },
+                };
+            });
+        });
+    });
+};

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

@@ -0,0 +1,56 @@
+import type { EvidenceRecord } from "./basis.js";
+import { type Basis } from "./basis.js";
+import { type LocalDate } from "./dates.js";
+export { selectedDecision, selectedAddition, legacyAcceptance } from "./decision-evaluation.js";
+import { ReadSet } from "./dependencies.js";
+import type * as IR from "../world-ir/types.generated.js";
+import { Unknown, type Cx, type Duration, type Env, type Instance, type InstRef, type Program, type Status, type Truth, type Value, type WorldReconciliation } from "./model.js";
+export declare const assertSnapshot: (b: Basis, now: LocalDate) => void;
+export declare const emptyEnv: Env;
+export declare const vars: (entries: Iterable<readonly [string, Value]>, parent?: Env) => Env;
+export declare const componentNames: WeakMap<IR.Component, {
+    params: Set<string>;
+    machines: Set<string>;
+    requirements: Set<string>;
+}>;
+/** An instance's names: its inputs, its component's params, self, attached, machines and
+ * requirements (whose statuses come from `status`). */
+export declare const instanceEnv: (p: Program, inst: Instance, status: (name: string) => Status, reads?: ReadSet) => Env;
+export declare const isUnknown: (v: Value) => v is Unknown;
+export declare const isInst: (v: Value) => v is InstRef;
+export declare const isDuration: (v: Value) => v is Duration;
+export declare const truth: (v: Value) => Truth;
+export declare const kleene: (t: Truth) => Value;
+export declare const and: (ts: readonly Truth[]) => Truth;
+export declare const or: (ts: readonly Truth[]) => Truth;
+export declare const plus: (date: LocalDate, d: Duration, sign?: number) => string;
+/** Evaluate an expression that reads no facts (account parameters). */
+export declare const constant: (p: Program, e: IR.Expr) => Value;
+export declare const keyText: (v: Value) => string;
+export declare const instanceId: (component: string, key: readonly Value[], cycle: number) => string;
+export declare const lookup: (cx: Cx, name: string) => Value;
+export declare const describe: (v: Value) => string;
+export declare const describeValue: (v: Value) => string;
+export declare const evaluateIn: (cx: Cx, e: IR.Expr) => Value;
+export declare const apply: (cx: Cx, fn: Value, args: readonly Value[]) => Value;
+export declare const timeOf: (v: Value) => LocalDate | Unknown;
+export declare const dateOf: (v: Value) => LocalDate | Unknown;
+export declare const call: (cx: Cx, e: Extract<IR.Expr, {
+    k: "call";
+}>) => Value;
+/** Attested evidence of a type: for the requirement being evaluated, or anywhere in the instance. */
+export declare const attested: (cx: Cx, type: string, pinned?: readonly EvidenceRecord[]) => Value;
+export declare const machineProtocol: (p: Program, component: string, machine: string) => IR.Machine | undefined;
+/** A machine's current state: the last accepted signal, or null before it starts. */
+export declare const machineState: (b: Basis, instance: string, machine: string, scope?: {
+    readonly account: string;
+    readonly generation: number;
+}) => string | null;
+/** May a signal move this machine to `state`? Only along declared transitions. */
+export declare const canTransition: (p: Program, b: Basis, instance: Instance, machine: string, state: string) => boolean;
+/** The evaluation context of one reconciled instance, for writes outside reconcile. */
+export declare const instanceContext: (recon: WorldReconciliation, b: Basis, inst: Instance, reads?: ReadSet) => Cx;
+/** Evaluate an expression in a reconciled instance's scope. */
+export declare const evaluateFor: (recon: WorldReconciliation, b: Basis, now: LocalDate, instance: string, e: IR.Expr, occurrence?: string) => Value;
+/** Evaluate an expression over plain values (a draft's fields), with no facts. */
+export declare const evaluateValues: (p: Program, values: Readonly<Record<string, Value>>, now: LocalDate, e: IR.Expr) => Value;