@bandeira-tech/b3nd-save 0.8.1

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

@@ -0,0 +1,54 @@
+/**
+ * @module
+ * FunctionalClient - A client that takes functions as config.
+ *
+ * Replaces createNode() for cases where you want to wire up
+ * custom behavior without class inheritance.
+ */
+/**
+ * A client that delegates each method to a config function.
+ *
+ * If a method is not provided, it returns a sensible default:
+ * - receive → { accepted: false, error: "not implemented" }
+ * - read → [{ success: false, error: "not implemented" }] per URI
+ * - status → { status: "healthy" }
+ *
+ * @example
+ * ```typescript
+ * const client = new FunctionalClient({
+ *   receive: async (msg) => backend.receive(msg),
+ *   read: async (urls) => backend.read(urls),
+ * });
+ * ```
+ */
+export class FunctionalClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    receive(msgs) {
+        if (this.config.receive) {
+            return this.config.receive(msgs);
+        }
+        return Promise.resolve(msgs.map(() => ({ accepted: false, error: "not implemented" })));
+    }
+    read(urls) {
+        if (this.config.read) {
+            return this.config.read(urls);
+        }
+        // No read config → empty result (option-A absence semantics).
+        return Promise.resolve([]);
+    }
+    async *observe(urls, signal) {
+        if (this.config.observe) {
+            yield* this.config.observe(urls, signal);
+        }
+        // No observe config → empty stream (never yields)
+    }
+    status() {
+        if (this.config.status) {
+            return this.config.status();
+        }
+        return Promise.resolve({ status: "healthy" });
+    }
+}

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

@@ -0,0 +1,47 @@
+/**
+ * @module
+ * URI pattern matching — shared by the rig (routing, reactions) and the
+ * observe emitter.
+ *
+ * Grammar (segments separated by `/`):
+ * - **literal** segments must match exactly.
+ * - `*` matches **exactly one** non-empty segment.
+ * - `**` matches **zero or more** remaining segments. Only valid as a
+ *   complete final segment.
+ *
+ * Patterns compile to a closure once; the closure is called per URI.
+ * Three compile paths, picked at compile time:
+ *
+ *   1. **Pure literal** (no metas)  → `(uri) => uri === pattern`
+ *   2. **Trailing `**` only**       → `(uri) => uri.startsWith(prefix)`
+ *   3. **Has a `*` somewhere**      → compiled `RegExp`, matched via `test`.
+ *
+ * Captures are intentionally not exposed. Callers that need a segment
+ * value extract it from the URI directly (split on `/`, pick the index).
+ * Keeping the matcher bool-only collapses three callers — routing,
+ * observe, reactions — onto one fast path with no allocations.
+ */
+/** A compiled pattern: takes a URI, returns whether it matches. */
+export type Matcher = (uri: string) => boolean;
+/**
+ * Compile a pattern string into a matcher closure.
+ *
+ * Throws `TypeError` on grammar violations:
+ * - `:param`-style segments (legacy; use `*` and extract from the URI).
+ * - `*` mixed into a segment with other chars (e.g. `abc*`, `*abc`).
+ * - `**` not as a complete final segment (e.g. `** /x`, `a/** b`).
+ *
+ * @example
+ * ```ts
+ * const m = compilePattern("mutable://**");
+ * m("mutable://users/alice"); // true
+ * m("hash://abc");            // false
+ * ```
+ */
+export declare function compilePattern(pattern: string): Matcher;
+/**
+ * One-shot matcher. Compiles the pattern every call — fine for ad-hoc
+ * use; prefer `compilePattern` for anything hot.
+ */
+export declare function matches(pattern: string, uri: string): boolean;
+//# sourceMappingURL=match-pattern.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"match-pattern.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/match-pattern/match-pattern.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,mEAAmE;AACnE,MAAM,MAAM,OAAO,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;AAE/C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAcvD;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAE7D"}

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

@@ -0,0 +1,134 @@
+/**
+ * @module
+ * URI pattern matching — shared by the rig (routing, reactions) and the
+ * observe emitter.
+ *
+ * Grammar (segments separated by `/`):
+ * - **literal** segments must match exactly.
+ * - `*` matches **exactly one** non-empty segment.
+ * - `**` matches **zero or more** remaining segments. Only valid as a
+ *   complete final segment.
+ *
+ * Patterns compile to a closure once; the closure is called per URI.
+ * Three compile paths, picked at compile time:
+ *
+ *   1. **Pure literal** (no metas)  → `(uri) => uri === pattern`
+ *   2. **Trailing `**` only**       → `(uri) => uri.startsWith(prefix)`
+ *   3. **Has a `*` somewhere**      → compiled `RegExp`, matched via `test`.
+ *
+ * Captures are intentionally not exposed. Callers that need a segment
+ * value extract it from the URI directly (split on `/`, pick the index).
+ * Keeping the matcher bool-only collapses three callers — routing,
+ * observe, reactions — onto one fast path with no allocations.
+ */
+/**
+ * Compile a pattern string into a matcher closure.
+ *
+ * Throws `TypeError` on grammar violations:
+ * - `:param`-style segments (legacy; use `*` and extract from the URI).
+ * - `*` mixed into a segment with other chars (e.g. `abc*`, `*abc`).
+ * - `**` not as a complete final segment (e.g. `** /x`, `a/** b`).
+ *
+ * @example
+ * ```ts
+ * const m = compilePattern("mutable://**");
+ * m("mutable://users/alice"); // true
+ * m("hash://abc");            // false
+ * ```
+ */
+export function compilePattern(pattern) {
+    const analysis = analyze(pattern);
+    if (analysis.kind === "literal") {
+        return (uri) => uri === pattern;
+    }
+    if (analysis.kind === "prefix") {
+        const prefix = analysis.prefix;
+        return (uri) => uri.startsWith(prefix);
+    }
+    const re = analysis.re;
+    return (uri) => re.test(uri);
+}
+/**
+ * One-shot matcher. Compiles the pattern every call — fine for ad-hoc
+ * use; prefer `compilePattern` for anything hot.
+ */
+export function matches(pattern, uri) {
+    return compilePattern(pattern)(uri);
+}
+/**
+ * Walk the pattern once, segment-aware:
+ *  - reject `:foo` segments (legacy capture syntax),
+ *  - reject mixed-meta segments like `abc*` or `**x`,
+ *  - detect a trailing `**` for the `startsWith` fast path,
+ *  - detect any `*` to switch to the regex path.
+ */
+function analyze(pattern) {
+    const len = pattern.length;
+    let hasSingleStar = false;
+    let trailingDoubleStarAt = -1;
+    let segStart = 0;
+    for (let i = 0; i <= len; i++) {
+        if (i === len || pattern.charCodeAt(i) === 47 /* / */) {
+            const seg = pattern.slice(segStart, i);
+            classifySegment(seg, i === len);
+            if (seg === "**") {
+                if (i !== len) {
+                    // `**` only valid as the last segment.
+                    throw new TypeError(`pattern "${pattern}": "**" must be the final segment`);
+                }
+                // Position of the `**` in the original string (segStart).
+                trailingDoubleStarAt = segStart;
+            }
+            else if (seg === "*") {
+                hasSingleStar = true;
+            }
+            segStart = i + 1;
+        }
+    }
+    if (!hasSingleStar && trailingDoubleStarAt < 0) {
+        return { kind: "literal" };
+    }
+    if (!hasSingleStar && trailingDoubleStarAt >= 0) {
+        // Strip the trailing `**` (and the `/` before it, if any).
+        // segStart for `**` is the char *after* the leading `/`, so
+        // `pattern.slice(0, trailingDoubleStarAt)` keeps the trailing `/`.
+        return { kind: "prefix", prefix: pattern.slice(0, trailingDoubleStarAt) };
+    }
+    return { kind: "regex", re: toRegex(pattern) };
+}
+function classifySegment(seg, _isLast) {
+    if (seg === "*" || seg === "**" || !seg.includes("*")) {
+        if (seg.startsWith(":")) {
+            throw new TypeError(`pattern segment ":${seg.slice(1)}": ":param" syntax was removed; ` +
+                `use "*" and extract the value from the URI`);
+        }
+        return;
+    }
+    // Segment contains `*` mixed with other chars (e.g. `abc*`, `*x`, `a**b`).
+    throw new TypeError(`pattern segment "${seg}": "*" and "**" must be complete segments`);
+}
+/** Build a regex from a pattern containing `*` (and optionally trailing `**`). */
+function toRegex(pattern) {
+    // Replace meta segments with placeholders that survive escaping, then
+    // escape, then swap placeholders for their regex equivalents.
+    //
+    // `*`  (full segment) → `[^/]+`   (one non-empty segment)
+    // `**` (trailing seg) → `.*`      (zero or more remaining chars; the
+    //                                  leading `/` before `**` is preserved
+    //                                  by the surrounding pattern when the
+    //                                  pattern has more than one segment,
+    //                                  and absent when `**` is the whole
+    //                                  pattern — both fall out naturally).
+    const ONE = "\x00ONE\x00";
+    const REST = "\x00REST\x00";
+    // Tokenize on `/` so we only swap full-segment metas.
+    const swapped = pattern
+        .split("/")
+        .map((seg) => seg === "*" ? ONE : seg === "**" ? REST : seg)
+        .join("/");
+    const escaped = swapped.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+    const body = escaped
+        .replaceAll(ONE, "[^/]+")
+        .replaceAll(REST, ".*");
+    return new RegExp(`^${body}$`);
+}

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

@@ -0,0 +1,20 @@
+/**
+ * @module
+ * Peer decorators — middleware that wraps a client while preserving the
+ * `ProtocolInterfaceNode` shape. Applied via `peer(client, { via: [decorator] })`.
+ */
+import type { PeerDecorator } from "./types.js";
+/**
+ * Swallow `receive()` errors and report them as accepted.
+ *
+ * Use for best-effort push: when you want a one-peer failure to be
+ * logged and otherwise ignored rather than aborting the whole fan-out.
+ * Every other method (read, observe, status) is passed through
+ * unchanged so bridges and observers behave normally.
+ *
+ * ```ts
+ * peer(remoteClient, { via: [bestEffort] })
+ * ```
+ */
+export declare const bestEffort: PeerDecorator;
+//# sourceMappingURL=decorators.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/network/decorators.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,EAAE,aAiBvB,CAAC"}

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

@@ -0,0 +1,34 @@
+/**
+ * @module
+ * Peer decorators — middleware that wraps a client while preserving the
+ * `ProtocolInterfaceNode` shape. Applied via `peer(client, { via: [decorator] })`.
+ */
+/**
+ * Swallow `receive()` errors and report them as accepted.
+ *
+ * Use for best-effort push: when you want a one-peer failure to be
+ * logged and otherwise ignored rather than aborting the whole fan-out.
+ * Every other method (read, observe, status) is passed through
+ * unchanged so bridges and observers behave normally.
+ *
+ * ```ts
+ * peer(remoteClient, { via: [bestEffort] })
+ * ```
+ */
+export const bestEffort = (client) => ({
+    async receive(msgs) {
+        try {
+            return await client.receive(msgs);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.warn(`[peer] best-effort receive failed: ${msg}`);
+            return msgs.map(() => ({ accepted: true }));
+        }
+    },
+    read: (urls) => client.read(urls),
+    observe: (urls, signal) => client.observe(urls, signal),
+    // bestEffort decorator preserves the underlying client's observe
+    // and read shape; the only enhancement is non-fatal receive.
+    status: () => client.status(),
+});

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

@@ -0,0 +1,46 @@
+/**
+ * @module
+ * `network(target, peers, policies?, opts?)` — the participant verb.
+ *
+ * Subscribes each peer's observe stream, passes events through the
+ * (optional) chain of `Policy.receive` hooks, and forwards yielded
+ * events into `target.receive`. Returns an async unbind that aborts
+ * every peer loop and awaits clean teardown.
+ *
+ * ```ts
+ * import { network, peer, pathVector } from "@bandeira-tech/b3nd-core/network";
+ *
+ * const unbind = network(rig, peers);                           // no policies
+ * const unbind = network(rig, peers, [myPolicy]);               // one policy
+ * const unbind = network(rig, peers, [filter, tellAndRead], {   // multiple, chained
+ *   pattern: "mutable://chat/**",
+ * });
+ *
+ * await unbind();
+ * ```
+ *
+ * `network()` is not a `ProtocolInterfaceNode`. Passing a peer list to
+ * a strategy factory (`flood(peers)`, `pathVector(peers)`) is how you
+ * build the remote-client shape for `connection()`.
+ */
+import type { ProtocolInterfaceNode } from "../types/types.js";
+import type { NetworkOptions, Peer, Policy } from "./types.js";
+/**
+ * Wire peers into a target's `receive` pipeline.
+ *
+ * Returns an async unbind; calling it aborts each peer's observe signal
+ * and awaits the per-peer loops so teardown is resource-sanitizer-clean.
+ * Idempotent — calling twice is a no-op.
+ */
+export declare function network(target: Pick<ProtocolInterfaceNode, "receive">, peers: Peer[], policies?: Policy[], opts?: NetworkOptions): () => Promise<void>;
+/**
+ * Shared peer-list validation. Exported for strategy factories that
+ * want the same uniqueness / non-empty guarantees.
+ *
+ * @internal
+ */
+export declare function validatePeers(peers: Peer[]): {
+    originId: string;
+    peers: readonly Peer[];
+};
+//# sourceMappingURL=network.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/network/network.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAU,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AACvE,OAAO,KAAK,EAAc,cAAc,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAE3E;;;;;;GAMG;AACH,wBAAgB,OAAO,CACrB,MAAM,EAAE,IAAI,CAAC,qBAAqB,EAAE,SAAS,CAAC,EAC9C,KAAK,EAAE,IAAI,EAAE,EACb,QAAQ,GAAE,MAAM,EAAO,EACvB,IAAI,GAAE,cAAmB,GACxB,MAAM,OAAO,CAAC,IAAI,CAAC,CAiBrB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,IAAI,EAAE,GACZ;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAA;CAAE,CAe9C"}

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

@@ -0,0 +1,131 @@
+/**
+ * @module
+ * `network(target, peers, policies?, opts?)` — the participant verb.
+ *
+ * Subscribes each peer's observe stream, passes events through the
+ * (optional) chain of `Policy.receive` hooks, and forwards yielded
+ * events into `target.receive`. Returns an async unbind that aborts
+ * every peer loop and awaits clean teardown.
+ *
+ * ```ts
+ * import { network, peer, pathVector } from "@bandeira-tech/b3nd-core/network";
+ *
+ * const unbind = network(rig, peers);                           // no policies
+ * const unbind = network(rig, peers, [myPolicy]);               // one policy
+ * const unbind = network(rig, peers, [filter, tellAndRead], {   // multiple, chained
+ *   pattern: "mutable://chat/**",
+ * });
+ *
+ * await unbind();
+ * ```
+ *
+ * `network()` is not a `ProtocolInterfaceNode`. Passing a peer list to
+ * a strategy factory (`flood(peers)`, `pathVector(peers)`) is how you
+ * build the remote-client shape for `connection()`.
+ */
+/**
+ * Wire peers into a target's `receive` pipeline.
+ *
+ * Returns an async unbind; calling it aborts each peer's observe signal
+ * and awaits the per-peer loops so teardown is resource-sanitizer-clean.
+ * Idempotent — calling twice is a no-op.
+ */
+export function network(target, peers, policies = [], opts = {}) {
+    const { originId, peers: frozenPeers } = validatePeers(peers);
+    const pattern = opts.pattern ?? "**";
+    const onError = opts.onError ?? (() => { });
+    const ac = new AbortController();
+    const tasks = frozenPeers.map((peer) => runPeer(peer, policies, originId, target, pattern, ac.signal, onError));
+    let unbound = false;
+    return async () => {
+        if (unbound)
+            return;
+        unbound = true;
+        ac.abort();
+        await Promise.allSettled(tasks);
+    };
+}
+/**
+ * Shared peer-list validation. Exported for strategy factories that
+ * want the same uniqueness / non-empty guarantees.
+ *
+ * @internal
+ */
+export function validatePeers(peers) {
+    if (!peers || peers.length === 0) {
+        throw new Error("peers[] must be non-empty");
+    }
+    const ids = new Set();
+    for (const p of peers) {
+        if (ids.has(p.id)) {
+            throw new Error(`duplicate peer id "${p.id}"`);
+        }
+        ids.add(p.id);
+    }
+    return {
+        originId: `net-${crypto.randomUUID()}`,
+        peers: Object.freeze([...peers]),
+    };
+}
+// ── Internals: the bridge ─────────────────────────────────────────────
+/**
+ * One peer's subscription loop. Kept as a separate function (not an
+ * inline IIFE) so error stacks identify the misbehaving peer.
+ */
+async function runPeer(peer, policies, originId, target, pattern, signal, onError) {
+    const ctx = { originId, source: peer };
+    const hooks = policies
+        .map((p) => p.receive?.bind(p))
+        .filter((r) => r !== undefined);
+    try {
+        for await (const uris of peer.client.observe([pattern], signal)) {
+            if (signal.aborted)
+                break;
+            // INV bundles: the observe event lists uris that changed. Pull
+            // the current state from the peer for each so policies see
+            // Outputs with the content attached.
+            for (const noteUri of uris) {
+                if (signal.aborted)
+                    break;
+                const fetched = await peer.client.read([noteUri]);
+                for (const ev of fetched) {
+                    for await (const out of foldReceive(ev, hooks, peer, ctx)) {
+                        if (signal.aborted)
+                            break;
+                        await forward(target, out, onError, peer.id);
+                    }
+                }
+            }
+        }
+    }
+    catch (err) {
+        onError(toError(err), { peerId: peer.id });
+    }
+}
+/**
+ * Fold `hooks` over `ev`: apply `hooks[0]` to `ev`, then `hooks[1]` to
+ * each event yielded, and so on. The result is one merged stream of
+ * Outputs the target should receive.
+ */
+async function* foldReceive(ev, hooks, source, ctx) {
+    if (hooks.length === 0) {
+        yield ev;
+        return;
+    }
+    const [first, ...rest] = hooks;
+    for await (const out of first(ev, source, ctx)) {
+        yield* foldReceive(out, rest, source, ctx);
+    }
+}
+/** Forward one Output into the target's `receive`. Swallows errors via `onError`. */
+async function forward(target, ev, onError, peerId) {
+    try {
+        await target.receive([ev]);
+    }
+    catch (err) {
+        onError(toError(err), { peerId });
+    }
+}
+function toError(e) {
+    return e instanceof Error ? e : new Error(String(e));
+}

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

@@ -0,0 +1,27 @@
+/**
+ * @module
+ * `peer()` — construct a Peer from a client, optionally applying decorators
+ * and pinning an explicit id.
+ */
+import type { ProtocolInterfaceNode } from "../types/types.js";
+import type { Peer, PeerDecorator } from "./types.js";
+/**
+ * Create a Peer from a client.
+ *
+ * @example
+ * ```ts
+ * // Anonymous peer — id auto-assigned at runtime
+ * peer(remoteClient)
+ *
+ * // Protocol with path-vector loop avoidance — id matches the peer's pubkey
+ * peer(client, { id: peerPubkeyHex })
+ *
+ * // Stack middleware
+ * peer(client, { via: [bestEffort, rateLimited(10)] })
+ * ```
+ */
+export declare function peer(client: ProtocolInterfaceNode, opts?: {
+    id?: string;
+    via?: PeerDecorator[];
+}): Peer;
+//# sourceMappingURL=peer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"peer.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/network/peer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,IAAI,CAClB,MAAM,EAAE,qBAAqB,EAC7B,IAAI,GAAE;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,aAAa,EAAE,CAAA;CAAO,GAChD,IAAI,CAON"}

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

@@ -0,0 +1,25 @@
+/**
+ * @module
+ * `peer()` — construct a Peer from a client, optionally applying decorators
+ * and pinning an explicit id.
+ */
+/**
+ * Create a Peer from a client.
+ *
+ * @example
+ * ```ts
+ * // Anonymous peer — id auto-assigned at runtime
+ * peer(remoteClient)
+ *
+ * // Protocol with path-vector loop avoidance — id matches the peer's pubkey
+ * peer(client, { id: peerPubkeyHex })
+ *
+ * // Stack middleware
+ * peer(client, { via: [bestEffort, rateLimited(10)] })
+ * ```
+ */
+export function peer(client, opts = {}) {
+    const id = opts.id ?? `peer-${crypto.randomUUID()}`;
+    const decorated = (opts.via ?? []).reduce((c, decorator) => decorator(c), client);
+    return { id, client: decorated };
+}

package/esm/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/network/policies/flood.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @module
+ * `flood(peers)` — the baseline remote-client strategy.
+ *
+ * Returns a `ProtocolInterfaceNode` that:
+ * - **receive**: fans every write out to every peer in parallel
+ * - **read**: tries peers in order and returns the first successful hit
+ * - **observe**: merges every peer's observe stream into one iterator
+ * - **status**: aggregates peer health (healthy / degraded / unhealthy)
+ *
+ * Use as a rig connection:
+ *
+ * ```ts
+ * import { connection, Rig } from "@bandeira-tech/b3nd-core";
+ * import { flood, peer } from "@bandeira-tech/b3nd-core/network";
+ *
+ * const peers = connection(flood([peer(remoteClient)]), ["**"]);
+ * const rig = new Rig({
+ *   routes: { receive: [peers], read: [peers], observe: [peers] },
+ * });
+ * ```
+ *
+ * For bidirectional signed meshes that need loop avoidance, use
+ * `pathVector(peers)` instead — same shape, plus a signer-chain filter
+ * on outbound.
+ *
+ * ## Error handling
+ *
+ * - `receive` propagates transport-level failures — one peer rejecting
+ *   aborts the fan-out. Wrap individual peers with the `bestEffort`
+ *   decorator if you want per-peer failures to be non-fatal.
+ * - `read` falls through: a failing peer is skipped, and if no peer
+ *   returns a hit the result is a `not-found` per input URI.
+ * - `observe` silently drops a peer whose stream throws (the merged
+ *   stream keeps flowing from the remaining peers). This is
+ *   intentional — `flood` is a one-shot PIN with no `onError` hook.
+ *   For observability over the inbound side, use `network()`, which
+ *   accepts an `onError` callback and reports per-peer failures.
+ * - `status` aggregates; individual unhealthy peers degrade the
+ *   overall status rather than throwing.
+ */
+import type { Output, ProtocolInterfaceNode } from "../../types/types.js";
+import type { Peer } from "../types.js";
+/**
+ * Build a flood PIN from peers. Peers must have unique ids and the list
+ * must be non-empty.
+ */
+export declare function flood(peers: Peer[]): ProtocolInterfaceNode;
+/**
+ * Internal shared implementation used by `flood`, `pathVector`, and
+ * `tellAndRead.outbound`. The `transform` rewrites the per-peer
+ * outbound batch: return `msgs` unchanged to flood as-is, return a
+ * subset to filter, return rewritten outputs to change what the peer
+ * receives, or return `[]` to skip the peer entirely.
+ *
+ * @internal
+ */
+export declare function floodImpl(originId: string, peers: readonly Peer[], transform: (msgs: Output[], peer: Peer) => Output[]): ProtocolInterfaceNode;
+//# sourceMappingURL=flood.d.ts.map

package/esm/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/network/policies/flood.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flood.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/network/policies/flood.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,KAAK,EACV,MAAM,EACN,qBAAqB,EAGtB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAGxC;;;GAGG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,qBAAqB,CAG1D;AAmBD;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACvB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,KAAK,MAAM,EAAE,GAClD,qBAAqB,CAsHvB"}