@seedprotocol/sdk 0.7.3-next.613.g79a8dfd → 0.7.4-next.711.gce2b766

package/dist/{ClientManager-DDA9956Y.js → ClientManager-i3nJASkg.js}

@@ -1,17 +1,16 @@
+import { startCase, isEqual } from 'lodash-es';
+import { E as BaseDb, l as easSyncProcesses, G as eventEmitter, a8 as isNode, ah as isBrowser, I as BasePathResolver, aA as normalizeAddressConfig, h as appState, aL as downloadAllFilesRequestHandler, aM as downloadAllFilesBinaryRequestHandler, J as BaseFileManager, H as toSnakeCase, s as models$1, r as modelUids, A as seeds, aB as normalizeAddressList, z as schemas, aK as loadModelsFromDbForSchema, aI as addSchemaToDb, aF as isInternalSchema, aN as INTERNAL_SCHEMA_IDS, $ as generateId, aO as linkModelToSchema, n as normalizeDataType, aq as SEED_PROTOCOL_SCHEMA_NAME, q as modelSchemas, m as metadata$1, u as properties, L as resolveItemModelFileId, C as versions, o as htmlEmbeddedImageCoPublish, j as arweaveL1FinalizeJobs, y as publishProcesses, X as normalizePublisher, aP as getWatchedAddressesFromDb, aQ as getOwnedAddressesFromDb, aR as CLIENT_NOT_INITIALIZED } from './BasePathResolver-Cm4apKRb.js';
 import debug from 'debug';
 import { createActor, setup, assign, fromPromise, fromCallback, waitFor } from 'xstate';
-import { m as eventEmitter, C as normalizeAddressConfig, E as normalizeAddressList, S as loadModelsFromDbForSchema, O as addSchemaToDb, n as normalizeDataType, U as linkModelToSchema, s as normalizePublisher, V as getWatchedAddressesFromDb, W as getOwnedAddressesFromDb } from './db-CQt-gcAl.js';
-import { u as MachineIds, V as ClientManagerEvents, C as ClientManagerState, W as resolvePublisherFromSeedRow, F as isLocalUnsealedDraft, I as Item } from './Item-D4FigtYS.js';
-import { a as BaseDb, e as easSyncProcesses, t as BasePathResolver, b as appState, B as BaseFileManager, j as models$1, i as modelUids, r as seeds, s as schemas, K as isInternalSchema, L as INTERNAL_SCHEMA_IDS, F as SEED_PROTOCOL_SCHEMA_NAME, g as modelSchemas, m as metadata$1, v as versions, h as htmlEmbeddedImageCoPublish, c as arweaveL1FinalizeJobs, q as publishProcesses, M as CLIENT_NOT_INITIALIZED } from './BasePathResolver-BdxCSIzn.js';
-import { eq, inArray, and, isNotNull, ne, desc, countDistinct, like, or, isNull } from 'drizzle-orm';
-import { q as withDbTabLock, k as isLeaderTab, x as postTabMessage, y as onTabMessage, w as whenLeaderTab, z as listenForOtherTabsEvents, B as isNode, C as isBrowser, D as startTabCoordination, E as downloadAllFilesRequestHandler, G as downloadAllFilesBinaryRequestHandler, t as toSnakeCase, v as withSeedDbLock, b as generateId, p as parseAddressesPersistedPayload, e as emitAcrossTabs, A as ADDRESSES_PERSISTED_EVENT, L as LOCAL_COPIES_REMOVED_EVENT } from './tabEvents-BZJMY5uK.js';
+import { x as MachineIds, a2 as ClientManagerEvents, a3 as withLockedItemStorageRow, a4 as getItemStorageFilePath, a5 as writeItemStorageFile, c as compareMetadataRowsLatestFirst, C as ClientManagerState, a6 as resolvePublisherFromSeedRow, J as isLocalUnsealedDraft, I as Item } from './Item-DBFchXpC.js';
+import { eq, inArray, and, isNotNull, ne, desc, countDistinct, isNull, or, like } from 'drizzle-orm';
+import { a as withDbTabLock, i as isLeaderTab, c as postTabMessage, o as onTabMessage, w as whenLeaderTab, l as listenForOtherTabsEvents, s as startTabCoordination, b as withSeedDbLock, p as parseAddressesPersistedPayload, e as emitAcrossTabs, A as ADDRESSES_PERSISTED_EVENT, L as LOCAL_COPIES_REMOVED_EVENT } from './tabEvents-9s2WCYw-.js';
 import { seedGatewayConfigFromSeedConfig, setPreferredArweaveReadBaseUrls, resolveSeedGatewayEndpoints, setResolvedSeedGatewayEndpoints, BaseArweaveClient, ensureReadGatewaySelected, DEFAULT_ARWEAVE_HOST } from '@seedprotocol/arweave';
 import { configureEasReadChain, BaseQueryClient, BaseEasClient, GET_SCHEMAS, whenEasReadChainSettled, getEasReadChainId, DEFAULT_EAS_CHAIN_ID, isEasReadChainConfigured, isValidEasAttestationUid } from '@seedprotocol/eas';
 import 'pluralize';
 import { sha3_256 } from '@noble/hashes/sha3';
-import { bytesToHex, utf8ToBytes } from '@noble/hashes/utils';
+import { utf8ToBytes, bytesToHex } from '@noble/hashes/utils';
 import { clearLocalQuerySource, registerLocalQuerySource, getSeed } from '@seedprotocol/query';
-import { startCase } from 'lodash-es';
 
 let writeTail = Promise.resolve();
 function enqueueEasSyncDbWrite(fn) {
@@ -109,7 +108,7 @@ const runEasSync = fromPromise(async ({ input, }) => {
         requestPayload: input.requestPayload,
         persistedSnapshot: input.runningSnapshot,
     });
-    const { runSyncFromEas } = await import('./syncDbWithEas-BU-jZ5bJ.js');
+    const { runSyncFromEas } = await import('./syncDbWithEas-Bv2Fe38J.js');
     try {
         // 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.
@@ -285,7 +284,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 = 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.
@@ -296,11 +295,11 @@ function runInLeaderTab(source, request) {
         return;
     }
     log(`${source} sync skipped: another tab leads`);
-    if (deferredUntilLeader.has(source))
+    if (deferredUntilLeader$1.has(source))
         return;
-    deferredUntilLeader.add(source);
+    deferredUntilLeader$1.add(source);
     void whenLeaderTab().then(() => {
-        deferredUntilLeader.delete(source);
+        deferredUntilLeader$1.delete(source);
         request();
     });
 }
@@ -374,10 +373,10 @@ var easSyncManager = /*#__PURE__*/Object.freeze({
     startEasSyncActor: startEasSyncActor
 });
 
-const logger$b = debug('seedSdk:services:events');
+const logger$c = debug('seedSdk:services:events');
 const handleServiceSaveState = (event) => {
     const { state, serviceId } = event;
-    logger$b(`[browser] [service.saveState.request] serviceId: ${serviceId}`);
+    logger$c(`[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))
 };
@@ -428,9 +427,18 @@ function normalizeSeedConfigEndpoints(config) {
     return { ...config, endpoints: next };
 }
 
-const logger$a = debug('seedSdk:ClientManager:initialize');
+const logger$b = debug('seedSdk:ClientManager:initialize');
+/**
+ * Whether a relative filesDir already names the .seed directory or a path inside
+ * it ('.seed', '.seed/files', './.seed/files'). '.seed-alt/x' is not: it is
+ * resolved under .seed like any other relative path.
+ */
+function isUnderDotSeed(relativePath) {
+    const firstSegment = relativePath.split(/[\\/]+/).find((segment) => segment !== '' && segment !== '.');
+    return firstSegment === '.seed';
+}
 const platformClassesInit = fromCallback(({ sendBack, input: { context, event } }) => {
-    logger$a('initialize from ClientManager');
+    logger$b('initialize from ClientManager');
     const { isInitialized } = context;
     if (!event || !('options' in event)) {
         throw new Error('Initialize event must include options');
@@ -463,7 +471,7 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
         }
         // Prefer the condition-resolved factory when available; fall back to explicit
         // platform imports so source/vitest resolution stays reliable.
-        const { configurePlatform } = await import('./configurePlatform-YcOiDQBZ.js');
+        const { configurePlatform } = await import('./configurePlatform-D0lQGAMQ.js');
         if (isBrowser()) {
             const { createPlatformServices } = await import('./platform.browser.js');
             configurePlatform(createPlatformServices());
@@ -526,8 +534,8 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
                 normalizedFilesDir = path.join(dotSeedDir, dirName);
             }
             else if (!path.isAbsolute(normalizedFilesDir)) {
-                // If it's a relative path, check if it already starts with .seed
-                if (normalizedFilesDir.startsWith('.seed') || normalizedFilesDir.startsWith('.seed/')) {
+                // If it's a relative path, check if it is already under .seed
+                if (isUnderDotSeed(normalizedFilesDir)) {
                     // Already relative to project root, resolve it
                     normalizedFilesDir = path.resolve(normalizedFilesDir);
                 }
@@ -550,6 +558,7 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
                 gatewaySidecarPort: gatewayConfig.hyper?.localSidecarPort,
                 gatewayProxyBaseUrl: resolvedGateway.proxyBaseUrl ?? gatewayConfig.proxyBaseUrl,
                 addresses: normalizedAddresses.owned,
+                addressesProvided: addresses !== undefined,
                 ownedAddresses: normalizedAddresses.owned,
                 watchedAddresses: normalizedAddresses.watched,
                 filesDir: normalizedFilesDir,
@@ -602,7 +611,7 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
     };
 });
 
-const logger$9 = debug('seedSdk:client:writeToDb');
+const logger$a = debug('seedSdk:client:writeToDb');
 const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
     const _saveAppState = async () => {
         try {
@@ -610,7 +619,7 @@ const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
             if (!appDb) {
                 // In test environments, continue anyway
                 if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-                    logger$9('[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');
@@ -626,13 +635,13 @@ const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
                     value: JSON.stringify(value),
                 },
             });
-            logger$9('result', result);
+            logger$a('result', result);
         }
         catch (error) {
-            logger$9('[client/actors] [saveAppState] Error saving app state:', error);
+            logger$a('[client/actors] [saveAppState] Error saving app state:', error);
             // In test environments, continue anyway
             if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-                logger$9('[client/actors] [saveAppState] Continuing despite error in test environment');
+                logger$a('[client/actors] [saveAppState] Continuing despite error in test environment');
                 return;
             }
             throw error;
@@ -647,10 +656,10 @@ const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
         });
     })
         .catch((error) => {
-        logger$9('[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 (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-            logger$9('[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,
@@ -720,7 +729,7 @@ const fileSystemInit = fromCallback(({ sendBack, input: { context }, }) => {
     };
 });
 
-const logger$8 = debug('seedSdk:client:actors:dbInit');
+const logger$9 = debug('seedSdk:client:actors:dbInit');
 const dbInit = fromCallback(({ sendBack, input: { context } }) => {
     const _dbInit = async () => {
         const { filesDir } = context;
@@ -734,14 +743,14 @@ const dbInit = fromCallback(({ sendBack, input: { context } }) => {
         if (!appDb) {
             throw new Error('Database not available after preparation');
         }
-        logger$8('[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$8('Error in dbInit:', error);
+        logger$9('Error in dbInit:', error);
         sendBack({
             type: 'error',
             error: error instanceof Error ? error : new Error(String(error))
@@ -749,7 +758,7 @@ const dbInit = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$7 = 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;
@@ -763,7 +772,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$7('model available:', key);
+            logger$8('model available:', key);
         }
     };
     _addModelsToStore()
@@ -771,7 +780,7 @@ const addModelsToStore = fromCallback(({ sendBack, input: { context } }) => {
         sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_STORE_SUCCESS });
     })
         .catch((error) => {
-        logger$7('[client/actors] [addModelsToStore] Error:', error);
+        logger$8('[client/actors] [addModelsToStore] Error:', error);
         sendBack({
             type: 'error',
             error: error instanceof Error ? error : new Error(String(error)),
@@ -779,7 +788,7 @@ const addModelsToStore = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$6 = 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:
@@ -802,7 +811,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$6('[client/actors] [addModelsToDb] inserted model:', name);
+                logger$7('[client/actors] [addModelsToDb] inserted model:', name);
             }
         }
         return rows;
@@ -839,7 +848,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         for (const modelName of modelNames) {
             const foundModel = rowFor(modelName);
             if (!foundModel) {
-                logger$6('[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;
             }
@@ -851,7 +860,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$6('[client/actors] [addModelsToDb] No models to process, but continuing');
+            logger$7('[client/actors] [addModelsToDb] No models to process, but continuing');
             sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_DB_SUCCESS });
             return;
         }
@@ -894,15 +903,15 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
                     requestEasSyncFromModelsInit();
                 }
                 else {
-                    logger$6('[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 (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-                    logger$6('[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$6('[client/actors] [addModelsToDb] Error fetching schemas (background):', error.message);
+                    logger$7('[client/actors] [addModelsToDb] Error fetching schemas (background):', error.message);
                 }
             }
         };
@@ -914,10 +923,10 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_DB_SUCCESS });
     })
         .catch((error) => {
-        logger$6('[client/actors] [addModelsToDb] Error:', error);
+        logger$7('[client/actors] [addModelsToDb] Error:', error);
         // In test environments, still send success to allow initialization to complete
         if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-            logger$6('[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 {
@@ -930,7 +939,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$5 = 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';
 /**
@@ -1000,7 +1009,7 @@ async function loadLocalDbChain() {
     const localChainId = await resolveLocalDbChainId(appDb);
     if (localChainId !== undefined) {
         configureEasReadChain('localDb', { chainId: localChainId });
-        logger$5('local DB holds chain %d', localChainId);
+        logger$6('local DB holds chain %d', localChainId);
         return;
     }
     if (isEasReadChainConfigured()) {
@@ -1026,15 +1035,33 @@ async function assertLocalDbChain() {
     configureEasReadChain('localDb', { chainId: localChainId ?? chainId });
 }
 
-const logger$4 = debug('seedSdk:client:actors:saveConfig');
+const logger$5 = debug('seedSdk:client:actors:saveConfig');
+let warnedKeptStoredAddresses = false;
 /**
- * Saves the addresses passed to init. Hosts pass `addresses: []` before a wallet connects. In the
- * first (leader) tab that clears stored addresses, as it always has, so drafts made before the
- * wallet reconnects stay editable. A tab opened while another is running (`keepStoredWhenEmpty`)
- * keeps them instead: they're the other tab's connected wallet, which EAS sync, downloads and
- * publishing read. See docs/MULTI_TAB.md.
+ * Saves the addresses passed to init.
+ *
+ * - No `addresses` option (`addressesProvided: false`): stored addresses are kept, with a
+ *   one-time warning when there are any, since a forgotten option would otherwise act on
+ *   an earlier session's wallet.
+ * - `addresses: []`: hosts pass this before a wallet connects. In the first (leader) tab it
+ *   clears stored addresses, so drafts made before the wallet reconnects stay editable. A tab
+ *   opened while another is running (`keepStoredWhenEmpty`) keeps them instead: they're the
+ *   other tab's connected wallet, which EAS sync, downloads and publishing read. See
+ *   docs/MULTI_TAB.md.
  */
-async function persistInitAddresses(appDb, { addresses, ownedAddresses, watchedAddresses }, { keepStoredWhenEmpty }) {
+async function persistInitAddresses(appDb, { addresses, addressesProvided, ownedAddresses, watchedAddresses, }, { keepStoredWhenEmpty }) {
+    if (addressesProvided === false) {
+        if (!warnedKeptStoredAddresses) {
+            const rows = await appDb.select().from(appState).where(eq(appState.key, 'addresses')).limit(1);
+            const stored = rows[0]?.value ? normalizeAddressConfig(JSON.parse(rows[0].value)) : undefined;
+            if (stored && (stored.owned.length > 0 || stored.watched.length > 0)) {
+                warnedKeptStoredAddresses = true;
+                console.warn(`[seed] client.init was called without \`addresses\`, so the stored addresses are kept ` +
+                    `(${stored.owned.length} owned, ${stored.watched.length} watched). Pass \`addresses: []\` to clear them.`);
+            }
+        }
+        return;
+    }
     const owned = normalizeAddressList(ownedAddresses ?? addresses ?? []);
     const watched = normalizeAddressList(watchedAddresses ?? []);
     if (owned.length === 0 && watched.length === 0 && keepStoredWhenEmpty)
@@ -1046,13 +1073,13 @@ async function persistInitAddresses(appDb, { addresses, ownedAddresses, watchedA
         .onConflictDoUpdate({ target: appState.key, set: { value } });
 }
 const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
-    logger$4('saveConfig starting');
-    const { endpoints, addresses, ownedAddresses, watchedAddresses, arweaveDomain, uploadApiBaseUrl, gatewayTransport, gatewayHyperKey, gatewaySidecarHost, gatewaySidecarPort, gatewayProxyBaseUrl, } = context;
+    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$4('[internal/actors] [saveConfig] Invalid endpoints:', { endpoints });
+        logger$5('[internal/actors] [saveConfig] Invalid endpoints:', { endpoints });
         throw error;
     }
     const _saveConfig = async () => {
@@ -1061,7 +1088,7 @@ const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
             if (!appDb) {
                 // In test environments, continue anyway
                 if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-                    logger$4('[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');
@@ -1080,7 +1107,7 @@ const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
                     value: endpointsValueString,
                 },
             });
-            await persistInitAddresses(appDb, { addresses, ownedAddresses, watchedAddresses }, { keepStoredWhenEmpty: !isLeaderTab() });
+            await persistInitAddresses(appDb, { addresses, addressesProvided, ownedAddresses, watchedAddresses }, { keepStoredWhenEmpty: !isLeaderTab() });
             await appDb
                 .insert(appState)
                 .values({
@@ -1116,10 +1143,10 @@ const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
             await loadLocalDbChain();
         }
         catch (error) {
-            logger$4('[internal/actors] [saveConfig] Error saving config:', error);
+            logger$5('[internal/actors] [saveConfig] Error saving config:', error);
             // In test environments, continue anyway
             if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-                logger$4('[internal/actors] [saveConfig] Continuing despite error in test environment');
+                logger$5('[internal/actors] [saveConfig] Continuing despite error in test environment');
                 return;
             }
             throw error;
@@ -1128,14 +1155,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$4('[internal/actors] [saveConfig] saveConfig success');
+        logger$5('[internal/actors] [saveConfig] saveConfig success');
         return sendBack({ type: ClientManagerEvents.SAVE_CONFIG_SUCCESS });
     })
         .catch((error) => {
-        logger$4('[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 (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-            logger$4('[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 {
@@ -1148,7 +1175,7 @@ const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$3 = debug('seedSdk:helpers:schema');
+const logger$4 = debug('seedSdk:helpers:schema');
 /**
  * Sanitize a schema name to be filesystem-safe
  * Replaces all special characters (except alphanumeric, hyphens, underscores) with underscores
@@ -1344,7 +1371,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$3(`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);
@@ -1480,7 +1507,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$3(`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 = [];
             }
         }
@@ -1533,7 +1560,7 @@ async function loadAllSchemasFromDb() {
                 continue;
             }
             catch (error) {
-                logger$3(`Error parsing schemaData for ${schemaName}:`, error);
+                logger$4(`Error parsing schemaData for ${schemaName}:`, error);
                 // Fall through to file-based loading
             }
         }
@@ -1575,7 +1602,7 @@ async function loadAllSchemasFromDb() {
                     continue;
                 }
                 catch (error) {
-                    logger$3(`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
                 }
             }
@@ -1619,7 +1646,7 @@ async function loadAllSchemasFromDb() {
                     continue;
                 }
                 catch (error) {
-                    logger$3(`Error parsing schemaData for ${schemaName}:`, error);
+                    logger$4(`Error parsing schemaData for ${schemaName}:`, error);
                 }
             }
         }
@@ -1630,11 +1657,11 @@ async function loadAllSchemasFromDb() {
         // Only process if not already in result
         if (!processedSchemaNames.has(schemaFileInfo.name)) {
             if (isInternalSchema(schemaFileInfo.name, schemaFileInfo.schemaFileId)) {
-                logger$3(`STEP 3: skipping internal schema file: ${schemaFileInfo.filePath}`);
+                logger$4(`STEP 3: skipping internal schema file: ${schemaFileInfo.filePath}`);
                 continue;
             }
             try {
-                logger$3(`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)
@@ -1654,7 +1681,7 @@ async function loadAllSchemasFromDb() {
                 processedSchemaNames.add(schemaFileInfo.name);
             }
             catch (error) {
-                logger$3(`Error loading schema file ${schemaFileInfo.filePath}:`, error);
+                logger$4(`Error loading schema file ${schemaFileInfo.filePath}:`, error);
             }
         }
     }
@@ -1671,7 +1698,7 @@ async function migrateFileSchemasToDb() {
     if (!db) {
         throw new Error('Database not found');
     }
-    logger$3('Starting migration of file-based schemas to database');
+    logger$4('Starting migration of file-based schemas to database');
     // Get all complete schema files
     const completeSchemas = await listCompleteSchemaFiles();
     let migratedCount = 0;
@@ -1681,7 +1708,7 @@ async function migrateFileSchemasToDb() {
             const content = await BaseFileManager.readFileAsString(schemaFileInfo.filePath);
             const schemaFile = JSON.parse(content);
             if (!schemaFile.$schema || !schemaFile.metadata?.name) {
-                logger$3(`Skipping invalid schema file: ${schemaFileInfo.filePath}`);
+                logger$4(`Skipping invalid schema file: ${schemaFileInfo.filePath}`);
                 continue;
             }
             const schemaName = schemaFile.metadata.name;
@@ -1703,17 +1730,17 @@ async function migrateFileSchemasToDb() {
                 JSON.stringify(schemaFile, null, 2), // schemaData
                 false);
                 migratedCount++;
-                logger$3(`Migrated schema: ${schemaName} v${schemaFile.version}`);
+                logger$4(`Migrated schema: ${schemaName} v${schemaFile.version}`);
             }
             else {
-                logger$3(`Schema ${schemaName} already exists in database, skipping`);
+                logger$4(`Schema ${schemaName} already exists in database, skipping`);
             }
         }
         catch (error) {
-            logger$3(`Error migrating schema file ${schemaFileInfo.filePath}:`, error);
+            logger$4(`Error migrating schema file ${schemaFileInfo.filePath}:`, error);
         }
     }
-    logger$3(`Migration complete: ${migratedCount} schemas migrated`);
+    logger$4(`Migration complete: ${migratedCount} schemas migrated`);
     return migratedCount;
 }
 /**
@@ -1768,7 +1795,7 @@ const getDeterministicIdsWithPrefix = (prefix) => {
     return (suffix) => bytesToHex(prefixHash.clone().update(utf8ToBytes(suffix)).digest()).slice(0, 10);
 };
 
-const logger$2 = 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.
@@ -1846,8 +1873,8 @@ function getRefValueType(prop) {
  * @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_0 = await import('./BasePathResolver-BdxCSIzn.js');
-    const _ns_0 = _mod_0.N;
+    const _mod_0 = await import('./BasePathResolver-Cm4apKRb.js');
+    const _ns_0 = _mod_0.aZ;
     const modelSchemaMod = _ns_0;
     const { properties: propertiesTable } = modelSchemaMod;
     const drizzleMod = await import('drizzle-orm');
@@ -1859,11 +1886,11 @@ const verifyPropertiesPersisted = async (db, modelId, modelName, maxRetries = 10
             .where(eq(propertiesTable.modelId, modelId))
             .limit(1);
         if (props.length > 0) {
-            logger$2(`Verified properties exist for model "${modelName}" (modelId: ${modelId}) after ${attempt + 1} attempt(s)`);
+            logger$3(`Verified properties exist for model "${modelName}" (modelId: ${modelId}) after ${attempt + 1} attempt(s)`);
             return;
         }
         if (attempt < maxRetries - 1) {
-            logger$2(`Properties not yet visible for model "${modelName}" (modelId: ${modelId}), retrying in ${retryDelay}ms (attempt ${attempt + 1}/${maxRetries})`);
+            logger$3(`Properties not yet visible for model "${modelName}" (modelId: ${modelId}), retrying in ${retryDelay}ms (attempt ${attempt + 1}/${maxRetries})`);
             await new Promise(resolve => setTimeout(resolve, retryDelay));
         }
     }
@@ -2169,7 +2196,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
             if (parsed.$schema && parsed.metadata) {
                 // It's already a complete schema format - preserve it (id may be missing, will be generated)
                 originalSchemaFile = parsed;
-                logger$2(`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 {
@@ -2194,8 +2221,8 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         // Check DB for existing schema by name+version (same as minimal path)
         const db = BaseDb.getAppDb();
         if (db) {
-            const _mod_1 = await import('./BasePathResolver-BdxCSIzn.js');
-            const _ns_1 = _mod_1.Q;
+            const _mod_1 = await import('./BasePathResolver-Cm4apKRb.js');
+            const _ns_1 = _mod_1.a$;
             const schemaSchemaMod = _ns_1;
             const { schemas: schemasTable } = schemaSchemaMod;
             const drizzleMod = await import('drizzle-orm');
@@ -2208,16 +2235,16 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                 .limit(1);
             if (existingByName.length > 0 && existingByName[0].schemaData) {
                 const existing = existingByName[0];
-                logger$2(`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$2(`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$2(`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);
@@ -2225,7 +2252,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                         await BaseFileManager.waitForFileWithContent(existingFilePath, 100, 5000);
                         return await loadSchemaFromFile(existingFilePath);
                     }
-                    logger$2(`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 '';
                 }
             }
@@ -2241,7 +2268,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         // processSchemaFiles runs multiple times (React StrictMode, app restarts).
         if (!schemaFile.id) {
             schemaFile.id = await getDeterministicSchemaFileId(schemaFile);
-            logger$2(`Generated deterministic schema ID for ${schemaFile.metadata.name}:`, schemaFile.id);
+            logger$3(`Generated deterministic schema ID for ${schemaFile.metadata.name}:`, schemaFile.id);
         }
         // Before generating IDs, check if a file already exists with this schemaFileId
         // This handles the case where the schema was already loaded via loadSchemaFromFile
@@ -2251,7 +2278,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         const existingFileExists = await BaseFileManager.pathExists(existingFilePath);
         if (existingFileExists) {
             // File already exists with this schemaFileId - just load it instead of creating a new one
-            logger$2(`Schema file already exists with schemaFileId ${schemaFile.id}, loading it instead of creating new file`);
+            logger$3(`Schema file already exists with schemaFileId ${schemaFile.id}, loading it instead of creating new file`);
             return await loadSchemaFromFile(existingFilePath);
         }
         // Generate missing model and property IDs.
@@ -2262,12 +2289,12 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         for (const [modelName, model] of Object.entries(schemaFile.models || {})) {
             if (!model.id) {
                 model.id = getDeterministicId(modelName);
-                logger$2(`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$2(`Generated deterministic property ID for ${modelName}.${propName}:`, prop.id);
+                    logger$3(`Generated deterministic property ID for ${modelName}.${propName}:`, prop.id);
                 }
             }
         }
@@ -2279,8 +2306,8 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         // For minimal imports: check DB for existing schema before creating new file
         const db = BaseDb.getAppDb();
         if (db) {
-            const _mod_2 = await import('./BasePathResolver-BdxCSIzn.js');
-            const _ns_2 = _mod_2.Q;
+            const _mod_2 = await import('./BasePathResolver-Cm4apKRb.js');
+            const _ns_2 = _mod_2.a$;
             const schemaSchemaMod = _ns_2;
             const { schemas: schemasTable } = schemaSchemaMod;
             const drizzleMod = await import('drizzle-orm');
@@ -2303,14 +2330,14 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                                 const workingDir = BaseFileManager.getWorkingDir();
                                 const existingFilePath = getSchemaFilePath(workingDir, importData.name, version, existing.schemaFileId);
                                 if (await BaseFileManager.pathExists(existingFilePath)) {
-                                    logger$2(`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$2(`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
@@ -2321,10 +2348,10 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                                 await BaseFileManager.createDirIfNotExists(workingDir);
                                 await BaseFileManager.saveFile(existingFilePath, existing.schemaData);
                                 await BaseFileManager.waitForFileWithContent(existingFilePath, 100, 5000);
-                                logger$2(`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$2(`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
@@ -2335,7 +2362,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                             .orderBy(desc(schemasTable.version))
                             .limit(1);
                         const newVersion = latestVersionRows.length > 0 ? latestVersionRows[0].version + 1 : version;
-                        logger$2(`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;
                     }
@@ -2359,7 +2386,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
     // 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$2(`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;
@@ -2416,7 +2443,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         // Use fixed internal schema ID if missing (never generate for internal)
         if (!schemaFile.id) {
             schemaFile.id = INTERNAL_SCHEMA_IDS[0];
-            logger$2('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
@@ -2426,7 +2453,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
             // Generate model ID if missing
             if (!model.id) {
                 model.id = generateId();
-                logger$2(`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;
             }
@@ -2436,7 +2463,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                 // Generate property ID if missing
                 if (!prop.id) {
                     prop.id = generateId();
-                    logger$2(`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;
                 }
@@ -2448,7 +2475,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         }
         // Convert JSON models to Model classes, passing modelFileIds and propertyFileIds so Model instances use correct IDs
         const modelDefinitions = await createModelsFromJson(importDataForInternal, modelFileIds, propertyFileIds);
-        logger$2('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,
@@ -2458,8 +2485,8 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
             updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
         };
         // Use dynamic import to break circular dependency
-        const _mod_3 = await import('./db-CQt-gcAl.js');
-        const _ns_3 = _mod_3.Z;
+        const _mod_3 = await import('./BasePathResolver-Cm4apKRb.js');
+        const _ns_3 = _mod_3.b2;
         const dbMod = _ns_3;
         const { addSchemaToDb, addModelsToDb } = dbMod;
         // Try to add schema and models to database if database is available
@@ -2480,12 +2507,12 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                     });
                     // Verify expected models are linked (single attempt - addModelsToDb already confirmed)
                     const expectedModelNames = Object.keys(schemaFile.models || {});
-                    const _mod_4 = await import('./BasePathResolver-BdxCSIzn.js');
-                    const _ns_4 = _mod_4.R;
+                    const _mod_4 = await import('./BasePathResolver-Cm4apKRb.js');
+                    const _ns_4 = _mod_4.b0;
                     const modelSchemaSchemaMod = _ns_4;
                     const { modelSchemas } = modelSchemaSchemaMod;
-                    const _mod_5 = await import('./BasePathResolver-BdxCSIzn.js');
-                    const _ns_5 = _mod_5.N;
+                    const _mod_5 = await import('./BasePathResolver-Cm4apKRb.js');
+                    const _ns_5 = _mod_5.aZ;
                     const modelSchemaMod = _ns_5;
                     const { models: modelsTable } = modelSchemaMod;
                     const drizzleMod = await import('drizzle-orm');
@@ -2574,12 +2601,12 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         }
         catch (dbError) {
             // Database not available - log warning but continue
-            logger$2('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));
         }
         // 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$2('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
@@ -2590,7 +2617,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
     // Ensure schema ID is defined (should always be set by this point, but check for safety)
     if (!schemaFile.id) {
         schemaFile.id = generateId();
-        logger$2('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);
@@ -2609,7 +2636,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                     const data = JSON.parse(content);
                     if (data.$schema) {
                         // File is already a complete schema, just load it
-                        logger$2(`Schema file ${filePath} already exists and is complete, loading it`);
+                        logger$3(`Schema file ${filePath} already exists and is complete, loading it`);
                         return await loadSchemaFromFile(filePath);
                     }
                 }
@@ -2627,7 +2654,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                 // Compare schemas structurally
                 if (compareSchemasStructurally(schemaFile, existingSchema)) {
                     // Schemas match - just load the existing file
-                    logger$2(`Schema ${schemaFile.metadata.name} v${version} already exists with matching content, loading it`);
+                    logger$3(`Schema ${schemaFile.metadata.name} v${version} already exists with matching content, loading it`);
                     return await loadSchemaFromFile(filePath);
                 }
                 else {
@@ -2670,7 +2697,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
  * Apply schema and models to the database. Shared by loadSchemaFromFile and syncSchemaFromSource.
  * @internal
  */
-async function applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, propertyFileIds) {
+async function applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, propertyFileIds, propertyDefinitions) {
     const schemaName = schemaFile.metadata?.name;
     const version = schemaFile.version;
     if (!schemaName) {
@@ -2683,8 +2710,8 @@ async function applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, prope
         createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
         updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
     };
-    const _mod_6 = await import('./db-CQt-gcAl.js');
-    const _ns_6 = _mod_6.Z;
+    const _mod_6 = await import('./BasePathResolver-Cm4apKRb.js');
+    const _ns_6 = _mod_6.b2;
     const dbMod = _ns_6;
     const { addSchemaToDb, addModelsToDb } = dbMod;
     const db = BaseDb.getAppDb();
@@ -2698,6 +2725,7 @@ async function applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, prope
             schemaFileId: schemaFile.id,
             modelFileIds,
             propertyFileIds,
+            propertyDefinitions,
         });
         await new Promise(resolve => setTimeout(resolve, 200));
     }
@@ -2804,7 +2832,7 @@ const loadSchemaFromFile = async (schemaFilePath) => {
         // Generate schema ID if missing (before creating schemaInput)
         if (!schemaFile.id) {
             schemaFile.id = generateId();
-            logger$2('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
@@ -2814,7 +2842,7 @@ const loadSchemaFromFile = async (schemaFilePath) => {
             // Generate model ID if missing
             if (!model.id) {
                 model.id = generateId();
-                logger$2(`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;
             }
@@ -2824,7 +2852,7 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                 // Generate property ID if missing
                 if (!prop.id) {
                     prop.id = generateId();
-                    logger$2(`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;
                 }
@@ -2836,19 +2864,26 @@ const loadSchemaFromFile = async (schemaFilePath) => {
         }
         // Convert JSON models to Model classes, passing modelFileIds and propertyFileIds so Model instances use correct IDs
         const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds);
-        logger$2('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();
             if (db) {
-                const { schemaRecord } = await applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, propertyFileIds);
+                // A model already in the instance cache keeps its old properties (Model.create ignores the
+                // ones passed), so give addModelsToDb this file's definitions: a renamed or changed property
+                // must come from the file, not from the cached model.
+                const propertyDefinitions = new Map(Object.entries(importData.models).map(([modelName, modelDef]) => [
+                    modelName,
+                    jsonPropertiesToSchemaProperties(modelName, modelDef, propertyFileIds.get(modelName)),
+                ]));
+                const { schemaRecord } = await applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, propertyFileIds, propertyDefinitions);
                 // Query the database to get model IDs that were just created
-                const _mod_7 = await import('./BasePathResolver-BdxCSIzn.js');
-                const _ns_7 = _mod_7.R;
+                const _mod_7 = await import('./BasePathResolver-Cm4apKRb.js');
+                const _ns_7 = _mod_7.b0;
                 const modelSchemaSchemaMod = _ns_7;
                 const { modelSchemas } = modelSchemaSchemaMod;
-                const _mod_8 = await import('./BasePathResolver-BdxCSIzn.js');
-                const _ns_8 = _mod_8.N;
+                const _mod_8 = await import('./BasePathResolver-Cm4apKRb.js');
+                const _ns_8 = _mod_8.aZ;
                 const modelSchemaMod = _ns_8;
                 const { models: modelsTable } = modelSchemaMod;
                 const drizzleMod = await import('drizzle-orm');
@@ -2895,17 +2930,17 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                             await new Promise(resolve => setTimeout(resolve, 100));
                         }
                     }
-                    logger$2(`Verifying properties: found ${modelLinks.length} model links for schema ${schemaName} (id: ${schemaRecord.id})`);
+                    logger$3(`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$2(`Verifying properties for Seed model via join table (modelId: ${seedModelLink.modelId})`);
+                            logger$3(`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$2(`Verifying properties for ${modelLinks[0].modelName} model via join table (modelId: ${modelLinks[0].modelId})`);
+                            logger$3(`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);
                         }
                     }
@@ -2913,8 +2948,8 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                 // 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_9 = await import('./BasePathResolver-BdxCSIzn.js');
-                const _ns_9 = _mod_9.N;
+                const _mod_9 = await import('./BasePathResolver-Cm4apKRb.js');
+                const _ns_9 = _mod_9.aZ;
                 const modelSchemaMod2 = _ns_9;
                 const { properties: propertiesTable } = modelSchemaMod2;
                 let schemaFileUpdated = false;
@@ -2938,7 +2973,7 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                                 const currentId = schemaFile.models[modelName].properties[propRecord.name].id;
                                 if (currentId !== propRecord.schemaFileId) {
                                     schemaFile.models[modelName].properties[propRecord.name].id = propRecord.schemaFileId;
-                                    logger$2(`Updated schemaFile property ID for ${modelName}.${propRecord.name} from ${currentId} to ${propRecord.schemaFileId}`);
+                                    logger$3(`Updated schemaFile property ID for ${modelName}.${propRecord.name} from ${currentId} to ${propRecord.schemaFileId}`);
                                     schemaFileUpdated = true;
                                 }
                             }
@@ -2949,8 +2984,8 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                 // 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_10 = await import('./BasePathResolver-BdxCSIzn.js');
-                const _ns_10 = _mod_10.Q;
+                const _mod_10 = await import('./BasePathResolver-Cm4apKRb.js');
+                const _ns_10 = _mod_10.a$;
                 const schemaSchemaMod = _ns_10;
                 const { schemas: schemasTable } = schemaSchemaMod;
                 await db
@@ -2958,21 +2993,21 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                     .set({ schemaData: updatedSchemaData })
                     .where(eq(schemasTable.id, schemaRecord.id));
                 if (schemaFileUpdated) {
-                    logger$2(`Updated schemaData in database with actual property IDs for schema "${schemaName}"`);
+                    logger$3(`Updated schemaData in database with actual property IDs for schema "${schemaName}"`);
                 }
                 else {
-                    logger$2(`Verified schemaData in database matches schemaFile for schema "${schemaName}"`);
+                    logger$3(`Verified schemaData in database matches schemaFile for schema "${schemaName}"`);
                 }
             }
         }
         catch (dbError) {
             // Database not available - log warning but continue
-            logger$2('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));
         }
         // 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$2('loadSchemaFromFile - model available:', modelName);
+            logger$3('loadSchemaFromFile - model available:', modelName);
         }
         return schemaFilePath;
     }
@@ -2984,19 +3019,12 @@ const loadSchemaFromFile = async (schemaFilePath) => {
     }
 };
 /**
- * Create a Model class from a JSON model definition
- * @param modelName - The name of the model
+ * Convert a JSON model's properties to the schema property format Model.create and addModelsToDb take
+ * @param modelName - The name of the model (for error messages)
  * @param modelDef - The JSON model definition
- * @param schemaName - The name of the schema this model belongs to
- * @returns A Model class that can be used with the SDK
+ * @param propertyFileIds - Optional map of property names to their file IDs from the JSON file
  */
-const createModelFromJson = async (modelName, modelDef, schemaName, modelFileId, // Optional modelFileId from JSON file
-propertyFileIds) => {
-    const _mod_11 = await import('./index-Xl1_4Lmb.js');
-    const _ns_11 = _mod_11.f;
-    const modelMod = _ns_11;
-    const { Model } = modelMod;
-    // Convert JSON properties to schema format
+const jsonPropertiesToSchemaProperties = (modelName, modelDef, propertyFileIds) => {
     const convertedProperties = {};
     if (modelDef.properties) {
         for (const [propName, propDef] of Object.entries(modelDef.properties)) {
@@ -3055,14 +3083,30 @@ propertyFileIds) => {
             convertedProperties[propName] = schemaProp;
         }
     }
+    return convertedProperties;
+};
+/**
+ * Create a Model class from a JSON model definition
+ * @param modelName - The name of the model
+ * @param modelDef - The JSON model definition
+ * @param schemaName - The name of the schema this model belongs to
+ * @returns A Model class that can be used with the SDK
+ */
+const createModelFromJson = async (modelName, modelDef, schemaName, modelFileId, // Optional modelFileId from JSON file
+propertyFileIds) => {
+    const _mod_11 = await import('./index-8O3Uow-Y.js');
+    const _ns_11 = _mod_11.f;
+    const modelMod = _ns_11;
+    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$2(`Creating schema model "${modelName}" with modelFileId: ${modelFileId}`);
+        logger$3(`Creating schema model "${modelName}" with modelFileId: ${modelFileId}`);
     }
     else {
-        logger$2(`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`);
     }
     const modelInstance = Model.create(modelName, schemaName, {
         modelFileId: modelFileId, // Pass modelFileId (preferred) as id (schemaFileId) from JSON file
@@ -3088,7 +3132,7 @@ const createModelsFromJson = async (importData, modelFileIds, propertyFileIds) =
         // Use modelFileId from map (no fallback to modelDef.id as JsonImportSchema doesn't have id property)
         const finalModelFileId = modelFileId;
         if (!finalModelFileId) {
-            logger$2(`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);
@@ -3278,7 +3322,7 @@ var SEEDPROTOCOL_Seed_Protocol_v1 = /*#__PURE__*/Object.freeze({
     version: version
 });
 
-const logger$1 = debug('seedSdk:client:actors:processSchemaFiles');
+const logger$2 = debug('seedSdk:client:actors:processSchemaFiles');
 let processSchemaFilesChain = Promise.resolve();
 function resolveSchemaFilePath(schemaFile) {
     const path = BaseFileManager.getPathModule();
@@ -3306,16 +3350,22 @@ async function resolveSchemaNameFromSource(source) {
             }
         }
         catch (error) {
-            logger$1('Could not resolve schema name from path:', source, error);
+            logger$2('Could not resolve schema name from path:', source, error);
         }
     }
     return null;
 }
+/** Error for a schema the app passed in config, so init fails with what went wrong and where. */
+function userSchemaLoadError(option, source, error) {
+    const where = typeof source === 'string' ? ` from "${source}"` : '';
+    const reason = error instanceof Error ? error.message : String(error);
+    return new Error(`Could not load config.${option}${where}: ${reason}`, { cause: error });
+}
 // Timeout for the entire schema processing operation (120 seconds)
 // 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$1('processSchemaFiles started');
+    logger$2('processSchemaFiles started');
     let hasResponded = false;
     let timeoutId = null;
     const reportError = (error) => {
@@ -3325,7 +3375,7 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                 clearTimeout(timeoutId);
                 timeoutId = null;
             }
-            logger$1('processSchemaFiles error:', error);
+            logger$2('processSchemaFiles error:', error);
             sendBack({
                 type: 'error',
                 error: error instanceof Error ? error : new Error(String(error))
@@ -3339,7 +3389,7 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                 clearTimeout(timeoutId);
                 timeoutId = null;
             }
-            logger$1('processSchemaFiles completed');
+            logger$2('processSchemaFiles completed');
             sendBack({ type: ClientManagerEvents.PROCESS_SCHEMA_FILES_SUCCESS });
         }
     };
@@ -3351,7 +3401,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$1('Loading internal seed-protocol schema');
+        logger$2('Loading internal seed-protocol schema');
         const internalSchemaData = internalSchema;
         const db = BaseDb.getAppDb();
         const internalSchemaExists = db
@@ -3360,21 +3410,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$1('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$1(`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$1('Internal seed-protocol schema already loaded');
+                    logger$2('Internal seed-protocol schema already loaded');
                 }
                 else {
-                    logger$1('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
                 }
             }
@@ -3387,7 +3437,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$1('Schema is internal (Seed Protocol), already loaded - skipping syncSchemaFromSource');
+                logger$2('Schema is internal (Seed Protocol), already loaded - skipping syncSchemaFromSource');
             }
             else {
                 try {
@@ -3396,11 +3446,12 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                     if (syncedName) {
                         schemasWrittenThisRun.add(syncedName);
                     }
-                    logger$1(`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) {
-                    logger$1(`Error syncing canonical schema:`, error);
-                    // Don't fail init - schema might already be in DB
+                    // A schema the app passed in failed (missing file, bad JSON, DB write). Re-running an
+                    // unchanged schema does not throw, so this is not the already-loaded case: fail init.
+                    throw userSchemaLoadError('schema', context.schema, error);
                 }
             }
         }
@@ -3414,23 +3465,22 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                 if (parsed?.metadata?.name) {
                     schemasWrittenThisRun.add(String(parsed.metadata.name));
                 }
-                logger$1(`Loaded schema from ${resolvedPath}`);
+                logger$2(`Loaded schema from ${resolvedPath}`);
             }
             catch (error) {
-                logger$1(`Error loading schema file ${context.schemaFile}:`, error);
-                // Don't fail init - schema might already be in DB
+                throw userSchemaLoadError('schemaFile', context.schemaFile, error);
             }
         }
         // Process minimal import files (files without $schema) - skip when canonical schema is set
         if (!context.schema) {
-            logger$1('Listing schema files');
+            logger$2('Listing schema files');
             let schemaFiles = [];
             try {
                 schemaFiles = await listSchemaFiles();
-                logger$1(`Found ${schemaFiles.length} schema files to process`);
+                logger$2(`Found ${schemaFiles.length} schema files to process`);
             }
             catch (error) {
-                logger$1('Error listing schema files (continuing anyway):', error);
+                logger$2('Error listing schema files (continuing anyway):', error);
                 schemaFiles = [];
             }
             for (const schemaFile of schemaFiles) {
@@ -3441,19 +3491,19 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                     }
                 }
                 catch (error) {
-                    logger$1(`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$1('Loading schemas from database and files');
+        logger$2('Loading schemas from database and files');
         let allSchemasData = [];
         try {
             allSchemasData = await loadAllSchemasFromDb();
-            logger$1(`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$1('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 = [];
@@ -3474,13 +3524,13 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                 }
             }
             catch (error) {
-                logger$1('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$1(`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)
@@ -3510,7 +3560,7 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                         }
                     }
                     catch (error) {
-                        logger$1(`Error loading schema file for ${schemaName}:`, error);
+                        logger$2(`Error loading schema file for ${schemaName}:`, error);
                     }
                 }
                 else {
@@ -3559,11 +3609,11 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                             };
                             const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds);
                             Object.assign(allModels, modelDefinitions);
-                            logger$1(`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$1(`Error creating models from schema data for ${schemaName}:`, error);
+                        logger$2(`Error creating models from schema data for ${schemaName}:`, error);
                     }
                 }
             }
@@ -3613,11 +3663,11 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                         };
                         const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds);
                         Object.assign(allModels, modelDefinitions);
-                        logger$1(`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$1(`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)
@@ -3631,14 +3681,12 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
             }
         });
     };
-    processSchemaFilesChain = processSchemaFilesChain
+    const run = processSchemaFilesChain
         // Its schema and model inserts check for rows first, so tabs take turns (docs/MULTI_TAB.md).
-        .then(() => withSeedDbLock('init', context.filesDir, _processSchemaFiles))
-        .catch((err) => {
-        logger$1('processSchemaFiles chain error:', err);
-        throw err;
-    });
-    processSchemaFilesChain.then(reportSuccess).catch((error) => {
+        .then(() => withSeedDbLock('init', context.filesDir, _processSchemaFiles));
+    // The chain only orders runs; a failed run must not fail the next init too.
+    processSchemaFilesChain = run.catch(() => { });
+    run.then(reportSuccess).catch((error) => {
         reportError(error instanceof Error ? error : new Error(String(error)));
     });
     // Cleanup function to clear timeout if actor is stopped
@@ -3650,6 +3698,285 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
     };
 });
 
+/**
+ * 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$1 = 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$1(`wrote ${row.propertyName} of ${row.seedLocalId} to ${converted.filePath}`);
+            }
+            else {
+                result.skipped++;
+            }
+        }
+        catch (error) {
+            result.failed++;
+            logger$1(`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$1(`legacy ItemStorage rows: ${result.converted} converted, ${result.failed} failed, ` +
+            `${result.skipped} skipped of ${result.candidates}`);
+    }
+    return result;
+}
+let running;
+let deferredUntilLeader = false;
+const runInBackground = () => {
+    running ?? (running = withDbTabLock('item-storage-migration', () => migrateLegacyItemStorageRows())
+        .then(() => undefined)
+        .catch((error) => {
+        // Never fails init: rows stay as they were and publish converts them lazily.
+        logger$1('legacy ItemStorage migration failed', error);
+    })
+        .finally(() => {
+        running = undefined;
+    }));
+    return running;
+};
+/**
+ * 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();
+        return;
+    }
+    if (deferredUntilLeader)
+        return;
+    deferredUntilLeader = true;
+    void whenLeaderTab().then(() => {
+        deferredUntilLeader = false;
+        void runInBackground();
+    });
+}
+
 const { UNINITIALIZED, PLATFORM_CLASSES_INIT, FILE_SYSTEM_INIT, DB_INIT, SAVE_CONFIG, PROCESS_SCHEMA_FILES, ADD_MODELS_TO_STORE, ADD_MODELS_TO_DB, IDLE, INIT_FAILED, } = ClientManagerState;
 const { UPDATE_CONTEXT, PLATFORM_CLASSES_READY, FILE_SYSTEM_READY, DB_READY, SAVE_CONFIG_SUCCESS, SAVE_APP_STATE_SUCCESS, SAVE_APP_STATE_ERROR, SET_ADDRESSES, ADD_MODELS_TO_STORE_SUCCESS, ADD_MODELS_TO_DB_SUCCESS, PROCESS_SCHEMA_FILES_SUCCESS, } = ClientManagerEvents;
 const logSyncAfterAddressSave = debug("seedSdk:client:clientManagerMachine:syncAfterAddressSave");
@@ -3870,9 +4197,15 @@ const clientManagerMachine = setup({
             },
         },
         [IDLE]: {
-            entry: assign({
-                isInitialized: true,
-            }),
+            entry: [
+                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(),
+            ],
             on: {
                 [SAVE_APP_STATE_SUCCESS]: {
                     actions: [
@@ -4486,6 +4819,7 @@ const emptyResult = () => ({
     seeds: 0,
     versions: 0,
     metadata: 0,
+    seedLocalIds: [],
 });
 /**
  * Stamp local seeds/versions/metadata that have no publisher and no real uid.
@@ -4514,22 +4848,23 @@ async function claimUnpublishedDrafts(publisher) {
             isLocalUnsealedDraft(row))
             .map((row) => row.localId);
         if (ids.length === 0)
-            return 0;
+            return [];
         await appDb
             .update(table)
             .set({ publisher: normalized, updatedAt: now })
             .where(inArray(table.localId, ids));
-        return ids.length;
+        return ids;
     };
-    const [seedCount, versionCount, metadataCount] = await Promise.all([
+    const [seedIds, versionIds, metadataIds] = await Promise.all([
         claimTable(seeds),
         claimTable(versions),
         claimTable(metadata$1),
     ]);
     return {
-        seeds: seedCount,
-        versions: versionCount,
-        metadata: metadataCount,
+        seeds: seedIds.length,
+        versions: versionIds.length,
+        metadata: metadataIds.length,
+        seedLocalIds: seedIds,
     };
 }
 
@@ -4547,11 +4882,97 @@ const subscription = clientManager.subscribe((snapshot) => {
     logger('ClientManager snapshot.context.isInitialized:', snapshot.context.isInitialized);
 });
 clientManager.start();
+/** Config of the init that is running or has succeeded; cleared when init fails or the client stops. */
+let activeInitConfig;
+const INIT_CONFIG_CONFLICT_MESSAGE = 'client.init was already called with a different config. The SDK keeps the config it was ' +
+    'initialised with: pass the same config, or call client.stop() before initialising with a new one. ' +
+    'To change addresses, use client.setAddresses() (or call init again with the same config and new addresses).';
 const ensureInitialized = () => {
     if (!clientManager.getSnapshot().context.isInitialized) {
         throw new Error(CLIENT_NOT_INITIALIZED);
     }
 };
+const coalescedInit = createCoalescedAsync(async (options) => {
+    // If the actor is stopped (e.g., from a previous failed test), restart it
+    const snapshot = clientManager.getSnapshot();
+    const currentState = snapshot.value;
+    const isStopped = snapshot.status === 'stopped';
+    if (isStopped) {
+        logger('Client manager was stopped, restarting...');
+        clientManager.start();
+        // Wait for the actor to be ready
+        try {
+            await waitFor(clientManager, (snapshot) => snapshot.status !== 'stopped', { timeout: 1000 });
+        }
+        catch (e) {
+            logger('Timeout waiting for actor to restart, continuing anyway...');
+        }
+    }
+    // Clear any stale context from previous failed initializations
+    // This ensures we start with a clean slate before the new init updates it
+    if (currentState !== 'uninitialized') {
+        logger(`Client manager is in state ${currentState}, clearing stale context before re-init...`);
+        clientManager.send({
+            type: 'updateContext',
+            context: {
+                isInitialized: false,
+                addressesSet: false,
+                isSaving: false,
+                syncFromEasOnAddressChange: false,
+                endpoints: undefined,
+                addresses: undefined,
+                ownedAddresses: undefined,
+                watchedAddresses: undefined,
+                models: undefined,
+                arweaveDomain: undefined,
+                filesDir: undefined,
+                dbConfig: undefined,
+                initError: undefined,
+                saveError: undefined,
+            }
+        });
+        // Wait a moment for the context update to be processed
+        await new Promise(resolve => setTimeout(resolve, 10));
+    }
+    // Send init event - the root-level handler will transition to PLATFORM_CLASSES_INIT
+    // which will stop any running actors and start fresh with the new options
+    // The platformClassesInit actor will update the context with the correct endpoints from options
+    clientManager.send({ type: 'init', options });
+    // Wait for the state machine to transition to PLATFORM_CLASSES_INIT to ensure
+    // any old actors are stopped and the new initialization flow begins
+    try {
+        await waitFor(clientManager, (snapshot) => {
+            return snapshot.value === 'platformClassesInit' || snapshot.context.isInitialized;
+        }, { timeout: 1000 });
+    }
+    catch (e) {
+        // If we can't transition, continue anyway - the waitFor below will catch any errors
+        logger('Timeout waiting for state transition, continuing...');
+    }
+    try {
+        await waitFor(clientManager, (snapshot) => {
+            return snapshot.context.isInitialized || snapshot.context.initError != null;
+        }, { timeout: 120000 });
+        const initError = clientManager.getSnapshot().context.initError;
+        if (initError) {
+            throw initError instanceof Error ? initError : new Error(String(initError));
+        }
+    }
+    catch (error) {
+        // Ensure we never throw undefined
+        if (error === undefined || error === null) {
+            throw new Error('Initialization failed with undefined error');
+        }
+        throw error;
+    }
+    // Wire `@seedprotocol/query` local source once DB is ready
+    registerSeedQueryLocalSource({ force: true });
+}, () => {
+    const snapshot = clientManager.getSnapshot();
+    return (snapshot.value === ClientManagerState.IDLE &&
+        snapshot.context.isInitialized === true &&
+        !snapshot.context.initError);
+});
 // Singleton instance - created once at module load time
 // ES modules cache exports, ensuring all imports get the same instance
 const clientInstance = {
@@ -4562,87 +4983,32 @@ const clientInstance = {
         // ensureInitialized();
         return clientManager;
     },
-    init: createCoalescedAsync(async (options) => {
-        // If the actor is stopped (e.g., from a previous failed test), restart it
-        const snapshot = clientManager.getSnapshot();
-        const currentState = snapshot.value;
-        const isStopped = snapshot.status === 'stopped';
-        if (isStopped) {
-            logger('Client manager was stopped, restarting...');
-            clientManager.start();
-            // Wait for the actor to be ready
-            try {
-                await waitFor(clientManager, (snapshot) => snapshot.status !== 'stopped', { timeout: 1000 });
-            }
-            catch (e) {
-                logger('Timeout waiting for actor to restart, continuing anyway...');
-            }
-        }
-        // Clear any stale context from previous failed initializations
-        // This ensures we start with a clean slate before the new init updates it
-        if (currentState !== 'uninitialized') {
-            logger(`Client manager is in state ${currentState}, clearing stale context before re-init...`);
-            clientManager.send({
-                type: 'updateContext',
-                context: {
-                    isInitialized: false,
-                    addressesSet: false,
-                    isSaving: false,
-                    syncFromEasOnAddressChange: false,
-                    endpoints: undefined,
-                    addresses: undefined,
-                    ownedAddresses: undefined,
-                    watchedAddresses: undefined,
-                    models: undefined,
-                    arweaveDomain: undefined,
-                    filesDir: undefined,
-                    dbConfig: undefined,
-                    initError: undefined,
-                    saveError: undefined,
-                }
-            });
-            // Wait a moment for the context update to be processed
-            await new Promise(resolve => setTimeout(resolve, 10));
-        }
-        // Send init event - the root-level handler will transition to PLATFORM_CLASSES_INIT
-        // which will stop any running actors and start fresh with the new options
-        // The platformClassesInit actor will update the context with the correct endpoints from options
-        clientManager.send({ type: 'init', options });
-        // Wait for the state machine to transition to PLATFORM_CLASSES_INIT to ensure
-        // any old actors are stopped and the new initialization flow begins
-        try {
-            await waitFor(clientManager, (snapshot) => {
-                return snapshot.value === 'platformClassesInit' || snapshot.context.isInitialized;
-            }, { timeout: 1000 });
-        }
-        catch (e) {
-            // If we can't transition, continue anyway - the waitFor below will catch any errors
-            logger('Timeout waiting for state transition, continuing...');
+    /**
+     * Initialise the SDK. Calls made while an init is running share it. Once initialised, a
+     * call with the same config resolves at once and applies any change in `addresses`; a
+     * call with a different config throws INIT_CONFIG_CONFLICT_MESSAGE (call stop() first).
+     */
+    init: async (options) => {
+        if (activeInitConfig !== undefined && !isEqual(activeInitConfig, options?.config)) {
+            throw new Error(INIT_CONFIG_CONFLICT_MESSAGE);
         }
+        const isRepeat = activeInitConfig !== undefined;
+        activeInitConfig = options?.config;
         try {
-            await waitFor(clientManager, (snapshot) => {
-                return snapshot.context.isInitialized || snapshot.context.initError != null;
-            }, { timeout: 120000 });
-            const initError = clientManager.getSnapshot().context.initError;
-            if (initError) {
-                throw initError instanceof Error ? initError : new Error(String(initError));
-            }
+            await coalescedInit(options);
         }
         catch (error) {
-            // Ensure we never throw undefined
-            if (error === undefined || error === null) {
-                throw new Error('Initialization failed with undefined error');
-            }
+            activeInitConfig = undefined;
             throw error;
         }
-        // Wire `@seedprotocol/query` local source once DB is ready
-        registerSeedQueryLocalSource({ force: true });
-    }, () => {
-        const snapshot = clientManager.getSnapshot();
-        return (snapshot.value === ClientManagerState.IDLE &&
-            snapshot.context.isInitialized === true &&
-            !snapshot.context.initError);
-    }),
+        if (isRepeat && options?.addresses !== undefined) {
+            const wanted = normalizeAddressConfig(options.addresses);
+            const current = { owned: await getOwnedAddressesFromDb(), watched: await getWatchedAddressesFromDb() };
+            if (!isEqual(wanted, current)) {
+                await clientInstance.setAddresses(wanted);
+            }
+        }
+    },
     setAddresses: async (addresses) => {
         ensureInitialized();
         logger('setAddresses', addresses);
@@ -4675,7 +5041,10 @@ const clientInstance = {
      */
     claimUnpublishedDrafts: async (publisher) => {
         ensureInitialized();
-        return claimUnpublishedDrafts(publisher);
+        const result = await claimUnpublishedDrafts(publisher);
+        // Loaded Items read publisher from their context; give the claimed ones the new value.
+        Item.setPublisherForCachedSeeds(result.seedLocalIds, publisher);
+        return result;
     },
     /**
      * Hard-delete local on-chain seed copies for the given publisher addresses.
@@ -4730,21 +5099,38 @@ const clientInstance = {
         // Global service removed - model registration is now handled by ClientManager
         // Models are added to DB during the ADD_MODELS_TO_DB state
     },
+    /**
+     * Calls `callback` once the client is initialised, or on the next microtask if it already
+     * is. Returns a function that cancels the callback.
+     */
     onReady: (callback) => {
+        if (clientManager.getSnapshot().context.isInitialized) {
+            let cancelled = false;
+            queueMicrotask(() => {
+                if (!cancelled)
+                    callback();
+            });
+            return () => {
+                cancelled = true;
+            };
+        }
         const subscription = clientManager.subscribe((snapshot) => {
             if (snapshot.context.isInitialized) {
                 subscription.unsubscribe();
                 callback();
             }
         });
+        return () => subscription.unsubscribe();
     },
     stop: () => {
         ensureInitialized();
+        activeInitConfig = undefined;
         unregisterSeedQueryLocalSource();
         clientManager.stop();
     },
     unload: () => {
         ensureInitialized();
+        activeInitConfig = undefined;
         unregisterSeedQueryLocalSource();
         clientManager.stop();
         subscription.unsubscribe();
@@ -4760,9 +5146,10 @@ const getClient = () => {
 var ClientManager$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     ClientManager: ClientManager,
+    INIT_CONFIG_CONFLICT_MESSAGE: INIT_CONFIG_CONFLICT_MESSAGE,
     clientManager: clientManager,
     getClient: getClient
 });
 
-export { startEasSyncActor as A, unregisterSeedQueryLocalSource as B, ClientManager as C, createModelsFromJson as D, EAS_CHAIN_ID_APP_STATE_KEY as E, getLatestSchemaVersion as F, schema as G, ClientManager$1 as H, SEEDPROTOCOL_Seed_Protocol_v1 as S, assertLocalDbChain as a, getRefValueType as b, claimUnpublishedDrafts as c, createLocalQueryDataSource as d, createSchema as e, easSyncActor as f, getContentHash as g, getClient as h, importJsonSchema as i, getPublishedSeedRecord as j, getSchemaNameFromId as k, loadSchemaFromFile as l, isSeedQueryLocalSourceRegistered as m, listCompleteSchemaFiles as n, loadAllSchemasFromDb as o, mergeEasSyncRequestIntents as p, readSchema as q, readJsonImportFile as r, syncSchemaFromSource as s, transformImportToSchemaFile as t, registerSeedQueryLocalSource as u, requestEasSyncFromAddressChange as v, waitForEasReadChain as w, requestEasSyncFromEventBus as x, requestEasSyncFromModelsInit as y, sendEasSyncClientRequest as z };
-//# sourceMappingURL=ClientManager-DDA9956Y.js.map
+export { requestEasSyncFromModelsInit as A, sendEasSyncClientRequest as B, ClientManager as C, startEasSyncActor as D, EAS_CHAIN_ID_APP_STATE_KEY as E, unregisterSeedQueryLocalSource as F, createModelsFromJson as G, getLatestSchemaVersion as H, INIT_CONFIG_CONFLICT_MESSAGE as I, jsonPropertiesToSchemaProperties as J, schema as K, ClientManager$1 as L, SEEDPROTOCOL_Seed_Protocol_v1 as S, assertLocalDbChain as a, importJsonSchema as b, convertVerbatimItemStorageRow as c, getContentHash as d, claimUnpublishedDrafts as e, createLocalQueryDataSource as f, getRefValueType as g, createSchema as h, isVerbatimItemStorageDraftRow as i, easSyncActor as j, getClient as k, loadSchemaFromFile as l, getPublishedSeedRecord as m, getSchemaNameFromId as n, isSeedQueryLocalSourceRegistered as o, listCompleteSchemaFiles as p, loadAllSchemasFromDb as q, readJsonImportFile as r, syncSchemaFromSource as s, transformImportToSchemaFile as t, mergeEasSyncRequestIntents as u, readSchema as v, waitForEasReadChain as w, registerSeedQueryLocalSource as x, requestEasSyncFromAddressChange as y, requestEasSyncFromEventBus as z };
+//# sourceMappingURL=ClientManager-i3nJASkg.js.map