@astrosheep/keiyaku 4.5.11 → 4.5.13

package/build/src/plugin/akuma-signals.js

@@ -0,0 +1,14 @@
+import { pluginRuntime } from "./runtime.js";
+export async function emitCalledPluginSignal(input) {
+    const runtime = await pluginRuntime({
+        world: input.world,
+        ...(input.settings === undefined ? {} : { settings: input.settings }),
+        reportDiagnostic: input.reportDiagnostic,
+    });
+    runtime.emit({
+        kind: "akuma.called",
+        akumaId: input.akumaId,
+        ...(input.callerAkumaId === undefined ? {} : { callerAkumaId: input.callerAkumaId }),
+        ...(input.contractId === undefined ? {} : { contractId: input.contractId }),
+    }, input.reportDiagnostic);
+}

package/build/src/plugin/public.d.ts

@@ -0,0 +1,51 @@
+import type { WorldRoot } from "../world.js";
+export type PluginManifest = Readonly<{
+    id: string;
+    apiVersion: 1;
+    writablePaths?: readonly Readonly<{
+        name: string;
+        path: string;
+    }>[];
+}>;
+export type PluginOutcome = Readonly<{
+    kind: "answered";
+    text: string;
+}> | Readonly<{
+    kind: "failed";
+    reason: string;
+}>;
+export type PluginSignalMap = Readonly<{
+    "akuma.called": Readonly<{
+        akumaId: string;
+        callerAkumaId?: string;
+        contractId?: string;
+    }>;
+    "akuma.turn-outcome": Readonly<{
+        akumaId: string;
+        turnSequence: number;
+        outcome: PluginOutcome;
+        contractId?: string;
+    }>;
+}>;
+export type PluginSignal = {
+    [K in keyof PluginSignalMap]: Readonly<{
+        kind: K;
+    }> & PluginSignalMap[K];
+}[keyof PluginSignalMap];
+export type PluginHooks = Readonly<{
+    [K in keyof PluginSignalMap]?: (signal: Readonly<{
+        kind: K;
+    }> & PluginSignalMap[K]) => Promise<void> | void;
+}>;
+export type PluginContext = Readonly<{
+    world: WorldRoot;
+    config: unknown;
+    writablePath(name: string): string;
+}>;
+export type KeiyakuPlugin = Readonly<{
+    manifest: PluginManifest;
+    activate(context: PluginContext): Promise<PluginInstance> | PluginInstance;
+}>;
+export type PluginInstance = Readonly<{
+    signals?: PluginHooks;
+}>;

package/build/src/plugin/public.js

@@ -0,0 +1 @@
+export {};

package/build/src/plugin/runtime.d.ts

@@ -0,0 +1,14 @@
+import { type Settings } from "../settings.js";
+import type { WorldRoot } from "../world.js";
+import type { PluginSignal } from "./public.js";
+type PluginDiagnostic = (diagnostic: string) => void;
+type PluginRuntimeInput = Readonly<{
+    world: WorldRoot;
+    settings?: Settings;
+    reportDiagnostic?: PluginDiagnostic;
+}>;
+export type PluginRuntime = Readonly<{
+    emit(signal: PluginSignal, reportDiagnostic?: PluginDiagnostic): Promise<void>;
+}>;
+export declare function pluginRuntime(input: PluginRuntimeInput): Promise<PluginRuntime>;
+export {};

package/build/src/plugin/runtime.js

@@ -0,0 +1,357 @@
+import { lstat, mkdir, realpath } from "node:fs/promises";
+import { registerHooks } from "node:module";
+import { isAbsolute, join, posix, relative, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import { settings } from "../settings.js";
+const DIAGNOSTIC_LIMIT = 500;
+const PLUGIN_NAMESPACE = "plugins";
+const SQUARE_PLUGIN_PACKAGE = "@astrosheep/keiyaku-plugin-square";
+const BUILTIN_PLUGINS = Object.freeze([
+    Object.freeze({ id: "square", package: SQUARE_PLUGIN_PACKAGE, config: undefined }),
+]);
+const PROCESS_RUNTIMES = new Map();
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function message(error) {
+    return (error instanceof Error ? error.message : String(error)).slice(0, DIAGNOSTIC_LIMIT);
+}
+function diagnostic(report, subject, stage, error) {
+    if (report === undefined)
+        return;
+    try {
+        report(`plugin ${subject} ${stage}: ${message(error)}`.slice(0, DIAGNOSTIC_LIMIT));
+    }
+    catch {
+        // Diagnostics are optional side effects too.
+    }
+}
+function selectedEntry(entry, report) {
+    if (entry.name.trim().length === 0) {
+        diagnostic(report, "<unnamed>", "selection", new TypeError("plugin setting name must be nonblank"));
+        return null;
+    }
+    if (!object(entry.value)) {
+        diagnostic(report, entry.name, "selection", new TypeError("plugin setting must be an object"));
+        return null;
+    }
+    const names = Object.keys(entry.value);
+    if (!names.includes("package") || names.some((name) => !["package", "enabled", "config"].includes(name))) {
+        diagnostic(report, entry.name, "selection", new TypeError("plugin setting has unknown or missing fields"));
+        return null;
+    }
+    const packageName = entry.value.package;
+    if (typeof packageName !== "string" || packageName.trim().length === 0) {
+        diagnostic(report, entry.name, "selection", new TypeError("plugin package must be a nonblank string"));
+        return null;
+    }
+    if (packageName !== packageName.trim()) {
+        diagnostic(report, entry.name, "selection", new TypeError("plugin package must not have surrounding whitespace"));
+        return null;
+    }
+    const enabled = entry.value.enabled;
+    if (enabled !== undefined && typeof enabled !== "boolean") {
+        diagnostic(report, entry.name, "selection", new TypeError("plugin enabled must be a boolean"));
+        return null;
+    }
+    if (enabled === false)
+        return null;
+    return Object.freeze({ id: entry.name, package: packageName, config: entry.value.config });
+}
+function selectedPlugins(input, report) {
+    const view = input.namespace(PLUGIN_NAMESPACE);
+    if (view.kind === "failed") {
+        for (const failure of view.failures)
+            diagnostic(report, "settings", failure.scope, failure.diagnostic);
+        return BUILTIN_PLUGINS;
+    }
+    if (view.entries.length === 0)
+        return BUILTIN_PLUGINS;
+    const configured = new Map(view.entries
+        .map((entry) => [entry.name, selectedEntry(entry, report)])
+        .filter((entry) => entry[1] !== null));
+    const disabled = new Set(view.entries.filter((entry) => object(entry.value) && entry.value.enabled === false).map((entry) => entry.name));
+    const selected = [
+        ...BUILTIN_PLUGINS.filter((entry) => !configured.has(entry.id) && !disabled.has(entry.id)),
+        ...configured.values(),
+    ]
+        .filter((entry) => entry !== null)
+        .sort((left, right) => left.id.localeCompare(right.id));
+    return Object.freeze(selected);
+}
+function manifest(value) {
+    if (!object(value))
+        throw new TypeError("plugin default export must be an object");
+    if (!object(value.manifest))
+        throw new TypeError("plugin manifest must be an object");
+    const candidate = value.manifest;
+    const names = Object.keys(candidate);
+    if (names.some((name) => !["id", "apiVersion", "writablePaths"].includes(name))) {
+        throw new TypeError("plugin manifest has unknown fields");
+    }
+    if (typeof candidate.id !== "string" || candidate.id.trim().length === 0) {
+        throw new TypeError("plugin manifest id must be nonblank");
+    }
+    if (candidate.apiVersion !== 1)
+        throw new TypeError("plugin apiVersion must equal 1");
+    if (candidate.writablePaths !== undefined && !Array.isArray(candidate.writablePaths)) {
+        throw new TypeError("plugin writablePaths must be an array");
+    }
+    if (typeof value.activate !== "function")
+        throw new TypeError("plugin activate must be a function");
+    return value;
+}
+function writablePathDeclaration(value, names) {
+    if (!object(value))
+        throw new TypeError("plugin writable path must be an object");
+    if (Object.keys(value).some((name) => name !== "name" && name !== "path")) {
+        throw new TypeError("plugin writable path has unknown fields");
+    }
+    if (typeof value.name !== "string" || value.name.trim().length === 0) {
+        throw new TypeError("plugin writable path name must be nonblank");
+    }
+    if (names.has(value.name))
+        throw new TypeError(`plugin writable path name is duplicated: ${value.name}`);
+    if (typeof value.path !== "string" || value.path.length === 0 || value.path.includes("\\")) {
+        throw new TypeError("plugin writable path must be a nonblank POSIX path");
+    }
+    if (posix.isAbsolute(value.path))
+        throw new TypeError("plugin writable path must be relative to the World");
+    const parts = value.path.split("/");
+    if (parts.some((part) => part.length === 0 || part === "." || part === ".." || part.toLowerCase() === ".keiyaku")) {
+        throw new TypeError("plugin writable path contains a reserved or traversal component");
+    }
+    names.add(value.name);
+    return Object.freeze({ name: value.name, parts: Object.freeze(parts) });
+}
+async function createTrustedPath(world, managementPath, declaration) {
+    let current = world;
+    for (const part of declaration.parts) {
+        current = join(current, part);
+        try {
+            await mkdir(current);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+        const entry = await lstat(current);
+        if (entry.isSymbolicLink())
+            throw new TypeError(`plugin writable path resolves through a symlink: ${current}`);
+        if (!entry.isDirectory())
+            throw new TypeError(`plugin writable path component is not a directory: ${current}`);
+        const resolved = await realpath(current);
+        const relation = relative(managementPath, resolved);
+        if (relation.length === 0 || (!isAbsolute(relation) && relation !== ".." && !relation.startsWith(`..${sep}`))) {
+            throw new TypeError(`plugin writable path resolves into Keiyaku management custody: ${current}`);
+        }
+    }
+    return current;
+}
+async function writablePaths(world, declarations) {
+    const names = new Set();
+    const paths = new Map();
+    const managementPath = await realpath(join(world, ".keiyaku"));
+    for (const value of declarations ?? []) {
+        const declaration = writablePathDeclaration(value, names);
+        paths.set(declaration.name, await createTrustedPath(world, managementPath, declaration));
+    }
+    return paths;
+}
+function handlers(pluginId, instance) {
+    if (!object(instance))
+        throw new TypeError("plugin activation must return an object");
+    if (Object.keys(instance).some((name) => name !== "signals"))
+        throw new TypeError("plugin instance has unknown fields");
+    if (instance.signals === undefined)
+        return [];
+    if (!object(instance.signals))
+        throw new TypeError("plugin signals must be an object");
+    const registered = [];
+    for (const [kind, handler] of Object.entries(instance.signals)) {
+        if (kind !== "akuma.called" && kind !== "akuma.turn-outcome") {
+            throw new TypeError(`plugin signal is unknown: ${kind}`);
+        }
+        if (typeof handler !== "function")
+            throw new TypeError(`plugin signal handler is not a function: ${kind}`);
+        registered.push({ pluginId, kind, handler });
+    }
+    return Object.freeze(registered);
+}
+function sourceUrl(world, packageName) {
+    if (packageName.startsWith("./")) {
+        const parts = packageName.slice(2).split("/");
+        if (parts.some((part) => part.length === 0 || part === "." || part === ".." || part.includes("\\"))) {
+            throw new TypeError("plugin source must be a World-relative POSIX path");
+        }
+        return new URL(packageName, pathToFileURL(`${world}/`)).href;
+    }
+    if (packageName.startsWith("/") || packageName.startsWith("file:") || packageName.startsWith("../")) {
+        throw new TypeError("plugin source must be a package or World-relative path");
+    }
+    return null;
+}
+async function importFromWorld(world, packageName) {
+    if (packageName === SQUARE_PLUGIN_PACKAGE)
+        return (await import(packageName));
+    const direct = sourceUrl(world, packageName);
+    if (direct !== null)
+        return (await import(direct));
+    const parentURL = pathToFileURL(join(world, "package.json")).href;
+    const request = `keiyaku-plugin:${encodeURIComponent(world)}:${encodeURIComponent(packageName)}`;
+    const hooks = registerHooks({
+        resolve(specifier, context, nextResolve) {
+            return specifier === request
+                ? nextResolve(packageName, { ...context, parentURL })
+                : nextResolve(specifier, context);
+        },
+    });
+    try {
+        return (await import(request));
+    }
+    finally {
+        hooks.deregister();
+    }
+}
+async function activate(selected, world, activated, report, onStarted) {
+    let started = false;
+    const markStarted = () => {
+        if (started)
+            return;
+        started = true;
+        onStarted();
+    };
+    let module;
+    try {
+        module = await importFromWorld(world, selected.package);
+    }
+    catch (error) {
+        markStarted();
+        diagnostic(report, selected.id, "import", error);
+        return [];
+    }
+    let candidate;
+    try {
+        candidate = manifest(module.default);
+        if (candidate.manifest.id !== selected.id) {
+            throw new TypeError(`plugin manifest id does not match selected entry: ${candidate.manifest.id}`);
+        }
+        if (activated.has(candidate.manifest.id))
+            throw new TypeError(`plugin id is duplicated: ${candidate.manifest.id}`);
+    }
+    catch (error) {
+        markStarted();
+        diagnostic(report, selected.id, "validation", error);
+        return [];
+    }
+    let context;
+    try {
+        const declared = await writablePaths(world, candidate.manifest.writablePaths);
+        context = Object.freeze({
+            world,
+            config: selected.config,
+            writablePath(name) {
+                const path = declared.get(name);
+                if (path === undefined)
+                    throw new TypeError(`plugin writable path is undeclared: ${name}`);
+                return path;
+            },
+        });
+    }
+    catch (error) {
+        markStarted();
+        diagnostic(report, selected.id, "validation", error);
+        return [];
+    }
+    markStarted();
+    try {
+        const instance = await candidate.activate(context);
+        const registered = handlers(candidate.manifest.id, instance);
+        activated.add(candidate.manifest.id);
+        return registered;
+    }
+    catch (error) {
+        diagnostic(report, selected.id, "activation", error);
+        return [];
+    }
+}
+export async function pluginRuntime(input) {
+    let runtime = PROCESS_RUNTIMES.get(input.world);
+    if (runtime === undefined) {
+        runtime = createPluginRuntime(input);
+        PROCESS_RUNTIMES.set(input.world, runtime);
+    }
+    return await runtime;
+}
+async function createPluginRuntime(input) {
+    const report = input.reportDiagnostic;
+    const selected = selectedPlugins(input.settings ?? (await settings({ root: input.world })), report);
+    const activated = new Set();
+    const registered = new Map();
+    const settled = new Set();
+    const pending = new Map();
+    const deliver = (entry, signal, reportDiagnostic) => {
+        try {
+            void Promise.resolve(entry.handler(signal)).catch((error) => diagnostic(reportDiagnostic, entry.pluginId, "signal", error));
+        }
+        catch (error) {
+            diagnostic(reportDiagnostic, entry.pluginId, "signal", error);
+        }
+    };
+    const deliverTo = (handlers, signal, reportDiagnostic) => {
+        for (const entry of handlers) {
+            if (entry.kind === signal.kind)
+                deliver(entry, signal, reportDiagnostic);
+        }
+    };
+    let previousStarted = Promise.resolve();
+    for (const [index, entry] of selected.entries()) {
+        let releaseStarted;
+        const started = new Promise((resolve) => {
+            releaseStarted = resolve;
+        });
+        void previousStarted.then(async () => {
+            try {
+                const handlers = await activate(entry, input.world, activated, report, releaseStarted);
+                if (handlers.length > 0)
+                    registered.set(index, handlers);
+                settled.add(index);
+                const queued = pending.get(index);
+                if (queued !== undefined) {
+                    pending.delete(index);
+                    for (const signal of queued)
+                        deliverTo(handlers, signal, report);
+                }
+            }
+            catch (error) {
+                diagnostic(report, entry.id, "activation", error);
+                settled.add(index);
+                pending.delete(index);
+            }
+            finally {
+                releaseStarted();
+            }
+        });
+        previousStarted = started;
+    }
+    return Object.freeze({
+        emit(signal, reportDiagnostic = report) {
+            const deliveries = [...registered.entries()]
+                .sort(([left], [right]) => left - right)
+                .flatMap(([, handlers]) => handlers)
+                .filter((handler) => handler.kind === signal.kind);
+            for (const [index] of selected.entries()) {
+                if (!settled.has(index)) {
+                    const queue = pending.get(index);
+                    if (queue === undefined)
+                        pending.set(index, [signal]);
+                    else
+                        queue.push(signal);
+                }
+            }
+            for (const entry of deliveries)
+                deliver(entry, signal, reportDiagnostic);
+            return Promise.resolve();
+        },
+    });
+}

package/build/src/protocol/amend.js

@@ -3,7 +3,7 @@ import { withPrivateStatePublicationSeat } from "../git/private-state-seat.js";
 import { contractState } from "../core/facts/observation.js";
 import { decideAmend } from "../core/verbs/amend.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
-import { admitted } from "./outcome.js";
+import { admitted, intentOutcomeWithSeatClose } from "./outcome.js";
 import { timestamp } from "./operations.js";
 async function extendPrerequisiteClosureAt(channel, observation, seeds) {
     let current = observation;
@@ -30,7 +30,7 @@ export async function amendOperation(input) {
         const initial = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
         source = contractState(initial.decision, input.contractId)?.terms;
     }
-    return await withPrivateStatePublicationSeat(input.scope, async (seat) => {
+    return intentOutcomeWithSeatClose(await withPrivateStatePublicationSeat(input.scope, async (seat) => {
         const attempts = mintAttempts({ entryCount: 1 });
         for (let index = 0; index < attempts.length; index += 1) {
             let observation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
@@ -81,5 +81,5 @@ export async function amendOperation(input) {
                 return { kind: "retry", reason: admission };
         }
         return { kind: "retry", reason: { kind: "exhausted" } };
-    });
+    }));
 }

package/build/src/protocol/attempt.d.ts

@@ -1,6 +1,6 @@
 import { type PublicationFailed } from "../git/admission.js";
 import { type GitDecisionObservation } from "../git/observe.js";
-import { type PrivateStatePublicationSeat } from "../git/private-state-seat.js";
+import { type PrivateStatePublicationSeat, type PrivateStateSeatCloseLag } from "../git/private-state-seat.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
 import { type GitRefAssertion } from "../git/repository.js";
 import type { GitRepository } from "../git/process.js";
@@ -28,6 +28,7 @@ export type AcceptedAdmission = Readonly<{
     facts: readonly JournalEntry[];
     state: ContractState;
     journal: readonly JournalEntry[];
+    seatClose?: readonly PrivateStateSeatCloseLag[];
 }>;
 export type AttemptTerminal = Readonly<{
     kind: "collision";

package/build/src/protocol/attempt.js

@@ -2,7 +2,7 @@ import { randomBytes } from "node:crypto";
 import { encodeEntry } from "../core/facts/codec.js";
 import { admit } from "../git/admission.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
-import { confirmPrivateStatePublication } from "../git/private-state-seat.js";
+import { confirmPrivateStatePublication, } from "../git/private-state-seat.js";
 import { GIT_REF, readRefs } from "../git/repository.js";
 import { foldJournal } from "../core/facts/fold.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";

package/build/src/protocol/audit.d.ts

@@ -2,6 +2,7 @@ import { type DeliveryDiffScope } from "../git/integration.js";
 import type { ChangeId, ContractState, DeliverData } from "../core/facts/types.js";
 import { type AuditTargetAnswer } from "../git/target-placement.js";
 import type { DeliveryPreparationRefusal, DocumentDerivation, IntentOutcome, MutationOperationInput, VerificationStop } from "./operations.js";
+export { decodeAuditReport } from "./result-codec.js";
 type AuditWorkspace = Readonly<{
     kind: "worktree";
     path: string;
@@ -50,4 +51,3 @@ type AuditOperationInput = MutationOperationInput & Readonly<{
     signal?: AbortSignal;
 }>;
 export declare function auditOperation(input: AuditOperationInput): Promise<IntentOutcome<AuditReport>>;
-export {};

package/build/src/protocol/audit.js

@@ -7,6 +7,7 @@ import { verifyDelivery } from "./intent.js";
 import { accepted, admitted } from "./outcome.js";
 import { prepareDelivery } from "./deliver.js";
 import { timestamp, unpackVerificationOutcome } from "./operations.js";
+export { decodeAuditReport } from "./result-codec.js";
 async function auditWorkspace(repository, state) {
     const appointed = await readManagedWorktreeAppointment(repository, state.id);
     if (appointed.kind === "failed")
@@ -30,7 +31,6 @@ async function auditCandidateVerification(input, state, snapshot, definition) {
         at: timestamp(),
         state,
         snapshot,
-        environment: process.env,
         ...(input.signal === undefined ? {} : { signal: input.signal }),
         verification: definition,
     });

package/build/src/protocol/bind.d.ts

@@ -2,7 +2,7 @@ import { type BindTargetSelection } from "../git/observe.js";
 export type { BindTargetSelection };
 import type { GitRepository } from "../git/process.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
-import type { BindData, ActorId, ContractId } from "../core/facts/types.js";
+import { type BindData, type ActorId, type ContractId } from "../core/facts/types.js";
 import { type BindRefusal } from "../core/verbs/bind.js";
 export type { BindRefusal } from "../core/verbs/bind.js";
 import type { VerificationDeclarationPreparation, VerificationDeclarationRefusal } from "../verification/declaration.js";
@@ -19,6 +19,8 @@ export type ForkSourceMovedRefusal = Readonly<{
     kind: "fork-source-moved";
     contractId: ContractId;
 }>;
+export declare function decodeTargetInputRefusal(value: unknown): TargetInputRefusal;
+export declare function decodeForkSourceMovedRefusal(value: unknown): ForkSourceMovedRefusal;
 type BindOperationInput = Readonly<{
     scope: GitRepository;
     channel: GitDecodeChannel;

package/build/src/protocol/bind.js

@@ -1,8 +1,34 @@
 import { normalizeTargetBranch, observeBindCoordinates } from "../git/observe.js";
 import { gitObjectIdForSnapshot } from "../git/identity.js";
+import { contractId } from "../core/facts/types.js";
 import { decideBind } from "../core/verbs/bind.js";
 import { admitIntent } from "./intent.js";
 import { complete } from "./outcome.js";
+export function decodeTargetInputRefusal(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new Error("malformed target input refusal");
+    const object = value;
+    if (object.kind !== "invalid-target" && object.kind !== "target-missing" && object.kind !== "unborn-head")
+        throw new Error("malformed target input refusal");
+    if (Object.keys(object).length !== 1)
+        throw new Error("malformed target input refusal");
+    return { kind: object.kind };
+}
+export function decodeForkSourceMovedRefusal(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new Error("malformed fork-source refusal");
+    const object = value;
+    if (object.kind !== "fork-source-moved")
+        throw new Error("malformed fork-source refusal");
+    if (Object.keys(object).some((key) => key !== "kind" && key !== "contractId"))
+        throw new Error("malformed fork-source refusal");
+    try {
+        return { kind: "fork-source-moved", contractId: contractId(String(object.contractId)) };
+    }
+    catch {
+        throw new Error("malformed fork-source refusal");
+    }
+}
 async function bindPreparation(input, selection, seed) {
     if (input.verification.kind === "refused") {
         return { kind: "prepared", input: { ...seed, preparation: input.verification } };

package/build/src/protocol/completion.js

@@ -35,7 +35,6 @@ async function verificationFor(input, admission, snapshot) {
         at: timestamp(),
         state: admission.state,
         snapshot,
-        environment: process.env,
         ...(input.signal === undefined ? {} : { signal: input.signal }),
         ...(input.verification.data === null ? {} : { verification: input.verification.data }),
     });

package/build/src/protocol/deliver.d.ts

@@ -16,6 +16,7 @@ export type IntegrationConflictMaterialized = Readonly<{
     conflictPaths: readonly string[];
     workspace: AppointedWorkspace;
 }>;
+export { decodeMaterializedConflict } from "./result-codec.js";
 type DeliverOperationInput = MutationOperationInput & Readonly<{
     deriveDocument: (state: ContractState) => DocumentDerivation;
     message?: string;
@@ -54,4 +55,3 @@ export declare function continueDeliveryOperation(input: Readonly<{
     signal?: AbortSignal;
 }>): Promise<CompletionResult>;
 export declare function deliverOperation(input: DeliverOperationInput): Promise<IntentOutcome<DeliverValue> | IntegrationConflictMaterialized>;
-export {};