worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/reconciler/signatures.js

@@ -0,0 +1,37 @@
+import { canonicalJson } from "./result-digest.js";
+import { sha256 } from "./sha256.js";
+export const signatureInputValid = (input, method) => !!input &&
+    Object.keys(input).length === 4 &&
+    input.consent === true &&
+    input.intent === true &&
+    input.method === method &&
+    typeof input.device === "string" &&
+    input.device.trim().length > 0 &&
+    input.device.length <= 512;
+/** A binding digest, not a claim that a host's authentication is cryptographically verified. */
+const digest = (record, trail) => {
+    const { signature: _signature, ...evidence } = record;
+    return sha256(canonicalJson({ evidence, trail }));
+};
+export const signEvidence = (record, policy, input) => {
+    const trail = {
+        ...policy,
+        method: input.method,
+        device: input.device,
+        by: record.by,
+        at: record.at,
+    };
+    return { ...record, signature: { ...trail, digest: digest(record, trail) } };
+};
+/** Historical basic records carry no inferred consent. A present trail must bind its source. */
+export const signatureValid = (record) => {
+    if (record.signature === undefined)
+        return true;
+    const { digest: recorded, ...trail } = record.signature;
+    return (Object.keys(trail).length === 6 &&
+        record.status === "attested" &&
+        trail.by === record.by &&
+        trail.at === record.at &&
+        [trail.consent, trail.intent, trail.method, trail.device].every((v) => typeof v === "string" && v.trim().length > 0) &&
+        recorded === digest(record, trail));
+};

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

@@ -0,0 +1,10 @@
+import { type LocalDate } from "./dates.js";
+import type { Dependency } from "./dependencies.js";
+/** Publishing guarantees direct clock operands and finite, non-recursive clock logic. */
+export declare const clockCutoffs: (operator: string, leftClock: boolean, rightClock: boolean, a: unknown, b: unknown, precision?: "date" | "instant") => readonly LocalDate[];
+/** Replay only cutoffs. A newly taken branch can expose a nearer cutoff than the queued ones. */
+export declare const firstChange: <T>(now: LocalDate, current: T, initial: ReadonlySet<LocalDate>, read: (at: LocalDate, cutoffs: Set<LocalDate>) => T, signature: (value: T) => string) => LocalDate | null;
+export declare const nextWake: (dependencies: Iterable<Dependency>, now: LocalDate) => {
+    wakeAt: string | null;
+    wakeReason: string;
+};

package/dist/_internal/reconciler/temporal.js

@@ -0,0 +1,46 @@
+import { isInstant, isLocalDate } from "../ir-checks/index.js";
+import { nextTime, timeOrder } from "./instants.js";
+import {} from "./dates.js";
+/** Publishing guarantees direct clock operands and finite, non-recursive clock logic. */
+export const clockCutoffs = (operator, leftClock, rightClock, a, b, precision = "date") => {
+    if (leftClock === rightClock)
+        return [];
+    const value = leftClock ? b : a;
+    if (typeof value !== "string" || (!isLocalDate(value) && !isInstant(value)))
+        return [];
+    if (precision === "date" && value.length !== 10) {
+        const day = value.slice(0, 10), next = nextTime(day);
+        return next ? [day, next] : [day];
+    }
+    const cutoff = precision === "instant" && value.length === 10 ? `${value}T00:00:00.000Z` : value;
+    const next = nextTime(cutoff);
+    if (operator === "=" || operator === "not=")
+        return next ? [cutoff, next] : [cutoff];
+    return leftClock ? [cutoff] : next ? [next] : [];
+};
+/** Replay only cutoffs. A newly taken branch can expose a nearer cutoff than the queued ones. */
+export const firstChange = (now, current, initial, read, signature) => {
+    const before = signature(current);
+    const pending = new Set([...initial].filter((at) => timeOrder(at, now) > 0));
+    let cursor = now;
+    while (pending.size) {
+        const at = [...pending].sort()[0];
+        pending.delete(at);
+        if (timeOrder(at, cursor) <= 0)
+            continue;
+        const found = new Set();
+        const value = read(at, found);
+        if (signature(value) !== before)
+            return at;
+        cursor = at;
+        for (const next of found)
+            if (timeOrder(next, cursor) > 0)
+                pending.add(next);
+    }
+    return null;
+};
+export const nextWake = (dependencies, now) => {
+    const candidates = [...dependencies].flatMap((d) => d.kind === "time" && d.value && timeOrder(d.value.at, now) > 0 ? [d.value] : []);
+    candidates.sort((a, b) => timeOrder(a.at, b.at) || (a.why < b.why ? -1 : a.why > b.why ? 1 : 0));
+    return { wakeAt: candidates[0]?.at ?? null, wakeReason: candidates[0]?.why ?? "" };
+};

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

@@ -0,0 +1,6 @@
+import { type LocalDate } from "./dates.js";
+import { type UpgradeConsequence, type WorldReconciliation } from "./model.js";
+/** Compare reconciliations of the same world under the pinned release and a candidate. Decided
+ * occurrences keep the release and proof they were decided under; open work follows each
+ * account's declared :upgrade policy. */
+export declare const planUpgrade: (current: WorldReconciliation, candidate: WorldReconciliation, now: LocalDate) => readonly UpgradeConsequence[];

package/dist/_internal/reconciler/upgrades.js

@@ -0,0 +1,65 @@
+import { formatDate } from "./dates.js";
+import {} from "./model.js";
+import { proofOf } from "./proofs.js";
+import { programFor } from "./reconcile.js";
+/** Compare reconciliations of the same world under the pinned release and a candidate. Decided
+ * occurrences keep the release and proof they were decided under; open work follows each
+ * account's declared :upgrade policy. */
+export const planUpgrade = (current, candidate, now) => {
+    const out = [];
+    for (const [id, result] of current.results) {
+        const p = programFor(current, id);
+        const next = candidate.results.get(id);
+        const nextRelease = candidate.programs.find((x) => x.account.name === p.account.name)?.release;
+        for (const q of result.requirements) {
+            if (q.status === "NotApplicable")
+                continue;
+            const after = next?.requirements.find((r) => r.name === q.name);
+            const changes = [
+                after && after.status !== q.status ? `status ${q.status} → ${after.status}` : "",
+                after && after.due !== q.due ? `due ${q.due ?? "—"} → ${after.due ?? "—"}` : "",
+                after && after.remindAt !== q.remindAt
+                    ? `reminder ${q.remindAt ? formatDate(q.remindAt, false) : "none"} → ${after.remindAt ? formatDate(after.remindAt, false) : "none"}`
+                    : "",
+            ].filter(Boolean);
+            const base = {
+                account: p.account.name,
+                occurrence: q.occurrence,
+                label: q.label,
+                status: q.status,
+                policy: p.account.upgrade,
+            };
+            if (q.status === "Satisfied" || q.status === "Waived")
+                out.push({
+                    ...base,
+                    outcome: "keeps",
+                    detail: `Keeps ${p.release} and proof ${proofOf(p.release, now, q)}`,
+                });
+            else if (!changes.length)
+                out.push({
+                    ...base,
+                    outcome: "unchanged",
+                    detail: `${q.status}: the revision changes nothing here`,
+                });
+            else if (p.account.upgrade === "open-only")
+                out.push({
+                    ...base,
+                    outcome: "replans",
+                    detail: `${q.status}: re-planned under ${nextRelease}: ${changes.join("; ")}`,
+                });
+            else if (p.account.upgrade === "review")
+                out.push({
+                    ...base,
+                    outcome: "review",
+                    detail: `Finding: a reviewer approves ${changes.join("; ")} before re-planning`,
+                });
+            else
+                out.push({
+                    ...base,
+                    outcome: "next-cycle",
+                    detail: `Stays on ${p.release} until its next cycle`,
+                });
+        }
+    }
+    return out;
+};

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

@@ -0,0 +1,2 @@
+export * from "../world-ir/schema.generated.js";
+export declare const decodeCompiled: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("../world-ir/types.generated.js").Compiled;

package/dist/_internal/reconciler/wire.js

@@ -0,0 +1,5 @@
+// Decode only the current shipped IR schema.
+import { Schema } from "effect";
+import { Compiled } from "../world-ir/schema.generated.js";
+export * from "../world-ir/schema.generated.js";
+export const decodeCompiled = Schema.decodeUnknownSync(Compiled);

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

@@ -0,0 +1,32 @@
+import type { EvaluationContext } from "./context.js";
+import type { ActionResult, WorldReconciliation, EvaluationResult } from "./model.js";
+export declare const workKey: (account: string, idempotencyKey: string) => string;
+export declare const actionTargets: (action: ActionResult) => readonly string[];
+export interface WorkMember {
+    readonly instance: string;
+    readonly action: string;
+    readonly occurrences: readonly string[];
+}
+export interface ProjectedWork {
+    readonly key: string;
+    readonly idempotencyKey: string;
+    readonly account: string;
+    readonly state: ActionResult["state"] | "conflict";
+    readonly assignee: {
+        readonly id: string | null;
+        readonly kind: ActionResult["assigneeKind"];
+    };
+    readonly members: readonly WorkMember[];
+    readonly reason?: string;
+}
+/** Project the provided graph only. Distinct proof contexts never become shared evidence. */
+export declare const workItems: (recon: Pick<WorldReconciliation, "instances"> & {
+    readonly results: ReadonlyMap<string, Pick<EvaluationResult, "actions" | "requirements">>;
+}) => readonly ProjectedWork[];
+export declare const resolveWorkConflicts: (ctx: EvaluationContext) => void;
+/** The host supplies identity/memberships; a display label cannot authorize a signature. */
+export declare const canPerformWork: (action: ActionResult, actor: {
+    readonly id: string;
+    readonly kind: "human" | "agent";
+    readonly groups: readonly string[];
+}, by: string) => boolean;

package/dist/_internal/reconciler/work.js

@@ -0,0 +1,101 @@
+import { permitsConstraints } from "./policies.js";
+export const workKey = (account, idempotencyKey) => JSON.stringify(["worldvm/work@1", account, idempotencyKey]);
+export const actionTargets = (action) => action.advancesAll ?? [action.advances];
+/** Project the provided graph only. Distinct proof contexts never become shared evidence. */
+export const workItems = (recon) => {
+    const groups = new Map();
+    for (const [instance, result] of recon.results) {
+        const account = recon.instances.get(instance).account;
+        for (const action of result.actions) {
+            const key = workKey(account, action.idempotencyKey), member = {
+                instance,
+                action: action.action,
+                occurrences: actionTargets(action).map((name) => result.requirements.find((r) => r.name === name).occurrence),
+            };
+            const prior = groups.get(key);
+            if (!prior) {
+                groups.set(key, {
+                    first: action,
+                    item: {
+                        key,
+                        idempotencyKey: action.idempotencyKey,
+                        account,
+                        state: action.state,
+                        assignee: { id: action.assigneeId ?? null, kind: action.assigneeKind },
+                        members: [member],
+                    },
+                });
+                continue;
+            }
+            const compatible = prior.item.members.every((m) => m.instance === instance && m.action === action.action) &&
+                prior.first.assigneeId === action.assigneeId &&
+                prior.first.assigneeKind === action.assigneeKind &&
+                prior.first.via === action.via &&
+                prior.first.kind === action.kind;
+            const members = [...prior.item.members, member].sort((a, b) => JSON.stringify(a) < JSON.stringify(b) ? -1 : JSON.stringify(a) > JSON.stringify(b) ? 1 : 0);
+            prior.item = {
+                ...prior.item,
+                members,
+                ...(!compatible
+                    ? {
+                        state: "conflict",
+                        reason: "One work key names incompatible assignees or proof occurrences; use a shared keyed component or distinct keys.",
+                    }
+                    : {}),
+            };
+        }
+    }
+    return [...groups.values()]
+        .map((g) => g.item)
+        .sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+};
+export const resolveWorkConflicts = (ctx) => {
+    let multi = false;
+    for (const result of ctx.results.values())
+        if (result.actions.some((a) => a.advancesAll)) {
+            multi = true;
+            break;
+        }
+    if (!multi)
+        return;
+    for (const work of workItems(ctx)) {
+        if (work.state !== "conflict")
+            continue;
+        for (const member of work.members) {
+            const result = ctx.results.get(member.instance);
+            const action = result.actions.find((a) => a.action === member.action);
+            if (!action.advancesAll)
+                continue;
+            const intents = (result.workIntents ?? []).filter((i) => i.action !== action.action);
+            if (action.state === "dispatched")
+                intents.push({
+                    instance: member.instance,
+                    action: action.action,
+                    occurrence: member.occurrences[0],
+                    idempotencyKey: action.idempotencyKey,
+                    at: action.at,
+                    kind: action.onIneligible ?? "withdraw",
+                });
+            ctx.results.set(member.instance, {
+                ...result,
+                actions: result.actions.map((a) => a === action
+                    ? {
+                        ...a,
+                        state: "waiting",
+                        missing: [...a.missing, { text: work.reason, kind: "other" }],
+                    }
+                    : a),
+                workIntents: intents,
+            });
+        }
+    }
+};
+/** The host supplies identity/memberships; a display label cannot authorize a signature. */
+export const canPerformWork = (action, actor, by) => action.kind !== "interaction" ||
+    ((!action.advancesAll || actor.kind === "human") &&
+        actor.id === by &&
+        action.assigneeId != null &&
+        (action.assigneeKind === "entity"
+            ? actor.id === action.assigneeId
+            : action.assigneeKind === "group" && actor.groups.includes(action.assigneeId)) &&
+        permitsConstraints(action.authorityConstraints ?? [], actor));

package/dist/_internal/world-ir/schema.generated.d.ts

@@ -0,0 +1,180 @@
+import { Schema } from "effect";
+import type * as T from "./types.generated.js";
+export type Span = T.Span;
+export declare const Span: Schema.Codec<T.Span>;
+export type TypeRef = T.TypeRef;
+export declare const TypeRef: Schema.Codec<T.TypeRef>;
+export type Expr = T.Expr;
+export declare const Expr: Schema.Codec<T.Expr>;
+export type FilePolicy = T.FilePolicy;
+export declare const FilePolicy: Schema.Codec<T.FilePolicy>;
+export type Seal = T.Seal;
+export declare const Seal: Schema.Codec<T.Seal>;
+export type Field = T.Field;
+export declare const Field: Schema.Codec<T.Field>;
+export type Source = T.Source;
+export declare const Source: Schema.Codec<T.Source>;
+export type Citation = T.Citation;
+export declare const Citation: Schema.Codec<T.Citation>;
+export type SensitiveClass = T.SensitiveClass;
+export declare const SensitiveClass: Schema.Codec<T.SensitiveClass>;
+export type AgentReadGrant = T.AgentReadGrant;
+export declare const AgentReadGrant: Schema.Codec<T.AgentReadGrant>;
+export type Agent = T.Agent;
+export declare const Agent: Schema.Codec<T.Agent>;
+export type VaultKey = T.VaultKey;
+export declare const VaultKey: Schema.Codec<T.VaultKey>;
+export type VaultErasure = T.VaultErasure;
+export declare const VaultErasure: Schema.Codec<T.VaultErasure>;
+export type VaultDisposal = T.VaultDisposal;
+export declare const VaultDisposal: Schema.Codec<T.VaultDisposal>;
+export type Vault = T.Vault;
+export declare const Vault: Schema.Codec<T.Vault>;
+export type Library = T.Library;
+export declare const Library: Schema.Codec<T.Library>;
+export type TypeAlias = T.TypeAlias;
+export declare const TypeAlias: Schema.Codec<T.TypeAlias>;
+export type Role = T.Role;
+export declare const Role: Schema.Codec<T.Role>;
+export type EntityField = T.EntityField;
+export declare const EntityField: Schema.Codec<T.EntityField>;
+export type Binding = T.Binding;
+export declare const Binding: Schema.Codec<T.Binding>;
+export type Entity = T.Entity;
+export declare const Entity: Schema.Codec<T.Entity>;
+export type Holiday = T.Holiday;
+export declare const Holiday: Schema.Codec<T.Holiday>;
+export type Calendar = T.Calendar;
+export declare const Calendar: Schema.Codec<T.Calendar>;
+export type Derive = T.Derive;
+export declare const Derive: Schema.Codec<T.Derive>;
+export type Rule = T.Rule;
+export declare const Rule: Schema.Codec<T.Rule>;
+export type AmendmentPolicy = T.AmendmentPolicy;
+export declare const AmendmentPolicy: Schema.Codec<T.AmendmentPolicy>;
+export type AmendmentInput = T.AmendmentInput;
+export declare const AmendmentInput: Schema.Codec<T.AmendmentInput>;
+export type SignaturePolicy = T.SignaturePolicy;
+export declare const SignaturePolicy: Schema.Codec<T.SignaturePolicy>;
+export type SignatureInput = T.SignatureInput;
+export declare const SignatureInput: Schema.Codec<T.SignatureInput>;
+export type Evidence = T.Evidence;
+export declare const Evidence: Schema.Codec<T.Evidence>;
+export type InteractionBinding = T.InteractionBinding;
+export declare const InteractionBinding: Schema.Codec<T.InteractionBinding>;
+export type Interaction = T.Interaction;
+export declare const Interaction: Schema.Codec<T.Interaction>;
+export type LayoutItem = T.LayoutItem;
+export declare const LayoutItem: Schema.Codec<T.LayoutItem>;
+export type Layout = T.Layout;
+export declare const Layout: Schema.Codec<T.Layout>;
+export type Connector = T.Connector;
+export declare const Connector: Schema.Codec<T.Connector>;
+export type Machine = T.Machine;
+export declare const Machine: Schema.Codec<T.Machine>;
+export type InputHome = T.InputHome;
+export declare const InputHome: Schema.Codec<T.InputHome>;
+export type Home = T.Home;
+export declare const Home: Schema.Codec<T.Home>;
+export type Milestone = T.Milestone;
+export declare const Milestone: Schema.Codec<T.Milestone>;
+export type DayOffset = T.DayOffset;
+export declare const DayOffset: Schema.Codec<T.DayOffset>;
+export type Escalation = T.Escalation;
+export declare const Escalation: Schema.Codec<T.Escalation>;
+export type Hold = T.Hold;
+export declare const Hold: Schema.Codec<T.Hold>;
+export type Accepts = T.Accepts;
+export declare const Accepts: Schema.Codec<T.Accepts>;
+export type Recurrence = T.Recurrence;
+export declare const Recurrence: Schema.Codec<T.Recurrence>;
+export type Effective = T.Effective;
+export declare const Effective: Schema.Codec<T.Effective>;
+export type RenewalWindow = T.RenewalWindow;
+export declare const RenewalWindow: Schema.Codec<T.RenewalWindow>;
+export type Reuse = T.Reuse;
+export declare const Reuse: Schema.Codec<T.Reuse>;
+export type Notice = T.Notice;
+export declare const Notice: Schema.Codec<T.Notice>;
+export type DocumentField = T.DocumentField;
+export declare const DocumentField: Schema.Codec<T.DocumentField>;
+export type Document = T.Document;
+export declare const Document: Schema.Codec<T.Document>;
+export type Requirement = T.Requirement;
+export declare const Requirement: Schema.Codec<T.Requirement>;
+export type Via = T.Via;
+export declare const Via: Schema.Codec<T.Via>;
+export type Action = T.Action;
+export declare const Action: Schema.Codec<T.Action>;
+export type Slot = T.Slot;
+export declare const Slot: Schema.Codec<T.Slot>;
+export type Output = T.Output;
+export declare const Output: Schema.Codec<T.Output>;
+export type PolicyNumber = T.PolicyNumber;
+export declare const PolicyNumber: Schema.Codec<T.PolicyNumber>;
+export type ParamBound = T.ParamBound;
+export declare const ParamBound: Schema.Codec<T.ParamBound>;
+export type AccountPolicy = T.AccountPolicy;
+export declare const AccountPolicy: Schema.Codec<T.AccountPolicy>;
+export type ResourceCall = T.ResourceCall;
+export declare const ResourceCall: Schema.Codec<T.ResourceCall>;
+export type Resource = T.Resource;
+export declare const Resource: Schema.Codec<T.Resource>;
+export type Component = T.Component;
+export declare const Component: Schema.Codec<T.Component>;
+export type Account = T.Account;
+export declare const Account: Schema.Codec<T.Account>;
+export type ScenarioValue = T.ScenarioValue;
+export declare const ScenarioValue: Schema.Codec<T.ScenarioValue>;
+export type ScenarioInstance = T.ScenarioInstance;
+export declare const ScenarioInstance: Schema.Codec<T.ScenarioInstance>;
+export type ScenarioStatus = T.ScenarioStatus;
+export declare const ScenarioStatus: Schema.Codec<T.ScenarioStatus>;
+export type ScenarioExpect = T.ScenarioExpect;
+export declare const ScenarioExpect: Schema.Codec<T.ScenarioExpect>;
+export type ScenarioField = T.ScenarioField;
+export declare const ScenarioField: Schema.Codec<T.ScenarioField>;
+export type ScenarioFields = T.ScenarioFields;
+export declare const ScenarioFields: Schema.Codec<T.ScenarioFields>;
+export type ScenarioRecord = T.ScenarioRecord;
+export declare const ScenarioRecord: Schema.Codec<T.ScenarioRecord>;
+export type ScenarioCommand = T.ScenarioCommand;
+export declare const ScenarioCommand: Schema.Codec<T.ScenarioCommand>;
+export type ScenarioActor = T.ScenarioActor;
+export declare const ScenarioActor: Schema.Codec<T.ScenarioActor>;
+export type ScenarioEntity = T.ScenarioEntity;
+export declare const ScenarioEntity: Schema.Codec<T.ScenarioEntity>;
+export type ScenarioFile = T.ScenarioFile;
+export declare const ScenarioFile: Schema.Codec<T.ScenarioFile>;
+export type Scenario = T.Scenario;
+export declare const Scenario: Schema.Codec<T.Scenario>;
+export type PropertyTarget = T.PropertyTarget;
+export declare const PropertyTarget: Schema.Codec<T.PropertyTarget>;
+export type PropertyStatus = T.PropertyStatus;
+export declare const PropertyStatus: Schema.Codec<T.PropertyStatus>;
+export type PropertyOperator = T.PropertyOperator;
+export declare const PropertyOperator: Schema.Codec<T.PropertyOperator>;
+export type PropertyExpr = T.PropertyExpr;
+export declare const PropertyExpr: Schema.Codec<T.PropertyExpr>;
+export type Property = T.Property;
+export declare const Property: Schema.Codec<T.Property>;
+export type Decision = T.Decision;
+export declare const Decision: Schema.Codec<T.Decision>;
+export type ConfirmationWindow = T.ConfirmationWindow;
+export declare const ConfirmationWindow: Schema.Codec<T.ConfirmationWindow>;
+export type Collect = T.Collect;
+export declare const Collect: Schema.Codec<T.Collect>;
+export type Bundle = T.Bundle;
+export declare const Bundle: Schema.Codec<T.Bundle>;
+export type ContractOperation = T.ContractOperation;
+export declare const ContractOperation: Schema.Codec<T.ContractOperation>;
+export type ComponentContract = T.ComponentContract;
+export declare const ComponentContract: Schema.Codec<T.ComponentContract>;
+export type ComponentImport = T.ComponentImport;
+export declare const ComponentImport: Schema.Codec<T.ComponentImport>;
+export type WorldIR = T.WorldIR;
+export declare const WorldIR: Schema.Codec<T.WorldIR>;
+export type Diagnostic = T.Diagnostic;
+export declare const Diagnostic: Schema.Codec<T.Diagnostic>;
+export type Compiled = T.Compiled;
+export declare const Compiled: Schema.Codec<T.Compiled>;