@seedprotocol/sdk 0.7.9-next.1110.g7eb9e57 → 0.7.9-next.1177.ga3e08ed

package/dist/{ClientManager-B1r_8P5Z.js → ClientManager-GZfXErDX.js}

@@ -1,15 +1,16 @@
-import { startCase, isEqual } from 'lodash-es';
-import { G as BaseDb, l as easSyncProcesses, J as eventEmitter, au as isBrowser, a4 as isNode, aI as normalizeAddressConfig, aX as isTestOrSeedDev, h as appState, aY as downloadAllFilesRequestHandler, aZ as downloadAllFilesBinaryRequestHandler, Q as BaseFileManager, ag as loadNameMatchLevels, t as models$1, s as modelUids, C as seeds, aJ as normalizeAddressList, B as schemas, aU as loadModelsFromDbForSchema, aQ as addSchemaToDb, aN as isInternalSchema, aj as generateId, aW as clearNameMatchLevels, a_ as warnOnInvalidNameMatch, a$ as INTERNAL_SCHEMA_IDS, b0 as linkModelToSchema, n as normalizeDataType, ad as easPropertyNameForPublish, ay as SEED_PROTOCOL_SCHEMA_NAME, r as modelSchemas, a2 as getItemStorageSubdir, a3 as getItemStorageLocalFileName, m as metadata$1, w as properties, O as resolveItemModelFileId, F as versions, ae as normalizePublisher, v as pendingWrites, b1 as getMetadataPropertyNamesForQuery, p as htmlEmbeddedImageCoPublish, j as arweaveL1FinalizeJobs, A as publishProcesses, b2 as getWatchedAddressesFromDb, b3 as getOwnedAddressesFromDb, b4 as CLIENT_NOT_INITIALIZED } from './index-C0SetTd1.js';
+import { isEqual } from 'lodash-es';
+import { L as BaseDb, u as easSyncProcesses, am as isBrowser, $ as isNode, aA as normalizeAddressConfig, aQ as isTestOrSeedDev, h as appState, Q as BaseFileManager, aa as loadNameMatchLevels, p as models$1, o as modelUids, s as seeds, aB as normalizeAddressList, J as schemas, aL as loadModelsFromDbForSchema, aN as addSchemaToDb, aF as isInternalSchema, ad as generateId, aR as warnOnInvalidNameMatch, aS as INTERNAL_SCHEMA_IDS, aT as linkModelToSchema, n as normalizeDataType, a7 as easPropertyNameForPublish, aq as SEED_PROTOCOL_SCHEMA_NAME, z as modelSchemas, v as versions, m as metadata$1, Z as getItemStorageSubdir, _ as getItemStorageLocalFileName, C as pendingWrites, aU as getMetadataPropertyNamesForQuery, x as htmlEmbeddedImageCoPublish, t as arweaveL1FinalizeJobs, I as publishProcesses, a8 as normalizePublisher, aV as getWatchedAddressesFromDb, aW as getOwnedAddressesFromDb, aX as CLIENT_NOT_INITIALIZED } from './index-Dx_GTdyQ.js';
 import debug from 'debug';
 import { createActor, setup, assign, fromPromise, fromCallback, waitFor } from 'xstate';
-import { Y as MachineIds, an as ClientManagerEvents, D as compareMetadataRowsLatestFirst, u as writeInBatches, ao as resolvePublisherFromSeedRow, ap as getSeedPublisher, aq as propertyNameVariants, M as METADATA_LATEST_FIRST_ORDER_SQL, L as selectInBatches, ar as createSeed, as as createMetadata, at as updateItemPropertyValue, s as registerOutboxApplier, q as outboxOpValue, i as OutboxOpDeferredError, t as startOutbox, j as OutboxOpFailedError, z as OwnershipError, B as isItemOwned, G as parseListPropertyValueFromStorage, X as ClientManagerState, a5 as isLocalUnsealedDraft, I as Item } from './Item-CjTEShfk.js';
-import { eq, inArray, and, isNotNull, ne, desc, countDistinct, isNull, or, sql, like, lt } from 'drizzle-orm';
-import { d as withDbTabLock, a as isLeaderTab, k as postTabMessage, o as onTabMessage, c as whenLeaderTab, l as listenForOtherTabsEvents, m as startTabCoordination, g as withSeedDbLock, e as emitAcrossTabs, A as ADDRESSES_PERSISTED_EVENT, q as tryWithTabLock, r as withTabLock, u as notifyFileSaved, p as parseAddressesPersistedPayload, L as LOCAL_COPIES_REMOVED_EVENT } from './changeFeed-DcsZ7deG.js';
+import { X as MachineIds, am as ClientManagerEvents, an as getSeedPublisher, ao as propertyNameVariants, M as METADATA_LATEST_FIRST_ORDER_SQL, z as selectInBatches, ap as createSeed, aq as createMetadata, C as compareMetadataRowsLatestFirst, ar as updateItemPropertyValue, r as registerOutboxApplier, n as outboxOpValue, i as OutboxOpDeferredError, s as startOutbox, j as OutboxOpFailedError, u as OwnershipError, x as isItemOwned, F as parseListPropertyValueFromStorage, W as ClientManagerState, as as resolvePublisherFromSeedRow, a4 as isLocalUnsealedDraft, y as writeInBatches, I as Item } from './Item-0oDoTPhi.js';
+import { eq, inArray, and, isNotNull, ne, desc, countDistinct, isNull, sql, lt, or, like } from 'drizzle-orm';
+import { d as withDbTabLock, a as isLeaderTab, k as postTabMessage, o as onTabMessage, c as whenLeaderTab, l as listenForOtherTabsEvents, m as startTabCoordination, g as withSeedDbLock, e as emitAcrossTabs, A as ADDRESSES_PERSISTED_EVENT, q as tryWithTabLock, r as notifyFileSaved, p as parseAddressesPersistedPayload, L as LOCAL_COPIES_REMOVED_EVENT } from './changeFeed-DKdVlUmt.js';
 import { seedGatewayConfigFromSeedConfig, setPreferredArweaveReadBaseUrls, resolveSeedGatewayEndpoints, setResolvedSeedGatewayEndpoints, BaseArweaveClient, ensureReadGatewaySelected, DEFAULT_ARWEAVE_HOST } from '@seedprotocol/arweave';
-import { configureEasReadChain, easName, BaseQueryClient, BaseEasClient, GET_SCHEMAS, whenEasReadChainSettled, getEasReadChainId, DEFAULT_EAS_CHAIN_ID, isEasReadChainConfigured, isPlaceholderUid, localNamesInBestMatchTier, isValidEasAttestationUid } from '@seedprotocol/eas';
+import { configureEasReadChain, easName, BaseQueryClient, BaseEasClient, GET_SCHEMAS, whenEasReadChainSettled, getEasReadChainId, DEFAULT_EAS_CHAIN_ID, isEasReadChainConfigured, localNamesInBestMatchTier, isPlaceholderUid, isValidEasAttestationUid } from '@seedprotocol/eas';
 import 'pluralize';
 import { sha3_256 } from '@noble/hashes/sha3';
 import { utf8ToBytes, bytesToHex } from '@noble/hashes/utils';
+import { e as eventEmitter } from './eventBus-7vxTCc3a.js';
 import { clearLocalQuerySource, registerLocalQuerySource, getSeed } from '@seedprotocol/query';
 
 let writeTail = Promise.resolve();
@@ -212,7 +213,7 @@ function toRunSyncArg(options) {
     return undefined;
 }
 const runEasSync = fromPromise(async ({ input, }) => {
-    const { runSyncFromEas } = await import('./syncDbWithEas-b4fESZ7C.js');
+    const { runSyncFromEas } = await import('./syncDbWithEas-DUu_wjUG.js');
     // Sync checks for rows and then inserts the rest (no unique index on uids), so syncs in
     // different tabs take turns. A sync can run for minutes, so wait without a timeout.
     await withDbTabLock('eas-sync', async () => {
@@ -271,7 +272,8 @@ const syncRetry = createRetryWhenOnline(() => {
 const initialContext = {
     runOptions: {},
     activeCorrelationIds: [],
-    activePrimarySource: 'event_bus',
+    // Replaced by the first request's source before any run.
+    activePrimarySource: 'models_init',
     pendingMergedOptions: undefined,
     pendingCorrelationIds: [],
     pendingPrimarySource: null,
@@ -394,7 +396,7 @@ const easSyncMachine = setup({
                         activeCorrelationIds: ({ context }) => [
                             ...context.pendingCorrelationIds,
                         ],
-                        activePrimarySource: ({ context }) => context.pendingPrimarySource ?? 'event_bus',
+                        activePrimarySource: ({ context }) => context.pendingPrimarySource ?? 'models_init',
                         pendingMergedOptions: () => undefined,
                         pendingCorrelationIds: () => [],
                         pendingPrimarySource: () => null,
@@ -422,7 +424,7 @@ function newCorrelationId() {
     return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
 }
 /** Requests deferred in this tab until it leads, by source; each runs once on takeover. */
-const deferredUntilLeader$5 = new Set();
+const deferredUntilLeader$1 = new Set();
 /**
  * Automatic syncs run in the leader tab only (docs/MULTI_TAB.md). A tab that skips one runs it if
  * it later becomes leader, so closing the leader doesn't lose the catch-up sync.
@@ -433,11 +435,11 @@ function runInLeaderTab(source, request) {
         return;
     }
     log(`${source} sync skipped: another tab leads`);
-    if (deferredUntilLeader$5.has(source))
+    if (deferredUntilLeader$1.has(source))
         return;
-    deferredUntilLeader$5.add(source);
+    deferredUntilLeader$1.add(source);
     void whenLeaderTab().then(() => {
-        deferredUntilLeader$5.delete(source);
+        deferredUntilLeader$1.delete(source);
         request();
     });
 }
@@ -453,17 +455,6 @@ function listenForEasSyncRequestsFromOtherTabs() {
         }
     });
 }
-function requestEasSyncFromEventBus() {
-    runInLeaderTab('event_bus', sendEventBusRequest);
-}
-function sendEventBusRequest() {
-    startEasSyncActor();
-    easSyncActor.send({
-        type: 'REQUEST',
-        correlationId: newCorrelationId(),
-        source: 'event_bus',
-    });
-}
 function requestEasSyncFromAddressChange(addresses) {
     if (!isLeaderTab()) {
         // The leader syncs these addresses; its own address list may be stale.
@@ -505,43 +496,18 @@ var easSyncManager = /*#__PURE__*/Object.freeze({
     easSyncMachine: easSyncMachine,
     listenForEasSyncRequestsFromOtherTabs: listenForEasSyncRequestsFromOtherTabs,
     requestEasSyncFromAddressChange: requestEasSyncFromAddressChange,
-    requestEasSyncFromEventBus: requestEasSyncFromEventBus,
     requestEasSyncFromModelsInit: requestEasSyncFromModelsInit,
     sendEasSyncClientRequest: sendEasSyncClientRequest,
     startEasSyncActor: startEasSyncActor
 });
 
-const logger$g = debug('seedSdk:services:events');
-const handleServiceSaveState = (event) => {
-    const { serviceId } = event;
-    logger$g(`[browser] [service.saveState.request] serviceId: ${serviceId}`);
-    // TODO: This is called from Node as well. Do we need it? If so, need to generalize this to all platforms.
-    // localStorage.setItem(`seed_sdk_service_${serviceId}`, JSON.stringify(state))
-};
-const setupServicesEventHandlers = () => {
-    eventEmitter.addListener('service.saveState.request', handleServiceSaveState);
-};
-
 const setupAllItemsEventHandlers = () => {
     startEasSyncActor();
     listenForEasSyncRequestsFromOtherTabs();
     listenForOtherTabsEvents();
-    eventEmitter.addListener('syncDbWithEas', requestEasSyncFromEventBus);
 };
 // Note: getAreItemEventHandlersReady removed - was only used by useItemIsReady hook which has been removed
 
-// AllItems services have been removed - this handler is no longer needed
-// Service state persistence is now handled by entity instances directly
-const saveServiceHandler = async (_event) => {
-    // AllItems services removed - this functionality is no longer needed
-    // Entity instances (Schema, Model, Item) manage their own state
-    console.warn('[saveServiceHandler] AllItems services removed - handler is a no-op');
-};
-
-const setupServiceHandlers = () => {
-    eventEmitter.addListener('service.save', saveServiceHandler);
-};
-
 /** `filesDir` when the config sets neither it nor `endpoints.files`. */
 const DEFAULT_FILES_DIR = '.seed';
 /**
@@ -563,9 +529,9 @@ function applySeedConfigDefaults(config) {
     return { ...config, filesDir, endpoints: next };
 }
 
-const logger$f = debug('seedSdk:ClientManager:initialize');
+const logger$b = debug('seedSdk:ClientManager:initialize');
 const platformClassesInit = fromCallback(({ sendBack, input: { context, event } }) => {
-    logger$f('initialize from ClientManager');
+    logger$b('initialize from ClientManager');
     const { isInitialized } = context;
     if (!event || !('options' in event)) {
         throw new Error('Initialize event must include options');
@@ -590,9 +556,7 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
         if (!config) {
             throw new Error('client.init requires a config');
         }
-        const _mod_0 = await import('./configurePlatform-AWild9o4.js');
-        const _ns_0 = _mod_0.a;
-        const { configurePlatform } = _ns_0;
+        const { configurePlatform } = await import('./configurePlatform-CrMafpMW.js');
         if (isBrowser()) {
             const { createPlatformServices } = await import('./platform.browser.js');
             configurePlatform(createPlatformServices());
@@ -630,7 +594,7 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
         BaseArweaveClient.setHost(`${resolvedGateway.arweaveProtocol}://${resolvedGateway.arweaveHost}`);
         // filesDir falls back to endpoints.files (applySeedConfigDefaults fills both)
         let normalizedFilesDir = filesDir || endpoints?.files;
-        // jsdom (and any env with both Node + window) is "browser" for SDK: PathResolver is OPFS/virtual.
+        // jsdom (and any env with both Node + window) is "browser" for SDK: filesDir is an OPFS path.
         // Do not run real fs against those paths (e.g. mkdir '/.seed').
         if (isNode() && !isBrowser() && normalizedFilesDir) {
             // Lives in the Node platform so browser bundles (and Next.js server builds, which
@@ -671,8 +635,6 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
         // Models are now Model instances, no registration needed
         // They should be created via Model.create() and are accessible via Model static methods
         setupAllItemsEventHandlers();
-        setupServicesEventHandlers();
-        setupServiceHandlers();
     });
     // Handle the promise immediately - this ensures rejections are caught synchronously
     // The catch handler is attached synchronously before the async function executes
@@ -703,7 +665,7 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
     };
 });
 
-const logger$e = debug('seedSdk:client:writeToDb');
+const logger$a = debug('seedSdk:client:writeToDb');
 const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
     const _saveAppState = async () => {
         try {
@@ -711,7 +673,7 @@ const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
             if (!appDb) {
                 // In test environments, continue anyway
                 if (isTestOrSeedDev()) {
-                    logger$e('[client/actors] [saveAppState] App DB not found, but continuing in test environment');
+                    logger$a('[client/actors] [saveAppState] App DB not found, but continuing in test environment');
                     return;
                 }
                 throw new Error('App DB not found');
@@ -727,13 +689,13 @@ const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
                     value: JSON.stringify(value),
                 },
             });
-            logger$e('result', result);
+            logger$a('result', result);
         }
         catch (error) {
-            logger$e('[client/actors] [saveAppState] Error saving app state:', error);
+            logger$a('[client/actors] [saveAppState] Error saving app state:', error);
             // In test environments, continue anyway
             if (isTestOrSeedDev()) {
-                logger$e('[client/actors] [saveAppState] Continuing despite error in test environment');
+                logger$a('[client/actors] [saveAppState] Continuing despite error in test environment');
                 return;
             }
             throw error;
@@ -748,10 +710,10 @@ const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
         });
     })
         .catch((error) => {
-        logger$e('[client/actors] [saveAppState] Error in promise chain:', error);
+        logger$a('[client/actors] [saveAppState] Error in promise chain:', error);
         // In test environments, still send success to allow state machine to progress
         if (isTestOrSeedDev()) {
-            logger$e('[client/actors] [saveAppState] Sending success despite error in test environment');
+            logger$a('[client/actors] [saveAppState] Sending success despite error in test environment');
             sendBack({
                 type: 'saveAppStateSuccess',
                 key,
@@ -769,29 +731,7 @@ const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
     });
 });
 
-let isInitialized = false;
-const fsInitHandler = async () => {
-    if (isInitialized) {
-        return;
-    }
-    isInitialized = true;
-};
-let areReady = false;
-const setupFsListeners = () => {
-    eventEmitter.addListener('fs.downloadAll.request', downloadAllFilesRequestHandler);
-    eventEmitter.addListener('fs.downloadAllBinary.request', downloadAllFilesBinaryRequestHandler);
-    eventEmitter.addListener('fs.init', fsInitHandler);
-    areReady = true;
-};
-const areFsListenersReady = () => {
-    return areReady;
-};
-
 const fileSystemInit = fromCallback(({ sendBack, input: { context }, }) => {
-    setupFsListeners();
-    if (!areFsListenersReady()) {
-        throw new Error('fs listeners not ready during init');
-    }
     // Check for filesDir synchronously before starting async operation
     // This ensures the error is thrown synchronously and caught by XState
     const { filesDir } = context;
@@ -800,7 +740,6 @@ const fileSystemInit = fromCallback(({ sendBack, input: { context }, }) => {
     }
     const _fileSystemInit = async () => {
         await BaseFileManager.initializeFileSystem(filesDir);
-        eventEmitter.emit('fs.init');
     };
     _fileSystemInit()
         .then(() => {
@@ -820,7 +759,7 @@ const fileSystemInit = fromCallback(({ sendBack, input: { context }, }) => {
     };
 });
 
-const logger$d = debug('seedSdk:client:actors:dbInit');
+const logger$9 = debug('seedSdk:client:actors:dbInit');
 const dbInit = fromCallback(({ sendBack, input: { context } }) => {
     const _dbInit = async () => {
         const { filesDir, dbConfig } = context;
@@ -834,14 +773,14 @@ const dbInit = fromCallback(({ sendBack, input: { context } }) => {
         if (!appDb) {
             throw new Error('Database not available after preparation');
         }
-        logger$d('[client/actors] [dbInit] Database prepared and ready');
+        logger$9('[client/actors] [dbInit] Database prepared and ready');
     };
     _dbInit()
         .then(() => {
         sendBack({ type: ClientManagerEvents.DB_READY });
     })
         .catch((error) => {
-        logger$d('Error in dbInit:', error);
+        logger$9('Error in dbInit:', error);
         sendBack({
             type: 'error',
             error: error instanceof Error ? error : new Error(String(error))
@@ -849,7 +788,7 @@ const dbInit = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$c = debug('seedSdk:client:actors:addModelsToStore');
+const logger$8 = debug('seedSdk:client:actors:addModelsToStore');
 const addModelsToStore = fromCallback(({ sendBack, input: { context } }) => {
     const _addModelsToStore = async () => {
         let { models } = context;
@@ -863,7 +802,7 @@ const addModelsToStore = fromCallback(({ sendBack, input: { context } }) => {
         // Models are now Model instances, no registration needed
         // They should be created via Model.create() and are accessible via Model static methods
         for (const [key] of Object.entries(allModels)) {
-            logger$c('model available:', key);
+            logger$8('model available:', key);
         }
     };
     _addModelsToStore()
@@ -871,7 +810,7 @@ const addModelsToStore = fromCallback(({ sendBack, input: { context } }) => {
         sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_STORE_SUCCESS });
     })
         .catch((error) => {
-        logger$c('[client/actors] [addModelsToStore] Error:', error);
+        logger$8('[client/actors] [addModelsToStore] Error:', error);
         sendBack({
             type: 'error',
             error: error instanceof Error ? error : new Error(String(error)),
@@ -879,7 +818,7 @@ const addModelsToStore = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$b = debug('seedSdk:client:actors:addModelsToDb');
+const logger$7 = debug('seedSdk:client:actors:addModelsToDb');
 /**
  * Returns every `models` row named in `modelNames`, inserting a null-schemaFileId stub for each name
  * with no row yet (the schema import adopts stubs via findOrCreateModelRecord). Check-then-insert:
@@ -902,7 +841,7 @@ async function ensureModelStubs(appDb, modelNames, filesDir) {
                 .returning({ id: models$1.id, name: models$1.name, schemaFileId: models$1.schemaFileId }));
             rows.push(...newlyInserted);
             for (const name of modelsToInsert) {
-                logger$b('[client/actors] [addModelsToDb] inserted model:', name);
+                logger$7('[client/actors] [addModelsToDb] inserted model:', name);
             }
         }
         return rows;
@@ -942,7 +881,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         for (const modelName of modelNames) {
             const foundModel = rowFor(modelName);
             if (!foundModel) {
-                logger$b('[client/actors] [addModelsToDb] Warning: Could not find or create model:', modelName);
+                logger$7('[client/actors] [addModelsToDb] Warning: Could not find or create model:', modelName);
                 hasModelsInDb = false;
                 continue;
             }
@@ -954,7 +893,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         }
         // If we have no models to process, still send success (empty models is valid)
         if (schemaDefsByModelName.size === 0) {
-            logger$b('[client/actors] [addModelsToDb] No models to process, but continuing');
+            logger$7('[client/actors] [addModelsToDb] No models to process, but continuing');
             return;
         }
         const schemaDefs = Array.from(schemaDefsByModelName.values()).map(({ schemaDef }) => schemaDef);
@@ -1001,15 +940,15 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
                     requestEasSyncFromModelsInit();
                 }
                 else {
-                    logger$b('[client/actors] [addModelsToDb] No schemas found from EAS, but continuing');
+                    logger$7('[client/actors] [addModelsToDb] No schemas found from EAS, but continuing');
                 }
             }
             catch (error) {
                 if (isTestOrSeedDev()) {
-                    logger$b('[client/actors] [addModelsToDb] Warning: Could not fetch schemas from EAS (background):', error.message);
+                    logger$7('[client/actors] [addModelsToDb] Warning: Could not fetch schemas from EAS (background):', error.message);
                 }
                 else {
-                    logger$b('[client/actors] [addModelsToDb] Error fetching schemas (background):', error.message);
+                    logger$7('[client/actors] [addModelsToDb] Error fetching schemas (background):', error.message);
                 }
                 // Probably offline: the startup sync waits for this lookup, so try again.
                 modelUidsRetry.schedule();
@@ -1023,16 +962,16 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
     _addModelsToDb()
         // Model.findByModelType reads the nameMatch levels synchronously: have them before init is ready.
         .then(() => loadNameMatchLevels().catch((error) => {
-        logger$b('[client/actors] [addModelsToDb] Could not load nameMatch levels:', error);
+        logger$7('[client/actors] [addModelsToDb] Could not load nameMatch levels:', error);
     }))
         .then(() => {
         sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_DB_SUCCESS });
     })
         .catch((error) => {
-        logger$b('[client/actors] [addModelsToDb] Error:', error);
+        logger$7('[client/actors] [addModelsToDb] Error:', error);
         // In test environments, still send success to allow initialization to complete
         if (isTestOrSeedDev()) {
-            logger$b('[client/actors] [addModelsToDb] Continuing despite error in test environment');
+            logger$7('[client/actors] [addModelsToDb] Continuing despite error in test environment');
             sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_DB_SUCCESS });
         }
         else {
@@ -1045,7 +984,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$a = debug('seedSdk:helpers:localDbChain');
+const logger$6 = debug('seedSdk:helpers:localDbChain');
 /** appState key recording which EAS chain the local database holds attestations from. */
 const EAS_CHAIN_ID_APP_STATE_KEY = 'easChainId';
 /**
@@ -1115,7 +1054,7 @@ async function loadLocalDbChain() {
     const localChainId = await resolveLocalDbChainId(appDb);
     if (localChainId !== undefined) {
         configureEasReadChain('localDb', { chainId: localChainId });
-        logger$a('local DB holds chain %d', localChainId);
+        logger$6('local DB holds chain %d', localChainId);
         return;
     }
     if (isEasReadChainConfigured()) {
@@ -1164,7 +1103,7 @@ function resetAddressesPersistedAnnouncement() {
     lastAnnounced = undefined;
 }
 
-const logger$9 = debug('seedSdk:client:actors:saveConfig');
+const logger$5 = debug('seedSdk:client:actors:saveConfig');
 let warnedKeptStoredAddresses = false;
 /**
  * Saves the addresses passed to init.
@@ -1205,13 +1144,13 @@ async function persistInitAddresses(appDb, { addresses, addressesProvided, owned
     announceAddressesPersisted({ owned, watched });
 }
 const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
-    logger$9('saveConfig starting');
+    logger$5('saveConfig starting');
     const { endpoints, addresses, addressesProvided, ownedAddresses, watchedAddresses, arweaveDomain, uploadApiBaseUrl, gatewayTransport, gatewayHyperKey, gatewaySidecarHost, gatewaySidecarPort, gatewayProxyBaseUrl, } = context;
     // Validate endpoints - required for proper initialization
     // If endpoints are missing or invalid, initialization should fail
     if (!endpoints || !endpoints.filePaths || !endpoints.files) {
         const error = new Error('saveConfig called with invalid endpoints: endpoints must include both filePaths and files');
-        logger$9('[internal/actors] [saveConfig] Invalid endpoints:', { endpoints });
+        logger$5('[internal/actors] [saveConfig] Invalid endpoints:', { endpoints });
         throw error;
     }
     const _saveConfig = async () => {
@@ -1220,7 +1159,7 @@ const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
             if (!appDb) {
                 // In test environments, continue anyway
                 if (isTestOrSeedDev()) {
-                    logger$9('[internal/actors] [saveConfig] App DB not found, but continuing in test environment');
+                    logger$5('[internal/actors] [saveConfig] App DB not found, but continuing in test environment');
                     return;
                 }
                 throw new Error('App DB not found');
@@ -1275,10 +1214,10 @@ const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
             await loadLocalDbChain();
         }
         catch (error) {
-            logger$9('[internal/actors] [saveConfig] Error saving config:', error);
+            logger$5('[internal/actors] [saveConfig] Error saving config:', error);
             // In test environments, continue anyway
             if (isTestOrSeedDev()) {
-                logger$9('[internal/actors] [saveConfig] Continuing despite error in test environment');
+                logger$5('[internal/actors] [saveConfig] Continuing despite error in test environment');
                 return;
             }
             throw error;
@@ -1287,14 +1226,14 @@ const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
     // Init writes run one tab at a time (docs/MULTI_TAB.md).
     withSeedDbLock('init', context.filesDir, _saveConfig)
         .then(() => {
-        logger$9('[internal/actors] [saveConfig] saveConfig success');
+        logger$5('[internal/actors] [saveConfig] saveConfig success');
         return sendBack({ type: ClientManagerEvents.SAVE_CONFIG_SUCCESS });
     })
         .catch((error) => {
-        logger$9('[internal/actors] [saveConfig] Error in saveConfig promise chain:', error);
+        logger$5('[internal/actors] [saveConfig] Error in saveConfig promise chain:', error);
         // In test environments, still send success to allow state machine to progress
         if (isTestOrSeedDev()) {
-            logger$9('[internal/actors] [saveConfig] Sending success despite error in test environment');
+            logger$5('[internal/actors] [saveConfig] Sending success despite error in test environment');
             sendBack({ type: ClientManagerEvents.SAVE_CONFIG_SUCCESS });
         }
         else {
@@ -1307,140 +1246,7 @@ const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$8 = debug('seedSdk:helpers:schema');
-/**
- * Sanitize a schema name to be filesystem-safe
- * Replaces all special characters (except alphanumeric, hyphens, underscores) with underscores
- * Converts spaces to underscores
- * Removes leading/trailing underscores
- *
- * @param name - Schema name to sanitize
- * @returns Sanitized name safe for use in filenames
- */
-const sanitizeSchemaName$1 = (name) => {
-    return name
-        .replace(/[^a-zA-Z0-9\s_-]/g, '_') // Replace special chars (except spaces, hyphens, underscores) with underscore
-        .replace(/\s+/g, '_') // Convert spaces to underscores
-        .replace(/^_+|_+$/g, '') // Remove leading/trailing underscores
-        .replace(/_+/g, '_'); // Collapse multiple underscores to single
-};
-/**
- * Generate filename for a schema
- * Format: {schemaFileId}_{schemaName}_v{version}.json
- *
- * The ID-first format ensures all files for a schema group together when sorted alphabetically.
- *
- * @param name - Schema name
- * @param version - Schema version
- * @param schemaFileId - Schema file ID (required)
- */
-const getSchemaFilename = (name, version, schemaFileId) => {
-    const sanitizedName = sanitizeSchemaName$1(name);
-    return `${schemaFileId}_${sanitizedName}_v${version}.json`;
-};
-/**
- * Get the full file path for a schema
- * Format: {schemaFileId}_{schemaName}_v{version}.json
- *
- * The ID-first format ensures all files for a schema group together when sorted alphabetically.
- *
- * @param name - Schema name
- * @param version - Schema version
- * @param schemaFileId - Schema file ID (required)
- */
-const getSchemaFilePath$1 = (name, version, schemaFileId) => {
-    const path = BaseFileManager.getPathModule();
-    const filename = getSchemaFilename(name, version, schemaFileId);
-    const workingDir = BaseFileManager.getWorkingDir();
-    return path.join(workingDir, filename);
-};
-/**
- * Create a new schema file
- * @param schema - The schema object to save
- * @param schemaFileId - Schema file ID (required)
- * @throws Error if schema already exists or if workingDir is invalid
- */
-const createSchema = async (schema, schemaFileId) => {
-    if (!schema.name || !schema.version) {
-        throw new Error('Schema must have a name and version');
-    }
-    const filePath = getSchemaFilePath$1(schema.name, schema.version, schemaFileId);
-    // Check if schema already exists
-    const exists = await BaseFileManager.pathExists(filePath);
-    if (exists) {
-        throw new Error(`Schema ${schema.name} v${schema.version} already exists`);
-    }
-    // Ensure working directory exists
-    const workingDir = BaseFileManager.getWorkingDir();
-    await BaseFileManager.createDirIfNotExists(workingDir);
-    // Write schema to file
-    const content = JSON.stringify(schema, null, 2);
-    await BaseFileManager.saveFile(filePath, content);
-};
-/**
- * Read a schema file by name and version
- * @param name - The name of the schema
- * @param version - The version of the schema
- * @param schemaFileId - Schema file ID (required)
- * @returns The schema object, or null if not found
- */
-const readSchema = async (name, version, schemaFileId) => {
-    const filePath = getSchemaFilePath$1(name, version, schemaFileId);
-    const exists = await BaseFileManager.pathExists(filePath);
-    if (!exists) {
-        return null;
-    }
-    try {
-        const content = await BaseFileManager.readFileAsString(filePath);
-        return JSON.parse(content);
-    }
-    catch (error) {
-        throw new Error(`Failed to read schema ${name} v${version}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-};
-/**
- * Update an existing schema file
- * @param schema - The updated schema object (must have same name and version as existing)
- * @param schemaFileId - Schema file ID (required)
- * @throws Error if schema doesn't exist
- */
-async function updateSchema(schema, schemaFileId) {
-    if (!schema.name || !schema.version) {
-        throw new Error('Schema must have a name and version');
-    }
-    const filePath = getSchemaFilePath$1(schema.name, schema.version, schemaFileId);
-    // Check if schema exists
-    const exists = await BaseFileManager.pathExists(filePath);
-    if (!exists) {
-        throw new Error(`Schema ${schema.name} v${schema.version} does not exist`);
-    }
-    // Write updated schema to file
-    const content = JSON.stringify(schema, null, 2);
-    await BaseFileManager.saveFile(filePath, content);
-}
-/**
- * Delete a schema file
- * @param name - The name of the schema
- * @param version - The version of the schema
- * @param schemaFileId - Schema file ID (required)
- * @throws Error if schema doesn't exist
- */
-async function deleteSchema(name, version, schemaFileId) {
-    const filePath = getSchemaFilePath$1(name, version, schemaFileId);
-    // Check if schema exists
-    const exists = await BaseFileManager.pathExists(filePath);
-    if (!exists) {
-        throw new Error(`Schema ${name} v${version} does not exist`);
-    }
-    // Delete the file
-    const fs = await BaseFileManager.getFs();
-    try {
-        await fs.promises.unlink(filePath);
-    }
-    catch (error) {
-        throw new Error(`Failed to delete schema ${name} v${version}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
+const logger$4 = debug('seedSdk:helpers:schema');
 /**
  * List all schema files in the working directory
  * Only returns files that are NOT already complete schema files (i.e., files without $schema field)
@@ -1502,7 +1308,7 @@ async function listCompleteSchemaFiles() {
         const dirExists = await BaseFileManager.pathExists(workingDir);
         if (!dirExists) {
             // Directory doesn't exist yet - return empty array (not an error condition)
-            logger$8(`Working directory does not exist yet: ${workingDir}, returning empty schema list`);
+            logger$4(`Working directory does not exist yet: ${workingDir}, returning empty schema list`);
             return [];
         }
         const files = await fs.promises.readdir(workingDir);
@@ -1546,24 +1352,6 @@ async function listCompleteSchemaFiles() {
         throw new Error(`Failed to list complete schemas: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
-/**
- * Find a schema by name (returns the latest version if multiple versions exist)
- * @param name - The name of the schema
- * @returns The schema with the highest version, or null if not found
- */
-async function findSchemaByName(name) {
-    const schemas = await listCompleteSchemaFiles();
-    const matchingSchemas = schemas.filter((s) => s.name === name);
-    if (matchingSchemas.length === 0) {
-        return null;
-    }
-    // Find the schema with the highest version
-    const latest = matchingSchemas.reduce((prev, current) => current.version > prev.version ? current : prev);
-    if (!latest.schemaFileId) {
-        throw new Error(`Schema ${latest.name} v${latest.version} is missing schemaFileId`);
-    }
-    return readSchema(latest.name, latest.version, latest.schemaFileId);
-}
 /**
  * Get the latest version number for a schema by name
  * Only considers complete schema files (with $schema field)
@@ -1596,27 +1384,6 @@ async function listLatestSchemaFiles() {
     }
     return Array.from(schemaMap.values());
 }
-/**
- * Filter an array of schemas to only include the latest version for each schema name
- * Works with any object that has a name (via metadata.name or name property) and a version property
- * @param schemas - Array of schema objects
- * @returns Array containing only the latest version of each schema
- */
-function filterLatestSchemas(schemas) {
-    // Group by schema name and keep only the latest version of each
-    const schemaMap = new Map();
-    for (const schema of schemas) {
-        const schemaName = schema.metadata?.name || schema.name;
-        if (!schemaName) {
-            continue; // Skip schemas without a name
-        }
-        const existing = schemaMap.get(schemaName);
-        if (!existing || schema.version > existing.version) {
-            schemaMap.set(schemaName, schema);
-        }
-    }
-    return Array.from(schemaMap.values());
-}
 async function loadAllSchemasFromDb() {
     const db = BaseDb.getAppDb();
     if (!db) {
@@ -1639,7 +1406,7 @@ async function loadAllSchemasFromDb() {
             }
             catch (error) {
                 // If we can't list schema files (e.g., directory doesn't exist yet), continue without file-based loading
-                logger$8(`Error listing complete schema files (continuing with DB data): ${error instanceof Error ? error.message : String(error)}`);
+                logger$4(`Error listing complete schema files (continuing with DB data): ${error instanceof Error ? error.message : String(error)}`);
                 completeSchemaFiles = [];
             }
         }
@@ -1692,7 +1459,7 @@ async function loadAllSchemasFromDb() {
                 continue;
             }
             catch (error) {
-                logger$8(`Error parsing schemaData for ${schemaName}:`, error);
+                logger$4(`Error parsing schemaData for ${schemaName}:`, error);
                 // Fall through to file-based loading
             }
         }
@@ -1734,7 +1501,7 @@ async function loadAllSchemasFromDb() {
                     continue;
                 }
                 catch (error) {
-                    logger$8(`Error loading schema file for ${schemaName}:`, error);
+                    logger$4(`Error loading schema file for ${schemaName}:`, error);
                     // Fall through to try loading from schemaData if available
                 }
             }
@@ -1778,7 +1545,7 @@ async function loadAllSchemasFromDb() {
                     continue;
                 }
                 catch (error) {
-                    logger$8(`Error parsing schemaData for ${schemaName}:`, error);
+                    logger$4(`Error parsing schemaData for ${schemaName}:`, error);
                 }
             }
         }
@@ -1789,11 +1556,11 @@ async function loadAllSchemasFromDb() {
         // Only process if not already in result
         if (!processedSchemaNames.has(schemaFileInfo.name)) {
             if (isInternalSchema(schemaFileInfo.name, schemaFileInfo.schemaFileId)) {
-                logger$8(`STEP 3: skipping internal schema file: ${schemaFileInfo.filePath}`);
+                logger$4(`STEP 3: skipping internal schema file: ${schemaFileInfo.filePath}`);
                 continue;
             }
             try {
-                logger$8(`STEP 3: processing schema file: ${schemaFileInfo.name} from ${schemaFileInfo.filePath}`);
+                logger$4(`STEP 3: processing schema file: ${schemaFileInfo.name} from ${schemaFileInfo.filePath}`);
                 const content = await BaseFileManager.readFileAsString(schemaFileInfo.filePath);
                 const schemaFile = JSON.parse(content);
                 // Import this schema to database (mark as non-draft since it's in a file)
@@ -1813,68 +1580,12 @@ async function loadAllSchemasFromDb() {
                 processedSchemaNames.add(schemaFileInfo.name);
             }
             catch (error) {
-                logger$8(`Error loading schema file ${schemaFileInfo.filePath}:`, error);
+                logger$4(`Error loading schema file ${schemaFileInfo.filePath}:`, error);
             }
         }
     }
     return result;
 }
-/**
- * Migration helper: Migrate existing file-based schemas to the database
- * This function should be called once to migrate existing schema files to the new database-first approach
- * All existing schemas will be marked as published (isDraft = false) since they already exist in files
- * @returns Number of schemas migrated
- */
-async function migrateFileSchemasToDb() {
-    const db = BaseDb.getAppDb();
-    if (!db) {
-        throw new Error('Database not found');
-    }
-    logger$8('Starting migration of file-based schemas to database');
-    // Get all complete schema files
-    const completeSchemas = await listCompleteSchemaFiles();
-    let migratedCount = 0;
-    for (const schemaFileInfo of completeSchemas) {
-        try {
-            // Read the schema file
-            const content = await BaseFileManager.readFileAsString(schemaFileInfo.filePath);
-            const schemaFile = JSON.parse(content);
-            if (!schemaFile.$schema || !schemaFile.metadata?.name) {
-                logger$8(`Skipping invalid schema file: ${schemaFileInfo.filePath}`);
-                continue;
-            }
-            const schemaName = schemaFile.metadata.name;
-            // Check if schema already exists in database
-            const existingSchemas = await db
-                .select()
-                .from(schemas)
-                .where(eq(schemas.name, schemaName))
-                .limit(1);
-            // Only migrate if it doesn't exist or if existing record doesn't have schemaFileId
-            if (existingSchemas.length === 0 || !existingSchemas[0].schemaFileId) {
-                // Add schema to database as published (isDraft = false)
-                await addSchemaToDb({
-                    name: schemaName,
-                    version: schemaFile.version,
-                    createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
-                    updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
-                }, schemaFile.id, // schemaFileId
-                JSON.stringify(schemaFile, null, 2), // schemaData
-                false);
-                migratedCount++;
-                logger$8(`Migrated schema: ${schemaName} v${schemaFile.version}`);
-            }
-            else {
-                logger$8(`Schema ${schemaName} already exists in database, skipping`);
-            }
-        }
-        catch (error) {
-            logger$8(`Error migrating schema file ${schemaFileInfo.filePath}:`, error);
-        }
-    }
-    logger$8(`Migration complete: ${migratedCount} schemas migrated`);
-    return migratedCount;
-}
 /**
  * Extract the schema name from a schemaId string
  * @param schemaId - Schema ID in the format `${schemaName}-${schemaVersion}`
@@ -1891,19 +1602,12 @@ function getSchemaNameFromId(schemaId) {
 
 var schema = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    createSchema: createSchema,
-    deleteSchema: deleteSchema,
-    filterLatestSchemas: filterLatestSchemas,
-    findSchemaByName: findSchemaByName,
     getLatestSchemaVersion: getLatestSchemaVersion,
     getSchemaNameFromId: getSchemaNameFromId,
     listCompleteSchemaFiles: listCompleteSchemaFiles,
     listLatestSchemaFiles: listLatestSchemaFiles,
     listSchemaFiles: listSchemaFiles,
-    loadAllSchemasFromDb: loadAllSchemasFromDb,
-    migrateFileSchemasToDb: migrateFileSchemasToDb,
-    readSchema: readSchema,
-    updateSchema: updateSchema
+    loadAllSchemasFromDb: loadAllSchemasFromDb
 });
 
 function toBytes(data) {
@@ -1925,7 +1629,7 @@ const getDeterministicIdsWithPrefix = (prefix) => {
     return (suffix) => bytesToHex(prefixHash.clone().update(utf8ToBytes(suffix)).digest()).slice(0, 10);
 };
 
-const logger$7 = debug('seedSdk:imports:json');
+const logger$3 = debug('seedSdk:imports:json');
 /**
  * Get refValueType from a property object with case-insensitive key lookup.
  * Handles refValueType, refvaluetype, ref_value_type, elementType, and legacy items.type / items.Type.
@@ -1992,119 +1696,6 @@ function getRefValueType(prop) {
     }
     return undefined;
 }
-/**
- * Verify that properties are persisted to the database for a given model
- * This is important in browser environments where database writes may not be immediately visible
- * @param db - Database instance
- * @param modelId - Database ID of the model
- * @param modelName - Name of the model (for logging)
- * @param maxRetries - Maximum number of retry attempts
- * @param retryDelay - Delay between retries in milliseconds
- * @returns Promise that resolves when properties are found, or rejects if not found after max retries
- */
-const verifyPropertiesPersisted = async (db, modelId, modelName, maxRetries = 10, retryDelay = 100) => {
-    const _mod_1 = await import('./index-C0SetTd1.js');
-    const _ns_1 = _mod_1.bj;
-    const modelSchemaMod = _ns_1;
-    const { properties: propertiesTable } = modelSchemaMod;
-    const drizzleMod = await import('drizzle-orm');
-    const { eq } = drizzleMod;
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-        const props = await db
-            .select()
-            .from(propertiesTable)
-            .where(eq(propertiesTable.modelId, modelId))
-            .limit(1);
-        if (props.length > 0) {
-            logger$7(`Verified properties exist for model "${modelName}" (modelId: ${modelId}) after ${attempt + 1} attempt(s)`);
-            return;
-        }
-        if (attempt < maxRetries - 1) {
-            logger$7(`Properties not yet visible for model "${modelName}" (modelId: ${modelId}), retrying in ${retryDelay}ms (attempt ${attempt + 1}/${maxRetries})`);
-            await new Promise(resolve => setTimeout(resolve, retryDelay));
-        }
-    }
-    throw new Error(`Properties not found for model "${modelName}" (modelId: ${modelId}) after ${maxRetries} attempts. This may indicate a database write issue in the browser environment.`);
-};
-/**
- * Compare two schema files structurally, ignoring metadata timestamps
- * This is used to determine if an existing schema file matches the schema being imported
- * @param schema1 - First schema to compare
- * @param schema2 - Second schema to compare
- * @returns true if schemas are structurally equivalent, false otherwise
- */
-function compareSchemasStructurally(schema1, schema2) {
-    // Compare basic fields
-    if (schema1.$schema !== schema2.$schema)
-        return false;
-    if (schema1.version !== schema2.version)
-        return false;
-    if (schema1.id !== schema2.id)
-        return false;
-    // Compare metadata (ignoring timestamps)
-    if (schema1.metadata?.name !== schema2.metadata?.name)
-        return false;
-    // Compare models structure
-    const models1 = schema1.models || {};
-    const models2 = schema2.models || {};
-    const modelNames1 = Object.keys(models1).sort();
-    const modelNames2 = Object.keys(models2).sort();
-    if (modelNames1.length !== modelNames2.length)
-        return false;
-    if (!modelNames1.every((name, i) => name === modelNames2[i]))
-        return false;
-    // Compare each model's structure
-    for (const modelName of modelNames1) {
-        const model1 = models1[modelName];
-        const model2 = models2[modelName];
-        // Compare model IDs if both have them
-        if (model1.id !== model2.id)
-            return false;
-        // Compare properties
-        const props1 = model1.properties || {};
-        const props2 = model2.properties || {};
-        const propNames1 = Object.keys(props1).sort();
-        const propNames2 = Object.keys(props2).sort();
-        if (propNames1.length !== propNames2.length)
-            return false;
-        if (!propNames1.every((name, i) => name === propNames2[i]))
-            return false;
-        // Compare each property's structure
-        for (const propName of propNames1) {
-            const prop1 = props1[propName];
-            const prop2 = props2[propName];
-            // Compare property IDs if both have them
-            if (prop1.id !== prop2.id)
-                return false;
-            // Compare property types
-            if (prop1.type !== prop2.type)
-                return false;
-            // Compare other relevant fields (ref, refValueType for List, etc.)
-            if (prop1.ref !== prop2.ref)
-                return false;
-            const refVal1 = prop1.refValueType ?? prop1.items?.type;
-            const refVal2 = prop2.refValueType ?? prop2.items?.type;
-            if (refVal1 !== refVal2)
-                return false;
-            const model1 = prop1.ref ?? prop1.items?.model;
-            const model2 = prop2.ref ?? prop2.items?.model;
-            if (model1 !== model2)
-                return false;
-        }
-    }
-    // Compare enums
-    const enums1 = schema1.enums || {};
-    const enums2 = schema2.enums || {};
-    const enumNames1 = Object.keys(enums1).sort();
-    const enumNames2 = Object.keys(enums2).sort();
-    if (enumNames1.length !== enumNames2.length)
-        return false;
-    if (!enumNames1.every((name, i) => name === enumNames2[i]))
-        return false;
-    // Note: We don't compare migrations as they're historical records
-    // and may differ even for the same schema structure
-    return true;
-}
 /**
  * Create a canonical JSON string for schema comparison (ignores IDs and timestamps).
  * Used to detect if schema content has changed via string comparison of schemaData.
@@ -2319,7 +1910,7 @@ const readCompleteSchemaFile = async (filePath) => {
         return schema;
     }
     catch (error) {
-        logger$7(`Could not read schema file ${filePath}:`, error);
+        logger$3(`Could not read schema file ${filePath}:`, error);
         return undefined;
     }
 };
@@ -2384,7 +1975,7 @@ async function importSchema(importFilePathOrContents, version, options) {
             if (parsed.$schema && parsed.metadata?.name) {
                 // It's already a complete schema format - preserve it (id may be missing, will be generated)
                 originalSchemaFile = parsed;
-                logger$7(`Input is complete schema format (${originalSchemaFile.id ? `preserving ID: ${originalSchemaFile.id}` : 'id will be generated'})`);
+                logger$3(`Input is complete schema format (${originalSchemaFile.id ? `preserving ID: ${originalSchemaFile.id}` : 'id will be generated'})`);
             }
         }
         catch {
@@ -2396,7 +1987,6 @@ async function importSchema(importFilePathOrContents, version, options) {
     }
     // Use original schema file if available, otherwise transform from import format
     let schemaFile;
-    let replacingStoredFile = false;
     if (originalSchemaFile) {
         schemaFile = originalSchemaFile;
         // Normalize models if provided as array (some tools output array format)
@@ -2410,9 +2000,9 @@ async function importSchema(importFilePathOrContents, version, options) {
         // Check DB for existing schema by name+version (same as minimal path)
         const db = BaseDb.getAppDb();
         if (db) {
-            const _mod_2 = await import('./index-C0SetTd1.js');
-            const _ns_2 = _mod_2.bl;
-            const schemaSchemaMod = _ns_2;
+            const _mod_0 = await import('./index-Dx_GTdyQ.js');
+            const _ns_0 = _mod_0.bc;
+            const schemaSchemaMod = _ns_0;
             const { schemas: schemasTable } = schemaSchemaMod;
             const drizzleMod = await import('drizzle-orm');
             const { eq, and, desc } = drizzleMod;
@@ -2424,16 +2014,16 @@ async function importSchema(importFilePathOrContents, version, options) {
                 .limit(1);
             if (existingByName.length > 0 && existingByName[0].schemaData) {
                 const existing = existingByName[0];
-                logger$7(`Idempotency: found existing schema by name+version: ${schemaFile.metadata.name} v${schemaFile.version ?? version}`);
+                logger$3(`Idempotency: found existing schema by name+version: ${schemaFile.metadata.name} v${schemaFile.version ?? version}`);
                 const existingSchema = JSON.parse(existing.schemaData);
                 const contentMatches = compareSchemaContent(schemaFile, existingSchema);
-                logger$7(`Idempotency: compareSchemaContent=${contentMatches} for ${schemaFile.metadata.name}`);
+                logger$3(`Idempotency: compareSchemaContent=${contentMatches} for ${schemaFile.metadata.name}`);
                 if (contentMatches) {
                     if (existing.schemaFileId) {
                         const workingDir = BaseFileManager.getWorkingDir();
                         const existingFilePath = getSchemaFilePath(workingDir, schemaFile.metadata.name, schemaFile.version ?? version, existing.schemaFileId);
                         if (await BaseFileManager.pathExists(existingFilePath)) {
-                            logger$7(`Schema ${schemaFile.metadata.name} v${schemaFile.version} already exists with same content, loading existing file`);
+                            logger$3(`Schema ${schemaFile.metadata.name} v${schemaFile.version} already exists with same content, loading existing file`);
                             return await loadSchemaFromFile(existingFilePath);
                         }
                         await BaseFileManager.createDirIfNotExists(workingDir);
@@ -2441,7 +2031,7 @@ async function importSchema(importFilePathOrContents, version, options) {
                         await BaseFileManager.waitForFileWithContent(existingFilePath, 100, 5000);
                         return await loadSchemaFromFile(existingFilePath);
                     }
-                    logger$7(`Schema ${schemaFile.metadata.name} v${schemaFile.version} already exists with same content (no schemaFileId), using DB`);
+                    logger$3(`Schema ${schemaFile.metadata.name} v${schemaFile.version} already exists with same content (no schemaFileId), using DB`);
                     return '';
                 }
             }
@@ -2457,7 +2047,7 @@ async function importSchema(importFilePathOrContents, version, options) {
         // processSchemaFiles runs multiple times (React StrictMode, app restarts).
         if (!schemaFile.id) {
             schemaFile.id = await getDeterministicSchemaFileId(schemaFile);
-            logger$7(`Generated deterministic schema ID for ${schemaFile.metadata.name}:`, schemaFile.id);
+            logger$3(`Generated deterministic schema ID for ${schemaFile.metadata.name}:`, schemaFile.id);
         }
         // A file with this schemaFileId and version is reused only when its content matches. A pinned id
         // (one the schema file sets) keeps the same path when the content changes.
@@ -2466,7 +2056,7 @@ async function importSchema(importFilePathOrContents, version, options) {
         if (await BaseFileManager.pathExists(existingFilePath)) {
             const storedSchema = await readCompleteSchemaFile(existingFilePath);
             if (storedSchema && compareSchemaContent(schemaFile, storedSchema)) {
-                logger$7(`Schema file already exists with schemaFileId ${schemaFile.id} and the same content, loading it`);
+                logger$3(`Schema file already exists with schemaFileId ${schemaFile.id} and the same content, loading it`);
                 return await loadSchemaFromFile(existingFilePath);
             }
             if (!options.replaceStoredFile) {
@@ -2475,7 +2065,6 @@ async function importSchema(importFilePathOrContents, version, options) {
             }
             console.warn(`[seed] schema ${schemaFile.metadata.name} v${schemaFile.version}: content changed but id ` +
                 `${schemaFile.id} and version did not; replacing the stored schema file. Bump "version" when the schema changes.`);
-            replacingStoredFile = true;
         }
         // Generate missing model and property IDs.
         // Use deterministic IDs (from schema content hash) so addModelsToDb finds existing
@@ -2485,12 +2074,12 @@ async function importSchema(importFilePathOrContents, version, options) {
         for (const [modelName, model] of Object.entries(schemaFile.models || {})) {
             if (!model.id) {
                 model.id = getDeterministicId(modelName);
-                logger$7(`Generated deterministic model ID for ${modelName}:`, model.id);
+                logger$3(`Generated deterministic model ID for ${modelName}:`, model.id);
             }
             for (const [propName, prop] of Object.entries(model.properties || {})) {
                 if (!prop.id) {
                     prop.id = getDeterministicId(modelName + propName);
-                    logger$7(`Generated deterministic property ID for ${modelName}.${propName}:`, prop.id);
+                    logger$3(`Generated deterministic property ID for ${modelName}.${propName}:`, prop.id);
                 }
             }
         }
@@ -2502,9 +2091,9 @@ async function importSchema(importFilePathOrContents, version, options) {
         // For minimal imports: check DB for existing schema before creating new file
         const db = BaseDb.getAppDb();
         if (db) {
-            const _mod_3 = await import('./index-C0SetTd1.js');
-            const _ns_3 = _mod_3.bl;
-            const schemaSchemaMod = _ns_3;
+            const _mod_1 = await import('./index-Dx_GTdyQ.js');
+            const _ns_1 = _mod_1.bc;
+            const schemaSchemaMod = _ns_1;
             const { schemas: schemasTable } = schemaSchemaMod;
             const drizzleMod = await import('drizzle-orm');
             const { eq, and, desc } = drizzleMod;
@@ -2526,14 +2115,14 @@ async function importSchema(importFilePathOrContents, version, options) {
                                 const workingDir = BaseFileManager.getWorkingDir();
                                 const existingFilePath = getSchemaFilePath(workingDir, importData.name, version, existing.schemaFileId);
                                 if (await BaseFileManager.pathExists(existingFilePath)) {
-                                    logger$7(`Schema ${importData.name} v${version} already exists with same content, loading existing file`);
+                                    logger$3(`Schema ${importData.name} v${version} already exists with same content, loading existing file`);
                                     return await loadSchemaFromFile(existingFilePath);
                                 }
                                 // File missing but schemaData exists - restore file from schemaData
                                 await BaseFileManager.createDirIfNotExists(workingDir);
                                 await BaseFileManager.saveFile(existingFilePath, existing.schemaData);
                                 await BaseFileManager.waitForFileWithContent(existingFilePath, 100, 5000);
-                                logger$7(`Restored schema file from schemaData for ${importData.name} v${version}`);
+                                logger$3(`Restored schema file from schemaData for ${importData.name} v${version}`);
                                 return await loadSchemaFromFile(existingFilePath);
                             }
                             // No schemaFileId - restore file from schemaData using id from parsed schema
@@ -2544,10 +2133,10 @@ async function importSchema(importFilePathOrContents, version, options) {
                                 await BaseFileManager.createDirIfNotExists(workingDir);
                                 await BaseFileManager.saveFile(existingFilePath, existing.schemaData);
                                 await BaseFileManager.waitForFileWithContent(existingFilePath, 100, 5000);
-                                logger$7(`Restored schema file from schemaData for ${importData.name} v${version}`);
+                                logger$3(`Restored schema file from schemaData for ${importData.name} v${version}`);
                                 return await loadSchemaFromFile(existingFilePath);
                             }
-                            logger$7(`Schema ${importData.name} v${version} already exists with same content (no id), using DB`);
+                            logger$3(`Schema ${importData.name} v${version} already exists with same content (no id), using DB`);
                             return '';
                         }
                         // Content differs - create new version
@@ -2558,7 +2147,7 @@ async function importSchema(importFilePathOrContents, version, options) {
                             .orderBy(desc(schemasTable.version))
                             .limit(1);
                         const newVersion = latestVersionRows.length > 0 ? latestVersionRows[0].version + 1 : version;
-                        logger$7(`Schema ${importData.name} content changed, creating new version v${newVersion}`);
+                        logger$3(`Schema ${importData.name} content changed, creating new version v${newVersion}`);
                         schemaFile = transformImportToSchemaFile(importData, newVersion);
                         version = newVersion;
                     }
@@ -2584,7 +2173,7 @@ async function importSchema(importFilePathOrContents, version, options) {
     // Check if this is an internal SDK schema (should not create files in app directory)
     const isInternal = isInternalSchema(schemaFile.metadata.name, schemaFile.id);
     if (isInternal) {
-        logger$7(`Skipping file creation for internal schema: ${schemaFile.metadata.name}`);
+        logger$3(`Skipping file creation for internal schema: ${schemaFile.metadata.name}`);
         // For internal schemas, just load to database and store, don't create file
         // Extract schema name and version
         const schemaName = schemaFile.metadata?.name;
@@ -2641,7 +2230,7 @@ async function importSchema(importFilePathOrContents, version, options) {
         // Use fixed internal schema ID if missing (never generate for internal)
         if (!schemaFile.id) {
             schemaFile.id = INTERNAL_SCHEMA_IDS[0];
-            logger$7('Using fixed internal schema ID:', schemaFile.id);
+            logger$3('Using fixed internal schema ID:', schemaFile.id);
         }
         // Extract schemaFileIds from JSON file and generate missing ones BEFORE creating models
         // This ensures Model instances are created with correct IDs
@@ -2651,7 +2240,7 @@ async function importSchema(importFilePathOrContents, version, options) {
             // Generate model ID if missing
             if (!model.id) {
                 model.id = generateId();
-                logger$7(`Generated model ID for ${modelName}:`, model.id);
+                logger$3(`Generated model ID for ${modelName}:`, model.id);
                 // Update the schemaFile object so it's included in schemaData
                 schemaFile.models[modelName].id = model.id;
             }
@@ -2661,7 +2250,7 @@ async function importSchema(importFilePathOrContents, version, options) {
                 // Generate property ID if missing
                 if (!prop.id) {
                     prop.id = generateId();
-                    logger$7(`Generated property ID for ${modelName}.${propName}:`, prop.id);
+                    logger$3(`Generated property ID for ${modelName}.${propName}:`, prop.id);
                     // Update the schemaFile object so it's included in schemaData
                     schemaFile.models[modelName].properties[propName].id = prop.id;
                 }
@@ -2675,7 +2264,7 @@ async function importSchema(importFilePathOrContents, version, options) {
         // addModelsToDb below writes their rows; the models adopt them once it has run.
         const rowsWritten = createRowsWrittenSignal();
         const modelDefinitions = await createModelsFromJson(importDataForInternal, modelFileIds, propertyFileIds, rowsWritten.promise);
-        logger$7('loadSchemaFromFile (internal) - modelDefinitions length:', Object.keys(modelDefinitions).length);
+        logger$3('loadSchemaFromFile (internal) - modelDefinitions length:', Object.keys(modelDefinitions).length);
         // Convert schema file metadata to schema input for database
         const schemaInput = {
             name: schemaName,
@@ -2685,9 +2274,9 @@ async function importSchema(importFilePathOrContents, version, options) {
             updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
         };
         // Use dynamic import to break circular dependency
-        const _mod_4 = await import('./index-C0SetTd1.js');
-        const _ns_4 = _mod_4.bo;
-        const dbMod = _ns_4;
+        const _mod_2 = await import('./index-Dx_GTdyQ.js');
+        const _ns_2 = _mod_2.bf;
+        const dbMod = _ns_2;
         const { addSchemaToDb, addModelsToDb } = dbMod;
         // Try to add schema and models to database if database is available
         try {
@@ -2707,13 +2296,13 @@ async function importSchema(importFilePathOrContents, version, options) {
                     });
                     // Verify expected models are linked (single attempt - addModelsToDb already confirmed)
                     const expectedModelNames = Object.keys(schemaFile.models || {});
-                    const _mod_5 = await import('./index-C0SetTd1.js');
-                    const _ns_5 = _mod_5.bm;
-                    const modelSchemaSchemaMod = _ns_5;
+                    const _mod_3 = await import('./index-Dx_GTdyQ.js');
+                    const _ns_3 = _mod_3.bd;
+                    const modelSchemaSchemaMod = _ns_3;
                     const { modelSchemas } = modelSchemaSchemaMod;
-                    const _mod_6 = await import('./index-C0SetTd1.js');
-                    const _ns_6 = _mod_6.bj;
-                    const modelSchemaMod = _ns_6;
+                    const _mod_4 = await import('./index-Dx_GTdyQ.js');
+                    const _ns_4 = _mod_4.ba;
+                    const modelSchemaMod = _ns_4;
                     const { models: modelsTable } = modelSchemaMod;
                     const drizzleMod = await import('drizzle-orm');
                     const { eq, and, isNull } = drizzleMod;
@@ -2791,7 +2380,6 @@ async function importSchema(importFilePathOrContents, version, options) {
                             }
                         }
                     }
-                    // Skip expensive verifyPropertiesPersisted - addModelsToDb already persisted; verification was for browser quirks
                     // Skip "After properties" block for internal schema: addSchemaToDb/addModelsToDb already stored
                     // correct schemaData. The per-model ID sync (6 model + 6 property selects + schema update) is
                     // redundant during init and causes slow OPFS writes. Ad-hoc loadSchemaFromFile uses the same
@@ -2801,7 +2389,7 @@ async function importSchema(importFilePathOrContents, version, options) {
         }
         catch (dbError) {
             // Database not available - log warning but continue
-            logger$7('Database not available, skipping database operations:', dbError instanceof Error ? dbError.message : String(dbError));
+            logger$3('Database not available, skipping database operations:', dbError instanceof Error ? dbError.message : String(dbError));
         }
         finally {
             rowsWritten.settle();
@@ -2809,78 +2397,20 @@ async function importSchema(importFilePathOrContents, version, options) {
         // Models are now Model instances, no registration needed
         // They should be created via Model.create() and are accessible via Model static methods
         for (const [modelName] of Object.entries(modelDefinitions)) {
-            logger$7('loadSchemaFromFile (internal) - model available:', modelName);
+            logger$3('loadSchemaFromFile (internal) - model available:', modelName);
         }
         // Schema is now saved to database
         // useSchemas hook will pick it up via database queries
         return ''; // Return empty string to indicate no file was created
     }
     const workingDir = BaseFileManager.getWorkingDir();
-    const path = BaseFileManager.getPathModule();
     // Ensure schema ID is defined (should always be set by this point, but check for safety)
     if (!schemaFile.id) {
         schemaFile.id = generateId();
-        logger$7('Generated schema ID before file path creation:', schemaFile.id);
+        logger$3('Generated schema ID before file path creation:', schemaFile.id);
     }
     // Get the target file path using ID-based naming (preferred)
     const filePath = getSchemaFilePath(workingDir, schemaFile.metadata.name, version, schemaFile.id);
-    // Check if schema already exists
-    const exists = !replacingStoredFile && (await BaseFileManager.pathExists(filePath));
-    if (exists) {
-        // If we have a file path and the import file is the same as the target file,
-        // and it's already a complete schema, just load it without writing
-        if (importFilePath) {
-            const normalizedImportPath = path.resolve(importFilePath);
-            const normalizedTargetPath = path.resolve(filePath);
-            if (normalizedImportPath === normalizedTargetPath) {
-                // Check if the file is already a complete schema
-                try {
-                    const content = await BaseFileManager.readFileAsString(importFilePath);
-                    const data = JSON.parse(content);
-                    if (data.$schema) {
-                        // File is already a complete schema, just load it
-                        logger$7(`Schema file ${filePath} already exists and is complete, loading it`);
-                        return await loadSchemaFromFile(filePath);
-                    }
-                }
-                catch {
-                    // If we can't read the file, proceed with the error
-                }
-            }
-        }
-        // File exists - check if it matches the schema we're trying to import
-        try {
-            const existingContent = await BaseFileManager.readFileAsString(filePath);
-            const existingSchema = JSON.parse(existingContent);
-            // Verify it's a complete schema file
-            if (existingSchema.$schema) {
-                // Compare schemas structurally
-                if (compareSchemasStructurally(schemaFile, existingSchema)) {
-                    // Schemas match - just load the existing file
-                    logger$7(`Schema ${schemaFile.metadata.name} v${version} already exists with matching content, loading it`);
-                    return await loadSchemaFromFile(filePath);
-                }
-                else {
-                    // Schemas don't match - throw error to prevent data loss
-                    throw new Error(`Schema ${schemaFile.metadata.name} v${version} already exists with different content. ` +
-                        `To update the schema, delete the existing file first or use a different version.`);
-                }
-            }
-            else {
-                // File exists but is not a complete schema - this shouldn't happen with ID-based naming
-                // but we'll treat it as a conflict
-                throw new Error(`Schema ${schemaFile.metadata.name} v${version} already exists but file is not a complete schema`);
-            }
-        }
-        catch (error) {
-            // If error is already our custom error, re-throw it
-            if (error instanceof Error && error.message.includes('already exists')) {
-                throw error;
-            }
-            // If we can't read/parse the existing file, throw a generic error
-            throw new Error(`Schema ${schemaFile.metadata.name} v${version} already exists but could not be read: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
     // Ensure working directory exists
     await BaseFileManager.createDirIfNotExists(workingDir);
     // Write schema to file
@@ -2913,9 +2443,9 @@ async function applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, prope
         createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
         updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
     };
-    const _mod_7 = await import('./index-C0SetTd1.js');
-    const _ns_7 = _mod_7.bo;
-    const dbMod = _ns_7;
+    const _mod_5 = await import('./index-Dx_GTdyQ.js');
+    const _ns_5 = _mod_5.bf;
+    const dbMod = _ns_5;
     const { addSchemaToDb, addModelsToDb } = dbMod;
     const db = BaseDb.getAppDb();
     if (!db) {
@@ -2945,9 +2475,9 @@ async function applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, prope
  * draft (its edits aren't the app's to undo) or a newer version than schemaFile.
  */
 async function getModelsDroppedFromStoredSchema(db, schemaFile) {
-    const _mod_8 = await import('./index-C0SetTd1.js');
-    const _ns_8 = _mod_8.bl;
-    const { schemas: schemasTable } = _ns_8;
+    const _mod_6 = await import('./index-Dx_GTdyQ.js');
+    const _ns_6 = _mod_6.bc;
+    const { schemas: schemasTable } = _ns_6;
     const { eq } = await import('drizzle-orm');
     const rows = await db
         .select({ version: schemasTable.version, isDraft: schemasTable.isDraft, schemaData: schemasTable.schemaData })
@@ -2973,12 +2503,12 @@ async function getModelsDroppedFromStoredSchema(db, schemaFile) {
 }
 /** Delete the model_schemas rows linking the named models to the schema. The models and their items stay. */
 async function unlinkModelsFromSchema(db, schemaId, modelNames) {
-    const _mod_9 = await import('./index-C0SetTd1.js');
-    const _ns_9 = _mod_9.bm;
-    const { modelSchemas } = _ns_9;
-    const _mod_10 = await import('./index-C0SetTd1.js');
-    const _ns_10 = _mod_10.bj;
-    const { models: modelsTable } = _ns_10;
+    const _mod_7 = await import('./index-Dx_GTdyQ.js');
+    const _ns_7 = _mod_7.bd;
+    const { modelSchemas } = _ns_7;
+    const _mod_8 = await import('./index-Dx_GTdyQ.js');
+    const _ns_8 = _mod_8.ba;
+    const { models: modelsTable } = _ns_8;
     const { and, eq, inArray } = await import('drizzle-orm');
     const links = await db
         .select({ id: modelSchemas.id })
@@ -2988,7 +2518,7 @@ async function unlinkModelsFromSchema(db, schemaId, modelNames) {
     if (links.length === 0)
         return;
     await db.delete(modelSchemas).where(inArray(modelSchemas.id, links.map((link) => link.id)));
-    logger$7(`Unlinked models dropped from the schema (schema id ${schemaId}): ${modelNames.join(', ')}`);
+    logger$3(`Unlinked models dropped from the schema (schema id ${schemaId}): ${modelNames.join(', ')}`);
 }
 /**
  * Sync a canonical schema from a file path or inlined object to the database.
@@ -3091,7 +2621,7 @@ const loadSchemaFromFile = async (schemaFilePath) => {
         // Generate schema ID if missing (before creating schemaInput)
         if (!schemaFile.id) {
             schemaFile.id = generateId();
-            logger$7('Generated schema ID for schema file:', schemaFile.id);
+            logger$3('Generated schema ID for schema file:', schemaFile.id);
         }
         // Extract schemaFileIds from JSON file and generate missing ones BEFORE creating models
         // This ensures Model instances are created with correct IDs
@@ -3101,7 +2631,7 @@ const loadSchemaFromFile = async (schemaFilePath) => {
             // Generate model ID if missing
             if (!model.id) {
                 model.id = generateId();
-                logger$7(`Generated model ID for ${modelName}:`, model.id);
+                logger$3(`Generated model ID for ${modelName}:`, model.id);
                 // Update the schemaFile object so it's included in schemaData
                 schemaFile.models[modelName].id = model.id;
             }
@@ -3111,7 +2641,7 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                 // Generate property ID if missing
                 if (!prop.id) {
                     prop.id = generateId();
-                    logger$7(`Generated property ID for ${modelName}.${propName}:`, prop.id);
+                    logger$3(`Generated property ID for ${modelName}.${propName}:`, prop.id);
                     // Update the schemaFile object so it's included in schemaData
                     schemaFile.models[modelName].properties[propName].id = prop.id;
                 }
@@ -3125,7 +2655,7 @@ const loadSchemaFromFile = async (schemaFilePath) => {
         // applySchemaToDb below writes their rows; the models adopt them once it has run.
         const rowsWritten = createRowsWrittenSignal();
         const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds, rowsWritten.promise);
-        logger$7('loadSchemaFromFile - modelDefinitions length:', Object.keys(modelDefinitions).length);
+        logger$3('loadSchemaFromFile - modelDefinitions length:', Object.keys(modelDefinitions).length);
         // Try to add schema and models to database if database is available
         try {
             const db = BaseDb.getAppDb();
@@ -3137,134 +2667,12 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                     modelName,
                     jsonPropertiesToSchemaProperties(modelName, modelDef, propertyFileIds.get(modelName)),
                 ]));
-                const { schemaRecord } = await applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, propertyFileIds, propertyDefinitions).finally(rowsWritten.settle);
-                // Query the database to get model IDs that were just created
-                const _mod_11 = await import('./index-C0SetTd1.js');
-                const _ns_11 = _mod_11.bm;
-                const modelSchemaSchemaMod = _ns_11;
-                const { modelSchemas } = modelSchemaSchemaMod;
-                const _mod_12 = await import('./index-C0SetTd1.js');
-                const _ns_12 = _mod_12.bj;
-                const modelSchemaMod = _ns_12;
-                const { models: modelsTable } = modelSchemaMod;
-                const drizzleMod = await import('drizzle-orm');
-                const { eq } = drizzleMod;
-                // Try to find models directly by schemaFileId first (more reliable than join table)
-                const seedModelId = modelFileIds.get('Seed');
-                let seedModel = [];
-                if (seedModelId) {
-                    // Retry querying for the model until it's visible
-                    for (let attempt = 0; attempt < 10; attempt++) {
-                        seedModel = await db
-                            .select()
-                            .from(modelsTable)
-                            .where(eq(modelsTable.schemaFileId, seedModelId))
-                            .limit(1);
-                        if (seedModel.length > 0 && seedModel[0].id) {
-                            break;
-                        }
-                        if (attempt < 9) {
-                            await new Promise(resolve => setTimeout(resolve, 100));
-                        }
-                    }
-                    if (seedModel.length > 0 && seedModel[0].id) {
-                        await verifyPropertiesPersisted(db, seedModel[0].id, 'Seed', 10, 100);
-                    }
-                }
-                // Also verify via join table if schemaRecord.id is available (for completeness)
-                if (schemaRecord.id) {
-                    // Retry querying join table until entries are visible
-                    let modelLinks = [];
-                    for (let attempt = 0; attempt < 10; attempt++) {
-                        modelLinks = await db
-                            .select({
-                            modelId: modelSchemas.modelId,
-                            modelName: modelsTable.name,
-                        })
-                            .from(modelSchemas)
-                            .innerJoin(modelsTable, eq(modelSchemas.modelId, modelsTable.id))
-                            .where(eq(modelSchemas.schemaId, schemaRecord.id));
-                        if (modelLinks.length > 0) {
-                            break;
-                        }
-                        if (attempt < 9) {
-                            await new Promise(resolve => setTimeout(resolve, 100));
-                        }
-                    }
-                    logger$7(`Verifying properties: found ${modelLinks.length} model links for schema ${schemaName} (id: ${schemaRecord.id})`);
-                    // If we didn't verify via direct lookup, verify via join table
-                    if (!seedModelId || (seedModel.length === 0 || !seedModel[0].id)) {
-                        const seedModelLink = modelLinks.find((link) => link.modelName === 'Seed');
-                        if (seedModelLink && seedModelLink.modelId) {
-                            logger$7(`Verifying properties for Seed model via join table (modelId: ${seedModelLink.modelId})`);
-                            await verifyPropertiesPersisted(db, seedModelLink.modelId, 'Seed', 10, 100);
-                        }
-                        else if (modelLinks.length > 0 && modelLinks[0].modelId) {
-                            // Fallback to first model if Seed not found
-                            logger$7(`Verifying properties for ${modelLinks[0].modelName} model via join table (modelId: ${modelLinks[0].modelId})`);
-                            await verifyPropertiesPersisted(db, modelLinks[0].modelId, modelLinks[0].modelName || 'unknown', 10, 100);
-                        }
-                    }
-                }
-                // After properties are created (file path), ensure schemaFile has the correct IDs from database
-                // Query the database to get the actual schemaFileId values that were used
-                // This ensures schemaData matches what's actually in the database
-                const _mod_13 = await import('./index-C0SetTd1.js');
-                const _ns_13 = _mod_13.bj;
-                const modelSchemaMod2 = _ns_13;
-                const { properties: propertiesTable } = modelSchemaMod2;
-                let schemaFileUpdated = false;
-                for (const [modelName, modelFileId] of modelFileIds.entries()) {
-                    // Get model record to find modelId
-                    const modelRecords = await db
-                        .select()
-                        .from(modelsTable)
-                        .where(eq(modelsTable.schemaFileId, modelFileId))
-                        .limit(1);
-                    if (modelRecords.length > 0) {
-                        const modelId = modelRecords[0].id;
-                        // Get all properties for this model from database
-                        const propertyRecords = await db
-                            .select()
-                            .from(propertiesTable)
-                            .where(eq(propertiesTable.modelId, modelId));
-                        // Update schemaFile with actual database IDs (only if they differ)
-                        for (const propRecord of propertyRecords) {
-                            if (propRecord.schemaFileId && schemaFile.models[modelName]?.properties[propRecord.name]) {
-                                const currentId = schemaFile.models[modelName].properties[propRecord.name].id;
-                                if (currentId !== propRecord.schemaFileId) {
-                                    schemaFile.models[modelName].properties[propRecord.name].id = propRecord.schemaFileId;
-                                    logger$7(`Updated schemaFile property ID for ${modelName}.${propRecord.name} from ${currentId} to ${propRecord.schemaFileId}`);
-                                    schemaFileUpdated = true;
-                                }
-                            }
-                        }
-                    }
-                }
-                // Always update schemaData to ensure it matches the current schemaFile state
-                // This is important even if nothing changed, to ensure consistency
-                const updatedSchemaData = JSON.stringify(schemaFile, null, 2);
-                // Update the schema record in the database with current schemaData
-                const _mod_14 = await import('./index-C0SetTd1.js');
-                const _ns_14 = _mod_14.bl;
-                const schemaSchemaMod = _ns_14;
-                const { schemas: schemasTable } = schemaSchemaMod;
-                await db
-                    .update(schemasTable)
-                    .set({ schemaData: updatedSchemaData })
-                    .where(eq(schemasTable.id, schemaRecord.id));
-                clearNameMatchLevels();
-                if (schemaFileUpdated) {
-                    logger$7(`Updated schemaData in database with actual property IDs for schema "${schemaName}"`);
-                }
-                else {
-                    logger$7(`Verified schemaData in database matches schemaFile for schema "${schemaName}"`);
-                }
+                await applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, propertyFileIds, propertyDefinitions).finally(rowsWritten.settle);
             }
         }
         catch (dbError) {
             // Database not available - log warning but continue
-            logger$7('Database not available, skipping database operations:', dbError instanceof Error ? dbError.message : String(dbError));
+            logger$3('Database not available, skipping database operations:', dbError instanceof Error ? dbError.message : String(dbError));
         }
         finally {
             rowsWritten.settle();
@@ -3272,7 +2680,7 @@ const loadSchemaFromFile = async (schemaFilePath) => {
         // Models are now Model instances, no registration needed
         // They should be created via Model.create() and are accessible via Model static methods
         for (const [modelName] of Object.entries(modelDefinitions)) {
-            logger$7('loadSchemaFromFile - model available:', modelName);
+            logger$3('loadSchemaFromFile - model available:', modelName);
         }
         return schemaFilePath;
     }
@@ -3372,19 +2780,19 @@ const createRowsWrittenSignal = () => {
 const createModelFromJson = async (modelName, modelDef, schemaName, modelFileId, // Optional modelFileId from JSON file
 propertyFileIds, // Optional map of property names to their file IDs from the JSON file
 persistedBy) => {
-    const _mod_15 = await import('./errors-rIWK7gwJ.js');
-    const _ns_15 = _mod_15.i;
-    const modelMod = _ns_15;
+    const _mod_9 = await import('./errors-D1zHAqjr.js');
+    const _ns_9 = _mod_9.i;
+    const modelMod = _ns_9;
     const { Model } = modelMod;
     const convertedProperties = jsonPropertiesToSchemaProperties(modelName, modelDef, propertyFileIds);
     // Create Model instance with the definition
     // Pass id (schemaFileId) if provided to ensure Model instance uses correct ID
     // Note: indexes and description are ignored - they remain in JSON for schema file format compliance but are not used by Model instances
     if (modelFileId) {
-        logger$7(`Creating schema model "${modelName}" with modelFileId: ${modelFileId}`);
+        logger$3(`Creating schema model "${modelName}" with modelFileId: ${modelFileId}`);
     }
     else {
-        logger$7(`Warning: Creating schema model "${modelName}" without modelFileId - it will be renamed if duplicates exist`);
+        logger$3(`Warning: Creating schema model "${modelName}" without modelFileId - it will be renamed if duplicates exist`);
     }
     // The schema holds its models once (Model.takeSchemaHold); a model it already holds takes no more.
     const schemaHold = Model.takeSchemaHold(modelFileId);
@@ -3416,7 +2824,7 @@ const createModelsFromJson = async (importData, modelFileIds, propertyFileIds, p
         // Use modelFileId from map (no fallback to modelDef.id as JsonImportSchema doesn't have id property)
         const finalModelFileId = modelFileId;
         if (!finalModelFileId) {
-            logger$7(`Warning: No modelFileId found for model "${modelName}" - model will be created without ID`);
+            logger$3(`Warning: No modelFileId found for model "${modelName}" - model will be created without ID`);
         }
         // Get propertyFileIds for this model if available
         const modelPropertyFileIds = propertyFileIds?.get(modelName);
@@ -3431,9 +2839,10 @@ const createModelsFromJson = async (importData, modelFileIds, propertyFileIds, p
  * use correct schemaFileIds - preventing duplicate models (Publication 1, etc.) when
  * processSchemaFiles runs multiple times.
  * @param filePath - Path to the JSON import file
+ * @param persistedBy - See createModelsFromJson
  * @returns ModelDefinitions with Model classes created from the JSON schema
  */
-const createModelsFromJsonFile = async (filePath) => {
+const createModelsFromJsonFile = async (filePath, persistedBy) => {
     const workingDir = BaseFileManager.getWorkingDir();
     const internalFilePath = filePath.startsWith(workingDir) ? filePath : `${workingDir}/${filePath}`;
     const content = await BaseFileManager.readFileAsString(internalFilePath);
@@ -3462,7 +2871,7 @@ const createModelsFromJsonFile = async (filePath) => {
             }
         }
     }
-    return createModelsFromJson(importData, modelFileIds, propertyFileIds);
+    return createModelsFromJson(importData, modelFileIds, propertyFileIds, persistedBy);
 };
 
 var $schema = "https://seedprotocol.org/schemas/data-model/v1";
@@ -3606,7 +3015,7 @@ var SEEDPROTOCOL_Seed_Protocol_v1 = /*#__PURE__*/Object.freeze({
     version: version
 });
 
-const logger$6 = debug('seedSdk:client:actors:processSchemaFiles');
+const logger$2 = debug('seedSdk:client:actors:processSchemaFiles');
 let processSchemaFilesChain = Promise.resolve();
 function resolveSchemaFilePath(schemaFile) {
     const path = BaseFileManager.getPathModule();
@@ -3634,7 +3043,7 @@ async function resolveSchemaNameFromSource(source) {
             }
         }
         catch (error) {
-            logger$6('Could not resolve schema name from path:', source, error);
+            logger$2('Could not resolve schema name from path:', source, error);
         }
     }
     return null;
@@ -3649,7 +3058,7 @@ function userSchemaLoadError(option, source, error) {
 // Schema processing can be slow with syncSchemaFromSource, loadAllSchemasFromDb, and OPFS file I/O
 const PROCESS_SCHEMA_FILES_TIMEOUT_MS = 120000;
 const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
-    logger$6('processSchemaFiles started');
+    logger$2('processSchemaFiles started');
     let hasResponded = false;
     let timeoutId = null;
     const reportError = (error) => {
@@ -3659,7 +3068,7 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                 clearTimeout(timeoutId);
                 timeoutId = null;
             }
-            logger$6('processSchemaFiles error:', error);
+            logger$2('processSchemaFiles error:', error);
             sendBack({
                 type: 'error',
                 error: error instanceof Error ? error : new Error(String(error))
@@ -3673,7 +3082,7 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                 clearTimeout(timeoutId);
                 timeoutId = null;
             }
-            logger$6('processSchemaFiles completed');
+            logger$2('processSchemaFiles completed');
             sendBack({ type: ClientManagerEvents.PROCESS_SCHEMA_FILES_SUCCESS });
         }
     };
@@ -3685,7 +3094,7 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
         // Schemas written (or confirmed present) this run — skip redundant loadSchemaFromFile later
         const schemasWrittenThisRun = new Set();
         // First, load the internal seed-protocol schema
-        logger$6('Loading internal seed-protocol schema');
+        logger$2('Loading internal seed-protocol schema');
         const internalSchemaData = internalSchema;
         const db = BaseDb.getAppDb();
         const internalSchemaExists = db
@@ -3694,21 +3103,21 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
         // Always mark internal schema as written so the DB/file loop does not re-apply it
         schemasWrittenThisRun.add(SEED_PROTOCOL_SCHEMA_NAME);
         if (internalSchemaExists) {
-            logger$6('Internal seed-protocol schema already in DB, skipping import');
+            logger$2('Internal seed-protocol schema already in DB, skipping import');
         }
         else {
             try {
                 // Import the internal schema to database (will create models and add to store)
                 await importJsonSchema({ contents: JSON.stringify(internalSchemaData) }, internalSchemaData.version);
-                logger$6(`Loaded internal seed-protocol schema v${internalSchemaData.version}`);
+                logger$2(`Loaded internal seed-protocol schema v${internalSchemaData.version}`);
             }
             catch (error) {
                 // If schema already exists, that's fine - it means it was already loaded
                 if (error?.message?.includes('already exists')) {
-                    logger$6('Internal seed-protocol schema already loaded');
+                    logger$2('Internal seed-protocol schema already loaded');
                 }
                 else {
-                    logger$6('Error loading internal seed-protocol schema:', error);
+                    logger$2('Error loading internal seed-protocol schema:', error);
                     // Don't fail if internal schema can't be loaded - it might already be in DB
                 }
             }
@@ -3721,7 +3130,7 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                 : '';
             const schemaId = typeof context.schema === 'object' && context.schema?.id ? String(context.schema.id) : undefined;
             if (isInternalSchema(schemaName, schemaId)) {
-                logger$6('Schema is internal (Seed Protocol), already loaded - skipping syncSchemaFromSource');
+                logger$2('Schema is internal (Seed Protocol), already loaded - skipping syncSchemaFromSource');
             }
             else {
                 try {
@@ -3730,7 +3139,7 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                     if (syncedName) {
                         schemasWrittenThisRun.add(syncedName);
                     }
-                    logger$6(`Synced canonical schema from ${typeof context.schema === 'string' ? context.schema : 'object'}`);
+                    logger$2(`Synced canonical schema from ${typeof context.schema === 'string' ? context.schema : 'object'}`);
                 }
                 catch (error) {
                     // A schema the app passed in failed (missing file, bad JSON, DB write). Re-running an
@@ -3749,7 +3158,7 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                 if (parsed?.metadata?.name) {
                     schemasWrittenThisRun.add(String(parsed.metadata.name));
                 }
-                logger$6(`Loaded schema from ${resolvedPath}`);
+                logger$2(`Loaded schema from ${resolvedPath}`);
             }
             catch (error) {
                 throw userSchemaLoadError('schemaFile', context.schemaFile, error);
@@ -3757,14 +3166,14 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
         }
         // Process minimal import files (files without $schema) - skip when canonical schema is set
         if (!context.schema) {
-            logger$6('Listing schema files');
+            logger$2('Listing schema files');
             let schemaFiles = [];
             try {
                 schemaFiles = await listSchemaFiles();
-                logger$6(`Found ${schemaFiles.length} schema files to process`);
+                logger$2(`Found ${schemaFiles.length} schema files to process`);
             }
             catch (error) {
-                logger$6('Error listing schema files (continuing anyway):', error);
+                logger$2('Error listing schema files (continuing anyway):', error);
                 schemaFiles = [];
             }
             for (const schemaFile of schemaFiles) {
@@ -3775,25 +3184,29 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                     }
                 }
                 catch (error) {
-                    logger$6(`Error importing schema file ${schemaFile.filePath}:`, error);
+                    logger$2(`Error importing schema file ${schemaFile.filePath}:`, error);
                 }
             }
         }
         // Then, load all schemas using the unified database-first approach
-        logger$6('Loading schemas from database and files');
+        logger$2('Loading schemas from database and files');
         let allSchemasData = [];
         try {
             allSchemasData = await loadAllSchemasFromDb();
-            logger$6(`Loaded ${allSchemasData.length} schemas (${allSchemasData.filter(s => s.isDraft).length} drafts, ${allSchemasData.filter(s => !s.isDraft).length} published)`);
+            logger$2(`Loaded ${allSchemasData.length} schemas (${allSchemasData.filter(s => s.isDraft).length} drafts, ${allSchemasData.filter(s => !s.isDraft).length} published)`);
         }
         catch (error) {
-            logger$6('Error loading schemas from database (continuing anyway):', error);
+            logger$2('Error loading schemas from database (continuing anyway):', error);
             // Continue with empty array - this is not critical for initialization
             // Schemas can be loaded on-demand later
             allSchemasData = [];
         }
         // Collect models to add to context (schemas are now loaded on-demand via database queries)
         const allModels = { ...(context.models || {}) };
+        // The models built below describe rows that loadSchemaFromFile or an earlier init already wrote:
+        // they adopt those rows, and only a model with no row writes one. Without it every init rewrote
+        // each property row and cleared is_edited.
+        const rowsWritten = Promise.resolve();
         // Linked model count per schema row, to tell whether an earlier load already applied a file's models
         const linkedModelCounts = new Map();
         if (db) {
@@ -3808,13 +3221,13 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                 }
             }
             catch (error) {
-                logger$6('Error counting linked models (re-applying all schema files):', error);
+                logger$2('Error counting linked models (re-applying all schema files):', error);
             }
         }
         for (const schemaData of allSchemasData) {
             const schema = schemaData.schema;
             const schemaName = schema.metadata?.name || 'unknown';
-            logger$6(`Processing schema: ${schemaName} v${schema.version} (${schemaData.isDraft ? 'draft' : 'published'}, source: ${schemaData.source})`);
+            logger$2(`Processing schema: ${schemaName} v${schema.version} (${schemaData.isDraft ? 'draft' : 'published'}, source: ${schemaData.source})`);
             // For published schemas (not drafts), load models from file if available
             if (!schemaData.isDraft && schema.id) {
                 // loadAllSchemasFromDb already picked the latest file for this schema (and read it)
@@ -3834,17 +3247,17 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                             schemaData.schemaRecordId != null &&
                             (linkedModelCounts.get(schemaData.schemaRecordId) ?? 0) >= expectedModelCount;
                         if (alreadyWritten || alreadyApplied) {
-                            const modelDefinitions = await createModelsFromJsonFile(latestFilePath);
+                            const modelDefinitions = await createModelsFromJsonFile(latestFilePath, rowsWritten);
                             Object.assign(allModels, modelDefinitions);
                         }
                         else {
                             await loadSchemaFromFile(latestFilePath);
-                            const modelDefinitions = await createModelsFromJsonFile(latestFilePath);
+                            const modelDefinitions = await createModelsFromJsonFile(latestFilePath, rowsWritten);
                             Object.assign(allModels, modelDefinitions);
                         }
                     }
                     catch (error) {
-                        logger$6(`Error loading schema file for ${schemaName}:`, error);
+                        logger$2(`Error loading schema file for ${schemaName}:`, error);
                     }
                 }
                 else {
@@ -3891,13 +3304,13 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                                     },
                                 ])),
                             };
-                            const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds);
+                            const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds, rowsWritten);
                             Object.assign(allModels, modelDefinitions);
-                            logger$6(`Loaded ${Object.keys(modelDefinitions).length} models from schema data for ${schemaName}`);
+                            logger$2(`Loaded ${Object.keys(modelDefinitions).length} models from schema data for ${schemaName}`);
                         }
                     }
                     catch (error) {
-                        logger$6(`Error creating models from schema data for ${schemaName}:`, error);
+                        logger$2(`Error creating models from schema data for ${schemaName}:`, error);
                     }
                 }
             }
@@ -3945,13 +3358,13 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                                 },
                             ])),
                         };
-                        const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds);
+                        const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds, rowsWritten);
                         Object.assign(allModels, modelDefinitions);
-                        logger$6(`Loaded ${Object.keys(modelDefinitions).length} models from draft schema ${schemaName}`);
+                        logger$2(`Loaded ${Object.keys(modelDefinitions).length} models from draft schema ${schemaName}`);
                     }
                 }
                 catch (error) {
-                    logger$6(`Error creating models from draft schema ${schemaName}:`, error);
+                    logger$2(`Error creating models from draft schema ${schemaName}:`, error);
                 }
             }
             // Schemas are now loaded on-demand via database queries (useSchemas hook uses loadAllSchemasFromDb)
@@ -3982,651 +3395,6 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
     };
 });
 
-/** Absolute path of the file {@link writeItemStorageFile} writes for `target`. */
-const getItemStorageFilePath = (target) => BaseFileManager.getFilesPath(getItemStorageSubdir(target.localStorageDir), target.fileName || getItemStorageLocalFileName(target.seedId, target.filenameSuffix));
-/**
- * Write an ItemStorage property's content to its local file, where saveItemStorage, reads, publish
- * (resolveItemStorageChildFile) and download all look for it. Returns what the metadata row records:
- * `refResolvedValue` (the file name) and `localStorageDir` (with a leading slash).
- *
- * Callers that also update the file's metadata row hold {@link withItemStorageFileLock} around
- * both, so another writer of the same file can't land in between.
- */
-const writeItemStorageFile = async (target, content) => {
-    const dir = getItemStorageSubdir(target.localStorageDir);
-    const fileName = target.fileName || getItemStorageLocalFileName(target.seedId, target.filenameSuffix);
-    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath(dir));
-    const filePath = BaseFileManager.getFilesPath(dir, fileName);
-    await BaseFileManager.saveFile(filePath, content);
-    return { fileName, filePath, localStorageDir: target.localStorageDir || `/${dir}` };
-};
-/**
- * Lock name for one ItemStorage file: `seed:item-storage:<absolute file path>`. The path starts
- * with the files root, which also names the database (`<filesDir>/db/seed.db`), so the name is
- * per database as well as per file.
- */
-const itemStorageFileLockName = (filePath) => `seed:item-storage:${filePath}`;
-/**
- * Runs `fn` holding the lock of one ItemStorage file, across tabs (Web Locks) and within this JS
- * realm (an in-process queue where Web Locks are missing, e.g. Node < 24.5; see `withTabLock`).
- *
- * Writers of a local draft's file (saveItemStorage, convertVerbatimItemStorageRow, createNewItem)
- * hold it across "read the row → write the file → update the row", so the file and the row end
- * with the same writer's content. See docs/MULTI_TAB.md.
- *
- * Lock ordering: this lock is always the innermost. It may be taken while holding a broader lock
- * (`seed:item-storage-migration:<db>`, `seed:publish:<seedLocalId>`), never the other way round,
- * and no other lock (nor a second file lock) is requested while it is held. Keep the section to
- * local DB and file I/O: no network. Not re-entrant.
- */
-function withItemStorageFileLock(filePath, fn) {
-    return withTabLock(itemStorageFileLockName(filePath), fn);
-}
-/** {@link withItemStorageFileLock} only if the lock is free now (see `tryWithTabLock`). */
-function tryWithItemStorageFileLock(filePath, fn) {
-    return tryWithTabLock(itemStorageFileLockName(filePath), fn);
-}
-/** Lock attempts before giving up when the row's target file keeps changing under us. */
-const ROW_LOCK_ATTEMPTS = 3;
-const readRow = async (localId) => {
-    const rows = await BaseDb.getAppDb()
-        .select()
-        .from(metadata$1)
-        .where(eq(metadata$1.localId, localId))
-        .limit(1);
-    return rows[0];
-};
-/**
- * Runs `fn` with a fresh read of metadata row `localId`, holding the lock of the file that row's
- * content goes to. `fileOf` names that file (absolute path) for a row, or returns undefined when
- * there is nothing to write (then `fn` isn't called and the result is undefined).
- *
- * The file depends on the row, so the row is read once to pick the lock and again once it is held;
- * if the row now points at another file (another writer changed it meanwhile), the lock is
- * released and taken again for that file.
- */
-async function withLockedItemStorageRow(localId, fileOf, fn) {
-    for (let attempt = 0; attempt < ROW_LOCK_ATTEMPTS; attempt++) {
-        const row = await readRow(localId);
-        const filePath = row && fileOf(row);
-        if (!filePath)
-            return undefined;
-        const outcome = await withItemStorageFileLock(filePath, async () => {
-            const fresh = await readRow(localId);
-            const freshPath = fresh && fileOf(fresh);
-            if (!freshPath)
-                return { done: true, value: undefined };
-            if (freshPath !== filePath)
-                return { done: false };
-            return { done: true, value: await fn(fresh, filePath) };
-        });
-        if (outcome.done)
-            return outcome.value;
-    }
-    throw new Error(`ItemStorage file of metadata row ${localId} kept changing; not written`);
-}
-
-/**
- * A legacy ItemStorage draft row: a local edit (no attestation uid, not derived from one) that holds
- * the content itself in property_value, with no file reference. Item.create / createNewItem stored
- * ItemStorage values like this before they went through the save pipeline.
- */
-const isVerbatimItemStorageDraftRow = (row) => !row.uid &&
-    row.derivedFromUid == null &&
-    !row.refResolvedValue &&
-    typeof row.propertyValue === 'string' &&
-    row.propertyValue !== '';
-/**
- * Convert one legacy ItemStorage draft row (see {@link isVerbatimItemStorageDraftRow}) into the
- * shape saveItemStorage gives a row: the content goes to the file a save would write
- * (`<seedUid or seedLocalId><extension>` in the property's storage directory), and the row records
- * `refResolvedValue`, `localStorageDir` and `refValueType: 'file'` with property_value cleared.
- * Used by publish (resolveItemStorageChildFile) and the one-time migration (migrateLegacyItemStorageRows).
- *
- * Reading the row, writing the file and updating the row happen under the file's lock
- * ({@link withItemStorageFileLock}), which saveItemStorage holds too: a save in this or another tab
- * either finishes before (the row, read again once the lock is held, is no longer legacy and is
- * left alone) or starts after (and overwrites the file and row with its content). Without the lock
- * a save landing between the read and the file write would have its file overwritten with the old
- * content. The row update also stays conditional on the row being unchanged, for writers that
- * don't take the lock (a tab still running an older SDK).
- *
- * Returns undefined when there was nothing to convert. Throws when the file can't be written; the
- * row is then unchanged.
- */
-const convertVerbatimItemStorageRow = async (localId, storage = {}) => {
-    const appDb = BaseDb.getAppDb();
-    if (!appDb || !localId)
-        return undefined;
-    const targetOf = (row) => {
-        if (!isVerbatimItemStorageDraftRow(row))
-            return undefined;
-        const seedId = storage.seedId || row.seedUid || row.seedLocalId;
-        if (!seedId)
-            return undefined;
-        return {
-            seedId,
-            localStorageDir: storage.localStorageDir || row.localStorageDir,
-            filenameSuffix: storage.filenameSuffix,
-        };
-    };
-    return withLockedItemStorageRow(localId, (row) => {
-        const target = targetOf(row);
-        return target && getItemStorageFilePath(target);
-    }, async (row) => {
-        const content = row.propertyValue;
-        const { fileName, filePath, localStorageDir } = await writeItemStorageFile(targetOf(row), content);
-        await appDb
-            .update(metadata$1)
-            .set({ refResolvedValue: fileName, localStorageDir, refValueType: 'file', propertyValue: null })
-            .where(and(eq(metadata$1.localId, localId), isNull(metadata$1.refResolvedValue), eq(metadata$1.propertyValue, content)));
-        // Changed between the read and the update by a writer outside the lock: that change stands.
-        const after = await appDb
-            .select({ refResolvedValue: metadata$1.refResolvedValue, propertyValue: metadata$1.propertyValue })
-            .from(metadata$1)
-            .where(eq(metadata$1.localId, localId))
-            .limit(1);
-        if (after[0]?.refResolvedValue !== fileName || after[0]?.propertyValue != null)
-            return undefined;
-        return { fileName, filePath, localStorageDir, content };
-    });
-};
-
-const logger$5 = debug('seedSdk:db:migrateLegacyItemStorageRows');
-/** appState key recording that legacy ItemStorage rows have been written to their files. */
-const LEGACY_ITEM_STORAGE_MIGRATION_KEY = 'legacyItemStorageFiles:v1';
-/** Runs in a row that left rows unconverted because a file write failed, before giving up. */
-const LEGACY_ITEM_STORAGE_MIGRATION_MAX_ATTEMPTS = 3;
-const readMarker = async () => {
-    const db = BaseDb.getAppDb();
-    const rows = await db
-        .select({ value: appState.value })
-        .from(appState)
-        .where(eq(appState.key, LEGACY_ITEM_STORAGE_MIGRATION_KEY))
-        .limit(1);
-    if (!rows.length)
-        return undefined;
-    try {
-        return JSON.parse(rows[0].value ?? '');
-    }
-    catch {
-        return null;
-    }
-};
-const writeMarker = async (marker) => {
-    const db = BaseDb.getAppDb();
-    const now = Date.now();
-    const value = JSON.stringify(marker);
-    await db
-        .insert(appState)
-        .values({ key: LEGACY_ITEM_STORAGE_MIGRATION_KEY, value, createdAt: now, updatedAt: now })
-        .onConflictDoUpdate({ target: appState.key, set: { value, updatedAt: now } });
-};
-/**
- * The storage settings of a metadata row's property: by its property_id, else by name in the
- * seed's own model (model names are only unique per schema). Undefined when it can't be told.
- */
-const createStorageResolver = () => {
-    const db = BaseDb.getAppDb();
-    const byPropertyId = new Map();
-    const byModelAndName = new Map();
-    return async (row) => {
-        if (row.propertyId != null) {
-            if (!byPropertyId.has(row.propertyId)) {
-                const found = await db
-                    .select({
-                    storageType: properties.storageType,
-                    localStorageDir: properties.localStorageDir,
-                    filenameSuffix: properties.filenameSuffix,
-                })
-                    .from(properties)
-                    .where(eq(properties.id, row.propertyId))
-                    .limit(1);
-                byPropertyId.set(row.propertyId, found[0]);
-            }
-            const fromId = byPropertyId.get(row.propertyId);
-            if (fromId)
-                return fromId;
-        }
-        const modelFileId = await resolveItemModelFileId({ seedLocalId: row.seedLocalId, seedUid: row.seedUid });
-        if (!modelFileId || !row.propertyName)
-            return undefined;
-        const key = `${modelFileId}\u0000${row.propertyName}`;
-        if (!byModelAndName.has(key)) {
-            const found = await db
-                .select({
-                storageType: properties.storageType,
-                localStorageDir: properties.localStorageDir,
-                filenameSuffix: properties.filenameSuffix,
-            })
-                .from(properties)
-                .innerJoin(models$1, eq(properties.modelId, models$1.id))
-                .where(and(eq(models$1.schemaFileId, modelFileId), eq(properties.name, row.propertyName)))
-                .limit(1);
-            byModelAndName.set(key, found[0]);
-        }
-        return byModelAndName.get(key);
-    };
-};
-/** True if `row` is the row readers show for its property: the newest of its seed's rows by that name. */
-const isNewestRowOfProperty = async (row) => {
-    if (!row.seedLocalId || !row.propertyName)
-        return false;
-    const db = BaseDb.getAppDb();
-    const siblings = await db
-        .select()
-        .from(metadata$1)
-        .where(and(eq(metadata$1.seedLocalId, row.seedLocalId), eq(metadata$1.propertyName, row.propertyName)));
-    return [...siblings].sort(compareMetadataRowsLatestFirst)[0]?.localId === row.localId;
-};
-/**
- * One-time data migration: writes the content of legacy ItemStorage draft rows to their files.
- *
- * Before Item.create / createNewItem saved ItemStorage values through the save pipeline, a value
- * given at creation was stored verbatim in metadata.property_value with no file. Publish converts
- * such a row lazily (resolveItemStorageChildFile); this converts them all up front, with the same
- * code ({@link convertVerbatimItemStorageRow}), so every ItemStorage draft has the shape a save
- * gives it: the content in `<seedUid or seedLocalId><extension>`, the row holding
- * refResolvedValue / localStorageDir / refValueType 'file' and no property_value.
- *
- * Only local drafts (no uid, not derived from an attestation) of properties whose properties row
- * says `storage_type = 'ItemStorage'` are touched, and of those only the newest row of each
- * seed's property: that is the row reads show and saves write to, and older rows sharing the one
- * file name would overwrite it with older content. Published and synced rows are never changed.
- *
- * A row that fails is logged and left as it was (publish still converts it). The run is recorded
- * in appState under {@link LEGACY_ITEM_STORAGE_MIGRATION_KEY}; a run with failed rows is retried
- * on the next start, up to {@link LEGACY_ITEM_STORAGE_MIGRATION_MAX_ATTEMPTS} runs. Safe to run
- * again regardless: a converted row no longer matches.
- *
- * @param options.force run even when the marker says it is done
- */
-async function migrateLegacyItemStorageRows(options = {}) {
-    const result = {
-        alreadyDone: false,
-        candidates: 0,
-        converted: 0,
-        failed: 0,
-        skipped: 0,
-    };
-    const db = BaseDb.getAppDb();
-    if (!db)
-        return { ...result, alreadyDone: true };
-    const marker = await readMarker();
-    const previousAttempts = marker?.status === 'retry' ? marker.attempts : 0;
-    if (!options.force && marker && marker.status === 'done') {
-        return { ...result, alreadyDone: true };
-    }
-    const itemStorageNames = (await db
-        .selectDistinct({ name: properties.name })
-        .from(properties)
-        .where(eq(properties.storageType, 'ItemStorage'))).map((r) => r.name);
-    const candidates = itemStorageNames.length
-        ? await db
-            .select()
-            .from(metadata$1)
-            .where(and(inArray(metadata$1.propertyName, itemStorageNames), or(isNull(metadata$1.uid), eq(metadata$1.uid, '')), isNull(metadata$1.derivedFromUid), isNull(metadata$1.refResolvedValue), isNotNull(metadata$1.propertyValue), ne(metadata$1.propertyValue, '')))
-        : [];
-    const resolveStorage = createStorageResolver();
-    for (const row of candidates) {
-        if (!row.localId || !isVerbatimItemStorageDraftRow(row))
-            continue;
-        try {
-            const storage = await resolveStorage(row);
-            if (storage?.storageType !== 'ItemStorage')
-                continue;
-            result.candidates++;
-            if (!(await isNewestRowOfProperty(row))) {
-                result.skipped++;
-                continue;
-            }
-            const converted = await convertVerbatimItemStorageRow(row.localId, {
-                localStorageDir: storage.localStorageDir,
-                filenameSuffix: storage.filenameSuffix,
-            });
-            if (converted) {
-                result.converted++;
-                logger$5(`wrote ${row.propertyName} of ${row.seedLocalId} to ${converted.filePath}`);
-            }
-            else {
-                result.skipped++;
-            }
-        }
-        catch (error) {
-            result.failed++;
-            logger$5(`converting ${row.propertyName} of ${row.seedLocalId} (${row.localId}) failed; left as is`, error);
-        }
-    }
-    const attempts = previousAttempts + 1;
-    await writeMarker({
-        status: result.failed > 0 && attempts < LEGACY_ITEM_STORAGE_MIGRATION_MAX_ATTEMPTS ? 'retry' : 'done',
-        attempts,
-        converted: result.converted,
-        failed: result.failed,
-        at: Date.now(),
-    });
-    if (result.candidates > 0) {
-        logger$5(`legacy ItemStorage rows: ${result.converted} converted, ${result.failed} failed, ` +
-            `${result.skipped} skipped of ${result.candidates}`);
-    }
-    return result;
-}
-let running$4;
-let deferredUntilLeader$4 = false;
-const runInBackground$4 = () => {
-    running$4 ?? (running$4 = withDbTabLock('item-storage-migration', () => migrateLegacyItemStorageRows())
-        .then(() => undefined)
-        .catch((error) => {
-        // Never fails init: rows stay as they were and publish converts them lazily.
-        logger$5('legacy ItemStorage migration failed', error);
-    })
-        .finally(() => {
-        running$4 = undefined;
-    }));
-    return running$4;
-};
-/**
- * Starts {@link migrateLegacyItemStorageRows} in the background once client init has finished
- * (the properties table then holds the current storage settings). It runs in the leader tab only
- * (docs/MULTI_TAB.md), under a `seed:item-storage-migration:<db>` lock in case several tabs lead
- * (`multiTab: 'off'`); a tab that isn't leader runs it if it takes over. Never throws.
- */
-function startLegacyItemStorageMigration() {
-    if (isLeaderTab()) {
-        void runInBackground$4();
-        return;
-    }
-    if (deferredUntilLeader$4)
-        return;
-    deferredUntilLeader$4 = true;
-    void whenLeaderTab().then(() => {
-        deferredUntilLeader$4 = false;
-        void runInBackground$4();
-    });
-}
-
-const logger$4 = debug('seedSdk:db:removeForeignAttestationRows');
-/** appState key recording that the cleanup below has run on this database. */
-const FOREIGN_ATTESTATION_CLEANUP_KEY = 'foreignAttestationRowsRemoved';
-/** Lowercased `attester` of a stored attestation JSON; NULL when the JSON is invalid or has none. */
-const attesterOf = (raw) => sql `(CASE WHEN json_valid(${raw}) THEN lower(json_extract(${raw}, '$.attester')) END)`;
-/**
- * Deletes rows that an SDK without the attester check (partitionByRefAttester) synced from other
- * accounts' attestations: versions whose attester isn't their seed's, and
- * properties whose attester isn't their version's, plus the properties of those versions. Sync
- * removes them too, but only for the seeds it reaches, and only online; this needs no network.
- *
- * Only rows synced from EAS on both sides are compared, by the `attester` in their stored
- * attestation, as sync compares them: local drafts and rows without a stored attestation are
- * kept, like partitionByRefAttester keeps children whose attesters aren't both known.
- */
-async function removeForeignAttestationRows() {
-    const appDb = BaseDb.getAppDb();
-    const foreignVersions = await appDb
-        .select({ uid: versions.uid })
-        .from(versions)
-        .innerJoin(seeds, eq(seeds.localId, versions.seedLocalId))
-        .where(and(isNotNull(versions.uid), sql `${attesterOf(versions.attestationRaw)} <> ${attesterOf(seeds.attestationRaw)}`));
-    const foreignVersionUids = foreignVersions.map((row) => row.uid).filter(Boolean);
-    const foreignProperties = await appDb
-        .select({ localId: metadata$1.localId })
-        .from(metadata$1)
-        .innerJoin(versions, eq(versions.uid, metadata$1.versionUid))
-        .where(and(isNotNull(metadata$1.uid), sql `${attesterOf(metadata$1.attestationRaw)} <> ${attesterOf(versions.attestationRaw)}`));
-    const foreignPropertyLocalIds = foreignProperties.map((row) => row.localId).filter(Boolean);
-    let propertyRows = foreignPropertyLocalIds.length;
-    await writeInBatches(foreignPropertyLocalIds, (chunk) => appDb.delete(metadata$1).where(inArray(metadata$1.localId, chunk)));
-    await writeInBatches(foreignVersionUids, async (chunk) => {
-        const removed = await appDb
-            .delete(metadata$1)
-            .where(inArray(metadata$1.versionUid, chunk))
-            .returning({ localId: metadata$1.localId });
-        propertyRows += removed.length;
-    });
-    await writeInBatches(foreignVersionUids, (chunk) => appDb.delete(versions).where(inArray(versions.uid, chunk)));
-    return { versionRows: foreignVersionUids.length, propertyRows };
-}
-/** Runs the cleanup unless this database has had it, and records that it has. */
-async function runOnce$2() {
-    const appDb = BaseDb.getAppDb();
-    const marker = await appDb
-        .select()
-        .from(appState)
-        .where(eq(appState.key, FOREIGN_ATTESTATION_CLEANUP_KEY))
-        .limit(1);
-    if (marker.length > 0)
-        return;
-    const result = await removeForeignAttestationRows();
-    const value = JSON.stringify({ ...result, at: Date.now() });
-    await appDb
-        .insert(appState)
-        .values({ key: FOREIGN_ATTESTATION_CLEANUP_KEY, value })
-        .onConflictDoUpdate({ target: appState.key, set: { value } });
-    if (result.versionRows > 0 || result.propertyRows > 0) {
-        logger$4(`removed ${result.versionRows} version and ${result.propertyRows} property rows from other attesters`);
-    }
-}
-let running$3;
-let deferredUntilLeader$3 = false;
-const runInBackground$3 = () => {
-    // Under the sync's lock, so it can't interleave with a sync writing the same rows.
-    running$3 ?? (running$3 = withDbTabLock('eas-sync', runOnce$2, { timeoutMs: Infinity })
-        .catch((error) => {
-        // Never fails init: the rows stay until the next sync of their seeds removes them.
-        logger$4('foreign attestation cleanup failed', error);
-    })
-        .finally(() => {
-        running$3 = undefined;
-    }));
-    return running$3;
-};
-/**
- * Starts {@link removeForeignAttestationRows} in the background after client init, once per
- * database: a one-time data fix, so an init step rather than a SQL migration (it needs the
- * attester out of stored JSON, the same rule as sync, and must never block or fail init). Leader
- * tab only (docs/MULTI_TAB.md); a tab that isn't leader runs it if it takes over. Never throws.
- */
-function startForeignAttestationCleanup() {
-    if (isLeaderTab()) {
-        void runInBackground$3();
-        return;
-    }
-    if (deferredUntilLeader$3)
-        return;
-    deferredUntilLeader$3 = true;
-    void whenLeaderTab().then(() => {
-        deferredUntilLeader$3 = false;
-        void runInBackground$3();
-    });
-}
-
-const logger$3 = debug('seedSdk:db:alignRowPublishers');
-/** appState key recording that the fix below has run on this database. */
-const ROW_PUBLISHERS_ALIGNED_KEY = 'rowPublishersAligned';
-/**
- * Gives version and property rows their seed's publisher. Before, edits wrote property rows with no
- * publisher, and versions and property rows took the session's publisher rather than the seed's,
- * so connecting another wallet could claim rows of a seed that already had one. Local query reads
- * report a row's publisher as its attester and leave out rows whose attester isn't their parent's.
- *
- * Only rows without a stored attestation are changed: synced rows carry their attester in
- * `attestation_raw`. When the seed belongs to no wallet yet, its unsealed rows lose any publisher,
- * so they're claimed with it.
- */
-async function alignRowPublishers() {
-    const appDb = BaseDb.getAppDb();
-    const align = async (table) => {
-        const rows = (await appDb
-            .select({
-            localId: table.localId,
-            uid: table.uid,
-            publisher: table.publisher,
-            seedPublisher: seeds.publisher,
-            seedAttestationRaw: seeds.attestationRaw,
-            seedUid: seeds.uid,
-            attestationRaw: table.attestationRaw,
-        })
-            .from(table)
-            .innerJoin(seeds, eq(seeds.localId, table.seedLocalId)));
-        const byTarget = new Map();
-        for (const row of rows) {
-            if (!row.localId || (row.attestationRaw != null && row.attestationRaw !== ''))
-                continue;
-            const seedPublisher = normalizePublisher(resolvePublisherFromSeedRow({
-                publisher: row.seedPublisher,
-                attestationRaw: row.seedAttestationRaw,
-                uid: row.seedUid,
-            }));
-            const current = normalizePublisher(row.publisher);
-            let target;
-            if (seedPublisher) {
-                if (current === seedPublisher)
-                    continue;
-                target = seedPublisher;
-            }
-            else {
-                // A seed with no wallet yet: its unsealed rows go with it when it's claimed.
-                if (!current || !isPlaceholderUid(row.uid))
-                    continue;
-                target = null;
-            }
-            const ids = byTarget.get(target) ?? [];
-            ids.push(row.localId);
-            byTarget.set(target, ids);
-        }
-        let changed = 0;
-        for (const [target, ids] of byTarget) {
-            await writeInBatches(ids, (chunk) => appDb.update(table).set({ publisher: target }).where(inArray(table.localId, chunk)));
-            changed += ids.length;
-        }
-        return changed;
-    };
-    const versionRows = await align(versions);
-    const propertyRows = await align(metadata$1);
-    return { versionRows, propertyRows };
-}
-/** Runs the fix unless this database has had it, and records that it has. */
-async function runOnce$1() {
-    const appDb = BaseDb.getAppDb();
-    const marker = await appDb
-        .select()
-        .from(appState)
-        .where(eq(appState.key, ROW_PUBLISHERS_ALIGNED_KEY))
-        .limit(1);
-    if (marker.length > 0)
-        return;
-    const result = await alignRowPublishers();
-    const value = JSON.stringify({ ...result, at: Date.now() });
-    await appDb
-        .insert(appState)
-        .values({ key: ROW_PUBLISHERS_ALIGNED_KEY, value })
-        .onConflictDoUpdate({ target: appState.key, set: { value } });
-    if (result.versionRows > 0 || result.propertyRows > 0) {
-        logger$3(`gave ${result.versionRows} version and ${result.propertyRows} property rows their seed's publisher`);
-    }
-}
-let running$2;
-let deferredUntilLeader$2 = false;
-const runInBackground$2 = () => {
-    // Under the sync's lock: sync writes these rows too.
-    running$2 ?? (running$2 = withDbTabLock('eas-sync', runOnce$1, { timeoutMs: Infinity })
-        .catch((error) => {
-        // Never fails init: the rows keep their old publisher.
-        logger$3('row publisher fix failed', error);
-    })
-        .finally(() => {
-        running$2 = undefined;
-    }));
-    return running$2;
-};
-/**
- * Starts {@link alignRowPublishers} in the background after client init, once per database, like
- * the foreign-attestation cleanup. Leader tab only (docs/MULTI_TAB.md). Never throws.
- */
-function startAlignRowPublishers() {
-    if (isLeaderTab()) {
-        void runInBackground$2();
-        return;
-    }
-    if (deferredUntilLeader$2)
-        return;
-    deferredUntilLeader$2 = true;
-    void whenLeaderTab().then(() => {
-        deferredUntilLeader$2 = false;
-        void runInBackground$2();
-    });
-}
-
-const logger$2 = debug('seedSdk:db:clearStoredDisplayUrls');
-/** appState key recording that the fix below has run on this database. */
-const STORED_DISPLAY_URLS_CLEARED_KEY = 'storedDisplayUrlsCleared';
-/**
- * Nulls `ref_resolved_display_value` on File and Image rows that hold a session URL. SDK 0.7.5 and
- * 0.7.6 stored a File's content URL there: a `blob:` URL that is dead after a reload, or a
- * `file://` URL that breaks when filesDir moves. Readers now mint the URL from the file on disk and
- * ignore the column for these types; clearing it keeps older readers and direct DB queries from
- * picking the dead URL up. Returns the number of rows changed.
- */
-async function clearStoredDisplayUrls() {
-    const appDb = BaseDb.getAppDb();
-    const where = and(inArray(metadata$1.refSeedType, ['file', 'image']), or(like(metadata$1.refResolvedDisplayValue, 'blob:%'), like(metadata$1.refResolvedDisplayValue, 'file:%')));
-    const rows = (await appDb.select({ localId: metadata$1.localId }).from(metadata$1).where(where));
-    if (rows.length === 0)
-        return 0;
-    await appDb.update(metadata$1).set({ refResolvedDisplayValue: null }).where(where);
-    return rows.length;
-}
-/** Runs the fix unless this database has had it, and records that it has. */
-async function runOnce() {
-    const appDb = BaseDb.getAppDb();
-    const marker = await appDb
-        .select()
-        .from(appState)
-        .where(eq(appState.key, STORED_DISPLAY_URLS_CLEARED_KEY))
-        .limit(1);
-    if (marker.length > 0)
-        return;
-    const rows = await clearStoredDisplayUrls();
-    const value = JSON.stringify({ rows, at: Date.now() });
-    await appDb
-        .insert(appState)
-        .values({ key: STORED_DISPLAY_URLS_CLEARED_KEY, value })
-        .onConflictDoUpdate({ target: appState.key, set: { value } });
-    if (rows > 0) {
-        logger$2(`cleared stored display URLs on ${rows} File/Image rows`);
-    }
-}
-let running$1;
-let deferredUntilLeader$1 = false;
-const runInBackground$1 = () => {
-    running$1 ?? (running$1 = runOnce()
-        .catch((error) => {
-        // Never fails init: readers ignore the column for File and Image anyway.
-        logger$2('clearing stored display URLs failed', error);
-    })
-        .finally(() => {
-        running$1 = undefined;
-    }));
-    return running$1;
-};
-/**
- * Starts {@link clearStoredDisplayUrls} in the background after client init, once per database.
- * Leader tab only (docs/MULTI_TAB.md). Never throws.
- */
-function startClearStoredDisplayUrls() {
-    if (isLeaderTab()) {
-        void runInBackground$1();
-        return;
-    }
-    if (deferredUntilLeader$1)
-        return;
-    deferredUntilLeader$1 = true;
-    void whenLeaderTab().then(() => {
-        deferredUntilLeader$1 = false;
-        void runInBackground$1();
-    });
-}
-
 const logger$1 = debug('seedSdk:db:canonicalizeModelTypes');
 /**
  * Model types in the local DB (`seeds.type`, `versions.seed_type`, `metadata.model_type`) are the
@@ -4720,6 +3488,19 @@ const createVersion = async ({ seedLocalId, seedUid, seedType, uid, }, options =
     return newVersionLocalId;
 };
 
+/** Absolute path of the file {@link writeItemStorageFile} writes for `target`. */
+const getItemStorageFilePath = (target) => BaseFileManager.getFilesPath(getItemStorageSubdir(target.localStorageDir), target.fileName || getItemStorageLocalFileName(target.seedId, target.filenameSuffix));
+/**
+ * Lock name for one ItemStorage file: `seed:item-storage:<absolute file path>`. The path starts
+ * with the files root, which also names the database (`<filesDir>/db/seed.db`), so the name is
+ * per database as well as per file.
+ */
+const itemStorageFileLockName = (filePath) => `seed:item-storage:${filePath}`;
+/** {@link withItemStorageFileLock} only if the lock is free now (see `tryWithTabLock`). */
+function tryWithItemStorageFileLock(filePath, fn) {
+    return tryWithTabLock(itemStorageFileLockName(filePath), fn);
+}
+
 /**
  * Conflicts between a local edit and a value sync wrote after it (ADR 0019). The local edit wins:
  * a pending edit applies over the synced row as a new draft, and a draft already written stays the
@@ -5036,7 +3817,6 @@ async function applyItemStorageValue(seedLocalId, propertyName, op, db) {
         localStorageDir,
         // The draft is as new as its content (see updateItemPropertyValue).
         createdAt: now,
-        // Same shape as a row the migration or publish converted (convertVerbatimItemStorageRow).
         ...(clearsVerbatimValue && { propertyValue: null, refValueType: 'file' }),
     })
         .where(eq(metadata$1.localId, draft.localId));
@@ -5504,16 +4284,6 @@ const clientManagerMachine = setup({
                 assign({
                     isInitialized: true,
                 }),
-                // One-time data migration that writes files, so it can't be a SQL migration in prepareDb.
-                // In the background after init: the app is usable at once, the properties table holds the
-                // current storage settings by now, and a failure never fails init.
-                () => startLegacyItemStorageMigration(),
-                // Also once, in the background: rows an older sync stored from other accounts' attestations.
-                () => startForeignAttestationCleanup(),
-                // Also once: version and property rows get their seed's publisher (rows from older edits had none).
-                () => startAlignRowPublishers(),
-                // Also once: File/Image rows lose the session URLs 0.7.5–0.7.6 stored (dead blob: URLs after reload).
-                () => startClearStoredDisplayUrls(),
                 // Stored model types to the ADR 0008 form (html_page), so exact type filters find old rows.
                 () => startCanonicalizeModelTypes(),
                 // Registers the item appliers and resumes outbox ops left pending (a reload, a closed
@@ -5656,10 +4426,8 @@ function seedRowToAttestation(row) {
         return null;
     const fromRaw = attestationFromRaw(row.attestationRaw);
     if (fromRaw) {
-        const schemaName = row.schemaName ??
-            fromRaw.schema?.schemaNames?.[0]?.name ??
-            row.type ??
-            'unknown';
+        // The EAS schema name ("post"), which `seeds.type` also holds.
+        const schemaName = fromRaw.schema?.schemaNames?.[0]?.name ?? row.type ?? 'unknown';
         return withLocalRevocation({
             ...fromRaw,
             id: row.uid,
@@ -5672,7 +4440,7 @@ function seedRowToAttestation(row) {
             schemaId: fromRaw.schemaId || row.schemaUid || '',
         }, row.revokedAt);
     }
-    const schemaName = row.schemaName ?? row.type ?? 'unknown';
+    const schemaName = row.type ?? 'unknown';
     return withLocalRevocation({
         id: row.uid,
         decodedDataJson: '',
@@ -5739,29 +4507,6 @@ function metadataRowToAttestation(row) {
         attester: row.publisher ?? undefined,
     }, row.revokedAt);
 }
-async function resolveSchemaNameForSeedType(appDb, seedType, 
-/** seeds.model_file_id: the seed's own model (model names are only unique per schema). */
-modelFileId) {
-    if (!seedType)
-        return null;
-    const normalized = startCase(seedType);
-    try {
-        const schemaRows = await appDb
-            .select({ schemaName: schemas.name })
-            .from(models$1)
-            .innerJoin(modelSchemas, eq(models$1.id, modelSchemas.modelId))
-            .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
-            .where(modelFileId ? eq(models$1.schemaFileId, modelFileId) : eq(models$1.name, normalized))
-            .orderBy(desc(models$1.id))
-            .limit(1);
-        if (schemaRows[0]?.schemaName)
-            return schemaRows[0].schemaName;
-    }
-    catch {
-        // ignore
-    }
-    return seedType;
-}
 function monthBoundsUnix(year, month) {
     const startDate = new Date(year, month - 1, 1);
     const endDate = new Date(year, month, 0, 23, 59, 59);
@@ -5783,7 +4528,6 @@ async function listPublishedSeedRows(schemaName, opts) {
         uid: seeds.uid,
         schemaUid: seeds.schemaUid,
         type: seeds.type,
-        modelFileId: seeds.modelFileId,
         publisher: seeds.publisher,
         attestationRaw: seeds.attestationRaw,
         attestationCreatedAt: seeds.attestationCreatedAt,
@@ -5812,11 +4556,7 @@ async function listPublishedSeedRows(schemaName, opts) {
         const hasPublished = versionRows.some((v) => v.uid && isValidEasAttestationUid(v.uid) && !isRevokedLocally(v.revokedAt));
         if (!hasPublished)
             continue;
-        const schemaResolved = await resolveSchemaNameForSeedType(appDb, row.type, row.modelFileId);
-        const att = seedRowToAttestation({
-            ...row,
-            schemaName: schemaResolved === schemaName ? schemaName : (schemaResolved ?? schemaName),
-        });
+        const att = seedRowToAttestation(row);
         if (!att)
             continue;
         // Force requested schema name so assembleSeeds filters correctly
@@ -5851,7 +4591,6 @@ function createLocalQueryDataSource() {
                 uid: seeds.uid,
                 schemaUid: seeds.schemaUid,
                 type: seeds.type,
-                modelFileId: seeds.modelFileId,
                 publisher: seeds.publisher,
                 attestationRaw: seeds.attestationRaw,
                 attestationCreatedAt: seeds.attestationCreatedAt,
@@ -5865,8 +4604,7 @@ function createLocalQueryDataSource() {
                 return null;
             if (isRevokedLocally(row.revokedAt))
                 return null;
-            const schemaName = await resolveSchemaNameForSeedType(appDb, row.type, row.modelFileId);
-            return seedRowToAttestation({ ...row, schemaName });
+            return seedRowToAttestation(row);
         },
         async listSeedsBySchemaName(schemaName, opts) {
             const all = await listPublishedSeedRows(schemaName);
@@ -5950,7 +4688,6 @@ function createLocalQueryDataSource() {
                 uid: seeds.uid,
                 schemaUid: seeds.schemaUid,
                 type: seeds.type,
-                modelFileId: seeds.modelFileId,
                 publisher: seeds.publisher,
                 attestationRaw: seeds.attestationRaw,
                 attestationCreatedAt: seeds.attestationCreatedAt,
@@ -5962,8 +4699,7 @@ function createLocalQueryDataSource() {
             for (const row of rows) {
                 if (isRevokedLocally(row.revokedAt))
                     continue;
-                const schemaName = await resolveSchemaNameForSeedType(appDb, row.type, row.modelFileId);
-                const att = seedRowToAttestation({ ...row, schemaName });
+                const att = seedRowToAttestation(row);
                 if (att)
                     out.push(att);
             }
@@ -6539,5 +5275,5 @@ var ClientManager$1 = /*#__PURE__*/Object.freeze({
     getClient: getClient
 });
 
-export { ClientManager$1 as $, getPublishedSeedRecord as A, getSchemaNameFromId as B, ClientManager as C, isSeedQueryLocalSourceRegistered as D, EAS_CHAIN_ID_APP_STATE_KEY as E, listCompleteSchemaFiles as F, loadAllSchemasFromDb as G, mergeEasSyncRequestIntents as H, INIT_CONFIG_CONFLICT_MESSAGE as I, readSchema as J, registerSeedQueryLocalSource as K, requestEasSyncFromAddressChange as L, requestEasSyncFromEventBus as M, requestEasSyncFromModelsInit as N, sendEasSyncClientRequest as O, setRetriesWhenOnlineEnabled as P, startEasSyncActor as Q, RelationTargetError as R, unregisterSeedQueryLocalSource as S, createRowsWrittenSignal as T, createModelsFromJson as U, getLatestSchemaVersion as V, jsonPropertiesToSchemaProperties as W, schema as X, SEEDPROTOCOL_Seed_Protocol_v1 as Y, conflicts as Z, itemAppliers as _, applyCreateItem as a, applyDelete as b, applyItemStorageValue as c, deleteFiles as d, applyStorageValue as e, getPropertyConflict as f, getItemConflicts as g, getRefValueType as h, importJsonSchema as i, syncSchemaFromSource as j, transformImportToSchemaFile as k, loadSchemaFromFile as l, markPropertyConflictsResolved as m, getContentHash as n, isVerbatimItemStorageDraftRow as o, convertVerbatimItemStorageRow as p, assertLocalDbChain as q, readJsonImportFile as r, startItemOutbox as s, throwItemWriteError as t, claimUnpublishedDrafts as u, createLocalQueryDataSource as v, waitForEasReadChain as w, createSchema as x, easSyncActor as y, getClient as z };
-//# sourceMappingURL=ClientManager-B1r_8P5Z.js.map
+export { listCompleteSchemaFiles as A, loadAllSchemasFromDb as B, ClientManager as C, mergeEasSyncRequestIntents as D, EAS_CHAIN_ID_APP_STATE_KEY as E, registerSeedQueryLocalSource as F, requestEasSyncFromAddressChange as G, requestEasSyncFromModelsInit as H, INIT_CONFIG_CONFLICT_MESSAGE as I, sendEasSyncClientRequest as J, setRetriesWhenOnlineEnabled as K, startEasSyncActor as L, unregisterSeedQueryLocalSource as M, getLatestSchemaVersion as N, createRowsWrittenSignal as O, createModelsFromJson as P, jsonPropertiesToSchemaProperties as Q, RelationTargetError as R, schema as S, SEEDPROTOCOL_Seed_Protocol_v1 as T, conflicts as U, itemAppliers as V, ClientManager$1 as W, applyCreateItem as a, applyDelete as b, applyItemStorageValue as c, deleteFiles as d, applyStorageValue as e, getPropertyConflict as f, getItemConflicts as g, getRefValueType as h, importJsonSchema as i, syncSchemaFromSource as j, transformImportToSchemaFile as k, loadSchemaFromFile as l, markPropertyConflictsResolved as m, getContentHash as n, assertLocalDbChain as o, claimUnpublishedDrafts as p, createLocalQueryDataSource as q, readJsonImportFile as r, startItemOutbox as s, throwItemWriteError as t, easSyncActor as u, getClient as v, waitForEasReadChain as w, getPublishedSeedRecord as x, getSchemaNameFromId as y, isSeedQueryLocalSourceRegistered as z };
+//# sourceMappingURL=ClientManager-GZfXErDX.js.map