@bandeira-tech/b3nd-save 0.8.1

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

@@ -0,0 +1,188 @@
+/**
+ * @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 { validatePeers } from "../network.js";
+/**
+ * Build a flood PIN from peers. Peers must have unique ids and the list
+ * must be non-empty.
+ */
+export function flood(peers) {
+    const { originId, peers: frozenPeers } = validatePeers(peers);
+    return floodImpl(originId, frozenPeers, identityTransform);
+}
+const identityTransform = (xs) => xs;
+/**
+ * Treat both `undefined` and `null` (common miss representations
+ * across protocols), and `[]` (empty ls), as "empty — try next peer."
+ * Everything else — including `0` from `fn=count` — is a real answer.
+ *
+ * Protocols that intentionally store `null` will see those treated as
+ * misses by flood; pair a different aggregation policy with such
+ * protocols, or wrap the null in a sentinel.
+ */
+function isEmptyPayload(payload) {
+    if (payload === undefined || payload === null)
+        return true;
+    if (Array.isArray(payload) && payload.length === 0)
+        return true;
+    return false;
+}
+/**
+ * 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 function floodImpl(originId, peers, transform) {
+    return {
+        // ── receive ──────────────────────────────────────────────────────
+        async receive(msgs) {
+            if (msgs.length === 0)
+                return [];
+            await Promise.all(peers.map(async (p) => {
+                const outbound = transform(msgs, p);
+                if (outbound.length === 0)
+                    return;
+                await p.client.receive(outbound);
+            }));
+            // Success per *input* message — we fanned out to the peers the
+            // transform selected. Transport-level failures throw and
+            // propagate; wrap individual peers with a best-effort decorator
+            // if you want rejection tolerance.
+            return msgs.map(() => ({ accepted: true }));
+        },
+        // ── read ─────────────────────────────────────────────────────────
+        async read(urls) {
+            if (urls.length === 0)
+                return [];
+            // 1:1 with input. Per url, try peers in order; first peer that
+            // returns a non-empty payload wins. "Empty" = `undefined` for
+            // point reads, `[]` for `fn=ls`, `0` for `fn=count`. If every
+            // peer is empty (or throws), the slot stays empty (`undefined`).
+            // Transport errors are swallowed per-peer.
+            const out = await Promise.all(urls.map(async (url) => {
+                let fallback = [url, undefined];
+                for (const p of peers) {
+                    try {
+                        const [r] = await p.client.read([url]);
+                        if (!r)
+                            continue;
+                        fallback = r;
+                        if (!isEmptyPayload(r[1]))
+                            return r;
+                    }
+                    catch {
+                        // try next peer
+                    }
+                }
+                return fallback;
+            }));
+            return out;
+        },
+        // ── observe ──────────────────────────────────────────────────────
+        async *observe(urls, signal) {
+            const queue = [];
+            let wake = null;
+            const forwarders = peers.map(async (p) => {
+                try {
+                    for await (const r of p.client.observe(urls, signal)) {
+                        queue.push(r);
+                        const w = wake;
+                        if (w) {
+                            wake = null;
+                            w();
+                        }
+                    }
+                }
+                catch {
+                    // Per-peer observe errors are swallowed — one broken peer
+                    // should not tear down the merged stream. The signal is still
+                    // the caller's mechanism to stop everything.
+                }
+            });
+            const onAbort = () => {
+                const w = wake;
+                if (w) {
+                    wake = null;
+                    w();
+                }
+            };
+            signal.addEventListener("abort", onAbort, { once: true });
+            try {
+                while (true) {
+                    while (queue.length > 0)
+                        yield queue.shift();
+                    if (signal.aborted)
+                        return;
+                    await new Promise((resolve) => {
+                        wake = resolve;
+                    });
+                }
+            }
+            finally {
+                signal.removeEventListener("abort", onAbort);
+                await Promise.allSettled(forwarders);
+            }
+        },
+        // ── status ───────────────────────────────────────────────────────
+        async status() {
+            const settled = await Promise.allSettled(peers.map((p) => p.client.status()));
+            let healthy = 0;
+            for (const s of settled) {
+                if (s.status === "fulfilled" && s.value.status === "healthy")
+                    healthy++;
+            }
+            const total = peers.length;
+            return {
+                status: healthy === total
+                    ? "healthy"
+                    : healthy > 0
+                        ? "degraded"
+                        : "unhealthy",
+                message: `${healthy}/${total} peers healthy`,
+                details: { originId, peerCount: total, healthyPeers: healthy },
+            };
+        },
+    };
+}

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

@@ -0,0 +1,35 @@
+/**
+ * @module
+ * `pathVector(peers)` — flood with signer-chain loop avoidance.
+ *
+ * Returns the same shape as `flood(peers)` but filters the outbound fan
+ * per-peer: before sending a message to peer P, inspect
+ * `data.auth[*].pubkey` on the message (the signer chain of an
+ * `AuthenticatedMessage`-shaped payload); if P's id appears in that
+ * chain, skip P — they have already seen (or signed) the message.
+ *
+ * Handles arbitrary-length cycles (A → B → C → A) without any state,
+ * because the chain grows with every relay that re-signs. Works "for
+ * free" when messages are signed with `Identity.sign()` + `message()`.
+ *
+ * ## Peer id convention
+ *
+ * For this to work, each `peer.id` must equal the peer's signing pubkey
+ * (typically the hex-encoded Ed25519 key):
+ *
+ * ```ts
+ * peer(client, { id: peerPubkeyHex })
+ * ```
+ *
+ * Auto-assigned UUID ids never match any signer and the filter becomes
+ * a no-op — pathVector then degenerates to plain `flood`.
+ *
+ * ## Scope
+ *
+ * pathVector only *reads* the chain. It does not add the local
+ * identity's signature on relay — that's the application's responsibility.
+ */
+import type { ProtocolInterfaceNode } from "../../types/types.js";
+import type { Peer } from "../types.js";
+export declare function pathVector(peers: Peer[]): ProtocolInterfaceNode;
+//# sourceMappingURL=path-vector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"path-vector.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/network/policies/path-vector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EAAU,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC1E,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAIxC,wBAAgB,UAAU,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,qBAAqB,CAO/D"}

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

@@ -0,0 +1,57 @@
+/**
+ * @module
+ * `pathVector(peers)` — flood with signer-chain loop avoidance.
+ *
+ * Returns the same shape as `flood(peers)` but filters the outbound fan
+ * per-peer: before sending a message to peer P, inspect
+ * `data.auth[*].pubkey` on the message (the signer chain of an
+ * `AuthenticatedMessage`-shaped payload); if P's id appears in that
+ * chain, skip P — they have already seen (or signed) the message.
+ *
+ * Handles arbitrary-length cycles (A → B → C → A) without any state,
+ * because the chain grows with every relay that re-signs. Works "for
+ * free" when messages are signed with `Identity.sign()` + `message()`.
+ *
+ * ## Peer id convention
+ *
+ * For this to work, each `peer.id` must equal the peer's signing pubkey
+ * (typically the hex-encoded Ed25519 key):
+ *
+ * ```ts
+ * peer(client, { id: peerPubkeyHex })
+ * ```
+ *
+ * Auto-assigned UUID ids never match any signer and the filter becomes
+ * a no-op — pathVector then degenerates to plain `flood`.
+ *
+ * ## Scope
+ *
+ * pathVector only *reads* the chain. It does not add the local
+ * identity's signature on relay — that's the application's responsibility.
+ */
+import { validatePeers } from "../network.js";
+import { floodImpl } from "./flood.js";
+export function pathVector(peers) {
+    const { originId, peers: frozenPeers } = validatePeers(peers);
+    return floodImpl(originId, frozenPeers, (msgs, peer) => msgs.filter((m) => !signerChain(m).includes(peer.id)));
+}
+/**
+ * Extract the list of signer pubkeys from an `AuthenticatedMessage`-
+ * shaped payload. Returns `[]` for any payload that doesn't carry an
+ * `auth` array — non-authenticated outputs flow freely.
+ */
+function signerChain(msg) {
+    const [, payload] = msg;
+    if (!payload || typeof payload !== "object")
+        return [];
+    const auth = payload.auth;
+    if (!Array.isArray(auth))
+        return [];
+    const keys = [];
+    for (const entry of auth) {
+        const pubkey = entry?.pubkey;
+        if (typeof pubkey === "string")
+            keys.push(pubkey);
+    }
+    return keys;
+}

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

@@ -0,0 +1,117 @@
+/**
+ * @module
+ * `tellAndRead(opts)` — INV/READ-style content synchronization.
+ *
+ * The pattern: instead of pushing full payloads to every peer, announce
+ * what you have with a small message; peers that want the content pull
+ * it via the existing `read()` primitive (no separate GETDATA message).
+ *
+ * ```
+ *   A writes M                            B observes A's announcement
+ *        │                                        │
+ *        ▼                                        ▼
+ *   outbound announce                      inbound onAnnounce
+ *   ─────────────────                      ──────────────────
+ *   transform full msg                     parse announcement;
+ *   into inv/ announcement                 pull full content
+ *   sent to peers                          via source.client.read
+ *        │                                        │
+ *        ▼                                        ▼
+ *   peers see inv/ only                    content flows into
+ *   (cheap over the wire)                  rig.receive pipeline
+ * ```
+ *
+ * This is URI-agnostic. The protocol decides:
+ * - What an "announcement" looks like (`announce`).
+ * - How to recognize one and which URI(s) to pull (`onAnnounce`).
+ *
+ * The "pull" leg is the existing peer `client.read()` — the remote
+ * side's read handler serves the payload with whatever auth/access it
+ * already enforces. No GETDATA message, no new transport, no new
+ * surface area to reason about.
+ *
+ * ## Shape
+ *
+ * `tellAndRead()` returns a pair: an outbound strategy factory
+ * (`outbound(peers)` → `ProtocolInterfaceNode`) and an inbound Policy.
+ * Use them on their respective sides:
+ *
+ * ```ts
+ * const sync = tellAndRead({
+ *   announce: (msgs) => msgs.map(([uri, vals, data]) =>
+ *     uri.startsWith("hash://")
+ *       ? [`net://inv/${uri}`, { have: uri }]
+ *       : [uri, vals, data]
+ *   ),
+ *   onAnnounce: (ev) => {
+ *     if (ev.uri?.startsWith("net://inv/")) {
+ *       return [(ev.record?.data as { have: string }).have];
+ *     }
+ *     return null;
+ *   },
+ * });
+ *
+ * const local = connection(localStore, ["**"]);
+ * const outbound = connection(sync.outbound(peers), ["hash://**"]);
+ * const rig = new Rig({
+ *   routes: {
+ *     receive: [local, outbound],
+ *     read:    [local],
+ *     observe: [local],
+ *   },
+ * });
+ * const unbind = network(rig, peers, [sync.inbound]);
+ * ```
+ *
+ * ## Batching
+ *
+ * `announce` runs on the full per-peer batch, so the protocol can
+ * choose per-item announcements, a single compound announcement
+ * carrying many URIs, or per-peer asymmetry (full to trusted, INV to
+ * untrusted). `onAnnounce` returns a list of URIs so multi-item
+ * announcements fan the pulls out naturally.
+ *
+ * ## What stays the protocol's responsibility
+ *
+ * - URI layout for the control plane (`net://inv/...`, `inv://...`,
+ *   `...?inv=true`, however you want).
+ * - Detection (which URIs are announcements vs. data).
+ * - "I already have this" short-circuit: `onAnnounce` closes over the
+ *   protocol's local store to decide whether to return the URI to
+ *   pull. The network layer doesn't plumb a local accessor.
+ */
+import type { Output, ProtocolInterfaceNode } from "../../types/types.js";
+import type { Peer, Policy } from "../types.js";
+export interface TellAndReadOptions {
+    /**
+     * Transform outbound outputs per peer. Return the outputs that
+     * should actually be sent to this peer: pass-through (`msgs`), a
+     * filtered subset, or rewritten announcements. Return `[]` to skip
+     * the peer entirely.
+     *
+     * Defaults to identity — `tellAndRead` without an `announce` is
+     * effectively `flood` on the outbound side.
+     */
+    announce?: (msgs: Output[], peer: Peer) => Output[];
+    /**
+     * Examine an inbound event. Return:
+     * - `null` / `undefined` — not an announcement. The event passes
+     *   through to the target unchanged.
+     * - `string[]` — URIs to pull from the source peer via
+     *   `source.client.read`. The fetched content replaces the
+     *   announcement in the inbound stream. Return `[]` to consume the
+     *   announcement without pulling anything (e.g., "I already have it").
+     */
+    onAnnounce?: (ev: Output<unknown>, source: Peer) => Promise<string[] | null> | string[] | null;
+}
+export interface TellAndReadBundle {
+    /** Strategy factory — build the outbound PIN for `connection()`. */
+    outbound: (peers: Peer[]) => ProtocolInterfaceNode;
+    /** Participant-side Policy — pass to `network(rig, peers, [bundle.inbound])`. */
+    inbound: Policy;
+}
+/**
+ * Construct a matched outbound/inbound pair for INV/READ-style sync.
+ */
+export declare function tellAndRead(opts: TellAndReadOptions): TellAndReadBundle;
+//# sourceMappingURL=tell-and-read.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tell-and-read.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/network/policies/tell-and-read.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC1E,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAIhD,MAAM,WAAW,kBAAkB;IACjC;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,KAAK,MAAM,EAAE,CAAC;IAEpD;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,CACX,EAAE,EAAE,MAAM,CAAC,OAAO,CAAC,EACnB,MAAM,EAAE,IAAI,KACT,OAAO,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,MAAM,EAAE,GAAG,IAAI,CAAC;CACjD;AAED,MAAM,WAAW,iBAAiB;IAChC,oEAAoE;IACpE,QAAQ,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,qBAAqB,CAAC;IACnD,iFAAiF;IACjF,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,kBAAkB,GAAG,iBAAiB,CAwCvE"}

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

@@ -0,0 +1,125 @@
+/**
+ * @module
+ * `tellAndRead(opts)` — INV/READ-style content synchronization.
+ *
+ * The pattern: instead of pushing full payloads to every peer, announce
+ * what you have with a small message; peers that want the content pull
+ * it via the existing `read()` primitive (no separate GETDATA message).
+ *
+ * ```
+ *   A writes M                            B observes A's announcement
+ *        │                                        │
+ *        ▼                                        ▼
+ *   outbound announce                      inbound onAnnounce
+ *   ─────────────────                      ──────────────────
+ *   transform full msg                     parse announcement;
+ *   into inv/ announcement                 pull full content
+ *   sent to peers                          via source.client.read
+ *        │                                        │
+ *        ▼                                        ▼
+ *   peers see inv/ only                    content flows into
+ *   (cheap over the wire)                  rig.receive pipeline
+ * ```
+ *
+ * This is URI-agnostic. The protocol decides:
+ * - What an "announcement" looks like (`announce`).
+ * - How to recognize one and which URI(s) to pull (`onAnnounce`).
+ *
+ * The "pull" leg is the existing peer `client.read()` — the remote
+ * side's read handler serves the payload with whatever auth/access it
+ * already enforces. No GETDATA message, no new transport, no new
+ * surface area to reason about.
+ *
+ * ## Shape
+ *
+ * `tellAndRead()` returns a pair: an outbound strategy factory
+ * (`outbound(peers)` → `ProtocolInterfaceNode`) and an inbound Policy.
+ * Use them on their respective sides:
+ *
+ * ```ts
+ * const sync = tellAndRead({
+ *   announce: (msgs) => msgs.map(([uri, vals, data]) =>
+ *     uri.startsWith("hash://")
+ *       ? [`net://inv/${uri}`, { have: uri }]
+ *       : [uri, vals, data]
+ *   ),
+ *   onAnnounce: (ev) => {
+ *     if (ev.uri?.startsWith("net://inv/")) {
+ *       return [(ev.record?.data as { have: string }).have];
+ *     }
+ *     return null;
+ *   },
+ * });
+ *
+ * const local = connection(localStore, ["**"]);
+ * const outbound = connection(sync.outbound(peers), ["hash://**"]);
+ * const rig = new Rig({
+ *   routes: {
+ *     receive: [local, outbound],
+ *     read:    [local],
+ *     observe: [local],
+ *   },
+ * });
+ * const unbind = network(rig, peers, [sync.inbound]);
+ * ```
+ *
+ * ## Batching
+ *
+ * `announce` runs on the full per-peer batch, so the protocol can
+ * choose per-item announcements, a single compound announcement
+ * carrying many URIs, or per-peer asymmetry (full to trusted, INV to
+ * untrusted). `onAnnounce` returns a list of URIs so multi-item
+ * announcements fan the pulls out naturally.
+ *
+ * ## What stays the protocol's responsibility
+ *
+ * - URI layout for the control plane (`net://inv/...`, `inv://...`,
+ *   `...?inv=true`, however you want).
+ * - Detection (which URIs are announcements vs. data).
+ * - "I already have this" short-circuit: `onAnnounce` closes over the
+ *   protocol's local store to decide whether to return the URI to
+ *   pull. The network layer doesn't plumb a local accessor.
+ */
+import { validatePeers } from "../network.js";
+import { floodImpl } from "./flood.js";
+/**
+ * Construct a matched outbound/inbound pair for INV/READ-style sync.
+ */
+export function tellAndRead(opts) {
+    const { announce, onAnnounce } = opts;
+    return {
+        outbound(peers) {
+            const { originId, peers: frozen } = validatePeers(peers);
+            const transform = announce
+                ? (msgs, peer) => announce(msgs, peer)
+                : (msgs) => msgs;
+            return floodImpl(originId, frozen, transform);
+        },
+        inbound: {
+            async *receive(ev, source) {
+                if (!onAnnounce) {
+                    yield ev;
+                    return;
+                }
+                const result = await Promise.resolve(onAnnounce(ev, source));
+                if (result == null) {
+                    // Not an announcement — pass through.
+                    yield ev;
+                    return;
+                }
+                // It's an announcement (possibly empty). Pull each listed URI
+                // in parallel — announcements carrying many URIs (compact
+                // block-style) shouldn't serialize into a chain of RTTs.
+                const pulls = await Promise.all(result.map((uri) => source.client.read([uri])));
+                for (const outputs of pulls) {
+                    // `read` is 1:1 with input; misses surface as `payload === undefined`.
+                    // Skip miss slots so consumers only see real content.
+                    for (const out of outputs) {
+                        if (out?.[1] !== undefined)
+                            yield out;
+                    }
+                }
+            },
+        },
+    };
+}

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

@@ -0,0 +1,112 @@
+/**
+ * @module
+ * Types for `@bandeira-tech/b3nd-core/network`.
+ *
+ * Two mental primitives, both just functions over a peer list:
+ *
+ * - **`network(target, peers, policies?, opts?)`** — 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.
+ *
+ * - **Strategy factories** (`flood(peers)`, `pathVector(peers)`, …) —
+ *   remote-client shape. Each factory returns a
+ *   `ProtocolInterfaceNode` consumed as a rig connection:
+ *   `connection(flood(peers), patterns)`.
+ *
+ * `network()` and the strategy factories are entirely different shapes
+ * (a verb vs. a ProtocolInterfaceNode), so they cannot be accidentally
+ * swapped.
+ */
+import type { Output, ProtocolInterfaceNode } from "../types/types.js";
+/**
+ * A peer is a client plus a stable id used for local routing control.
+ *
+ * The id is always present — auto-generated at runtime via `peer()` when
+ * not supplied. Protocols that key on cryptographic identity (e.g.,
+ * path-vector loop avoidance) pass their pubkey hex as the id explicitly.
+ *
+ * The id is not advertised on the wire by the network itself; it is
+ * purely local bookkeeping used by strategy factories and Policies.
+ */
+export interface Peer {
+    readonly id: string;
+    readonly client: ProtocolInterfaceNode;
+}
+/**
+ * A PeerDecorator wraps a client with middleware (best-effort, retry,
+ * rate-limit, logging, etc.) while preserving the `ProtocolInterfaceNode`
+ * shape. Applied via `peer(client, { via: [decoratorA, decoratorB] })`.
+ */
+export type PeerDecorator = (client: ProtocolInterfaceNode) => ProtocolInterfaceNode;
+/**
+ * Context passed to `Policy.receive` — inbound path, peer → rig.
+ *
+ * Carries only information the bridge uniquely knows at call time. Any
+ * data sources a policy needs (local store, cache, index, etc.) are
+ * the policy's own concern and should be injected at its construction.
+ */
+export interface InboundCtx {
+    /** Local identity for this network invocation. */
+    readonly originId: string;
+    /** The peer this event came from. `source.client` exposes `read`/`receive`
+     *  for side-requests to the sender (e.g., pulling a full payload after
+     *  an announcement). */
+    readonly source: Peer;
+}
+/**
+ * A Policy shapes how the `network()` verb translates inbound peer
+ * events before feeding them into the target rig. It is scoped to the
+ * participant side — strategy factories (flood, pathVector, etc.)
+ * encapsulate their own outbound behavior and do not consult a Policy.
+ *
+ * Multiple policies can be passed as an array to `network()`; their
+ * `receive` hooks are chained left-to-right (each yielded event flows
+ * through the next policy).
+ */
+export interface Policy {
+    /**
+     * Per-event transform on the inbound path. Yield zero or more
+     * `Output`s that should be delivered into the consuming target's
+     * pipeline.
+     *
+     * The async-generator shape lets the policy:
+     *  - consume a control-plane event silently (yield nothing)
+     *  - trigger a side-read from the source peer (via `source.client.read`)
+     *    and yield the fetched content to the target
+     *  - pass the event through unchanged
+     */
+    receive?(ev: Output<unknown>, source: Peer, ctx: InboundCtx): AsyncIterable<Output<unknown>>;
+}
+/**
+ * Options passed to the `network()` verb — strictly bridge-level concerns.
+ */
+export interface NetworkOptions {
+    /**
+     * Observe pattern subscribed to on each peer. Defaults to `"**"` —
+     * every event is bridged. Narrow to reduce noise in busy networks.
+     */
+    pattern?: string;
+    /**
+     * Called when a peer's observe stream or `target.receive` throws.
+     * Defaults to a silent catch so one bad peer/message does not tear
+     * down the whole bridge.
+     */
+    onError?: (err: Error, ctx: {
+        peerId?: string;
+    }) => void;
+}
+/**
+ * A StrategyFactory builds a plain `ProtocolInterfaceNode` from a peer
+ * list. Examples: `flood(peers)` (fan-out to all, first-match reads),
+ * `pathVector(peers)` (flood with signer-chain loop avoidance).
+ *
+ * The returned value is an ordinary client and goes into a rig
+ * connection list unchanged:
+ *
+ * ```ts
+ * connection(flood(peers), ["**"])
+ * ```
+ */
+export type StrategyFactory = (peers: Peer[]) => ProtocolInterfaceNode;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/network/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAEvE;;;;;;;;;GASG;AACH,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;CACxC;AAED;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,CAC1B,MAAM,EAAE,qBAAqB,KAC1B,qBAAqB,CAAC;AAE3B;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,kDAAkD;IAClD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;4BAEwB;IACxB,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;CACvB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,MAAM;IACrB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,CACN,EAAE,EAAE,MAAM,CAAC,OAAO,CAAC,EACnB,MAAM,EAAE,IAAI,EACZ,GAAG,EAAE,UAAU,GACd,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;CAC1D;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,qBAAqB,CAAC"}

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

@@ -0,0 +1,21 @@
+/**
+ * @module
+ * Types for `@bandeira-tech/b3nd-core/network`.
+ *
+ * Two mental primitives, both just functions over a peer list:
+ *
+ * - **`network(target, peers, policies?, opts?)`** — 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.
+ *
+ * - **Strategy factories** (`flood(peers)`, `pathVector(peers)`, …) —
+ *   remote-client shape. Each factory returns a
+ *   `ProtocolInterfaceNode` consumed as a rig connection:
+ *   `connection(flood(peers), patterns)`.
+ *
+ * `network()` and the strategy factories are entirely different shapes
+ * (a verb vs. a ProtocolInterfaceNode), so they cannot be accidentally
+ * swapped.
+ */
+export {};