keri-ts 2.1.0 → 2.2.0

package/esm/keri/npm/src/app/transport/http-client.js

@@ -4,6 +4,21 @@ import { ValidationError } from "../../core/errors.js";
 import { abortable } from "../runtime/abortable.js";
 import { collectBytes } from "./byte-source.js";
 import { TransportError } from "./transport-error.js";
+/**
+ * Native requests and signals that a pending `fetch` still needs. WebKit links an in-flight fetch to
+ * its abort signal only weakly: once the `Request`, or an `AbortSignal.any` composite, is garbage
+ * collected, `abort()` neither rejects the fetch nor closes the connection, so a halted caller waits
+ * forever on a request that WebKit will never settle. A strong reference until the request scope
+ * ends keeps the link alive; engines that hold it themselves are unaffected.
+ */
+const inFlight = new Set();
+/**
+ * Whether `cause` is the rejection an abort of `signal` produces. Chromium rejects with `signal.reason`;
+ * Node 20 and WebKit reject with a fresh native `AbortError`, which is the same cancellation.
+ */
+function isAbort(cause, signal) {
+    return cause === signal.reason || (cause instanceof DOMException && cause.name === "AbortError");
+}
 /**
  * Own the native Request, fetch and response reader for one attempt.
  * Construction errors remain outside network classification. Native fetch/read
@@ -44,6 +59,7 @@ export class FetchHttpClient {
             const controller = new AbortController();
             const signal = init.signal ? AbortSignal.any([controller.signal, init.signal]) : controller.signal;
             // These handles let scope teardown join native work before releasing the reader.
+            let request;
             let fetching;
             let reader;
             let reading;
@@ -57,7 +73,9 @@ export class FetchHttpClient {
              * @param message Operation detail to combine with the endpoint URL.
              * @returns Original cancellation reason or a TransportError retaining cause.
              */
-            const transportFailure = (cause, message) => signal.aborted && cause === signal.reason ? cause : new TransportError(`${message} for ${url}`, { cause });
+            const transportFailure = (cause, message) => signal.aborted && isAbort(cause, signal)
+                ? signal.reason
+                : new TransportError(`${message} for ${url}`, { cause });
             try {
                 signal.throwIfAborted();
                 const endpoint = new URL(url);
@@ -65,7 +83,8 @@ export class FetchHttpClient {
                     throw new ValidationError("HTTP output requires an HTTP(S) URL without credentials");
                 }
                 // Construction errors are caller errors, before native network classification.
-                const request = new Request(url, { ...init, signal, body: init.body });
+                request = new Request(url, { ...init, signal, body: init.body });
+                inFlight.add(request).add(signal);
                 fetching = fetch(request).catch((cause) => {
                     throw transportFailure(cause, "HTTP request failed");
                 });
@@ -99,9 +118,6 @@ export class FetchHttpClient {
                                         signal.throwIfAborted();
                                         reading = reader.read().catch((cause) => {
                                             // Node 20 Fetch replaces the supplied reason with a native AbortError during body reads.
-                                            if (signal.aborted && cause instanceof DOMException && cause.name === "AbortError") {
-                                                throw signal.reason;
-                                            }
                                             throw transportFailure(cause, "HTTP response body failed");
                                         });
                                         let result;
@@ -144,7 +160,7 @@ export class FetchHttpClient {
                             await pending;
                         }
                         catch (error) {
-                            if (error !== signal.reason && error !== failure?.error)
+                            if (!isAbort(error, signal) && error !== failure?.error)
                                 cleanup.push(error);
                         }
                     }
@@ -156,6 +172,9 @@ export class FetchHttpClient {
                     }
                     bodySignal?.removeEventListener("abort", abortBody);
                 });
+                if (request)
+                    inFlight.delete(request);
+                inFlight.delete(signal);
                 // Throw outside the Promise leaf so Effection teardown preserves genuine cleanup failures.
                 if (cleanup.length) {
                     if (failure && failure.error !== signal.reason)

package/esm/keri/npm/src/app/witness/http-endpoints.js

@@ -1,5 +1,5 @@
 /** Witness HTTP semantic policies for receipts, log queries and endorsed key state; adapters format decisions. */
-import { Ilks, Vrsn_2_0 } from "cesr-ts";
+import { Ilks } from "cesr-ts";
 import { receipt as receiptEvent, reply as replyEvent } from "../../core/protocol-eventing.js";
 import { dgKey } from "../../db/core/keys.js";
 import { inspectCesrRequest } from "../transport/cesr-http.js";
@@ -178,8 +178,8 @@ export function witnessKeyStateGet(serviceHab, query) {
         status: 200,
         body: serviceHab.endorse(replyEvent(`/ksn/${serviceHab.pre}`, kever.state().asDict(), {
             pre: serviceHab.pre,
-            pvrsn: Vrsn_2_0,
-            gvrsn: Vrsn_2_0,
-        }), { gvrsn: Vrsn_2_0 }),
+            pvrsn: serviceHab.kelVersion,
+            gvrsn: serviceHab.kelVersion,
+        }), { gvrsn: serviceHab.kelVersion }),
     };
 }

package/esm/keri/npm/src/cli/common/event-completion.js

@@ -0,0 +1,49 @@
+import { completeEvent } from "../../app/identity/event-completion.js";
+import { KelPublisher } from "../../app/mailbox/kel-publisher.js";
+import { createProtocolProcessor } from "../../app/protocol/protocol-processing.js";
+import { createAgentRuntime } from "../../app/runtime/agent-runtime.js";
+import { systemClock } from "../../app/runtime/runtime-clock.js";
+import { withRuntimeWorkers } from "./runtime-workers.js";
+/**
+ * Compose event-completion dependencies for one CLI command.
+ *
+ * A short-lived runtime is created only when a delegated event needs workers.
+ * It is lent to the library for that one scope with its workers running around
+ * the library's observe-only wait, and closed on every exit path.
+ */
+export function cliEventCompletionDeps(hby, http) {
+    // A command has no running runtime, so it carries the publisher whose pass `completeEventOrThrow` runs.
+    const publisher = new KelPublisher({ hby, http, clock: systemClock });
+    return {
+        hby,
+        publisher,
+        rotated: publisher.rotated,
+        protocol: createProtocolProcessor(hby),
+        http,
+        clock: systemClock,
+        *withDelegation(hab, use) {
+            const runtime = yield* createAgentRuntime(hby, http, systemClock);
+            try {
+                return yield* withRuntimeWorkers(runtime, { hab, pollMailbox: true }, () => use({ anchorer: runtime.delegating }));
+            }
+            finally {
+                yield* runtime.close();
+            }
+        },
+    };
+}
+/**
+ * `completeEvent` for commands: an expired delegation wait fails the command with
+ * the text the CLI has always printed, then the caller sees the usual result.
+ */
+export function* completeEventOrThrow(deps, ...args) {
+    const completion = yield* completeEvent(deps, ...args);
+    if (completion.outcome === "timed-out") {
+        throw new Error(`Runtime did not converge within ${completion.timeoutMs}ms.`);
+    }
+    // No fiber runs the publisher in a one-shot command: tell the mailboxes of a completed rotation now. A
+    // mailbox that cannot be reached stays owed in the marker and the poller repairs it.
+    if (!deps.publisher.rotated.empty)
+        yield* deps.publisher.processOnce();
+    return completion;
+}

package/esm/keri/npm/src/cli/common/runtime-workers.js

@@ -0,0 +1,23 @@
+import { spawn } from "effection";
+import { runAgentRuntime } from "../../app/runtime/agent-runtime.js";
+/**
+ * Run the runtime workers around one observe-only library call.
+ *
+ * Library workflows only observe (see `app/runtime/workflow-contract.ts`); a
+ * one-shot CLI command has no running runtime, so it supplies the workers here.
+ * The worker is halted and joined on success, failure and cancellation before
+ * the caller can release stores.
+ *
+ * @param runtime Borrowed composed runtime; the command owns its lifetime.
+ * @param options Signer, mailbox polling and command-owned query cue Deck.
+ * @param use Observe-only operation that depends on the workers' progress.
+ */
+export function* withRuntimeWorkers(runtime, options, use) {
+    const worker = yield* spawn(() => runAgentRuntime(runtime, options));
+    try {
+        return yield* use();
+    }
+    finally {
+        yield* worker.halt();
+    }
+}