worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/reconciler/collection-values.js

@@ -0,0 +1,60 @@
+import { fileDigest } from "./files.js";
+import { isLocalDate, normalizeInstant, collectionType, } from "../ir-checks/index.js";
+/** Collection writes are scalar facts, validated against the owning entity's type. */
+export const collectionValue = (p, type, value) => {
+    const parse = (descriptor) => {
+        if (!descriptor)
+            return undefined;
+        if (descriptor.kind === "literal")
+            return typeof value === "string" && value.replace(/^:/, "") === descriptor.value
+                ? descriptor.value
+                : undefined;
+        if (descriptor.kind === "union") {
+            for (const member of descriptor.members) {
+                const result = parse(member);
+                if (result !== undefined)
+                    return result;
+            }
+            return undefined;
+        }
+        switch (descriptor.kind) {
+            case "File":
+                return fileDigest(value) ? value : undefined;
+            case "String":
+                return typeof value === "string" && value.trim() !== "" ? value : undefined;
+            case "Keyword":
+                return typeof value === "string" && value.trim() !== ""
+                    ? value.replace(/^:/, "")
+                    : undefined;
+            case "Bool":
+                return typeof value === "boolean"
+                    ? value
+                    : value === "true"
+                        ? true
+                        : value === "false"
+                            ? false
+                            : undefined;
+            case "Int": {
+                const n = typeof value === "number"
+                    ? value
+                    : typeof value === "string" && /^-?\d+$/.test(value)
+                        ? Number(value)
+                        : NaN;
+                return Number.isSafeInteger(n) ? n : undefined;
+            }
+            case "Float": {
+                const n = typeof value === "number"
+                    ? value
+                    : typeof value === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(value)
+                        ? Number(value)
+                        : NaN;
+                return Number.isFinite(n) ? n : undefined;
+            }
+            case "Date":
+                return typeof value === "string" && isLocalDate(value) ? value : undefined;
+            case "Instant":
+                return typeof value === "string" ? (normalizeInstant(value) ?? undefined) : undefined;
+        }
+    };
+    return parse(collectionType(type, p.ir.types));
+};

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

@@ -0,0 +1,35 @@
+import type * as IR from "../world-ir/types.generated.js";
+import type { Basis, Scalar } from "./basis.js";
+import { type World } from "./memory.js";
+import type { TimePoint } from "./instants.js";
+import type { WorldReconciliation } from "./model.js";
+export interface CollectionField {
+    readonly key: string;
+    readonly entity: string;
+    readonly attribute: string;
+    readonly field: string;
+    readonly collection: string | null;
+    readonly type: IR.TypeRef;
+    readonly value: Scalar | null;
+    readonly mode: "ask" | "confirm";
+    readonly consumers: readonly {
+        instance: string;
+        action: string;
+        field: string;
+    }[];
+}
+export interface CollectionTask {
+    readonly key: string;
+    readonly assignee: string;
+    readonly fields: readonly CollectionField[];
+}
+/** Only the supplied eligible work is traversed; this never discovers source subjects. */
+export declare const collectionTasks: (recon: WorldReconciliation, snapshot: Basis) => readonly CollectionTask[];
+export declare const collectFacts: (recon: WorldReconciliation, world: World, at: TimePoint, request: {
+    readonly assignee: string;
+    readonly by: string;
+    readonly values: Readonly<Record<string, Scalar>>;
+    readonly actor?: {
+        readonly kind: "human" | "agent";
+    };
+}) => World;

package/dist/_internal/reconciler/collections.js

@@ -0,0 +1,141 @@
+import { factFileAllowed, fileAllowed } from "./files.js";
+import { occurrenceHome } from "./homes.js";
+import { collectionType } from "../ir-checks/index.js";
+import { command } from "./commands.js";
+import { confirmFacts } from "./collection-state.js";
+import { factKey, collectionRule } from "./collection-rules.js";
+import { collectionValue } from "./collection-values.js";
+import { evaluateFor } from "./evaluation.js";
+import { bindingReadOnly } from "./interaction-fields.js";
+import { log } from "./journal.js";
+import { basis } from "./memory.js";
+import { programFor, admit } from "./reconcile.js";
+/** Only the supplied eligible work is traversed; this never discovers source subjects. */
+export const collectionTasks = (recon, snapshot) => {
+    const groups = new Map();
+    for (const [instance, result] of recon.results) {
+        const p = programFor(recon, instance);
+        for (const action of result.actions) {
+            if ((action.state !== "eligible" && action.state !== "dispatched") ||
+                action.missing.length ||
+                action.assigneeKind !== "entity" ||
+                !action.assigneeId ||
+                !action.interaction ||
+                action.authorityConstraints?.some((c) => c.kind !== "entity" || c.id !== action.assigneeId))
+                continue;
+            const interaction = p.interactions.get(action.interaction);
+            for (const field of action.fields ?? []) {
+                const binding = interaction.binds.find((b) => b.field === field.field), expr = binding?.from ?? binding?.target;
+                if (expr?.k !== "attr")
+                    continue;
+                const rule = collectionRule(p, expr.attr);
+                if (!rule && (field.mode !== "ask" || !binding?.target || bindingReadOnly(p, binding)))
+                    continue;
+                if (rule && !field.collection?.required)
+                    continue;
+                const entity = evaluateFor(recon, snapshot, snapshot.now, instance, expr.of);
+                if (typeof entity !== "string")
+                    continue;
+                const key = factKey(entity, expr.attr), value = snapshot.fact(entity, expr.attr)?.v ?? null;
+                const consumer = { instance, action: action.action, field: field.field };
+                const type = p.entities
+                    .get(expr.attr.slice(0, expr.attr.indexOf("/")))
+                    ?.fields.find((f) => f.attr === expr.attr)?.type ??
+                    p.evidence.get(interaction.produces).fields.find((f) => f.name === field.field).type;
+                if (!collectionType(type, p.ir.types))
+                    continue;
+                let fields = groups.get(action.assigneeId);
+                if (!fields)
+                    groups.set(action.assigneeId, (fields = new Map()));
+                const old = fields.get(key);
+                fields.set(key, old
+                    ? { ...old, consumers: [...old.consumers, consumer] }
+                    : {
+                        key,
+                        entity,
+                        attribute: expr.attr,
+                        field: field.field,
+                        collection: rule?.name ?? null,
+                        type,
+                        value,
+                        mode: value === null ? "ask" : "confirm",
+                        consumers: [consumer],
+                    });
+            }
+        }
+    }
+    return [...groups]
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([assignee, fields]) => ({
+        key: JSON.stringify(["worldvm/collect@1", assignee]),
+        assignee,
+        fields: [...fields.values()]
+            .sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0))
+            .map((field) => ({
+            ...field,
+            consumers: [...field.consumers].sort((a, b) => {
+                const x = JSON.stringify(a), y = JSON.stringify(b);
+                return x < y ? -1 : x > y ? 1 : 0;
+            }),
+        })),
+    }));
+};
+export const collectFacts = (recon, world, at, request) => {
+    if (request.by !== request.assignee || request.actor?.kind === "agent")
+        return world;
+    const snapshot = basis(world, at), task = collectionTasks(recon, snapshot).find((t) => t.assignee === request.assignee);
+    if (!task || !Object.keys(request.values).length)
+        return world;
+    const parsed = [];
+    for (const [key, value] of Object.entries(request.values)) {
+        const field = task.fields.find((f) => f.key === key);
+        if (!field)
+            return world;
+        const p = programFor(recon, field.consumers[0].instance), typed = collectionValue(p, field.type, value);
+        if (typed === undefined || !factFileAllowed(p, snapshot, field.entity, field.attribute, typed))
+            return world;
+        for (const consumer of field.consumers) {
+            const cp = programFor(recon, consumer.instance), inst = recon.instances.get(consumer.instance), action = recon.results.get(inst.id).actions.find((a) => a.action === consumer.action), interaction = cp.interactions.get(action.interaction), contract = cp.evidence
+                .get(interaction.produces)
+                .fields.find((f) => f.name === consumer.field);
+            const home = occurrenceHome(cp, inst, recon.instances)?.id;
+            if (!home || !fileAllowed(cp, snapshot, home, contract, typed))
+                return world;
+        }
+        parsed.push({ entity: field.entity, attribute: field.attribute, value: typed });
+    }
+    const subjects = new Set([request.assignee, ...parsed.map((f) => f.entity)]);
+    const violations = [...subjects].flatMap((subject) => admit(recon, snapshot, at, { kind: "collect", subject }));
+    if (violations.length)
+        return log(world, {
+            at,
+            actor: request.by,
+            title: "Rejected: collect shared facts",
+            context: violations.map((v) => v.reason).join("; "),
+            changes: [],
+        });
+    const writes = parsed
+        .filter((f) => snapshot.fact(f.entity, f.attribute)?.v !== f.value)
+        .map((f) => ({ e: f.entity, a: f.attribute, v: f.value }));
+    const applied = writes.length
+        ? command(recon, world, at, {
+            kind: "collect",
+            subject: request.assignee,
+            title: "Collected shared facts",
+            by: request.by,
+            facts: writes,
+        })
+        : { world, violations: [] };
+    if (applied.violations.length)
+        return applied.world;
+    const confirmed = confirmFacts(applied.world, at, request.by, parsed);
+    return confirmed === applied.world
+        ? confirmed
+        : log(confirmed, {
+            at,
+            actor: request.by,
+            title: "Confirmed shared facts",
+            context: task.key,
+            changes: [],
+        });
+};

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

@@ -0,0 +1,60 @@
+import { type DecisionRequest } from "./decide.js";
+export { log } from "./journal.js";
+import type { LocalDate } from "./dates.js";
+import { type Program, type Violation, type WorldReconciliation } from "./reconcile.js";
+import { type World } from "./memory.js";
+import type { Scalar } from "./basis.js";
+import type * as IR from "../world-ir/types.generated.js";
+/** Shared field and rule checks for signed submissions. */
+export declare const validEvidence: (p: Program, type: string, values: Readonly<Record<string, Scalar>>, now: LocalDate) => boolean;
+export type WorkActor = DecisionRequest["actor"] | {
+    readonly id: string;
+    readonly kind: "service" | "connector";
+    readonly groups: readonly string[];
+};
+export interface Perform {
+    readonly signature?: IR.SignatureInput;
+    readonly instance: string;
+    readonly action: string;
+    readonly by: string;
+    /** A submission without its attestation: recorded, but not proof. */
+    readonly unsigned?: boolean;
+    readonly decision?: "accepted" | "declined";
+    /** Trusted host identity/memberships. Without actor, by is a trusted human ID, not a label. */
+    readonly actor?: WorkActor;
+    /** Public commands defer acknowledgement until their workflow result arrives. */
+    readonly connectorAcknowledgement?: "simulated" | "deferred";
+    readonly id?: string;
+    readonly reason?: Scalar | null;
+    readonly revoke?: string;
+    readonly values?: Readonly<Record<string, Scalar>>;
+}
+/** Perform an eligible action. Ineligible or repeated work leaves the world unchanged. */
+export declare const perform: (recon: WorldReconciliation, world: World, at: LocalDate, request: Perform) => World;
+/** An inbound signal moves a machine only along a declared transition. */
+export declare const signal: (recon: WorldReconciliation, world: World, at: LocalDate, request: {
+    instance: string;
+    machine: string;
+    state: string;
+    by: string;
+}) => World;
+export interface Command {
+    readonly kind: string;
+    readonly subject: string;
+    readonly title: string;
+    readonly by: string;
+    readonly facts: ReadonlyArray<{
+        readonly e: string;
+        readonly a: string;
+        readonly v: Scalar | null;
+    }>;
+}
+/** A command is admitted only if no declared invariant forbids it now. */
+export declare const command: (recon: WorldReconciliation, world: World, at: LocalDate, request: Command) => {
+    world: World;
+    violations: readonly Violation[];
+};
+/** Only this checked path can pass correction metadata into the shared writer. */
+export declare const amendEvidence: (recon: WorldReconciliation, world: World, at: LocalDate, request: Perform & {
+    readonly amend: IR.AmendmentInput;
+}) => World;