@bandeira-tech/b3nd-save 0.8.1

package/esm/ipfs/mod.d.ts

@@ -0,0 +1,24 @@
+/**
+ * IPFS backend for b3nd.
+ *
+ * Store implementation backed by IPFS. Requires an injected
+ * IpfsExecutor so the package does not depend on a specific IPFS
+ * library. Blocks hold raw payload bytes — the store is opaque.
+ *
+ * `add` accepts the `StorePayload` union to support both buffered
+ * and streaming callers; `cat` returns a `ReadableStream<Uint8Array>`
+ * to avoid materializing the block in memory unless the caller wants
+ * it.
+ */
+import type { StorePayload } from "../types.js";
+export interface IpfsExecutor {
+    add: (content: StorePayload) => Promise<string>;
+    cat: (cid: string) => Promise<ReadableStream<Uint8Array>>;
+    pin: (cid: string) => Promise<void>;
+    unpin: (cid: string) => Promise<void>;
+    listPins: () => Promise<string[]>;
+    isOnline: () => Promise<boolean>;
+    cleanup?: () => Promise<void>;
+}
+export { IpfsStore } from "./store.js";
+//# sourceMappingURL=mod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/ipfs/mod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAChD,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC;IAC1D,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,QAAQ,EAAE,MAAM,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAClC,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B;AAED,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC"}

package/esm/ipfs/mod.js

@@ -0,0 +1,13 @@
+/**
+ * IPFS backend for b3nd.
+ *
+ * Store implementation backed by IPFS. Requires an injected
+ * IpfsExecutor so the package does not depend on a specific IPFS
+ * library. Blocks hold raw payload bytes — the store is opaque.
+ *
+ * `add` accepts the `StorePayload` union to support both buffered
+ * and streaming callers; `cat` returns a `ReadableStream<Uint8Array>`
+ * to avoid materializing the block in memory unless the caller wants
+ * it.
+ */
+export { IpfsStore } from "./store.js";

package/esm/ipfs/store.d.ts

@@ -0,0 +1,42 @@
+/**
+ * IpfsStore — IPFS implementation of Store.
+ *
+ * Pure mechanical byte storage with no protocol awareness. Writes
+ * pinned IPFS objects and maintains an in-memory `uri → CID` index
+ * for lookups. The block body is the payload bytes verbatim.
+ *
+ * `fn=ls` / `fn=count` are shallow direct-leaves only: scan the
+ * in-memory index, keep URIs whose remainder under the prefix has no
+ * further `/`.
+ */
+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 { IpfsExecutor } from "./mod.js";
+export declare class IpfsStore implements EntityStore<BytesOnlyEntityMeta> {
+    private readonly executor;
+    private readonly index;
+    constructor(executor: IpfsExecutor);
+    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;
+    /** Shallow direct-leaves from the in-memory URI index. */
+    private _directLeafUris;
+    private _ls;
+    private _count;
+    private _deleteBytes;
+    status(): Promise<StatusResult>;
+    capabilities(): StoreCapabilities;
+}
+//# sourceMappingURL=store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/ipfs/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;AAM/D,OAAO,KAAK,EACV,iBAAiB,EAEjB,gBAAgB,EACjB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAQ7C,qBAAa,SAAU,YAAW,WAAW,CAAC,mBAAmB,CAAC;IAChE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAe;IACxC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiC;gBAE3C,QAAQ,EAAE,YAAY;IAOlC,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;IAiCzB,OAAO,CAAC,UAAU;YAQJ,QAAQ;IAYtB,0DAA0D;IAC1D,OAAO,CAAC,eAAe;YAWT,GAAG;IA0BjB,OAAO,CAAC,MAAM;YAOA,YAAY;IA4BpB,MAAM,IAAI,OAAO,CAAC,YAAY,CAAC;IAqCrC,YAAY,IAAI,iBAAiB;CAGlC"}

package/esm/ipfs/store.js

@@ -0,0 +1,197 @@
+/**
+ * IpfsStore — IPFS implementation of Store.
+ *
+ * Pure mechanical byte storage with no protocol awareness. Writes
+ * pinned IPFS objects and maintains an in-memory `uri → CID` index
+ * for lookups. The block body is the payload bytes verbatim.
+ *
+ * `fn=ls` / `fn=count` are shallow direct-leaves only: scan the
+ * in-memory index, keep URIs whose remainder under the prefix has no
+ * further `/`.
+ */
+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 = "IpfsStore";
+export class IpfsStore {
+    executor;
+    index = new Map();
+    constructor(executor) {
+        if (!executor)
+            throw new Error("executor is required");
+        this.executor = executor;
+    }
+    // ── 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 {
+                const cid = await this.executor.add(entry.payload);
+                await this.executor.pin(cid);
+                // Unpin the old CID if this URI was already indexed
+                const existing = this.index.get(entry.uri);
+                if (existing) {
+                    try {
+                        await this.executor.unpin(existing.cid);
+                    }
+                    catch {
+                        // Old CID may already be unpinned — ignore
+                    }
+                }
+                this.index.set(entry.uri, { cid });
+                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 entry = this.index.get(uri);
+        if (!entry)
+            return undefined;
+        try {
+            return await this.executor.cat(entry.cid);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** Shallow direct-leaves from the in-memory URI index. */
+    _directLeafUris(prefixUri) {
+        const out = [];
+        for (const uri of this.index.keys()) {
+            if (!uri.startsWith(prefixUri))
+                continue;
+            const tail = uri.slice(prefixUri.length);
+            if (tail === "" || tail.includes("/"))
+                continue;
+            out.push(uri);
+        }
+        return out;
+    }
+    async _ls(parsed) {
+        validateReadParams(parsed.params, STORE_NAME);
+        const { params } = parsed;
+        const format = params.format ?? "full";
+        let uris = this._directLeafUris(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;
+    }
+    _count(parsed) {
+        if (parsed.params.pattern !== undefined) {
+            throw new Error(`${STORE_NAME}: pattern filter not supported`);
+        }
+        return this._directLeafUris(parsed.uri).length;
+    }
+    async _deleteBytes(uris) {
+        const results = [];
+        for (const uri of uris) {
+            try {
+                const entry = this.index.get(uri);
+                if (entry) {
+                    try {
+                        await this.executor.unpin(entry.cid);
+                    }
+                    catch {
+                        // CID may already be unpinned — ignore
+                    }
+                    this.index.delete(uri);
+                }
+                results.push({ success: true });
+            }
+            catch (err) {
+                results.push({
+                    success: false,
+                    ...storageFailure(err, "Delete failed", uri),
+                });
+            }
+        }
+        return results;
+    }
+    // ── Status ───────────────────────────────────────────────────────
+    async status() {
+        try {
+            const online = await this.executor.isOnline();
+            if (!online) {
+                return {
+                    status: "unhealthy",
+                    message: "IPFS node is not reachable",
+                    fns: ["read", "ls", "count"],
+                };
+            }
+            // Derive schema from indexed URIs
+            const programs = new Set();
+            for (const uri of this.index.keys()) {
+                try {
+                    const url = new URL(uri);
+                    programs.add(`${url.protocol}//${url.hostname}`);
+                }
+                catch {
+                    // skip malformed URIs
+                }
+            }
+            return {
+                status: "healthy",
+                schema: [...programs],
+                fns: ["read", "ls", "count"],
+                details: { indexedUris: this.index.size },
+            };
+        }
+        catch (error) {
+            return {
+                status: "unhealthy",
+                message: error instanceof Error ? error.message : String(error),
+                fns: ["read", "ls", "count"],
+            };
+        }
+    }
+    capabilities() {
+        return { atomicBatch: false };
+    }
+}

package/esm/localstorage/mod.d.ts

@@ -0,0 +1,9 @@
+/**
+ * LocalStorage backend for b3nd.
+ *
+ * Browser localStorage Store implementation. Pure mechanical storage
+ * with no protocol awareness — wrap with SaveClient
+ * for NodeProtocolInterface.
+ */
+export { LocalStorageStore } from "./store.js";
+//# sourceMappingURL=mod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/localstorage/mod.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC"}

package/esm/localstorage/mod.js

@@ -0,0 +1,8 @@
+/**
+ * LocalStorage backend for b3nd.
+ *
+ * Browser localStorage Store implementation. Pure mechanical storage
+ * with no protocol awareness — wrap with SaveClient
+ * for NodeProtocolInterface.
+ */
+export { LocalStorageStore } from "./store.js";

package/esm/localstorage/store.d.ts

@@ -0,0 +1,45 @@
+/**
+ * LocalStorageStore — browser localStorage implementation of Store.
+ *
+ * Pure mechanical byte storage with no protocol awareness. Uses
+ * `localStorage` as a flat key→string KV. Payload bytes are
+ * base64-encoded since `localStorage` values are strings.
+ */
+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";
+export declare class LocalStorageStore implements EntityStore<BytesOnlyEntityMeta> {
+    private readonly keyPrefix;
+    private readonly storage;
+    constructor(config?: {
+        keyPrefix?: string;
+        storage?: Storage;
+    });
+    private getKey;
+    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;
+    /**
+     * Walk localStorage once, returning `[uri, bytes]` for every entry
+     * whose URI is `prefix + <segment>` with no further `/`. Subtree-only
+     * paths are excluded by the slash check.
+     */
+    private _directLeaves;
+    private _ls;
+    private _count;
+    private _deleteBytes;
+    status(): Promise<StatusResult>;
+    capabilities(): StoreCapabilities;
+}
+//# sourceMappingURL=store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/localstorage/store.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;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;AAQ/D,OAAO,KAAK,EACV,iBAAiB,EAEjB,gBAAgB,EACjB,MAAM,aAAa,CAAC;AAIrB,qBAAa,iBAAkB,YAAW,WAAW,CAAC,mBAAmB,CAAC;IACxE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;gBAEtB,MAAM,GAAE;QAClB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,CAAC,EAAE,OAAO,CAAC;KACd;IAUN,OAAO,CAAC,MAAM;IAMd,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;IAqBzB,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,QAAQ;IAMhB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAcrB,OAAO,CAAC,GAAG;IAQX,OAAO,CAAC,MAAM;IAOd,OAAO,CAAC,YAAY;IAoBpB,MAAM,IAAI,OAAO,CAAC,YAAY,CAAC;IAmB/B,YAAY,IAAI,iBAAiB;CAGlC"}

package/esm/localstorage/store.js

@@ -0,0 +1,147 @@
+/**
+ * LocalStorageStore — browser localStorage implementation of Store.
+ *
+ * Pure mechanical byte storage with no protocol awareness. Uses
+ * `localStorage` as a flat key→string KV. Payload bytes are
+ * base64-encoded since `localStorage` values are strings.
+ */
+import { bytesOnlyDelete, bytesOnlyEntitySupport, bytesOnlyRead, bytesOnlyWrite, } from "../byte-entity-shim.js";
+import { decodeBase64, encodeBase64 } from "../deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/mod.js";
+import { dispatchRead } from "../dispatch.js";
+import { storageFailure } from "../errors.js";
+import { toBytes } from "../payload.js";
+import { applyReadParams } from "../read.js";
+const STORE_NAME = "LocalStorageStore";
+export class LocalStorageStore {
+    keyPrefix;
+    storage;
+    constructor(config = {}) {
+        this.keyPrefix = config.keyPrefix || "b3nd:";
+        this.storage = config.storage ||
+            (typeof localStorage !== "undefined" ? localStorage : null);
+        if (!this.storage) {
+            throw new Error("localStorage is not available in this environment");
+        }
+    }
+    getKey(uri) {
+        return `${this.keyPrefix}${uri}`;
+    }
+    // ── 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 {
+                const bytes = await toBytes(entry.payload);
+                this.storage.setItem(this.getKey(entry.uri), encodeBase64(bytes));
+                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),
+        });
+    }
+    _readOne(uri) {
+        const serialized = this.storage.getItem(this.getKey(uri));
+        if (serialized === null)
+            return undefined;
+        return decodeBase64(serialized);
+    }
+    /**
+     * Walk localStorage once, returning `[uri, bytes]` for every entry
+     * whose URI is `prefix + <segment>` with no further `/`. Subtree-only
+     * paths are excluded by the slash check.
+     */
+    _directLeaves(prefixUri) {
+        const prefixKey = this.getKey(prefixUri);
+        const out = [];
+        for (let i = 0; i < this.storage.length; i++) {
+            const key = this.storage.key(i);
+            if (!key || !key.startsWith(prefixKey))
+                continue;
+            const rest = key.substring(prefixKey.length);
+            if (rest === "" || rest.includes("/"))
+                continue;
+            const childUri = `${prefixUri}${rest}`;
+            out.push([childUri, this._readOne(childUri)]);
+        }
+        return out;
+    }
+    _ls(parsed) {
+        return applyReadParams(this._directLeaves(parsed.uri), parsed.params, STORE_NAME);
+    }
+    _count(parsed) {
+        if (parsed.params.pattern !== undefined) {
+            throw new Error(`${STORE_NAME}: pattern filter not supported`);
+        }
+        return this._directLeaves(parsed.uri).length;
+    }
+    _deleteBytes(uris) {
+        const results = [];
+        for (const uri of uris) {
+            try {
+                this.storage.removeItem(this.getKey(uri));
+                results.push({ success: true });
+            }
+            catch (err) {
+                results.push({
+                    success: false,
+                    ...storageFailure(err, "Delete failed", uri),
+                });
+            }
+        }
+        return Promise.resolve(results);
+    }
+    // ── Status ───────────────────────────────────────────────────────
+    status() {
+        try {
+            const testKey = `${this.keyPrefix}__health_check__`;
+            this.storage.setItem(testKey, "ok");
+            this.storage.removeItem(testKey);
+            return Promise.resolve({
+                status: "healthy",
+                schema: [],
+                fns: ["read", "ls", "count"],
+            });
+        }
+        catch {
+            return Promise.resolve({
+                status: "unhealthy",
+                schema: [],
+                fns: ["read", "ls", "count"],
+            });
+        }
+    }
+    capabilities() {
+        return { atomicBatch: false };
+    }
+}

package/esm/memory/mod.d.ts

@@ -0,0 +1,12 @@
+/**
+ * In-memory `EntityStore` backend.
+ *
+ * `MemoryStore` is the reference implementation — one flat
+ * `Map<uri, EntityRecord>` per ensured entity. Useful as a
+ * deterministic stand-in for tests and prototypes.
+ *
+ * Follows the shallow direct-leaves `fn=ls` / `fn=count` contract
+ * enforced across every backend in this package.
+ */
+export { MemoryStore } from "./store.js";
+//# sourceMappingURL=mod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/memory/mod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC"}

package/esm/memory/mod.js

@@ -0,0 +1,11 @@
+/**
+ * In-memory `EntityStore` backend.
+ *
+ * `MemoryStore` is the reference implementation — one flat
+ * `Map<uri, EntityRecord>` per ensured entity. Useful as a
+ * deterministic stand-in for tests and prototypes.
+ *
+ * Follows the shallow direct-leaves `fn=ls` / `fn=count` contract
+ * enforced across every backend in this package.
+ */
+export { MemoryStore } from "./store.js";

package/esm/memory/store.d.ts

@@ -0,0 +1,73 @@
+/**
+ * MemoryStore — in-memory reference implementation of `EntityStore`.
+ *
+ * One flat `Map<uri, EntityRecord>` per provisioned entity, keyed by
+ * the entity's name. `BYTES_ENTITY` is just another entity here — its
+ * records sit in the same map as any custom entity.
+ *
+ * ## Lifecycle
+ *
+ * `entitySupport(schema)` is pure: it walks the schema's fields,
+ * picks the first recognised `TYPE_TAGS` entry per field as the
+ * canonical tag, and returns the operational handle (declared field
+ * set, bytes-field set, signature for collision detection, support
+ * report). `provisionEntity(meta)` allocates the bucket and stores
+ * the meta's signature so future collisions can be detected.
+ * `entityStatus(meta)` returns `"live"` only when the cached
+ * signature matches `meta` exactly — a same-name-different-shape
+ * schema reports `"unprovisioned"`, where "shape" includes the
+ * canonical type tag of each field (so changing `["string"]` to
+ * `["bigint"]` on an existing field name is a collision, mirroring
+ * what SQL backends catch via column-type introspection).
+ *
+ * Writes/reads/deletes consume the meta directly: there is no
+ * per-call cache lookup gate. If `meta`'s bucket does not exist on
+ * this store, `write` and `delete` surface the medium's natural
+ * "not provisioned" storage failure per entry; `read` returns misses.
+ *
+ * ## Validation
+ *
+ * A record under `meta` may only contain keys declared in
+ * `meta.declared`. Extra keys produce a per-entry
+ * `StoreWriteResult` failure. The store does not coerce.
+ *
+ * `payload: ReadableStream` (and any other field whose type tag is
+ * `"bytes"`) is collected to `Uint8Array` via `toBytes` before the
+ * record lands in the bucket. That coercion runs for every entity
+ * that declares a bytes field; nothing about it is bytes-entity-
+ * specific.
+ */
+import type { DeleteResult, Output, StatusResult } from "../deps/jsr.io/@bandeira-tech/b3nd-core/0.22.0/src/types/types.js";
+import type { StoreCapabilities, StoreWriteResult } from "../types.js";
+import type { EntityStore } from "../entity-store.js";
+import { type EntityMeta, type EntityRecord, type EntitySchema } from "../entity.js";
+/**
+ * MemoryStore-specific entity handle.
+ *
+ * `declared` and `bytesFields` drive the per-write extras check and
+ * bytes-field normalisation. `signature` is the canonical string for
+ * collision detection in `entityStatus` / `provisionEntity`.
+ */
+export interface MemoryEntityMeta extends EntityMeta {
+    readonly declared: ReadonlySet<string>;
+    readonly bytesFields: ReadonlySet<string>;
+    readonly signature: string;
+}
+export declare class MemoryStore implements EntityStore<MemoryEntityMeta> {
+    private readonly buckets;
+    entitySupport(schema: EntitySchema): MemoryEntityMeta;
+    entityStatus(meta: MemoryEntityMeta): Promise<"live" | "unprovisioned">;
+    provisionEntity(meta: MemoryEntityMeta): Promise<void>;
+    write(meta: MemoryEntityMeta, entries: {
+        uri: string;
+        record: EntityRecord;
+    }[]): Promise<StoreWriteResult[]>;
+    read<T = EntityRecord | undefined>(meta: MemoryEntityMeta, urls: string[]): Promise<Output<T>[]>;
+    private _walk;
+    private _list;
+    private _count;
+    delete(meta: MemoryEntityMeta, uris: string[]): Promise<DeleteResult[]>;
+    status(): Promise<StatusResult>;
+    capabilities(): StoreCapabilities;
+}
+//# sourceMappingURL=store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/memory/store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,MAAM,EACN,YAAY,EACb,MAAM,mEAAmE,CAAC;AAK3E,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EACL,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,YAAY,EAGlB,MAAM,cAAc,CAAC;AAKtB;;;;;;GAMG;AACH,MAAM,WAAW,gBAAiB,SAAQ,UAAU;IAClD,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACvC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC1C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAOD,qBAAa,WAAY,YAAW,WAAW,CAAC,gBAAgB,CAAC;IAC/D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IAIrD,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,gBAAgB;IAwC/C,YAAY,CAChB,IAAI,EAAE,gBAAgB,GACrB,OAAO,CAAC,MAAM,GAAG,eAAe,CAAC;IAO9B,eAAe,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBtD,KAAK,CACT,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,YAAY,CAAA;KAAE,EAAE,GAC/C,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAsDxB,IAAI,CAAC,CAAC,GAAG,YAAY,GAAG,SAAS,EACrC,IAAI,EAAE,gBAAgB,EACtB,IAAI,EAAE,MAAM,EAAE,GACb,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;IAiBvB,OAAO,CAAC,KAAK;IAgBb,OAAO,CAAC,KAAK;IA8Bb,OAAO,CAAC,MAAM;IAYd,MAAM,CACJ,IAAI,EAAE,gBAAgB,EACtB,IAAI,EAAE,MAAM,EAAE,GACb,OAAO,CAAC,YAAY,EAAE,CAAC;IAgC1B,MAAM,IAAI,OAAO,CAAC,YAAY,CAAC;IAQ/B,YAAY,IAAI,iBAAiB;CAGlC"}