@bandeira-tech/b3nd-save 0.8.1 → 0.13.1

package/esm/indexeddb/store.js

@@ -1,24 +1,64 @@
 /**
- * IndexedDBStore — browser IndexedDB implementation of Store.
+ * IndexedDBStore — browser IndexedDB implementation of `EntityStore`.
  *
- * Pure mechanical byte storage with no protocol awareness. Uses
- * IndexedDB for large-scale persistent browser storage. IndexedDB's
- * structured clone preserves `Uint8Array` natively.
+ * Two layouts share one object store, separated by storage-key prefix.
+ * IDB's structured clone preserves typed values natively
+ * (`Uint8Array`, `Date`, `BigInt`, plain JSON), so records are stored
+ * verbatim — no JSON encoding step on the way in or out.
  *
- * `fn=ls` / `fn=count` are shallow direct-leaves only: cursor over
- * the `uri_index`, keep records whose URI is `prefix + <segment>`
- * with no further `/`. The `format=uris` fast path and `count` only
- * touch the index key — they never load the full record's payload.
+ * - `BYTES_ENTITY` → record `{ uri, payload }` keyed by `uri` (the
+ *   original byte-store layout — existing deployments keep working).
+ * - any other schema → record `{ uri, record }` keyed by
+ *   `__entities__/{entityName}/{originalUri}`. The `__entities__/`
+ *   prefix isolates entity slots from byte slots in the cursor's
+ *   ordered key space.
+ *
+ * ## Lifecycle
+ *
+ * `entitySupport(schema)` is pure — it plans the field set and computes
+ * a collision signature. `provisionEntity(meta)` writes a tiny meta
+ * record (`__meta__/{name}`) holding the signature; subsequent
+ * `entityStatus(meta)` reads it back. Same-name different-shape
+ * provisioning throws.
+ *
+ * IDB needs an `onupgradeneeded` to create object stores, but since we
+ * use a single store for everything, schema migrations are not required
+ * to grow new entities.
+ *
+ * ## Read params
+ *
+ * `fn=ls` / `fn=count` are shallow direct-leaves only: cursor over the
+ * `uri_index` bounded by `[storageKey, storageKey + ￿)`, keep records
+ * whose remainder under the prefix has no further `/`. Standard params
+ * (`limit`/`page`/`sortBy=uri`/`sortOrder`/`format=uris`) are honoured
+ * via cursor walking — `format=uris` and `count` skip loading payloads
+ * via `openKeyCursor`.
+ *
+ * `fn=find` (v2 §3.5) is the deep counterpart: same cursor, same
+ * range, no `rest.includes("/")` tail cutoff. With `pushDownFind:
+ * false` the handler returns every descendant under the prefix and
+ * dispatch applies the glob, sort, cursor, limit, format, and appends
+ * the cursor-as-trailing-slot. IDB has no engine for glob/regex
+ * push-down — its cursor only honours key-range and direction — so
+ * dispatch's post-filter path is the honest fit (same shape as memory
+ * PR #84).
  */
 import * as dntShim from "../_dnt.shims.js";
-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";
+import { BYTES_ENTITY, } from "../entity.js";
+import { IDENTIFIER_PATTERN, isValidIdentifier } from "../identifiers.js";
+import { computeSignature, planFields } from "./fields.js";
 const STORE_NAME = "IndexedDBStore";
+const ENTITY_PREFIX = "__entities__/";
+const META_PREFIX = "__meta__/";
 // deno-lint-ignore no-explicit-any
 const idbKeyRange = dntShim.dntGlobalThis.IDBKeyRange;
+function isBytesSchema(schema) {
+    return schema.name === BYTES_ENTITY.name;
+}
 export class IndexedDBStore {
     databaseName;
     storeName;
@@ -63,93 +103,185 @@ export class IndexedDBStore {
         const db = await this.initDB();
         return db.transaction([this.storeName], mode).objectStore(this.storeName);
     }
-    // ── EntityStore surface ──────────────────────────────────────────
+    // ── Lifecycle ────────────────────────────────────────────────────
     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));
+        if (isBytesSchema(schema)) {
+            const fields = [{ name: "payload", tag: "bytes" }];
+            return {
+                support: {
+                    entity: schema.name,
+                    supported: ["payload"],
+                    unsupported: [],
+                },
+                storageRoot: "",
+                isBytes: true,
+                fields,
+                declared: new Set(["payload"]),
+                bytesFields: new Set(["payload"]),
+                signature: computeSignature(schema.name, fields),
+            };
+        }
+        if (!isValidIdentifier(schema.name)) {
+            throw new Error(`${STORE_NAME}: entity name '${schema.name}' must match ${IDENTIFIER_PATTERN.source}`);
+        }
+        const { fields, unsupported } = planFields(schema.fields);
+        const declared = new Set(fields.map((f) => f.name));
+        const bytesFields = new Set(fields.filter((f) => f.tag === "bytes").map((f) => f.name));
+        return {
+            support: {
+                entity: schema.name,
+                supported: fields.map((f) => f.name),
+                unsupported,
+            },
+            storageRoot: `${ENTITY_PREFIX}${schema.name}/`,
+            isBytes: false,
+            fields,
+            declared,
+            bytesFields,
+            signature: computeSignature(schema.name, fields),
+        };
     }
-    read(meta, urls) {
-        return bytesOnlyRead(meta, STORE_NAME, urls, (u) => this._readBytes(u));
+    async entityStatus(meta) {
+        const recorded = await this._readMetaSignature(meta.support.entity);
+        if (recorded === null)
+            return "unprovisioned";
+        return recorded === meta.signature ? "live" : "unprovisioned";
     }
-    delete(meta, uris) {
-        return bytesOnlyDelete(meta, STORE_NAME, uris, (u) => this._deleteBytes(u));
+    async provisionEntity(meta) {
+        const recorded = await this._readMetaSignature(meta.support.entity);
+        if (recorded !== null) {
+            if (recorded !== meta.signature) {
+                throw new Error(`${STORE_NAME}: entity '${meta.support.entity}' is already ` +
+                    `provisioned with a different shape`);
+            }
+            return;
+        }
+        const doc = {
+            uri: `${META_PREFIX}${meta.support.entity}`,
+            signature: meta.signature,
+        };
+        const store = await this.getStore("readwrite");
+        await new Promise((resolve, reject) => {
+            const req = store.put(doc);
+            req.onsuccess = () => resolve();
+            req.onerror = () => reject(new Error(`Failed to write entity meta: ${req.error}`));
+        });
     }
-    // ── Byte ops (BYTES_ENTITY routing) ──────────────────────────────
-    async _writeBytes(entries) {
-        const results = [];
-        // Collect any streams to bytes BEFORE opening the IDB transaction.
-        // An IDB transaction stays alive only across IDB-callback
-        // microtasks; awaiting a non-IDB promise (like draining a
-        // ReadableStream) yields long enough for the transaction to
-        // auto-commit, after which subsequent put()s either throw
-        // `TransactionInactiveError` or silently no-op depending on the
-        // implementation. fake-indexeddb is permissive about this; real
-        // Chromium is not.
-        let prepared;
-        try {
-            prepared = await Promise.all(entries.map(async (e) => ({
-                uri: e.uri,
-                payload: await toBytes(e.payload),
-            })));
+    // ── Write ────────────────────────────────────────────────────────
+    async write(meta, entries) {
+        if (entries.length === 0)
+            return [];
+        if ((await this._readMetaSignature(meta.support.entity)) !== meta.signature) {
+            return entries.map(({ uri }) => ({
+                success: false,
+                ...storageFailure(new Error(`${STORE_NAME}: entity '${meta.support.entity}' is not provisioned`), "Entity not provisioned", uri),
+            }));
         }
-        catch (err) {
-            const failure = storageFailure(err, "Write failed");
-            return entries.map(() => ({ success: false, ...failure }));
+        // Validate + collect streams BEFORE opening the IDB transaction.
+        // IDB transactions stay alive only across IDB-callback microtasks;
+        // awaiting a non-IDB promise (like draining a ReadableStream)
+        // yields long enough for the transaction to auto-commit.
+        const out = new Array(entries.length);
+        const prepared = [];
+        for (let i = 0; i < entries.length; i++) {
+            const { uri, record } = entries[i];
+            const extras = Object.keys(record).filter((k) => !meta.declared.has(k));
+            if (extras.length > 0) {
+                out[i] = {
+                    success: false,
+                    ...storageFailure(new Error(`record contains keys not declared in schema '${meta.support.entity}': ${extras.join(", ")}`), "Schema mismatch", uri),
+                };
+                continue;
+            }
+            try {
+                if (meta.isBytes) {
+                    const payload = record.payload;
+                    if (!(payload instanceof Uint8Array) &&
+                        !(payload instanceof ReadableStream)) {
+                        throw new Error("BYTES_ENTITY record.payload must be Uint8Array or ReadableStream");
+                    }
+                    const bytes = await toBytes(payload);
+                    prepared.push({ idx: i, doc: { uri, payload: bytes } });
+                }
+                else {
+                    const normalised = await this._normaliseBytesFields(record, meta.bytesFields);
+                    prepared.push({
+                        idx: i,
+                        doc: { uri: `${meta.storageRoot}${uri}`, record: normalised },
+                    });
+                }
+            }
+            catch (err) {
+                out[i] = {
+                    success: false,
+                    ...storageFailure(err, "Write failed", uri),
+                };
+            }
         }
+        if (prepared.length === 0)
+            return out;
         try {
             const store = await this.getStore("readwrite");
-            for (const record of prepared) {
+            for (const { idx, doc } of prepared) {
                 try {
                     await new Promise((resolve, reject) => {
-                        const request = store.put(record);
-                        request.onsuccess = () => resolve();
-                        request.onerror = () => reject(new Error(`Failed to write ${record.uri}: ${request.error}`));
+                        const req = store.put(doc);
+                        req.onsuccess = () => resolve();
+                        req.onerror = () => reject(new Error(`Failed to write ${doc.uri}: ${req.error}`));
                     });
-                    results.push({ success: true });
+                    out[idx] = { success: true };
                 }
                 catch (err) {
-                    results.push({
+                    out[idx] = {
                         success: false,
-                        ...storageFailure(err, "Write failed", record.uri),
-                    });
+                        ...storageFailure(err, "Write failed", entries[idx].uri),
+                    };
                 }
             }
         }
         catch (err) {
-            // Outer failure (e.g. db open) — every entry fails with the same
-            // root cause; no per-entry uri since the failure isn't entry-scoped.
             const failure = storageFailure(err, "Write failed");
-            for (const _ of entries) {
-                results.push({ success: false, ...failure });
+            for (const { idx } of prepared) {
+                out[idx] = { success: false, ...failure };
             }
         }
-        return results;
+        return out;
     }
-    _readBytes(urls) {
+    // ── Read ─────────────────────────────────────────────────────────
+    read(meta, urls) {
         return dispatchRead(urls, STORE_NAME, {
-            read: (p) => this._readOne(p.uri),
-            ls: (p) => this._ls(p),
-            count: (p) => this._count(p),
+            read: (p) => this._readOne(meta, p.uri),
+            ls: (p) => this._ls(meta, p),
+            count: (p) => this._count(meta, p),
+            // v2 §3.5: find walks every descendant under the prefix (no
+            // shallow `/` cutoff). With `pushDownFind: false`, dispatch
+            // strips pattern/cursor/limit/page before calling, then applies
+            // the glob, sort, cursor, limit, format, and appends the cursor-
+            // as-trailing-slot on the returned rows. IDB has no engine for
+            // glob/regex push-down — only key-range + direction — so the
+            // honest shape mirrors memory PR #84: handler returns the raw
+            // deep walk, dispatch does the rest.
+            find: (p) => this._find(meta, p),
         });
     }
-    async _readOne(uri) {
+    async _readOne(meta, uri) {
         try {
             const store = await this.getStore();
+            const storageKey = meta.isBytes ? uri : `${meta.storageRoot}${uri}`;
             return await new Promise((resolve) => {
-                const request = store.get(uri);
-                request.onsuccess = () => {
-                    const record = request.result;
-                    resolve(record ? record.payload : undefined);
+                const req = store.get(storageKey);
+                req.onsuccess = () => {
+                    const doc = req.result;
+                    if (!doc)
+                        return resolve(undefined);
+                    if (meta.isBytes) {
+                        resolve({ payload: doc.payload });
+                    }
+                    else {
+                        resolve(doc.record);
+                    }
                 };
-                request.onerror = () => resolve(undefined);
+                req.onerror = () => resolve(undefined);
             });
         }
         catch {
@@ -157,30 +289,37 @@ export class IndexedDBStore {
         }
     }
     /**
-     * Open a cursor over the `uri_index` constrained to the prefix.
-     * Returns URIs (and optionally records) that are direct leaves
-     * under `prefixUri` — i.e. `prefixUri + <segment>` with no further
-     * `/`. Honours sortOrder and limit/page via cursor walking.
+     * Cursor over `uri_index` constrained to `[meta.storageRoot+prefix,
+     * meta.storageRoot+prefix+￿)`. Honours `sortOrder=desc` via `prev`
+     * direction and `limit`/`page` via cursor walking + skipping.
+     *
+     * `shallow` selects the walk shape:
+     *   - `true`  → only direct leaves (the `rest.includes("/")` tail
+     *     cutoff). Powers `fn=ls` and shallow `fn=count`.
+     *   - `false` → every descendant under the prefix, any depth. Powers
+     *     `fn=find` (v2 §3.5). Dispatch applies the glob, sort, cursor,
+     *     limit, format on top.
+     *
+     * Either way the exact-prefix match (`tail === ""`) is skipped — the
+     * URL identifies the parent, not a child of itself.
      */
-    async _walkLeaves(parsed, onlyUris) {
+    async _walkLeaves(meta, parsed, onlyKeys, shallow) {
         const { uri: prefix, params } = parsed;
         const desc = params.sortBy === "uri" && params.sortOrder === "desc";
         const direction = desc ? "prev" : "next";
         const limit = params.limit;
         const offset = limit !== undefined ? ((params.page ?? 1) - 1) * limit : 0;
-        // Bound the cursor to `[prefix, prefix + ￿)` — both ends
-        // inclusive of the prefix, exclusive of anything past the high
-        // surrogate. Fall back to a full scan if IDBKeyRange isn't
-        // available in this environment.
+        const lower = `${meta.storageRoot}${prefix}`;
+        const upper = `${lower}￿`;
         const range = this.keyRange
-            ? this.keyRange.bound(prefix, prefix + "￿", false, false)
+            ? this.keyRange.bound(lower, upper, false, false)
             : undefined;
         const store = await this.getStore();
         const index = store.index("uri_index");
         return await new Promise((resolve, reject) => {
             const out = [];
             let skipped = 0;
-            const request = onlyUris
+            const request = onlyKeys
                 ? index.openKeyCursor(range, direction)
                 : index.openCursor(range, direction);
             request.onsuccess = () => {
@@ -189,13 +328,13 @@ export class IndexedDBStore {
                     resolve(out);
                     return;
                 }
-                const key = (onlyUris ? cursor.key : cursor.value.uri);
-                if (!key.startsWith(prefix)) {
+                const storedKey = (onlyKeys ? cursor.key : cursor.value.uri);
+                if (!storedKey.startsWith(lower)) {
                     resolve(out);
                     return;
                 }
-                const tail = key.slice(prefix.length);
-                if (tail === "" || tail.includes("/")) {
+                const tail = storedKey.slice(lower.length);
+                if (tail === "" || (shallow && tail.includes("/"))) {
                     cursor.continue();
                     return;
                 }
@@ -204,12 +343,10 @@ export class IndexedDBStore {
                     cursor.continue();
                     return;
                 }
-                if (onlyUris) {
-                    out.push({ uri: key });
-                }
-                else {
-                    out.push({ uri: key, payload: cursor.value.payload });
-                }
+                const originalUri = `${prefix}${tail}`;
+                out.push(onlyKeys
+                    ? { uri: originalUri }
+                    : { uri: originalUri, doc: cursor.value });
                 if (limit !== undefined && out.length >= limit) {
                     resolve(out);
                     return;
@@ -219,42 +356,90 @@ export class IndexedDBStore {
             request.onerror = () => reject(request.error ?? new Error("Cursor failed"));
         });
     }
-    async _ls(parsed) {
+    async _ls(meta, parsed) {
         validateReadParams(parsed.params, STORE_NAME);
         const format = parsed.params.format ?? "full";
-        const onlyUris = format === "uris";
+        const onlyKeys = format === "uris";
         try {
-            const entries = await this._walkLeaves(parsed, onlyUris);
-            if (onlyUris)
+            const entries = await this._walkLeaves(meta, parsed, onlyKeys, true);
+            if (onlyKeys)
                 return entries.map((e) => e.uri);
-            return entries.map((e) => [e.uri, e.payload]);
+            return entries.map((e) => {
+                if (!e.doc)
+                    return [e.uri, undefined];
+                if (meta.isBytes) {
+                    return [e.uri, { payload: e.doc.payload }];
+                }
+                return [e.uri, e.doc.record];
+            });
         }
         catch {
             return [];
         }
     }
-    async _count(parsed) {
+    /**
+     * v2 §3.5: recursive walk under the prefix. Same cursor as `_ls` with
+     * `shallow=false` so the `tail.includes("/")` cutoff is dropped —
+     * every descendant flows through, any depth. By the time dispatch
+     * calls us (with `pushDownFind: false`), it has stripped
+     * pattern/cursor/limit/page from `parsed.params`; sortBy is forced to
+     * `"uri"`; format may be either `"full"` or `"uris"`. The handler
+     * returns the raw deep walk in that format; dispatch handles glob
+     * post-filter, sort, cursor, limit, and the cursor-as-trailing-slot.
+     */
+    async _find(meta, parsed) {
+        validateReadParams(parsed.params, STORE_NAME);
+        const format = parsed.params.format ?? "full";
+        const onlyKeys = format === "uris";
+        try {
+            const entries = await this._walkLeaves(meta, parsed, onlyKeys, false);
+            if (onlyKeys)
+                return entries.map((e) => e.uri);
+            return entries.map((e) => {
+                if (!e.doc)
+                    return [e.uri, undefined];
+                if (meta.isBytes) {
+                    return [e.uri, { payload: e.doc.payload }];
+                }
+                return [e.uri, e.doc.record];
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+    async _count(meta, parsed) {
         if (parsed.params.pattern !== undefined) {
             throw new Error(`${STORE_NAME}: pattern filter not supported`);
         }
         try {
-            const entries = await this._walkLeaves(parsed, true);
+            const entries = await this._walkLeaves(meta, parsed, true, true);
             return entries.length;
         }
         catch {
             return 0;
         }
     }
-    async _deleteBytes(uris) {
+    // ── Delete ───────────────────────────────────────────────────────
+    async delete(meta, uris) {
+        if (uris.length === 0)
+            return [];
+        if ((await this._readMetaSignature(meta.support.entity)) !== meta.signature) {
+            return uris.map((uri) => ({
+                success: false,
+                ...storageFailure(new Error(`${STORE_NAME}: entity '${meta.support.entity}' is not provisioned`), "Entity not provisioned", uri),
+            }));
+        }
         const results = [];
         try {
             const store = await this.getStore("readwrite");
             for (const uri of uris) {
                 try {
+                    const storageKey = meta.isBytes ? uri : `${meta.storageRoot}${uri}`;
                     await new Promise((resolve, reject) => {
-                        const request = store.delete(uri);
-                        request.onsuccess = () => resolve();
-                        request.onerror = () => reject(new Error(`Failed to delete ${uri}: ${request.error}`));
+                        const req = store.delete(storageKey);
+                        req.onsuccess = () => resolve();
+                        req.onerror = () => reject(new Error(`Failed to delete ${uri}: ${req.error}`));
                     });
                     results.push({ success: true });
                 }
@@ -267,33 +452,104 @@ export class IndexedDBStore {
             }
         }
         catch (err) {
-            // Outer failure — every uri fails with the same root cause.
             const failure = storageFailure(err, "Delete failed");
-            for (const _ of uris) {
+            for (const _ of uris)
                 results.push({ success: false, ...failure });
-            }
         }
         return results;
     }
-    // ── Status ───────────────────────────────────────────────────────
+    // ── Status / capabilities ────────────────────────────────────────
     async status() {
         try {
             await this.initDB();
+            const schema = await this._listProvisionedEntities();
             return {
                 status: "healthy",
-                schema: [],
-                fns: ["read", "ls", "count"],
+                schema: schema.map((s) => `entity:${s}`),
+                fns: ["read", "ls", "count", "find"],
             };
         }
         catch {
             return {
                 status: "unhealthy",
                 schema: [],
-                fns: ["read", "ls", "count"],
+                fns: ["read", "ls", "count", "find"],
             };
         }
     }
     capabilities() {
         return { atomicBatch: false };
     }
+    // ── Internals ────────────────────────────────────────────────────
+    /**
+     * Read the persisted signature for an entity's meta record. Returns
+     * `null` if no provisioning record exists. The meta record lives at
+     * `__meta__/{name}` in the same object store as data records, so a
+     * single object-store cursor sees both layouts without needing a
+     * separate IDB store.
+     */
+    async _readMetaSignature(entityName) {
+        try {
+            const store = await this.getStore();
+            return await new Promise((resolve) => {
+                const req = store.get(`${META_PREFIX}${entityName}`);
+                req.onsuccess = () => {
+                    const doc = req.result;
+                    resolve(doc ? doc.signature : null);
+                };
+                req.onerror = () => resolve(null);
+            });
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Scan the meta keyspace for every provisioned entity name. Used by
+     * `status()` to advertise the entities a peer can talk to.
+     */
+    async _listProvisionedEntities() {
+        if (!this.keyRange)
+            return [];
+        const range = this.keyRange.bound(META_PREFIX, `${META_PREFIX}￿`);
+        const store = await this.getStore();
+        const index = store.index("uri_index");
+        return await new Promise((resolve, reject) => {
+            const out = [];
+            const req = index.openKeyCursor(range, "next");
+            req.onsuccess = () => {
+                const cursor = req.result;
+                if (!cursor)
+                    return resolve(out);
+                const key = cursor.key;
+                if (!key.startsWith(META_PREFIX))
+                    return resolve(out);
+                out.push(key.slice(META_PREFIX.length));
+                cursor.continue();
+            };
+            req.onerror = () => reject(req.error ?? new Error("Meta cursor failed"));
+        });
+    }
+    /**
+     * Collect any `ReadableStream` values on `bytes`-tagged fields into
+     * `Uint8Array` and return a shallow-copied record. Non-stream values
+     * pass through; matches the normalisation pattern used by Memory,
+     * Postgres, and LocalStorage.
+     */
+    async _normaliseBytesFields(record, bytesFields) {
+        const out = { ...record };
+        for (const name of bytesFields) {
+            const v = out[name];
+            if (v === undefined || v === null)
+                continue;
+            if (v instanceof Uint8Array)
+                continue;
+            if (v instanceof ReadableStream) {
+                out[name] = await toBytes(v);
+                continue;
+            }
+            throw new Error(`field '${name}' must be Uint8Array or ReadableStream, got ${typeof v}`);
+        }
+        return out;
+    }
 }

package/esm/ipfs/mod.d.ts

@@ -9,6 +9,25 @@
  * and streaming callers; `cat` returns a `ReadableStream<Uint8Array>`
  * to avoid materializing the block in memory unless the caller wants
  * it.
+ *
+ * ## Durability warning — session-scoped index
+ *
+ * IPFS blocks are pinned and durable, but the URI → CID index and
+ * provisioning bookkeeping live only in process memory (a `Map`
+ * inside the `IpfsStore` instance). After a process restart:
+ *
+ * - Previously-written blocks are unreachable: the store cannot map
+ *   any URI back to its CID.
+ * - `entityStatus(meta)` returns `"unprovisioned"` for every entity
+ *   until `provisionEntity` is called again.
+ * - `read` returns misses for all URIs that were valid before the
+ *   restart.
+ *
+ * `IpfsStore` is effectively session-scoped as an `EntityStore`.
+ * Persisting the index (e.g. writing a bucket-root IPFS block on
+ * each write and handing the root CID to the caller for rehydration)
+ * is deferred — callers that need durable addressing across restarts
+ * should track CIDs externally or use a different backend.
  */
 import type { StorePayload } from "../types.js";
 export interface IpfsExecutor {

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

@@ -1 +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"}
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/ipfs/mod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;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"}