@bandeira-tech/b3nd-save 0.8.1

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

@@ -0,0 +1,167 @@
+/**
+ * @module
+ * Types for the b3nd Rig — the universal harness.
+ */
+import type { CodeHandler, Program, ProtocolInterfaceNode } from "../types/types.js";
+import type { HooksConfig } from "./hooks.js";
+import type { EventHandler, RigEventName } from "./events.js";
+import type { ReactionHandler } from "./reactions.js";
+import type { Connection } from "./connection.js";
+export type { ProtocolInterfaceNode };
+/**
+ * Per-operation route bindings.
+ *
+ * Each route is an ordered list of connections. The rig treats the
+ * three routes independently:
+ *
+ * - `receive` — broadcast: a tuple lands at every connection whose
+ *   pattern accepts its URI. Per-route outcomes surface as
+ *   `route:success` / `route:error` on the operation handle.
+ * - `read` — sequential: per url, the first connection whose pattern
+ *   accepts the routing key gets the request. No fall-through, no
+ *   aggregation. Aggregation across sources is the job of an
+ *   aggregating client (e.g. memcache + shards), not the rig.
+ * - `observe` — urls are grouped by the first matching connection;
+ *   the rig multiplexes the per-connection streams into one.
+ *
+ * The same connection value can appear in multiple routes when one
+ * client serves all three with the same filter. A different filter
+ * for a different op means a separate `connection(...)` call.
+ */
+export interface RigRoutes {
+    receive?: Connection[];
+    read?: Connection[];
+    observe?: Connection[];
+}
+/**
+ * Configuration for `new Rig()`.
+ *
+ * The rig is pure orchestration — build clients outside, hand them
+ * in via `routes`. Routes are the only way the rig learns about
+ * clients.
+ */
+export interface RigConfig {
+    /**
+     * Routes — per-op connection lists.
+     *
+     * @example
+     * ```typescript
+     * const node = connection(httpClient, ["mutable://**", "hash://**"]);
+     *
+     * const rig = new Rig({
+     *   routes: {
+     *     receive: [node],
+     *     read:    [node],
+     *     observe: [node],
+     *   },
+     * });
+     * ```
+     */
+    routes: RigRoutes;
+    /**
+     * Programs — pure classifiers that return protocol-defined codes.
+     *
+     * Maps URI prefixes (e.g. `"store://balance"`) to Program functions.
+     * When a message arrives, the rig looks up the program for its URI,
+     * runs classification, and routes to the handler for the returned code.
+     *
+     * ```typescript
+     * const rig = new Rig({
+     *   routes: { ... },
+     *   programs: {
+     *     "store://balance": balanceProgram,
+     *     "msg://app": appMsgProgram,
+     *   },
+     *   handlers: {
+     *     "app:valid":     async (out) => [out],
+     *     "app:confirmed": async (out, _result, read) => {
+     *       // ...inspect state via read; return what to dispatch
+     *       return [out];
+     *     },
+     *   },
+     * });
+     * ```
+     */
+    programs?: Record<string, Program>;
+    /**
+     * Code handlers — what to do when a program returns a specific code.
+     *
+     * Each handler returns `Output[]` — the tuples it wants the rig
+     * to dispatch through `routes.receive`. Handler emissions skip
+     * `process` (handlers are canonical interpreters); reactions run
+     * after broadcast lands.
+     */
+    handlers?: Record<string, CodeHandler>;
+    /**
+     * Hooks — frozen after construction, one function per slot.
+     *
+     * Before-hooks **throw** to reject (no silent aborts).
+     * After-hooks **observe** (cannot modify the result; throw if violated).
+     *
+     * @example
+     * ```typescript
+     * const rig = new Rig({
+     *   routes: { ... },
+     *   hooks: {
+     *     beforeReceive: (ctx) => { validate(ctx.uri); },
+     *     afterRead: (ctx, result) => { audit(ctx.uri, result); },
+     *   },
+     * });
+     * ```
+     */
+    hooks?: HooksConfig;
+    /**
+     * Async event handlers — fire-and-forget after operations complete.
+     *
+     * Events never block the caller. Handler errors are caught and logged.
+     * Wildcard events (`*:success`, `*:error`) fire for all operations.
+     *
+     * @example
+     * ```typescript
+     * const rig = new Rig({
+     *   routes: { ... },
+     *   on: {
+     *     "send:success": [audit, notifyPeers],
+     *     "*:error": [alertOps],
+     *   },
+     * });
+     * ```
+     */
+    on?: Partial<Record<RigEventName, EventHandler[]>>;
+    /**
+     * URI-pattern reactions — fire on successful writes.
+     *
+     * Patterns use the shared glob grammar: `*` matches one segment,
+     * `**` matches the rest. Handlers are fire-and-forget; if you need
+     * a segment value, extract it from `out[0]` inside the handler.
+     *
+     * @example
+     * ```typescript
+     * const rig = new Rig({
+     *   routes: { ... },
+     *   reactions: {
+     *     "mutable://app/users/*": async (out, _read) => {
+     *       const id = out[0].split("/").pop();
+     *       return [[`notify://email/${id}`, { kind: "user-updated" }]];
+     *     },
+     *   },
+     * });
+     * ```
+     */
+    reactions?: Record<string, ReactionHandler>;
+}
+/**
+ * Snapshot of a Rig's current state — returned by `rig.info()`.
+ *
+ * Pure local inspection, no network calls. Useful for debugging,
+ * logging, and UI display of identity/capability status.
+ */
+export interface RigInfo {
+    /** Behavior layer counts — hooks, events, and observers registered. */
+    behavior: {
+        hooks: string[];
+        events: Record<string, number>;
+        reactors: number;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/esm/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/rig/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/rig/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,OAAO,EACP,qBAAqB,EACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAIlD,YAAY,EAAE,qBAAqB,EAAE,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,SAAS;IACxB,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;IACvB,IAAI,CAAC,EAAE,UAAU,EAAE,CAAC;IACpB,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;CACxB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACxB;;;;;;;;;;;;;;;OAeG;IACH,MAAM,EAAE,SAAS,CAAC;IAElB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEnC;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAEvC;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,CAAC,EAAE,WAAW,CAAC;IAEpB;;;;;;;;;;;;;;;;OAgBG;IACH,EAAE,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,YAAY,EAAE,CAAC,CAAC,CAAC;IAEnD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CAC7C;AAED;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,uEAAuE;IACvE,QAAQ,EAAE;QACR,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC/B,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH"}

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

@@ -0,0 +1,5 @@
+/**
+ * @module
+ * Types for the b3nd Rig — the universal harness.
+ */
+export {};

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

@@ -0,0 +1,278 @@
+/**
+ * @b3nd/sdk Types
+ * Core types for the universal B3nd protocol interface
+ */
+/**
+ * Result of a write operation
+ */
+export interface WriteResult<T = unknown> {
+    success: boolean;
+    record?: {
+        data: T;
+    };
+    error?: string;
+}
+/**
+ * Result of a delete operation
+ */
+export interface DeleteResult {
+    success: boolean;
+    error?: string;
+    errorDetail?: B3ndError;
+}
+/**
+ * Health status response
+ */
+export interface HealthStatus {
+    status: "healthy" | "degraded" | "unhealthy";
+    message?: string;
+    details?: Record<string, unknown>;
+}
+/**
+ * Status response — replaces health() + getSchema().
+ * Each client reports its health + capabilities.
+ * The rig aggregates and adds schema info.
+ *
+ * `fns` advertises the set of named read functions this node supports,
+ * if its locator grammar defines such a concept. Provider-specific —
+ * the framework neither populates nor interprets it. Clients may use
+ * it to surface capability info to humans/diagnostic UIs.
+ */
+export interface StatusResult {
+    status: "healthy" | "degraded" | "unhealthy";
+    message?: string;
+    schema?: string[];
+    fns?: string[];
+    details?: Record<string, unknown>;
+}
+/**
+ * Output — the universal addressed-content primitive: [uri, payload]
+ *
+ * The framework treats `payload` as opaque on both sides. The first
+ * element's meaning differs by direction:
+ *
+ * - **write** (`receive`, `send`, programs): `uri` is the canonical
+ *   identifier the payload is written under.
+ * - **read** (`read` results): the first element echoes the caller's
+ *   input locator so results pair positionally or by lookup. Payload
+ *   shape is entirely the executing client's choice — what a miss
+ *   looks like, what a listing yields, what an extension function
+ *   returns, all defined by the client's locator-grammar contract.
+ */
+export type Output<T = unknown> = [
+    uri: string,
+    payload: T
+];
+/**
+ * Read function for storage lookups.
+ *
+ * Single-locator convenience used by program authors — wraps
+ * `read([locator])[0]`. Because `read` is 1:1 with its input, the
+ * tuple is always present. What "miss" looks like in the payload is up
+ * to the executing client; the type parameter `T` should reflect that
+ * (e.g. `T | undefined` if your client uses `undefined` for miss).
+ */
+export type ReadFn = <T = unknown>(locator: string) => Promise<Output<T>>;
+/**
+ * Receive function — batch of outputs through the rig pipeline.
+ */
+export type ReceiveFn = (msgs: Output[]) => Promise<ReceiveResult[]>;
+/**
+ * Program result — classification of a message by a program.
+ * Programs return protocol-defined codes, not binary valid/invalid.
+ */
+export interface ProgramResult {
+    code: string;
+    error?: string;
+}
+/**
+ * Program — classifies a message and returns a protocol-defined code.
+ *
+ * Programs are pure classifiers with no side effects. A protocol ships its
+ * own programs as a closed package — sub-output classification is handled
+ * internally by the protocol, not by calling back into the rig.
+ *
+ * - `output`   — the [uri, payload] being classified
+ * - `upstream` — the parent output (undefined at top level)
+ * - `read`     — storage lookup (only confirmed state)
+ */
+export type Program<T = unknown> = (output: Output<T>, upstream: Output | undefined, read: ReadFn) => Promise<ProgramResult>;
+/**
+ * Code handler — what to do when a program returns a specific code.
+ *
+ * Handlers are pure transforms: they take the classified output and
+ * return the `Output[]` they want the Rig to dispatch. The Rig owns
+ * the wire — handlers never call broadcast directly.
+ *
+ * Common shapes:
+ * - persist:     `return [out]`            (the simple "write this" case)
+ * - decompose:   `return [envelope, ...payload.outputs, ...deletions]`
+ * - conditional: `return existing.success ? [] : [out]`
+ * - refuse:      `return []`
+ *
+ * - `out`    — the classified output `[uri, payload]`
+ * - `result` — the `ProgramResult` that produced this code
+ * - `read`   — storage lookup (confirmed state)
+ */
+export type CodeHandler = (out: Output, result: ProgramResult, read: ReadFn) => Promise<Output[]>;
+/**
+ * Result of a receive operation.
+ * `error` remains a string for backward compatibility.
+ * `errorDetail` provides structured error info for programmatic handling.
+ */
+export interface ReceiveResult {
+    accepted: boolean;
+    error?: string;
+    errorDetail?: B3ndError;
+}
+/**
+ * ProtocolInterfaceNode — the universal interface implemented by all clients.
+ *
+ * Four primitives:
+ * - `receive` — all state changes (writes), addressed by **uri**
+ * - `read`    — all queries, addressed by **locator**
+ * - `observe` — stream of changes, subscribed by **locator**
+ * - `status`  — health + capabilities
+ *
+ * **URIs vs locators.** A *uri* is the canonical identifier of a
+ * resource — used for writes and emitted on observe so listeners learn
+ * which resource changed. A *locator* is any addressing string a caller
+ * passes to `read`/`observe`: it may be a bare uri, a pattern with
+ * wildcards, or a uri decorated with request-time directives. The
+ * framework treats locators as opaque — it routes them by string
+ * pattern matching and hands them to the executing client verbatim.
+ * What grammar (if any) a locator follows is a contract between the
+ * caller and the executing client.
+ *
+ * All B3nd clients (Memory, HTTP, WebSocket, Postgres, IndexedDB, etc.)
+ * implement this interface, enabling recursive composition and uniform usage.
+ */
+export interface ProtocolInterfaceNode {
+    /**
+     * Receive a batch of outputs — the unified entry point for all state changes.
+     *
+     * Each output is `[uri, payload]` where `uri` is the canonical
+     * resource identifier the payload is written under. Clients interpret
+     * the payload per their role (storage clients persist, audit clients
+     * append, forwarders forward). Returns one `ReceiveResult` per output.
+     *
+     * The return type is `PromiseLike` (not `Promise`) so implementations
+     * can return richer await-targets — e.g., the Rig returns an
+     * `OperationHandle` that's awaitable AND exposes per-route events.
+     * Plain `Promise<ReceiveResult[]>` still satisfies the contract.
+     */
+    receive(msgs: Output[]): PromiseLike<ReceiveResult[]>;
+    /**
+     * Read a batch of locators.
+     *
+     * Locators are opaque to the framework: their grammar is a contract
+     * between the caller and the executing client. The rig routes each
+     * locator to the first connection whose pattern accepts it (pure
+     * string pattern matching, no normalization).
+     *
+     * **Shape: 1:1 with input.** Returns one `Output<T>` per input
+     * locator, in input order. Each output is `[inputLocator, payload]` —
+     * the first element echoes the caller's locator so results are
+     * addressable positionally or by lookup.
+     *
+     * Payload semantics are entirely the client's concern. What "not
+     * found" looks like, what listing shapes look like, what extension
+     * functions return — all defined by the executing client and agreed
+     * with its callers out-of-band.
+     *
+     * **Errors:** transport / programmer errors throw (network down, no
+     * route accepts, grammar violations the client rejects). Anything
+     * else — "not found", auth refusals, etc. — is encoded in the payload
+     * per the client's convention.
+     */
+    read<T = unknown>(locators: string[]): Promise<Output<T>[]>;
+    /**
+     * Observe a batch of locators. Yields INV-style batches of uris that
+     * changed under any subscribed pattern. The observer reads each uri
+     * to learn its current state.
+     *
+     * Locators are matched against emitted uris as segment-globs — pure
+     * string pattern matching, no grammar awareness. Each yield is a
+     * non-empty `readonly string[]` of concrete uris that fired in this
+     * batch. Which of the caller's subscription locators matched is not
+     * surfaced; the caller can re-match locally if it needs that routing,
+     * which keeps the wire (and in-process surface) minimal.
+     *
+     * The `signal` controls lifecycle — abort to stop observing.
+     *
+     * @example
+     * ```ts
+     * const abort = new AbortController();
+     * for await (const uris of client.observe(["mutable://market/**"], abort.signal)) {
+     *   const outputs = await client.read(uris);
+     *   for (const [uri, payload] of outputs) console.log(uri, payload);
+     * }
+     * ```
+     */
+    observe(locators: string[], signal: AbortSignal): AsyncIterable<readonly string[]>;
+    /**
+     * Status — health + capabilities.
+     * Clients report health. The rig aggregates and adds schema.
+     */
+    status(): Promise<StatusResult>;
+}
+/**
+ * Structured error codes for programmatic error handling.
+ * Callers can switch on `error.code` without string parsing.
+ */
+export declare enum ErrorCode {
+    UNAUTHORIZED = "UNAUTHORIZED",
+    FORBIDDEN = "FORBIDDEN",
+    INVALID_URI = "INVALID_URI",
+    INVALID_SCHEMA = "INVALID_SCHEMA",
+    INVALID_SEQUENCE = "INVALID_SEQUENCE",
+    NOT_FOUND = "NOT_FOUND",
+    CONFLICT = "CONFLICT",
+    STORAGE_ERROR = "STORAGE_ERROR",
+    INTERNAL_ERROR = "INTERNAL_ERROR"
+}
+/**
+ * Structured error returned by protocol operations.
+ */
+export interface B3ndError {
+    code: ErrorCode;
+    message: string;
+    uri?: string;
+    details?: unknown;
+}
+/**
+ * Convenience constructors for B3ndError
+ */
+export declare const Errors: {
+    unauthorized: (uri: string, msg?: string) => B3ndError;
+    forbidden: (uri: string, msg?: string) => B3ndError;
+    invalidUri: (uri: string, msg?: string) => B3ndError;
+    invalidSchema: (uri: string, details?: unknown) => B3ndError;
+    invalidSequence: (uri: string, msg?: string) => B3ndError;
+    notFound: (uri: string) => B3ndError;
+    conflict: (uri: string, msg?: string) => B3ndError;
+    storageError: (msg: string, uri?: string) => B3ndError;
+    internal: (msg: string, uri?: string) => B3ndError;
+};
+/**
+ * Error class for client operations
+ * Preserves error context without hiding details
+ */
+export declare class ClientError extends Error {
+    readonly code: string;
+    readonly details?: unknown | undefined;
+    constructor(message: string, code: string, details?: unknown | undefined);
+}
+/**
+ * Link value - just a string URI pointing to another resource
+ */
+export type LinkValue = string;
+/**
+ * Content-addressed data metadata (optional wrapper for hash:// data)
+ */
+export interface ContentData<T = unknown> {
+    type?: string;
+    encoding?: string;
+    data: T;
+}
+//# sourceMappingURL=types.d.ts.map

package/esm/deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/types/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/types/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,GAAG,OAAO;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE;QAAE,IAAI,EAAE,CAAC,CAAA;KAAE,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,SAAS,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,WAAW,CAAC;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,WAAW,CAAC;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,GAAG,OAAO,IAAI;IAChC,GAAG,EAAE,MAAM;IACX,OAAO,EAAE,CAAC;CACX,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,GAAG,OAAO,EAC/B,OAAO,EAAE,MAAM,KACZ,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAExB;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;AAIrE;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,GAAG,OAAO,IAAI,CACjC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EACjB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,IAAI,EAAE,MAAM,KACT,OAAO,CAAC,aAAa,CAAC,CAAC;AAE5B;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,WAAW,GAAG,CACxB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,MAAM,KACT,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;AAEvB;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,SAAS,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,WAAW,CAAC,aAAa,EAAE,CAAC,CAAC;IAEtD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,IAAI,CAAC,CAAC,GAAG,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAE5D;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,OAAO,CACL,QAAQ,EAAE,MAAM,EAAE,EAClB,MAAM,EAAE,WAAW,GAClB,aAAa,CAAC,SAAS,MAAM,EAAE,CAAC,CAAC;IAEpC;;;OAGG;IACH,MAAM,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC;CACjC;AAED;;;GAGG;AACH,oBAAY,SAAS;IAEnB,YAAY,iBAAiB;IAC7B,SAAS,cAAc;IAEvB,WAAW,gBAAgB;IAC3B,cAAc,mBAAmB;IACjC,gBAAgB,qBAAqB;IAErC,SAAS,cAAc;IACvB,QAAQ,aAAa;IAErB,aAAa,kBAAkB;IAC/B,cAAc,mBAAmB;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,eAAO,MAAM,MAAM;wBACG,MAAM,QAAQ,MAAM,KAAG,SAAS;qBAKnC,MAAM,QAAQ,MAAM,KAAG,SAAS;sBAK/B,MAAM,QAAQ,MAAM,KAAG,SAAS;yBAK7B,MAAM,YAAY,OAAO,KAAG,SAAS;2BAMnC,MAAM,QAAQ,MAAM,KAAG,SAAS;oBAKvC,MAAM,KAAG,SAAS;oBAKlB,MAAM,QAAQ,MAAM,KAAG,SAAS;wBAK5B,MAAM,QAAQ,MAAM,KAAG,SAAS;oBAKpC,MAAM,QAAQ,MAAM,KAAG,SAAS;CAKjD,CAAC;AAEF;;;GAGG;AACH,qBAAa,WAAY,SAAQ,KAAK;aAGlB,IAAI,EAAE,MAAM;aACZ,OAAO,CAAC,EAAE,OAAO;gBAFjC,OAAO,EAAE,MAAM,EACC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,OAAO,YAAA;CAKpC;AAED;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC;AAE/B;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,GAAG,OAAO;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,CAAC,CAAC;CACT"}

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

@@ -0,0 +1,89 @@
+/**
+ * @b3nd/sdk Types
+ * Core types for the universal B3nd protocol interface
+ */
+/**
+ * Structured error codes for programmatic error handling.
+ * Callers can switch on `error.code` without string parsing.
+ */
+export var ErrorCode;
+(function (ErrorCode) {
+    // Auth errors
+    ErrorCode["UNAUTHORIZED"] = "UNAUTHORIZED";
+    ErrorCode["FORBIDDEN"] = "FORBIDDEN";
+    // Validation errors
+    ErrorCode["INVALID_URI"] = "INVALID_URI";
+    ErrorCode["INVALID_SCHEMA"] = "INVALID_SCHEMA";
+    ErrorCode["INVALID_SEQUENCE"] = "INVALID_SEQUENCE";
+    // State errors
+    ErrorCode["NOT_FOUND"] = "NOT_FOUND";
+    ErrorCode["CONFLICT"] = "CONFLICT";
+    // Internal errors
+    ErrorCode["STORAGE_ERROR"] = "STORAGE_ERROR";
+    ErrorCode["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+})(ErrorCode || (ErrorCode = {}));
+/**
+ * Convenience constructors for B3ndError
+ */
+export const Errors = {
+    unauthorized: (uri, msg) => ({
+        code: ErrorCode.UNAUTHORIZED,
+        message: msg ?? "Unauthorized",
+        uri,
+    }),
+    forbidden: (uri, msg) => ({
+        code: ErrorCode.FORBIDDEN,
+        message: msg ?? "Forbidden",
+        uri,
+    }),
+    invalidUri: (uri, msg) => ({
+        code: ErrorCode.INVALID_URI,
+        message: msg ?? "Invalid URI",
+        uri,
+    }),
+    invalidSchema: (uri, details) => ({
+        code: ErrorCode.INVALID_SCHEMA,
+        message: "Schema validation failed",
+        uri,
+        details,
+    }),
+    invalidSequence: (uri, msg) => ({
+        code: ErrorCode.INVALID_SEQUENCE,
+        message: msg ?? "Invalid sequence number",
+        uri,
+    }),
+    notFound: (uri) => ({
+        code: ErrorCode.NOT_FOUND,
+        message: `Not found: ${uri}`,
+        uri,
+    }),
+    conflict: (uri, msg) => ({
+        code: ErrorCode.CONFLICT,
+        message: msg ?? "Conflict",
+        uri,
+    }),
+    storageError: (msg, uri) => ({
+        code: ErrorCode.STORAGE_ERROR,
+        message: msg,
+        uri,
+    }),
+    internal: (msg, uri) => ({
+        code: ErrorCode.INTERNAL_ERROR,
+        message: msg,
+        uri,
+    }),
+};
+/**
+ * Error class for client operations
+ * Preserves error context without hiding details
+ */
+export class ClientError extends Error {
+    code;
+    details;
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "ClientError";
+    }
+}

package/esm/dispatch.d.ts

@@ -0,0 +1,35 @@
+/**
+ * URL dispatch helper for Store.read implementations.
+ *
+ * Every store parses the input url, switches on `fn`, and calls back
+ * into store-supplied handlers. Centralising the dispatch keeps the
+ * `read`/`ls`/`count`/`x-*` switch identical across stores so they
+ * cannot drift apart.
+ *
+ * Stores call `dispatchRead(urls, handlers)`; the helper handles
+ * parsing, the fn switch, and tuple assembly. Each handler receives
+ * the parsed url and returns the payload — the helper wraps it into
+ * `[inputUrl, payload]`.
+ */
+import type { Output } from "./deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/types/types.js";
+import type { ParsedUrl } from "./url.js";
+export interface ReadHandlers {
+    /** Point read. Return `undefined` for a miss. */
+    read: (parsed: ParsedUrl) => unknown | Promise<unknown>;
+    /**
+     * List entries under a prefix. Return `Output[]` for `format=full`
+     * (default) or `string[]` for `format=uris`. Handler is responsible
+     * for honoring `params.format` itself — typically by calling
+     * `applyReadParams` from `./read.ts`.
+     */
+    ls: (parsed: ParsedUrl) => unknown | Promise<unknown>;
+    /** Count entries under a prefix. Return a number. */
+    count: (parsed: ParsedUrl) => number | Promise<number>;
+    /**
+     * Optional handler for provider-defined `x-*.*` extension fns.
+     * If absent, unknown fns throw.
+     */
+    ext?: (parsed: ParsedUrl) => unknown | Promise<unknown>;
+}
+export declare function dispatchRead<T = unknown>(urls: string[], storeName: string, handlers: ReadHandlers): Promise<Output<T>[]>;
+//# sourceMappingURL=dispatch.d.ts.map

package/esm/dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../src/dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kEAAkE,CAAC;AAC/F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAG1C,MAAM,WAAW,YAAY;IAC3B,iDAAiD;IACjD,IAAI,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACxD;;;;;OAKG;IACH,EAAE,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACtD,qDAAqD;IACrD,KAAK,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACvD;;;OAGG;IACH,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACzD;AAED,wBAAsB,YAAY,CAAC,CAAC,GAAG,OAAO,EAC5C,IAAI,EAAE,MAAM,EAAE,EACd,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAyBtB"}

package/esm/dispatch.js

@@ -0,0 +1,40 @@
+/**
+ * URL dispatch helper for Store.read implementations.
+ *
+ * Every store parses the input url, switches on `fn`, and calls back
+ * into store-supplied handlers. Centralising the dispatch keeps the
+ * `read`/`ls`/`count`/`x-*` switch identical across stores so they
+ * cannot drift apart.
+ *
+ * Stores call `dispatchRead(urls, handlers)`; the helper handles
+ * parsing, the fn switch, and tuple assembly. Each handler receives
+ * the parsed url and returns the payload — the helper wraps it into
+ * `[inputUrl, payload]`.
+ */
+import { parseUrl } from "./url.js";
+export async function dispatchRead(urls, storeName, handlers) {
+    const out = [];
+    for (const url of urls) {
+        const parsed = parseUrl(url);
+        let payload;
+        switch (parsed.fn) {
+            case "read":
+                payload = await handlers.read(parsed);
+                break;
+            case "ls":
+                payload = await handlers.ls(parsed);
+                break;
+            case "count":
+                payload = await handlers.count(parsed);
+                break;
+            default:
+                if (parsed.fn.startsWith("x-") && handlers.ext) {
+                    payload = await handlers.ext(parsed);
+                    break;
+                }
+                throw new Error(`${storeName}: unsupported fn '${parsed.fn}'`);
+        }
+        out.push([url, payload]);
+    }
+    return out;
+}

package/esm/elasticsearch/mod.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Elasticsearch backend for b3nd.
+ *
+ * Store implementation backed by Elasticsearch. Requires an injected
+ * ElasticsearchExecutor so the package does not depend on a specific
+ * ES client.
+ */
+export interface ElasticsearchClientConfig {
+    /** Index name prefix for b3nd data (e.g., "b3nd") */
+    indexPrefix: string;
+}
+export interface ElasticsearchSearchResult {
+    hits: Array<{
+        _id: string;
+        _source?: Record<string, unknown>;
+    }>;
+}
+export interface ElasticsearchExecutor {
+    index: (index: string, id: string, body: Record<string, unknown>) => Promise<void>;
+    get: (index: string, id: string) => Promise<Record<string, unknown> | null>;
+    search: (index: string, body: Record<string, unknown>) => Promise<ElasticsearchSearchResult>;
+    /**
+     * Count documents matching a query. Maps to the ES `_count` endpoint.
+     */
+    count: (index: string, body: Record<string, unknown>) => Promise<number>;
+    delete: (index: string, id: string) => Promise<void>;
+    ping: () => Promise<boolean>;
+    cleanup?: () => Promise<void>;
+}
+export { ElasticsearchStore } from "./store.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/elasticsearch/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/elasticsearch/mod.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,WAAW,yBAAyB;IACxC,qDAAqD;IACrD,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,KAAK,CACT;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CACnD,CAAC;CACH;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,CACL,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC1B,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,GAAG,EAAE,CACH,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,KACP,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;IAC7C,MAAM,EAAE,CACN,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC1B,OAAO,CAAC,yBAAyB,CAAC,CAAC;IACxC;;OAEG;IACH,KAAK,EAAE,CACL,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC1B,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7B,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B;AAED,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC"}

package/esm/elasticsearch/mod.js

@@ -0,0 +1,8 @@
+/**
+ * Elasticsearch backend for b3nd.
+ *
+ * Store implementation backed by Elasticsearch. Requires an injected
+ * ElasticsearchExecutor so the package does not depend on a specific
+ * ES client.
+ */
+export { ElasticsearchStore } from "./store.js";