worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/reconciler/component-operations.js

@@ -0,0 +1,256 @@
+import { amendmentAction } from "./amendments.js";
+import { canAttestEvidence } from "./evidence-authority.js";
+import { instanceContext } from "./evaluation.js";
+import { decisionRelease } from "./decision-release.js";
+import { collectionValue } from "./collection-values.js";
+import { advanceTargets, componentOperationNames } from "../ir-checks/index.js";
+import { timeOrder } from "./instants.js";
+import { perform, amendEvidence } from "./commands.js";
+import { decide } from "./decide.js";
+import { occurrenceHome } from "./homes.js";
+import { admit } from "./invariants.js";
+import { basis } from "./memory.js";
+import { programFor } from "./reconcile.js";
+import { permitsConstraints } from "./policies.js";
+import { canonicalJson } from "./result-digest.js";
+import { sha256 } from "./sha256.js";
+import { workKey } from "./work.js";
+const resolve = (recon, account, target) => {
+    let parent, instance;
+    if ("parent" in target) {
+        parent = recon.instances.get(target.parent);
+        const slot = parent?.children.find((s) => s.name === target.slot);
+        if (!parent || parent.account !== account || !slot || slot.applies !== true)
+            return;
+        const ids = [...new Set(slot.instances)];
+        const selected = target.instance ?? (ids.length === 1 ? ids[0] : undefined);
+        if (!selected || !ids.includes(selected))
+            return;
+        instance = recon.instances.get(selected);
+        if (!instance?.parents.has(parent.id))
+            return;
+    }
+    else
+        instance = recon.instances.get(target.instance);
+    if (!instance || instance.account !== account || !recon.results.has(instance.id))
+        return;
+    const program = programFor(recon, instance.id);
+    if (!program)
+        return;
+    const candidates = (program.ir.componentContracts ?? []).filter((c) => c.component === instance.component);
+    let contract;
+    if (parent) {
+        const consumer = program.components.get(parent.component).library ?? program.library.name;
+        const imported = program.ir.componentImports?.find((i) => i.library === consumer && candidates.some((c) => c.name === i.contract));
+        contract = imported
+            ? candidates.find((c) => c.name === imported.contract)
+            : candidates.length === 1 && candidates[0].library === consumer
+                ? candidates[0]
+                : undefined;
+        const provider = program.components.get(instance.component).library;
+        if ((candidates.length && !contract) || (provider && provider !== consumer && !contract))
+            return;
+    }
+    else {
+        if (candidates.length > 1)
+            return;
+        contract = candidates[0];
+    }
+    return { instance, program, contract };
+};
+/** Structural projection only; command admission still checks the trusted actor and current work. */
+export const operationsFor = (recon, account, target) => {
+    const found = resolve(recon, account, target);
+    if (!found)
+        return { instance: null, operations: [], codes: ["operation-target"] };
+    const { instance, program, contract } = found, component = program.components.get(instance.component);
+    const names = componentOperationNames(program.ir, component).filter((n) => !contract || contract.operations.some((o) => o.name === n));
+    const operations = names.map((name) => {
+        const definition = component.actions.find((a) => a.name === name);
+        if (definition) {
+            const action = recon.results.get(instance.id)?.actions.find((a) => a.action === name);
+            const evidence = definition.via.kind === "interaction"
+                ? program.evidence.get(program.interactions.get(definition.via.name).produces)
+                : undefined;
+            return {
+                name,
+                kind: "action",
+                ...(evidence?.amend && evidence.of === component.name ? { amendable: true } : {}),
+                state: action?.state ??
+                    (advanceTargets(definition).every((name) => recon.results.get(instance.id).requirements.find((r) => r.name === name)?.status ===
+                        "NotApplicable")
+                        ? "not-applicable"
+                        : "complete"),
+                ...(action ? { workKey: workKey(account, action.idempotencyKey) } : {}),
+                at: definition.at,
+            };
+        }
+        return {
+            name,
+            kind: "decision",
+            state: "decision",
+            at: program.ir.decisions.find((d) => d.of === component.name && d.name === name).at,
+        };
+    });
+    return {
+        instance: instance.id,
+        operations: operations.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0)),
+        codes: [],
+    };
+};
+/** The host supplies a current reconciliation/basis pair and verified identity; M16 serializes it. */
+export const invokeOperation = (recon, world, now, request) => {
+    const reject = (...codes) => ({ accepted: false, codes, world });
+    const program = recon.programs.find((p) => p.account.name === request.account);
+    if (!program || !request.id.trim() || !request.actor.id.trim())
+        return reject("operation-target");
+    const digest = sha256(canonicalJson({
+        account: request.account,
+        id: request.id,
+        target: request.target,
+        operation: request.operation,
+        actor: { ...request.actor, groups: [...request.actor.groups].sort() },
+        values: request.values ?? null,
+        unsigned: request.unsigned ?? false,
+        ...(request.signature ? { signature: request.signature } : {}),
+        ...(request.amend ? { amend: request.amend } : {}),
+        reason: request.reason ?? null,
+        revoke: request.revoke ?? null,
+        release: decisionRelease(program),
+    }));
+    const previous = world.operationReceipts?.find((r) => r.account === request.account && r.id === request.id);
+    if (previous) {
+        if (previous.digest !== digest)
+            return reject("operation-duplicate");
+        if (timeOrder(previous.at, now) > 0)
+            return reject("operation-snapshot");
+        return { accepted: true, codes: [], world, instance: previous.instance };
+    }
+    if (recon.now !== now)
+        return reject("operation-snapshot");
+    const projection = operationsFor(recon, request.account, request.target);
+    if (!projection.instance)
+        return reject(...projection.codes);
+    const operation = projection.operations.find((o) => o.name === request.operation);
+    if (!operation)
+        return reject("E_NOT_AN_OPERATION");
+    const instance = recon.instances.get(projection.instance), p = programFor(recon, instance.id);
+    const home = occurrenceHome(p, instance, recon.instances);
+    if (!home)
+        return reject("operation-target");
+    let next;
+    if (operation.kind === "decision") {
+        if (request.actor.kind !== "human")
+            return reject("decision-authority");
+        if (request.unsigned || request.values || request.signature || request.amend)
+            return reject("operation-input");
+        const result = decide(recon, world, now, {
+            id: JSON.stringify(["worldvm/operation", request.account, request.id]),
+            instance: instance.id,
+            decision: operation.name,
+            actor: request.actor,
+            ...(request.reason === undefined ? {} : { reason: request.reason }),
+            ...(request.revoke ? { revoke: request.revoke } : {}),
+        });
+        if (!result.accepted)
+            return { accepted: false, codes: result.codes, world: result.world, instance: instance.id };
+        next = result.world;
+    }
+    else {
+        if (request.amend && request.actor.kind !== "human")
+            return reject("human-required");
+        if (request.amend &&
+            (request.unsigned ||
+                !request.amend.previous.trim() ||
+                !request.amend.reason.trim() ||
+                request.amend.reason.length > 2000))
+            return reject("amendment-input");
+        const prepared = request.amend
+            ? amendmentAction(recon, world, now, instance.id, operation.name, request.amend.previous)
+            : undefined;
+        if (prepared?.code)
+            return reject(prepared.code);
+        const actions = prepared?.action
+            ? [prepared.action]
+            : recon.results.get(instance.id).actions.filter((a) => a.action === operation.name), action = actions[0];
+        if (actions.length !== 1 ||
+            !action ||
+            action.kind === "decision" ||
+            (action.state !== "eligible" && action.state !== "dispatched"))
+            return reject("operation-not-eligible");
+        const who = request.actor, allowed = action.kind === "connector"
+            ? (who.kind === "service" || who.kind === "connector") && who.id === action.assigneeId
+            : (who.kind === "human" || who.kind === "agent") &&
+                action.assigneeId != null &&
+                (action.assigneeKind === "group"
+                    ? who.groups.includes(action.assigneeId)
+                    : who.id === action.assigneeId);
+        if (!allowed || !permitsConstraints(action.authorityConstraints ?? [], who))
+            return reject("operation-authority");
+        if (who.kind === "agent" && !request.unsigned)
+            return reject("human-required");
+        if (request.signature && (who.kind !== "human" || request.unsigned))
+            return reject("human-required");
+        if (request.revoke || request.reason !== undefined)
+            return reject("operation-input");
+        const values = {};
+        if (action.kind === "connector" &&
+            (request.unsigned || Object.keys(request.values ?? {}).length))
+            return reject("operation-input");
+        const interaction = action.interaction ? p.interactions.get(action.interaction) : undefined;
+        const evidence = interaction ? p.evidence.get(interaction.produces) : undefined;
+        if (evidence &&
+            !request.unsigned &&
+            !canAttestEvidence(instanceContext(recon, basis(world, now), instance), evidence.name, who))
+            return reject("operation-authority");
+        if (request.signature && !evidence?.attest?.audit)
+            return reject("operation-input");
+        for (const [name, value] of Object.entries(request.values ?? {})) {
+            const field = evidence?.fields.find((f) => f.name === name);
+            if (!field)
+                return reject("operation-input");
+            const parsed = request.unsigned && value === "" ? "" : collectionValue(p, field.type, value);
+            if (parsed === undefined)
+                return reject("operation-input");
+            values[name] = parsed;
+        }
+        if ([operation.name, "perform"].some((kind) => admit(recon, basis(world, now), now, { kind, subject: home.id }).length))
+            return reject("operation-invariant");
+        const write = {
+            instance: instance.id,
+            action: operation.name,
+            by: who.id,
+            actor: who,
+            connectorAcknowledgement: "deferred",
+            ...(request.signature ? { signature: request.signature } : {}),
+            ...(request.values ? { values } : {}),
+            ...(request.unsigned === undefined ? {} : { unsigned: request.unsigned }),
+        };
+        next = request.amend
+            ? amendEvidence(recon, world, now, { ...write, amend: request.amend })
+            : perform(recon, world, now, write);
+        if (next === world &&
+            !(action.kind === "connector" && world.dispatches.some((d) => d.key === action.idempotencyKey)))
+            return reject("evidence-invalid");
+    }
+    return {
+        accepted: true,
+        codes: [],
+        instance: instance.id,
+        world: {
+            ...next,
+            operationReceipts: [
+                ...(next.operationReceipts ?? []),
+                {
+                    account: request.account,
+                    id: request.id,
+                    digest,
+                    instance: instance.id,
+                    operation: operation.name,
+                    kind: operation.kind,
+                    at: now,
+                },
+            ],
+        },
+    };
+};

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

@@ -0,0 +1,38 @@
+import { type Basis } from "./basis.js";
+import { type TimePoint } from "./instants.js";
+import { ReadSet, type Dependency } from "./dependencies.js";
+import { type Cx, type EvaluationResult, type Instance, type KernelState, type Program, type ReconcileScope, type RequirementResult, type Status } from "./model.js";
+export declare const contextOf: (ctx: EvaluationContext, inst: Instance) => Cx;
+export interface PredictedStatus {
+    readonly value: Status;
+    readonly cutoffs: ReadonlySet<TimePoint>;
+    readonly reads: ReadonlyMap<string, Dependency>;
+    readonly cyclic?: boolean;
+}
+export interface EvaluationContext {
+    readonly programs: readonly Program[];
+    readonly b: Basis;
+    readonly now: TimePoint;
+    readonly scope: ReconcileScope | undefined;
+    readonly instances: Map<string, Instance>;
+    readonly programOf: Map<string, Program>;
+    readonly results: Map<string, EvaluationResult>;
+    readonly evaluating: Map<string, Map<string, RequirementResult>>;
+    readonly resolvingOutputs: Set<string>;
+    readonly roots: Array<{
+        subject: string;
+        account: string;
+        instance: string;
+    }>;
+    readonly rootFocus: Map<string, string>;
+    blockedTotal: number;
+    readonly temporalJobs: (() => void)[];
+    readonly discoveryJobs: (() => void)[];
+    discoveryReadSets: ReadonlyMap<string, ReadSet>;
+    readonly state: KernelState;
+    readonly contexts: Map<string, Cx>;
+    readonly observations: Map<string, ReadSet>;
+    readonly predictions: Map<string, PredictedStatus>;
+    readonly predicting: Set<string>;
+}
+export declare const createEvaluationContext: (programs: readonly Program[], b: Basis, now: TimePoint, scope: ReconcileScope | undefined) => EvaluationContext;

package/dist/_internal/reconciler/context.js

@@ -0,0 +1,44 @@
+import {} from "./basis.js";
+import {} from "./instants.js";
+import { observeBasis, programDependency, ReadSet } from "./dependencies.js";
+import { instanceEnv } from "./evaluation.js";
+import {} from "./model.js";
+import { readStatus, requirementStatus } from "./outputs.js";
+export const contextOf = (ctx, inst) => {
+    const cached = ctx.contexts.get(inst.id);
+    if (cached)
+        return cached;
+    const p = ctx.programOf.get(inst.id);
+    const reads = new ReadSet();
+    reads.add(programDependency(p));
+    const env = instanceEnv(p, inst, (name) => requirementStatus(ctx, inst, name), reads);
+    const cx = { p, b: observeBasis(ctx.b, reads), inst, env, k: ctx.state, reads };
+    ctx.contexts.set(inst.id, cx);
+    return cx;
+};
+export const createEvaluationContext = (programs, b, now, scope) => {
+    const instances = new Map();
+    const ctx = {
+        programs,
+        b,
+        now,
+        scope,
+        instances,
+        programOf: new Map(),
+        results: new Map(),
+        evaluating: new Map(),
+        resolvingOutputs: new Set(),
+        roots: [],
+        rootFocus: new Map(),
+        blockedTotal: 0,
+        temporalJobs: [],
+        discoveryJobs: [],
+        discoveryReadSets: new Map(),
+        contexts: new Map(),
+        observations: new Map(),
+        predictions: new Map(),
+        predicting: new Set(),
+        state: { instances, status: (inst, name) => readStatus(ctx, inst, name) },
+    };
+    return ctx;
+};

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

@@ -0,0 +1,31 @@
+import type * as IR from "../world-ir/types.generated.js";
+import type { Status, WorldReconciliation } from "./reconcile.js";
+export type CoverageTruth = "true" | "false" | "Unknown";
+export interface CoverageReference {
+    readonly kind: "scenario" | "property";
+    readonly name: string;
+}
+export interface CoverageOutcomes<T extends string> {
+    readonly expected: readonly T[];
+    readonly seen: readonly T[];
+    readonly missing: readonly T[];
+}
+export interface RequirementCoverage {
+    readonly key: string;
+    readonly at: IR.Span;
+    readonly observations: number;
+    readonly references: readonly CoverageReference[];
+    readonly applicability: CoverageOutcomes<CoverageTruth>;
+    readonly statuses: CoverageOutcomes<Status>;
+    readonly due: {
+        readonly outcomes: CoverageOutcomes<"date" | "Unknown">;
+        readonly branches: readonly (CoverageOutcomes<CoverageTruth> & {
+            readonly at: IR.Span;
+        })[];
+    } | null;
+}
+/** An explicit, bounded accumulator over supplied reconciliations; no clock or I/O. */
+export declare const createCoverageCollector: (ir: IR.WorldIR) => {
+    observe(recon: WorldReconciliation, reference: CoverageReference): void;
+    report(): RequirementCoverage[];
+};

package/dist/_internal/reconciler/coverage.js

@@ -0,0 +1,124 @@
+const truthValues = ["true", "false", "Unknown"];
+const statuses = [
+    "NotApplicable",
+    "Unknown",
+    "Open",
+    "Overdue",
+    "Satisfied",
+    "Waived",
+];
+const location = (at) => JSON.stringify([at.src, at.from, at.to]);
+const outcomes = (expected, seen) => ({
+    expected: [...expected],
+    seen: [
+        ...expected.filter((v) => seen.has(v)),
+        ...[...seen].filter((v) => !expected.includes(v)).sort(),
+    ],
+    missing: expected.filter((v) => !seen.has(v)),
+});
+/** Walk only due expressions and their called derives; keep unvisited branches in the report. */
+const dueBranches = (ir, expr) => {
+    const found = new Map(), visited = new Set();
+    const visit = (e) => {
+        switch (e.k) {
+            case "if":
+                found.set(location(e.at), e.at);
+                visit(e.test);
+                visit(e.then);
+                visit(e.else);
+                break;
+            case "call":
+                e.args.forEach(visit);
+                if (e.derive && !visited.has(e.fn)) {
+                    visited.add(e.fn);
+                    const d = ir.derives.find((d) => d.name === e.fn);
+                    if (d)
+                        visit(d.body);
+                }
+                break;
+            case "fn":
+                visit(e.body);
+                break;
+            case "list":
+                e.items.forEach(visit);
+                break;
+            case "attr":
+            case "read":
+            case "inst":
+                visit(e.of);
+                break;
+        }
+    };
+    visit(expr);
+    return [...found.values()].sort((a, b) => a.src.localeCompare(b.src) || a.from - b.from || a.to - b.to);
+};
+/** An explicit, bounded accumulator over supplied reconciliations; no clock or I/O. */
+export const createCoverageCollector = (ir) => {
+    const rows = ir.components.flatMap((component) => component.requirements.map((requirement) => ({
+        key: `${component.name}/${requirement.name}`,
+        requirement,
+        observations: 0,
+        refs: new Map(),
+        applicability: new Set(),
+        statuses: new Set(),
+        due: new Set(),
+        branches: (requirement.due ? dueBranches(ir, requirement.due) : []).map((at) => ({
+            at,
+            seen: new Set(),
+        })),
+    })));
+    const byKey = new Map(rows.map((row) => [row.key, row]));
+    return {
+        observe(recon, reference) {
+            for (const result of recon.results.values())
+                for (const requirement of result.requirements) {
+                    const row = byKey.get(`${result.component}/${requirement.name}`);
+                    if (!row)
+                        continue;
+                    row.observations++;
+                    row.refs.set(JSON.stringify([reference.kind, reference.name]), { ...reference });
+                    row.statuses.add(requirement.status);
+                    const applies = requirement.reasons.find((r) => r.label === "Applies when");
+                    row.applicability.add(!applies || applies.outcome === "passed"
+                        ? "true"
+                        : applies.outcome === "failed"
+                            ? "false"
+                            : "Unknown");
+                    if (!row.requirement.due)
+                        continue;
+                    if (requirement.due !== null)
+                        row.due.add("date");
+                    else if (requirement.dueUnknown !== null)
+                        row.due.add("Unknown");
+                    for (const step of requirement.dueSteps)
+                        if (step.branch) {
+                            row.branches
+                                .find((branch) => location(branch.at) === location(step.at))
+                                ?.seen.add(step.branch);
+                        }
+                }
+        },
+        report() {
+            return rows
+                .map((row) => ({
+                key: row.key,
+                at: row.requirement.at,
+                observations: row.observations,
+                references: [...row.refs.values()].sort((a, b) => a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name)),
+                applicability: outcomes(row.requirement.appliesWhen ? truthValues : ["true"], row.applicability),
+                statuses: outcomes(statuses, row.statuses),
+                due: row.requirement.due
+                    ? {
+                        outcomes: outcomes(["date", "Unknown"], row.due),
+                        // Authored if tests require Bool: true?/false?/unknown? make absence explicit.
+                        branches: row.branches.map((branch) => ({
+                            at: branch.at,
+                            ...outcomes(["true", "false"], branch.seen),
+                        })),
+                    }
+                    : null,
+            }))
+                .sort((a, b) => a.key.localeCompare(b.key));
+        },
+    };
+};

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

@@ -0,0 +1,38 @@
+export type LocalDate = string;
+export declare const addDays: (date: LocalDate, days: number) => LocalDate;
+export declare const addYears: (date: LocalDate, years: number) => LocalDate;
+/** Calendar months; a day past the target month's end clamps to its last day (Jan 31 + 1 = Feb 28/29). */
+export declare const addMonths: (date: LocalDate, months: number) => LocalDate;
+export declare const daysBetween: (from: LocalDate, to: LocalDate) => number;
+export declare const weekday: (date: LocalDate) => number;
+export declare const latest: (...dates: LocalDate[]) => string;
+export declare const earliest: (...dates: LocalDate[]) => string;
+/** A holiday rule as a calendar declares it: a fixed day, or the nth (−1: last) weekday. */
+export interface HolidayRule {
+    readonly label: string;
+    readonly month: number;
+    readonly day?: number;
+    readonly weekday?: string;
+    readonly nth?: number;
+    readonly observed: boolean;
+}
+export declare const holidayDate: (rule: HolidayRule, year: number) => LocalDate;
+export interface Calendar {
+    readonly id: string;
+    readonly version: string;
+    readonly isBusinessDay: (date: LocalDate) => boolean;
+    readonly holiday: (date: LocalDate) => string | undefined;
+}
+/** A versioned business-day calendar from its declared weekend and holiday rules. */
+export declare const makeCalendar: (id: string, version: string, weekend: readonly string[], rules: readonly HolidayRule[]) => Calendar;
+type BusinessDays = {
+    readonly date: LocalDate;
+    readonly skipped: ReadonlyArray<{
+        date: LocalDate;
+        why: string;
+    }>;
+};
+/** Memoize by pinned calendar object: distinct releases can reuse a calendar label/version. */
+export declare const businessDaysAfter: (date: LocalDate, days: number, calendar: Calendar) => BusinessDays;
+export declare const formatDate: (date: LocalDate, withWeekday?: boolean) => string;
+export {};

package/dist/_internal/reconciler/dates.js

@@ -0,0 +1,121 @@
+import { isInstant } from "../ir-checks/index.js";
+const toUtc = (date) => Date.parse(`${date}T00:00:00Z`);
+const fromUtc = (ms) => new Date(ms).toISOString().slice(0, 10);
+const DAY = 86_400_000;
+const shifted = new Map();
+export const addDays = (date, days) => {
+    const key = `${date}|${days}`;
+    let result = shifted.get(key);
+    if (result === undefined) {
+        result = fromUtc(toUtc(date) + days * DAY);
+        shifted.set(key, result);
+    }
+    return result;
+};
+export const addYears = (date, years) => {
+    const year = Number(date.slice(0, 4)) + years;
+    const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    const suffix = date.endsWith("-02-29") && !leap ? "-02-28" : date.slice(4);
+    return `${String(year).padStart(4, "0")}${suffix}`;
+};
+/** Calendar months; a day past the target month's end clamps to its last day (Jan 31 + 1 = Feb 28/29). */
+export const addMonths = (date, months) => {
+    const index = Number(date.slice(0, 4)) * 12 + Number(date.slice(5, 7)) - 1 + months;
+    const year = Math.floor(index / 12), month = index - year * 12 + 1;
+    const last = new Date(Date.UTC(year, month, 0)).getUTCDate();
+    const day = Math.min(Number(date.slice(8, 10)), last);
+    return `${String(year).padStart(4, "0")}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+};
+export const daysBetween = (from, to) => Math.round((toUtc(to) - toUtc(from)) / DAY);
+const weekdays = new Map();
+export const weekday = (date) => {
+    let day = weekdays.get(date);
+    if (day === undefined) {
+        day = new Date(toUtc(date)).getUTCDay();
+        weekdays.set(date, day);
+    }
+    return day;
+};
+export const latest = (...dates) => dates.reduce((a, b) => (a > b ? a : b));
+export const earliest = (...dates) => dates.reduce((a, b) => (a < b ? a : b));
+const nth = (year, month, day, n) => {
+    const first = `${year}-${String(month).padStart(2, "0")}-01`;
+    const offset = (day - weekday(first) + 7) % 7;
+    return addDays(first, offset + (n - 1) * 7);
+};
+const last = (year, month, day) => {
+    const end = addDays(`${month === 12 ? year + 1 : year}-${String((month % 12) + 1).padStart(2, "0")}-01`, -1);
+    return addDays(end, -((weekday(end) - day + 7) % 7));
+};
+// A fixed-date holiday that falls on a weekend is observed on the nearest weekday.
+const observed = (date) => weekday(date) === 6 ? addDays(date, -1) : weekday(date) === 0 ? addDays(date, 1) : date;
+const WEEKDAYS = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+export const holidayDate = (rule, year) => {
+    if (rule.day !== undefined) {
+        const date = `${year}-${String(rule.month).padStart(2, "0")}-${String(rule.day).padStart(2, "0")}`;
+        return rule.observed ? observed(date) : date;
+    }
+    const day = WEEKDAYS.indexOf(rule.weekday ?? "mon");
+    return rule.nth === -1 ? last(year, rule.month, day) : nth(year, rule.month, day, rule.nth ?? 1);
+};
+/** A versioned business-day calendar from its declared weekend and holiday rules. */
+export const makeCalendar = (id, version, weekend, rules) => {
+    const closed = new Set(weekend.map((d) => WEEKDAYS.indexOf(d)));
+    const years = new Map();
+    // A December 31 observance of next year's New Year's Day belongs to this year.
+    const holidaysOf = (year) => {
+        let found = years.get(year);
+        if (!found) {
+            found = new Map([year, year + 1].flatMap((y) => rules.map((r) => [holidayDate(r, y), r.label])));
+            years.set(year, found);
+        }
+        return found;
+    };
+    return {
+        id,
+        version,
+        holiday: (date) => holidaysOf(Number(date.slice(0, 4))).get(date),
+        isBusinessDay: (date) => !closed.has(weekday(date)) && !holidaysOf(Number(date.slice(0, 4))).has(date),
+    };
+};
+const businessCache = new WeakMap();
+/** Memoize by pinned calendar object: distinct releases can reuse a calendar label/version. */
+export const businessDaysAfter = (date, days, calendar) => {
+    let cache = businessCache.get(calendar);
+    if (!cache)
+        businessCache.set(calendar, (cache = new Map()));
+    const key = `${date}|${days}`;
+    const hit = cache.get(key);
+    if (hit)
+        return hit;
+    let cursor = date;
+    let counted = 0;
+    const skipped = [];
+    while (counted < days) {
+        cursor = addDays(cursor, 1);
+        if (calendar.isBusinessDay(cursor))
+            counted++;
+        else {
+            const holiday = calendar.holiday(cursor);
+            if (holiday)
+                skipped.push({ date: cursor, why: holiday });
+        }
+    }
+    const result = { date: cursor, skipped };
+    cache.set(key, result);
+    return result;
+};
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+const DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+const formatted = new Map();
+export const formatDate = (date, withWeekday = true) => {
+    if (date.length > 10 && isInstant(date))
+        return `${formatDate(date.slice(0, 10), withWeekday)} at ${date.slice(11, 23)} UTC`;
+    const key = `${date}|${withWeekday}`;
+    let text = formatted.get(key);
+    if (text === undefined) {
+        text = `${withWeekday ? `${DAYS[weekday(date)]}, ` : ""}${MONTHS[Number(date.slice(5, 7)) - 1]} ${Number(date.slice(8, 10))}, ${date.slice(0, 4)}`;
+        formatted.set(key, text);
+    }
+    return text;
+};