@opendatalabs/personal-server-ts-lite 0.0.1-canary.00328bf

package/dist/storage.js

@@ -0,0 +1,718 @@
+import { buildDataBlocksAsync } from "@opendatalabs/personal-server-ts-core/storage/blocks";
+import { DataBlockStorageError, encodeDataBlockCursor, selectScopeBlocksByIds, validateDataBlockCursor, } from "@opendatalabs/personal-server-ts-core/storage/blocks";
+import { createStorageReadMethods, sortEntries } from "./storage-utils.js";
+import { previewEnvelopeValue, previewJsonEnvelopePrefix, } from "@opendatalabs/personal-server-ts-core/storage/preview";
+const DEFAULT_INDEXED_DB_NAME = "personal-server-lite-storage";
+const DEFAULT_INDEXED_DB_STORE = "state";
+const DEFAULT_INDEXED_DB_KEY = "data-storage-v1";
+const TEXT_PAGE_MEDIA_TYPE = "text/plain; charset=utf-8";
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+function schemaIdFromEnvelope(envelope) {
+    const schemaId = envelope.schemaId;
+    return typeof schemaId === "string" ? schemaId : undefined;
+}
+function initialState() {
+    return {
+        version: 1,
+        nextId: 1,
+        entries: [],
+        envelopes: [],
+    };
+}
+function envelopePath(scope, collectedAt) {
+    return `data/${scope}/${collectedAt}.json`;
+}
+function blockTreePath(scope, collectedAt) {
+    return `blocks/${scope}/${collectedAt}`;
+}
+function blockManifestPath(scope, collectedAt) {
+    return `${blockTreePath(scope, collectedAt)}/manifest.json`;
+}
+function blockPayloadPath(scope, collectedAt, blockId) {
+    return `${blockTreePath(scope, collectedAt)}/${encodeURIComponent(blockId)}.json`;
+}
+function normalizeState(state) {
+    if (!state || state.version !== 1) {
+        return initialState();
+    }
+    return {
+        version: 1,
+        nextId: Math.max(state.nextId, 1),
+        entries: state.entries.map((entry) => ({
+            ...entry,
+            schemaId: entry.schemaId ?? null,
+        })),
+        envelopes: state.envelopes,
+        blockManifests: state.blockManifests ?? [],
+        blockPayloads: state.blockPayloads ?? [],
+    };
+}
+export function createIndexedDbFallbackDataFileStore(envelopes, blockManifests = new Map(), blockPayloads = new Map()) {
+    return {
+        kind: "indexeddb",
+        async readEnvelope(path) {
+            return envelopes.get(path) ?? null;
+        },
+        async readEnvelopePreview(path, { maxBytes }) {
+            const envelope = envelopes.get(path);
+            if (!envelope)
+                return null;
+            return previewEnvelopeValue(envelope, maxBytes);
+        },
+        async writeEnvelope(path, envelope) {
+            envelopes.set(path, envelope);
+            return new TextEncoder().encode(JSON.stringify(envelope)).length;
+        },
+        async deleteEnvelope(path) {
+            envelopes.delete(path);
+        },
+        async readBlockManifest(path) {
+            return blockManifests.get(path) ?? null;
+        },
+        async writeBlockManifest(path, manifest) {
+            blockManifests.set(path, manifest);
+        },
+        async readBlockPayload(path) {
+            return blockPayloads.get(path) ?? null;
+        },
+        async writeBlockPayload(path, block) {
+            blockPayloads.set(path, block);
+        },
+        async deleteBlockTree(pathPrefix) {
+            deleteMapPrefix(blockManifests, pathPrefix);
+            deleteMapPrefix(blockPayloads, pathPrefix);
+        },
+    };
+}
+function deleteMapPrefix(map, pathPrefix) {
+    const prefix = pathPrefix.endsWith("/") ? pathPrefix : `${pathPrefix}/`;
+    for (const path of map.keys()) {
+        if (path === pathPrefix || path.startsWith(prefix)) {
+            map.delete(path);
+        }
+    }
+}
+function describeStorageError(error) {
+    if (error instanceof Error) {
+        return { errorClass: error.name, message: error.message };
+    }
+    return { errorClass: typeof error, message: String(error) };
+}
+async function getOrCreateOpfsDirectory(root, parts) {
+    let dir = root;
+    for (const part of parts) {
+        dir = await dir.getDirectoryHandle(part, { create: true });
+    }
+    return dir;
+}
+async function getOpfsFileHandle(root, path, options) {
+    const parts = path.split("/").filter(Boolean);
+    const fileName = parts.pop();
+    if (!fileName) {
+        throw new Error("OPFS path must include a file name");
+    }
+    const dir = await getOrCreateOpfsDirectory(root, parts);
+    return dir.getFileHandle(fileName, options);
+}
+export async function isOpfsAvailable() {
+    return (typeof navigator !== "undefined" &&
+        typeof navigator.storage?.getDirectory === "function");
+}
+export async function createOpfsPsLiteDataFileStore() {
+    if (!(await isOpfsAvailable())) {
+        throw new Error("OPFS is not available in this runtime");
+    }
+    const root = await navigator.storage.getDirectory();
+    return {
+        kind: "opfs",
+        async readEnvelope(path) {
+            try {
+                const handle = await getOpfsFileHandle(root, path);
+                const file = await handle.getFile();
+                return JSON.parse(await file.text());
+            }
+            catch (err) {
+                if (err instanceof DOMException && err.name === "NotFoundError") {
+                    return null;
+                }
+                throw err;
+            }
+        },
+        async readEnvelopePreview(path, { maxBytes }) {
+            try {
+                const handle = await getOpfsFileHandle(root, path);
+                const file = await handle.getFile();
+                return previewJsonEnvelopePrefix(await file.slice(0, maxBytes).text(), maxBytes, {
+                    sourceTruncated: file.size > maxBytes,
+                });
+            }
+            catch (err) {
+                if (err instanceof DOMException && err.name === "NotFoundError") {
+                    return null;
+                }
+                throw err;
+            }
+        },
+        async writeEnvelope(path, envelope) {
+            const encoded = JSON.stringify(envelope);
+            const handle = await getOpfsFileHandle(root, path, { create: true });
+            const writable = await handle.createWritable();
+            await writable.write(encoded);
+            await writable.close();
+            return new TextEncoder().encode(encoded).length;
+        },
+        async deleteEnvelope(path) {
+            const parts = path.split("/").filter(Boolean);
+            const fileName = parts.pop();
+            if (!fileName)
+                return;
+            try {
+                const dir = await getOrCreateOpfsDirectory(root, parts);
+                await dir.removeEntry(fileName);
+            }
+            catch (err) {
+                if (err instanceof DOMException && err.name === "NotFoundError") {
+                    return;
+                }
+                throw err;
+            }
+        },
+        async readBlockManifest(path) {
+            return readJsonOpfsFile(root, path);
+        },
+        async writeBlockManifest(path, manifest) {
+            await writeJsonOpfsFile(root, path, manifest);
+        },
+        async readBlockPayload(path) {
+            return readJsonOpfsFile(root, path);
+        },
+        async writeBlockPayload(path, block) {
+            await writeJsonOpfsFile(root, path, block);
+        },
+        async deleteBlockTree(pathPrefix) {
+            await removeOpfsDirectoryTree(root, pathPrefix);
+        },
+    };
+}
+async function readJsonOpfsFile(root, path) {
+    try {
+        const handle = await getOpfsFileHandle(root, path);
+        const file = await handle.getFile();
+        return JSON.parse(await file.text());
+    }
+    catch (err) {
+        if (err instanceof DOMException && err.name === "NotFoundError") {
+            return null;
+        }
+        throw err;
+    }
+}
+async function writeJsonOpfsFile(root, path, value) {
+    const handle = await getOpfsFileHandle(root, path, { create: true });
+    const writable = await handle.createWritable();
+    try {
+        await writable.write(JSON.stringify(value));
+    }
+    finally {
+        await writable.close();
+    }
+}
+async function removeOpfsDirectoryTree(root, pathPrefix) {
+    const parts = pathPrefix.split("/").filter(Boolean);
+    const directoryName = parts.pop();
+    if (!directoryName)
+        return;
+    try {
+        const parent = await getOrCreateOpfsDirectory(root, parts);
+        await parent.removeEntry(directoryName, { recursive: true });
+    }
+    catch (err) {
+        if (err instanceof DOMException && err.name === "NotFoundError") {
+            return;
+        }
+        throw err;
+    }
+}
+function openIndexedDb(dbName, storeName) {
+    if (typeof indexedDB === "undefined") {
+        throw new Error("IndexedDB is not available in this runtime");
+    }
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open(dbName, 1);
+        request.onupgradeneeded = () => {
+            const db = request.result;
+            if (!db.objectStoreNames.contains(storeName)) {
+                db.createObjectStore(storeName);
+            }
+        };
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+    });
+}
+function runIndexedDbTransaction(options, mode, callback) {
+    return openIndexedDb(options.dbName, options.storeName).then((db) => new Promise((resolve, reject) => {
+        const transaction = db.transaction(options.storeName, mode);
+        const store = transaction.objectStore(options.storeName);
+        const request = callback(store);
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+        transaction.oncomplete = () => db.close();
+        transaction.onerror = () => {
+            db.close();
+            reject(transaction.error);
+        };
+    }));
+}
+export function createIndexedDbPsLitePersistence(options = {}) {
+    const resolved = {
+        dbName: options.dbName ?? DEFAULT_INDEXED_DB_NAME,
+        storeName: options.storeName ?? DEFAULT_INDEXED_DB_STORE,
+        key: options.key ?? DEFAULT_INDEXED_DB_KEY,
+    };
+    return {
+        async read() {
+            const state = await runIndexedDbTransaction(resolved, "readonly", (store) => store.get(resolved.key));
+            return state ?? null;
+        },
+        async write(state) {
+            await runIndexedDbTransaction(resolved, "readwrite", (store) => store.put(state, resolved.key));
+        },
+    };
+}
+export async function createPersistentPsLiteStorage(adapter, persistence = createIndexedDbPsLitePersistence(), dataFileStore) {
+    let state = normalizeState(await persistence.read());
+    const fallbackEnvelopes = new Map(state.envelopes.map((envelope) => [
+        envelopePath(envelope.scope, envelope.collectedAt),
+        envelope,
+    ]));
+    const fallbackBlockManifests = new Map((state.blockManifests ?? []).map(({ path, manifest }) => [path, manifest]));
+    const fallbackBlockPayloads = new Map((state.blockPayloads ?? []).map(({ path, block }) => [path, block]));
+    const fallbackStore = createIndexedDbFallbackDataFileStore(fallbackEnvelopes, fallbackBlockManifests, fallbackBlockPayloads);
+    const fileStore = dataFileStore ??
+        (adapter.kind !== "custom" && (await isOpfsAvailable())
+            ? await createOpfsPsLiteDataFileStore()
+            : fallbackStore);
+    const capabilities = {
+        metadata: adapter.kind === "custom" ? "custom" : "indexeddb",
+        files: fileStore.kind,
+        opfsAvailable: await isOpfsAvailable(),
+    };
+    let persistQueue = Promise.resolve();
+    async function persist() {
+        const snapshot = {
+            ...state,
+            envelopes: fileStore.kind === "indexeddb"
+                ? Array.from(fallbackEnvelopes.values())
+                : [],
+            blockManifests: Array.from(fallbackBlockManifests.entries()).map(([path, manifest]) => ({ path, manifest })),
+            blockPayloads: Array.from(fallbackBlockPayloads.entries()).map(([path, block]) => ({ path, block })),
+        };
+        const write = persistQueue.then(() => persistence.write(snapshot));
+        persistQueue = write.catch(() => undefined);
+        await write;
+    }
+    function entriesForScope(scope) {
+        return sortEntries(state.entries.filter((entry) => entry.scope === scope));
+    }
+    const storagePort = {
+        kind: adapter.kind === "custom" ? "custom" : "browser-indexeddb-opfs",
+        capabilities,
+        ...createStorageReadMethods(() => state.entries, entriesForScope),
+        findByFileId(fileId) {
+            return state.entries.find((entry) => entry.fileId === fileId);
+        },
+        findByDataPointId(dataPointId) {
+            return state.entries.find((entry) => entry.dataPointId === dataPointId);
+        },
+        findUnsynced(options) {
+            const entries = state.entries
+                .filter((entry) => entry.dataPointId === null)
+                .sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+            return options?.limit === undefined
+                ? entries
+                : entries.slice(0, options.limit);
+        },
+        async readEnvelope(scope, collectedAt) {
+            const path = envelopePath(scope, collectedAt);
+            const envelope = (await fileStore.readEnvelope(path)) ??
+                (await fallbackStore.readEnvelope(path));
+            if (!envelope) {
+                throw new Error("Envelope not found");
+            }
+            return envelope;
+        },
+        async writeEnvelope(envelope) {
+            const path = envelopePath(envelope.scope, envelope.collectedAt);
+            const sizeBytes = await fileStore.writeEnvelope(path, envelope);
+            if (fileStore.kind !== "indexeddb") {
+                await fallbackStore.deleteEnvelope(path);
+            }
+            await persist();
+            return {
+                path,
+                relativePath: path,
+                sizeBytes,
+            };
+        },
+        async readScopeBlocks(scope, collectedAt, options) {
+            const manifestPath = blockManifestPath(scope, collectedAt);
+            let manifest = (await fileStore.readBlockManifest?.(manifestPath)) ??
+                (fileStore === fallbackStore
+                    ? null
+                    : await fallbackStore.readBlockManifest?.(manifestPath)) ??
+                null;
+            let inMemoryBlocks = null;
+            if (!manifest) {
+                const envelope = await storagePort.readEnvelope(scope, collectedAt);
+                const built = await buildDataBlocksAsync({
+                    scope,
+                    collectedAt,
+                    schemaId: schemaIdFromEnvelope(envelope),
+                    content: envelope,
+                });
+                manifest = built.manifest;
+                inMemoryBlocks = built.blocks;
+                try {
+                    await storagePort.writeBlockManifest?.(scope, collectedAt, built.manifest, built.blocks);
+                }
+                catch (error) {
+                    console.warn({
+                        scope,
+                        collectedAt,
+                        ...describeStorageError(error),
+                    }, "Block sidecar cache write failed; serving read from local envelope");
+                }
+            }
+            if (options.blockIds?.length) {
+                const selection = await selectScopeBlocksByIds(manifest, options.blockIds, { maxBytes: options.maxBytes }, async (blockId) => inMemoryBlocks?.find((candidate) => candidate.id === blockId) ??
+                    (await readBlockPayloadFromStores(fileStore, fallbackStore, blockPayloadPath(scope, collectedAt, blockId))));
+                return {
+                    scope: manifest.scope,
+                    collectedAt: manifest.collectedAt,
+                    ...(manifest.schemaId ? { schemaId: manifest.schemaId } : {}),
+                    contentKind: manifest.contentKind,
+                    blocks: selection.blocks,
+                    warnings: [...manifest.warnings, ...selection.warnings],
+                };
+            }
+            const cursorResult = options.cursor
+                ? validateDataBlockCursor(options.cursor, { scope, collectedAt })
+                : { ok: true, cursor: null };
+            if (!cursorResult.ok) {
+                throw new DataBlockStorageError("cursor_invalid", cursorResult.error.message);
+            }
+            const maxBytes = Math.max(1, options.maxBytes);
+            const startIndex = cursorResult.cursor?.blockIndex ?? 0;
+            const startOffset = cursorResult.cursor?.intraBlockOffset ?? 0;
+            const blocks = [];
+            let bytes = 0;
+            let nextIndex = startIndex;
+            let nextOffset;
+            while (nextIndex < manifest.blocks.length) {
+                const ref = manifest.blocks[nextIndex];
+                if (!ref) {
+                    nextIndex += 1;
+                    continue;
+                }
+                const offset = nextIndex === startIndex ? startOffset : 0;
+                if (offset >= ref.sizeBytes) {
+                    nextIndex += 1;
+                    continue;
+                }
+                if (blocks.length > 0 &&
+                    offset === 0 &&
+                    bytes + ref.sizeBytes > maxBytes) {
+                    break;
+                }
+                const block = inMemoryBlocks?.find((candidate) => candidate.id === ref.id) ??
+                    (await readBlockPayloadFromStores(fileStore, fallbackStore, blockPayloadPath(scope, collectedAt, ref.id)));
+                if (!block) {
+                    const envelope = await storagePort.readEnvelope(scope, collectedAt);
+                    const rebuilt = await buildDataBlocksAsync({
+                        scope,
+                        collectedAt,
+                        schemaId: schemaIdFromEnvelope(envelope),
+                        content: envelope,
+                    });
+                    manifest = rebuilt.manifest;
+                    inMemoryBlocks = rebuilt.blocks;
+                    nextIndex = startIndex;
+                    nextOffset = undefined;
+                    bytes = 0;
+                    blocks.length = 0;
+                    continue;
+                }
+                const page = pageBlock(block, offset, maxBytes - bytes);
+                blocks.push(page.block);
+                bytes += page.block.sizeBytes;
+                if (page.nextOffset !== undefined) {
+                    nextOffset = page.nextOffset;
+                    break;
+                }
+                nextIndex += 1;
+            }
+            return {
+                scope: manifest.scope,
+                collectedAt: manifest.collectedAt,
+                ...(manifest.schemaId ? { schemaId: manifest.schemaId } : {}),
+                contentKind: manifest.contentKind,
+                blocks,
+                ...(nextOffset !== undefined || nextIndex < manifest.blocks.length
+                    ? {
+                        nextCursor: encodeDataBlockCursor({
+                            scope,
+                            collectedAt,
+                            blockIndex: nextIndex,
+                            ...(nextOffset === undefined
+                                ? {}
+                                : { intraBlockOffset: nextOffset }),
+                        }),
+                    }
+                    : {}),
+                warnings: manifest.warnings,
+            };
+        },
+        async readBlockManifest(scope, collectedAt) {
+            const manifestPath = blockManifestPath(scope, collectedAt);
+            return ((await fileStore.readBlockManifest?.(manifestPath)) ??
+                (fileStore === fallbackStore
+                    ? null
+                    : await fallbackStore.readBlockManifest?.(manifestPath)) ??
+                null);
+        },
+        async hasScopeBlocks(scope, collectedAt) {
+            return Boolean(await storagePort.readBlockManifest?.(scope, collectedAt));
+        },
+        async canReadScopeBlocks(scope, collectedAt) {
+            if (await storagePort.hasScopeBlocks?.(scope, collectedAt)) {
+                return true;
+            }
+            const path = envelopePath(scope, collectedAt);
+            const preview = (await readPreviewFromFileStore(fileStore, path, 1)) ??
+                (fileStore === fallbackStore
+                    ? null
+                    : await readPreviewFromFileStore(fallbackStore, path, 1));
+            if (preview)
+                return true;
+            const envelope = (await fileStore.readEnvelope(path)) ??
+                (fileStore === fallbackStore
+                    ? null
+                    : await fallbackStore.readEnvelope(path));
+            return Boolean(envelope);
+        },
+        async writeBlockManifest(scope, collectedAt, manifest, blocks) {
+            const writeTree = async (store) => {
+                if (!store.writeBlockManifest || !store.writeBlockPayload) {
+                    throw new Error("Block sidecar storage is not available");
+                }
+                await store.deleteBlockTree?.(blockTreePath(scope, collectedAt));
+                for (const block of blocks) {
+                    await store.writeBlockPayload(blockPayloadPath(scope, collectedAt, block.id), block);
+                }
+                await store.writeBlockManifest(blockManifestPath(scope, collectedAt), manifest);
+            };
+            let wrotePrimary = false;
+            try {
+                await writeTree(fileStore);
+                wrotePrimary = true;
+            }
+            catch (error) {
+                if (fileStore === fallbackStore) {
+                    throw error;
+                }
+                console.warn({
+                    scope,
+                    collectedAt,
+                    fileStoreKind: fileStore.kind,
+                    fallbackStoreKind: fallbackStore.kind,
+                    ...describeStorageError(error),
+                }, "Primary block sidecar write failed; using IndexedDB fallback");
+                await writeTree(fallbackStore);
+            }
+            if (wrotePrimary && fileStore.kind !== "indexeddb") {
+                await fallbackStore.deleteBlockTree?.(blockTreePath(scope, collectedAt));
+            }
+            await persist();
+        },
+        async insertEntry(entry) {
+            const version = entry.version ??
+                state.entries.reduce((max, e) => e.scope === entry.scope && e.version > max ? e.version : max, 0) + 1;
+            const indexed = {
+                ...entry,
+                schemaId: entry.schemaId ?? null,
+                version,
+                dataPointId: entry.dataPointId ?? null,
+                afterTombstoneVersion: entry.afterTombstoneVersion ?? null,
+                id: state.nextId,
+                createdAt: new Date().toISOString(),
+            };
+            state = {
+                ...state,
+                nextId: state.nextId + 1,
+                entries: [
+                    ...state.entries.filter((item) => item.path !== entry.path),
+                    indexed,
+                ],
+            };
+            await persist();
+            return indexed;
+        },
+        async updateFileId(path, fileId) {
+            let updated = false;
+            state = {
+                ...state,
+                entries: state.entries.map((entry) => {
+                    if (entry.path !== path)
+                        return entry;
+                    updated = true;
+                    return { ...entry, fileId };
+                }),
+            };
+            if (updated) {
+                await persist();
+            }
+            return updated;
+        },
+        findLatestVersionByScope(scope) {
+            return state.entries.reduce((max, e) => (e.scope === scope && e.version > max ? e.version : max), 0);
+        },
+        async updateDataPointId(path, dataPointId) {
+            let updated = false;
+            state = {
+                ...state,
+                entries: state.entries.map((entry) => {
+                    if (entry.path !== path)
+                        return entry;
+                    updated = true;
+                    return { ...entry, dataPointId };
+                }),
+            };
+            if (updated) {
+                await persist();
+            }
+            return updated;
+        },
+        async updateEntryVersion(path, version) {
+            let updated = false;
+            state = {
+                ...state,
+                entries: state.entries.map((entry) => {
+                    if (entry.path !== path)
+                        return entry;
+                    updated = true;
+                    return { ...entry, version };
+                }),
+            };
+            if (updated) {
+                await persist();
+            }
+            return updated;
+        },
+        async deleteScope(scope) {
+            let deleted = 0;
+            const deletedPaths = [];
+            const deletedBlockTrees = [];
+            state = {
+                ...state,
+                entries: state.entries.filter((entry) => {
+                    if (entry.scope !== scope)
+                        return true;
+                    deleted += 1;
+                    deletedPaths.push(envelopePath(entry.scope, entry.collectedAt));
+                    deletedBlockTrees.push(blockTreePath(entry.scope, entry.collectedAt));
+                    return false;
+                }),
+            };
+            await Promise.all([
+                ...deletedPaths.flatMap((path) => [
+                    fileStore.deleteEnvelope(path),
+                    fallbackStore.deleteEnvelope(path),
+                ]),
+                ...deletedBlockTrees.flatMap((path) => [
+                    fileStore.deleteBlockTree?.(path),
+                    fallbackStore.deleteBlockTree?.(path),
+                ]),
+            ].filter((promise) => promise !== undefined));
+            await persist();
+            return deleted;
+        },
+        async deleteVersion(scope, collectedAt) {
+            const entry = state.entries.find((e) => e.scope === scope && e.collectedAt === collectedAt);
+            if (!entry)
+                return false;
+            return removeEntry(entry);
+        },
+        async deleteByFileId(fileId) {
+            const entry = state.entries.find((e) => e.fileId === fileId);
+            if (!entry)
+                return false;
+            return removeEntry(entry);
+        },
+    };
+    async function removeEntry(entry) {
+        const blobPath = envelopePath(entry.scope, entry.collectedAt);
+        // Delete the blob FIRST (both stores tolerate a missing blob); only drop the index row once
+        // the blob is gone. If blob deletion throws for a real reason, the row is preserved so the
+        // next sync retry re-attempts instead of orphaning the local blob.
+        await Promise.all([
+            fileStore.deleteEnvelope(blobPath),
+            fallbackStore.deleteEnvelope(blobPath),
+            fileStore.deleteBlockTree?.(blockTreePath(entry.scope, entry.collectedAt)) ?? Promise.resolve(),
+            fallbackStore.deleteBlockTree?.(blockTreePath(entry.scope, entry.collectedAt)) ?? Promise.resolve(),
+        ]);
+        state = {
+            ...state,
+            entries: state.entries.filter((e) => e !== entry),
+        };
+        await persist();
+        return true;
+    }
+    if (fileStore.readEnvelopePreview) {
+        storagePort.readEnvelopePreview = async (scope, collectedAt, { maxBytes }) => {
+            const path = envelopePath(scope, collectedAt);
+            const primaryPreview = await readPreviewFromFileStore(fileStore, path, maxBytes);
+            const preview = primaryPreview ??
+                (fileStore === fallbackStore
+                    ? null
+                    : await readPreviewFromFileStore(fallbackStore, path, maxBytes));
+            if (!preview) {
+                throw new Error("Envelope not found");
+            }
+            return preview;
+        };
+    }
+    return storagePort;
+}
+async function readPreviewFromFileStore(store, path, maxBytes) {
+    return (await store.readEnvelopePreview?.(path, { maxBytes })) ?? null;
+}
+function pageBlock(block, offsetBytes, maxBytes) {
+    const text = typeof block.value === "string" ? block.value : JSON.stringify(block.value);
+    const bytes = textEncoder.encode(text);
+    if (offsetBytes <= 0 && bytes.length <= maxBytes) {
+        return { block };
+    }
+    const start = Math.min(Math.max(0, offsetBytes), bytes.length);
+    const end = Math.min(bytes.length, start + Math.max(1, maxBytes));
+    const value = textDecoder.decode(bytes.slice(start, end));
+    return {
+        block: {
+            ...block,
+            path: `${block.path}[bytes ${start}:${end}]`,
+            mediaType: block.mediaType.startsWith("text/")
+                ? block.mediaType
+                : TEXT_PAGE_MEDIA_TYPE,
+            value,
+            sizeBytes: end - start,
+            truncated: end < bytes.length,
+        },
+        ...(end < bytes.length ? { nextOffset: end } : {}),
+    };
+}
+async function readBlockPayloadFromStores(primary, fallback, path) {
+    return ((await primary.readBlockPayload?.(path)) ??
+        (primary === fallback ? null : await fallback.readBlockPayload?.(path)) ??
+        null);
+}
+//# sourceMappingURL=storage.js.map