@bandeira-tech/b3nd-save 0.8.1

package/esm/read.js

@@ -0,0 +1,67 @@
+/**
+ * In-process post-processing for `fn=ls` results.
+ *
+ * Stores that cannot push `sortBy`/`limit`/`page`/`format` down to
+ * their backend collect the raw `Output[]` rows under a prefix and
+ * pipe them through `applyReadParams`. Stores that CAN push these
+ * down (postgres, mongo, elasticsearch, s3) should skip this helper
+ * and handle the params in their query.
+ *
+ * Throws on unsupported params — programmer errors are not silent
+ * "misses." See project decisions in `project_core_upgrade.md`.
+ */
+/**
+ * Validate standard ReadParams and throw on anything we cannot honor.
+ *
+ * Push-down stores (postgres, mongo, ES, S3) call this first, then
+ * translate the surviving params into their backend query language.
+ * Stores that post-process in memory call `applyReadParams` instead,
+ * which validates and applies in one go.
+ *
+ * Project-wide baseline: `pattern` and `cursor` are unsupported
+ * everywhere; `sortBy` only accepts `"uri"`; `format` only accepts
+ * `"full"` (default) or `"uris"`. Per-store relaxations should be
+ * added explicitly as features land.
+ */
+export function validateReadParams(params, storeName) {
+    if (params.pattern !== undefined) {
+        throw new Error(`${storeName}: pattern filter not supported`);
+    }
+    if (params.cursor !== undefined) {
+        throw new Error(`${storeName}: cursor not supported`);
+    }
+    if (params.sortBy !== undefined && params.sortBy !== "uri") {
+        throw new Error(`${storeName}: unsupported sortBy: ${params.sortBy}`);
+    }
+    const format = params.format ?? "full";
+    if (format !== "full" && format !== "uris") {
+        throw new Error(`${storeName}: unsupported format: ${format}`);
+    }
+}
+/**
+ * Apply standard ReadParams to a list of rows.
+ *
+ * @param rows   raw `[uri, payload]` entries collected from the backend
+ * @param params parsed read params (from `parseUrl(...).params`)
+ * @param storeName label used in thrown error messages
+ *
+ * Returns `Output[]` when `format` is `"full"` (default) or `string[]`
+ * when `format` is `"uris"`.
+ */
+export function applyReadParams(rows, params, storeName) {
+    validateReadParams(params, storeName);
+    const format = params.format ?? "full";
+    let out = rows;
+    if (params.sortBy === "uri") {
+        const dir = params.sortOrder === "desc" ? -1 : 1;
+        out = [...out].sort(([a], [b]) => a.localeCompare(b) * dir);
+    }
+    if (params.limit !== undefined) {
+        const page = params.page ?? 1;
+        const start = (page - 1) * params.limit;
+        out = out.slice(start, start + params.limit);
+    }
+    if (format === "uris")
+        return out.map(([uri]) => uri);
+    return out;
+}

package/esm/s3/mod.d.ts

@@ -0,0 +1,23 @@
+/**
+ * S3 backend for b3nd.
+ *
+ * Store implementation backed by Amazon S3. Requires an injected
+ * S3Executor so the package does not depend on a specific S3 library.
+ * Object bodies hold raw payload bytes — the store is opaque.
+ *
+ * `putObject` accepts the `StorePayload` union (fetch handles either
+ * bytes or a `ReadableStream` as a request body); `getObject` returns
+ * a `ReadableStream<Uint8Array>` so callers don't have to materialize
+ * the whole object in memory unless they want to.
+ */
+import type { StorePayload } from "../types.js";
+export interface S3Executor {
+    putObject: (key: string, body: StorePayload, contentType: string) => Promise<void>;
+    getObject: (key: string) => Promise<ReadableStream<Uint8Array> | null>;
+    deleteObject: (key: string) => Promise<void>;
+    listObjects: (prefix: string) => Promise<string[]>;
+    headBucket: () => Promise<boolean>;
+    cleanup?: () => Promise<void>;
+}
+export { S3Store } from "./store.js";
+//# sourceMappingURL=mod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/s3/mod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,CACT,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,YAAY,EAClB,WAAW,EAAE,MAAM,KAChB,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,CAAC;IACvE,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACnD,UAAU,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IACnC,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B;AAED,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC"}

package/esm/s3/mod.js

@@ -0,0 +1,13 @@
+/**
+ * S3 backend for b3nd.
+ *
+ * Store implementation backed by Amazon S3. Requires an injected
+ * S3Executor so the package does not depend on a specific S3 library.
+ * Object bodies hold raw payload bytes — the store is opaque.
+ *
+ * `putObject` accepts the `StorePayload` union (fetch handles either
+ * bytes or a `ReadableStream` as a request body); `getObject` returns
+ * a `ReadableStream<Uint8Array>` so callers don't have to materialize
+ * the whole object in memory unless they want to.
+ */
+export { S3Store } from "./store.js";

package/esm/s3/store.d.ts

@@ -0,0 +1,46 @@
+/**
+ * S3Store — Amazon S3 implementation of Store.
+ *
+ * Pure mechanical byte storage with no protocol awareness. One S3
+ * object per entry. Object body is the payload bytes verbatim; the
+ * store is opaque.
+ *
+ * `fn=ls` / `fn=count` are shallow direct-leaves only: list objects
+ * under the URI's key prefix, then filter to keys whose remainder
+ * contains no further `/`. The `format=uris` fast path returns the
+ * URIs without issuing `getObject`; `format=full` only fetches the
+ * selected page.
+ */
+import type { DeleteResult, Output, StatusResult } from "../deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/types/types.js";
+import { type BytesOnlyEntityMeta } from "../byte-entity-shim.js";
+import type { EntityStore } from "../entity-store.js";
+import type { EntityRecord, EntitySchema } from "../entity.js";
+import type { StoreCapabilities, StoreWriteResult } from "../types.js";
+import type { S3Executor } from "./mod.js";
+export declare class S3Store implements EntityStore<BytesOnlyEntityMeta> {
+    private readonly bucket;
+    private readonly executor;
+    private readonly prefix;
+    constructor(bucket: string, executor: S3Executor, prefix?: string);
+    entitySupport(schema: EntitySchema): BytesOnlyEntityMeta;
+    entityStatus(meta: BytesOnlyEntityMeta): Promise<"live" | "unprovisioned">;
+    provisionEntity(_meta: BytesOnlyEntityMeta): Promise<void>;
+    write(meta: BytesOnlyEntityMeta, entries: {
+        uri: string;
+        record: EntityRecord;
+    }[]): Promise<StoreWriteResult[]>;
+    read<T = EntityRecord | undefined>(meta: BytesOnlyEntityMeta, urls: string[]): Promise<Output<T>[]>;
+    delete(meta: BytesOnlyEntityMeta, uris: string[]): Promise<DeleteResult[]>;
+    private _writeBytes;
+    private _readBytes;
+    private _readOne;
+    /** List direct-child URIs under a prefix (no recursion into sub-prefixes). */
+    private _listChildUris;
+    private _ls;
+    private _count;
+    private _deleteBytes;
+    status(): Promise<StatusResult>;
+    capabilities(): StoreCapabilities;
+    private _resolveKey;
+}
+//# sourceMappingURL=store.d.ts.map

package/esm/s3/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/s3/store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,MAAM,EACN,YAAY,EACb,MAAM,mEAAmE,CAAC;AAC3E,OAAO,EAEL,KAAK,mBAAmB,EAIzB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAM/D,OAAO,KAAK,EACV,iBAAiB,EAEjB,gBAAgB,EACjB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAgB3C,qBAAa,OAAQ,YAAW,WAAW,CAAC,mBAAmB,CAAC;IAC9D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAa;IACtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEpB,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,MAAM;IAWjE,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,mBAAmB;IAIxD,YAAY,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,GAAG,eAAe,CAAC;IAI1E,eAAe,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAI1D,KAAK,CACH,IAAI,EAAE,mBAAmB,EACzB,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,YAAY,CAAA;KAAE,EAAE,GAC/C,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAS9B,IAAI,CAAC,CAAC,GAAG,YAAY,GAAG,SAAS,EAC/B,IAAI,EAAE,mBAAmB,EACzB,IAAI,EAAE,MAAM,EAAE,GACb,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;IASvB,MAAM,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;YAW5D,WAAW;IAwBzB,OAAO,CAAC,UAAU;YAQJ,QAAQ;IAOtB,8EAA8E;YAChE,cAAc;YAad,GAAG;YA0BH,MAAM;YAON,YAAY;IAoBpB,MAAM,IAAI,OAAO,CAAC,YAAY,CAAC;IA4BrC,YAAY,IAAI,iBAAiB;IAIjC,OAAO,CAAC,WAAW;CAGpB"}

package/esm/s3/store.js

@@ -0,0 +1,183 @@
+/**
+ * S3Store — Amazon S3 implementation of Store.
+ *
+ * Pure mechanical byte storage with no protocol awareness. One S3
+ * object per entry. Object body is the payload bytes verbatim; the
+ * store is opaque.
+ *
+ * `fn=ls` / `fn=count` are shallow direct-leaves only: list objects
+ * under the URI's key prefix, then filter to keys whose remainder
+ * contains no further `/`. The `format=uris` fast path returns the
+ * URIs without issuing `getObject`; `format=full` only fetches the
+ * selected page.
+ */
+import { bytesOnlyDelete, bytesOnlyEntitySupport, bytesOnlyRead, bytesOnlyWrite, } from "../byte-entity-shim.js";
+import { dispatchRead } from "../dispatch.js";
+import { storageFailure } from "../errors.js";
+import { validateReadParams } from "../read.js";
+const STORE_NAME = "S3Store";
+const EXT = ".bin";
+/** `protocol://host/path` → `protocol_host/path`. */
+function uriToKey(uri) {
+    return uri.replace("://", "_").replace(/^\//, "");
+}
+/** Inverse of `uriToKey` with `.bin` suffix stripping. */
+function keyTailToUri(tail) {
+    const noExt = tail.endsWith(EXT) ? tail.slice(0, -EXT.length) : tail;
+    return noExt.replace("_", "://");
+}
+export class S3Store {
+    bucket;
+    executor;
+    prefix;
+    constructor(bucket, executor, prefix) {
+        if (!bucket)
+            throw new Error("bucket is required");
+        if (!executor)
+            throw new Error("executor is required");
+        this.bucket = bucket;
+        this.executor = executor;
+        this.prefix = prefix ?? "";
+    }
+    // ── EntityStore surface ──────────────────────────────────────────
+    entitySupport(schema) {
+        return bytesOnlyEntitySupport(schema);
+    }
+    entityStatus(meta) {
+        return Promise.resolve(meta.isBytes ? "live" : "unprovisioned");
+    }
+    provisionEntity(_meta) {
+        return Promise.resolve();
+    }
+    write(meta, entries) {
+        return bytesOnlyWrite(meta, STORE_NAME, entries, (e) => this._writeBytes(e));
+    }
+    read(meta, urls) {
+        return bytesOnlyRead(meta, STORE_NAME, urls, (u) => this._readBytes(u));
+    }
+    delete(meta, uris) {
+        return bytesOnlyDelete(meta, STORE_NAME, uris, (u) => this._deleteBytes(u));
+    }
+    // ── Byte ops (BYTES_ENTITY routing) ──────────────────────────────
+    async _writeBytes(entries) {
+        const results = [];
+        for (const entry of entries) {
+            try {
+                await this.executor.putObject(this._resolveKey(entry.uri), entry.payload, "application/octet-stream");
+                results.push({ success: true });
+            }
+            catch (err) {
+                results.push({
+                    success: false,
+                    ...storageFailure(err, "Write failed", entry.uri),
+                });
+            }
+        }
+        return results;
+    }
+    _readBytes(urls) {
+        return dispatchRead(urls, STORE_NAME, {
+            read: (p) => this._readOne(p.uri),
+            ls: (p) => this._ls(p),
+            count: (p) => this._count(p),
+        });
+    }
+    async _readOne(uri) {
+        const content = await this.executor.getObject(this._resolveKey(uri));
+        return content ?? undefined;
+    }
+    /** List direct-child URIs under a prefix (no recursion into sub-prefixes). */
+    async _listChildUris(prefixUri) {
+        const keyPrefix = `${this.prefix}${uriToKey(prefixUri)}`;
+        const keys = await this.executor.listObjects(keyPrefix);
+        const uris = [];
+        for (const key of keys) {
+            if (!key.endsWith(EXT))
+                continue;
+            const tail = key.slice(keyPrefix.length);
+            if (tail.includes("/"))
+                continue; // nested, not a direct leaf
+            uris.push(`${prefixUri}${keyTailToUri(tail)}`);
+        }
+        return uris;
+    }
+    async _ls(parsed) {
+        validateReadParams(parsed.params, STORE_NAME);
+        const { params } = parsed;
+        const format = params.format ?? "full";
+        let uris = await this._listChildUris(parsed.uri);
+        if (params.sortBy === "uri") {
+            const dir = params.sortOrder === "desc" ? -1 : 1;
+            uris = [...uris].sort((a, b) => a.localeCompare(b) * dir);
+        }
+        if (params.limit !== undefined) {
+            const page = params.page ?? 1;
+            const start = (page - 1) * params.limit;
+            uris = uris.slice(start, start + params.limit);
+        }
+        if (format === "uris")
+            return uris;
+        const out = [];
+        for (const uri of uris) {
+            out.push([uri, await this._readOne(uri)]);
+        }
+        return out;
+    }
+    async _count(parsed) {
+        if (parsed.params.pattern !== undefined) {
+            throw new Error(`${STORE_NAME}: pattern filter not supported`);
+        }
+        return (await this._listChildUris(parsed.uri)).length;
+    }
+    async _deleteBytes(uris) {
+        const results = [];
+        for (const uri of uris) {
+            try {
+                await this.executor.deleteObject(this._resolveKey(uri));
+                results.push({ success: true });
+            }
+            catch (err) {
+                results.push({
+                    success: false,
+                    ...storageFailure(err, "Delete failed", uri),
+                });
+            }
+        }
+        return results;
+    }
+    // ── Status ───────────────────────────────────────────────────────
+    async status() {
+        try {
+            const ok = await this.executor.headBucket();
+            if (!ok) {
+                return {
+                    status: "unhealthy",
+                    message: `Bucket not accessible: ${this.bucket}`,
+                    fns: ["read", "ls", "count"],
+                };
+            }
+            return {
+                status: "healthy",
+                message: "S3 store is operational",
+                fns: ["read", "ls", "count"],
+                details: {
+                    bucket: this.bucket,
+                    prefix: this.prefix || "(none)",
+                },
+            };
+        }
+        catch (error) {
+            return {
+                status: "unhealthy",
+                message: error instanceof Error ? error.message : String(error),
+                fns: ["read", "ls", "count"],
+            };
+        }
+    }
+    capabilities() {
+        return { atomicBatch: false };
+    }
+    _resolveKey(uri) {
+        return `${this.prefix}${uriToKey(uri)}${EXT}`;
+    }
+}

package/esm/sqlite/mod.d.ts

@@ -0,0 +1,18 @@
+/**
+ * SQLite backend for b3nd.
+ *
+ * Store implementation backed by SQLite. Requires an injected SqliteExecutor
+ * so the SDK does not depend on a specific SQLite driver.
+ */
+export interface SqliteExecutorResult {
+    rows: Record<string, unknown>[];
+    rowCount?: number;
+}
+export interface SqliteExecutor {
+    query: (sql: string, args?: unknown[]) => SqliteExecutorResult;
+    transaction: <T>(fn: (tx: SqliteExecutor) => T) => T;
+    cleanup?: () => void;
+}
+export { SqliteStore } from "./store.js";
+export { generateSqliteSchema } from "./schema.js";
+//# sourceMappingURL=mod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/sqlite/mod.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,KAAK,oBAAoB,CAAC;IAC/D,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,cAAc,KAAK,CAAC,KAAK,CAAC,CAAC;IACrD,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACtB;AAED,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC"}

package/esm/sqlite/mod.js

@@ -0,0 +1,8 @@
+/**
+ * SQLite backend for b3nd.
+ *
+ * Store implementation backed by SQLite. Requires an injected SqliteExecutor
+ * so the SDK does not depend on a specific SQLite driver.
+ */
+export { SqliteStore } from "./store.js";
+export { generateSqliteSchema } from "./schema.js";

package/esm/sqlite/schema.d.ts

@@ -0,0 +1,10 @@
+/**
+ * SQLite schema utilities for b3nd.
+ *
+ * Generates SQLite-compatible DDL. The schema is intentionally
+ * minimal: `uri` (PK) + `payload` (BLOB) + timestamps. The store is
+ * opaque — `payload` is raw bytes, not JSON; higher layers own
+ * serialization.
+ */
+export declare function generateSqliteSchema(tablePrefix: string): string;
+//# sourceMappingURL=schema.d.ts.map

package/esm/sqlite/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/sqlite/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAqBhE"}

package/esm/sqlite/schema.js

@@ -0,0 +1,26 @@
+/**
+ * SQLite schema utilities for b3nd.
+ *
+ * Generates SQLite-compatible DDL. The schema is intentionally
+ * minimal: `uri` (PK) + `payload` (BLOB) + timestamps. The store is
+ * opaque — `payload` is raw bytes, not JSON; higher layers own
+ * serialization.
+ */
+export function generateSqliteSchema(tablePrefix) {
+    if (!tablePrefix) {
+        throw new Error("tablePrefix is required and cannot be empty");
+    }
+    if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(tablePrefix)) {
+        throw new Error("tablePrefix must start with a letter and contain only letters, numbers, and underscores");
+    }
+    return `-- SQLite schema for b3nd storage
+-- Table prefix: ${tablePrefix}
+
+CREATE TABLE IF NOT EXISTS ${tablePrefix}_data (
+    uri TEXT PRIMARY KEY,
+    payload BLOB NOT NULL,
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now'))
+);
+`;
+}

package/esm/sqlite/store.d.ts

@@ -0,0 +1,42 @@
+/**
+ * SqliteStore — SQLite implementation of Store.
+ *
+ * Pure mechanical byte storage with no protocol awareness. Pushes
+ * fn=ls/fn=count down to SQL using the shallow-direct-leaves
+ * predicate: `uri LIKE ? || '%' AND uri NOT LIKE ? || '%/%'`.
+ *
+ * Uses an injected synchronous SqliteExecutor; results are wrapped in
+ * Promise.resolve() to satisfy the async Store interface. `payload`
+ * is a BLOB; the store does not inspect or transform its contents.
+ */
+import type { DeleteResult, Output, StatusResult } from "../deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/types/types.js";
+import { type BytesOnlyEntityMeta } from "../byte-entity-shim.js";
+import type { EntityStore } from "../entity-store.js";
+import type { EntityRecord, EntitySchema } from "../entity.js";
+import type { StoreCapabilities, StoreWriteResult } from "../types.js";
+import type { SqliteExecutor } from "./mod.js";
+export declare class SqliteStore implements EntityStore<BytesOnlyEntityMeta> {
+    private readonly tableName;
+    private readonly executor;
+    private readonly provisioned;
+    constructor(tablePrefix: string, executor: SqliteExecutor);
+    entitySupport(schema: EntitySchema): BytesOnlyEntityMeta;
+    entityStatus(meta: BytesOnlyEntityMeta): Promise<"live" | "unprovisioned">;
+    provisionEntity(meta: BytesOnlyEntityMeta): Promise<void>;
+    write(meta: BytesOnlyEntityMeta, entries: {
+        uri: string;
+        record: EntityRecord;
+    }[]): Promise<StoreWriteResult[]>;
+    read<T = EntityRecord | undefined>(meta: BytesOnlyEntityMeta, urls: string[]): Promise<Output<T>[]>;
+    delete(meta: BytesOnlyEntityMeta, uris: string[]): Promise<DeleteResult[]>;
+    private _writeBytes;
+    private _readBytes;
+    private _readOne;
+    private _ls;
+    private _count;
+    private _deleteBytes;
+    status(): Promise<StatusResult>;
+    private schemaUris;
+    capabilities(): StoreCapabilities;
+}
+//# sourceMappingURL=store.d.ts.map

package/esm/sqlite/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/sqlite/store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,MAAM,EACN,YAAY,EACb,MAAM,mEAAmE,CAAC;AAC3E,OAAO,EAEL,KAAK,mBAAmB,EAIzB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAO/D,OAAO,KAAK,EACV,iBAAiB,EAEjB,gBAAgB,EACjB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAW/C,qBAAa,WAAY,YAAW,WAAW,CAAC,mBAAmB,CAAC;IAClE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiB;IAK1C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;gBAErC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc;IAUzD,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,mBAAmB;IAIxD,YAAY,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,GAAG,eAAe,CAAC;IAI1E,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IASzD,KAAK,CACH,IAAI,EAAE,mBAAmB,EACzB,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,YAAY,CAAA;KAAE,EAAE,GAC/C,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAS9B,IAAI,CAAC,CAAC,GAAG,YAAY,GAAG,SAAS,EAC/B,IAAI,EAAE,mBAAmB,EACzB,IAAI,EAAE,MAAM,EAAE,GACb,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;IASvB,MAAM,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;YAW5D,WAAW;IAqCzB,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,QAAQ;IAShB,OAAO,CAAC,GAAG;IA2BX,OAAO,CAAC,MAAM;IAYd,OAAO,CAAC,YAAY;IAwBpB,MAAM,IAAI,OAAO,CAAC,YAAY,CAAC;IAoB/B,OAAO,CAAC,UAAU;IAIlB,YAAY,IAAI,iBAAiB;CAGlC"}

package/esm/sqlite/store.js

@@ -0,0 +1,184 @@
+/**
+ * SqliteStore — SQLite implementation of Store.
+ *
+ * Pure mechanical byte storage with no protocol awareness. Pushes
+ * fn=ls/fn=count down to SQL using the shallow-direct-leaves
+ * predicate: `uri LIKE ? || '%' AND uri NOT LIKE ? || '%/%'`.
+ *
+ * Uses an injected synchronous SqliteExecutor; results are wrapped in
+ * Promise.resolve() to satisfy the async Store interface. `payload`
+ * is a BLOB; the store does not inspect or transform its contents.
+ */
+import { bytesOnlyDelete, bytesOnlyEntitySupport, bytesOnlyRead, bytesOnlyWrite, } from "../byte-entity-shim.js";
+import { dispatchRead } from "../dispatch.js";
+import { storageFailure } from "../errors.js";
+import { toBytes } from "../payload.js";
+import { validateReadParams } from "../read.js";
+const STORE_NAME = "SqliteStore";
+function rowToBytes(value) {
+    if (value instanceof Uint8Array)
+        return value;
+    if (value instanceof ArrayBuffer)
+        return new Uint8Array(value);
+    if (Array.isArray(value))
+        return new Uint8Array(value);
+    throw new Error(`SqliteStore: unexpected payload type ${typeof value}`);
+}
+export class SqliteStore {
+    tableName;
+    executor;
+    // Names of entities provisioned on this store. SqliteStore currently
+    // routes only BYTES_ENTITY, so this is at most `{"bytes"}` — but the
+    // tracking shape matches MemoryStore so `status().schema` reads the
+    // same way across backends.
+    provisioned = new Set();
+    constructor(tablePrefix, executor) {
+        if (!tablePrefix)
+            throw new Error("tablePrefix is required");
+        if (!executor)
+            throw new Error("executor is required");
+        this.tableName = `${tablePrefix}_data`;
+        this.executor = executor;
+    }
+    // ── EntityStore surface ──────────────────────────────────────────
+    entitySupport(schema) {
+        return bytesOnlyEntitySupport(schema);
+    }
+    entityStatus(meta) {
+        return Promise.resolve(meta.isBytes ? "live" : "unprovisioned");
+    }
+    provisionEntity(meta) {
+        // Only BYTES_ENTITY is honored at the storage layer; record the
+        // name so `status()` surfaces what callers can actually use.
+        // Non-bytes schemas are silently ignored — `write`/`read` already
+        // surface "Unsupported schema" via the shim.
+        if (meta.isBytes)
+            this.provisioned.add(meta.schema.name);
+        return Promise.resolve();
+    }
+    write(meta, entries) {
+        return bytesOnlyWrite(meta, STORE_NAME, entries, (e) => this._writeBytes(e));
+    }
+    read(meta, urls) {
+        return bytesOnlyRead(meta, STORE_NAME, urls, (u) => this._readBytes(u));
+    }
+    delete(meta, uris) {
+        return bytesOnlyDelete(meta, STORE_NAME, uris, (u) => this._deleteBytes(u));
+    }
+    // ── Byte ops (BYTES_ENTITY routing) ──────────────────────────────
+    async _writeBytes(entries) {
+        if (entries.length === 0)
+            return [];
+        // Collect streams up front: the executor is synchronous (BLOB
+        // wants bytes), and we don't want to await mid-transaction.
+        const prepared = await Promise.all(entries.map(async (e) => ({
+            uri: e.uri,
+            bytes: await toBytes(e.payload),
+        })));
+        // `capabilities.atomicBatch` is true: the whole batch commits or
+        // nothing does. On failure every result is `{ success: false }`
+        // with the same root-cause error.
+        try {
+            this.executor.transaction((tx) => {
+                for (const entry of prepared) {
+                    tx.query(`INSERT INTO ${this.tableName} (uri, payload, updated_at)
+             VALUES (?, ?, datetime('now'))
+             ON CONFLICT(uri) DO UPDATE SET
+               payload = excluded.payload,
+               updated_at = datetime('now')`, [entry.uri, entry.bytes]);
+                }
+            });
+            return entries.map(() => ({ success: true }));
+        }
+        catch (err) {
+            const failure = storageFailure(err, "Write failed");
+            return entries.map(() => ({ success: false, ...failure }));
+        }
+    }
+    _readBytes(urls) {
+        return dispatchRead(urls, STORE_NAME, {
+            read: (p) => this._readOne(p.uri),
+            ls: (p) => this._ls(p),
+            count: (p) => this._count(p),
+        });
+    }
+    _readOne(uri) {
+        const result = this.executor.query(`SELECT payload FROM ${this.tableName} WHERE uri = ?`, [uri]);
+        if (!result.rows.length)
+            return undefined;
+        return rowToBytes(result.rows[0].payload);
+    }
+    _ls(parsed) {
+        validateReadParams(parsed.params, STORE_NAME);
+        const { params } = parsed;
+        const format = params.format ?? "full";
+        const select = format === "uris" ? "uri" : "uri, payload";
+        const order = params.sortBy === "uri"
+            ? ` ORDER BY uri ${params.sortOrder === "desc" ? "DESC" : "ASC"}`
+            : "";
+        let sql = `SELECT ${select} FROM ${this.tableName} WHERE uri LIKE ? || '%' AND uri NOT LIKE ? || '%/%'${order}`;
+        const args = [parsed.uri, parsed.uri];
+        if (params.limit !== undefined) {
+            const page = params.page ?? 1;
+            sql += ` LIMIT ? OFFSET ?`;
+            args.push(params.limit, (page - 1) * params.limit);
+        }
+        const result = this.executor.query(sql, args);
+        const rows = result.rows;
+        if (format === "uris")
+            return rows.map((r) => r.uri);
+        return rows.map((r) => [r.uri, rowToBytes(r.payload)]);
+    }
+    _count(parsed) {
+        if (parsed.params.pattern !== undefined) {
+            throw new Error(`${STORE_NAME}: pattern filter not supported`);
+        }
+        const result = this.executor.query(`SELECT COUNT(*) AS n FROM ${this.tableName} WHERE uri LIKE ? || '%' AND uri NOT LIKE ? || '%/%'`, [parsed.uri, parsed.uri]);
+        const row = result.rows[0];
+        return row?.n ?? 0;
+    }
+    _deleteBytes(uris) {
+        if (uris.length === 0)
+            return Promise.resolve([]);
+        // Atomic batch: every uri either deletes together or not at all.
+        try {
+            this.executor.transaction((tx) => {
+                for (const uri of uris) {
+                    tx.query(`DELETE FROM ${this.tableName} WHERE uri = ?`, [uri]);
+                }
+            });
+            return Promise.resolve(uris.map(() => ({ success: true })));
+        }
+        catch (err) {
+            const failure = storageFailure(err, "Delete failed");
+            return Promise.resolve(uris.map(() => ({ success: false, ...failure })));
+        }
+    }
+    // ── Status ───────────────────────────────────────────────────────
+    status() {
+        try {
+            this.executor.query("SELECT 1");
+            return Promise.resolve({
+                status: "healthy",
+                message: "SQLite store is operational",
+                schema: this.schemaUris(),
+                fns: ["read", "ls", "count"],
+                details: { tableName: this.tableName },
+            });
+        }
+        catch (error) {
+            return Promise.resolve({
+                status: "unhealthy",
+                message: error instanceof Error ? error.message : String(error),
+                schema: this.schemaUris(),
+                fns: ["read", "ls", "count"],
+            });
+        }
+    }
+    schemaUris() {
+        return [...this.provisioned].map((name) => `entity:${name}`);
+    }
+    capabilities() {
+        return { atomicBatch: true };
+    }
+}