@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/src/library/configuration.js

@@ -0,0 +1,97 @@
+import { gateWord } from "../core/facts/types.js";
+import { SettingsError } from "../settings.js";
+export { SettingsError };
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function namespaceFailure(view) {
+    if (view.kind !== "failed")
+        throw new Error("settings namespace failure expected");
+    throw new SettingsError(view.failures.map((failure) => `${failure.scope}: ${failure.diagnostic}`).join("; "));
+}
+export function gatesFrom(input) {
+    if (!record(input))
+        throw new TypeError("gatesFrom input must be an object");
+    const name = input.name ?? "default";
+    if (!gateWord(name))
+        throw new SettingsError("gate set name must match ^[a-z][a-z0-9-]{0,63}$");
+    const view = input.settings.namespace("gates");
+    if (view.kind === "failed")
+        namespaceFailure(view);
+    const selected = view.entries.find((entry) => entry.name === name);
+    if (selected === undefined) {
+        if (input.name === undefined)
+            return Object.freeze([]);
+        throw new SettingsError(`unknown gate set: ${name}`);
+    }
+    if (!Array.isArray(selected.value))
+        throw new SettingsError(`gate set '${name}' must be an array`);
+    const values = selected.value.map((value) => {
+        if (!gateWord(value))
+            throw new SettingsError(`gate set '${name}' contains an invalid gate word`);
+        return value;
+    });
+    if (new Set(values).size !== values.length)
+        throw new SettingsError(`gate set '${name}' contains duplicate gates`);
+    return Object.freeze(values);
+}
+function command(value, coordinate, ErrorType) {
+    if (!record(value))
+        throw new ErrorType(`${coordinate} must be an object`);
+    for (const key of Object.keys(value)) {
+        if (key !== "argv" && key !== "timeoutMs")
+            throw new ErrorType(`${coordinate} has unknown field: ${key}`);
+    }
+    if (!Array.isArray(value.argv) || value.argv.length === 0 || !value.argv.every((item) => typeof item === "string")) {
+        throw new ErrorType(`${coordinate}.argv must be a nonempty string array`);
+    }
+    if (value.argv[0].trim().length === 0)
+        throw new ErrorType(`${coordinate}.argv[0] must be nonblank`);
+    if (!Number.isSafeInteger(value.timeoutMs) || value.timeoutMs < 1 || value.timeoutMs > 2_147_483_647) {
+        throw new ErrorType(`${coordinate}.timeoutMs must be an integer from 1 through 2147483647`);
+    }
+    return Object.freeze({ argv: Object.freeze([...value.argv]), timeoutMs: value.timeoutMs });
+}
+function commands(value, coordinate, ErrorType) {
+    if (!Array.isArray(value))
+        throw new ErrorType(`${coordinate} must be an array`);
+    return Object.freeze(value.map((item, index) => command(item, `${coordinate}[${index}]`, ErrorType)));
+}
+export function requireBranchesToBeUpToDateFrom(input) {
+    if (!record(input))
+        throw new TypeError("requireBranchesToBeUpToDateFrom input must be an object");
+    const view = input.settings.namespace("git");
+    if (view.kind === "failed")
+        namespaceFailure(view);
+    for (const entry of view.entries) {
+        if (entry.name !== "requireBranchesToBeUpToDate") {
+            throw new SettingsError(`git has unknown entry: ${entry.name}`);
+        }
+    }
+    const selected = view.entries.find((entry) => entry.name === "requireBranchesToBeUpToDate");
+    if (selected === undefined)
+        return false;
+    if (typeof selected.value !== "boolean") {
+        throw new SettingsError("git.requireBranchesToBeUpToDate must be a boolean");
+    }
+    return selected.value;
+}
+export function normalizedWorktreeHooks(value) {
+    if (!record(value))
+        throw new TypeError("hooks must be an object");
+    for (const key of Object.keys(value)) {
+        if (key !== "create" && key !== "destroy")
+            throw new TypeError(`hooks has unknown field: ${key}`);
+    }
+    return Object.freeze({
+        create: commands(value.create, "hooks.create", TypeError),
+        destroy: commands(value.destroy, "hooks.destroy", TypeError),
+    });
+}
+export const EMPTY_WORKTREE_HOOKS = Object.freeze({
+    create: Object.freeze([]),
+    destroy: Object.freeze([]),
+});
+export function worktreeHooksOption(value) {
+    return value === undefined ? EMPTY_WORKTREE_HOOKS : normalizedWorktreeHooks(value);
+}

package/build/src/library/contract.d.ts

@@ -0,0 +1,120 @@
+import { type ContractFileEffect, type ContractFileLag } from "../contract-worktree.js";
+import { type RegionObservation, type RegionOverlap } from "./region.js";
+import { type Gate, type WorktreeHooks } from "./configuration.js";
+import { type ChangeId, type ContractId, type ContractState, type JournalEntry, type SnapshotId } from "../core/facts/types.js";
+export { AuthorityCorruptionError } from "../core/facts/errors.js";
+import { type AuditReport, type ContractBoard, type ContractDisposition, type ContractGateCurrent, type ContractGateReport, type ContractObservation, type ContractPhase, type ContractRow, type FactKind, type PlacementStop, type ReconcileReport as ProtocolReconcileReport, type RepositoryScope, type ReviewValue, type TimelineEntry, type VerificationStop } from "../protocol/operations.js";
+import { type SettlementReport } from "../settlement/settle.js";
+import { type TaskId } from "../task/identity.js";
+import { Repo, type ReconcileInput } from "./repo.js";
+import { Delivery } from "./delivery.js";
+import { type MutationResult } from "./mutation.js";
+export { KeiyakuRefused, KeiyakuRetry, type ContractAppointmentRefusal, type KeiyakuRefusal, type KeiyakuRetryReason, } from "./refusal.js";
+export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError } from "./configuration.js";
+export type { Gate, GatesFromInput, HookCommand, RequireBranchesToBeUpToDateFromInput, WorktreeHooks } from "./configuration.js";
+export type { AuditReport, ChangeId, ContractId, ContractState, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractObservation, ContractPhase, ContractRow, FactKind, SnapshotId, TimelineEntry, };
+export type { TaskId };
+export type { RegionOverlap };
+export type Fact = JournalEntry;
+export type ActorId = string;
+export type AttestationVerdict = "satisfied" | "unsatisfied";
+export type Review = ReviewValue;
+export type { PlacementStop, VerificationStop };
+export type TopologyEffect = ProtocolReconcileReport["effects"][number] | ContractFileEffect;
+export type Lag = ProtocolReconcileReport["lag"][number] | ContractFileLag;
+export type { MutationResult };
+export { Delivery };
+export type BindResult = Readonly<Omit<MutationResult<Keiyaku>, "value"> & {
+    keiyaku: Keiyaku;
+} & RegionObservation>;
+export type AmendResult = Readonly<MutationResult<void> & RegionObservation & {
+    documentDiff: string;
+}>;
+export type ReconcileReport = Readonly<{
+    effects: readonly TopologyEffect[];
+    lag: readonly Lag[];
+    settlement: SettlementReport;
+}>;
+export type { SettlementAction, SettlementLag, SettlementReport } from "../settlement/settle.js";
+export type BindInput = Readonly<{
+    repo: Repo;
+    markdown: string;
+    task?: TaskId;
+    target?: string;
+    workspace?: "worktree" | "here";
+    actor?: ActorId;
+    after?: readonly ContractId[];
+    gates?: readonly Gate[];
+    hooks?: WorktreeHooks;
+}>;
+export type AmendInput = Readonly<{
+    markdown: string;
+    actor?: ActorId;
+    after?: readonly ContractId[];
+    gates?: readonly Gate[];
+    hooks?: WorktreeHooks;
+}>;
+export type ArcInput = Readonly<{
+    markdown: string;
+    actor?: ActorId;
+    hooks?: WorktreeHooks;
+}>;
+type HookOptions = Readonly<{
+    hooks?: WorktreeHooks;
+}>;
+type ActorOptions = Readonly<{
+    actor?: ActorId;
+}> & HookOptions;
+export type ContractListInput = Readonly<{
+    repo: Repo;
+}>;
+export type ContractObservationInput = Readonly<{
+    repo: Repo;
+    id: ContractId;
+}>;
+export type KeiyakuOfInput = Readonly<{
+    repo: Repo;
+    id: ContractId;
+}>;
+export type ReviewInput = ActorOptions & Readonly<{
+    verdict: AttestationVerdict;
+    summary?: string;
+}>;
+export type AbandonInput = ActorOptions & Readonly<{
+    note?: string;
+}>;
+export type DeliverInput = ActorOptions & Readonly<{
+    message?: string;
+    requireBranchesToBeUpToDate?: boolean;
+    includeDirty?: boolean;
+    signal?: AbortSignal;
+}>;
+export type AuditInput = ActorOptions & Readonly<{
+    signal?: AbortSignal;
+}>;
+export declare class KeiyakuHandle {
+    private readonly id;
+    private readonly scope;
+    constructor(id: ContractId, scope: RepositoryScope);
+    state(): Promise<ContractState>;
+    guidance(): Promise<string>;
+    delivery(): Promise<Delivery | null>;
+    amend(input: AmendInput): Promise<AmendResult>;
+    deliver(input?: DeliverInput): Promise<MutationResult<Delivery>>;
+    review(input: ReviewInput): Promise<MutationResult<Review>>;
+    abandon(input?: AbandonInput): Promise<MutationResult<void>>;
+    arc(input: ArcInput): Promise<MutationResult<void>>;
+    audit(input?: AuditInput): Promise<MutationResult<AuditReport>>;
+    reconcile(input?: ReconcileInput): Promise<ReconcileReport>;
+    private deliveryHandle;
+}
+/** Internal package composition capability; not exported from the package root. */
+export declare function seatForKeiyaku(value: unknown): Readonly<{
+    id: ContractId;
+    scope: RepositoryScope;
+}>;
+export type Keiyaku = KeiyakuHandle;
+export declare function keiyakuOf(input: KeiyakuOfInput): Keiyaku;
+export declare function listKeiyaku(input: ContractListInput): Promise<ContractBoard>;
+export declare function observeKeiyaku(input: ContractObservationInput): Promise<ContractObservation>;
+export declare function bindKeiyaku(input: BindInput): Promise<BindResult>;

package/build/src/library/contract.js

@@ -0,0 +1,335 @@
+import { documentDiff } from "../markdown/diff.js";
+import { applyAmendDocument } from "../body/amend.js";
+import { decodeArcDocument } from "../body/arc.js";
+import { decodeContractDocument } from "../body/decode.js";
+import { projectContractWorktree, renderContractGuidance, } from "../contract-worktree.js";
+import { actorOption, contractTerms, documentDerivation, normalizedGates, normalizedList, optionalBoolean, optionalNonblank, optionalSignal, requireInput, requireMarkdown, } from "./input.js";
+import { observeRegion } from "./region.js";
+import { worktreeHooksOption } from "./configuration.js";
+import { contractId, } from "../core/facts/types.js";
+export { AuthorityCorruptionError } from "../core/facts/errors.js";
+import { abandonOperation, amendOperation, arcOperation, auditOperation, contractObservationOperation, contractsOperation, deliveryDiffOperation, deliverOperation, deliveryOperation, reconcileOperation, reviewOperation, stateOperation, } from "../protocol/operations.js";
+import { withGitDecodeChannel } from "../git/read-observation.js";
+import { settle } from "../settlement/settle.js";
+import { claimTaskHolderWithFence, releaseTaskHolder, releaseTaskHolderWithFence, taskHolderObservationSelection, } from "../settlement/holder.js";
+import { parseTaskId } from "../task/identity.js";
+import { reconcileInput, scopeForRepo } from "./repo.js";
+import { Delivery, deliveryHandle } from "./delivery.js";
+import { completeHolderMutation, completeMutation, } from "./mutation.js";
+import { admitBindWithAppointment } from "./bind.js";
+import { KeiyakuRefused, requireAccepted } from "./refusal.js";
+export { KeiyakuRefused, KeiyakuRetry, } from "./refusal.js";
+export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError } from "./configuration.js";
+export { Delivery };
+function taskOption(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string")
+        throw new TypeError("task must be a TaskId");
+    try {
+        parseTaskId(value);
+    }
+    catch (error) {
+        throw new TypeError(error instanceof Error ? error.message : "task must be a TaskId");
+    }
+    return value;
+}
+function completion(scope, channel, id, value, hooks) {
+    return { scope, channel, contractId: id, value, hooks };
+}
+export class KeiyakuHandle {
+    id;
+    scope;
+    constructor(id, scope) {
+        this.id = id;
+        this.scope = scope;
+        KEIYAKU_SEATS.set(this, { id, scope });
+    }
+    async state() {
+        return withGitDecodeChannel(this.scope, (channel) => stateOperation({
+            scope: this.scope,
+            channel,
+            contractId: this.id,
+        }));
+    }
+    async guidance() {
+        return withGitDecodeChannel(this.scope, async (channel) => {
+            const observed = await contractObservationOperation({ scope: this.scope, channel, contractId: this.id });
+            if (observed.kind === "missing")
+                throw new KeiyakuRefused({ kind: "contract-missing", contractId: this.id });
+            return renderContractGuidance(await stateOperation({ scope: this.scope, channel, contractId: this.id }));
+        });
+    }
+    async delivery() {
+        const delivery = await withGitDecodeChannel(this.scope, (channel) => deliveryOperation({
+            scope: this.scope,
+            channel,
+            contractId: this.id,
+        }));
+        return delivery === null
+            ? null
+            : this.deliveryHandle(delivery);
+    }
+    async amend(input) {
+        const values = requireInput(input, "amend input");
+        const hooks = worktreeHooksOption(values.hooks);
+        const markdown = requireMarkdown(values.markdown);
+        const actor = actorOption(values.actor);
+        const gates = values.gates === undefined ? undefined : normalizedGates(values.gates);
+        const prerequisites = values.after === undefined
+            ? undefined
+            : normalizedList(values.after, "after", contractId);
+        return withGitDecodeChannel(this.scope, async (channel) => {
+            const accepted = requireAccepted(await amendOperation({
+                scope: this.scope,
+                channel,
+                contractId: this.id,
+                ...actor,
+                deriveAmendment: (source) => {
+                    const document = decodeContractDocument(applyAmendDocument(markdown, decodeContractDocument(source.document.bytes)));
+                    const terms = contractTerms(document, gates ?? source.gates, prerequisites ?? source.after);
+                    return {
+                        terms,
+                        verification: documentDerivation(document, terms.gates, this.id).verification,
+                    };
+                },
+            }));
+            const document = decodeContractDocument(accepted.value.terms.document.bytes);
+            return {
+                ...await completeMutation({
+                    ...completion(this.scope, channel, this.id, () => undefined, hooks),
+                    accepted,
+                }),
+                documentDiff: documentDiff("before", "after", accepted.value.source.document.bytes, accepted.value.terms.document.bytes),
+                ...await observeRegion(this.scope, channel, this.id, document.region),
+            };
+        });
+    }
+    async deliver(input) {
+        const values = input === undefined ? undefined : requireInput(input, "deliver input");
+        const hooks = worktreeHooksOption(values?.hooks);
+        const message = optionalNonblank(values?.message, "deliver message");
+        const requireBranchesToBeUpToDate = optionalBoolean(values?.requireBranchesToBeUpToDate, "requireBranchesToBeUpToDate") ?? false;
+        const includeDirty = optionalBoolean(values?.includeDirty, "includeDirty") ?? false;
+        const actor = actorOption(values?.actor);
+        const signal = optionalSignal(values?.signal);
+        return withGitDecodeChannel(this.scope, async (channel) => {
+            const accepted = requireAccepted(await deliverOperation({
+                scope: this.scope,
+                channel,
+                contractId: this.id,
+                deriveDocument: (state) => documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id),
+                ...actor,
+                ...(message === undefined ? {} : { message }),
+                requireBranchesToBeUpToDate,
+                includeDirty,
+                ...(signal === undefined ? {} : { signal }),
+            }));
+            return completeMutation({
+                ...completion(this.scope, channel, this.id, (delivery) => this.deliveryHandle(delivery), hooks),
+                accepted,
+            });
+        });
+    }
+    async review(input) {
+        const values = requireInput(input, "review input");
+        const hooks = worktreeHooksOption(values.hooks);
+        const verdict = values.verdict;
+        if (verdict !== "satisfied" && verdict !== "unsatisfied") {
+            throw new TypeError("verdict must be satisfied or unsatisfied");
+        }
+        const summary = optionalNonblank(values.summary, "review summary");
+        return withGitDecodeChannel(this.scope, async (channel) => {
+            const accepted = requireAccepted(await reviewOperation({
+                scope: this.scope,
+                channel,
+                contractId: this.id,
+                verdict,
+                ...(summary === undefined ? {} : { summary }),
+                ...actorOption(values.actor),
+            }));
+            return completeMutation({
+                ...completion(this.scope, channel, this.id, (value) => value, hooks),
+                accepted,
+            });
+        });
+    }
+    async abandon(input) {
+        const values = input === undefined ? undefined : requireInput(input, "abandon input");
+        const hooks = worktreeHooksOption(values?.hooks);
+        const note = optionalNonblank(values?.note, "abandon note");
+        return withGitDecodeChannel(this.scope, async (channel) => {
+            const admission = await releaseTaskHolderWithFence(this.scope, channel, this.id, () => abandonOperation({
+                scope: this.scope,
+                channel,
+                contractId: this.id,
+                ...actorOption(values?.actor),
+                ...(note === undefined ? {} : { note }),
+                observationSelection: taskHolderObservationSelection(),
+                decorateOffer: async ({ observation, contractId: owner }) => {
+                    const companion = await releaseTaskHolder(channel, observation, owner);
+                    return companion === null ? [] : [companion];
+                },
+            }));
+            return completeHolderMutation({
+                completion: completion(this.scope, channel, this.id, () => undefined, hooks),
+                admission,
+                requireAccepted,
+            });
+        });
+    }
+    async arc(input) {
+        const values = requireInput(input, "arc input");
+        const hooks = worktreeHooksOption(values.hooks);
+        const chapter = decodeArcDocument(requireMarkdown(values.markdown));
+        return withGitDecodeChannel(this.scope, async (channel) => {
+            const accepted = requireAccepted(await arcOperation({
+                scope: this.scope,
+                channel,
+                contractId: this.id,
+                ...actorOption(values.actor),
+                chapter,
+            }));
+            return completeMutation({
+                ...completion(this.scope, channel, this.id, () => undefined, hooks),
+                accepted,
+            });
+        });
+    }
+    async audit(input) {
+        const values = input === undefined ? undefined : requireInput(input, "audit input");
+        const hooks = worktreeHooksOption(values?.hooks);
+        const actor = actorOption(values?.actor);
+        const signal = optionalSignal(values?.signal);
+        return withGitDecodeChannel(this.scope, async (channel) => {
+            const accepted = requireAccepted(await auditOperation({
+                scope: this.scope,
+                channel,
+                contractId: this.id,
+                deriveDocument: (state) => documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id),
+                ...(signal === undefined ? {} : { signal }),
+                ...actor,
+            }));
+            return completeMutation({
+                ...completion(this.scope, channel, this.id, (report) => report, hooks),
+                accepted,
+            });
+        });
+    }
+    async reconcile(input) {
+        const options = reconcileInput(input);
+        return withGitDecodeChannel(this.scope, async (channel) => {
+            const retained = await reconcileOperation({ scope: this.scope, channel, contractId: this.id, ...options, retainTerminalWorktree: true });
+            const projection = projectContractWorktree(this.scope, retained.state);
+            const settlement = await settle({ repository: this.scope, channel, state: retained.state, effects: retained.report.effects });
+            const deferRemoval = retained.state !== null && retained.state.terminal !== null
+                && retained.state.coordinates.workspace === "worktree";
+            const cleanup = deferRemoval
+                ? await reconcileOperation({ scope: this.scope, channel, contractId: this.id, ...options })
+                : null;
+            return {
+                effects: [...retained.report.effects, ...projection.effects, ...(cleanup?.report.effects ?? [])],
+                lag: [...retained.report.lag, ...projection.lag, ...(cleanup?.report.lag ?? [])],
+                settlement,
+            };
+        });
+    }
+    deliveryHandle(delivery) {
+        return deliveryHandle(delivery, () => deliveryDiffOperation({
+            scope: this.scope,
+            integrationPredecessor: delivery.integration.predecessor,
+            integrationSnapshot: delivery.integration.snapshot,
+        }));
+    }
+}
+const KEIYAKU_SEATS = new WeakMap();
+/** Internal package composition capability; not exported from the package root. */
+export function seatForKeiyaku(value) {
+    if (!(value instanceof KeiyakuHandle))
+        throw new TypeError("contract must be a Keiyaku");
+    const seat = KEIYAKU_SEATS.get(value);
+    if (seat === undefined)
+        throw new TypeError("contract must be a Keiyaku");
+    return seat;
+}
+export function keiyakuOf(input) {
+    const values = requireInput(input, "Keiyaku.of input");
+    const scope = scopeForRepo(values.repo);
+    if (typeof values.id !== "string")
+        throw new TypeError("contract ID must be a string");
+    return new KeiyakuHandle(contractId(values.id), scope);
+}
+export async function listKeiyaku(input) {
+    const values = requireInput(input, "Keiyaku.list input");
+    for (const key of Object.keys(values))
+        if (key !== "repo")
+            throw new TypeError(`Keiyaku.list input has unknown field: ${key}`);
+    const scope = scopeForRepo(values.repo);
+    return withGitDecodeChannel(scope, (channel) => contractsOperation({ scope, channel }));
+}
+export async function observeKeiyaku(input) {
+    const values = requireInput(input, "Keiyaku.observe input");
+    for (const key of Object.keys(values))
+        if (key !== "repo" && key !== "id")
+            throw new TypeError(`Keiyaku.observe input has unknown field: ${key}`);
+    const scope = scopeForRepo(values.repo);
+    if (typeof values.id !== "string")
+        throw new TypeError("contract ID must be a string");
+    let id;
+    try {
+        id = contractId(values.id);
+    }
+    catch (error) {
+        throw new TypeError(error instanceof Error ? error.message : "contract ID is invalid");
+    }
+    return withGitDecodeChannel(scope, (channel) => contractObservationOperation({ scope, channel, contractId: id }));
+}
+export async function bindKeiyaku(input) {
+    const values = requireInput(input, "Keiyaku.bind input");
+    const hooks = worktreeHooksOption(values.hooks);
+    const scope = scopeForRepo(values.repo);
+    const markdown = requireMarkdown(values.markdown);
+    const task = taskOption(values.task);
+    const document = decodeContractDocument(markdown);
+    const workspace = values.workspace === undefined ? "worktree" : values.workspace;
+    if (workspace !== "worktree" && workspace !== "here")
+        throw new TypeError("workspace must be worktree or here");
+    const target = values.target;
+    if (target !== undefined && typeof target !== "string")
+        throw new TypeError("target must be a string");
+    const actor = actorOption(values.actor);
+    const terms = contractTerms(document, normalizedGates(values.gates), normalizedList(values.after, "after", contractId));
+    return withGitDecodeChannel(scope, async (channel) => {
+        const admitCandidate = () => admitBindWithAppointment({
+            scope,
+            channel,
+            title: document.title,
+            terms,
+            verification: documentDerivation(document, terms.gates).verification,
+            workspace,
+            ...(target === undefined ? {} : { target }),
+            ...(task === undefined ? {} : { task }),
+            ...actor,
+        });
+        const admission = task === undefined ? null : await claimTaskHolderWithFence(scope, task, admitCandidate);
+        const accepted = requireAccepted(admission === null ? await admitCandidate() : admission.result);
+        const id = accepted.value.contractId;
+        const toHandle = ({ contractId: contract }) => new KeiyakuHandle(contract, scope);
+        const result = admission === null
+            ? await completeMutation({ ...completion(scope, channel, id, toHandle, hooks), accepted })
+            : await completeHolderMutation({
+                completion: completion(scope, channel, id, toHandle, hooks),
+                admission,
+                requireAccepted,
+            });
+        return {
+            facts: result.facts,
+            head: result.head,
+            keiyaku: result.value,
+            effects: result.effects,
+            lags: result.lags,
+            settlement: result.settlement,
+            ...await observeRegion(scope, channel, id, document.region),
+        };
+    });
+}

package/build/src/library/delivery.d.ts

@@ -0,0 +1,23 @@
+import type { SnapshotId } from "../core/facts/types.js";
+import type { DeliverValue } from "../protocol/operations.js";
+declare class DeliveryHandle {
+    private readonly readDiff;
+    readonly verification?: DeliverValue["verification"];
+    readonly placement?: DeliverValue["placement"];
+    readonly cleanup?: DeliverValue["cleanup"];
+    readonly leak?: DeliverValue["leak"];
+    readonly tenderSnapshot: SnapshotId;
+    readonly integration: DeliverValue["integration"];
+    readonly method: DeliverValue["method"];
+    readonly policy: DeliverValue["policy"];
+    constructor(identity: Pick<DeliverValue, "tenderSnapshot" | "integration" | "method" | "policy">, readDiff: () => Promise<string | null>, outcomes?: Partial<Pick<DeliverValue, "verification" | "placement" | "cleanup" | "leak">>);
+    diff(): Promise<string | null>;
+}
+export type Delivery = DeliveryHandle;
+type HandleType<T extends object> = Readonly<{
+    prototype: T;
+    [Symbol.hasInstance](value: unknown): boolean;
+}>;
+export declare const Delivery: HandleType<DeliveryHandle>;
+export declare function deliveryHandle(delivery: DeliverValue, readDiff: () => Promise<string | null>): Delivery;
+export {};

package/build/src/library/delivery.js

@@ -0,0 +1,21 @@
+class DeliveryHandle {
+    readDiff;
+    constructor(identity, readDiff, outcomes = {}) {
+        this.readDiff = readDiff;
+        this.tenderSnapshot = identity.tenderSnapshot;
+        this.integration = identity.integration;
+        this.method = identity.method;
+        this.policy = identity.policy;
+        Object.assign(this, outcomes);
+    }
+    diff() {
+        return this.readDiff();
+    }
+}
+export const Delivery = Object.freeze({
+    prototype: DeliveryHandle.prototype,
+    [Symbol.hasInstance]: (value) => value instanceof DeliveryHandle,
+});
+export function deliveryHandle(delivery, readDiff) {
+    return new DeliveryHandle(delivery, readDiff, delivery);
+}

package/build/src/library/fleet.d.ts

@@ -0,0 +1,65 @@
+import { type ActivityHistory, type AkumaStatus, type InterruptReceipt, type KillEvidence, type TellResult } from "../akuma/index.js";
+import type { ContractId } from "../core/facts/types.js";
+import { type AkumaAddressInput, type AkumaSetAddressInput } from "./address.js";
+export type AkumaWaitInput = AkumaSetAddressInput & Readonly<{
+    completion?: "any" | "all";
+    timeoutMs?: number;
+}>;
+export type AkumaWaitResult = Readonly<{
+    completion: "any" | "all";
+    statuses: readonly AkumaStatusView[];
+}>;
+export type AkumaStatusView = Readonly<{
+    status: AkumaStatus;
+    contractId?: ContractId;
+}>;
+export type AkumaKillResult = Readonly<{
+    results: readonly Readonly<{
+        id: AkumaStatus["id"];
+        evidence: KillEvidence;
+        observation: AkumaStatusView;
+    }>[];
+}>;
+export type AkumaTellInput = AkumaAddressInput & Readonly<{
+    body: string;
+}>;
+export type AkumaTellResult = Readonly<{
+    akuma: AkumaStatus["id"];
+    tell: TellResult;
+    observation: AkumaStatusView;
+}>;
+export type AkumaInterruptInput = AkumaAddressInput & Readonly<{
+    body: string;
+}>;
+export type AkumaInterruptResult = Readonly<{
+    id: AkumaStatus["id"];
+    receipt: InterruptReceipt;
+    observation: AkumaStatusView;
+}>;
+export type AkumaHistoryInput = AkumaAddressInput & Readonly<{
+    before?: number;
+    since?: number;
+    limit?: number;
+    last?: boolean;
+}>;
+export type AkumaHistoryResult = Readonly<{
+    kind: "history";
+    id: AkumaStatus["id"];
+    history: ActivityHistory;
+    contractId?: ContractId;
+}> | Readonly<{
+    kind: "last";
+    id: AkumaStatus["id"];
+    answer: string;
+    contractId?: ContractId;
+}> | Readonly<{
+    kind: "no-answer";
+    id: AkumaStatus["id"];
+    contractId?: ContractId;
+}>;
+export declare function statusAkuma(input: AkumaAddressInput): AkumaStatusView;
+export declare function waitAkuma(input: AkumaWaitInput): Promise<AkumaWaitResult>;
+export declare function killAkuma(input: AkumaSetAddressInput): Promise<AkumaKillResult>;
+export declare function tellAkuma(input: AkumaTellInput): Promise<AkumaTellResult>;
+export declare function interruptAkuma(input: AkumaInterruptInput): Promise<AkumaInterruptResult>;
+export declare function historyAkuma(input: AkumaHistoryInput): AkumaHistoryResult;