@fungi.computer/truffle 0.0.0-stage → 0.2.0

package/dist/private-local-ui-attachment.js

@@ -0,0 +1,71 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { z } from "zod";
+export const localUiAttachmentLifetimeSchema = z.enum(["watch", "connection"]);
+const attachments = new WeakMap();
+export function createLocalUiAttachment(sessionId, lifetime = "watch") {
+    const controller = new AbortController();
+    const attachment = {
+        sessionId,
+        signal: controller.signal,
+        close: () => {
+            attachments.delete(attachment);
+            controller.abort();
+        },
+    };
+    attachments.set(attachment, { watches: 0, lifetime });
+    return attachment;
+}
+export function startLocalUiWatch(attachment, sessionId) {
+    const state = attachments.get(attachment);
+    if (state === undefined || attachment.sessionId !== sessionId)
+        return undefined;
+    state.watches += 1;
+    let watching = true;
+    return () => {
+        if (!watching)
+            return;
+        watching = false;
+        state.watches -= 1;
+        // TUI/form authority is watch-scoped. ACP closes each prompt's watch,
+        // but its host-issued route belongs to the retained connection binding.
+        if (state.lifetime === "watch")
+            attachment.close();
+    };
+}
+const commands = new AsyncLocalStorage();
+function isAttached(command) {
+    return (command.attachment.sessionId === command.sessionId &&
+        (attachments.get(command.attachment)?.watches ?? 0) > 0);
+}
+/** Authority lasts for one command, not model work that might wake later. */
+export function runLocalUiCommand(attachment, sessionId, body) {
+    const command = { attachment, sessionId, available: true };
+    return commands.run(command, async () => {
+        let result;
+        try {
+            result = await body();
+        }
+        catch (cause) {
+            command.available = false;
+            await command.complete?.(false);
+            throw cause;
+        }
+        command.available = false;
+        return command.complete === undefined
+            ? result
+            : command.complete(isAttached(command));
+    });
+}
+/** Consume host authority before registering the post-commit continuation. */
+export function consumeLocalUiCommand(sessionId) {
+    const command = commands.getStore();
+    if (command === undefined ||
+        !command.available ||
+        command.sessionId !== sessionId ||
+        !isAttached(command))
+        return undefined;
+    command.available = false;
+    return (complete) => {
+        command.complete = complete;
+    };
+}

package/dist/private-local-worker-server.d.ts

@@ -0,0 +1,16 @@
+import type { openPrivateLocalBunShiitakeWorkerBatch } from "./private-bun-shiitake-host.js";
+export type ShutdownSignal = "SIGINT" | "SIGTERM";
+export type Signals = Readonly<{
+    on: (signal: ShutdownSignal, listener: () => void) => void;
+    off: (signal: ShutdownSignal, listener: () => void) => void;
+}>;
+export type Output = Pick<NodeJS.WritableStream, "write">;
+export type OpenWorkerBatch = typeof openPrivateLocalBunShiitakeWorkerBatch;
+export type PrivateLocalWorkerServerIo = Readonly<{
+    cwd: string;
+    home?: string;
+    stdout?: Output | undefined;
+    signals?: Signals | undefined;
+}>;
+/** Retained explicit static worker batch; ordinary clients use the persistent manager. */
+export declare function runPrivateLocalWorkerServer(workersFile: string, listen: string, io: PrivateLocalWorkerServerIo, openBatch?: OpenWorkerBatch): Promise<void>;

package/dist/private-local-worker-server.js

@@ -0,0 +1,144 @@
+import { logEvent } from "./log-event.js";
+import { capturePrivateLocalConfigRoot, } from "./private-local-config-root.js";
+import { readFungiMcpSelection } from "./private-fungi-mcp-selection.js";
+import { fungiMcpSelectionSchema } from "./private-fungi-mcp-selection-schema.js";
+import { readFile } from "node:fs/promises";
+import process from "node:process";
+import { dirname, resolve } from "node:path";
+import { z } from "zod";
+const reasoningSchema = z.enum([
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+]);
+const ownerSchema = z.strictObject({
+    invocationRoot: z.string().min(1),
+    databasePath: z.string().min(1).optional(),
+    modelId: z.string().min(1).optional(),
+    reasoning: reasoningSchema.optional(),
+    fungiMcp: fungiMcpSelectionSchema.optional(),
+});
+const workerSchema = z.strictObject({
+    name: z.string(),
+    owner: ownerSchema,
+});
+const workersSchema = z.array(workerSchema).min(1);
+function parseWorkers(value, filePath) {
+    const decoded = workersSchema.safeParse(value);
+    if (!decoded.success)
+        throw new Error("Invalid workers file: " + filePath);
+    const root = dirname(filePath);
+    return decoded.data.map(({ name, owner }) => ({
+        name,
+        owner: {
+            ...owner,
+            invocationRoot: resolve(root, owner.invocationRoot),
+        },
+    }));
+}
+async function readWorkers(filePath, cwd, configRoot) {
+    const absolutePath = resolve(cwd, filePath);
+    let value;
+    try {
+        value = JSON.parse(await readFile(absolutePath, "utf8"));
+    }
+    catch (cause) {
+        throw new Error("Could not read workers file: " + absolutePath, { cause });
+    }
+    const workers = [];
+    for (const { name, owner } of parseWorkers(value, absolutePath)) {
+        const { fungiMcp, ...local } = owner;
+        let configured = {
+            ...local,
+            configRoot,
+        };
+        if (fungiMcp !== undefined)
+            configured = {
+                ...configured,
+                fungiMcp: readFungiMcpSelection(fungiMcp, {
+                    credentialPath: configRoot.credentialPath,
+                }),
+            };
+        workers.push({ name, owner: configured });
+    }
+    return workers;
+}
+function asFailure(cause, message) {
+    return cause instanceof Error ? cause : new Error(message, { cause });
+}
+function readyRecord(batch) {
+    return JSON.stringify({
+        status: "ready",
+        baseUrl: batch.baseUrl,
+        workers: batch.workers.map(({ name, routePath, databasePath }) => ({
+            name,
+            routePath,
+            databasePath,
+        })),
+    });
+}
+/** Retained explicit static worker batch; ordinary clients use the persistent manager. */
+export async function runPrivateLocalWorkerServer(workersFile, listen, io, openBatch = async (...args) => {
+    const { openPrivateLocalBunShiitakeWorkerBatch } = await import("./private-bun-shiitake-host.js");
+    return openPrivateLocalBunShiitakeWorkerBatch(...args);
+}) {
+    const root = capturePrivateLocalConfigRoot(io.home);
+    const workers = await readWorkers(workersFile, io.cwd, root);
+    const stdout = io.stdout ?? process.stdout;
+    const signals = io.signals ?? process;
+    const stopped = Promise.withResolvers();
+    const stop = { requested: false };
+    let batch;
+    let initiating;
+    let closeFailure;
+    const onSignal = () => {
+        if (stop.requested)
+            return;
+        stop.requested = true;
+        stopped.resolve(undefined);
+    };
+    signals.on("SIGINT", onSignal);
+    signals.on("SIGTERM", onSignal);
+    try {
+        try {
+            batch = await openBatch(workers, listen);
+            if (!stop.requested) {
+                try {
+                    stdout.write(readyRecord(batch) + "\n");
+                }
+                catch (cause) {
+                    logEvent("worker-server.ready-output", cause);
+                    initiating = asFailure(cause, "Worker server ready output failed");
+                }
+            }
+            if (initiating === undefined)
+                await stopped.promise;
+        }
+        catch (cause) {
+            logEvent("worker-server.opening", cause);
+            initiating = asFailure(cause, "Worker server opening failed");
+        }
+        if (batch !== undefined) {
+            try {
+                await batch.close();
+            }
+            catch (cause) {
+                logEvent("worker-server.close", cause);
+                closeFailure = asFailure(cause, "Worker server close failed");
+            }
+        }
+    }
+    finally {
+        signals.off("SIGINT", onSignal);
+        signals.off("SIGTERM", onSignal);
+    }
+    if (initiating !== undefined && closeFailure !== undefined)
+        throw new AggregateError([initiating, closeFailure], "Worker server startup and close failed");
+    if (initiating !== undefined)
+        throw initiating;
+    if (closeFailure !== undefined)
+        throw closeFailure;
+}

package/dist/private-mcp-form-contract.d.ts

@@ -0,0 +1,186 @@
+import * as Schema from "effect/Schema";
+/** The actual MCP form, not a ledger record or an authorization decision. */
+export declare const McpFormApprovalRequestSchema: Schema.Struct<{
+    readonly message: Schema.String;
+    readonly requestedSchema: Schema.Struct<{
+        readonly type: Schema.Literal<"object">;
+        readonly properties: Schema.Struct<{
+            readonly approve: Schema.Struct<{
+                readonly type: Schema.Literal<"boolean">;
+                readonly title: Schema.optionalKey<Schema.String>;
+            }>;
+        }>;
+        readonly required: Schema.Tuple<readonly [Schema.Literal<"approve">]>;
+    }>;
+}>;
+export type McpFormApprovalRequest = typeof McpFormApprovalRequestSchema.Type;
+/** Human dispositions of one live protocol request. */
+export type McpFormApprovalDecision = "approve" | "decline" | "cancel";
+declare const answerResult: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"answered">;
+    readonly view: Schema.Struct<{
+        readonly record: Schema.Struct<{
+            readonly recordId: Schema.String;
+            readonly requester: Schema.Struct<{
+                readonly principalId: Schema.String;
+                readonly agentId: Schema.NullOr<Schema.String>;
+                readonly sessionId: Schema.NullOr<Schema.String>;
+                readonly displayName: Schema.String;
+            }>;
+            readonly module: Schema.String;
+            readonly operation: Schema.String;
+            readonly access: Schema.Literals<readonly ["write", "external"]>;
+            readonly description: Schema.Struct<{
+                readonly title: Schema.String;
+                readonly inputBytes: Schema.Int;
+                readonly inputSha256: Schema.String;
+            }>;
+            readonly evidence: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly kind: Schema.Literal<"artifact">;
+                readonly ref: Schema.String;
+                readonly mediaType: Schema.Literal<"image/png">;
+                readonly bytes: Schema.Int;
+            }>>>;
+            readonly authorityFence: Schema.String;
+            readonly reversibility: Schema.Literals<readonly ["reversible", "irreversible-external"]>;
+            readonly state: Schema.Literals<readonly ["requested", "pending", "approved", "claimed", "applied", "denied", "expired", "outcome_unknown"]>;
+            readonly by: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"human">;
+                readonly memberId: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"policy">;
+            }>]>>;
+            readonly reason: Schema.NullOr<Schema.Literals<readonly ["not-found", "not-eligible", "already-answered", "stale-revision", "expired", "declined", "fenced", "not-granted", "read-only", "pending", "in-flight", "outcome-unknown", "identity-conflict"]>>;
+            readonly requestedAt: Schema.Int;
+            readonly expiresAt: Schema.Int;
+            readonly updatedAt: Schema.Int;
+            readonly revision: Schema.Int;
+        }>;
+        readonly canAnswer: Schema.Boolean;
+        readonly canSetAutoApprove: Schema.Boolean;
+    }>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"refused">;
+    readonly reason: Schema.Literals<readonly ["not-found", "not-eligible", "already-answered", "stale-revision", "expired", "declined", "fenced", "not-granted", "read-only", "pending", "in-flight", "outcome-unknown", "identity-conflict"]>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"submitted">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"refused">;
+    readonly reason: Schema.Literals<readonly ["not-attached", "not-pending"]>;
+}>]>;
+export type McpFormAnswerResult = typeof answerResult.Type;
+/** The existing Session extension slot carries only display-safe form data. */
+export declare const mcpFormApprovalContract: {
+    id: string & import("effect/Brand").Brand<"ExtensionId">;
+    commands: {
+        answer: {
+            scope: "session";
+            input: Schema.Struct<{
+                readonly id: Schema.String;
+                readonly decision: Schema.Literals<readonly ["approve", "deny"]>;
+                readonly expectedRevision: Schema.Int;
+            }>;
+            output: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"answered">;
+                readonly view: Schema.Struct<{
+                    readonly record: Schema.Struct<{
+                        readonly recordId: Schema.String;
+                        readonly requester: Schema.Struct<{
+                            readonly principalId: Schema.String;
+                            readonly agentId: Schema.NullOr<Schema.String>;
+                            readonly sessionId: Schema.NullOr<Schema.String>;
+                            readonly displayName: Schema.String;
+                        }>;
+                        readonly module: Schema.String;
+                        readonly operation: Schema.String;
+                        readonly access: Schema.Literals<readonly ["write", "external"]>;
+                        readonly description: Schema.Struct<{
+                            readonly title: Schema.String;
+                            readonly inputBytes: Schema.Int;
+                            readonly inputSha256: Schema.String;
+                        }>;
+                        readonly evidence: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                            readonly kind: Schema.Literal<"artifact">;
+                            readonly ref: Schema.String;
+                            readonly mediaType: Schema.Literal<"image/png">;
+                            readonly bytes: Schema.Int;
+                        }>>>;
+                        readonly authorityFence: Schema.String;
+                        readonly reversibility: Schema.Literals<readonly ["reversible", "irreversible-external"]>;
+                        readonly state: Schema.Literals<readonly ["requested", "pending", "approved", "claimed", "applied", "denied", "expired", "outcome_unknown"]>;
+                        readonly by: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+                            readonly kind: Schema.Literal<"human">;
+                            readonly memberId: Schema.String;
+                        }>, Schema.Struct<{
+                            readonly kind: Schema.Literal<"policy">;
+                        }>]>>;
+                        readonly reason: Schema.NullOr<Schema.Literals<readonly ["not-found", "not-eligible", "already-answered", "stale-revision", "expired", "declined", "fenced", "not-granted", "read-only", "pending", "in-flight", "outcome-unknown", "identity-conflict"]>>;
+                        readonly requestedAt: Schema.Int;
+                        readonly expiresAt: Schema.Int;
+                        readonly updatedAt: Schema.Int;
+                        readonly revision: Schema.Int;
+                    }>;
+                    readonly canAnswer: Schema.Boolean;
+                    readonly canSetAutoApprove: Schema.Boolean;
+                }>;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"refused">;
+                readonly reason: Schema.Literals<readonly ["not-found", "not-eligible", "already-answered", "stale-revision", "expired", "declined", "fenced", "not-granted", "read-only", "pending", "in-flight", "outcome-unknown", "identity-conflict"]>;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"submitted">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"refused">;
+                readonly reason: Schema.Literals<readonly ["not-attached", "not-pending"]>;
+            }>]>;
+        };
+    };
+    projection: {
+        schema: Schema.Struct<{
+            readonly pending: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly approval: Schema.Struct<{
+                    readonly record: Schema.Struct<{
+                        readonly recordId: Schema.String;
+                        readonly requester: Schema.Struct<{
+                            readonly principalId: Schema.String;
+                            readonly agentId: Schema.NullOr<Schema.String>;
+                            readonly sessionId: Schema.NullOr<Schema.String>;
+                            readonly displayName: Schema.String;
+                        }>;
+                        readonly module: Schema.String;
+                        readonly operation: Schema.String;
+                        readonly access: Schema.Literals<readonly ["write", "external"]>;
+                        readonly description: Schema.Struct<{
+                            readonly title: Schema.String;
+                            readonly inputBytes: Schema.Int;
+                            readonly inputSha256: Schema.String;
+                        }>;
+                        readonly evidence: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                            readonly kind: Schema.Literal<"artifact">;
+                            readonly ref: Schema.String;
+                            readonly mediaType: Schema.Literal<"image/png">;
+                            readonly bytes: Schema.Int;
+                        }>>>;
+                        readonly authorityFence: Schema.String;
+                        readonly reversibility: Schema.Literals<readonly ["reversible", "irreversible-external"]>;
+                        readonly state: Schema.Literals<readonly ["requested", "pending", "approved", "claimed", "applied", "denied", "expired", "outcome_unknown"]>;
+                        readonly by: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+                            readonly kind: Schema.Literal<"human">;
+                            readonly memberId: Schema.String;
+                        }>, Schema.Struct<{
+                            readonly kind: Schema.Literal<"policy">;
+                        }>]>>;
+                        readonly reason: Schema.NullOr<Schema.Literals<readonly ["not-found", "not-eligible", "already-answered", "stale-revision", "expired", "declined", "fenced", "not-granted", "read-only", "pending", "in-flight", "outcome-unknown", "identity-conflict"]>>;
+                        readonly requestedAt: Schema.Int;
+                        readonly expiresAt: Schema.Int;
+                        readonly updatedAt: Schema.Int;
+                        readonly revision: Schema.Int;
+                    }>;
+                    readonly canAnswer: Schema.Boolean;
+                    readonly canSetAutoApprove: Schema.Boolean;
+                }>;
+            }>>;
+        }>;
+    };
+};
+export {};

package/dist/private-mcp-form-contract.js

@@ -0,0 +1,53 @@
+import { ExtensionId, } from "@fungi.computer/shiitake/extensions";
+import * as Schema from "effect/Schema";
+import { ApprovalAnswerInputSchema, ApprovalRefusalSchema, ApprovalViewSchema, } from "@fungi.computer/approvals";
+/** The actual MCP form, not a ledger record or an authorization decision. */
+export const McpFormApprovalRequestSchema = Schema.Struct({
+    message: Schema.String,
+    requestedSchema: Schema.Struct({
+        type: Schema.Literal("object"),
+        properties: Schema.Struct({
+            approve: Schema.Struct({
+                type: Schema.Literal("boolean"),
+                title: Schema.optionalKey(Schema.String),
+            }),
+        }),
+        required: Schema.Tuple([Schema.Literal("approve")]),
+    }),
+});
+const answerResult = Schema.Union([
+    Schema.Struct({
+        kind: Schema.Literal("answered"),
+        view: ApprovalViewSchema,
+    }),
+    ApprovalRefusalSchema,
+    // The attached client awaits the private host's post-commit decision.
+    Schema.Struct({ kind: Schema.Literal("submitted") }),
+    Schema.Struct({
+        kind: Schema.Literal("refused"),
+        reason: Schema.Literals(["not-attached", "not-pending"]),
+    }),
+]);
+/** The ephemeral id references the canonical record; it grants no authority. */
+const McpFormPendingSchema = Schema.Struct({
+    id: Schema.String,
+    approval: ApprovalViewSchema,
+});
+/** The existing Session extension slot carries only display-safe form data. */
+export const mcpFormApprovalContract = {
+    id: ExtensionId.make("botanical-local-mcp-form"),
+    commands: {
+        answer: {
+            scope: "session",
+            input: Schema.Struct({
+                id: Schema.String,
+                decision: ApprovalAnswerInputSchema.fields.decision,
+                expectedRevision: ApprovalAnswerInputSchema.fields.expectedRevision,
+            }),
+            output: answerResult,
+        },
+    },
+    projection: {
+        schema: Schema.Struct({ pending: Schema.Array(McpFormPendingSchema) }),
+    },
+};

package/dist/private-mcp-form-elicitation.d.ts

@@ -0,0 +1,18 @@
+import type { Client } from "@modelcontextprotocol/client";
+import { type McpFormApprovalRequest, type McpFormApprovalDecision } from "./private-mcp-form-contract.js";
+/** Host-owned human interaction. No callback means immediate cancellation. */
+export type RequestMcpFormApproval = (pending: McpFormApprovalRequest, signal: AbortSignal, 
+/** Session captured by source acquisition, never supplied by tool arguments. */
+sessionId: string | undefined) => Promise<McpFormApprovalDecision>;
+/** A refused form is a failed tool call, not an uncertain transport outcome. */
+export declare class McpFormApprovalError extends Error {
+    readonly reason: "declined" | "cancelled";
+    readonly kind = "mcp_approval_refused";
+    constructor(reason: "declined" | "cancelled");
+}
+/** Discriminant carried in a failed MCP tool result's structuredContent. */
+export type McpFormApprovalRefusal = Readonly<Pick<McpFormApprovalError, "kind" | "reason">>;
+export declare function registerMcpFormElicitation(client: Client, requestApproval: RequestMcpFormApproval | undefined, sessionId: string | undefined): {
+    close: () => void;
+    run: <T>(signal: AbortSignal, invoke: (signal: AbortSignal) => Promise<T>) => Promise<T>;
+};

package/dist/private-mcp-form-elicitation.js

@@ -0,0 +1,97 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { addAbortListener } from "node:events";
+import * as Schema from "effect/Schema";
+import { McpFormApprovalRequestSchema, } from "./private-mcp-form-contract.js";
+const decodePendingForm = Schema.decodeUnknownSync(McpFormApprovalRequestSchema);
+/** A refused form is a failed tool call, not an uncertain transport outcome. */
+export class McpFormApprovalError extends Error {
+    reason;
+    kind = "mcp_approval_refused";
+    constructor(reason) {
+        super(`MCP approval was ${reason}.`);
+        this.reason = reason;
+        this.name = "McpFormApprovalError";
+    }
+}
+export function registerMcpFormElicitation(client, requestApproval, sessionId) {
+    // The producer sends its form on the requesting tools/call response stream.
+    // Keep that call's refusal local even when another call shares this client.
+    const calls = new AsyncLocalStorage();
+    const lifetime = new AbortController();
+    const close = () => {
+        lifetime.abort();
+        calls.disable();
+    };
+    client.onclose = close;
+    client.registerCapabilities({ elicitation: { form: {} } });
+    client.setRequestHandler("elicitation/create", async (request, context) => {
+        const call = calls.getStore();
+        if (call === undefined || call.failure !== undefined)
+            return { action: "cancel" };
+        const signal = AbortSignal.any([call.signal, context.mcpReq.signal]);
+        let abortListener;
+        call.pending++;
+        try {
+            signal.throwIfAborted();
+            const pending = decodePendingForm(request.params);
+            const aborted = new Promise((_resolve, reject) => {
+                abortListener = addAbortListener(signal, () => {
+                    reject(new McpFormApprovalError("cancelled"));
+                });
+            });
+            const decision = await Promise.race([
+                requestApproval === undefined
+                    ? Promise.resolve("cancel")
+                    : Promise.resolve().then(() => requestApproval(pending, signal, sessionId)),
+                aborted,
+            ]);
+            // Cancellation wins over a late Approve, including a UI ignoring abort.
+            signal.throwIfAborted();
+            if (decision === "approve")
+                return { action: "accept", content: { approve: true } };
+            call.failure ??= new McpFormApprovalError(decision === "decline" ? "declined" : "cancelled");
+            call.cancel();
+            return { action: decision };
+        }
+        catch {
+            call.failure ??= new McpFormApprovalError("cancelled");
+            call.cancel();
+            return { action: "cancel" };
+        }
+        finally {
+            call.pending--;
+            abortListener?.[Symbol.dispose]();
+        }
+    });
+    return {
+        close,
+        run: (signal, invoke) => {
+            const settled = new AbortController();
+            const call = {
+                signal: AbortSignal.any([signal, lifetime.signal, settled.signal]),
+                cancel: () => {
+                    settled.abort();
+                },
+                pending: 0,
+            };
+            return calls.run(call, async () => {
+                try {
+                    const result = await invoke(call.signal);
+                    if (call.failure !== undefined)
+                        throw call.failure;
+                    return result;
+                }
+                catch (cause) {
+                    if (call.failure !== undefined)
+                        throw call.failure;
+                    if (call.pending > 0)
+                        throw new McpFormApprovalError("cancelled");
+                    throw cause;
+                }
+                finally {
+                    settled.abort();
+                }
+            });
+        },
+    };
+}