@seedprotocol/sdk 0.7.9-next.1189.g5e63267 → 0.7.9

package/dist/{index.browser-QPWBkLJA.js → index.browser-CUmBVYen.js}

@@ -1,22 +1,60 @@
-import { d as withDbTabLock, n as notifyFilesWrittenOutsideCache, f as createSessionObjectUrl, g as withSeedDbLock, h as countDbStatements, s as startChangeFeed, j as countLiveQueryRuns } from './changeFeed-M8sGbOrW.js';
-import { L as BaseDb, h as appState, aw as contentSha256TagMatches, Q as BaseFileManager, aL as withSqliteBusyRetry } from './index-rOTW-2QZ.js';
+import { ay as withDbTabLock, az as MIME_TO_EXTENSION, aA as sniffMimeType, ak as contentSha256TagMatches, aB as notifyFilesWrittenOutsideCache, aC as createSessionObjectUrl, aD as withSeedDbLock, aE as countDbStatements, aF as startChangeFeed, aG as countLiveQueryRuns } from './tabEvents-CaVmngqr.js';
+import { B as BaseDb, a as appState, w as BaseFileManager, y as withSqliteBusyRetry } from './BaseFileManager-BAlySv8w.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-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-DxHpPNfn.js';
+import { DefaultArweaveClient } from '@seedprotocol/arweave';
+import 'pluralize';
+import { DefaultQueryClient, DefaultEasClient } from '@seedprotocol/eas';
+import { s as schema } from './index-D0V-mjCV.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';
-import './configurePlatform-Dukm2QwO.js';
+import './configurePlatform-CiOJ1R3q.js';
+
+/**
+ * String classification for stored values. Each function is self-contained (no imports, no
+ * module-level references) because the download worker gets them as source text: see
+ * `browser/workers/filesDownload.ts`.
+ */
+/** MIME type of a `data:` URL, or null. */
+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
+    }
+};
+/** What a stored string looks like: bare base64, a base64 image data URL, or a URL. */
+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';
+    }
+    // Blob URLs are fetchable but session-scoped; recognize them as url type
+    if (data.startsWith('blob:')) {
+        return 'url';
+    }
+    // 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 KEY = 'excludedTransactions';
 /**
@@ -53,6 +91,9 @@ async function addExcludedTransactions(transactionIds) {
 }
 
 var filesDownload = `const SEED_MIME_TO_EXTENSION = ${JSON.stringify(MIME_TO_EXTENSION)};
+const seedSniffMimeType = ${sniffMimeType.toString()};
+const seedGetMimeType = ${getMimeType.toString()};
+const seedGetDataTypeFromString = ${getDataTypeFromString.toString()};
 (
   ${function () {
     const identifyString = (str) => {
@@ -79,35 +120,6 @@ var filesDownload = `const SEED_MIME_TO_EXTENSION = ${JSON.stringify(MIME_TO_EXT
         // 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;
@@ -284,30 +296,7 @@ var filesDownload = `const SEED_MIME_TO_EXTENSION = ${JSON.stringify(MIME_TO_EXT
      */
     const transformDownloadedContent = async (bytes, _context) => bytes;
     /** True when the bytes start with the signature of an image format the SDK stores in `images/`. */
-    const hasImageSignature = (bytes) => {
-        const at = (offset, ...sig) => sig.every((b, i) => bytes[offset + i] === b);
-        const ascii = (offset, s) => at(offset, ...Array.from(s).map((c) => c.charCodeAt(0)));
-        if (at(0, 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a))
-            return true; // PNG
-        if (at(0, 0xff, 0xd8, 0xff))
-            return true; // JPEG
-        if (ascii(0, 'GIF87a') || ascii(0, 'GIF89a'))
-            return true;
-        if (ascii(0, 'RIFF') && ascii(8, 'WEBP'))
-            return true;
-        if (ascii(0, 'BM'))
-            return true; // BMP
-        if (at(0, 0x00, 0x00, 0x01, 0x00))
-            return true; // ICO
-        if (at(0, 0x49, 0x49, 0x2a, 0x00) || at(0, 0x4d, 0x4d, 0x00, 0x2a))
-            return true; // TIFF
-        if (ascii(4, 'ftyp')) {
-            // ISO-BMFF images (AVIF / HEIC); ftyp is also MP4, so check the brand
-            const brand = String.fromCharCode(...Array.from(bytes.slice(8, 12)));
-            return ['avif', 'avis', 'heic', 'heix', 'heif', 'mif1', 'msf1'].includes(brand);
-        }
-        return false;
-    };
+    const hasImageSignature = (bytes) => (seedSniffMimeType(bytes) || '').startsWith('image/');
     /**
      * Content-Types that say nothing about the content: these are sniffed instead. `text/plain` is
      * here because some gateways send it for anything textual.
@@ -585,7 +574,7 @@ var filesDownload = `const SEED_MIME_TO_EXTENSION = ${JSON.stringify(MIME_TO_EXT
         if (textType !== 'json' &&
             textType !== 'base64' &&
             textType !== 'html') {
-            const possibleImageType = getDataTypeFromString(dataString);
+            const possibleImageType = seedGetDataTypeFromString(dataString);
             if (!possibleImageType) {
                 // Plain text / markdown / anything else textual.
                 await saveToFiles(bytes);
@@ -620,7 +609,7 @@ var filesDownload = `const SEED_MIME_TO_EXTENSION = ${JSON.stringify(MIME_TO_EXT
         }
         let fileName = transactionId;
         if (textType === 'base64') {
-            const mimeType = getMimeType(dataString);
+            const mimeType = seedGetMimeType(dataString);
             const isDataUri = dataString.startsWith('data:');
             // Remove the Base64 header if it exists (e.g., "data:image/png;base64,")
             const binaryData = decodeBase64(dataString.split(',').pop() || '');
@@ -675,7 +664,7 @@ var filesDownload = `const SEED_MIME_TO_EXTENSION = ${JSON.stringify(MIME_TO_EXT
 }.toString()}
 )()`;
 
-const logger$5 = debug('seedSdk:browser:workers:FileDownloader');
+const logger$4 = debug('seedSdk:browser:workers:FileDownloader');
 /**
  * Longest the worker may go without posting anything before the download is failed. The worker
  * posts after every transaction and each gateway request times out after 60s, so this only fires
@@ -746,7 +735,7 @@ class FileDownloader {
                         return;
                     settled = true;
                     cleanup();
-                    logger$5('file download failed', error);
+                    logger$4('file download failed', error);
                     // Files the worker already wrote are on disk: refresh caches for them anyway.
                     if (savedPaths.length) {
                         void notifyFilesWrittenOutsideCache(savedPaths).catch(() => { });
@@ -777,7 +766,7 @@ class FileDownloader {
                 worker.onmessage = (e) => {
                     armWatchdog();
                     const data = e.data ?? {};
-                    logger$5('filesDownload main thread onmessage', data);
+                    logger$4('filesDownload main thread onmessage', data);
                     if (data.message === 'excludeTransaction') {
                         localExcludedTransactions.add(data.transactionId);
                     }
@@ -791,14 +780,14 @@ class FileDownloader {
                             ok = contentSha256TagMatches(new Uint8Array(data.bytes), String(data.expected ?? ''));
                         }
                         catch (error) {
-                            logger$5('content verification failed', error);
+                            logger$4('content verification failed', error);
                         }
                         worker.postMessage({ message: 'verifyContentResult', requestId: data.requestId, ok });
                         return;
                     }
                     if (data.message === 'compositeChildUnrouted') {
                         // No local ItemStorage property for this child (e.g. its item is not synced yet).
-                        logger$5(`composite ${data.transactionId}: no local path for child "${data.name}"; not saved`);
+                        logger$4(`composite ${data.transactionId}: no local path for child "${data.name}"; not saved`);
                     }
                     if (data.message === 'contentVerified') {
                         verified.add(data.transactionId);
@@ -838,7 +827,7 @@ class FileDownloader {
                         expectedContentHashes,
                         compositeChildPaths,
                         skipExisting,
-                        debug: logger$5.enabled,
+                        debug: logger$4.enabled,
                         filesRoot: BaseFileManager.getWorkingDir(),
                     });
                 }
@@ -851,7 +840,8 @@ class FileDownloader {
     }
 }
 
-var imageResize = `(
+var imageResize = `const seedSniffMimeType = ${sniffMimeType.toString()};
+(
   ${function () {
     const getFileHandle = async (path, rootHandle = null) => {
         // Split the path into segments
@@ -905,25 +895,10 @@ var imageResize = `(
     /** 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] === 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';
-            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';
+            const sniffed = seedSniffMimeType(new Uint8Array(buf));
+            mime = sniffed && sniffed.startsWith('image/') ? sniffed : 'image/jpeg';
         }
         return new Blob([buf], { type: mime });
     }
@@ -1239,7 +1214,7 @@ var imageResize = `(
 }.toString()}
 )()`;
 
-const logger$4 = debug('seedSdk:browser:workers:ImageResizer');
+const logger$3 = debug('seedSdk:browser:workers:ImageResizer');
 class ImageResizer {
     constructor() {
         this.workersArchive = new Map();
@@ -1250,18 +1225,18 @@ class ImageResizer {
         if (this.workersArchive.has(filePath)) {
             const savedWorker = this.workersArchive.get(filePath);
             savedWorker?.terminate();
-            logger$4('[ImageResizer.resize] Terminated worker for filePath due to incoming request', filePath);
+            logger$3('[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$4('[ImageResizer.resize] main thread onmessage', e.data);
+                logger$3('[ImageResizer.resize] main thread onmessage', e.data);
                 if (e.data.done) {
                     const savedWorker = this.workersArchive.get(filePath);
                     savedWorker?.terminate();
-                    logger$4('[ImageResizer.resize] Terminated worker for filePath due to done', filePath);
+                    logger$3('[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));
@@ -1277,7 +1252,7 @@ class ImageResizer {
                 filePath,
                 width,
                 height,
-                debug: logger$4.enabled,
+                debug: logger$3.enabled,
             });
         });
     }
@@ -1315,7 +1290,7 @@ function isSkippableOpfsEntryError(error) {
     return error instanceof DOMException && SKIPPABLE_ENTRY_ERRORS.has(error.name);
 }
 
-const logger$3 = debug('seedSdk:browser:helpers:FileManager');
+const logger$2 = 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.
@@ -1465,9 +1440,9 @@ class BrowserFileManager {
     }
     async initializeFileSystem(_workingDir) {
         const zenfs = await this.getFs();
-        const { TolerantWebAccess, TolerantWebAccessFS } = await import('./tolerantWebAccess-BHndShch.js');
-        const _mod_0 = await import('./changeFeed-M8sGbOrW.js');
-        const _ns_0 = _mod_0.G;
+        const { TolerantWebAccess, TolerantWebAccessFS } = await import('./tolerantWebAccess-BJqViq08.js');
+        const _mod_0 = await import('./tabEvents-CaVmngqr.js');
+        const _ns_0 = _mod_0.bm;
         const { queueFilesChangedNotice } = _ns_0;
         const { configureSingle } = zenfs;
         const configureRoot = async () => {
@@ -1498,7 +1473,7 @@ class BrowserFileManager {
                 if (attempt === MOUNT_RETRY_DELAYS_MS.length) {
                     throw new FileSystemLockedError(error);
                 }
-                logger$3(`OPFS mount attempt ${attempt + 1} failed (${error?.name}); retrying`);
+                logger$2(`OPFS mount attempt ${attempt + 1} failed (${error?.name}); retrying`);
                 await sleep(MOUNT_RETRY_DELAYS_MS[attempt]);
             }
         }
@@ -1535,7 +1510,7 @@ class BrowserFileManager {
     }
     async invalidateNow(filePaths) {
         const { mounts } = await this.getFs();
-        const { TolerantWebAccessFS } = await import('./tolerantWebAccess-BHndShch.js');
+        const { TolerantWebAccessFS } = await import('./tolerantWebAccess-BJqViq08.js');
         const mounted = mounts.get('/');
         if (!(mounted instanceof TolerantWebAccessFS))
             return;
@@ -1545,7 +1520,7 @@ class BrowserFileManager {
                 await mounted.invalidate(absolute);
             }
             catch (error) {
-                logger$3(`could not refresh cached ${absolute}`, error);
+                logger$2(`could not refresh cached ${absolute}`, error);
             }
         }
     }
@@ -1582,7 +1557,7 @@ class BrowserFileManager {
             }
             catch {
                 // This is a no-op. We tried to create a directory that already exists.
-                logger$3('Attempted to create a directory that already exists');
+                logger$2('Attempted to create a directory that already exists');
             }
         }
     }
@@ -1604,7 +1579,7 @@ class BrowserFileManager {
             const startTime = Date.now();
             let isBusy = false;
             const cancelableInterval = new CancelableInterval(async (stop) => {
-                logger$3('waitForFile', filePath);
+                logger$2('waitForFile', filePath);
                 if (isBusy) {
                     return;
                 }
@@ -1697,7 +1672,7 @@ class BrowserFileManager {
             const startTime = Date.now();
             let isBusy = false;
             const cancelableInterval = new CancelableInterval(async (stop) => {
-                logger$3('waitForFileWithContent', filePath);
+                logger$2('waitForFileWithContent', filePath);
                 if (isBusy) {
                     return;
                 }
@@ -1909,7 +1884,7 @@ class CancelableInterval {
             }
             catch (error) {
                 if (error instanceof DOMException && error.name === 'AbortError') {
-                    logger$3('Previous task was canceled.');
+                    logger$2('Previous task was canceled.');
                 }
                 else {
                     console.error('Task error:', error);
@@ -2387,6 +2362,221 @@ DELETE FROM \`seeds\` WHERE \`local_id\` IN (
 );
 `;
 const migrationSql_0025_add_metadata_retract = `ALTER TABLE \`metadata\` ADD \`retract\` integer;`;
+const migrationSql_0026_add_content_hash_to_schemas = `ALTER TABLE \`schemas\` ADD \`content_hash\` text;`;
+const migrationSql_0027_link_metadata_property_ids = `-- Links metadata rows written without property_id to their property (decision D4: readers match
+-- rows by property_id). Only rows whose seed records its model (seeds.model_file_id) are linked,
+-- and only to one of that model's properties. Rows that match no property, or several, keep NULL
+-- and are read by name.
+--
+-- First the rows whose stored name is a property's key (unique per model).
+UPDATE \`metadata\` SET \`property_id\` = (
+  SELECT \`p\`.\`id\` FROM \`seeds\` \`s\`
+  JOIN \`models\` \`m\` ON \`m\`.\`schema_file_id\` = \`s\`.\`model_file_id\`
+  JOIN \`properties\` \`p\` ON \`p\`.\`model_id\` = \`m\`.\`id\`
+  WHERE \`s\`.\`local_id\` = \`metadata\`.\`seed_local_id\` AND \`p\`.\`name\` = \`metadata\`.\`property_name\`
+)
+WHERE \`property_id\` IS NULL AND EXISTS (
+  SELECT 1 FROM \`seeds\` \`s\`
+  JOIN \`models\` \`m\` ON \`m\`.\`schema_file_id\` = \`s\`.\`model_file_id\`
+  JOIN \`properties\` \`p\` ON \`p\`.\`model_id\` = \`m\`.\`id\`
+  WHERE \`s\`.\`local_id\` = \`metadata\`.\`seed_local_id\` AND \`p\`.\`name\` = \`metadata\`.\`property_name\`
+);
+--> statement-breakpoint
+-- Then the other stored forms, when exactly one property matches: \`<key>Id\` for an Image, File,
+-- Html or Relation, and a List of Relation's \`<singular key><Ref>Ids\` (singular as \`key\` minus a
+-- trailing \`s\` or \`es\`, or \`ies\` → \`y\`; other plurals stay NULL).
+UPDATE \`metadata\` SET \`property_id\` = (
+  SELECT \`p\`.\`id\` FROM \`seeds\` \`s\`
+  JOIN \`models\` \`m\` ON \`m\`.\`schema_file_id\` = \`s\`.\`model_file_id\`
+  JOIN \`properties\` \`p\` ON \`p\`.\`model_id\` = \`m\`.\`id\`
+  LEFT JOIN \`models\` \`r\` ON \`r\`.\`id\` = \`p\`.\`ref_model_id\`
+  WHERE \`s\`.\`local_id\` = \`metadata\`.\`seed_local_id\` AND (
+    (
+      (\`p\`.\`data_type\` IN ('Image', 'File', 'Html', 'Relation') OR \`p\`.\`ref_value_type\` IN ('Image', 'File', 'Html', 'Relation'))
+      AND \`p\`.\`name\` || 'Id' = \`metadata\`.\`property_name\`
+    ) OR (
+      \`p\`.\`data_type\` = 'List' AND \`r\`.\`name\` IS NOT NULL
+      AND length(\`metadata\`.\`property_name\`) > length(\`r\`.\`name\`) + 3
+      AND substr(\`metadata\`.\`property_name\`, -(length(\`r\`.\`name\`) + 3)) = \`r\`.\`name\` || 'Ids'
+      AND (
+        \`p\`.\`name\` IN (
+          substr(\`metadata\`.\`property_name\`, 1, length(\`metadata\`.\`property_name\`) - length(\`r\`.\`name\`) - 3),
+          substr(\`metadata\`.\`property_name\`, 1, length(\`metadata\`.\`property_name\`) - length(\`r\`.\`name\`) - 3) || 's',
+          substr(\`metadata\`.\`property_name\`, 1, length(\`metadata\`.\`property_name\`) - length(\`r\`.\`name\`) - 3) || 'es'
+        ) OR (
+          substr(\`metadata\`.\`property_name\`, length(\`metadata\`.\`property_name\`) - length(\`r\`.\`name\`) - 3, 1) = 'y'
+          AND \`p\`.\`name\` = substr(\`metadata\`.\`property_name\`, 1, length(\`metadata\`.\`property_name\`) - length(\`r\`.\`name\`) - 4) || 'ies'
+        )
+      )
+    )
+  )
+)
+WHERE \`property_id\` IS NULL AND (
+  SELECT COUNT(*) FROM \`seeds\` \`s\`
+  JOIN \`models\` \`m\` ON \`m\`.\`schema_file_id\` = \`s\`.\`model_file_id\`
+  JOIN \`properties\` \`p\` ON \`p\`.\`model_id\` = \`m\`.\`id\`
+  LEFT JOIN \`models\` \`r\` ON \`r\`.\`id\` = \`p\`.\`ref_model_id\`
+  WHERE \`s\`.\`local_id\` = \`metadata\`.\`seed_local_id\` AND (
+    (
+      (\`p\`.\`data_type\` IN ('Image', 'File', 'Html', 'Relation') OR \`p\`.\`ref_value_type\` IN ('Image', 'File', 'Html', 'Relation'))
+      AND \`p\`.\`name\` || 'Id' = \`metadata\`.\`property_name\`
+    ) OR (
+      \`p\`.\`data_type\` = 'List' AND \`r\`.\`name\` IS NOT NULL
+      AND length(\`metadata\`.\`property_name\`) > length(\`r\`.\`name\`) + 3
+      AND substr(\`metadata\`.\`property_name\`, -(length(\`r\`.\`name\`) + 3)) = \`r\`.\`name\` || 'Ids'
+      AND (
+        \`p\`.\`name\` IN (
+          substr(\`metadata\`.\`property_name\`, 1, length(\`metadata\`.\`property_name\`) - length(\`r\`.\`name\`) - 3),
+          substr(\`metadata\`.\`property_name\`, 1, length(\`metadata\`.\`property_name\`) - length(\`r\`.\`name\`) - 3) || 's',
+          substr(\`metadata\`.\`property_name\`, 1, length(\`metadata\`.\`property_name\`) - length(\`r\`.\`name\`) - 3) || 'es'
+        ) OR (
+          substr(\`metadata\`.\`property_name\`, length(\`metadata\`.\`property_name\`) - length(\`r\`.\`name\`) - 3, 1) = 'y'
+          AND \`p\`.\`name\` = substr(\`metadata\`.\`property_name\`, 1, length(\`metadata\`.\`property_name\`) - length(\`r\`.\`name\`) - 4) || 'ies'
+        )
+      )
+    )
+  )
+) = 1;
+`;
+const migrationSql_0028_add_definition_to_properties = `ALTER TABLE \`properties\` ADD \`definition\` text;
+--> statement-breakpoint
+-- Backfill from the stored schema files: a property row takes the property object whose \`id\` is
+-- its schema_file_id, from the newest schema version that has one. Rows no stored file names by id
+-- keep NULL and read their definition from the columns alone.
+UPDATE \`properties\` SET \`definition\` = (
+	SELECT \`p\`.\`value\`
+	FROM \`schemas\` \`s\`,
+		json_each(CASE WHEN json_valid(\`s\`.\`schema_data\`) THEN \`s\`.\`schema_data\` ELSE '{}' END, '$.models') \`m\`,
+		json_each(\`m\`.\`value\`, '$.properties') \`p\`
+	WHERE \`m\`.\`type\` = 'object'
+		AND json_type(\`m\`.\`value\`, '$.properties') = 'object'
+		AND \`p\`.\`type\` = 'object'
+		AND json_extract(\`p\`.\`value\`, '$.id') = \`properties\`.\`schema_file_id\`
+	ORDER BY \`s\`.\`version\` DESC, \`s\`.\`id\` DESC
+	LIMIT 1
+) WHERE \`definition\` IS NULL AND \`schema_file_id\` IS NOT NULL;
+`;
+const migrationSql_0029_dedupe_chain_uids_add_unique_indexes = `-- Unique keys the writers already assume (SDK audit T9): one model_schemas link per model and
+-- schema, and one seeds / versions row per attested uid (placeholder uids are left out, see
+-- seedSchema/attestedUid.ts). Duplicates are merged first. The survivor is the row with local
+-- children (versions for a seed, metadata for a version), then the oldest; the duplicate's
+-- references move to it, columns it lacks are copied from the duplicate, and the duplicate is
+-- deleted.
+CREATE TABLE \`__t9_seed_merge\` (\`dup_rowid\` integer PRIMARY KEY, \`dup\` text, \`keep\` text);
+--> statement-breakpoint
+INSERT INTO \`__t9_seed_merge\` (\`dup_rowid\`, \`dup\`, \`keep\`)
+SELECT \`rid\`, \`local_id\`, \`keep\` FROM (
+  SELECT \`s\`.\`rowid\` AS \`rid\`, \`s\`.\`local_id\`,
+    first_value(\`s\`.\`local_id\`) OVER \`w\` AS \`keep\`,
+    row_number() OVER \`w\` AS \`rank\`
+  FROM \`seeds\` \`s\`
+  WHERE \`s\`.\`uid\` IS NOT NULL AND trim(\`s\`.\`uid\`) NOT IN ('', 'NULL') AND lower(trim(\`s\`.\`uid\`)) != '0x0000000000000000000000000000000000000000000000000000000000000000'
+  WINDOW \`w\` AS (
+    PARTITION BY \`s\`.\`uid\`
+    ORDER BY (\`s\`.\`local_id\` IS NULL),
+      EXISTS (SELECT 1 FROM \`versions\` \`v\` WHERE \`v\`.\`seed_local_id\` = \`s\`.\`local_id\`) DESC,
+      COALESCE(\`s\`.\`created_at\`, 9223372036854775807), \`s\`.\`rowid\`
+  )
+)
+WHERE \`rank\` > 1;
+--> statement-breakpoint
+UPDATE \`seeds\` SET
+  \`schema_uid\` = COALESCE(\`schema_uid\`, (SELECT \`d\`.\`schema_uid\` FROM \`__t9_seed_merge\` \`m\` JOIN \`seeds\` \`d\` ON \`d\`.\`rowid\` = \`m\`.\`dup_rowid\` WHERE \`m\`.\`keep\` = \`seeds\`.\`local_id\` AND \`d\`.\`schema_uid\` IS NOT NULL LIMIT 1)),
+  \`type\` = COALESCE(\`type\`, (SELECT \`d\`.\`type\` FROM \`__t9_seed_merge\` \`m\` JOIN \`seeds\` \`d\` ON \`d\`.\`rowid\` = \`m\`.\`dup_rowid\` WHERE \`m\`.\`keep\` = \`seeds\`.\`local_id\` AND \`d\`.\`type\` IS NOT NULL LIMIT 1)),
+  \`model_file_id\` = COALESCE(\`model_file_id\`, (SELECT \`d\`.\`model_file_id\` FROM \`__t9_seed_merge\` \`m\` JOIN \`seeds\` \`d\` ON \`d\`.\`rowid\` = \`m\`.\`dup_rowid\` WHERE \`m\`.\`keep\` = \`seeds\`.\`local_id\` AND \`d\`.\`model_file_id\` IS NOT NULL LIMIT 1)),
+  \`publisher\` = COALESCE(\`publisher\`, (SELECT \`d\`.\`publisher\` FROM \`__t9_seed_merge\` \`m\` JOIN \`seeds\` \`d\` ON \`d\`.\`rowid\` = \`m\`.\`dup_rowid\` WHERE \`m\`.\`keep\` = \`seeds\`.\`local_id\` AND \`d\`.\`publisher\` IS NOT NULL LIMIT 1)),
+  \`attestation_raw\` = COALESCE(\`attestation_raw\`, (SELECT \`d\`.\`attestation_raw\` FROM \`__t9_seed_merge\` \`m\` JOIN \`seeds\` \`d\` ON \`d\`.\`rowid\` = \`m\`.\`dup_rowid\` WHERE \`m\`.\`keep\` = \`seeds\`.\`local_id\` AND \`d\`.\`attestation_raw\` IS NOT NULL LIMIT 1)),
+  \`attestation_created_at\` = COALESCE(\`attestation_created_at\`, (SELECT \`d\`.\`attestation_created_at\` FROM \`__t9_seed_merge\` \`m\` JOIN \`seeds\` \`d\` ON \`d\`.\`rowid\` = \`m\`.\`dup_rowid\` WHERE \`m\`.\`keep\` = \`seeds\`.\`local_id\` AND \`d\`.\`attestation_created_at\` IS NOT NULL LIMIT 1))
+WHERE \`local_id\` IN (SELECT \`keep\` FROM \`__t9_seed_merge\`);
+--> statement-breakpoint
+-- A property row the survivor already has (same attestation uid) is not moved.
+DELETE FROM \`metadata\`
+WHERE \`seed_local_id\` IN (SELECT \`dup\` FROM \`__t9_seed_merge\` WHERE \`keep\` IS NOT NULL)
+  AND \`metadata\`.\`uid\` IS NOT NULL AND trim(\`metadata\`.\`uid\`) NOT IN ('', 'NULL') AND lower(trim(\`metadata\`.\`uid\`)) != '0x0000000000000000000000000000000000000000000000000000000000000000'
+  AND EXISTS (
+    SELECT 1 FROM \`metadata\` \`k\` JOIN \`__t9_seed_merge\` \`m\` ON \`k\`.\`seed_local_id\` = \`m\`.\`keep\`
+    WHERE \`m\`.\`dup\` = \`metadata\`.\`seed_local_id\` AND \`k\`.\`uid\` = \`metadata\`.\`uid\`
+  );
+--> statement-breakpoint
+UPDATE \`metadata\` SET \`seed_local_id\` = (SELECT \`keep\` FROM \`__t9_seed_merge\` WHERE \`dup\` = \`metadata\`.\`seed_local_id\`)
+WHERE \`seed_local_id\` IN (SELECT \`dup\` FROM \`__t9_seed_merge\` WHERE \`keep\` IS NOT NULL);
+--> statement-breakpoint
+UPDATE \`versions\` SET \`seed_local_id\` = (SELECT \`keep\` FROM \`__t9_seed_merge\` WHERE \`dup\` = \`versions\`.\`seed_local_id\`)
+WHERE \`seed_local_id\` IN (SELECT \`dup\` FROM \`__t9_seed_merge\` WHERE \`keep\` IS NOT NULL);
+--> statement-breakpoint
+UPDATE \`pending_writes\` SET \`seed_local_id\` = (SELECT \`keep\` FROM \`__t9_seed_merge\` WHERE \`dup\` = \`pending_writes\`.\`seed_local_id\`)
+WHERE \`seed_local_id\` IN (SELECT \`dup\` FROM \`__t9_seed_merge\` WHERE \`keep\` IS NOT NULL);
+--> statement-breakpoint
+UPDATE \`publish_processes\` SET \`seed_local_id\` = (SELECT \`keep\` FROM \`__t9_seed_merge\` WHERE \`dup\` = \`publish_processes\`.\`seed_local_id\`)
+WHERE \`seed_local_id\` IN (SELECT \`dup\` FROM \`__t9_seed_merge\` WHERE \`keep\` IS NOT NULL);
+--> statement-breakpoint
+UPDATE \`arweave_l1_finalize_jobs\` SET \`seed_local_id\` = (SELECT \`keep\` FROM \`__t9_seed_merge\` WHERE \`dup\` = \`arweave_l1_finalize_jobs\`.\`seed_local_id\`)
+WHERE \`seed_local_id\` IN (SELECT \`dup\` FROM \`__t9_seed_merge\` WHERE \`keep\` IS NOT NULL);
+--> statement-breakpoint
+UPDATE \`html_embedded_image_co_publish\` SET \`image_seed_local_id\` = (SELECT \`keep\` FROM \`__t9_seed_merge\` WHERE \`dup\` = \`html_embedded_image_co_publish\`.\`image_seed_local_id\`)
+WHERE \`image_seed_local_id\` IN (SELECT \`dup\` FROM \`__t9_seed_merge\` WHERE \`keep\` IS NOT NULL);
+--> statement-breakpoint
+UPDATE OR IGNORE \`html_embedded_image_co_publish\` SET \`parent_seed_local_id\` = (SELECT \`keep\` FROM \`__t9_seed_merge\` WHERE \`dup\` = \`html_embedded_image_co_publish\`.\`parent_seed_local_id\`)
+WHERE \`parent_seed_local_id\` IN (SELECT \`dup\` FROM \`__t9_seed_merge\` WHERE \`keep\` IS NOT NULL);
+--> statement-breakpoint
+DELETE FROM \`html_embedded_image_co_publish\` WHERE \`parent_seed_local_id\` IN (SELECT \`dup\` FROM \`__t9_seed_merge\` WHERE \`keep\` IS NOT NULL);
+--> statement-breakpoint
+UPDATE OR IGNORE \`html_embedded_image_co_publish\` SET \`html_seed_local_id\` = (SELECT \`keep\` FROM \`__t9_seed_merge\` WHERE \`dup\` = \`html_embedded_image_co_publish\`.\`html_seed_local_id\`)
+WHERE \`html_seed_local_id\` IN (SELECT \`dup\` FROM \`__t9_seed_merge\` WHERE \`keep\` IS NOT NULL);
+--> statement-breakpoint
+DELETE FROM \`html_embedded_image_co_publish\` WHERE \`html_seed_local_id\` IN (SELECT \`dup\` FROM \`__t9_seed_merge\` WHERE \`keep\` IS NOT NULL);
+--> statement-breakpoint
+DELETE FROM \`seeds\` WHERE \`rowid\` IN (SELECT \`dup_rowid\` FROM \`__t9_seed_merge\`);
+--> statement-breakpoint
+DROP TABLE \`__t9_seed_merge\`;
+--> statement-breakpoint
+CREATE TABLE \`__t9_version_merge\` (\`dup_rowid\` integer PRIMARY KEY, \`dup\` text, \`keep\` text);
+--> statement-breakpoint
+INSERT INTO \`__t9_version_merge\` (\`dup_rowid\`, \`dup\`, \`keep\`)
+SELECT \`rid\`, \`local_id\`, \`keep\` FROM (
+  SELECT \`v\`.\`rowid\` AS \`rid\`, \`v\`.\`local_id\`,
+    first_value(\`v\`.\`local_id\`) OVER \`w\` AS \`keep\`,
+    row_number() OVER \`w\` AS \`rank\`
+  FROM \`versions\` \`v\`
+  WHERE \`v\`.\`uid\` IS NOT NULL AND trim(\`v\`.\`uid\`) NOT IN ('', 'NULL') AND lower(trim(\`v\`.\`uid\`)) != '0x0000000000000000000000000000000000000000000000000000000000000000'
+  WINDOW \`w\` AS (
+    PARTITION BY \`v\`.\`uid\`
+    ORDER BY (\`v\`.\`local_id\` IS NULL),
+      EXISTS (SELECT 1 FROM \`metadata\` \`md\` WHERE \`md\`.\`version_local_id\` = \`v\`.\`local_id\`) DESC,
+      COALESCE(\`v\`.\`created_at\`, 9223372036854775807), \`v\`.\`rowid\`
+  )
+)
+WHERE \`rank\` > 1;
+--> statement-breakpoint
+UPDATE \`versions\` SET
+  \`seed_uid\` = COALESCE(\`seed_uid\`, (SELECT \`d\`.\`seed_uid\` FROM \`__t9_version_merge\` \`m\` JOIN \`versions\` \`d\` ON \`d\`.\`rowid\` = \`m\`.\`dup_rowid\` WHERE \`m\`.\`keep\` = \`versions\`.\`local_id\` AND \`d\`.\`seed_uid\` IS NOT NULL LIMIT 1)),
+  \`seed_type\` = COALESCE(\`seed_type\`, (SELECT \`d\`.\`seed_type\` FROM \`__t9_version_merge\` \`m\` JOIN \`versions\` \`d\` ON \`d\`.\`rowid\` = \`m\`.\`dup_rowid\` WHERE \`m\`.\`keep\` = \`versions\`.\`local_id\` AND \`d\`.\`seed_type\` IS NOT NULL LIMIT 1)),
+  \`attestation_raw\` = COALESCE(\`attestation_raw\`, (SELECT \`d\`.\`attestation_raw\` FROM \`__t9_version_merge\` \`m\` JOIN \`versions\` \`d\` ON \`d\`.\`rowid\` = \`m\`.\`dup_rowid\` WHERE \`m\`.\`keep\` = \`versions\`.\`local_id\` AND \`d\`.\`attestation_raw\` IS NOT NULL LIMIT 1)),
+  \`attestation_created_at\` = COALESCE(\`attestation_created_at\`, (SELECT \`d\`.\`attestation_created_at\` FROM \`__t9_version_merge\` \`m\` JOIN \`versions\` \`d\` ON \`d\`.\`rowid\` = \`m\`.\`dup_rowid\` WHERE \`m\`.\`keep\` = \`versions\`.\`local_id\` AND \`d\`.\`attestation_created_at\` IS NOT NULL LIMIT 1)),
+  \`publisher\` = COALESCE(\`publisher\`, (SELECT \`d\`.\`publisher\` FROM \`__t9_version_merge\` \`m\` JOIN \`versions\` \`d\` ON \`d\`.\`rowid\` = \`m\`.\`dup_rowid\` WHERE \`m\`.\`keep\` = \`versions\`.\`local_id\` AND \`d\`.\`publisher\` IS NOT NULL LIMIT 1)),
+  \`revoked_at\` = COALESCE(\`revoked_at\`, (SELECT \`d\`.\`revoked_at\` FROM \`__t9_version_merge\` \`m\` JOIN \`versions\` \`d\` ON \`d\`.\`rowid\` = \`m\`.\`dup_rowid\` WHERE \`m\`.\`keep\` = \`versions\`.\`local_id\` AND \`d\`.\`revoked_at\` IS NOT NULL LIMIT 1))
+WHERE \`local_id\` IN (SELECT \`keep\` FROM \`__t9_version_merge\`);
+--> statement-breakpoint
+UPDATE \`metadata\` SET \`version_local_id\` = (SELECT \`keep\` FROM \`__t9_version_merge\` WHERE \`dup\` = \`metadata\`.\`version_local_id\`)
+WHERE \`version_local_id\` IN (SELECT \`dup\` FROM \`__t9_version_merge\` WHERE \`keep\` IS NOT NULL);
+--> statement-breakpoint
+UPDATE \`arweave_l1_finalize_jobs\` SET \`version_local_id\` = (SELECT \`keep\` FROM \`__t9_version_merge\` WHERE \`dup\` = \`arweave_l1_finalize_jobs\`.\`version_local_id\`)
+WHERE \`version_local_id\` IN (SELECT \`dup\` FROM \`__t9_version_merge\` WHERE \`keep\` IS NOT NULL);
+--> statement-breakpoint
+DELETE FROM \`versions\` WHERE \`rowid\` IN (SELECT \`dup_rowid\` FROM \`__t9_version_merge\`);
+--> statement-breakpoint
+DROP TABLE \`__t9_version_merge\`;
+--> statement-breakpoint
+DELETE FROM \`model_schemas\`
+WHERE \`model_id\` IS NOT NULL AND \`schema_id\` IS NOT NULL
+  AND \`id\` NOT IN (SELECT MIN(\`id\`) FROM \`model_schemas\` GROUP BY \`model_id\`, \`schema_id\`);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`model_schemas_model_id_schema_id_unique\` ON \`model_schemas\` (\`model_id\`,\`schema_id\`);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`seeds_attested_uid_unique\` ON \`seeds\` (\`uid\`) WHERE "seeds"."uid" IS NOT NULL AND trim("seeds"."uid") NOT IN ('', 'NULL') AND lower(trim("seeds"."uid")) != '0x0000000000000000000000000000000000000000000000000000000000000000';
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`versions_attested_uid_unique\` ON \`versions\` (\`uid\`) WHERE "versions"."uid" IS NOT NULL AND trim("versions"."uid") NOT IN ('', 'NULL') AND lower(trim("versions"."uid")) != '0x0000000000000000000000000000000000000000000000000000000000000000';
+`;
 // Journal JSON file
 const journalJson = `{
   "version": "7",
@@ -2573,16 +2763,45 @@ const journalJson = `{
       "when": 1792585560172,
       "tag": "0025_add_metadata_retract",
       "breakpoints": true
+    },
+    {
+      "idx": 26,
+      "version": "6",
+      "when": 1792587787468,
+      "tag": "0026_add_content_hash_to_schemas",
+      "breakpoints": true
+    },
+    {
+      "idx": 27,
+      "version": "6",
+      "when": 1792587787964,
+      "tag": "0027_link_metadata_property_ids",
+      "breakpoints": true
+    },
+    {
+      "idx": 28,
+      "version": "6",
+      "when": 1792596417502,
+      "tag": "0028_add_definition_to_properties",
+      "breakpoints": true
+    },
+    {
+      "idx": 29,
+      "version": "6",
+      "when": 1792596480144,
+      "tag": "0029_dedupe_chain_uids_add_unique_indexes",
+      "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": "932b9df0-151c-4c9c-83d4-516250bd7b31",
-  "prevId": "3264e54f-0bb8-4116-87e8-b059b4ac1ae7",
+  "id": "0937d0b1-f4ea-4ae1-885b-7173e7b786b9",
+  "prevId": "083c3909-4feb-4b61-bf23-fa806a60b826",
   "tables": {
     "appState": {
       "name": "appState",
@@ -3347,6 +3566,13 @@ const snapshotJson = `{
           "primaryKey": false,
           "notNull": false,
           "autoincrement": false
+        },
+        "definition": {
+          "name": "definition",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
         }
       },
       "indexes": {
@@ -3423,7 +3649,16 @@ const snapshotJson = `{
           "autoincrement": false
         }
       },
-      "indexes": {},
+      "indexes": {
+        "model_schemas_model_id_schema_id_unique": {
+          "name": "model_schemas_model_id_schema_id_unique",
+          "columns": [
+            "model_id",
+            "schema_id"
+          ],
+          "isUnique": true
+        }
+      },
       "foreignKeys": {
         "model_schemas_model_id_models_id_fk": {
           "name": "model_schemas_model_id_models_id_fk",
@@ -3905,6 +4140,13 @@ const snapshotJson = `{
           "notNull": false,
           "autoincrement": false
         },
+        "content_hash": {
+          "name": "content_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
         "created_at": {
           "name": "created_at",
           "type": "integer",
@@ -4043,6 +4285,14 @@ const snapshotJson = `{
             "type"
           ],
           "isUnique": false
+        },
+        "seeds_attested_uid_unique": {
+          "name": "seeds_attested_uid_unique",
+          "columns": [
+            "uid"
+          ],
+          "isUnique": true,
+          "where": "\\"seeds\\".\\"uid\\" IS NOT NULL AND trim(\\"seeds\\".\\"uid\\") NOT IN ('', 'NULL') AND lower(trim(\\"seeds\\".\\"uid\\")) != '0x0000000000000000000000000000000000000000000000000000000000000000'"
         }
       },
       "foreignKeys": {},
@@ -4211,6 +4461,14 @@ const snapshotJson = `{
             "seed_local_id"
           ],
           "isUnique": false
+        },
+        "versions_attested_uid_unique": {
+          "name": "versions_attested_uid_unique",
+          "columns": [
+            "uid"
+          ],
+          "isUnique": true,
+          "where": "\\"versions\\".\\"uid\\" IS NOT NULL AND trim(\\"versions\\".\\"uid\\") NOT IN ('', 'NULL') AND lower(trim(\\"versions\\".\\"uid\\")) != '0x0000000000000000000000000000000000000000000000000000000000000000'"
         }
       },
       "foreignKeys": {},
@@ -4260,6 +4518,10 @@ var drizzleFiles = /*#__PURE__*/Object.freeze({
     migrationSql_0023_add_entity_changes: migrationSql_0023_add_entity_changes,
     migrationSql_0024_merge_republished_ghost_seeds: migrationSql_0024_merge_republished_ghost_seeds,
     migrationSql_0025_add_metadata_retract: migrationSql_0025_add_metadata_retract,
+    migrationSql_0026_add_content_hash_to_schemas: migrationSql_0026_add_content_hash_to_schemas,
+    migrationSql_0027_link_metadata_property_ids: migrationSql_0027_link_metadata_property_ids,
+    migrationSql_0028_add_definition_to_properties: migrationSql_0028_add_definition_to_properties,
+    migrationSql_0029_dedupe_chain_uids_add_unique_indexes: migrationSql_0029_dedupe_chain_uids_add_unique_indexes,
     snapshotJson: snapshotJson
 });
 
@@ -4320,7 +4582,7 @@ async function applyEmbeddedMigrations(db, migrations, migrationsTable = '__driz
     }
 }
 
-const logger$2 = debug('seedSdk:browser:db:createSqlocalDrizzle');
+const logger$1 = 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;
@@ -4441,7 +4703,7 @@ function installModuleWorkerBlobWrap(onWorkerFailed) {
             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);
+            logger$1('[createSqlocalDrizzle] worker failed', error.message);
             onWorkerFailed(error);
         };
         worker.addEventListener('error', fail);
@@ -4456,7 +4718,7 @@ function installModuleWorkerBlobWrap(onWorkerFailed) {
     };
 }
 
-const logger$1 = debug('seedSdk:browser:db:Db');
+const logger = debug('seedSdk:browser:db:Db');
 class BrowserDb {
     constructor() {
         /** Live queries by SQL + params while they have subscribers; see liveQuery. */
@@ -4469,7 +4731,7 @@ class BrowserDb {
         return !!this.appDb;
     }
     async prepareDb(filesDir) {
-        logger$1('[Db.prepareDb] preparing database');
+        logger('[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.
@@ -4500,7 +4762,7 @@ class BrowserDb {
             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`);
+            logger(`[Db.prepareDb] SQLocal opened a "${storageType}" database; retrying in ${waitMs} ms`);
             await new Promise((resolve) => setTimeout(resolve, waitMs));
         }
     }
@@ -4521,11 +4783,6 @@ class BrowserDb {
                     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');
             // SQLite's OPFS VFS needs SharedArrayBuffer and Atomics. Without them SQLocal quietly
             // opens an in-memory database, so fail before starting the worker.
             if (typeof SharedArrayBuffer === 'undefined' || typeof Atomics === 'undefined') {
@@ -4546,24 +4803,19 @@ class BrowserDb {
             const db = drizzle(driver, batchDriver, {
                 schema,
             });
-            logger$1('[Db.prepareDb] database prepared');
+            logger('[Db.prepareDb] database prepared');
             await raceSqlocalStartup((async () => {
                 await recreateIfOlderThanMinimumUpgradeVersion(db);
                 await this.runMigrations(db);
                 this.appDb = db;
-                const { backfillMetadataPropertyIds } = await import('./backfillMetadataPropertyIds-C7P7FL6F.js');
-                await backfillMetadataPropertyIds();
                 // 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, {
-                    liveQuery: (query) => this.liveQuery(query),
-                    sql: ((...args) => sqlocalDrizzle.sql(...args)),
-                });
+                // after the migrations above, so their log rows aren't dispatched.
+                await startChangeFeed(db, { liveQuery: (query) => this.liveQuery(query) });
             })(), workerFailed);
             return this.appDb;
         }
         catch (error) {
-            logger$1('[Db.prepareDb] error', JSON.stringify(error));
+            logger('[Db.prepareDb] error', JSON.stringify(error));
             throw error;
         }
     }
@@ -4571,7 +4823,7 @@ class BrowserDb {
         return undefined;
     }
     async copyDrizzleFiles(filesDir) {
-        logger$1('[Db.copyDrizzleFiles] copying drizzle migration files');
+        logger('[Db.copyDrizzleFiles] copying drizzle migration files');
         try {
             // Ensure db directory exists
             const dbDirPath = `${filesDir}/db`;
@@ -4583,7 +4835,7 @@ class BrowserDb {
             const journal = JSON.parse(journalJson);
             const entries = journal.entries || [];
             if (entries.length === 0) {
-                logger$1('[Db.copyDrizzleFiles] no migration entries found in journal');
+                logger('[Db.copyDrizzleFiles] no migration entries found in journal');
                 return;
             }
             // Copy each migration SQL file (always overwrite to ensure they're up-to-date)
@@ -4597,16 +4849,16 @@ class BrowserDb {
                 const migrationVarName = `migrationSql_${tag}`;
                 const migrationContent = drizzleFiles[migrationVarName];
                 if (!migrationContent) {
-                    logger$1(`[Db.copyDrizzleFiles] ERROR: No migration content found for ${migrationFileName} (variable: ${migrationVarName})`);
+                    logger(`[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}`);
+                logger(`[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');
+            logger('[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
@@ -4617,11 +4869,11 @@ class BrowserDb {
             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');
+            logger(`[Db.copyDrizzleFiles] copied/updated snapshot JSON file: ${snapshotFileName}`);
+            logger('[Db.copyDrizzleFiles] drizzle files copied successfully');
         }
         catch (error) {
-            logger$1('[Db.copyDrizzleFiles] error copying drizzle files', error);
+            logger('[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
         }
@@ -4630,12 +4882,12 @@ class BrowserDb {
     async runMigrations(db, _pathToDbDir) {
         try {
             const migrations = getEmbeddedMigrations();
-            logger$1('[Db.runMigrations] embedded migrations', migrations.length);
+            logger('[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');
+            logger('[Db.runMigrations] migrations completed');
         }
         catch (error) {
-            logger$1('[Db.runMigrations] error', JSON.stringify(error));
+            logger('[Db.runMigrations] error', JSON.stringify(error));
             throw error;
         }
     }
@@ -4742,12 +4994,12 @@ class BrowserDb {
                     countRun();
                     subscriber.next(data);
                 }, (err) => {
-                    logger$1('[BaseDb.liveQuery] SQLocal reactiveQuery error:', err);
+                    logger('[BaseDb.liveQuery] SQLocal reactiveQuery error:', err);
                     subscriber.error(err);
                 });
             }
             catch (error) {
-                logger$1('[BaseDb.liveQuery] SQLocal reactiveQuery setup failed:', error);
+                logger('[BaseDb.liveQuery] SQLocal reactiveQuery setup failed:', error);
                 subscriber.error(error);
                 return;
             }
@@ -4796,224 +5048,13 @@ function liveQueryKey(statement) {
     }
 }
 
-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) {
-        return fetchTransactionStatusAcrossGateways(transactionId);
-    }
-    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: createEasGraphQLClient(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.query({
-                    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 {
         fileManager: new BrowserFileManager(),
         db: new BrowserDb(),
-        arweaveClient: new BrowserArweaveClient(),
-        easClient: new BrowserEasClient(),
-        queryClient: new BrowserQueryClient(),
+        arweaveClient: new DefaultArweaveClient(),
+        easClient: new DefaultEasClient(),
+        queryClient: new DefaultQueryClient(),
     };
 }
 /**
@@ -5025,4 +5066,4 @@ function resolveFilesDir(filesDir) {
 }
 
 export { createPlatformServices as c, isSkippableOpfsEntryError as i, resolveFilesDir as r };
-//# sourceMappingURL=index.browser-QPWBkLJA.js.map
+//# sourceMappingURL=index.browser-CUmBVYen.js.map