worldvm 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,253 @@
+import type { SignatureTrail } from "./signatures.js";
+import type { TimePoint } from "./instants.js";
+import type * as IR from "../world-ir/types.generated.js";
+export interface LifecycleRecord {
+    readonly routing?: readonly {
+        readonly entity: string;
+        readonly attribute: string;
+    }[];
+    readonly account: string;
+    readonly home: string;
+    readonly instance: string;
+    readonly generation: number;
+    readonly active: boolean;
+    readonly at: TimePoint;
+}
+export interface ResourceIntent {
+    readonly account: string;
+    readonly home: string;
+    readonly instance: string;
+    readonly resource: string;
+    readonly generation: number;
+    readonly policy: IR.Resource;
+    readonly programDigest: string;
+    readonly phase: "acquire" | "release";
+    readonly key: string;
+    readonly connector: string;
+    readonly capability: string;
+    readonly handle?: string;
+}
+export interface ResourceRecord extends ResourceIntent {
+    readonly observation?: {
+        readonly revision: number;
+        readonly state: string;
+    };
+    readonly commandId?: string;
+    readonly state: "acquiring" | "acquired" | "releasing" | "released" | "failed" | "uncertain" | "timed-out";
+    readonly by: string;
+    readonly at: TimePoint;
+    readonly code?: string;
+}
+export type Scalar = string | number | boolean;
+/** An attribute assertion with valid time. A null value retracts the attribute. */
+export interface Fact {
+    readonly command?: string;
+    readonly e: string;
+    readonly a: string;
+    readonly v: Scalar | null;
+    readonly at: TimePoint;
+    readonly by: string;
+}
+/** A host-attested upload target; this provenance grants no byte access. */
+export type FileProducer = {
+    readonly actor: {
+        readonly id: string;
+        readonly kind: "human" | "agent" | "service";
+    };
+} & ({
+    readonly kind: "evidence";
+    readonly evidence: string;
+    readonly field: string;
+    readonly instance: string;
+} | {
+    readonly kind: "document";
+    readonly key: string;
+    readonly sourceIds: readonly string[];
+});
+/** Trusted scanner metadata; bytes are held outside the reconciliation world. */
+export interface FileRecord {
+    readonly account: string;
+    readonly home: string;
+    readonly digest: string;
+    readonly mediaType: string;
+    readonly size: number;
+    readonly scan: "pending" | "clean" | "rejected";
+    readonly redacted: boolean;
+    readonly at: TimePoint;
+    readonly by: string;
+    readonly producer?: FileProducer;
+}
+/** A generated artifact retains the exact template and immutable source signatures. */
+export interface DocumentRecord {
+    readonly key: string;
+    readonly account: string;
+    readonly home: string;
+    readonly instance: string;
+    readonly document: string;
+    readonly edition: string;
+    readonly templateDigest: string;
+    readonly sourceDigest: string;
+    readonly evidenceIds: readonly string[];
+    readonly digest: string;
+    readonly renderer: string;
+    readonly at: TimePoint;
+    readonly by: string;
+}
+/** Identity shared by immutable delivery and the human's separate acknowledgment. */
+export interface NoticeIdentity {
+    readonly key: string;
+    readonly account: string;
+    readonly home: string;
+    readonly instance: string;
+    readonly notice: string;
+    readonly recipient: string;
+    readonly documentKey: string;
+    readonly documentDigest: string;
+}
+export interface NoticeDeliveryRecord extends NoticeIdentity {
+    readonly receipt: string;
+    readonly at: TimePoint;
+    readonly by: string;
+}
+export interface NoticeAcknowledgmentRecord extends NoticeIdentity {
+    readonly deliveryReceipt: string;
+    readonly at: TimePoint;
+    readonly by: string;
+}
+export interface EvidenceRecord {
+    readonly amendment?: {
+        readonly previous: string;
+        readonly reason: string;
+        readonly previousDigest: string;
+    };
+    readonly signature?: SignatureTrail;
+    readonly reuseScopes?: readonly string[];
+    readonly occurrences?: readonly string[];
+    readonly workKey?: string;
+    readonly interaction?: string;
+    readonly id: string;
+    readonly type: string;
+    readonly occurrence: string;
+    readonly status: "submitted" | "attested" | "superseded";
+    readonly at: TimePoint;
+    readonly by: string;
+    readonly values: Readonly<Record<string, string>>;
+}
+/** First observed reach; a host adds durable journal positions when it persists this record. */
+export interface MilestoneRecord {
+    readonly instance: string;
+    readonly milestone: string;
+    readonly at: TimePoint;
+    readonly release: string;
+    readonly basis: {
+        readonly at: TimePoint;
+        readonly digest: string;
+    };
+}
+/** A human grant or revocation. Timing is captured at admission, never recomputed. */
+export interface DecisionRecord {
+    readonly id: string;
+    readonly instance: string;
+    readonly decision: string;
+    readonly requirement: string;
+    readonly effect: "approve" | "reject" | "waive" | "defer" | "accept" | "add";
+    readonly kind: "grant" | "revoke";
+    readonly at: TimePoint;
+    readonly by: string;
+    readonly reason: Scalar | null;
+    readonly release: string;
+    readonly commandDigest: string;
+    readonly authority?: {
+        readonly kind: "individual" | "group";
+        readonly principal: string;
+    };
+    readonly approvals?: number;
+    readonly distinctFrom?: readonly string[];
+    readonly revokes?: string;
+    readonly expiresAt?: TimePoint;
+    readonly deferredUntil?: TimePoint;
+    readonly from?: string;
+    readonly evidence?: string;
+}
+/** A recorded decision to accept (or decline) a prior cycle's evidence for a requirement. */
+export interface AcceptanceRecord {
+    readonly instance: string;
+    readonly requirement: string;
+    readonly from: string;
+    readonly decision: "accepted" | "declined";
+    readonly by: string;
+    readonly at: TimePoint;
+}
+/** An inbound signal that moved a machine to a state. */
+export interface SignalRecord {
+    readonly generation?: number;
+    readonly account?: string;
+    readonly instance: string;
+    readonly machine: string;
+    readonly state: string;
+    readonly at: TimePoint;
+    readonly by: string;
+}
+export interface DispatchRecord {
+    readonly key: string;
+    readonly action: string;
+    readonly occurrence: string;
+    readonly assignee: string;
+    readonly at: TimePoint;
+}
+export interface JournalEntry {
+    readonly id: string;
+    readonly at: TimePoint;
+    readonly actor: string;
+    readonly title: string;
+    readonly context: string;
+    readonly changes: ReadonlyArray<{
+        label: string;
+        before: string;
+        after: string;
+    }>;
+}
+/** A human's confirmation is separate from the original assertion and signed documents. */
+export interface ConfirmationRecord {
+    readonly entity: string;
+    readonly attribute: string;
+    readonly value: Scalar;
+    readonly at: TimePoint;
+    readonly by: string;
+}
+/** Historical metadata only; never evidence that satisfies a current requirement. */
+export interface RedactionObservation {
+    readonly entity: string;
+    readonly attribute?: string;
+    readonly at: TimePoint;
+    readonly by?: string;
+    readonly attestation?: Pick<EvidenceRecord, "id" | "type" | "occurrence" | "status">;
+}
+/** Facts visible at `now`: the reconciliation basis. Later records do not exist yet. */
+export interface Basis {
+    readonly redactions?: (entity: string) => readonly RedactionObservation[];
+    readonly lifecycleRecords?: (account: string, home: string) => readonly LifecycleRecord[];
+    readonly lifecycle?: (account: string, instance: string) => LifecycleRecord | undefined;
+    readonly resourceRecords?: (account: string, home: string) => readonly ResourceRecord[];
+    readonly now: TimePoint;
+    readonly document?: (account: string, home: string, key: string) => DocumentRecord | undefined;
+    readonly noticeDelivery?: (account: string, home: string, key: string) => NoticeDeliveryRecord | undefined;
+    readonly noticeAcknowledgment?: (account: string, home: string, key: string) => NoticeAcknowledgmentRecord | undefined;
+    readonly file?: (account: string, home: string, digest: string) => FileRecord | undefined;
+    readonly fact: (e: string, a: string) => Fact | undefined;
+    readonly confirmation?: (e: string, a: string) => ConfirmationRecord | undefined;
+    readonly entities: (ns?: string) => readonly string[];
+    /** Entities with this current attribute value, in lexical id order. */
+    readonly matching: (a: string, v: Scalar) => readonly string[];
+    readonly nsOf: (e: string) => string | undefined;
+    readonly evidence: (occurrence: string) => readonly EvidenceRecord[];
+    /** Evidence recorded for any occurrence of an instance. */
+    readonly evidenceIn?: (scope: string) => readonly EvidenceRecord[];
+    readonly evidenceOf: (instance: string) => readonly EvidenceRecord[];
+    readonly milestone?: (instance: string, name: string) => MilestoneRecord | undefined;
+    readonly decisions?: (instance: string) => readonly DecisionRecord[];
+    readonly acceptance: (instance: string, requirement: string) => AcceptanceRecord | undefined;
+    readonly history: (instance: string, machine: string) => readonly SignalRecord[];
+    readonly dispatched: (key: string) => DispatchRecord | undefined;
+}
+export declare const emptyBasis: (now: TimePoint) => Basis;

package/dist/_internal/reconciler/basis.js

@@ -0,0 +1,16 @@
+export const emptyBasis = (now) => ({
+    now,
+    fact: () => undefined,
+    confirmation: () => undefined,
+    entities: () => [],
+    matching: () => [],
+    nsOf: () => undefined,
+    evidence: () => [],
+    evidenceOf: () => [],
+    evidenceIn: () => [],
+    milestone: () => undefined,
+    decisions: () => [],
+    acceptance: () => undefined,
+    history: () => [],
+    dispatched: () => undefined,
+});

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

@@ -0,0 +1,22 @@
+import type { Basis } from "./basis.js";
+import type { ActionResult, WorldReconciliation } from "./model.js";
+import { type ProjectedWork } from "./work.js";
+export interface BundleItem {
+    readonly work: ProjectedWork;
+    readonly instance: string;
+    readonly action: ActionResult;
+    readonly due: string | null;
+    readonly prerequisites: readonly string[];
+}
+export interface BundleSession {
+    readonly name: string;
+    readonly label: string;
+    readonly actor: string;
+    readonly cyclic: boolean;
+    readonly items: readonly BundleItem[];
+}
+/** A view over the supplied graph, not a new work/eligibility/signature state machine. */
+export declare const bundleFor: (recon: WorldReconciliation, b: Basis, account: string, name: string, actor: {
+    readonly id: string;
+    readonly groups: readonly string[];
+}) => BundleSession | null;

package/dist/_internal/reconciler/bundles.js

@@ -0,0 +1,110 @@
+import { permitsConstraints } from "./policies.js";
+import { deadlineOrder } from "./instants.js";
+import { workItems, actionTargets } from "./work.js";
+/** A view over the supplied graph, not a new work/eligibility/signature state machine. */
+export const bundleFor = (recon, b, account, name, actor) => {
+    const p = recon.programs.find((p) => p.account.name === account), definition = p?.ir.bundles?.find((d) => d.name === name);
+    const ns = b.nsOf(actor.id), entity = ns ? p?.entities.get(ns) : undefined;
+    if (!p || !definition || !entity?.implements.some((i) => i.role === definition.role))
+        return null;
+    const items = [];
+    for (const work of workItems(recon)) {
+        if (work.account !== account ||
+            !(work.assignee.kind === "entity"
+                ? work.assignee.id === actor.id
+                : work.assignee.kind === "group" &&
+                    work.assignee.id !== null &&
+                    actor.groups.includes(work.assignee.id)))
+            continue;
+        const member = work.members[0], result = recon.results.get(member.instance), action = result.actions.find((a) => a.action === member.action);
+        if (!permitsConstraints(action.authorityConstraints ?? [], actor))
+            continue;
+        const dates = work.members
+            .flatMap((m) => {
+            const value = recon.results.get(m.instance), a = value.actions.find((a) => a.action === m.action);
+            return value.requirements
+                .filter((r) => actionTargets(a).includes(r.name) && r.due !== null)
+                .map((r) => r.due);
+        })
+            .sort(deadlineOrder);
+        items.push({
+            work,
+            instance: member.instance,
+            action,
+            due: dates[0] ?? null,
+            prerequisites: [],
+        });
+    }
+    const projected = items.map((item) => {
+        const prerequisites = new Set();
+        const add = (other) => {
+            if (other.work.key !== item.work.key)
+                prerequisites.add(other.work.key);
+        };
+        for (const member of item.work.members) {
+            const instance = recon.instances.get(member.instance), component = p.components.get(instance.component);
+            const action = component.actions.find((a) => a.name === member.action);
+            const visit = (e) => {
+                if (e.k === "ref" && e.kind === "evidence")
+                    for (const other of items) {
+                        const interaction = other.action.interaction
+                            ? p.interactions.get(other.action.interaction)
+                            : undefined;
+                        if (other.instance === member.instance && interaction?.produces === e.name)
+                            add(other);
+                    }
+                if (e.k === "var" && component.requirements.some((r) => r.name === e.name))
+                    for (const other of items)
+                        if (other.work.members.some((m) => m.instance === member.instance &&
+                            recon.results
+                                .get(m.instance)
+                                .actions.some((a) => a.action === m.action && actionTargets(a).includes(e.name))))
+                            add(other);
+                // Opaque reads/derives may hide producers. Over-order supplied work instead of discovering entities.
+                if (e.k === "inst" ||
+                    e.k === "read" ||
+                    e.k === "attr" ||
+                    (e.k === "call" && p.derives.has(e.fn)) ||
+                    (e.k === "ref" && e.kind === "decision"))
+                    items.forEach(add);
+                if (e.k === "call")
+                    e.args.forEach(visit);
+                if (e.k === "list")
+                    e.items.forEach(visit);
+                if (e.k === "fn")
+                    visit(e.body);
+                if (e.k === "if")
+                    [e.test, e.then, e.else].forEach(visit);
+                if (e.k === "read" || e.k === "attr" || e.k === "inst")
+                    visit(e.of);
+            };
+            action?.needs?.forEach((need) => visit(need.expr));
+        }
+        return { ...item, prerequisites: [...prerequisites].sort() };
+    });
+    const order = (a, b) => a.due && b.due
+        ? deadlineOrder(a.due, b.due) ||
+            (a.work.key < b.work.key ? -1 : a.work.key > b.work.key ? 1 : 0)
+        : a.due
+            ? -1
+            : b.due
+                ? 1
+                : a.work.key < b.work.key
+                    ? -1
+                    : a.work.key > b.work.key
+                        ? 1
+                        : 0;
+    const remaining = new Map(projected.map((i) => [i.work.key, i])), ordered = [];
+    while (remaining.size) {
+        const ready = [...remaining.values()]
+            .filter((i) => i.prerequisites.every((key) => !remaining.has(key)))
+            .sort(order)[0];
+        if (!ready)
+            break;
+        ordered.push(ready);
+        remaining.delete(ready.work.key);
+    }
+    const cyclic = remaining.size > 0;
+    ordered.push(...[...remaining.values()].sort(order));
+    return { name, label: definition.label, actor: actor.id, cyclic, items: ordered };
+};

package/dist/_internal/reconciler/change-detection.d.ts

@@ -0,0 +1,5 @@
+import type { Basis } from "./basis.js";
+import type { Program, SubjectReconciliation } from "./reconcile.js";
+/** Replay a complete subject read set on an immutable snapshot. True permits extra work;
+ * false permits reuse only at the same date under the same linked program semantics. */
+export declare const subjectChanged: (previous: SubjectReconciliation, program: Program, next: Basis) => boolean;

package/dist/_internal/reconciler/change-detection.js

@@ -0,0 +1,82 @@
+import { isLocalDependency } from "./dependencies.js";
+import { canonicalJson } from "./result-digest.js";
+const programText = (p) => canonicalJson({ ir: p.ir, account: p.account, library: p.library, release: p.release });
+const observed = (d, b) => {
+    switch (d.kind) {
+        case "lifecycle":
+            return b.lifecycle?.(d.account, d.instance) ?? null;
+        case "lifecycles":
+            return b.lifecycleRecords?.(d.account, d.home) ?? [];
+        case "resources":
+            return b.resourceRecords?.(d.account, d.home) ?? [];
+        case "document":
+            return b.document?.(d.account, d.home, d.key) ?? null;
+        case "notice-delivery":
+            return b.noticeDelivery?.(d.account, d.home, d.key) ?? null;
+        case "notice-acknowledgment":
+            return b.noticeAcknowledgment?.(d.account, d.home, d.key) ?? null;
+        case "file":
+            return b.file?.(d.account, d.home, d.digest) ?? null;
+        case "scoped-evidence":
+            return b.evidenceIn?.(d.scope) ?? [];
+        case "milestone":
+            return b.milestone?.(d.instance, d.name) ?? null;
+        case "confirmation":
+            return b.confirmation?.(d.entity, d.attribute) ?? null;
+        case "fact":
+            return b.fact(d.entity, d.attribute) ?? null;
+        case "entities":
+            return [...b.entities(d.namespace ?? undefined)].sort();
+        case "matching":
+            return [...b.matching(d.attribute, d.where)].sort();
+        case "namespace":
+            return b.nsOf(d.entity) ?? null;
+        case "evidence":
+            return b.evidence(d.occurrence);
+        case "decisions":
+            return b.decisions?.(d.instance) ?? [];
+        case "instance-evidence":
+            return b.evidenceOf(d.instance);
+        case "acceptance":
+            return b.acceptance(d.instance, d.requirement) ?? null;
+        case "signals":
+            return b.history(d.instance, d.machine);
+        case "dispatch":
+            return b.dispatched(d.key) ?? null;
+        case "clock":
+            return b.now;
+        // These projections are pure functions of the IR, clock and recorded Basis queries.
+        case "program":
+        case "input":
+        case "members":
+        case "status":
+        case "slot":
+        case "time":
+            return d.value;
+    }
+};
+/** Replay a complete subject read set on an immutable snapshot. True permits extra work;
+ * false permits reuse only at the same date under the same linked program semantics. */
+export const subjectChanged = (previous, program, next) => {
+    if (previous.now !== next.now)
+        return true;
+    const before = previous.programs[0];
+    if (previous.programs.length !== 1 ||
+        !before ||
+        (before !== program && programText(before) !== programText(program)))
+        return true;
+    for (const d of previous.dependsOn.values()) {
+        // A remote projection can change without any of this home's Basis queries changing.
+        // Until output revisions can be replayed, never skip a remote graph projection.
+        // Timer observations are forecasts over the recorded queries and the checked date.
+        if (d.kind !== "time" &&
+            isLocalDependency(d) &&
+            "instance" in d &&
+            !previous.instances.has(d.instance))
+            return true;
+        const value = observed(d, next);
+        if (value !== d.value && canonicalJson(value) !== canonicalJson(d.value))
+            return true;
+    }
+    return false;
+};

package/dist/_internal/reconciler/collection-rules.d.ts

@@ -0,0 +1,7 @@
+import type * as IR from "../world-ir/types.generated.js";
+import type { Basis } from "./basis.js";
+import { type TimePoint } from "./instants.js";
+import type { FactCollection, Program } from "./model.js";
+export declare const factKey: (entity: string, attribute: string) => string;
+export declare const collectionRule: (p: Program, attribute: string) => IR.Collect | undefined;
+export declare const collectionState: (p: Program, b: Basis, entity: string, attribute: string, temporal?: Set<TimePoint>) => FactCollection | undefined;

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

@@ -0,0 +1,46 @@
+import { plus } from "./evaluation.js";
+import { timeOrder } from "./instants.js";
+export const factKey = (entity, attribute) => JSON.stringify([entity, attribute]);
+const rulesFor = (p, attribute) => (p.ir.collects ?? []).filter((c) => c.facts.some((field) => {
+    const attrs = p.bindings.get(`${c.from}.${field}`)?.attrs;
+    return attrs?.length === 1 && attrs[0] === attribute;
+}));
+export const collectionRule = (p, attribute) => rulesFor(p, attribute)[0];
+export const collectionState = (p, b, entity, attribute, temporal) => {
+    const rules = rulesFor(p, attribute), rule = rules[0];
+    if (!rule)
+        return undefined;
+    const fact = b.fact(entity, attribute);
+    let confirmAt = null, unknown;
+    if (fact) {
+        const receipt = rules.some((r) => r.confirmAfter)
+            ? b.confirmation?.(entity, attribute)
+            : undefined;
+        const last = receipt?.value === fact.v && timeOrder(receipt.at, fact.at) >= 0 ? receipt.at : fact.at;
+        for (const current of rules) {
+            if (!current.confirmAfter)
+                continue;
+            try {
+                const cutoff = plus(last, current.confirmAfter);
+                if (!confirmAt || timeOrder(cutoff, confirmAt) < 0)
+                    confirmAt = cutoff;
+            }
+            catch (error) {
+                if (!(error instanceof RangeError))
+                    throw error;
+                unknown = "The confirmation date is outside the supported calendar.";
+            }
+        }
+        if (confirmAt && timeOrder(confirmAt, b.now) > 0)
+            temporal?.add(confirmAt);
+    }
+    return {
+        key: factKey(entity, attribute),
+        entity,
+        attribute,
+        name: rule.name,
+        required: !fact || (!!confirmAt && timeOrder(b.now, confirmAt) >= 0),
+        confirmAt,
+        ...(unknown ? { unknown } : {}),
+    };
+};

package/dist/_internal/reconciler/collection-state.d.ts

@@ -0,0 +1,11 @@
+import type { Scalar } from "./basis.js";
+import { type World } from "./memory.js";
+import { type TimePoint } from "./instants.js";
+import type { WorldReconciliation } from "./model.js";
+export declare const confirmFacts: (world: World, at: TimePoint, by: string, facts: readonly {
+    entity: string;
+    attribute: string;
+    value: Scalar;
+}[]) => World;
+/** Refresh only provided active drafts; signed evidence is never a correction target. */
+export declare const refreshDrafts: (recon: WorldReconciliation, world: World, at: TimePoint, changed: ReadonlySet<string>) => World;

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

@@ -0,0 +1,62 @@
+import { basis } from "./memory.js";
+import { evaluateFor } from "./evaluation.js";
+import { programFor } from "./reconcile.js";
+import { factKey } from "./collection-rules.js";
+import { timeOrder } from "./instants.js";
+export const confirmFacts = (world, at, by, facts) => {
+    const current = basis(world, at);
+    const records = facts
+        .filter((f) => {
+        const old = current.confirmation?.(f.entity, f.attribute);
+        return old?.value !== f.value || old.at !== at || old.by !== by;
+    })
+        .map((f) => ({ ...f, at, by }));
+    return records.length
+        ? { ...world, confirmations: [...(world.confirmations ?? []), ...records] }
+        : world;
+};
+/** Refresh only provided active drafts; signed evidence is never a correction target. */
+export const refreshDrafts = (recon, world, at, changed) => {
+    if (!changed.size)
+        return world;
+    const snapshot = basis(world, at);
+    let modified = false;
+    const evidence = world.evidence.map((record) => {
+        if (record.status !== "submitted" || timeOrder(record.at, at) > 0)
+            return record;
+        const instance = record.occurrence.slice(0, record.occurrence.lastIndexOf("/")), p = programFor(recon, instance);
+        if (!p)
+            return record;
+        const candidates = [...p.interactions.values()].filter((i) => i.produces === record.type);
+        const interaction = record.interaction
+            ? p.interactions.get(record.interaction)
+            : candidates.length === 1
+                ? candidates[0]
+                : undefined;
+        if (!interaction)
+            return record;
+        let values = record.values;
+        for (const binding of interaction.binds) {
+            const expr = binding.from ?? binding.target;
+            if (expr?.k !== "attr")
+                continue;
+            const entity = evaluateFor(recon, snapshot, at, instance, expr.of, record.occurrence);
+            if (typeof entity !== "string" || !changed.has(factKey(entity, expr.attr)))
+                continue;
+            const value = snapshot.fact(entity, expr.attr)?.v;
+            if (value === undefined || value === null) {
+                if (Object.hasOwn(values, binding.field)) {
+                    const { [binding.field]: old, ...rest } = values;
+                    values = rest;
+                }
+            }
+            else if (values[binding.field] !== String(value))
+                values = { ...values, [binding.field]: String(value) };
+        }
+        if (values === record.values)
+            return record;
+        modified = true;
+        return { ...record, values };
+    });
+    return modified ? { ...world, evidence } : world;
+};

package/dist/_internal/reconciler/collection-values.d.ts

@@ -0,0 +1,5 @@
+import type * as IR from "../world-ir/types.generated.js";
+import type { Scalar } from "./basis.js";
+import type { Program } from "./model.js";
+/** Collection writes are scalar facts, validated against the owning entity's type. */
+export declare const collectionValue: (p: Program, type: IR.TypeRef, value: Scalar) => Scalar | undefined;