@seedprotocol/sdk 0.7.8 → 0.7.9-next.1177.ga3e08ed

package/dist/{index.browser-Ll71Y_Dl.js → index.browser-i9uPJice.js}

@@ -1,83 +1,22 @@
-import { B as BasePathResolver } from './configurePlatform-AWild9o4.js';
-import { d as withDbTabLock, n as notifyFilesWrittenOutsideCache, f as createSessionObjectUrl, g as withSeedDbLock, h as countDbStatements, s as startChangeFeed, j as countLiveQueryRuns } from './changeFeed-DcsZ7deG.js';
-import { G as BaseDb, h as appState, aE as contentSha256TagMatches, Q as BaseFileManager, aT as withSqliteBusyRetry } from './index-C0SetTd1.js';
+import { d as withDbTabLock, n as notifyFilesWrittenOutsideCache, f as createSessionObjectUrl, g as withSeedDbLock, h as countDbStatements, s as startChangeFeed, j as countLiveQueryRuns } from './changeFeed-DKdVlUmt.js';
+import { L as BaseDb, h as appState, av as contentSha256TagMatches, Q as BaseFileManager, aK as withSqliteBusyRetry } from './index-Dx_GTdyQ.js';
 import { eq, sql } from 'drizzle-orm';
 import { M as MIME_TO_EXTENSION } from './mimeTypes-C9r76DCH.js';
 import debug from 'debug';
-import { F as FileSystemLockedError, D as DatabaseNotPersistentError } from './errors-Do7v6RKu.js';
+import { F as FileSystemLockedError, D as DatabaseNotPersistentError } from './errors-C1qUEZ7A.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-CZQrNqvq.js';
+import { s as schema } from './index-PbnKw2es.js';
 import { SQLocalDrizzle } from 'sqlocal/drizzle';
+import { r as recreateIfOlderThanMinimumUpgradeVersion } from './minimumUpgradeVersion-BDhHvHtr.js';
 import { throwError, Observable, distinctUntilChanged, finalize, share, ReplaySubject } from 'rxjs';
 import { BaseArweaveClient, fetchTransactionStatusAcrossGateways, getPreferredArweaveReadBaseUrls, fetchArweaveRawFromBaseUrl, GET_TRANSACTION_TAGS } from '@seedprotocol/arweave';
 import { GraphQLClient } from 'graphql-request';
 import Arweave from 'arweave';
 import { getEasEndpoint, createEasGraphQLClient, BaseEasClient, BaseQueryClient } from '@seedprotocol/eas';
 import { QueryClient } from '@tanstack/query-core';
-
-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());
+import './configurePlatform-CrMafpMW.js';
 
 const KEY = 'excludedTransactions';
 /**
@@ -458,7 +397,81 @@ var filesDownload = `const SEED_MIME_TO_EXTENSION = ${JSON.stringify(MIME_TO_EXT
         }
         return path;
     };
-    const downloadFiles = async ({ transactionIds, arweaveHost, arweaveBaseUrls, filesRoot = '/files', expectedContentHashes, compositeChildPaths, }) => {
+    /** The OPFS directory at `path`, or undefined when it does not exist. Creates nothing. */
+    const getExistingDirectory = async (path) => {
+        let dir = await navigator.storage.getDirectory();
+        for (const segment of path.split('/').filter(Boolean)) {
+            try {
+                dir = await dir.getDirectoryHandle(segment);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return dir;
+    };
+    const isNonEmptyFile = async (filePath) => {
+        const segments = filePath.split('/').filter(Boolean);
+        const fileName = segments.pop();
+        const dir = fileName ? await getExistingDirectory(segments.join('/')) : undefined;
+        if (!dir || !fileName)
+            return false;
+        try {
+            return (await (await dir.getFileHandle(fileName)).getFile()).size > 0;
+        }
+        catch {
+            return false;
+        }
+    };
+    /**
+     * Which of `transactionIds` already have a non-empty file where a download would put them:
+     * `<txId>` or `<txId>.<ext>` in images/, html/, json/ or files/. Each directory is listed once.
+     */
+    const listStoredTransactionIds = async (filesRoot, transactionIds) => {
+        const wanted = new Set(transactionIds);
+        const stored = new Set();
+        for (const dirName of ['images', 'html', 'json', 'files']) {
+            const dir = await getExistingDirectory(getFilesPath(filesRoot, dirName));
+            if (!dir)
+                continue;
+            for await (const handle of dir.values()) {
+                if (handle.kind !== 'file')
+                    continue;
+                // Transaction ids never contain a dot.
+                const transactionId = handle.name.split('.')[0];
+                if (!wanted.has(transactionId) || stored.has(transactionId))
+                    continue;
+                try {
+                    if ((await handle.getFile()).size > 0)
+                        stored.add(transactionId);
+                }
+                catch {
+                    /* unreadable: download it again */
+                }
+            }
+        }
+        return stored;
+    };
+    /**
+     * True when a transaction needs no download. A composite with child paths counts as stored only
+     * when every routed child is on disk, so a child that got its path after an earlier run is placed.
+     */
+    const isAlreadyStored = async (transactionId, stored, filesRoot, childPaths) => {
+        const routed = Object.values(childPaths ?? {})
+            .map(safeRelativePath)
+            .filter((path) => !!path);
+        if (routed.length === 0)
+            return stored.has(transactionId);
+        for (const path of routed) {
+            if (!(await isNonEmptyFile(getFilesPath(filesRoot, path))))
+                return false;
+        }
+        return true;
+    };
+    const downloadFiles = async ({ transactionIds, arweaveHost, arweaveBaseUrls, filesRoot = '/files', expectedContentHashes, compositeChildPaths, skipExisting, }) => {
+        const stored = skipExisting
+            ? await listStoredTransactionIds(filesRoot, transactionIds).catch(() => new Set())
+            : new Set();
         // Preferred / resolved gateways first, then the configured host; deduped.
         const baseUrls = [];
         for (const candidate of (arweaveBaseUrls || []).concat([arweaveHost])) {
@@ -470,7 +483,10 @@ var filesDownload = `const SEED_MIME_TO_EXTENSION = ${JSON.stringify(MIME_TO_EXT
         for (const transactionId of transactionIds) {
             // One bad file (failed OPFS write, quota, malformed content) must not stall or abort the batch.
             try {
-                await downloadFile(transactionId, baseUrls, filesRoot, expectedContentHashes?.[transactionId], compositeChildPaths?.[transactionId]);
+                const skip = skipExisting &&
+                    (await isAlreadyStored(transactionId, stored, filesRoot, compositeChildPaths?.[transactionId]));
+                if (!skip)
+                    await downloadFile(transactionId, baseUrls, filesRoot, expectedContentHashes?.[transactionId], compositeChildPaths?.[transactionId]);
             }
             catch (error) {
                 globalThis.postMessage({ message: 'fileError', transactionId, error: errorInfo(error) });
@@ -689,7 +705,7 @@ const toError = (raw, fallback) => {
 class FileDownloader {
     constructor(options = {}) {
         this.options = options;
-        this.downloadAll = async ({ transactionIds, arweaveHost, arweaveBaseUrls, excludedTransactions, expectedContentHashes, compositeChildPaths, }) => {
+        this.downloadAll = async ({ transactionIds, arweaveHost, arweaveBaseUrls, excludedTransactions, expectedContentHashes, compositeChildPaths, skipExisting, }) => {
             // One download per instance at a time: a newer call replaces the older one, which rejects
             // instead of waiting forever on a terminated worker.
             this.abortCurrent?.(new FileDownloadWorkerError('Superseded by a newer download'));
@@ -821,6 +837,7 @@ class FileDownloader {
                         arweaveBaseUrls,
                         expectedContentHashes,
                         compositeChildPaths,
+                        skipExisting,
                         debug: logger$5.enabled,
                         filesRoot: BaseFileManager.getWorkingDir(),
                     });
@@ -895,7 +912,7 @@ var imageResize = `(
                 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)
+            else if (bytes[0] === 0x52 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x46 && 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';
@@ -1448,9 +1465,9 @@ class BrowserFileManager {
     }
     async initializeFileSystem(_workingDir) {
         const zenfs = await this.getFs();
-        const { TolerantWebAccess, TolerantWebAccessFS } = await import('./tolerantWebAccess-CIpS7RLk.js');
-        const _mod_0 = await import('./changeFeed-DcsZ7deG.js');
-        const _ns_0 = _mod_0.H;
+        const { TolerantWebAccess, TolerantWebAccessFS } = await import('./tolerantWebAccess-DecKDGen.js');
+        const _mod_0 = await import('./changeFeed-DKdVlUmt.js');
+        const _ns_0 = _mod_0.G;
         const { queueFilesChangedNotice } = _ns_0;
         const { configureSingle } = zenfs;
         const configureRoot = async () => {
@@ -1518,7 +1535,7 @@ class BrowserFileManager {
     }
     async invalidateNow(filePaths) {
         const { mounts } = await this.getFs();
-        const { TolerantWebAccessFS } = await import('./tolerantWebAccess-CIpS7RLk.js');
+        const { TolerantWebAccessFS } = await import('./tolerantWebAccess-DecKDGen.js');
         const mounted = mounts.get('/');
         if (!(mounted instanceof TolerantWebAccessFS))
             return;
@@ -2339,6 +2356,36 @@ END;
 CREATE TRIGGER \`entity_changes_metadata_delete\` AFTER DELETE ON \`metadata\` BEGIN
 	INSERT INTO \`entity_changes\` (\`tbl\`, \`seed_local_id\`, \`seed_uid\`, \`property_name\`, \`at\`) VALUES ('metadata', OLD.\`seed_local_id\`, OLD.\`seed_uid\`, OLD.\`property_name\`, CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER));
 END;`;
+const migrationSql_0024_merge_republished_ghost_seeds = `-- A sync after an unpublish and republish inserted the old seed uid as a second seed row with no
+-- versions, while the item's old version rows still record that uid in versions.seed_uid. Property
+-- rows sync attached to that row move to the item, then the row is deleted.
+UPDATE \`metadata\` SET \`seed_local_id\` = (
+  SELECT \`v\`.\`seed_local_id\` FROM \`versions\` \`v\`
+  JOIN \`seeds\` \`owner\` ON \`owner\`.\`local_id\` = \`v\`.\`seed_local_id\`
+  JOIN \`seeds\` \`ghost\` ON \`ghost\`.\`uid\` = \`v\`.\`seed_uid\`
+  WHERE \`ghost\`.\`local_id\` = \`metadata\`.\`seed_local_id\` AND \`owner\`.\`local_id\` != \`ghost\`.\`local_id\`
+  LIMIT 1
+)
+WHERE \`seed_local_id\` IN (
+  SELECT \`ghost\`.\`local_id\` FROM \`seeds\` \`ghost\`
+  WHERE \`ghost\`.\`uid\` IS NOT NULL
+    AND NOT EXISTS (SELECT 1 FROM \`versions\` WHERE \`versions\`.\`seed_local_id\` = \`ghost\`.\`local_id\`)
+    AND EXISTS (
+      SELECT 1 FROM \`versions\` \`v\` JOIN \`seeds\` \`owner\` ON \`owner\`.\`local_id\` = \`v\`.\`seed_local_id\`
+      WHERE \`v\`.\`seed_uid\` = \`ghost\`.\`uid\` AND \`owner\`.\`local_id\` != \`ghost\`.\`local_id\`
+    )
+);
+--> statement-breakpoint
+DELETE FROM \`seeds\` WHERE \`local_id\` IN (
+  SELECT \`ghost\`.\`local_id\` FROM \`seeds\` \`ghost\`
+  WHERE \`ghost\`.\`uid\` IS NOT NULL
+    AND NOT EXISTS (SELECT 1 FROM \`versions\` WHERE \`versions\`.\`seed_local_id\` = \`ghost\`.\`local_id\`)
+    AND EXISTS (
+      SELECT 1 FROM \`versions\` \`v\` JOIN \`seeds\` \`owner\` ON \`owner\`.\`local_id\` = \`v\`.\`seed_local_id\`
+      WHERE \`v\`.\`seed_uid\` = \`ghost\`.\`uid\` AND \`owner\`.\`local_id\` != \`ghost\`.\`local_id\`
+    )
+);
+`;
 // Journal JSON file
 const journalJson = `{
   "version": "7",
@@ -2511,16 +2558,23 @@ const journalJson = `{
       "when": 1792455641631,
       "tag": "0023_add_entity_changes",
       "breakpoints": true
+    },
+    {
+      "idx": 24,
+      "version": "6",
+      "when": 1792576238054,
+      "tag": "0024_merge_republished_ghost_seeds",
+      "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 = `{
+  "id": "3264e54f-0bb8-4116-87e8-b059b4ac1ae7",
+  "prevId": "7767667b-3cf0-4630-b1ff-02913f2f35ad",
   "version": "6",
   "dialect": "sqlite",
-  "id": "7767667b-3cf0-4630-b1ff-02913f2f35ad",
-  "prevId": "781ce7c2-f397-4df2-a32c-9267c4a4163d",
   "tables": {
     "appState": {
       "name": "appState",
@@ -3131,15 +3185,15 @@ const snapshotJson = `{
         "metadata_property_id_properties_id_fk": {
           "name": "metadata_property_id_properties_id_fk",
           "tableFrom": "metadata",
-          "tableTo": "properties",
           "columnsFrom": [
             "property_id"
           ],
+          "tableTo": "properties",
           "columnsTo": [
             "id"
           ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
+          "onUpdate": "no action",
+          "onDelete": "no action"
         }
       },
       "compositePrimaryKeys": {},
@@ -3301,28 +3355,28 @@ const snapshotJson = `{
         "properties_model_id_models_id_fk": {
           "name": "properties_model_id_models_id_fk",
           "tableFrom": "properties",
-          "tableTo": "models",
           "columnsFrom": [
             "model_id"
           ],
+          "tableTo": "models",
           "columnsTo": [
             "id"
           ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
+          "onUpdate": "no action",
+          "onDelete": "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"
           ],
+          "tableTo": "models",
           "columnsTo": [
             "id"
           ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
+          "onUpdate": "no action",
+          "onDelete": "no action"
         }
       },
       "compositePrimaryKeys": {},
@@ -3359,28 +3413,28 @@ const snapshotJson = `{
         "model_schemas_model_id_models_id_fk": {
           "name": "model_schemas_model_id_models_id_fk",
           "tableFrom": "model_schemas",
-          "tableTo": "models",
           "columnsFrom": [
             "model_id"
           ],
+          "tableTo": "models",
           "columnsTo": [
             "id"
           ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
+          "onUpdate": "no action",
+          "onDelete": "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"
           ],
+          "tableTo": "schemas",
           "columnsTo": [
             "id"
           ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
+          "onUpdate": "no action",
+          "onDelete": "no action"
         }
       },
       "compositePrimaryKeys": {},
@@ -3425,15 +3479,15 @@ const snapshotJson = `{
         "model_uids_model_id_models_id_fk": {
           "name": "model_uids_model_id_models_id_fk",
           "tableFrom": "model_uids",
-          "tableTo": "models",
           "columnsFrom": [
             "model_id"
           ],
+          "tableTo": "models",
           "columnsTo": [
             "id"
           ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
+          "onUpdate": "no action",
+          "onDelete": "no action"
         }
       },
       "compositePrimaryKeys": {},
@@ -3647,15 +3701,15 @@ const snapshotJson = `{
         "property_uids_property_id_properties_id_fk": {
           "name": "property_uids_property_id_properties_id_fk",
           "tableFrom": "property_uids",
-          "tableTo": "properties",
           "columnsFrom": [
             "property_id"
           ],
+          "tableTo": "properties",
           "columnsTo": [
             "id"
           ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
+          "onUpdate": "no action",
+          "onDelete": "no action"
         }
       },
       "compositePrimaryKeys": {},
@@ -4153,9 +4207,9 @@ const snapshotJson = `{
   "views": {},
   "enums": {},
   "_meta": {
+    "columns": {},
     "schemas": {},
-    "tables": {},
-    "columns": {}
+    "tables": {}
   },
   "internal": {
     "indexes": {}
@@ -4189,6 +4243,7 @@ var drizzleFiles = /*#__PURE__*/Object.freeze({
     migrationSql_0021_add_pending_write_error_name: migrationSql_0021_add_pending_write_error_name,
     migrationSql_0022_add_read_indexes: migrationSql_0022_add_read_indexes,
     migrationSql_0023_add_entity_changes: migrationSql_0023_add_entity_changes,
+    migrationSql_0024_merge_republished_ghost_seeds: migrationSql_0024_merge_republished_ghost_seeds,
     snapshotJson: snapshotJson
 });
 
@@ -4259,14 +4314,59 @@ function shouldBlobWrapModuleWorker(scriptURL, options) {
         return false;
     return HTTP_MODULE_WORKER_URL.test(String(scriptURL));
 }
-function createBlobModuleWorkerSource(scriptURL) {
-    return `import ${JSON.stringify(String(scriptURL))};`;
+/**
+ * Source of a module that replaces `self.Worker` inside sqlocal's worker. SQLite's OPFS VFS starts
+ * its async proxy from there with `new Worker(new URL('sqlite3-opfs-async-proxy.js', import.meta.url))`,
+ * and some Chromium builds fail any worker started from a worker with an http(s) URL (an `error`
+ * event with no message). They do start a blob worker, so an http(s) URL is started from a blob that
+ * loads it: `import` for a module worker, `importScripts` for a classic one. The classic blob also
+ * resolves later `importScripts` calls against the original URL, because Vite dev prepends a
+ * root-relative `importScripts("/@vite/env")`, which has no base inside a blob worker.
+ *
+ * Plain JS in a string so bundlers and transpilers can't add helpers that don't exist in the worker.
+ */
+const NESTED_WORKER_SHIM_SOURCE = `(() => {
+  const OriginalWorker = self.Worker;
+  if (typeof OriginalWorker !== 'function' || OriginalWorker.__seedNestedWorkerWrap) return;
+  const HTTP_URL = /^https?:/i;
+  const classicSource = (url) =>
+    'const __seedWorkerUrl = ' + JSON.stringify(url) + ';\\n' +
+    'const __seedImportScripts = self.importScripts.bind(self);\\n' +
+    'self.importScripts = (...urls) => __seedImportScripts(...urls.map((u) => new URL(String(u), __seedWorkerUrl).href));\\n' +
+    '__seedImportScripts(__seedWorkerUrl);\\n';
+  function NestedWorker(scriptURL, options) {
+    const url = String(scriptURL);
+    if (!HTTP_URL.test(url)) return new OriginalWorker(scriptURL, options);
+    const isModule = options && options.type === 'module';
+    const source = isModule ? 'import ' + JSON.stringify(url) + ';\\n' : classicSource(url);
+    const blobUrl = URL.createObjectURL(new Blob([source], { type: 'text/javascript' }));
+    const worker = new OriginalWorker(blobUrl, options);
+    worker.addEventListener('error', (event) => {
+      console.warn('[seed] A worker started inside the SQLite worker failed to load: ' + url, event.message || '');
+    });
+    return worker;
+  }
+  NestedWorker.prototype = OriginalWorker.prototype;
+  Object.setPrototypeOf(NestedWorker, OriginalWorker);
+  NestedWorker.__seedNestedWorkerWrap = true;
+  self.Worker = NestedWorker;
+})();
+`;
+/**
+ * Source of the blob module that starts sqlocal's worker. The shim is a separate import ahead of
+ * the worker's: static imports are hoisted, so shim code in this module's body would run after the
+ * worker module, while imports evaluate in the order they're written.
+ */
+function createBlobModuleWorkerSource(scriptURL, shimURL) {
+    const workerImport = `import ${JSON.stringify(String(scriptURL))};`;
+    return shimURL ? `import ${JSON.stringify(shimURL)};\n${workerImport}` : workerImport;
 }
 /**
  * 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.
+ * script; importing the same URL from a blob worker reaches connect. The blob also installs
+ * {@link NESTED_WORKER_SHIM_SOURCE} first, for the OPFS proxy worker SQLite starts inside it.
  *
  * 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
@@ -4311,10 +4411,9 @@ function installModuleWorkerBlobWrap(onWorkerFailed) {
         return () => { };
     }
     function WrappedWorker(scriptURL, options) {
+        const toBlobURL = (source) => URL.createObjectURL(new Blob([source], { type: 'text/javascript' }));
         const worker = shouldBlobWrapModuleWorker(scriptURL, options)
-            ? new OriginalWorker(URL.createObjectURL(new Blob([createBlobModuleWorkerSource(scriptURL)], {
-                type: 'text/javascript',
-            })), { ...options, type: 'module' })
+            ? new OriginalWorker(toBlobURL(createBlobModuleWorkerSource(scriptURL, toBlobURL(NESTED_WORKER_SHIM_SOURCE))), { ...options, type: 'module' })
             : new OriginalWorker(scriptURL, options);
         const fail = (event) => {
             const filename = 'filename' in event && typeof event.filename === 'string'
@@ -4360,6 +4459,35 @@ class BrowserDb {
         // one-time data fixes one tab at a time. See docs/MULTI_TAB.md.
         return withSeedDbLock('migrate', filesDir, () => this.prepareDbLocked(filesDir));
     }
+    /**
+     * Starts SQLocal on `<filesDir>/db/seed.db` and checks it opened the OPFS file. SQLocal opens an
+     * in-memory database instead when its OPFS open throws, which also happens when another tab keeps
+     * the file's sync access handle for longer than sqlite-wasm retries (about 4.5 s), e.g. while that
+     * tab runs its first queries after migrating. That clears up, so a memory database is closed and
+     * the open tried again, waiting 1, 2 and 4 s, before it's reported as DatabaseNotPersistentError.
+     */
+    async openPersistentSqlocal() {
+        const retryWaitsMs = [1000, 2000, 4000];
+        for (let attempt = 0;; attempt++) {
+            // reactive: true enables 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 { storageType } = await raceSqlocalStartup(sqlocalDrizzle.getDatabaseInfo(), workerFailed);
+            if (storageType === 'opfs')
+                return { sqlocalDrizzle, workerFailed };
+            await sqlocalDrizzle.destroy().catch(() => { });
+            const waitMs = retryWaitsMs[attempt];
+            if (waitMs === undefined) {
+                throw new DatabaseNotPersistentError(`SQLocal opened a "${storageType}" database instead of OPFS`, globalThis.crossOriginIsolated === true ? 'vfs' : 'headers');
+            }
+            logger$1(`[Db.prepareDb] SQLocal opened a "${storageType}" database; retrying in ${waitMs} ms`);
+            await new Promise((resolve) => setTimeout(resolve, waitMs));
+        }
+    }
     async prepareDbLocked(filesDir) {
         try {
             // Copy drizzle migration files from src/db/drizzle to filesDir/db
@@ -4389,14 +4517,7 @@ class BrowserDb {
                     ? 'the page is not cross-origin isolated, so SharedArrayBuffer is unavailable'
                     : 'SharedArrayBuffer is unavailable');
             }
-            // 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 { sqlocalDrizzle, workerFailed } = await this.openPersistentSqlocal();
             const { batchDriver } = sqlocalDrizzle;
             const driver = countDbStatements(withSqliteBusyRetry(sqlocalDrizzle.driver));
             // Store SQLocalDrizzle instance for reactive queries
@@ -4411,18 +4532,11 @@ class BrowserDb {
             });
             logger$1('[Db.prepareDb] database prepared');
             await raceSqlocalStartup((async () => {
-                // OPFS can still fail inside the worker (e.g. storage blocked); SQLocal then reports memory.
-                const { storageType } = await sqlocalDrizzle.getDatabaseInfo();
-                if (storageType !== 'opfs') {
-                    throw new DatabaseNotPersistentError(`SQLocal opened a "${storageType}" database instead of OPFS`);
-                }
+                await recreateIfOlderThanMinimumUpgradeVersion(db);
                 await this.runMigrations(db);
                 this.appDb = db;
-                const { backfillMetadataPropertyIds } = await import('./backfillMetadataPropertyIds-DWWkh-Ex.js');
+                const { backfillMetadataPropertyIds } = await import('./backfillMetadataPropertyIds-BbxgavEQ.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-0Tin9-JK.js');
-                await resetAmbiguousLegacyItemData();
                 // Loaded Items and ItemProperties hear about row changes through it (ADR 0020). Started
                 // after the fixups above, so their log rows aren't dispatched.
                 await startChangeFeed(db, {
@@ -4437,61 +4551,8 @@ class BrowserDb {
             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;
+        return undefined;
     }
     async copyDrizzleFiles(filesDir) {
         logger$1('[Db.copyDrizzleFiles] copying drizzle migration files');
@@ -4932,7 +4993,6 @@ BaseQueryClient.configure(new BrowserQueryClient());
 
 function createPlatformServices() {
     return {
-        pathResolver: new BrowserPathResolver(),
         fileManager: new BrowserFileManager(),
         db: new BrowserDb(),
         arweaveClient: new BrowserArweaveClient(),
@@ -4949,4 +5009,4 @@ function resolveFilesDir(filesDir) {
 }
 
 export { createPlatformServices as c, isSkippableOpfsEntryError as i, resolveFilesDir as r };
-//# sourceMappingURL=index.browser-Ll71Y_Dl.js.map
+//# sourceMappingURL=index.browser-i9uPJice.js.map