keri-ts 1.0.0 → 2.0.1

package/esm/keri/npm/src/app/respondant.js

@@ -1,358 +0,0 @@
-import { call, resource } from "effection";
-import { Deck } from "../core/deck.js";
-import { attemptPreparedCesrTarget } from "./forwarding.js";
-/**
- * Shared host-side responder for indirect and witness runtimes.
- *
- * KERIpy correspondence:
- * - this is the local analogue of `Respondant` for reply/replay/receipt-style
- *   cues
- * - `BaseHab.processCuesIter()` interprets the cue; `Respondant` delivers the
- *   resulting bytes
- * - mailbox-query `stream` cues stay with mailbox storage/query coordination
- *
- * Boundary rule:
- * - this class owns non-`stream` cue delivery
- * - `MailboxDirector` owns mailbox storage and `stream` cue correlation
- * - if a future change starts treating generic `reply` / `replay` /
- *   `receipt`-family cues as local mailbox writes, that change is regressing
- *   back toward the bug where mailbox code was incorrectly acting like
- *   KERIpy's `Respondant`
- */
-export class Respondant {
-    constructor(hby, { poster, reactor, replyStreams, }) {
-        Object.defineProperty(this, "hby", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "poster", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "reactor", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "replyStreams", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "outgoing", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Deck()
-        });
-        Object.defineProperty(this, "processing", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "closed", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "active", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "joined", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.hby = hby;
-        this.poster = poster;
-        this.reactor = reactor;
-        this.replyStreams = replyStreams;
-    }
-    /** Include active transport and lazy replies in runtime convergence. */
-    get hasPending() {
-        return this.processing || !this.outgoing.empty;
-    }
-    /** Interpret and route a source head before removing it; failed preparation leaves it visible. */
-    enqueueCue(interpreter, source, hint) {
-        this.assertOpen();
-        const cue = source.peekHead();
-        if (!cue)
-            return false;
-        const recipient = recipientForCue(cue), topic = topicForCue(cue);
-        const sender = senderHabForCue(this.hby, cue, hint);
-        if (!recipient || !topic || !sender)
-            return false;
-        const emission = interpreter.interpretCue(cue);
-        if (emission?.kind !== "wire")
-            throw new RangeError("Cue delivery requires wire");
-        const route = this.poster.findBytesRoute(sender, { recipient, recipientIsPrefix: true, topic });
-        if (route?.targets.length) {
-            this.outgoing.push({ kind: "cues", cues: [{ emission, hab: sender, route, targetIndex: 0 }], index: 0 });
-        }
-        source.pull();
-        return true;
-    }
-    /** Queue an already interpreted witness emission without reopening or signing its messages. */
-    enqueueEmission(hab, emission) {
-        this.assertOpen();
-        const route = this.routeForEmission(emission, hab);
-        if (route?.targets.length) {
-            const sender = this.hby.habs.get(route.sender) ?? hab;
-            this.outgoing.push({ kind: "cues", cues: [{ emission, hab: sender, route, targetIndex: 0 }], index: 0 });
-        }
-    }
-    /** Prepare the whole correlated batch before publishing either its HTTP reader or queued destinations. */
-    openReply(hab, reply) {
-        this.assertOpen();
-        const captured = reply.peekAll();
-        if (!captured)
-            return null;
-        const { emissions, cues } = this.interpretReplies(hab, captured.cues);
-        const stream = this.replyStreams.open({
-            *[Symbol.iterator]() {
-                for (const emission of emissions)
-                    yield* emission.messages;
-            },
-        });
-        if (cues.length)
-            this.outgoing.push({ kind: "cues", cues, index: 0 });
-        reply.takeAll();
-        return stream;
-    }
-    /** Earlier queries transfer to ordinary queued replies without an HTTP response reader. */
-    enqueueReply(hab, reply) {
-        this.assertOpen();
-        const captured = reply.peekAll();
-        if (!captured)
-            return false;
-        const { cues } = this.interpretReplies(hab, captured.cues);
-        if (cues.length)
-            this.outgoing.push({ kind: "cues", cues, index: 0 });
-        reply.takeAll();
-        return true;
-    }
-    interpretReplies(hab, replies) {
-        const emissions = [], cues = [];
-        for (const cue of replies) {
-            const emission = hab.interpretCue(cue);
-            if (emission?.kind !== "wire")
-                throw new RangeError("Direct reply requires wire");
-            emissions.push(emission);
-            const sender = ("src" in cue && cue.src ? this.hby.habs.get(cue.src) : undefined) ?? hab;
-            const route = "dest" in cue && cue.dest
-                ? this.poster.findBytesRoute(sender, {
-                    recipient: cue.dest,
-                    recipientIsPrefix: true,
-                    topic: cue.kin === "replay" ? "/replay" : "/reply",
-                })
-                : null;
-            if (route?.targets.length)
-                cues.push({ emission, hab: sender, route, targetIndex: 0 });
-        }
-        return { emissions, cues };
-    }
-    assertOpen() {
-        if (this.closed)
-            throw new Error("Respondant is closed");
-    }
-    /** Join actual transport before returning every opened replay cursor; ordinary cues need no release protocol. */
-    *close() {
-        this.closed = true;
-        this.active?.abort();
-        if (this.joined)
-            yield* call(() => this.joined);
-        const errors = [];
-        while (!this.outgoing.empty) {
-            try {
-                this.closeReply(this.outgoing.pull());
-            }
-            catch (error) {
-                errors.push(error);
-            }
-        }
-        if (errors.length === 1)
-            throw errors[0];
-        if (errors.length)
-            throw new AggregateError(errors, "Respondant cleanup failed");
-    }
-    closeReply(reply) {
-        if (reply.kind === "packet")
-            return;
-        const errors = [];
-        for (const cue of reply.cues.splice(0)) {
-            try {
-                cue.iterator?.return?.();
-            }
-            catch (error) {
-                if (!errors.includes(error))
-                    errors.push(error);
-            }
-        }
-        if (errors.length === 1)
-            throw errors[0];
-        if (errors.length)
-            throw new AggregateError(errors, "Reply cursor cleanup failed");
-    }
-    /** Advance each captured batch once; concrete target preparation and transport remain owned operations. */
-    process() {
-        // deno-lint-ignore no-this-alias -- The operation owns this finite output pass.
-        const self = this;
-        return call(function* () {
-            if (self.processing || self.closed)
-                return;
-            self.processing = true;
-            const active = self.active = new AbortController();
-            let complete;
-            self.joined = new Promise((resolve) => complete = resolve);
-            yield* resource(function* (provide) {
-                try {
-                    yield* provide();
-                }
-                finally {
-                    self.processing = false;
-                    self.active = undefined;
-                    self.joined = undefined;
-                    complete();
-                }
-            });
-            const count = self.outgoing.length;
-            for (let index = 0; index < count && !self.closed; index++) {
-                const reply = self.outgoing.peekHead();
-                if (!reply)
-                    break;
-                active.signal.throwIfAborted();
-                let done = true;
-                if (reply.kind === "packet") {
-                    done = (yield* attemptPreparedCesrTarget(reply.packet, self.poster.services, active.signal, {
-                        reactor: self.reactor,
-                    })) === "complete";
-                }
-                else {
-                    const cue = reply.cues[reply.index];
-                    const next = yield* self.prepareReplyTarget(reply);
-                    done = next.kind === "done";
-                    if (next.kind === "target") {
-                        const target = next.target;
-                        const outcome = yield* attemptPreparedCesrTarget(target, self.poster.services, active.signal, {
-                            reactor: self.reactor,
-                        });
-                        if (outcome === "complete" || outcome === "refused" && !self.closed) {
-                            active.signal.throwIfAborted();
-                            if (outcome === "refused")
-                                self.outgoing.push({ kind: "packet", packet: target });
-                            cue.prepared = undefined;
-                            if (++cue.targetIndex === cue.route.targets.length) {
-                                cue.targetIndex = 0;
-                                cue.message = undefined;
-                            }
-                        }
-                    }
-                }
-                active.signal.throwIfAborted();
-                if (done) {
-                    try {
-                        self.closeReply(reply);
-                    }
-                    finally {
-                        self.outgoing.pull();
-                    }
-                }
-                else {
-                    self.outgoing.pull();
-                    self.outgoing.push(reply);
-                }
-            }
-        });
-    }
-    *prepareReplyTarget(reply) {
-        const cue = reply.cues[reply.index];
-        if (!cue)
-            return { kind: "done" };
-        if (cue.prepared)
-            return { kind: "target", target: cue.prepared };
-        if (!cue.message) {
-            cue.iterator ??= cue.emission.messages[Symbol.iterator]();
-            const next = cue.iterator.next();
-            if (next.done) {
-                reply.index++;
-                return { kind: "more" };
-            }
-            cue.message = next.value;
-            if (!(cue.message instanceof Uint8Array))
-                throw new TypeError("Cue message must be binary");
-        }
-        cue.prepared = yield* this.poster.prepareBytesTarget(cue.hab, cue.route, cue.targetIndex, cue.message);
-        return { kind: "target", target: cue.prepared };
-    }
-    /** Resolve the existing responder policy for an admitted witness emission without sending or signing again. */
-    routeForEmission(emission, hab) {
-        const recipient = recipientForCue(emission.cue), topic = topicForCue(emission.cue);
-        const sender = senderHabForCue(this.hby, emission.cue, hab);
-        if (emission.kind !== "wire" || !recipient || !topic || !sender)
-            return null;
-        return this.poster.findBytesRoute(sender, { recipient, recipientIsPrefix: true, topic });
-    }
-}
-/** Select the existing mailbox topic for a responder cue. */
-function topicForCue(cue) {
-    switch (cue.kin) {
-        case "replay":
-            return "/replay";
-        case "reply":
-            return "/reply";
-        case "receipt":
-        case "witness":
-            return "/receipt";
-        default:
-            return null;
-    }
-}
-/** Select the intended recipient without preparing or transmitting bytes. */
-function recipientForCue(cue) {
-    switch (cue.kin) {
-        case "replay":
-            return cue.dest ?? null;
-        case "reply":
-            return cue.dest ?? null;
-        case "receipt":
-        case "witness":
-            return cue.serder.pre ?? null;
-        default:
-            return null;
-    }
-}
-/** Borrow the local sender selected by cue provenance, explicit hint or sole habitat. */
-function senderHabForCue(hby, cue, hab) {
-    const source = cueSourcePrefix(cue);
-    if (source) {
-        return hby.habs.get(source) ?? hab ?? soleHab(hby);
-    }
-    return hab ?? soleHab(hby);
-}
-function cueSourcePrefix(cue) {
-    switch (cue.kin) {
-        case "replay":
-            return cue.src ?? null;
-        case "reply":
-            return cue.src ?? null;
-        default:
-            return null;
-    }
-}
-function soleHab(hby) {
-    const habitats = hby.habs.values();
-    const first = habitats.next();
-    return first.done || !habitats.next().done ? null : first.value;
-}

package/esm/keri/npm/src/app/runtime-services.js

@@ -1,22 +0,0 @@
-/** Production clock backed by the JavaScript runtime. */
-export const defaultRuntimeClock = Object.freeze({
-    now: () => Date.now(),
-    setTimeout: (callback, ms) => setTimeout(callback, ms),
-    clearTimeout: (timer) => clearTimeout(timer),
-});
-/** Production HTTP client backed by global `fetch`. */
-export const defaultRuntimeHttpClient = Object.freeze({
-    fetch: (url, init) => fetch(url, init),
-});
-/** Production runtime services. */
-export const defaultRuntimeServices = Object.freeze({
-    clock: defaultRuntimeClock,
-    http: defaultRuntimeHttpClient,
-});
-/** Resolve partial runtime service overrides against production defaults. */
-export function resolveRuntimeServices(services = {}) {
-    return Object.freeze({
-        clock: services.clock ?? defaultRuntimeClock,
-        http: services.http ?? defaultRuntimeHttpClient,
-    });
-}

package/esm/keri/npm/src/app/tcp-conversation.js

@@ -1,85 +0,0 @@
-/** Application composition of actual TCP receive and transmit lifetimes. */
-import { parse } from "cesr-ts";
-import { call, ensure, on, race, spawn } from "effection";
-import { rethrowCleanupFailure } from "./abortable.js";
-import { chunkBytes } from "./byte-source.js";
-import { socketBytes } from "./socket-source.js";
-import { openTcpConnection, sendCesrTcpSocket, } from "./tcp-egress.js";
-/** Send finite wire while this application flow owns parser/dispatch and the transport owns the socket. */
-export function converseCesrTcp(url, bytes, options) {
-    return conversation(url, (signal) => chunkBytes(bytes, { signal, maxChunkBytes: options.maxChunkBytes }), options);
-}
-/** Pull output and process same-socket frames concurrently without adding a queue or prefetch. */
-export function streamCesrTcpConversation(url, source, options) {
-    return conversation(url, source, options);
-}
-/** Compose native RX/TX siblings over a real socket; transport never starts protocol work. */
-function conversation(url, source, options) {
-    return call(function* () {
-        const { replies, ...output } = options;
-        const connection = yield* openTcpConnection(url, output);
-        let processedFrames = 0;
-        const receive = yield* spawn(function* () {
-            yield* race([
-                call(function* () {
-                    const controller = new AbortController();
-                    const signal = AbortSignal.any([controller.signal, connection.signal]);
-                    const frames = parse(socketBytes(connection.socket, { signal }));
-                    let pending;
-                    yield* ensure(function* () {
-                        try {
-                            if (pending) {
-                                try {
-                                    yield* call(() => pending);
-                                }
-                                catch (error) {
-                                    rethrowCleanupFailure(error, signal);
-                                }
-                            }
-                        }
-                        finally {
-                            yield* call(() => frames.return());
-                        }
-                    });
-                    try {
-                        while (true) {
-                            signal.throwIfAborted();
-                            pending = frames.next();
-                            let next;
-                            try {
-                                next = yield* call(() => pending);
-                            }
-                            catch (error) {
-                                pending = undefined;
-                                throw error;
-                            }
-                            pending = undefined;
-                            signal.throwIfAborted();
-                            if (next.done)
-                                return;
-                            yield* replies.reactor.dispatch(next.value, { local: replies.local ?? true, escrows: true });
-                            processedFrames++;
-                        }
-                    }
-                    catch (error) {
-                        // Stop TX before parser/source cleanup can suspend on the failed direction.
-                        connection.close(error);
-                    }
-                    finally {
-                        controller.abort();
-                    }
-                }),
-                call(function* () {
-                    const abort = yield* on(connection.signal, "abort");
-                    connection.signal.throwIfAborted();
-                    yield* abort.next();
-                    throw connection.signal.reason;
-                }),
-            ]);
-        });
-        const transmission = yield* sendCesrTcpSocket(connection, source, output);
-        yield* receive;
-        connection.signal.throwIfAborted();
-        return { kind: "conversationDrained", transmission, receive: { kind: "eof", processedFrames } };
-    });
-}