@seedprotocol/sdk 0.6.10 → 0.7.0

package/dist/index.browser-CNrqhvEA.js

@@ -0,0 +1,4139 @@
+import { t as BasePathResolver, B as BaseDb, c as appState, a as BaseFileManager } from './BasePathResolver-ndE8XTpw.js';
+import { eq, sql } from 'drizzle-orm';
+import { o as withDbTabLock, q as notifyFilesWrittenOutsideCache, u as withSeedDbLock } from './tabEvents-DYI2GU7i.js';
+import debug from 'debug';
+import { F as FileSystemLockedError } from './errors-CrBxGWah.js';
+import { drizzle } from 'drizzle-orm/sqlite-proxy';
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex, utf8ToBytes } from '@noble/hashes/utils';
+import { s as schema } from './index-B0LgJblD.js';
+import { SQLocalDrizzle } from 'sqlocal/drizzle';
+import { Observable, distinctUntilChanged } from 'rxjs';
+import { BaseArweaveClient, getPreferredArweaveReadBaseUrls, fetchArweaveRawFromBaseUrl, GET_TRANSACTION_TAGS } from '@seedprotocol/arweave';
+import { GraphQLClient } from 'graphql-request';
+import Arweave from 'arweave';
+import { getEasEndpoint, BaseEasClient, BaseQueryClient } from '@seedprotocol/eas';
+import { QueryClient } from '@tanstack/react-query';
+
+class BrowserPathResolver {
+    /** @deprecated Prefer BasePathResolver static methods or configure(). */
+    static getInstance() {
+        return BasePathResolver.getInstance();
+    }
+    /**
+     * Gets the root directory containing node_modules
+     * Note: In browser, this returns a virtual path based on OPFS
+     */
+    getRootWithNodeModules() {
+        // In browser, we use OPFS which doesn't have traditional paths
+        // Return a virtual root path
+        return '/';
+    }
+    /**
+     * Gets the SDK root directory
+     * Note: In browser, this returns a virtual path
+     */
+    getSdkRootDir() {
+        // In browser, SDK is bundled, so we return a virtual path
+        return '/sdk';
+    }
+    getNodeModulesDir() {
+        // In browser, node_modules don't exist in the traditional sense
+        return '/node_modules';
+    }
+    /**
+     * Gets the .seed directory path
+     * Note: In browser, this returns the OPFS path where .seed data is stored
+     */
+    getDotSeedDir(schemaFileDir) {
+        // In browser, .seed directory is stored in OPFS
+        // The actual path is handled by the FileManager
+        return '/.seed';
+    }
+    /**
+     * Finds the Seed Protocol config file
+     * Note: In browser, config files are not accessible via filesystem
+     */
+    findConfigFile(searchDir) {
+        // In browser, config files are typically embedded in the bundle
+        // or loaded via fetch/import
+        return null;
+    }
+    /**
+     * Gets paths for app-specific directories
+     * Note: In browser, these are virtual paths for OPFS
+     */
+    getAppPaths(schemaFileDir) {
+        const dotSeedDir = this.getDotSeedDir(schemaFileDir);
+        return {
+            sdkRootDir: this.getSdkRootDir(),
+            dotSeedDir,
+            nodeModulesDir: this.getNodeModulesDir(),
+            appSchemaDir: `${dotSeedDir}/schema`,
+            appDbDir: `${dotSeedDir}/db`,
+            appMetaDir: `${dotSeedDir}/db/meta`,
+        };
+    }
+}
+BasePathResolver.configure(new BrowserPathResolver());
+
+const KEY = 'excludedTransactions';
+/**
+ * Adds transaction ids to the `excludedTransactions` app_state list (txs no gateway could serve).
+ * Reads, merges and writes under a cross-tab lock: writing a whole list read earlier lost the ids
+ * another tab or download had added in between.
+ */
+async function addExcludedTransactions(transactionIds) {
+    const additions = [...transactionIds];
+    if (additions.length === 0)
+        return;
+    await withDbTabLock('excluded-transactions', async () => {
+        const appDb = BaseDb.getAppDb();
+        const rows = await appDb.select().from(appState).where(eq(appState.key, KEY)).limit(1);
+        const merged = new Set();
+        try {
+            for (const id of JSON.parse(rows[0]?.value ?? '[]'))
+                merged.add(id);
+        }
+        catch {
+            // Unreadable list: start over with the new ids.
+        }
+        const sizeBefore = merged.size;
+        for (const id of additions)
+            merged.add(id);
+        if (merged.size === sizeBefore && rows.length > 0)
+            return;
+        const value = JSON.stringify([...merged]);
+        await appDb
+            .insert(appState)
+            .values({ key: KEY, value })
+            .onConflictDoUpdate({ target: appState.key, set: { value } });
+    });
+}
+
+var filesDownload = `(
+  ${function () {
+    const identifyString = (str) => {
+        try {
+            JSON.parse(str);
+            return 'json';
+        }
+        catch (e) {
+            // Not JSON
+        }
+        if (!str) {
+            return;
+        }
+        if (str.trim().startsWith('<') && str.trim().endsWith('>')) {
+            return 'html';
+        }
+        // Simple markdown checks (very naive)
+        if (/^#{1,6}\s|^-{3,}|\*{3,}|^-{1,2}\s|\*\s/.test(str)) {
+            return 'markdown';
+        }
+        if (/^data:image\/[a-zA-Z]+;base64,[A-Za-z0-9+/]+={0,2}$/.test(str)) {
+            return 'base64';
+        }
+        // Default to plain text if unsure
+        return 'text';
+    };
+    const getMimeType = (base64) => {
+        if (!base64) {
+            return null;
+        }
+        const result = base64.match(/^data:([a-zA-Z0-9]+\/[a-zA-Z0-9-.+]+).*,/);
+        if (result && result.length > 1) {
+            return result[1];
+        }
+        else {
+            return null; // MIME type could not be determined
+        }
+    };
+    const getDataTypeFromString = (data) => {
+        const nonImageBase64Regex = /^(?!data:image\/(?:jpeg|png|gif|bmp|webp);base64,)[A-Za-z0-9+/=]+$/;
+        if (nonImageBase64Regex.test(data)) {
+            return 'base64';
+        }
+        // Regular expression for base64 (simple version, checking for base64 format)
+        const imageBase64Regex = /^data:image\/[a-zA-Z]+;base64,[A-Za-z0-9+/]+={0,2}$/;
+        if (imageBase64Regex.test(data)) {
+            return 'imageBase64';
+        }
+        // Regular expression for URL (simple version, checking for common URL format)
+        const urlRegex = /^(http:\/\/www\.|https:\/\/www\.|http:\/\/|https:\/\/)?[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/;
+        if (urlRegex.test(data)) {
+            return 'url';
+        }
+        return null;
+    };
+    const isBinary = (arrayBuffer) => {
+        const view = new Uint8Array(arrayBuffer);
+        let nonTextCount = 0;
+        const threshold = 0.2; // Adjust as needed (e.g., 20% non-text implies binary)
+        for (let i = 0; i < view.length; i++) {
+            const byte = view[i];
+            // ASCII printable characters (32-126) and common whitespace (9, 10, 13)
+            if ((byte >= 32 && byte <= 126) || // Printable ASCII
+                byte === 9 || byte === 10 || byte === 13 // Tab, LF, CR
+            ) {
+                continue;
+            }
+            nonTextCount++;
+            if (nonTextCount / view.length > threshold) {
+                return true; // More than threshold are non-text bytes
+            }
+        }
+        return false; // Fewer than threshold are non-text bytes
+    };
+    const saveBufferToOPFS = async (filePath, buffer) => {
+        // Access the OPFS root directory
+        const rootHandle = await navigator.storage.getDirectory();
+        // Split the filePath into directory segments and file name
+        const segments = filePath.split('/').filter(Boolean);
+        const fileName = segments.pop(); // Extract the file name
+        if (!fileName) {
+            throw new Error('Invalid file path: No file name provided.');
+        }
+        // Traverse or create directories as needed
+        let currentDirHandle = rootHandle;
+        for (const segment of segments) {
+            currentDirHandle = await currentDirHandle.getDirectoryHandle(segment, { create: true });
+        }
+        // Create or open the file in OPFS
+        const fileHandleAsync = await currentDirHandle.getFileHandle(fileName, { create: true });
+        const write = async () => {
+            const fileHandle = await fileHandleAsync.createSyncAccessHandle();
+            try {
+                // Drop any previous, longer contents before writing from the start
+                fileHandle.truncate(0);
+                fileHandle.write(buffer, { at: 0 });
+                fileHandle.flush();
+            }
+            finally {
+                // A leaked handle keeps the file locked for the worker's lifetime
+                fileHandle.close();
+            }
+        };
+        // A sync access handle is exclusive: a download of the same file in another tab or worker would
+        // make createSyncAccessHandle throw, so writers of one path take turns.
+        if (navigator.locks) {
+            await navigator.locks.request(`seed:opfs-write:${filePath}`, write);
+        }
+        else {
+            await write();
+        }
+        // Written past ZenFS: the page refreshes its cache for this path and tells other tabs.
+        globalThis.postMessage({ message: 'fileSaved', filePath });
+    };
+    const getFilesPath = (filesRoot, ...parts) => {
+        const root = filesRoot.replace(/\/$/, '');
+        return [root, ...parts].filter(Boolean).join('/').replace(/\/+/g, '/');
+    };
+    const toBaseUrl = (hostOrUrl) => {
+        const h = (hostOrUrl || '').trim().replace(/\/$/, '');
+        if (!h)
+            return '';
+        if (h.startsWith('http://') || h.startsWith('https://'))
+            return h;
+        const protocol = h.startsWith('127.0.0.1') || h.startsWith('localhost') || h.includes(':1984')
+            ? 'http'
+            : 'https';
+        return `${protocol}://${h}`;
+    };
+    /**
+     * GET /raw/{id} from each gateway in order. `networkFailedEverywhere` is true only when no gateway
+     * answered at all; a non-2xx (e.g. not yet propagated) is not a reason to exclude the transaction.
+     */
+    const fetchRaw = async (baseUrls, transactionId) => {
+        let answered = false;
+        for (const base of baseUrls) {
+            try {
+                const response = await fetch(`${base}/raw/${transactionId}`);
+                answered = true;
+                if (!response.ok)
+                    continue;
+                const arrayBuffer = await response.arrayBuffer();
+                if (arrayBuffer.byteLength > 0) {
+                    return { arrayBuffer, networkFailedEverywhere: false };
+                }
+            }
+            catch (error) {
+                /* next gateway */
+            }
+        }
+        return { networkFailedEverywhere: !answered };
+    };
+    const downloadFiles = async ({ transactionIds, arweaveHost, arweaveBaseUrls, filesRoot = '/files', }) => {
+        // Preferred / resolved gateways first, then the configured host; deduped.
+        const baseUrls = [];
+        for (const candidate of (arweaveBaseUrls || []).concat([arweaveHost])) {
+            const base = toBaseUrl(candidate);
+            if (base && baseUrls.indexOf(base) === -1) {
+                baseUrls.push(base);
+            }
+        }
+        for (const transactionId of transactionIds) {
+            const { arrayBuffer, networkFailedEverywhere } = await fetchRaw(baseUrls, transactionId);
+            if (!arrayBuffer) {
+                if (networkFailedEverywhere) {
+                    globalThis.postMessage({
+                        message: 'excludeTransaction',
+                        transactionId,
+                    });
+                }
+                continue;
+            }
+            let dataString;
+            const isBinaryData = isBinary(arrayBuffer);
+            if (!isBinaryData) {
+                const decoder = new TextDecoder('utf-8');
+                const text = decoder.decode(arrayBuffer);
+                dataString = text;
+            }
+            if (dataString && dataString.startsWith('===FILE_SEPARATOR===')) {
+                const dataStringParts = dataString
+                    .split('===FILE_SEPARATOR===')
+                    .slice(1);
+                if (dataStringParts.length % 2 !== 0) {
+                    throw new Error('Input array must have an even number of elements.');
+                }
+                for (let i = 0; i < dataStringParts.length; i += 2) {
+                    const contentType = dataStringParts[i];
+                    const content = dataStringParts[i + 1];
+                    const encoder = new TextEncoder();
+                    if (contentType === 'html') {
+                        const fileName = `${transactionId}.html`;
+                        const buffer = encoder.encode(content);
+                        await saveBufferToOPFS(getFilesPath(filesRoot, 'html', fileName), buffer);
+                    }
+                    if (contentType === 'json') {
+                        const fileName = `${transactionId}.json`;
+                        const buffer = encoder.encode(content);
+                        await saveBufferToOPFS(getFilesPath(filesRoot, 'json', fileName), buffer);
+                    }
+                }
+                continue;
+            }
+            if (!dataString && arrayBuffer) {
+                await saveBufferToOPFS(getFilesPath(filesRoot, 'images', transactionId), new Uint8Array(arrayBuffer));
+                continue;
+            }
+            if (!dataString) {
+                continue;
+            }
+            let contentType = identifyString(dataString);
+            if (contentType !== 'json' &&
+                contentType !== 'base64' &&
+                contentType !== 'html') {
+                const possibleImageType = getDataTypeFromString(dataString);
+                if (!possibleImageType) {
+                    continue;
+                }
+                contentType = possibleImageType;
+            }
+            if (contentType === 'url') {
+                const url = dataString;
+                let buffer;
+                try {
+                    const response = await fetch(url);
+                    if (!response.ok) {
+                        continue;
+                    }
+                    buffer = await response.arrayBuffer();
+                }
+                catch (error) {
+                    globalThis.postMessage({
+                        message: 'excludeTransaction',
+                        transactionId,
+                    });
+                    continue;
+                }
+                const bufferUint8Array = new Uint8Array(buffer);
+                // Extract the file extension from the URL
+                const extensionMatch = url.match(/\.(jpg|jpeg|png|gif|bmp|webp|svg)$/i);
+                if (!extensionMatch) {
+                    throw new Error('Unable to determine the file extension from the URL.');
+                }
+                extensionMatch[0]; // e.g., ".jpg"
+                // Set the file name (you can customize this)
+                // const fileNameFromUrl = `${transactionId}${fileExtension}`
+                await saveBufferToOPFS(getFilesPath(filesRoot, 'images', transactionId), bufferUint8Array);
+                continue;
+            }
+            const mimeType = getMimeType(dataString);
+            let fileExtension = mimeType;
+            if (fileExtension && fileExtension?.startsWith('image')) {
+                fileExtension = fileExtension.replace('image/', '');
+            }
+            let fileName = transactionId;
+            if (contentType === 'base64') {
+                if (fileExtension) {
+                    fileName += `.${fileExtension}`;
+                }
+                // Remove the Base64 header if it exists (e.g., "data:image/png;base64,")
+                const base64Data = dataString.split(',').pop() || '';
+                // Decode the Base64 string to binary
+                const binaryString = atob(base64Data);
+                const length = binaryString.length;
+                const binaryData = new Uint8Array(length);
+                for (let i = 0; i < length; i++) {
+                    binaryData[i] = binaryString.charCodeAt(i);
+                }
+                await saveBufferToOPFS(getFilesPath(filesRoot, 'images', fileName), binaryData);
+            }
+            if (contentType === 'html') {
+                fileName += '.html';
+                const encoder = new TextEncoder();
+                const buffer = encoder.encode(dataString);
+                await saveBufferToOPFS(getFilesPath(filesRoot, 'html', fileName), buffer);
+            }
+            if (contentType === 'json') {
+                fileName += '.json';
+                const encoder = new TextEncoder();
+                const buffer = encoder.encode(dataString);
+                await saveBufferToOPFS(getFilesPath(filesRoot, 'json', fileName), buffer);
+            }
+        }
+    };
+    onmessage = async (e) => {
+        const { debug, filesRoot } = e.data;
+        if (!debug) {
+            console.log = () => { };
+        }
+        await downloadFiles({ ...e.data, filesRoot });
+        globalThis.postMessage({
+            message: 'filesDownload onmessage done',
+            done: true,
+        });
+    };
+}.toString()}
+)()`;
+
+const logger$6 = debug('seedSdk:browser:workers:FileDownloader');
+class FileDownloader {
+    constructor() {
+        this.workersArchive = [];
+        this.downloadAll = async ({ transactionIds, arweaveHost, arweaveBaseUrls, excludedTransactions }) => {
+            if (this.workersArchive.length > 0) {
+                for (let i = 0; i < this.workersArchive.length; i++) {
+                    this.workersArchive[i].terminate();
+                    delete this.workersArchive[i];
+                }
+                this.workersArchive = [];
+            }
+            const worker = new Worker(this.workerBlobUrl);
+            this.workersArchive.push(worker);
+            const localExcludedTransactions = new Set(excludedTransactions);
+            const savedPaths = [];
+            return new Promise((resolve, reject) => {
+                worker.onmessage = (e) => {
+                    logger$6('filesDownload main thread onmessage', e.data);
+                    if (e.data.message === 'excludeTransaction') {
+                        localExcludedTransactions.add(e.data.transactionId);
+                    }
+                    if (e.data.message === 'fileSaved') {
+                        savedPaths.push(e.data.filePath);
+                    }
+                    if (e.data.done) {
+                        addExcludedTransactions(localExcludedTransactions)
+                            // The worker wrote to OPFS directly; refresh caches here and in other tabs.
+                            .then(() => notifyFilesWrittenOutsideCache(savedPaths))
+                            .then(() => {
+                            resolve(e.data);
+                        })
+                            .catch((error) => {
+                            reject(error);
+                        });
+                    }
+                    if (e.data.error) {
+                        reject(e.data.error);
+                    }
+                };
+                worker.postMessage({
+                    transactionIds,
+                    arweaveHost,
+                    arweaveBaseUrls,
+                    debug: logger$6.enabled,
+                    filesRoot: BaseFileManager.getWorkingDir(),
+                });
+            });
+        };
+        this.cores = Math.min(navigator.hardwareConcurrency || 4, 4);
+        this.workerBlobUrl = globalThis.URL.createObjectURL(new Blob([filesDownload], { type: 'application/javascript' }));
+    }
+}
+
+var imageResize = `(
+  ${function () {
+    const getFileHandle = async (path, rootHandle = null) => {
+        // Split the path into segments
+        const segments = path.split('/').filter(Boolean);
+        // Start from the root directory if not provided
+        if (!rootHandle) {
+            rootHandle = await navigator.storage.getDirectory();
+        }
+        let currentHandle = rootHandle;
+        // Traverse the path segments
+        for (let i = 0; i < segments.length; i++) {
+            const segment = segments[i];
+            const isLastSegment = i === segments.length - 1;
+            try {
+                for await (const [name, handle] of currentHandle.entries()) {
+                    if (name !== segment) {
+                        continue;
+                    }
+                    if (isLastSegment) {
+                        if (handle.kind === 'file') {
+                            return handle; // Return the file handle if found
+                        }
+                        else {
+                            throw new Error(`Path '${path}' refers to a directory, not a file.`);
+                        }
+                    }
+                    else if (handle.kind === 'directory') {
+                        currentHandle = handle; // Traverse into the directory
+                    }
+                    else {
+                        throw new Error(`Invalid path segment '${segment}'`);
+                    }
+                }
+            }
+            catch (err) {
+                if (err instanceof Error && err.name === 'NotFoundError') {
+                    throw new Error(`Path '${path}' does not exist.`);
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+        throw new Error(`Path '${path}' could not be resolved.`);
+    };
+    async function getFileFromOPFS(path) {
+        const fileHandleAsync = await getFileHandle(path);
+        const file = await fileHandleAsync.getFile();
+        return file;
+    }
+    /** Infer MIME from magic bytes. OPFS File may have empty type, causing createImageBitmap to fail. */
+    async function getBlobWithInferredMime(file) {
+        const buf = await file.arrayBuffer();
+        const bytes = new Uint8Array(buf);
+        let mime = file.type;
+        if (!mime || mime === '') {
+            if (bytes[0] === 0xff && bytes[1] === 0xd8)
+                mime = 'image/jpeg';
+            else if (bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47)
+                mime = 'image/png';
+            else if (bytes[0] === 0x52 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x52 && bytes[8] === 0x57 && bytes[9] === 0x45 && bytes[10] === 0x42 && bytes[11] === 0x50)
+                mime = 'image/webp';
+            else if (bytes[0] === 0x47 && bytes[1] === 0x49 && bytes[2] === 0x46)
+                mime = 'image/gif';
+            else if (bytes[0] === 0x42 && bytes[1] === 0x4d)
+                mime = 'image/bmp';
+            else if (bytes[4] === 0x66 && bytes[5] === 0x74 && bytes[6] === 0x79 && bytes[7] === 0x70 && bytes[8] === 0x61 && bytes[9] === 0x76 && bytes[10] === 0x69 && bytes[11] === 0x66)
+                mime = 'image/avif';
+            else if (bytes[4] === 0x66 && bytes[5] === 0x74 && bytes[6] === 0x79 && bytes[7] === 0x70 && bytes[8] === 0x68 && bytes[9] === 0x65 && bytes[10] === 0x69 && bytes[11] === 0x63)
+                mime = 'image/heic';
+            else
+                mime = 'image/jpeg';
+        }
+        return new Blob([buf], { type: mime });
+    }
+    const DEFAULT_CONFIG = {
+        argorithm: 'null',
+        processByHalf: true,
+        quality: 0.5,
+        maxWidth: 800,
+        maxHeight: 600,
+        debug: false,
+        mimeType: 'image/jpeg',
+    };
+    function isIos() {
+        if (typeof navigator === 'undefined')
+            return false;
+        if (!navigator.userAgent)
+            return false;
+        return /iPad|iPhone|iPod/.test(navigator.userAgent);
+    }
+    const getTargetHeight = (srcHeight, scale, config) => {
+        return Math.min(Math.floor(srcHeight * scale), config.maxHeight);
+    };
+    const findMaxWidth = (config, canvas) => {
+        //Let's find the max available width for scaled image
+        const ratio = canvas.width / canvas.height;
+        let mWidth = Math.min(canvas.width, config.maxWidth, ratio * config.maxHeight);
+        if (config.maxSize &&
+            config.maxSize > 0 &&
+            config.maxSize < (canvas.width * canvas.height) / 1000)
+            mWidth = Math.min(mWidth, Math.floor((config.maxSize * 1000) / canvas.height));
+        if (!!config.scaleRatio)
+            mWidth = Math.min(mWidth, Math.floor(config.scaleRatio * canvas.width));
+        const rHeight = getTargetHeight(canvas.height, mWidth / canvas.width, config);
+        // console.log(
+        //   'browser-image-resizer: original image size = ' +
+        //   canvas.width +
+        //   ' px (width) X ' +
+        //   canvas.height +
+        //   ' px (height)'
+        // );
+        // console.log(
+        //   'browser-image-resizer: scaled image size = ' +
+        //   mWidth +
+        //   ' px (width) X ' +
+        //   rHeight +
+        //   ' px (height)'
+        // );
+        if (mWidth <= 0) {
+            mWidth = 1;
+            console.warn("browser-image-resizer: image size is too small");
+        }
+        if (isIos() && mWidth * rHeight > 167777216) {
+            console.error("browser-image-resizer: image size is too large for iOS WebKit.", mWidth, rHeight);
+            throw new Error("browser-image-resizer: image size is too large for iOS WebKit.");
+        }
+        return mWidth;
+    };
+    /**
+    * Hermite resize, multicore version - fast image resize/resample using Hermite filter.
+    */
+    const resample = (srcCanvas, destCanvas, config) => {
+        return new Promise((resolve, reject) => {
+            const ratio_h = srcCanvas.height / destCanvas.height;
+            const cores = Math.min(navigator.hardwareConcurrency || 4, 4);
+            //prepare source and target data for workers
+            const ctx = srcCanvas.getContext('2d');
+            if (!ctx)
+                return reject('Canvas is empty (resample)');
+            const data_part = [];
+            const block_height = Math.ceil(srcCanvas.height / cores / 2) * 2;
+            let end_y = -1;
+            for (let c = 0; c < cores; c++) {
+                //source
+                const offset_y = end_y + 1;
+                if (offset_y >= srcCanvas.height) {
+                    //size too small, nothing left for this core
+                    continue;
+                }
+                end_y = Math.min(offset_y + block_height - 1, srcCanvas.height - 1);
+                const current_block_height = Math.min(block_height, srcCanvas.height - offset_y);
+                data_part.push({
+                    source: ctx.getImageData(0, offset_y, srcCanvas.width, block_height),
+                    startY: Math.ceil(offset_y / ratio_h),
+                    height: current_block_height
+                });
+            }
+            //start
+            const destCtx = destCanvas.getContext('2d');
+            if (!destCtx)
+                return reject('Canvas is empty (resample dest)');
+            for (let c = 0; c < data_part.length; c++) {
+                //draw
+                const height_part = Math.ceil(data_part[c].height / ratio_h);
+                const target = destCtx.createImageData(destCanvas.width, height_part);
+                // target.data.set(event.data.target);
+                destCtx.putImageData(target, 0, data_part[c].startY);
+            }
+        });
+    };
+    /**
+     * Hermite resize - fast image resize/resample using Hermite filter. 1 cpu version!
+     */
+    const resampleSingle = (srcCanvasData, destCanvasData) => {
+        const ratio_w = srcCanvasData.width / destCanvasData.width;
+        const ratio_h = srcCanvasData.height / destCanvasData.height;
+        const ratio_w_half = Math.ceil(ratio_w / 2);
+        const ratio_h_half = Math.ceil(ratio_h / 2);
+        const data = srcCanvasData.data;
+        const data2 = destCanvasData.data;
+        for (let j = 0; j < destCanvasData.height; j++) {
+            for (let i = 0; i < destCanvasData.width; i++) {
+                const x2 = (i + j * destCanvasData.width) * 4;
+                let weight = 0;
+                let weights = 0;
+                let weights_alpha = 0;
+                let gx_r = 0;
+                let gx_g = 0;
+                let gx_b = 0;
+                let gx_a = 0;
+                const center_y = j * ratio_h;
+                const xx_start = Math.floor(i * ratio_w);
+                const xx_stop = Math.min(Math.ceil((i + 1) * ratio_w), srcCanvasData.width);
+                const yy_start = Math.floor(j * ratio_h);
+                const yy_stop = Math.min(Math.ceil((j + 1) * ratio_h), srcCanvasData.height);
+                for (let yy = yy_start; yy < yy_stop; yy++) {
+                    let dy = Math.abs(center_y - yy) / ratio_h_half;
+                    let center_x = i * ratio_w;
+                    let w0 = dy * dy; //pre-calc part of w
+                    for (let xx = xx_start; xx < xx_stop; xx++) {
+                        let dx = Math.abs(center_x - xx) / ratio_w_half;
+                        let w = Math.sqrt(w0 + dx * dx);
+                        if (w >= 1) {
+                            //pixel too far
+                            continue;
+                        }
+                        //hermite filter
+                        weight = 2 * w * w * w - 3 * w * w + 1;
+                        let pos_x = 4 * (xx + yy * srcCanvasData.width);
+                        //alpha
+                        gx_a += weight * data[pos_x + 3];
+                        weights_alpha += weight;
+                        //colors
+                        if (data[pos_x + 3] < 255)
+                            weight = weight * data[pos_x + 3] / 250;
+                        gx_r += weight * data[pos_x];
+                        gx_g += weight * data[pos_x + 1];
+                        gx_b += weight * data[pos_x + 2];
+                        weights += weight;
+                    }
+                }
+                data2[x2] = gx_r / weights;
+                data2[x2 + 1] = gx_g / weights;
+                data2[x2 + 2] = gx_b / weights;
+                data2[x2 + 3] = gx_a / weights_alpha;
+            }
+        }
+    };
+    /**
+    * Hermite resize. Detect cpu count and use best option for user.
+    */
+    const resampleAuto = (srcCanvas, destCanvas, config) => {
+        if (!!globalThis.Worker && navigator.hardwareConcurrency > 1 && config?.argorithm !== 'hermite_single') {
+            //workers supported and we have at least 2 cpu cores - using multithreading
+            return resample(srcCanvas, destCanvas);
+        }
+        else {
+            //1 cpu version
+            const { srcImgData, destImgData } = getImageData(srcCanvas, destCanvas);
+            resampleSingle(srcImgData, destImgData);
+            destCanvas.getContext('2d').putImageData(destImgData, 0, 0);
+            return;
+        }
+    };
+    async function scaleCanvasWithAlgorithm(canvas, config) {
+        const scale = config.outputWidth / canvas.width;
+        const scaled = new OffscreenCanvas(Math.floor(config.outputWidth), getTargetHeight(canvas.height, scale, config));
+        switch (config.algorithm) {
+            case 'hermite': {
+                await resampleAuto(canvas, scaled, config);
+                break;
+            }
+            case 'hermite_single': {
+                const { srcImgData, destImgData } = getImageData(canvas, scaled);
+                resampleSingle(srcImgData, destImgData);
+                scaled?.getContext('2d')?.putImageData(destImgData, 0, 0);
+                break;
+            }
+            case 'bilinear': {
+                // const { srcImgData, destImgData } = getImageData(canvas, scaled);
+                // bilinear(srcImgData, destImgData, scale);
+                // scaled?.getContext('2d')?.putImageData(destImgData, 0, 0);
+                break;
+            }
+            default: {
+                scaled.getContext('2d')?.drawImage(canvas, 0, 0, scaled.width, scaled.height);
+                break;
+            }
+        }
+        return scaled;
+    }
+    const getHalfScaleCanvas = (src) => {
+        const half = new OffscreenCanvas(src.width / 2, src.height / 2);
+        half
+            ?.getContext('2d')
+            ?.drawImage(src, 0, 0, half.width, half.height);
+        return half;
+    };
+    const getImageData = (canvas, scaled) => {
+        const srcImgData = canvas
+            ?.getContext('2d')
+            ?.getImageData(0, 0, canvas.width, canvas.height);
+        const destImgData = scaled
+            ?.getContext('2d')
+            ?.createImageData(scaled.width, scaled.height);
+        if (!srcImgData || !destImgData)
+            throw Error('Canvas is empty (scaleCanvasWithAlgorithm). You should run this script after the document is ready.');
+        return { srcImgData, destImgData };
+    };
+    async function saveBlobToOPFS(filePath, blob) {
+        // Access the OPFS root directory
+        const rootHandle = await navigator.storage.getDirectory();
+        // Split the filePath into directory segments and file name
+        const segments = filePath.split('/').filter(Boolean);
+        const fileName = segments.pop(); // Extract the file name
+        if (!fileName) {
+            throw new Error('Invalid file path: No file name provided.');
+        }
+        // Traverse or create directories as needed
+        let currentDirHandle = rootHandle;
+        for (const segment of segments) {
+            currentDirHandle = await currentDirHandle.getDirectoryHandle(segment, { create: true });
+        }
+        // Create or open the file in OPFS
+        const fileHandle = await currentDirHandle.getFileHandle(fileName, { create: true });
+        // Write the Blob to the file
+        const writableStream = await fileHandle.createWritable();
+        try {
+            await writableStream.write(blob);
+        }
+        catch (error) {
+            // Discard the partial write and release the file's lock
+            await writableStream.abort().catch(() => { });
+            throw error;
+        }
+        await writableStream.close();
+    }
+    const imageResize = async (filePath, width, height) => {
+        const config = {
+            ...DEFAULT_CONFIG,
+            algorithm: 'hermite_single',
+            mimeType: 'image/webp',
+            maxWidth: width,
+            maxHeight: height,
+        };
+        const file = await getFileFromOPFS(filePath);
+        const blobWithMime = await getBlobWithInferredMime(file);
+        const imageBitmap = await createImageBitmap(blobWithMime);
+        let converting;
+        if (isIos() && imageBitmap.width * imageBitmap.height > 16777216) {
+            const scale = Math.sqrt(16777216 / (imageBitmap.width * imageBitmap.height));
+            converting = new OffscreenCanvas(Math.floor(imageBitmap.width * scale), Math.floor(imageBitmap.height * scale));
+            converting.getContext('2d')?.drawImage(imageBitmap, 0, 0, converting.width, converting.height);
+        }
+        else {
+            converting = new OffscreenCanvas(imageBitmap.width, imageBitmap.height);
+            converting.getContext('2d')?.drawImage(imageBitmap, 0, 0);
+        }
+        const maxWidth = findMaxWidth(config, converting);
+        if (!maxWidth) {
+            throw Error(`browser-image-resizer: maxWidth is ${maxWidth}!!`);
+        }
+        while (config.processByHalf && converting.width >= 2 * maxWidth) {
+            converting = getHalfScaleCanvas(converting);
+        }
+        if (converting.width > maxWidth) {
+            converting = await scaleCanvasWithAlgorithm(converting, Object.assign(config, { outputWidth: maxWidth }));
+        }
+        if (config.mimeType === null) {
+            return converting;
+        }
+        const resizedBlob = await converting.convertToBlob({ type: config.mimeType, quality: config.quality });
+        const pathSegments = filePath.split('/');
+        const fileName = pathSegments.pop();
+        if (!fileName) {
+            throw Error('Invalid file path: No file name provided.');
+        }
+        const newSegments = [
+            ...pathSegments,
+            width,
+        ];
+        const fileNameParts = fileName.split('.');
+        const newFileName = `${fileNameParts[0]}.webp`;
+        const newDirPath = newSegments.join('/');
+        const newFilePath = `${newDirPath}/${newFileName}`;
+        await saveBlobToOPFS(newFilePath, resizedBlob);
+        globalThis.postMessage({
+            done: true,
+            filePath: newFilePath,
+        });
+    };
+    onmessage = async (e) => {
+        const { filePath, width, height, debug } = e.data;
+        if (!debug) {
+            console.log = () => { };
+        }
+        try {
+            await imageResize(filePath, width, height);
+        }
+        catch (err) {
+            globalThis.postMessage({ error: err instanceof Error ? err.message : String(err) });
+        }
+    };
+}.toString()}
+)()`;
+
+const logger$5 = debug('seedSdk:browser:workers:ImageResizer');
+class ImageResizer {
+    constructor() {
+        this.workersArchive = new Map();
+        this.cores = Math.min(navigator.hardwareConcurrency || 4, 4);
+        this.workerBlobUrl = globalThis.URL.createObjectURL(new Blob([imageResize], { type: 'application/javascript' }));
+    }
+    async resize({ filePath, width, height }) {
+        if (this.workersArchive.has(filePath)) {
+            const savedWorker = this.workersArchive.get(filePath);
+            savedWorker?.terminate();
+            logger$5('[ImageResizer.resize] Terminated worker for filePath due to incoming request', filePath);
+            this.workersArchive.delete(filePath);
+        }
+        const worker = new Worker(this.workerBlobUrl);
+        this.workersArchive.set(filePath, worker);
+        return new Promise((resolve, reject) => {
+            worker.onmessage = (e) => {
+                logger$5('[ImageResizer.resize] main thread onmessage', e.data);
+                if (e.data.done) {
+                    const savedWorker = this.workersArchive.get(filePath);
+                    savedWorker?.terminate();
+                    logger$5('[ImageResizer.resize] Terminated worker for filePath due to done', filePath);
+                    this.workersArchive.delete(filePath);
+                    // The worker wrote the variant to OPFS directly; refresh caches here and in other tabs.
+                    notifyFilesWrittenOutsideCache([e.data.filePath]).then(() => resolve(e.data), () => resolve(e.data));
+                }
+                if (e.data.error) {
+                    reject(e.data.error);
+                }
+            };
+            worker.onerror = (err) => {
+                reject(err);
+            };
+            worker.postMessage({
+                filePath,
+                width,
+                height,
+                debug: logger$5.enabled,
+            });
+        });
+    }
+    async resizeAll({ width, height }) {
+        const fs = await BaseFileManager.getFs();
+        const imageDir = BaseFileManager.getFilesPath('images');
+        let imageFilesStats = await fs.promises.readdir(imageDir, {
+            withFileTypes: true
+        });
+        imageFilesStats = imageFilesStats.filter((file) => file.isFile());
+        const imageFiles = imageFilesStats.map((file) => file.path);
+        const widthDir = `${imageDir}/${width}`;
+        await BaseFileManager.createDirIfNotExists(widthDir);
+        for (const imageFile of imageFiles) {
+            const resizedImageExists = await BaseFileManager.pathExists(`${widthDir}/${imageFile}`);
+            if (!resizedImageExists) {
+                await this.resize({ filePath: `${imageDir}/${imageFile}`, width, height });
+            }
+        }
+    }
+}
+
+/**
+ * Errors Chromium throws for a single OPFS entry that another context is using: the entry was
+ * removed between listing and reading (SQLite journals come and go per transaction), or it is
+ * held by a sync access handle in another tab or a not-yet-terminated worker.
+ */
+const SKIPPABLE_ENTRY_ERRORS = new Set([
+    'NotFoundError',
+    'InvalidStateError',
+    'NoModificationAllowedError',
+    'NotReadableError',
+]);
+function isSkippableOpfsEntryError(error) {
+    return error instanceof DOMException && SKIPPABLE_ENTRY_ERRORS.has(error.name);
+}
+
+const logger$4 = debug('seedSdk:browser:helpers:FileManager');
+/**
+ * Browser-safe path helpers for SDK virtual file paths.
+ * We intentionally avoid Node/CJS path polyfills here to keep browser bundles ESM-safe.
+ * Provides the subset of Node path APIs used via BaseFileManager.getPathModule().
+ */
+const pathCompat = {
+    dirname(filePath) {
+        if (!filePath)
+            return '.';
+        const normalized = filePath.replace(/\\/g, '/');
+        if (normalized === '/')
+            return '/';
+        const trimmed = normalized.endsWith('/') && normalized.length > 1
+            ? normalized.slice(0, -1)
+            : normalized;
+        const lastSlash = trimmed.lastIndexOf('/');
+        if (lastSlash === -1)
+            return '.';
+        if (lastSlash === 0)
+            return '/';
+        return trimmed.slice(0, lastSlash);
+    },
+    basename(filePath) {
+        if (!filePath)
+            return '';
+        const normalized = filePath.replace(/\\/g, '/');
+        if (normalized === '/')
+            return '/';
+        const trimmed = normalized.endsWith('/') && normalized.length > 1
+            ? normalized.slice(0, -1)
+            : normalized;
+        const lastSlash = trimmed.lastIndexOf('/');
+        return lastSlash === -1 ? trimmed : trimmed.slice(lastSlash + 1);
+    },
+    isAbsolute(filePath) {
+        if (!filePath)
+            return false;
+        const normalized = filePath.replace(/\\/g, '/');
+        return normalized.startsWith('/');
+    },
+    join(...segments) {
+        if (segments.length === 0)
+            return '.';
+        const joined = segments
+            .filter((s) => s != null && s !== '')
+            .map((s) => String(s).replace(/\\/g, '/'))
+            .join('/');
+        return pathCompat.normalize(joined);
+    },
+    resolve(...segments) {
+        // POSIX-like resolve for virtual paths: walk right-to-left until absolute.
+        let resolved = '';
+        let absolute = false;
+        for (let i = segments.length - 1; i >= 0 && !absolute; i--) {
+            const segment = segments[i];
+            if (segment == null || segment === '')
+                continue;
+            const normalized = String(segment).replace(/\\/g, '/');
+            resolved = resolved ? `${normalized}/${resolved}` : normalized;
+            absolute = pathCompat.isAbsolute(normalized);
+        }
+        // Browser has no process.cwd(); treat unresolved relative paths as root-relative.
+        if (!absolute) {
+            resolved = `/${resolved}`;
+        }
+        return pathCompat.normalize(resolved);
+    },
+    normalize(filePath) {
+        if (!filePath)
+            return '.';
+        const normalized = filePath.replace(/\\/g, '/');
+        const absolute = normalized.startsWith('/');
+        const parts = normalized.split('/');
+        const stack = [];
+        for (const part of parts) {
+            if (!part || part === '.')
+                continue;
+            if (part === '..') {
+                if (stack.length > 0 && stack[stack.length - 1] !== '..') {
+                    stack.pop();
+                }
+                else if (!absolute) {
+                    stack.push('..');
+                }
+                continue;
+            }
+            stack.push(part);
+        }
+        const result = stack.join('/');
+        if (absolute)
+            return `/${result}`;
+        return result || '.';
+    },
+};
+/**
+ * Chromium OPFS: the mount walk hit an entry another context is using (reload, other tab,
+ * leftover sync access handle, a SQLite journal removed mid-walk).
+ */
+function isBusyOpfsMountError(error) {
+    if (isSkippableOpfsEntryError(error)) {
+        return true;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes('state cached in an interface object');
+}
+/** Waits between mount attempts; about 2 s in total. */
+const MOUNT_RETRY_DELAYS_MS = [50, 150, 300, 600, 1000];
+/** OPFS / ZenFS can throw NotReadableError while a file is still settling after write. */
+function isTransientOpfsReadError(error) {
+    if (error instanceof DOMException && error.name === 'NotReadableError') {
+        return true;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    // Chromium wording when getFile/read races a writer or stale handle
+    if (message.includes('permission problems') && message.includes('reference')) {
+        return true;
+    }
+    return false;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+class BrowserFileManager {
+    constructor() {
+        this.zenfsCache = null;
+    }
+    async getFs() {
+        if (!this.zenfsCache) {
+            this.zenfsCache = await import('@zenfs/core');
+        }
+        return this.zenfsCache;
+    }
+    getFsSync() {
+        if (!this.zenfsCache) {
+            throw new Error('File system not initialized. Call getFs() or initializeFileSystem() first.');
+        }
+        return this.zenfsCache;
+    }
+    async getContentUrlFromPath(path) {
+        const fileExists = await this.pathExists(path);
+        if (fileExists) {
+            const file = await this.readFile(path);
+            return URL.createObjectURL(file);
+        }
+    }
+    async initializeFileSystem(_workingDir) {
+        const zenfs = await this.getFs();
+        const { TolerantWebAccess } = await import('./tolerantWebAccess-CzOBz5M6.js');
+        const { configureSingle } = zenfs;
+        const configureRoot = async () => {
+            const handle = await navigator.storage.getDirectory();
+            await configureSingle({
+                backend: TolerantWebAccess,
+                handle,
+            });
+        };
+        // TolerantWebAccess skips busy entries, so what reaches here is the walk failing above them
+        // (e.g. a stale root handle). Retry without deleting OPFS data; BaseFileManager resets its
+        // flags if every attempt fails.
+        for (let attempt = 0;; attempt++) {
+            try {
+                await configureRoot();
+                return;
+            }
+            catch (error) {
+                if (!isBusyOpfsMountError(error)) {
+                    throw error;
+                }
+                if (attempt === MOUNT_RETRY_DELAYS_MS.length) {
+                    throw new FileSystemLockedError(error);
+                }
+                logger$4(`OPFS mount attempt ${attempt + 1} failed (${error?.name}); retrying`);
+                await sleep(MOUNT_RETRY_DELAYS_MS[attempt]);
+            }
+        }
+    }
+    async downloadAllFiles({ transactionIds, arweaveHost, arweaveBaseUrls, excludedTransactions, }) {
+        const fileDownloader = new FileDownloader();
+        await fileDownloader.downloadAll({ transactionIds, arweaveHost, arweaveBaseUrls, excludedTransactions });
+    }
+    async resizeImage({ filePath, width, height }) {
+        const imageResizer = new ImageResizer();
+        await imageResizer.resize({ filePath, width, height });
+    }
+    async resizeAllImages({ width, height }) {
+        const imageResizer = new ImageResizer();
+        await imageResizer.resizeAll({ width, height });
+    }
+    async listImageFiles() {
+        return this.listFiles('images');
+    }
+    async listFiles(dir) {
+        const targetDir = BaseFileManager.getFilesPath(dir);
+        const exists = await this.pathExists(targetDir);
+        if (!exists) {
+            return [];
+        }
+        const zenfs = await this.getFs();
+        const entries = await zenfs.promises.readdir(targetDir, { withFileTypes: true });
+        return entries.filter((entry) => entry.isFile()).map((entry) => entry.name);
+    }
+    async invalidateCachedPaths(filePaths) {
+        const { mounts } = await this.getFs();
+        const { TolerantWebAccessFS } = await import('./tolerantWebAccess-CzOBz5M6.js');
+        const mounted = mounts.get('/');
+        if (!(mounted instanceof TolerantWebAccessFS))
+            return;
+        for (const filePath of filePaths) {
+            const absolute = filePath.startsWith('/') ? filePath : `/${filePath}`;
+            try {
+                await mounted.invalidate(absolute);
+            }
+            catch (error) {
+                logger$4(`could not refresh cached ${absolute}`, error);
+            }
+        }
+    }
+    async pathExists(filePath) {
+        try {
+            const zenfs = await this.getFs();
+            await zenfs.promises.access(filePath, zenfs.constants.F_OK);
+            return true;
+        }
+        catch (error) {
+            // ENOENT means the file doesn't exist, which is expected
+            if (error?.code === 'ENOENT' || error?.errno === -2) {
+                return false;
+            }
+            // For other errors, re-throw them
+            throw error;
+        }
+    }
+    async getFileSize(filePath) {
+        try {
+            const zenfs = await this.getFs();
+            const stat = await zenfs.promises.stat(filePath);
+            return typeof stat?.size === 'number' ? stat.size : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async createDirIfNotExists(filePath) {
+        if (!(await this.pathExists(filePath))) {
+            try {
+                const zenfs = await this.getFs();
+                await zenfs.promises.mkdir(filePath, { recursive: true });
+            }
+            catch (error) {
+                // This is a no-op. We tried to create a directory that already exists.
+                logger$4('Attempted to create a directory that already exists');
+            }
+        }
+    }
+    /**
+     * Waits for a file to exist at the specified path.
+     * @param {string} filePath - The path of the file to check.
+     * @param {number} interval - The interval in milliseconds between checks (default: 500ms).
+     * @param {number} timeout - The timeout in milliseconds to wait for the file to exist (default: 10s).
+     * @returns {Promise<boolean>} - Resolves to true if the file exists within the timeout period, otherwise false.
+     */
+    async waitForFile(filePath, interval = 1000, timeout = 60000) {
+        // const fs = await this.getFs()
+        // const fsNode = await import('node:fs')
+        const pathExists = await this.pathExists(filePath);
+        if (pathExists) {
+            return true;
+        }
+        return new Promise((resolve, reject) => {
+            const startTime = Date.now();
+            let isBusy = false;
+            const cancelableInterval = new CancelableInterval(async (stop) => {
+                logger$4('waitForFile', filePath);
+                if (isBusy) {
+                    return;
+                }
+                isBusy = true;
+                // // TODO: Needs to read from OPFS
+                // const exists = await BaseFileManager.pathExists(filePath)
+                // if (exists) {
+                //   stop()
+                //   resolve(true)
+                // }
+                const pathExists = await this.pathExists(filePath);
+                if (pathExists) {
+                    stop();
+                    resolve(true);
+                }
+                if (Date.now() - startTime >= timeout) {
+                    stop();
+                    reject(new Error('Timeout exceeded while waiting for file'));
+                }
+                isBusy = false;
+            }, interval);
+            cancelableInterval.start();
+            // const _interval = setInterval(async () => {
+            //   logger('waitForFile', filePath)
+            //   if (isBusy) {
+            //     return
+            //   }
+            //   isBusy = true
+            //   // TODO: Needs to read from OPFS
+            //   if (fs.existsSync(filePath) && fsNode.existsSync(filePath)) {
+            //     clearInterval(_interval)
+            //     resolve(true)
+            //   }
+            //   const pathExists = await this.pathExists(filePath)
+            //   if (pathExists) {
+            //     clearInterval(_interval)
+            //     resolve(true)
+            //   }
+            //   if (Date.now() - startTime >= timeout) {
+            //     clearInterval(_interval)
+            //     reject(new Error('Timeout exceeded while waiting for file'))
+            //   }
+            //   isBusy = false
+            // }, interval)
+            // retry(
+            //   {
+            //     times: Math.ceil(timeout / interval),
+            //     interval: interval,
+            //   },
+            //   (callback: Function) => {
+            //     if (fs.existsSync(filePath) && fsNode.existsSync(filePath)) {
+            //       return callback(null, true) // File exists, finish with success
+            //     }
+            //     if (Date.now() - startTime >= timeout) {
+            //       return callback(new Error('Timeout exceeded while waiting for file'))
+            //     }
+            //     callback(new Error('File does not exist yet')) // Retry with this error
+            //   },
+            //   (err: Error, result: boolean) => {
+            //     if (err) {
+            //       return resolve(false) // Resolve as false if timeout or error occurs
+            //     }
+            //     resolve(result) // Resolve as true if file exists
+            //   },
+            // )
+        });
+    }
+    /**
+     * Waits for a file to exist and have content (non-zero size).
+     * This is important for browser/OPFS where writes may not be immediately readable.
+     * @param {string} filePath - The path of the file to check.
+     * @param {number} interval - The interval in milliseconds between checks (default: 100ms).
+     * @param {number} timeout - The timeout in milliseconds to wait (default: 5s).
+     * @returns {Promise<boolean>} - Resolves to true if the file exists with content within the timeout period.
+     */
+    async waitForFileWithContent(filePath, interval = 100, timeout = 5000) {
+        // First wait for file to exist
+        await this.waitForFile(filePath, interval, timeout);
+        // Usually readable at once: polling first cost every saveFile 100ms. Any read error falls
+        // through to the polling below, which decides whether it is transient.
+        try {
+            if ((await this.readFile(filePath)).size > 0)
+                return true;
+        }
+        catch {
+            // handled by polling
+        }
+        // Now wait for file to have content
+        return new Promise((resolve, reject) => {
+            const startTime = Date.now();
+            let isBusy = false;
+            const cancelableInterval = new CancelableInterval(async (stop) => {
+                logger$4('waitForFileWithContent', filePath);
+                if (isBusy) {
+                    return;
+                }
+                isBusy = true;
+                try {
+                    // Try to read the file to check if it has content
+                    const file = await this.readFile(filePath);
+                    if (file.size > 0) {
+                        stop();
+                        resolve(true);
+                        return;
+                    }
+                    // File exists but is 0 bytes, continue waiting
+                }
+                catch (error) {
+                    // If error is about file being 0 bytes, not readable, or I/O error, continue waiting
+                    const errorMessage = error?.message || String(error);
+                    if (errorMessage.includes('0 bytes') ||
+                        errorMessage.includes('ENOENT') ||
+                        errorMessage.includes('EIO') ||
+                        errorMessage.includes('Input/output error') ||
+                        isTransientOpfsReadError(error)) ;
+                    else {
+                        // Other errors should be thrown
+                        stop();
+                        reject(error);
+                        return;
+                    }
+                }
+                if (Date.now() - startTime >= timeout) {
+                    stop();
+                    reject(new Error(`Timeout exceeded while waiting for file ${filePath} to have content`));
+                    return;
+                }
+                isBusy = false;
+            }, interval);
+            cancelableInterval.start();
+        });
+    }
+    async saveFile(filePath, content) {
+        const zenfs = await this.getFs();
+        // Convert content to a format that zenfs.writeFile accepts
+        let writeContent;
+        if (typeof content === 'string') {
+            writeContent = content;
+        }
+        else if (content instanceof Blob) {
+            const arrayBuffer = await content.arrayBuffer();
+            writeContent = new Uint8Array(arrayBuffer);
+        }
+        else if (content instanceof ArrayBuffer) {
+            writeContent = new Uint8Array(content);
+        }
+        else {
+            throw new Error('Unsupported content type');
+        }
+        await zenfs.writeFile(filePath, writeContent);
+        await this.waitForFileWithContent(filePath, 100, 5000);
+        // try {
+        //   // Get a handle to the OPFS root directory
+        //   const root = await navigator.storage.getDirectory();
+        //   // Split the file path into directory and file name
+        //   const pathParts = filePath.split('/');
+        //   const fileName = pathParts.pop();
+        //   if (!fileName) throw new Error('Invalid file path');
+        //   // Traverse directories and create them if they don't exist
+        //   let currentDir = root;
+        //   for (const part of pathParts) {
+        //     if (part !== '') {
+        //       currentDir = await currentDir.getDirectoryHandle(part, { create: true });
+        //     }
+        //   }
+        //   // Get the file handle and create the file if it doesn't exist
+        //   const fileHandle = await currentDir.getFileHandle(fileName, { create: true });
+        //   // Create a writable stream and write the content
+        //   const writable = await fileHandle.createWritable();
+        //   if (typeof content === 'string' || content instanceof Uint8Array) {
+        //       await writable.write(content);
+        //   } else if (content instanceof Blob) {
+        //       await writable.write(content);
+        //   } else if (content instanceof ArrayBuffer) {
+        //       await writable.write(new Blob([content]));
+        //   } else {
+        //       throw new Error('Unsupported content type');
+        //   }
+        //   await writable.close();
+        //   logger(`File written successfully: ${filePath}`);
+        // } catch (error) {
+        //     console.error(`Error writing to OPFS: ${error.message}`);
+        // }
+    }
+    saveFileSync(filePath, content) {
+        // Note: This is a synchronous wrapper, but zenfs operations may still be async under the hood
+        // For true sync operations in browser, we'd need to use OPFS sync access handles
+        // For now, we'll use zenfs.writeFileSync which should be available
+        const zenfs = this.getFsSync();
+        // Convert content to a format that zenfs.writeFileSync accepts
+        let writeContent;
+        if (typeof content === 'string') {
+            writeContent = content;
+        }
+        else if (content instanceof Blob) {
+            // Blob cannot be converted synchronously - throw error
+            throw new Error('Blob content not supported in saveFileSync. Use saveFile() instead or convert to ArrayBuffer first.');
+        }
+        else if (content instanceof ArrayBuffer) {
+            writeContent = new Uint8Array(content);
+        }
+        else {
+            throw new Error('Unsupported content type');
+        }
+        zenfs.writeFileSync(filePath, writeContent);
+    }
+    async readFile(filePath) {
+        const zenfs = await this.getFs();
+        const maxAttempts = 3;
+        const baseDelayMs = 50;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            try {
+                const data = await zenfs.promises.readFile(filePath);
+                return new File([new Uint8Array(data)], filePath);
+            }
+            catch (error) {
+                if (!isTransientOpfsReadError(error) || attempt === maxAttempts - 1) {
+                    throw error;
+                }
+                await sleep(baseDelayMs * (attempt + 1));
+            }
+        }
+        throw new Error('readFile: exhausted retries');
+        // try {
+        //   // Get a handle to the OPFS root directory
+        //   const root = await navigator.storage.getDirectory();
+        //    // Split the file path into directory and file name
+        //    const pathParts = filePath.split('/');
+        //    const fileName = pathParts.pop();
+        //    if (!fileName) throw new Error('Invalid file path');
+        //    // Traverse directories to reach the target file
+        //    let currentDir = root;
+        //    for (const part of pathParts) {
+        //      if (part !== '') {
+        //        currentDir = await currentDir.getDirectoryHandle(part, { create: false });
+        //      }
+        //    }
+        //    // Get the file handle
+        //    const fileHandle = await currentDir.getFileHandle(fileName, { create: false });
+        //    // Get the file and read it as an ArrayBuffer
+        //    return await fileHandle.getFile();
+        // } catch (error) {
+        //   console.error(`Error reading from OPFS: ${error.message}`);
+        //   throw error;
+        // }
+    }
+    readFileSync(filePath) {
+        // Note: This is a synchronous wrapper, but zenfs operations may still be async under the hood
+        // For true sync operations in browser, we'd need to use OPFS sync access handles
+        // For now, we'll use zenfs.readFileSync which should be available
+        const zenfs = this.getFsSync();
+        const file = zenfs.readFileSync(filePath);
+        return new File([new Uint8Array(file)], filePath);
+    }
+    async readFileAsBuffer(filePath) {
+        try {
+            // Get the file and read it as an ArrayBuffer
+            const file = await this.readFile(filePath);
+            const arrayBuffer = await file.arrayBuffer();
+            // Convert ArrayBuffer to Blob
+            return new Blob([arrayBuffer]);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Error reading from OPFS: ${errorMessage}`);
+            throw error;
+        }
+    }
+    async readFileAsString(filePath) {
+        const blob = await this.readFileAsBuffer(filePath);
+        return blob.text();
+    }
+    getParentDirPath(filePath) {
+        return pathCompat.dirname(filePath);
+    }
+    getFilenameFromPath(filePath) {
+        return pathCompat.basename(filePath);
+    }
+    getPathModule() {
+        return pathCompat;
+    }
+}
+class CancelableInterval {
+    constructor(task, interval) {
+        this.task = task;
+        this.interval = interval;
+        this.intervalId = null;
+        this.currentTaskAbortController = null;
+    }
+    start() {
+        this.intervalId = window.setInterval(async () => {
+            if (this.currentTaskAbortController) {
+                // Cancel the previous running task
+                this.currentTaskAbortController.abort();
+            }
+            // Create a new abort controller for the current task
+            this.currentTaskAbortController = new AbortController();
+            const signal = this.currentTaskAbortController.signal;
+            try {
+                await this.taskWithCancellation(signal);
+            }
+            catch (error) {
+                if (error instanceof DOMException && error.name === 'AbortError') {
+                    logger$4('Previous task was canceled.');
+                }
+                else {
+                    console.error('Task error:', error);
+                }
+                this.stop();
+            }
+        }, this.interval);
+    }
+    async taskWithCancellation(signal) {
+        await this.task(() => this.stop());
+        if (signal.aborted) {
+            throw new DOMException('Task was aborted', 'AbortError');
+        }
+    }
+    stop() {
+        if (this.intervalId !== null) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        if (this.currentTaskAbortController) {
+            this.currentTaskAbortController.abort();
+        }
+    }
+}
+BaseFileManager.configure(new BrowserFileManager());
+
+// This file embeds the drizzle migration files as strings for browser runtime
+// These files are copied from packages/sdk/src/db/drizzle at build time
+// Individual migration SQL files
+const migrationSql_0000_married_malice = `CREATE TABLE \`appState\` (
+	\`key\` text,
+	\`value\` text,
+	\`created_at\` integer,
+	\`updated_at\` integer
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`appState_key_unique\` ON \`appState\` (\`key\`);--> statement-breakpoint
+CREATE TABLE \`config\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`key\` text NOT NULL,
+	\`text\` text,
+	\`json\` text,
+	\`blob\` blob
+);
+--> statement-breakpoint
+CREATE TABLE \`metadata\` (
+	\`local_id\` text,
+	\`uid\` text,
+	\`property_name\` text,
+	\`property_value\` text,
+	\`schema_uid\` text,
+	\`model_type\` text,
+	\`seed_local_id\` text,
+	\`seed_uid\` text,
+	\`version_local_id\` text,
+	\`version_uid\` text,
+	\`eas_data_type\` text,
+	\`ref_value_type\` text,
+	\`ref_schema_uid\` text,
+	\`ref_seed_type\` text,
+	\`ref_resolved_value\` text,
+	\`ref_resolved_display_value\` text,
+	\`local_storage_dir\` text,
+	\`attestation_raw\` text,
+	\`attestation_created_at\` integer,
+	\`content_hash\` text,
+	\`created_at\` integer,
+	\`updated_at\` integer
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`metadata_local_id_unique\` ON \`metadata\` (\`local_id\`);--> statement-breakpoint
+CREATE TABLE \`models\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`name\` text NOT NULL,
+	\`schema_file_id\` text
+);
+--> statement-breakpoint
+CREATE TABLE \`properties\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`name\` text NOT NULL,
+	\`data_type\` text NOT NULL,
+	\`model_id\` integer NOT NULL,
+	\`ref_model_id\` integer,
+	\`ref_value_type\` text,
+	\`schema_file_id\` text,
+	FOREIGN KEY (\`model_id\`) REFERENCES \`models\`(\`id\`) ON UPDATE no action ON DELETE no action,
+	FOREIGN KEY (\`ref_model_id\`) REFERENCES \`models\`(\`id\`) ON UPDATE no action ON DELETE no action
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`unique_name_model_id\` ON \`properties\` (\`name\`,\`model_id\`);--> statement-breakpoint
+CREATE TABLE \`model_schemas\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`model_id\` integer,
+	\`schema_id\` integer,
+	FOREIGN KEY (\`model_id\`) REFERENCES \`models\`(\`id\`) ON UPDATE no action ON DELETE no action,
+	FOREIGN KEY (\`schema_id\`) REFERENCES \`schemas\`(\`id\`) ON UPDATE no action ON DELETE no action
+);
+--> statement-breakpoint
+CREATE TABLE \`model_uids\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`uid\` text NOT NULL,
+	\`model_id\` integer NOT NULL,
+	FOREIGN KEY (\`model_id\`) REFERENCES \`models\`(\`id\`) ON UPDATE no action ON DELETE no action
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`model_uids_model_id_unique\` ON \`model_uids\` (\`model_id\`);--> statement-breakpoint
+CREATE TABLE \`property_uids\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`uid\` text NOT NULL,
+	\`property_id\` integer NOT NULL,
+	FOREIGN KEY (\`property_id\`) REFERENCES \`models\`(\`id\`) ON UPDATE no action ON DELETE no action
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`property_uids_property_id_unique\` ON \`property_uids\` (\`property_id\`);--> statement-breakpoint
+CREATE TABLE \`schemas\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`name\` text NOT NULL,
+	\`version\` integer NOT NULL,
+	\`schema_file_id\` text,
+	\`created_at\` integer,
+	\`updated_at\` integer
+);
+--> statement-breakpoint
+CREATE TABLE \`seeds\` (
+	\`local_id\` text,
+	\`uid\` text,
+	\`schema_uid\` text,
+	\`type\` text,
+	\`attestation_raw\` text,
+	\`attestation_created_at\` integer,
+	\`created_at\` integer,
+	\`updated_at\` integer,
+	\`_marked_for_deletion\` integer
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`seeds_local_id_unique\` ON \`seeds\` (\`local_id\`);--> statement-breakpoint
+CREATE TABLE \`versions\` (
+	\`local_id\` text,
+	\`uid\` text,
+	\`seed_local_id\` text,
+	\`seed_uid\` text,
+	\`seed_type\` text,
+	\`note\` text,
+	\`created_at\` integer,
+	\`updated_at\` integer,
+	\`attestation_created_at\` integer,
+	\`attestation_raw\` text
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`versions_local_id_unique\` ON \`versions\` (\`local_id\`);`;
+const migrationSql_0001_sweet_bruce_banner = `ALTER TABLE \`schemas\` ADD \`schema_data\` text;--> statement-breakpoint
+ALTER TABLE \`schemas\` ADD \`is_draft\` integer;`;
+const migrationSql_0002_bitter_proudstar = `CREATE UNIQUE INDEX \`unique_schema_file_id\` ON \`models\` (\`schema_file_id\`);--> statement-breakpoint
+CREATE UNIQUE INDEX \`unique_property_schema_file_id\` ON \`properties\` (\`schema_file_id\`);--> statement-breakpoint
+CREATE UNIQUE INDEX \`unique_schema_schema_file_id\` ON \`schemas\` (\`schema_file_id\`);`;
+const migrationSql_0003_cultured_senator_kelly = `ALTER TABLE \`models\` ADD \`is_edited\` integer;--> statement-breakpoint
+ALTER TABLE \`properties\` ADD \`is_edited\` integer;--> statement-breakpoint
+ALTER TABLE \`schemas\` ADD \`is_edited\` integer;`;
+const migrationSql_0004_add_publisher_to_seeds = `ALTER TABLE \`seeds\` ADD \`publisher\` text;`;
+const migrationSql_0005_bright_lily_hollister = `CREATE TABLE \`publish_processes\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`seed_local_id\` text NOT NULL,
+	\`model_name\` text NOT NULL,
+	\`schema_id\` text,
+	\`status\` text NOT NULL,
+	\`started_at\` integer NOT NULL,
+	\`completed_at\` integer,
+	\`error_message\` text,
+	\`error_step\` text,
+	\`error_details\` text,
+	\`persisted_snapshot\` text NOT NULL,
+	\`seed_id\` text,
+	\`existing_seed_uid\` text,
+	\`created_at\` integer,
+	\`updated_at\` integer
+);
+--> statement-breakpoint
+CREATE TABLE \`upload_processes\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`reimbursement_confirmed\` integer NOT NULL,
+	\`reimbursement_transaction_id\` text,
+	\`transaction_keys\` text,
+	\`persisted_snapshot\` text NOT NULL,
+	\`created_at\` integer,
+	\`updated_at\` integer
+);
+`;
+const migrationSql_0006_add_publisher_to_versions_and_metadata = `ALTER TABLE \`versions\` ADD \`publisher\` text;
+--> statement-breakpoint
+ALTER TABLE \`metadata\` ADD \`publisher\` text;
+`;
+const migrationSql_0007_add_required_to_properties = `ALTER TABLE \`properties\` ADD \`required\` integer DEFAULT 0;
+`;
+const migrationSql_0008_add_revoked_at_to_seeds = `ALTER TABLE \`seeds\` ADD \`revoked_at\` integer;
+`;
+const migrationSql_0009_happy_namor = `PRAGMA foreign_keys=OFF;--> statement-breakpoint
+CREATE TABLE \`__new_property_uids\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`uid\` text NOT NULL,
+	\`property_id\` integer NOT NULL,
+	FOREIGN KEY (\`property_id\`) REFERENCES \`properties\`(\`id\`) ON UPDATE no action ON DELETE no action
+);
+--> statement-breakpoint
+INSERT INTO \`__new_property_uids\`("id", "uid", "property_id") SELECT "id", "uid", "property_id" FROM \`property_uids\`;--> statement-breakpoint
+DROP TABLE \`property_uids\`;--> statement-breakpoint
+ALTER TABLE \`__new_property_uids\` RENAME TO \`property_uids\`;--> statement-breakpoint
+PRAGMA foreign_keys=ON;--> statement-breakpoint
+CREATE UNIQUE INDEX \`property_uids_property_id_unique\` ON \`property_uids\` (\`property_id\`);--> statement-breakpoint
+ALTER TABLE \`metadata\` ADD \`property_id\` integer REFERENCES properties(id);`;
+const migrationSql_0010_add_arweave_l1_finalize_jobs = `CREATE TABLE \`arweave_l1_finalize_jobs\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`seed_local_id\` text NOT NULL,
+	\`data_item_id\` text NOT NULL,
+	\`l1_transaction_id\` text,
+	\`bundle_id\` text,
+	\`version_local_id\` text,
+	\`item_property_name\` text,
+	\`phase\` text NOT NULL,
+	\`status_json\` text,
+	\`error_message\` text,
+	\`created_at\` integer NOT NULL,
+	\`updated_at\` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`arweave_l1_finalize_jobs_data_item_id_unique\` ON \`arweave_l1_finalize_jobs\` (\`data_item_id\`);
+`;
+const migrationSql_0011_normalize_placeholder_uids = `UPDATE \`versions\` SET \`uid\` = NULL WHERE \`uid\` = 'NULL';
+--> statement-breakpoint
+UPDATE \`versions\` SET \`seed_uid\` = NULL WHERE \`seed_uid\` = 'NULL';
+--> statement-breakpoint
+UPDATE \`metadata\` SET \`uid\` = NULL WHERE \`uid\` = 'NULL';
+--> statement-breakpoint
+UPDATE \`metadata\` SET \`version_uid\` = NULL WHERE \`version_uid\` = 'NULL';
+--> statement-breakpoint
+UPDATE \`seeds\` SET \`uid\` = NULL WHERE \`uid\` = 'NULL';
+`;
+const migrationSql_0012_html_embedded_image_co_publish = `CREATE TABLE \`html_embedded_image_co_publish\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`parent_seed_local_id\` text NOT NULL,
+	\`html_seed_local_id\` text NOT NULL,
+	\`image_seed_local_id\` text NOT NULL,
+	\`stable_key\` text NOT NULL,
+	\`created_at\` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`html_embed_co_pub_parent_html_stable\` ON \`html_embedded_image_co_publish\` (\`parent_seed_local_id\`,\`html_seed_local_id\`,\`stable_key\`);
+`;
+const migrationSql_0013_eas_sync_processes = `CREATE TABLE \`eas_sync_processes\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`status\` text NOT NULL,
+	\`started_at\` integer NOT NULL,
+	\`completed_at\` integer,
+	\`request_payload\` text NOT NULL,
+	\`error_message\` text,
+	\`error_details\` text,
+	\`persisted_snapshot\` text NOT NULL,
+	\`created_at\` integer,
+	\`updated_at\` integer
+);
+`;
+const migrationSql_0014_add_error_code_to_publish_processes = `ALTER TABLE \`publish_processes\` ADD \`error_code\` text;
+`;
+const migrationSql_0015_add_model_file_id_to_seeds = `ALTER TABLE \`seeds\` ADD \`model_file_id\` text;
+--> statement-breakpoint
+UPDATE \`seeds\` SET \`model_file_id\` = (
+	SELECT \`models\`.\`schema_file_id\`
+	FROM \`metadata\`
+	INNER JOIN \`properties\` ON \`properties\`.\`id\` = \`metadata\`.\`property_id\`
+	INNER JOIN \`models\` ON \`models\`.\`id\` = \`properties\`.\`model_id\`
+	WHERE \`metadata\`.\`seed_local_id\` = \`seeds\`.\`local_id\`
+		AND \`models\`.\`schema_file_id\` IS NOT NULL
+	LIMIT 1
+) WHERE \`model_file_id\` IS NULL;
+`;
+const migrationSql_0016_add_revoked_at_to_metadata = `ALTER TABLE \`metadata\` ADD \`revoked_at\` integer;
+`;
+const migrationSql_0017_add_revoked_at_to_versions = `ALTER TABLE \`versions\` ADD \`revoked_at\` integer;`;
+const migrationSql_0018_add_storage_settings_to_properties = `ALTER TABLE \`properties\` ADD \`storage_type\` text;
+--> statement-breakpoint
+ALTER TABLE \`properties\` ADD \`local_storage_dir\` text;
+--> statement-breakpoint
+ALTER TABLE \`properties\` ADD \`filename_suffix\` text;
+--> statement-breakpoint
+UPDATE \`properties\` SET (\`storage_type\`, \`local_storage_dir\`, \`filename_suffix\`) = (
+	SELECT
+		CASE
+			WHEN json_type(\`p\`.\`def\`, '$.storage') = 'object' THEN
+				CASE WHEN json_extract(\`p\`.\`def\`, '$.storage.type') = 'ItemStorage' THEN 'ItemStorage' ELSE 'PropertyStorage' END
+			ELSE json_extract(\`p\`.\`def\`, '$.storageType')
+		END,
+		CASE
+			WHEN json_type(\`p\`.\`def\`, '$.storage') = 'object' THEN json_extract(\`p\`.\`def\`, '$.storage.path')
+			ELSE json_extract(\`p\`.\`def\`, '$.localStorageDir')
+		END,
+		CASE
+			WHEN json_type(\`p\`.\`def\`, '$.storage') = 'object' THEN json_extract(\`p\`.\`def\`, '$.storage.extension')
+			ELSE json_extract(\`p\`.\`def\`, '$.filenameSuffix')
+		END
+	FROM (
+		SELECT json_extract(
+			\`schemas\`.\`schema_data\`,
+			'$.models."' || \`models\`.\`name\` || '".properties."' || \`properties\`.\`name\` || '"'
+		) AS \`def\`
+		FROM \`models\`
+		INNER JOIN \`model_schemas\` ON \`model_schemas\`.\`model_id\` = \`models\`.\`id\`
+		INNER JOIN \`schemas\` ON \`schemas\`.\`id\` = \`model_schemas\`.\`schema_id\`
+		WHERE \`models\`.\`id\` = \`properties\`.\`model_id\`
+			AND \`models\`.\`name\` NOT LIKE '%"%'
+			AND json_valid(\`schemas\`.\`schema_data\`)
+			AND json_type(
+				\`schemas\`.\`schema_data\`,
+				'$.models."' || \`models\`.\`name\` || '".properties."' || \`properties\`.\`name\` || '"'
+			) = 'object'
+		ORDER BY \`schemas\`.\`id\` DESC
+		LIMIT 1
+	) AS \`p\`
+) WHERE \`storage_type\` IS NULL
+	AND \`name\` NOT LIKE '%"%'
+	AND EXISTS (
+		SELECT 1 FROM \`models\`
+		INNER JOIN \`model_schemas\` ON \`model_schemas\`.\`model_id\` = \`models\`.\`id\`
+		INNER JOIN \`schemas\` ON \`schemas\`.\`id\` = \`model_schemas\`.\`schema_id\`
+		WHERE \`models\`.\`id\` = \`properties\`.\`model_id\`
+			AND \`models\`.\`name\` NOT LIKE '%"%'
+			AND json_valid(\`schemas\`.\`schema_data\`)
+			AND json_type(
+				\`schemas\`.\`schema_data\`,
+				'$.models."' || \`models\`.\`name\` || '".properties."' || \`properties\`.\`name\` || '"'
+			) = 'object'
+	);
+`;
+const migrationSql_0019_add_derived_from_uid_to_metadata = `ALTER TABLE \`metadata\` ADD \`derived_from_uid\` text;
+--> statement-breakpoint
+UPDATE \`metadata\` SET
+	\`derived_from_uid\` = (
+		SELECT \`source\`.\`uid\`
+		FROM \`metadata\` AS \`source\`
+		WHERE \`source\`.\`version_uid\` = \`metadata\`.\`version_uid\`
+			AND \`source\`.\`property_name\` = 'storageTransactionId'
+			AND \`source\`.\`uid\` IS NOT NULL
+			AND \`source\`.\`property_value\` = \`metadata\`.\`property_value\`
+		ORDER BY COALESCE(\`source\`.\`attestation_created_at\`, \`source\`.\`created_at\`) DESC
+		LIMIT 1
+	),
+	\`attestation_created_at\` = COALESCE(\`attestation_created_at\`, (
+		SELECT \`source\`.\`attestation_created_at\`
+		FROM \`metadata\` AS \`source\`
+		WHERE \`source\`.\`version_uid\` = \`metadata\`.\`version_uid\`
+			AND \`source\`.\`property_name\` = 'storageTransactionId'
+			AND \`source\`.\`uid\` IS NOT NULL
+			AND \`source\`.\`property_value\` = \`metadata\`.\`property_value\`
+		ORDER BY COALESCE(\`source\`.\`attestation_created_at\`, \`source\`.\`created_at\`) DESC
+		LIMIT 1
+	))
+WHERE \`uid\` IS NULL
+	AND \`ref_value_type\` = 'file'
+	AND \`version_uid\` IS NOT NULL
+	AND \`derived_from_uid\` IS NULL
+	AND EXISTS (
+		SELECT 1
+		FROM \`metadata\` AS \`source\`
+		WHERE \`source\`.\`version_uid\` = \`metadata\`.\`version_uid\`
+			AND \`source\`.\`property_name\` = 'storageTransactionId'
+			AND \`source\`.\`uid\` IS NOT NULL
+			AND \`source\`.\`property_value\` = \`metadata\`.\`property_value\`
+	);
+`;
+// Journal JSON file
+const journalJson = `{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1765976502903,
+      "tag": "0000_married_malice",
+      "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "6",
+      "when": 1766010851770,
+      "tag": "0001_sweet_bruce_banner",
+      "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "6",
+      "when": 1767621120087,
+      "tag": "0002_bitter_proudstar",
+      "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "6",
+      "when": 1768415440282,
+      "tag": "0003_cultured_senator_kelly",
+      "breakpoints": true
+    },
+    {
+      "idx": 4,
+      "version": "6",
+      "when": 1768500000000,
+      "tag": "0004_add_publisher_to_seeds",
+      "breakpoints": true
+    },
+    {
+      "idx": 5,
+      "version": "6",
+      "when": 1772489937031,
+      "tag": "0005_bright_lily_hollister",
+      "breakpoints": true
+    },
+    {
+      "idx": 6,
+      "version": "6",
+      "when": 1772600000000,
+      "tag": "0006_add_publisher_to_versions_and_metadata",
+      "breakpoints": true
+    },
+    {
+      "idx": 7,
+      "version": "6",
+      "when": 1772700000000,
+      "tag": "0007_add_required_to_properties",
+      "breakpoints": true
+    },
+    {
+      "idx": 8,
+      "version": "6",
+      "when": 1772800000000,
+      "tag": "0008_add_revoked_at_to_seeds",
+      "breakpoints": true
+    },
+    {
+      "idx": 9,
+      "version": "6",
+      "when": 1773924021107,
+      "tag": "0009_happy_namor",
+      "breakpoints": true
+    },
+    {
+      "idx": 10,
+      "version": "6",
+      "when": 1774000000000,
+      "tag": "0010_add_arweave_l1_finalize_jobs",
+      "breakpoints": true
+    },
+    {
+      "idx": 11,
+      "version": "6",
+      "when": 1774100000000,
+      "tag": "0011_normalize_placeholder_uids",
+      "breakpoints": true
+    },
+    {
+      "idx": 12,
+      "version": "6",
+      "when": 1774200000000,
+      "tag": "0012_html_embedded_image_co_publish",
+      "breakpoints": true
+    },
+    {
+      "idx": 13,
+      "version": "6",
+      "when": 1774300000000,
+      "tag": "0013_eas_sync_processes",
+      "breakpoints": true
+    },
+    {
+      "idx": 14,
+      "version": "6",
+      "when": 1774400000000,
+      "tag": "0014_add_error_code_to_publish_processes",
+      "breakpoints": true
+    },
+    {
+      "idx": 15,
+      "version": "6",
+      "when": 1774500000000,
+      "tag": "0015_add_model_file_id_to_seeds",
+      "breakpoints": true
+    },
+    {
+      "idx": 16,
+      "version": "6",
+      "when": 1774600000000,
+      "tag": "0016_add_revoked_at_to_metadata",
+      "breakpoints": true
+    },
+    {
+      "idx": 17,
+      "version": "6",
+      "when": 1774700000000,
+      "tag": "0017_add_revoked_at_to_versions",
+      "breakpoints": true
+    },
+    {
+      "idx": 18,
+      "version": "6",
+      "when": 1774800000000,
+      "tag": "0018_add_storage_settings_to_properties",
+      "breakpoints": true
+    },
+    {
+      "idx": 19,
+      "version": "6",
+      "when": 1774900000000,
+      "tag": "0019_add_derived_from_uid_to_metadata",
+      "breakpoints": true
+    }
+  ]
+}`;
+// Snapshot JSON file - this is large, so we'll import it dynamically if needed
+// For now, we'll read it from the actual file if ?raw works, otherwise we'll need to embed it
+const snapshotJson = `{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "dd5a777b-e1a9-4b35-82c6-b0c2c7a8ef4d",
+  "prevId": "ab739b16-741c-4ac4-b3bc-a894ef2582a1",
+  "tables": {
+    "appState": {
+      "name": "appState",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "appState_key_unique": {
+          "name": "appState_key_unique",
+          "columns": [
+            "key"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "arweave_l1_finalize_jobs": {
+      "name": "arweave_l1_finalize_jobs",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "seed_local_id": {
+          "name": "seed_local_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "data_item_id": {
+          "name": "data_item_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "l1_transaction_id": {
+          "name": "l1_transaction_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "bundle_id": {
+          "name": "bundle_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "version_local_id": {
+          "name": "version_local_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "item_property_name": {
+          "name": "item_property_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "phase": {
+          "name": "phase",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status_json": {
+          "name": "status_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "arweave_l1_finalize_jobs_data_item_id_unique": {
+          "name": "arweave_l1_finalize_jobs_data_item_id_unique",
+          "columns": [
+            "data_item_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "config": {
+      "name": "config",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "text": {
+          "name": "text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "json": {
+          "name": "json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "blob": {
+          "name": "blob",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "eas_sync_processes": {
+      "name": "eas_sync_processes",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "request_payload": {
+          "name": "request_payload",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "error_details": {
+          "name": "error_details",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "persisted_snapshot": {
+          "name": "persisted_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "html_embedded_image_co_publish": {
+      "name": "html_embedded_image_co_publish",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "parent_seed_local_id": {
+          "name": "parent_seed_local_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "html_seed_local_id": {
+          "name": "html_seed_local_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "image_seed_local_id": {
+          "name": "image_seed_local_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "stable_key": {
+          "name": "stable_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "html_embed_co_pub_parent_html_stable": {
+          "name": "html_embed_co_pub_parent_html_stable",
+          "columns": [
+            "parent_seed_local_id",
+            "html_seed_local_id",
+            "stable_key"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "metadata": {
+      "name": "metadata",
+      "columns": {
+        "local_id": {
+          "name": "local_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "uid": {
+          "name": "uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "property_id": {
+          "name": "property_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "property_name": {
+          "name": "property_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "property_value": {
+          "name": "property_value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "schema_uid": {
+          "name": "schema_uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "model_type": {
+          "name": "model_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "seed_local_id": {
+          "name": "seed_local_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "seed_uid": {
+          "name": "seed_uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "version_local_id": {
+          "name": "version_local_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "version_uid": {
+          "name": "version_uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "eas_data_type": {
+          "name": "eas_data_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "ref_value_type": {
+          "name": "ref_value_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "ref_schema_uid": {
+          "name": "ref_schema_uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "ref_seed_type": {
+          "name": "ref_seed_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "ref_resolved_value": {
+          "name": "ref_resolved_value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "ref_resolved_display_value": {
+          "name": "ref_resolved_display_value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "local_storage_dir": {
+          "name": "local_storage_dir",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "attestation_raw": {
+          "name": "attestation_raw",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "attestation_created_at": {
+          "name": "attestation_created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "content_hash": {
+          "name": "content_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "publisher": {
+          "name": "publisher",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "revoked_at": {
+          "name": "revoked_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "derived_from_uid": {
+          "name": "derived_from_uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "metadata_local_id_unique": {
+          "name": "metadata_local_id_unique",
+          "columns": [
+            "local_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "metadata_property_id_properties_id_fk": {
+          "name": "metadata_property_id_properties_id_fk",
+          "tableFrom": "metadata",
+          "tableTo": "properties",
+          "columnsFrom": [
+            "property_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "models": {
+      "name": "models",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "schema_file_id": {
+          "name": "schema_file_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_edited": {
+          "name": "is_edited",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "unique_schema_file_id": {
+          "name": "unique_schema_file_id",
+          "columns": [
+            "schema_file_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "properties": {
+      "name": "properties",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "data_type": {
+          "name": "data_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "model_id": {
+          "name": "model_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "ref_model_id": {
+          "name": "ref_model_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "ref_value_type": {
+          "name": "ref_value_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "schema_file_id": {
+          "name": "schema_file_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_edited": {
+          "name": "is_edited",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "required": {
+          "name": "required",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "storage_type": {
+          "name": "storage_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "local_storage_dir": {
+          "name": "local_storage_dir",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "filename_suffix": {
+          "name": "filename_suffix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "unique_name_model_id": {
+          "name": "unique_name_model_id",
+          "columns": [
+            "name",
+            "model_id"
+          ],
+          "isUnique": true
+        },
+        "unique_property_schema_file_id": {
+          "name": "unique_property_schema_file_id",
+          "columns": [
+            "schema_file_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "properties_model_id_models_id_fk": {
+          "name": "properties_model_id_models_id_fk",
+          "tableFrom": "properties",
+          "tableTo": "models",
+          "columnsFrom": [
+            "model_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "properties_ref_model_id_models_id_fk": {
+          "name": "properties_ref_model_id_models_id_fk",
+          "tableFrom": "properties",
+          "tableTo": "models",
+          "columnsFrom": [
+            "ref_model_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "model_schemas": {
+      "name": "model_schemas",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "model_id": {
+          "name": "model_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "schema_id": {
+          "name": "schema_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "model_schemas_model_id_models_id_fk": {
+          "name": "model_schemas_model_id_models_id_fk",
+          "tableFrom": "model_schemas",
+          "tableTo": "models",
+          "columnsFrom": [
+            "model_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "model_schemas_schema_id_schemas_id_fk": {
+          "name": "model_schemas_schema_id_schemas_id_fk",
+          "tableFrom": "model_schemas",
+          "tableTo": "schemas",
+          "columnsFrom": [
+            "schema_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "model_uids": {
+      "name": "model_uids",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "uid": {
+          "name": "uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "model_id": {
+          "name": "model_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "model_uids_model_id_unique": {
+          "name": "model_uids_model_id_unique",
+          "columns": [
+            "model_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "model_uids_model_id_models_id_fk": {
+          "name": "model_uids_model_id_models_id_fk",
+          "tableFrom": "model_uids",
+          "tableTo": "models",
+          "columnsFrom": [
+            "model_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "property_uids": {
+      "name": "property_uids",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "uid": {
+          "name": "uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "property_id": {
+          "name": "property_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "property_uids_property_id_unique": {
+          "name": "property_uids_property_id_unique",
+          "columns": [
+            "property_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "property_uids_property_id_properties_id_fk": {
+          "name": "property_uids_property_id_properties_id_fk",
+          "tableFrom": "property_uids",
+          "tableTo": "properties",
+          "columnsFrom": [
+            "property_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "publish_processes": {
+      "name": "publish_processes",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "seed_local_id": {
+          "name": "seed_local_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "model_name": {
+          "name": "model_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "schema_id": {
+          "name": "schema_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "error_step": {
+          "name": "error_step",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "error_details": {
+          "name": "error_details",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "error_code": {
+          "name": "error_code",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "persisted_snapshot": {
+          "name": "persisted_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "seed_id": {
+          "name": "seed_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "existing_seed_uid": {
+          "name": "existing_seed_uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "schemas": {
+      "name": "schemas",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "version": {
+          "name": "version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "schema_file_id": {
+          "name": "schema_file_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "schema_data": {
+          "name": "schema_data",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_draft": {
+          "name": "is_draft",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_edited": {
+          "name": "is_edited",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "unique_schema_schema_file_id": {
+          "name": "unique_schema_schema_file_id",
+          "columns": [
+            "schema_file_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "seeds": {
+      "name": "seeds",
+      "columns": {
+        "local_id": {
+          "name": "local_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "uid": {
+          "name": "uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "schema_uid": {
+          "name": "schema_uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "model_file_id": {
+          "name": "model_file_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "publisher": {
+          "name": "publisher",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "attestation_raw": {
+          "name": "attestation_raw",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "attestation_created_at": {
+          "name": "attestation_created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "_marked_for_deletion": {
+          "name": "_marked_for_deletion",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "revoked_at": {
+          "name": "revoked_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "seeds_local_id_unique": {
+          "name": "seeds_local_id_unique",
+          "columns": [
+            "local_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "upload_processes": {
+      "name": "upload_processes",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "reimbursement_confirmed": {
+          "name": "reimbursement_confirmed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "reimbursement_transaction_id": {
+          "name": "reimbursement_transaction_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "transaction_keys": {
+          "name": "transaction_keys",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "persisted_snapshot": {
+          "name": "persisted_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "versions": {
+      "name": "versions",
+      "columns": {
+        "local_id": {
+          "name": "local_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "uid": {
+          "name": "uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "seed_local_id": {
+          "name": "seed_local_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "seed_uid": {
+          "name": "seed_uid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "seed_type": {
+          "name": "seed_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "attestation_created_at": {
+          "name": "attestation_created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "attestation_raw": {
+          "name": "attestation_raw",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "publisher": {
+          "name": "publisher",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "revoked_at": {
+          "name": "revoked_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "versions_local_id_unique": {
+          "name": "versions_local_id_unique",
+          "columns": [
+            "local_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}`;
+
+var drizzleFiles = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    journalJson: journalJson,
+    migrationSql_0000_married_malice: migrationSql_0000_married_malice,
+    migrationSql_0001_sweet_bruce_banner: migrationSql_0001_sweet_bruce_banner,
+    migrationSql_0002_bitter_proudstar: migrationSql_0002_bitter_proudstar,
+    migrationSql_0003_cultured_senator_kelly: migrationSql_0003_cultured_senator_kelly,
+    migrationSql_0004_add_publisher_to_seeds: migrationSql_0004_add_publisher_to_seeds,
+    migrationSql_0005_bright_lily_hollister: migrationSql_0005_bright_lily_hollister,
+    migrationSql_0006_add_publisher_to_versions_and_metadata: migrationSql_0006_add_publisher_to_versions_and_metadata,
+    migrationSql_0007_add_required_to_properties: migrationSql_0007_add_required_to_properties,
+    migrationSql_0008_add_revoked_at_to_seeds: migrationSql_0008_add_revoked_at_to_seeds,
+    migrationSql_0009_happy_namor: migrationSql_0009_happy_namor,
+    migrationSql_0010_add_arweave_l1_finalize_jobs: migrationSql_0010_add_arweave_l1_finalize_jobs,
+    migrationSql_0011_normalize_placeholder_uids: migrationSql_0011_normalize_placeholder_uids,
+    migrationSql_0012_html_embedded_image_co_publish: migrationSql_0012_html_embedded_image_co_publish,
+    migrationSql_0013_eas_sync_processes: migrationSql_0013_eas_sync_processes,
+    migrationSql_0014_add_error_code_to_publish_processes: migrationSql_0014_add_error_code_to_publish_processes,
+    migrationSql_0015_add_model_file_id_to_seeds: migrationSql_0015_add_model_file_id_to_seeds,
+    migrationSql_0016_add_revoked_at_to_metadata: migrationSql_0016_add_revoked_at_to_metadata,
+    migrationSql_0017_add_revoked_at_to_versions: migrationSql_0017_add_revoked_at_to_versions,
+    migrationSql_0018_add_storage_settings_to_properties: migrationSql_0018_add_storage_settings_to_properties,
+    migrationSql_0019_add_derived_from_uid_to_metadata: migrationSql_0019_add_derived_from_uid_to_metadata,
+    snapshotJson: snapshotJson
+});
+
+/**
+ * Build drizzle migration metadata from embedded SQL strings.
+ * Avoids `drizzle-orm/migrator` (Node fs / path / crypto) on the browser graph.
+ */
+function getEmbeddedMigrations() {
+    const journal = JSON.parse(journalJson);
+    const entries = journal.entries ?? [];
+    return entries.map((entry) => {
+        const varName = `migrationSql_${entry.tag}`;
+        const query = drizzleFiles[varName];
+        if (typeof query !== 'string') {
+            throw new Error(`No embedded migration content for ${entry.tag}`);
+        }
+        const trimmed = query.trim();
+        return {
+            sql: trimmed.split('--> statement-breakpoint'),
+            bps: Boolean(entry.breakpoints),
+            folderMillis: entry.when,
+            hash: bytesToHex(sha256(utf8ToBytes(trimmed))),
+        };
+    });
+}
+/** SQLite ignores `PRAGMA foreign_keys` inside a transaction, so such migrations must run outside one. */
+function canRunInTransaction(migration) {
+    return !migration.sql.some((query) => /^\s*PRAGMA\s+foreign_keys\b/im.test(query));
+}
+/**
+ * Same apply loop as drizzle-orm/sqlite-proxy/migrator, with in-memory migrations. Callers sharing
+ * the database across tabs must hold a cross-tab lock: the read of the last applied migration and
+ * the writes that follow aren't atomic.
+ */
+async function applyEmbeddedMigrations(db, migrations, migrationsTable = '__drizzle_migrations', runMigration) {
+    await db.run(sql `
+		CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
+			id SERIAL PRIMARY KEY,
+			hash text NOT NULL,
+			created_at numeric
+		)
+	`);
+    const dbMigrations = await db.values(sql `SELECT id, hash, created_at FROM ${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`);
+    const lastDbMigration = dbMigrations[0] ?? undefined;
+    const runSequentially = async (queries) => {
+        for (const query of queries) {
+            await db.run(sql.raw(query));
+        }
+    };
+    for (const migration of migrations) {
+        if (!lastDbMigration || Number(lastDbMigration[2]) < migration.folderMillis) {
+            const queries = [
+                ...migration.sql,
+                `INSERT INTO \`${migrationsTable}\` ("hash", "created_at") VALUES('${migration.hash}', '${migration.folderMillis}')`,
+            ];
+            await (runMigration ?? runSequentially)(queries, migration);
+        }
+    }
+}
+
+const logger$3 = debug('seedSdk:browser:db:sqliteBusyRetry');
+/** Waits between attempts; about 1 s in total. */
+const SQLITE_BUSY_RETRY_DELAYS_MS = [25, 75, 150, 300, 450];
+/**
+ * Another connection (usually another tab) holds the database lock. SQLite reports this as
+ * SQLITE_BUSY ("database is locked") or SQLITE_LOCKED ("database table is locked").
+ */
+function isSqliteBusyError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /SQLITE_BUSY|SQLITE_LOCKED|database (table )?is locked/i.test(message);
+}
+/**
+ * Retries a statement another tab's lock rejected. Safe for the SDK's writes because each is a
+ * single autocommit statement: one that failed with SQLITE_BUSY didn't apply. Don't use this for
+ * statements inside a transaction, where a retry would replay part of it.
+ */
+function withSqliteBusyRetry(driver, delaysMs = SQLITE_BUSY_RETRY_DELAYS_MS) {
+    return async (...args) => {
+        for (let attempt = 0;; attempt++) {
+            try {
+                return await driver(...args);
+            }
+            catch (error) {
+                if (!isSqliteBusyError(error) || attempt >= delaysMs.length)
+                    throw error;
+                logger$3(`database busy (attempt ${attempt + 1}); retrying`);
+                await new Promise((resolve) => setTimeout(resolve, delaysMs[attempt]));
+            }
+        }
+    };
+}
+
+const logger$2 = debug('seedSdk:browser:db:createSqlocalDrizzle');
+/** First sqlocal work can include sqlite-wasm fetch; keep this long to avoid false positives. */
+const SQLOCAL_FIRST_QUERY_TIMEOUT_MS = 90000;
+const HTTP_MODULE_WORKER_URL = /^https?:/i;
+function shouldBlobWrapModuleWorker(scriptURL, options) {
+    const type = options?.type ?? 'classic';
+    if (type !== 'module')
+        return false;
+    return HTTP_MODULE_WORKER_URL.test(String(scriptURL));
+}
+function createBlobModuleWorkerSource(scriptURL) {
+    return `import ${JSON.stringify(String(scriptURL))};`;
+}
+/**
+ * Construct SQLocal while starting its HTTPS module worker from a blob that
+ * only imports the bundled worker URL. Some Chrome profiles kill
+ * `new Worker(https://…/worker-HASH.js, { type: 'module' })` as an entry
+ * script; importing the same URL from a blob worker reaches connect.
+ *
+ * The `Worker` patch is scoped to `factory()` so Vite still sees sqlocal's
+ * own `new Worker(new URL('./worker', import.meta.url))` and emits a real
+ * worker chunk.
+ */
+function createSqlocalDrizzle(factory) {
+    let rejectFailed;
+    const workerFailed = new Promise((_, reject) => {
+        rejectFailed = reject;
+    });
+    // Avoid an unhandled rejection if the caller throws before racing this promise.
+    workerFailed.catch(() => { });
+    const restore = installModuleWorkerBlobWrap((error) => {
+        rejectFailed?.(error);
+    });
+    try {
+        return { instance: factory(), workerFailed };
+    }
+    finally {
+        restore();
+    }
+}
+async function raceSqlocalStartup(work, workerFailed, timeoutMs = SQLOCAL_FIRST_QUERY_TIMEOUT_MS) {
+    let timeoutId;
+    const timedOut = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+            reject(new Error(`sqlocal database failed to become ready within ${timeoutMs}ms`));
+        }, timeoutMs);
+    });
+    try {
+        return await Promise.race([work, workerFailed, timedOut]);
+    }
+    finally {
+        if (timeoutId !== undefined) {
+            clearTimeout(timeoutId);
+        }
+    }
+}
+function installModuleWorkerBlobWrap(onWorkerFailed) {
+    const OriginalWorker = globalThis.Worker;
+    if (typeof OriginalWorker === 'undefined') {
+        return () => { };
+    }
+    function WrappedWorker(scriptURL, options) {
+        const worker = shouldBlobWrapModuleWorker(scriptURL, options)
+            ? new OriginalWorker(URL.createObjectURL(new Blob([createBlobModuleWorkerSource(scriptURL)], {
+                type: 'text/javascript',
+            })), { ...options, type: 'module' })
+            : new OriginalWorker(scriptURL, options);
+        const fail = (event) => {
+            const filename = 'filename' in event && typeof event.filename === 'string'
+                ? event.filename
+                : '';
+            const message = 'message' in event && typeof event.message === 'string'
+                ? event.message
+                : event.type;
+            const error = new Error(filename
+                ? `sqlocal worker failed to start (${event.type}): ${message} [${filename}]`
+                : `sqlocal worker failed to start (${event.type}): ${message}`);
+            logger$2('[createSqlocalDrizzle] worker failed', error.message);
+            onWorkerFailed(error);
+        };
+        worker.addEventListener('error', fail);
+        worker.addEventListener('messageerror', fail);
+        return worker;
+    }
+    WrappedWorker.prototype = OriginalWorker.prototype;
+    Object.setPrototypeOf(WrappedWorker, OriginalWorker);
+    globalThis.Worker = WrappedWorker;
+    return () => {
+        globalThis.Worker = OriginalWorker;
+    };
+}
+
+const logger$1 = debug('seedSdk:browser:db:Db');
+class BrowserDb {
+    getAppDb() {
+        return this.appDb;
+    }
+    isAppDbReady() {
+        return !!this.appDb;
+    }
+    async prepareDb(filesDir) {
+        logger$1('[Db.prepareDb] preparing database');
+        this.filesDir = filesDir;
+        // Another tab may be preparing the same database: run file copies, migrations and the
+        // one-time data fixes one tab at a time. See docs/MULTI_TAB.md.
+        return withSeedDbLock('migrate', filesDir, () => this.prepareDbLocked(filesDir));
+    }
+    async prepareDbLocked(filesDir) {
+        try {
+            // Copy drizzle migration files from src/db/drizzle to filesDir/db
+            await this.copyDrizzleFiles(filesDir);
+            // Ensure meta directory exists
+            const metaDirPath = `${filesDir}/db/meta`;
+            await BaseFileManager.createDirIfNotExists(metaDirPath);
+            // Ensure _journal.json file exists in meta directory
+            const journalFilePath = `${metaDirPath}/_journal.json`;
+            const journalExists = await BaseFileManager.pathExists(journalFilePath);
+            if (!journalExists) {
+                await BaseFileManager.saveFile(journalFilePath, JSON.stringify({
+                    version: 1,
+                    dialect: 'sqlite',
+                    entries: [],
+                }, null, 2));
+            }
+            // Wait for journal file to be fully written before proceeding with migration
+            // This is critical in browser/OPFS where writes may not be immediately readable
+            logger$1('[Db.prepareDb] waiting for journal file to be fully written...');
+            await BaseFileManager.waitForFileWithContent(journalFilePath, 100, 5000);
+            logger$1('[Db.prepareDb] journal file is ready');
+            // Initialize SQLocalDrizzle with reactive: true to enable reactive queries.
+            // Blob-wrap sqlocal's HTTPS module worker so Chrome profiles that kill
+            // `new Worker(https://…/worker-HASH.js, { type: 'module' })` as an entry
+            // still reach connect via `import` of the same URL.
+            const { instance: sqlocalDrizzle, workerFailed } = createSqlocalDrizzle(() => new SQLocalDrizzle({
+                databasePath: `${this.filesDir}/db/seed.db`,
+                reactive: true,
+            }));
+            const { batchDriver } = sqlocalDrizzle;
+            const driver = withSqliteBusyRetry(sqlocalDrizzle.driver);
+            // Store SQLocalDrizzle instance for reactive queries
+            this.sqlocalInstance = sqlocalDrizzle;
+            // Create db instance but do NOT set this.appDb yet. restoreFromDb (and other
+            // callers of getAppDb()) must not see the db until migrations have completed,
+            // otherwise they may query tables (e.g. publish_processes) that don't exist yet.
+            const db = drizzle(driver, batchDriver, {
+                schema,
+            });
+            logger$1('[Db.prepareDb] database prepared');
+            await raceSqlocalStartup((async () => {
+                await this.runMigrations(db);
+                this.appDb = db;
+                const { backfillMetadataPropertyIds } = await import('./backfillMetadataPropertyIds-fG3ujaSh.js');
+                await backfillMetadataPropertyIds();
+                // One-time: clear item data whose model can't be determined (seeds.model_file_id, migration 0015)
+                const { resetAmbiguousLegacyItemData } = await import('./resetAmbiguousLegacyItemData-BqbHNUYk.js');
+                await resetAmbiguousLegacyItemData();
+            })(), workerFailed);
+            return this.appDb;
+        }
+        catch (error) {
+            logger$1('[Db.prepareDb] error', JSON.stringify(error));
+            throw error;
+        }
+    }
+    // static async prepareDb(filesDir: string) {
+    //   console.log('prepareDb', filesDir)
+    //   if (Db.sqliteWasmClient) {
+    //     return this.dbId
+    //   }
+    //   this.filesDir = filesDir
+    //   this.pathToDb = `${filesDir}/db/${DB_NAME_APP}.db`
+    //   if (typeof document === 'undefined') {
+    //     return
+    //   }
+    //   let promiser
+    //   try {
+    //       let sqlite3Worker1Promiser
+    //       const sqliteWasm = await import('@sqlite.org/sqlite-wasm')
+    //       if (sqliteWasm && sqliteWasm.sqlite3Worker1Promiser) {
+    //         sqlite3Worker1Promiser = sqliteWasm.sqlite3Worker1Promiser
+    //       }
+    //       if (!sqlite3Worker1Promiser && window.sqlite3Worker1Promiser) {
+    //         sqlite3Worker1Promiser = window.sqlite3Worker1Promiser
+    //       }
+    //       if (!sqlite3Worker1Promiser) {
+    //         throw new Error('Failed to load sqlite3Worker1Promiser')
+    //       }
+    //       promiser = await new Promise<(event: string, config: Record<string, unknown>) => Promise<any>>((resolve) => {
+    //         const _promiser = sqlite3Worker1Promiser({
+    //           onready: () => {
+    //             resolve(_promiser);
+    //           },
+    //         });
+    //       }).catch((error) => {
+    //         console.error('Error from sqlite proxy server: ', JSON.stringify(error))
+    //       });
+    //   } catch ( e ) {
+    //     console.error('Error from sqlite proxy server: ', JSON.stringify(e))
+    //   }
+    //   if (!promiser) {
+    //     throw new Error('Failed to create promiser')
+    //   }
+    //   this.sqliteWasmClient = promiser
+    //   const responseGet = await this.sqliteWasmClient('config-get', {});
+    //   logger('[Db.prepareDb] Running SQLite3 version', responseGet.result.version.libVersion);
+    //   const responseOpen = await this.sqliteWasmClient('open', {
+    //     filename: `file:${filesDir}/db/${DB_NAME_APP}.db?vfs=opfs`,
+    //   });
+    //   const { dbId } = responseOpen;
+    //   logger(
+    //     '[Db.prepareDb] OPFS is available, created persisted database at',
+    //     responseOpen.result.filename.replace(/^file:(.*?)\?vfs=opfs/, '$1'),
+    //   );
+    //   logger('[Db.prepareDb] dbId', dbId)
+    //   this.dbId = dbId
+    //   await this.migrate()
+    // }
+    async connectToDb(filesDir) {
+        return this.dbId;
+    }
+    async copyDrizzleFiles(filesDir) {
+        logger$1('[Db.copyDrizzleFiles] copying drizzle migration files');
+        try {
+            // Ensure db directory exists
+            const dbDirPath = `${filesDir}/db`;
+            await BaseFileManager.createDirIfNotExists(dbDirPath);
+            // Ensure meta directory exists
+            const metaDirPath = `${dbDirPath}/meta`;
+            await BaseFileManager.createDirIfNotExists(metaDirPath);
+            // Parse journal JSON to get all migration entries
+            const journal = JSON.parse(journalJson);
+            const entries = journal.entries || [];
+            if (entries.length === 0) {
+                logger$1('[Db.copyDrizzleFiles] no migration entries found in journal');
+                return;
+            }
+            // Copy each migration SQL file (always overwrite to ensure they're up-to-date)
+            // Each migration is exported as a separate variable (e.g., migrationSql_0000_married_malice)
+            for (let i = 0; i < entries.length; i++) {
+                const entry = entries[i];
+                const tag = entry.tag; // e.g., "0000_married_malice"
+                const migrationFileName = `${tag}.sql`;
+                const migrationPath = `${dbDirPath}/${migrationFileName}`;
+                // Get the SQL for this migration from the exported variable
+                const migrationVarName = `migrationSql_${tag}`;
+                const migrationContent = drizzleFiles[migrationVarName];
+                if (!migrationContent) {
+                    logger$1(`[Db.copyDrizzleFiles] ERROR: No migration content found for ${migrationFileName} (variable: ${migrationVarName})`);
+                    throw new Error(`No migration content found for ${migrationFileName}. Expected variable: ${migrationVarName}`);
+                }
+                await BaseFileManager.saveFile(migrationPath, migrationContent.trim());
+                logger$1(`[Db.copyDrizzleFiles] copied/updated migration SQL file: ${migrationFileName}`);
+            }
+            // Copy journal JSON file (always overwrite to ensure it's up-to-date with all migrations)
+            const journalPath = `${metaDirPath}/_journal.json`;
+            await BaseFileManager.saveFile(journalPath, journalJson);
+            logger$1('[Db.copyDrizzleFiles] copied/updated journal JSON file');
+            // Copy snapshot JSON file (use the latest snapshot based on the highest idx in journal)
+            // Snapshot files are named like: 0000_snapshot.json, 0001_snapshot.json, etc.
+            // The tag format is like "0000_married_malice", so we extract the numeric prefix
+            const latestEntry = entries[entries.length - 1];
+            const tagPrefixMatch = latestEntry.tag.match(/^(\d+_)/);
+            const tagPrefix = tagPrefixMatch ? tagPrefixMatch[1] : '0000_';
+            const snapshotFileName = `${tagPrefix}snapshot.json`;
+            const snapshotPath = `${metaDirPath}/${snapshotFileName}`;
+            // Always overwrite snapshot to ensure it's up-to-date
+            await BaseFileManager.saveFile(snapshotPath, snapshotJson);
+            logger$1(`[Db.copyDrizzleFiles] copied/updated snapshot JSON file: ${snapshotFileName}`);
+            logger$1('[Db.copyDrizzleFiles] drizzle files copied successfully');
+        }
+        catch (error) {
+            logger$1('[Db.copyDrizzleFiles] error copying drizzle files', error);
+            // Don't throw - the files might already exist or migration might work without them
+            // The migration will fail later if the files are truly needed
+        }
+    }
+    /** Internal migration runner. Used by prepareDb before appDb is set. */
+    async runMigrations(db, _pathToDbDir) {
+        try {
+            const migrations = getEmbeddedMigrations();
+            logger$1('[Db.runMigrations] embedded migrations', migrations.length);
+            await applyEmbeddedMigrations(db, migrations, undefined, (queries, migration) => this.runMigrationQueries(db, queries, canRunInTransaction(migration)));
+            logger$1('[Db.runMigrations] migrations completed');
+        }
+        catch (error) {
+            logger$1('[Db.runMigrations] error', JSON.stringify(error));
+            throw error;
+        }
+    }
+    /** Applies a migration atomically through SQLocal's transaction (exclusive across tabs) when SQLite allows. */
+    async runMigrationQueries(db, queries, atomic) {
+        const statements = queries.filter((query) => query.trim() !== '');
+        if (!atomic || !this.sqlocalInstance) {
+            for (const query of statements) {
+                await db.run(sql.raw(query));
+            }
+            return;
+        }
+        await this.sqlocalInstance.transaction(async (tx) => {
+            for (const query of statements) {
+                await tx.query({ sql: query, params: [] });
+            }
+        });
+    }
+    async migrate(pathToDbDir, _dbName, _dbId) {
+        const targetDb = this.appDb;
+        if (!targetDb) {
+            throw new Error('Database not prepared');
+        }
+        await this.runMigrations(targetDb, pathToDbDir);
+    }
+    // Legacy commented migrate/exec implementation archived at
+    // docs/archive/commented/browser-Db-legacy-migrate.ts.txt
+    /**
+     * Execute a reactive query that emits new results whenever the underlying data changes.
+     *
+     * Supports two usage patterns:
+     * 1. SQL tag function: liveQuery((sql) => sql`SELECT * FROM models`)
+     * 2. Drizzle query builder: liveQuery(db.select().from(models))
+     *
+     * @param query - SQL query function or Drizzle query builder
+     * @returns Observable that emits arrays of query results
+     *
+     * @example
+     * ```typescript
+     * // Using SQL tag function
+     * const models$ = Db.liveQuery<ModelRow>(
+     *   (sql) => sql`SELECT * FROM models WHERE schema_file_id = ${schemaId}`
+     * )
+     *
+     * // Using Drizzle query builder
+     * const models$ = Db.liveQuery<ModelRow>(
+     *   appDb.select().from(models).where(eq(models.schemaFileId, schemaId))
+     * )
+     *
+     * models$.subscribe(models => {
+     *   console.log('Models updated:', models)
+     * })
+     * ```
+     */
+    liveQuery(query) {
+        if (!this.sqlocalInstance) {
+            throw new Error('Database not initialized. Call prepareDb first.');
+        }
+        if (!this.sqlocalInstance.reactiveQuery) {
+            throw new Error('Reactive queries not enabled. Initialize SQLocalDrizzle with reactive: true.');
+        }
+        const baseObservable = new Observable((subscriber) => {
+            const reactiveQueryResult = this.sqlocalInstance.reactiveQuery(query);
+            const subscription = reactiveQueryResult.subscribe((data) => {
+                subscriber.next(data);
+            }, (err) => {
+                console.error('[BaseDb.liveQuery] SQLocal reactiveQuery error:', err);
+                subscriber.error(err);
+            });
+            return () => {
+                subscription.unsubscribe();
+            };
+        });
+        // Compare stable JSON snapshots via keySelector. SQLocal may reuse one array reference
+        // and mutate rows in place; comparing (prev, curr) on the same reference makes
+        // JSON.stringify(prev) === JSON.stringify(curr) after mutation and suppresses emissions.
+        return baseObservable.pipe(distinctUntilChanged((a, b) => a === b, (x) => JSON.stringify(x)));
+    }
+}
+BaseDb.configure(new BrowserDb());
+
+const logger = debug("seedSdk:browser:ArweaveClient");
+// Cached Arweave instance (keyed by gateway so setHost / protocol changes apply)
+let _arweaveInstance = null;
+let _arweaveGatewayKey = null;
+/**
+ * Get or create the Arweave instance for browser
+ */
+const getArweaveInstance = () => {
+    const gatewayKey = `${BaseArweaveClient.getProtocol()}://${BaseArweaveClient.getHost()}`;
+    if (_arweaveInstance && _arweaveGatewayKey === gatewayKey) {
+        return _arweaveInstance;
+    }
+    _arweaveGatewayKey = gatewayKey;
+    const apiConfig = BaseArweaveClient.getArweaveJsApiConfig();
+    // Handle both ES modules and CommonJS exports from arweave package
+    if ("default" in Arweave && typeof Arweave.default?.init === "function") {
+        _arweaveInstance = Arweave.default.init(apiConfig);
+    }
+    else {
+        _arweaveInstance = Arweave.init(apiConfig);
+    }
+    return _arweaveInstance;
+};
+class BrowserArweaveClient {
+    getArweaveClient() {
+        return new GraphQLClient(BaseArweaveClient.getEndpoint());
+    }
+    async getTransactionStatus(transactionId) {
+        const url = BaseArweaveClient.getStatusUrl(transactionId);
+        try {
+            const response = await fetch(url);
+            if (response.status === 404) {
+                return {
+                    status: 404,
+                    confirmed: null,
+                };
+            }
+            if (!response.ok) {
+                return {
+                    status: response.status,
+                    confirmed: null,
+                };
+            }
+            if (response.body) {
+                await response.body.cancel();
+            }
+            return {
+                status: 200,
+                confirmed: null,
+            };
+        }
+        catch (error) {
+            logger("Error fetching transaction status:", error);
+            return {
+                status: 500,
+                confirmed: null,
+            };
+        }
+    }
+    async getTransactionData(transactionId, options) {
+        // Preferred gateways (usually the one the item was uploaded through) serve it before L1 does.
+        // `/raw` is already decoded, so skip them when the caller asked for undecoded data.
+        const preferred = options?.decode === false ? [] : getPreferredArweaveReadBaseUrls();
+        for (const base of preferred) {
+            const response = await fetchArweaveRawFromBaseUrl(base, transactionId);
+            if (!response)
+                continue;
+            try {
+                if (options?.string) {
+                    return await response.text();
+                }
+                return new Uint8Array(await response.arrayBuffer());
+            }
+            catch (error) {
+                logger("Error reading preferred gateway response:", error);
+            }
+        }
+        // Path-prefixed proxies (app-server Hyper proxy) are not supported by arweave.init host;
+        // fetch via getRawUrl so /api/seed-gateway/... works.
+        if (BaseArweaveClient.getGatewayPath()) {
+            const response = await fetch(BaseArweaveClient.getRawUrl(transactionId));
+            if (!response.ok) {
+                throw new Error(`Failed to fetch transaction data: HTTP ${response.status}`);
+            }
+            if (options?.string) {
+                return response.text();
+            }
+            return new Uint8Array(await response.arrayBuffer());
+        }
+        const arweave = getArweaveInstance();
+        try {
+            const data = await arweave.transactions.getData(transactionId, {
+                decode: options?.decode ?? true,
+                string: options?.string ?? false,
+            });
+            if (options?.string && typeof data === "string") {
+                return data;
+            }
+            // Ensure we return Uint8Array
+            if (data instanceof Uint8Array) {
+                return data;
+            }
+            // Handle string data when not requesting string
+            if (typeof data === "string") {
+                return new TextEncoder().encode(data);
+            }
+            return data;
+        }
+        catch (error) {
+            logger("Error fetching transaction data:", error);
+            throw error;
+        }
+    }
+    async getTransactionTags(transactionId) {
+        const client = this.getArweaveClient();
+        try {
+            const result = await client.request(GET_TRANSACTION_TAGS, { transactionId });
+            if (!result.tags?.tags) {
+                return [];
+            }
+            return result.tags.tags.map((tag) => ({
+                name: tag.name,
+                value: tag.value,
+            }));
+        }
+        catch (error) {
+            logger("Error fetching transaction tags:", error);
+            return [];
+        }
+    }
+    async createTransaction(data, options) {
+        const arweave = getArweaveInstance();
+        const tx = await arweave.createTransaction({
+            data,
+        });
+        // Add tags if provided
+        if (options?.tags) {
+            for (const tag of options.tags) {
+                tx.addTag(tag.name, tag.value);
+            }
+        }
+        return tx;
+    }
+    async downloadFiles(params) {
+        const { transactionIds, excludedTransactions } = params;
+        const results = [];
+        const baseUrl = BaseArweaveClient.getBaseUrl();
+        for (const transactionId of transactionIds) {
+            // Skip excluded transactions
+            if (excludedTransactions?.has(transactionId)) {
+                continue;
+            }
+            try {
+                const url = `${baseUrl}/raw/${transactionId}`;
+                const response = await fetch(url);
+                if (!response.ok) {
+                    results.push({
+                        transactionId,
+                        success: false,
+                        error: `HTTP ${response.status}: ${response.statusText}`,
+                    });
+                    continue;
+                }
+                const arrayBuffer = await response.arrayBuffer();
+                const data = new Uint8Array(arrayBuffer);
+                // Detect content type
+                const contentType = response.headers.get("content-type") || undefined;
+                results.push({
+                    transactionId,
+                    success: true,
+                    contentType,
+                    data,
+                });
+            }
+            catch (error) {
+                logger(`Error downloading transaction ${transactionId}:`, error);
+                results.push({
+                    transactionId,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        return results;
+    }
+}
+BaseArweaveClient.configure(new BrowserArweaveClient());
+
+class BrowserEasClient {
+    /** Reads the endpoint per call so SDK / publish chain config applied after import takes effect. */
+    getEasClient() {
+        const url = getEasEndpoint();
+        if (this.easClient?.url !== url) {
+            this.easClient = { url, client: new GraphQLClient(url) };
+        }
+        return this.easClient.client;
+    }
+}
+BaseEasClient.configure(new BrowserEasClient());
+
+/**
+ * Cached results are only reused within a query's staleTime (0 unless the caller sets one), so
+ * they don't need to outlive that by much. Nothing persists this cache.
+ */
+const QUERY_GC_TIME_MS = 1000 * 60 * 5;
+class BrowserQueryClient {
+    getQueryClient() {
+        if (this.queryClient)
+            return this.queryClient;
+        const reactQueryClient = new QueryClient({
+            defaultOptions: {
+                queries: {
+                    networkMode: 'offlineFirst',
+                    gcTime: QUERY_GC_TIME_MS,
+                },
+            },
+        });
+        const queryClient = {
+            fetchQuery: async (options) => {
+                const { queryKey, queryFn, networkMode, staleTime } = options;
+                return reactQueryClient.fetchQuery({
+                    queryKey,
+                    queryFn,
+                    networkMode: networkMode,
+                    staleTime,
+                });
+            },
+            getQueryData: (queryKey) => {
+                return reactQueryClient.getQueryData(queryKey);
+            },
+            removeQueries: async (filters) => {
+                await reactQueryClient.removeQueries(filters);
+            },
+        };
+        this.queryClient = queryClient;
+        return queryClient;
+    }
+}
+BaseQueryClient.configure(new BrowserQueryClient());
+
+function createPlatformServices() {
+    return {
+        pathResolver: new BrowserPathResolver(),
+        fileManager: new BrowserFileManager(),
+        db: new BrowserDb(),
+        arweaveClient: new BrowserArweaveClient(),
+        easClient: new BrowserEasClient(),
+        queryClient: new BrowserQueryClient(),
+    };
+}
+
+export { createPlatformServices as c, isSkippableOpfsEntryError as i };
+//# sourceMappingURL=index.browser-CNrqhvEA.js.map