@bandeira-tech/b3nd-save 0.8.1

package/esm/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/rig/operation-handle.d.ts

@@ -0,0 +1,185 @@
+/**
+ * @module
+ * Operation handles — the return value of `rig.receive()` / `rig.send()`.
+ *
+ * An OperationHandle is BOTH:
+ *   - a `Promise<ReceiveResult[]>` (the pipeline-stage acknowledgment;
+ *     resolves once `process` + `handle` finish for every input tuple),
+ *   - and a scoped event emitter that fires per-stage events for THIS
+ *     operation as it progresses (`process:done`, `handle:emit`,
+ *     `route:success`, `route:error`, `settled`).
+ *
+ * Why both shapes:
+ *   - Awaitable so existing callers (`await rig.receive(outs)`) and
+ *     `ProtocolInterfaceNode.receive` consumers see no contract change.
+ *   - Observable so callers who care about per-stage detail or per-route
+ *     dispatch outcomes can subscribe inline, without correlation IDs
+ *     or filtering global rig events.
+ *
+ * Single paper-trail: the events are the source of truth. The result
+ * the await resolves to (`ReceiveResult[]`) is the small pipeline-level
+ * ack; everything richer flows through events.
+ *
+ * Dispatch is async by design: `await op` resolves once the pipeline
+ * decides what to dispatch, but the broadcast itself runs in the
+ * background. Per-route events fire after the await has returned.
+ * Callers that need full settlement await `op.settled` (a Promise that
+ * resolves on the `settled` event).
+ */
+import type { B3ndError, Output, ProgramResult, ReceiveResult } from "../types/types.js";
+/** Emitted once `process()` produces a classification for one input tuple. */
+export interface ProcessDoneEvent {
+    /** The input tuple being classified. */
+    input: Output;
+    /** The classification produced by `process()`. */
+    result: ProgramResult;
+}
+/** Emitted when `process()` throws or a program returns an error code. */
+export interface ProcessErrorEvent {
+    /** The input tuple whose classification failed. */
+    input: Output;
+    /** Error message. */
+    error: string;
+    /** Structured error info, when available. */
+    errorDetail?: B3ndError;
+    /** The original thrown value (if `process()` threw). */
+    cause?: unknown;
+}
+/** Emitted once `handle()` returns its emissions for one classified tuple. */
+export interface HandleEmitEvent {
+    /** The input tuple that was handled. */
+    input: Output;
+    /** The classification that was passed to `handle()`. */
+    classification: ProgramResult;
+    /** What the handler returned — the tuples to dispatch. */
+    emissions: Output[];
+}
+/** Emitted when `handle()` throws while processing one classified tuple. */
+export interface HandleErrorEvent {
+    /** The input tuple that was handled. */
+    input: Output;
+    /** The classification that was passed to `handle()`. */
+    classification: ProgramResult;
+    /** Error message. */
+    error: string;
+    /** The original thrown value. */
+    cause?: unknown;
+}
+/** Emitted when a registered reaction throws while running. */
+export interface ReactionErrorEvent {
+    /** The emission whose URI matched the reaction's pattern. */
+    emission: Output;
+    /** The reaction's URI pattern. */
+    pattern: string;
+    /** Error message. */
+    error: string;
+    /** The original thrown value. */
+    cause?: unknown;
+}
+/** Emitted when a single connection accepts a single emission. */
+export interface RouteSuccessEvent {
+    /** The tuple that was dispatched. */
+    emission: Output;
+    /** Stable ID of the connection that accepted. */
+    connectionId: string;
+}
+/** Emitted when a single connection rejects a single emission. */
+export interface RouteErrorEvent {
+    /** The tuple that was dispatched. */
+    emission: Output;
+    /** Stable ID of the connection that rejected. */
+    connectionId: string;
+    /** Error message. */
+    error?: string;
+    /** Structured error info, when available. */
+    errorDetail?: B3ndError;
+}
+/** Emitted once after the operation's last route has settled. */
+export interface SettledEvent {
+    /** The pipeline-stage results returned by the await. */
+    results: ReceiveResult[];
+}
+/** Names of events the OperationHandle fires. */
+export type OperationEventName = "process:done" | "process:error" | "handle:emit" | "handle:error" | "route:success" | "route:error" | "reaction:error" | "settled";
+/** Map from event name to payload type. */
+export interface OperationEventMap {
+    "process:done": ProcessDoneEvent;
+    "process:error": ProcessErrorEvent;
+    "handle:emit": HandleEmitEvent;
+    "handle:error": HandleErrorEvent;
+    "route:success": RouteSuccessEvent;
+    "route:error": RouteErrorEvent;
+    "reaction:error": ReactionErrorEvent;
+    "settled": SettledEvent;
+}
+/**
+ * Generic event handler. Return value is ignored, but accepting any
+ * type lets handler bodies use expression-style arrow functions —
+ * `op.on("route:success", e => log.push(e.emission[0]))` — without
+ * TS yelling about the return type.
+ */
+export type OperationEventHandler<E extends OperationEventName> = (event: OperationEventMap[E]) => unknown;
+/**
+ * Promise + scoped event emitter for one rig.receive / rig.send call.
+ *
+ * Awaiting the handle resolves to the pipeline-stage `ReceiveResult[]`
+ * (one per input tuple). Subscribing to the handle observes per-stage
+ * events scoped to this operation only.
+ *
+ * Construction is internal — the Rig builds the handle, exposes it to
+ * the caller, and drives its lifecycle via the helper methods on the
+ * implementation class.
+ */
+export interface OperationHandle extends PromiseLike<ReceiveResult[]> {
+    /**
+     * Subscribe to an event scoped to this operation.
+     * Returns an unsubscribe function.
+     */
+    on<E extends OperationEventName>(event: E, handler: OperationEventHandler<E>): () => void;
+    /** Remove a previously-registered handler. */
+    off<E extends OperationEventName>(event: E, handler: OperationEventHandler<E>): void;
+    /**
+     * Convenience Promise that resolves once the `settled` event fires —
+     * i.e., every dispatched route has settled. Useful for callers who
+     * need read-after-write semantics across replicas:
+     *
+     * ```ts
+     * const op = rig.send([out]);
+     * await op;            // pipeline ack
+     * await op.settled;    // wait for all routes
+     * const data = await rig.read(out[0]);
+     * ```
+     *
+     * The same outcome is observable via `op.on("settled", …)`. This
+     * accessor exists for the common await-then-read pattern.
+     */
+    readonly settled: Promise<SettledEvent>;
+}
+/**
+ * Internal implementation. The Rig drives this via the `_pipelineDone`
+ * and `_emit` methods; callers see the `OperationHandle` interface.
+ */
+export declare class OperationHandleImpl implements OperationHandle {
+    private _listeners;
+    private _pipelinePromise;
+    private _resolvePipeline;
+    private _rejectPipeline;
+    private _settledPromise;
+    private _resolveSettled;
+    constructor();
+    /** Resolve the pipeline-stage promise. */
+    _pipelineDone(results: ReceiveResult[]): void;
+    /** Reject the pipeline-stage promise (a hook threw, etc.). */
+    _pipelineError(err: unknown): void;
+    /**
+     * Emit a scoped event. Handlers run fire-and-forget; errors caught
+     * and logged so a misbehaving handler can't break the operation.
+     * The `settled` event also resolves the `settled` promise.
+     */
+    _emit<E extends OperationEventName>(event: E, payload: OperationEventMap[E]): void;
+    on<E extends OperationEventName>(event: E, handler: OperationEventHandler<E>): () => void;
+    off<E extends OperationEventName>(event: E, handler: OperationEventHandler<E>): void;
+    get settled(): Promise<SettledEvent>;
+    then<TResult1 = ReceiveResult[], TResult2 = never>(onfulfilled?: ((value: ReceiveResult[]) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseLike<TResult1 | TResult2>;
+}
+//# sourceMappingURL=operation-handle.d.ts.map

package/esm/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/rig/operation-handle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation-handle.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/rig/operation-handle.ts"],"names":[],"mappings":"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"}

package/esm/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/rig/operation-handle.js

@@ -0,0 +1,103 @@
+/**
+ * @module
+ * Operation handles — the return value of `rig.receive()` / `rig.send()`.
+ *
+ * An OperationHandle is BOTH:
+ *   - a `Promise<ReceiveResult[]>` (the pipeline-stage acknowledgment;
+ *     resolves once `process` + `handle` finish for every input tuple),
+ *   - and a scoped event emitter that fires per-stage events for THIS
+ *     operation as it progresses (`process:done`, `handle:emit`,
+ *     `route:success`, `route:error`, `settled`).
+ *
+ * Why both shapes:
+ *   - Awaitable so existing callers (`await rig.receive(outs)`) and
+ *     `ProtocolInterfaceNode.receive` consumers see no contract change.
+ *   - Observable so callers who care about per-stage detail or per-route
+ *     dispatch outcomes can subscribe inline, without correlation IDs
+ *     or filtering global rig events.
+ *
+ * Single paper-trail: the events are the source of truth. The result
+ * the await resolves to (`ReceiveResult[]`) is the small pipeline-level
+ * ack; everything richer flows through events.
+ *
+ * Dispatch is async by design: `await op` resolves once the pipeline
+ * decides what to dispatch, but the broadcast itself runs in the
+ * background. Per-route events fire after the await has returned.
+ * Callers that need full settlement await `op.settled` (a Promise that
+ * resolves on the `settled` event).
+ */
+/**
+ * Internal implementation. The Rig drives this via the `_pipelineDone`
+ * and `_emit` methods; callers see the `OperationHandle` interface.
+ */
+export class OperationHandleImpl {
+    _listeners = [];
+    _pipelinePromise;
+    _resolvePipeline;
+    _rejectPipeline;
+    _settledPromise;
+    _resolveSettled;
+    constructor() {
+        this._pipelinePromise = new Promise((resolve, reject) => {
+            this._resolvePipeline = resolve;
+            this._rejectPipeline = reject;
+        });
+        this._settledPromise = new Promise((resolve) => {
+            this._resolveSettled = resolve;
+        });
+    }
+    // ── Internal driver methods (called by the Rig) ──
+    /** Resolve the pipeline-stage promise. */
+    _pipelineDone(results) {
+        this._resolvePipeline(results);
+    }
+    /** Reject the pipeline-stage promise (a hook threw, etc.). */
+    _pipelineError(err) {
+        this._rejectPipeline(err);
+    }
+    /**
+     * Emit a scoped event. Handlers run fire-and-forget; errors caught
+     * and logged so a misbehaving handler can't break the operation.
+     * The `settled` event also resolves the `settled` promise.
+     */
+    _emit(event, payload) {
+        // Schedule handler microtasks BEFORE resolving the settled promise.
+        // Microtask order is FIFO, so handlers' microtasks run before any
+        // `await op.settled` continuation. This matters for tests/callers
+        // that subscribe to `settled` and inspect state right after
+        // awaiting `op.settled`.
+        for (const entry of this._listeners) {
+            if (entry.event !== event)
+                continue;
+            Promise.resolve()
+                .then(() => entry.handler(payload))
+                .catch((err) => {
+                console.warn(`[rig] operation listener error on "${event}":`, err);
+            });
+        }
+        if (event === "settled") {
+            this._resolveSettled(payload);
+        }
+    }
+    // ── Public OperationHandle interface ──
+    on(event, handler) {
+        const entry = {
+            event,
+            handler: handler,
+        };
+        this._listeners.push(entry);
+        return () => this.off(event, handler);
+    }
+    off(event, handler) {
+        const idx = this._listeners.findIndex((e) => e.event === event && e.handler === handler);
+        if (idx >= 0)
+            this._listeners.splice(idx, 1);
+    }
+    get settled() {
+        return this._settledPromise;
+    }
+    // PromiseLike implementation — delegates to the pipeline promise.
+    then(onfulfilled, onrejected) {
+        return this._pipelinePromise.then(onfulfilled, onrejected);
+    }
+}

package/esm/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/rig/reactions.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @module
+ * Reaction registry for the Rig.
+ *
+ * Reactions fire on successfully dispatched outputs (via send/receive)
+ * whose URI matches a registered pattern. Patterns use the shared glob
+ * grammar (`*` for one segment, `**` for the rest).
+ *
+ * Reactions are pure: they take the dispatched output and a `read`
+ * function and return `Output[]`. The Rig feeds those returned tuples
+ * back through `rig.send` (full pipeline — programs run, handlers run,
+ * more reactions can fire).
+ *
+ * Reactions receive only the dispatched output; if a handler needs a
+ * segment value, it extracts it from the URI directly.
+ *
+ * Pure module — no Rig dependency, testable in isolation.
+ */
+import type { Output, ReadFn } from "../types/types.js";
+/**
+ * Reaction handler — called when a dispatched URI matches the pattern.
+ *
+ * Receives the dispatched output and a read function. Returns the tuples
+ * the Rig should put on the wire as a consequence of what the reaction
+ * observed; those flow through full `rig.send` (programs + handlers +
+ * more reactions).
+ *
+ * Returning `[]` means "I observed it but emit nothing further."
+ */
+export type Reaction = (out: Output, read: ReadFn) => Promise<Output[]>;
+/** @deprecated alias kept for migration; prefer `Reaction`. */
+export type ReactionHandler = Reaction;
+/**
+ * Registry of URI-pattern-matched reaction handlers.
+ *
+ * Use `match()` to find matching reactions for a dispatched URI; the
+ * caller (the Rig) is responsible for invoking each reaction and
+ * routing its returned tuples back through the pipeline.
+ */
+export declare class ReactionRegistry {
+    private entries;
+    /**
+     * Register a reaction handler for a URI pattern.
+     * Returns an unsubscribe function.
+     */
+    add(pattern: string, handler: Reaction): () => void;
+    /**
+     * Find every reaction whose pattern matches `uri`. Returns the list
+     * of `(pattern, handler)` pairs the caller can invoke.
+     */
+    matches(uri: string): {
+        pattern: string;
+        handler: Reaction;
+    }[];
+    /** Whether any patterns are registered. */
+    get size(): number;
+}
+//# sourceMappingURL=reactions.d.ts.map

package/esm/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/rig/reactions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactions.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/rig/reactions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAMH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAIxD;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,GAAG,CACrB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,KACT,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;AAEvB,+DAA+D;AAC/D,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;AAavC;;;;;;GAMG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,OAAO,CAAuB;IAEtC;;;OAGG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,GAAG,MAAM,IAAI;IAanD;;;OAGG;IACH,OAAO,CACL,GAAG,EAAE,MAAM,GACV;QACD,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,QAAQ,CAAC;KACnB,EAAE;IAUH,2CAA2C;IAC3C,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/esm/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/rig/reactions.js

@@ -0,0 +1,64 @@
+/**
+ * @module
+ * Reaction registry for the Rig.
+ *
+ * Reactions fire on successfully dispatched outputs (via send/receive)
+ * whose URI matches a registered pattern. Patterns use the shared glob
+ * grammar (`*` for one segment, `**` for the rest).
+ *
+ * Reactions are pure: they take the dispatched output and a `read`
+ * function and return `Output[]`. The Rig feeds those returned tuples
+ * back through `rig.send` (full pipeline — programs run, handlers run,
+ * more reactions can fire).
+ *
+ * Reactions receive only the dispatched output; if a handler needs a
+ * segment value, it extracts it from the URI directly.
+ *
+ * Pure module — no Rig dependency, testable in isolation.
+ */
+import { compilePattern, } from "../match-pattern/match-pattern.js";
+// ── Registry ──
+/**
+ * Registry of URI-pattern-matched reaction handlers.
+ *
+ * Use `match()` to find matching reactions for a dispatched URI; the
+ * caller (the Rig) is responsible for invoking each reaction and
+ * routing its returned tuples back through the pipeline.
+ */
+export class ReactionRegistry {
+    entries = [];
+    /**
+     * Register a reaction handler for a URI pattern.
+     * Returns an unsubscribe function.
+     */
+    add(pattern, handler) {
+        const entry = {
+            pattern,
+            matcher: compilePattern(pattern),
+            handler,
+        };
+        this.entries.push(entry);
+        return () => {
+            const idx = this.entries.indexOf(entry);
+            if (idx >= 0)
+                this.entries.splice(idx, 1);
+        };
+    }
+    /**
+     * Find every reaction whose pattern matches `uri`. Returns the list
+     * of `(pattern, handler)` pairs the caller can invoke.
+     */
+    matches(uri) {
+        const out = [];
+        for (const entry of this.entries) {
+            if (entry.matcher(uri)) {
+                out.push({ pattern: entry.pattern, handler: entry.handler });
+            }
+        }
+        return out;
+    }
+    /** Whether any patterns are registered. */
+    get size() {
+        return this.entries.length;
+    }
+}