@seedprotocol/sdk 0.7.3-next.654.g52217f6 → 0.7.3

package/dist/{ClientManager-C-QXqUK9.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, r as resolveItemModelFileId, s as normalizePublisher, V as getWatchedAddressesFromDb, W as getOwnedAddressesFromDb } from './db-D9K_f5cF.js';
-import { u as MachineIds, Y as ClientManagerEvents, Z as withLockedItemStorageRow, _ as getItemStorageFilePath, $ as writeItemStorageFile, c as compareMetadataRowsLatestFirst, C as ClientManagerState, a0 as resolvePublisherFromSeedRow, F as isLocalUnsealedDraft, I as Item } from './Item-C7sUUu2B.js';
-import { B as BaseDb, e as easSyncProcesses, r as BasePathResolver, a as appState, t as BaseFileManager, i as models$1, g as modelUids, q as seeds, s as schemas, K as isInternalSchema, L as INTERNAL_SCHEMA_IDS, F as SEED_PROTOCOL_SCHEMA_NAME, f as modelSchemas, m as metadata$1, p as properties, v as versions, h as htmlEmbeddedImageCoPublish, b as arweaveL1FinalizeJobs, o as publishProcesses, M as CLIENT_NOT_INITIALIZED } from './BasePathResolver-CfSfMW5_.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 { D as withDbTabLock, v as isLeaderTab, H as postTabMessage, I as onTabMessage, B as whenLeaderTab, J as listenForOtherTabsEvents, K as isNode, M as isBrowser, N as startTabCoordination, O as downloadAllFilesRequestHandler, P as downloadAllFilesBinaryRequestHandler, t as toSnakeCase, G as withSeedDbLock, j as generateId, y as parseAddressesPersistedPayload, h as emitAcrossTabs, A as ADDRESSES_PERSISTED_EVENT, L as LOCAL_COPIES_REMOVED_EVENT } from './tabEvents-DguZpCCv.js';
+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 { 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--HUA9WNb.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.
@@ -429,6 +428,15 @@ function normalizeSeedConfigEndpoints(config) {
 }
 
 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$b('initialize from ClientManager');
     const { isInitialized } = context;
@@ -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-BRw2j0ZN.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,
@@ -1027,14 +1036,32 @@ async function assertLocalDbChain() {
 }
 
 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)
@@ -1047,7 +1074,7 @@ async function persistInitAddresses(appDb, { addresses, ownedAddresses, watchedA
 }
 const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
     logger$5('saveConfig starting');
-    const { endpoints, addresses, ownedAddresses, watchedAddresses, arweaveDomain, uploadApiBaseUrl, gatewayTransport, gatewayHyperKey, gatewaySidecarHost, gatewaySidecarPort, gatewayProxyBaseUrl, } = context;
+    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) {
@@ -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({
@@ -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-CfSfMW5_.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');
@@ -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-CfSfMW5_.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');
@@ -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-CfSfMW5_.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');
@@ -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-D9K_f5cF.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-CfSfMW5_.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-CfSfMW5_.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');
@@ -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-D9K_f5cF.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));
     }
@@ -2841,14 +2869,21 @@ const loadSchemaFromFile = async (schemaFilePath) => {
         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-CfSfMW5_.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-CfSfMW5_.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');
@@ -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-CfSfMW5_.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;
@@ -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-CfSfMW5_.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
@@ -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-s15q14rm.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,6 +3083,22 @@ 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
@@ -3311,6 +3355,12 @@ async function resolveSchemaNameFromSource(source) {
     }
     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;
@@ -3399,8 +3449,9 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                     logger$2(`Synced canonical schema from ${typeof context.schema === 'string' ? context.schema : 'object'}`);
                 }
                 catch (error) {
-                    logger$2(`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);
                 }
             }
         }
@@ -3417,8 +3468,7 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
                 logger$2(`Loaded schema from ${resolvedPath}`);
             }
             catch (error) {
-                logger$2(`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
@@ -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$2('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
@@ -4771,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.
@@ -4799,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,
     };
 }
 
@@ -4832,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 = {
@@ -4847,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);
@@ -4960,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.
@@ -5015,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();
@@ -5045,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 { 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, schema as I, ClientManager$1 as J, 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-C-QXqUK9.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