@seedprotocol/sdk 0.6.3 → 0.6.5

package/dist/cjs/{index-C-POwaLs.js → index-Bx8ReSFI.js}

@@ -152,14 +152,36 @@ class BaseFileManager {
         }
         return BaseFileManager._impl;
     }
-    static async initializeFileSystem(workingDir) {
-        if (this.initializing || this.fileSystemInitialized) {
+    /**
+     * Clears FS init flags so a later call can retry. Used after a failed init
+     * and by tests. Does not unmount or delete any files.
+     */
+    static resetInitializationState() {
+        this.fileSystemInitialized = false;
+        this.initializing = false;
+        this.initializePromise = null;
+        this.workingDir = undefined;
+    }
+    static initializeFileSystem(workingDir) {
+        if (this.fileSystemInitialized) {
             return Promise.resolve();
         }
+        if (this.initializePromise) {
+            return this.initializePromise;
+        }
         this.initializing = true;
+        const pending = this.runInitializeFileSystem(workingDir).finally(() => {
+            this.initializing = false;
+            if (this.initializePromise === pending) {
+                this.initializePromise = null;
+            }
+        });
+        this.initializePromise = pending;
+        return pending;
+    }
+    static async runInitializeFileSystem(workingDir) {
         await BaseFileManager.requireImpl().initializeFileSystem(workingDir);
         this.fileSystemInitialized = true;
-        this.initializing = false;
         this.workingDir = workingDir;
     }
     static getWorkingDir() {
@@ -268,6 +290,7 @@ class BaseFileManager {
 BaseFileManager.fileSystemInitialized = false;
 BaseFileManager.initializing = false;
 BaseFileManager._impl = null;
+BaseFileManager.initializePromise = null;
 
 var BaseFileManager$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -999,7 +1022,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-DvIIhBnK.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-CGjXNHFW.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$v('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -1183,7 +1206,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
         // Step 2: Fallback to Schema context (only if database doesn't have the model)
         // This handles the case where model exists in schema file but not yet in database
         try {
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-FdzNqyGo.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-CLMqGTHn.js'); });
             const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             const schemaSnapshot = schema.getService().getSnapshot();
@@ -1427,7 +1450,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
         }
         // Mark schema as draft when a new model is created so saveNewVersion() can persist it
         try {
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-FdzNqyGo.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-CLMqGTHn.js'); });
             const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             schema.getService().send({ type: 'markAsDraft', propertyKey: 'schema:models' });
@@ -1471,10 +1494,10 @@ const validateModel = xstate.fromCallback(({ sendBack, input: { context } }) =>
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-pxRoOs79.js'); });
+            const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-BnS8o5FK.js'); });
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-FdzNqyGo.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-CLMqGTHn.js'); });
             const { Schema } = schemaMod;
             // Validate model structure
             const structureResult = validationService.validateModelStructure(context);
@@ -1584,7 +1607,7 @@ const createModelProperties = xstate.fromCallback(({ sendBack, input }) => {
             return;
         }
         logger$t(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-DvIIhBnK.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-CGjXNHFW.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$t('ModelProperty not available from dynamic import');
@@ -1687,7 +1710,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                 const structureMsg = `[validateEntity] Validating model structure`;
                 logger$s(structureMsg);
                 // Use existing Model validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-pxRoOs79.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-BnS8o5FK.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
@@ -1705,7 +1728,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                     if (entityInput.entityData.schemaName) {
                         try {
                             logger$s(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
-                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-FdzNqyGo.js'); });
+                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-CLMqGTHn.js'); });
                             const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData.schemaName, {
                                 waitForReady: false,
@@ -1741,7 +1764,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-pxRoOs79.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-BnS8o5FK.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -1756,7 +1779,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                     // If schema name and model name provided, validate against schema
                     if (entityInput.entityData._schemaName && entityInput.entityData.modelName) {
                         try {
-                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-FdzNqyGo.js'); });
+                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-CLMqGTHn.js'); });
                             const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData._schemaName, {
                                 waitForReady: false,
@@ -1785,7 +1808,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'schema') {
                 // Schema validation - use existing validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-pxRoOs79.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-BnS8o5FK.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
@@ -3865,7 +3888,7 @@ const writeToDatabase = xstate.fromCallback(({ sendBack, input }) => {
                 // initial write completes is not overwritten by the stale requestWrite payload.
                 let dataToWrite = input.entityData;
                 try {
-                    const mod = await Promise.resolve().then(function () { return require('./ModelProperty-DvIIhBnK.js'); });
+                    const mod = await Promise.resolve().then(function () { return require('./ModelProperty-CGjXNHFW.js'); });
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -4245,7 +4268,7 @@ const modelMachine = xstate.setup({
                                 // Create ModelProperty instances for any new property IDs
                                 if (Array.isArray(newPropertyIds) && newPropertyIds.length > 0) {
                                     // Import and create instances asynchronously (fire-and-forget)
-                                    Promise.resolve().then(function () { return require('./ModelProperty-DvIIhBnK.js'); }).then(({ ModelProperty }) => {
+                                    Promise.resolve().then(function () { return require('./ModelProperty-CGjXNHFW.js'); }).then(({ ModelProperty }) => {
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
                                             try {
                                                 const property = await ModelProperty.createById(propertyFileId);
@@ -4674,6 +4697,7 @@ exports.ClientManagerState = void 0;
     ClientManagerState["ADD_MODELS_TO_DB"] = "addModelsToDb";
     ClientManagerState["PROCESS_SCHEMA_FILES"] = "processSchemaFiles";
     ClientManagerState["IDLE"] = "idle";
+    ClientManagerState["INIT_FAILED"] = "initFailed";
 })(exports.ClientManagerState || (exports.ClientManagerState = {}));
 var ClientManagerEvents;
 (function (ClientManagerEvents) {
@@ -4683,6 +4707,7 @@ var ClientManagerEvents;
     ClientManagerEvents["DB_READY"] = "dbReady";
     ClientManagerEvents["SAVE_CONFIG_SUCCESS"] = "saveConfigSuccess";
     ClientManagerEvents["SAVE_APP_STATE_SUCCESS"] = "saveAppStateSuccess";
+    ClientManagerEvents["SAVE_APP_STATE_ERROR"] = "saveAppStateError";
     ClientManagerEvents["SET_ADDRESSES"] = "setAddresses";
     ClientManagerEvents["ADD_MODELS_TO_STORE_SUCCESS"] = "addModelsToStoreSuccess";
     ClientManagerEvents["ADD_MODELS_TO_DB_SUCCESS"] = "addModelsToDbSuccess";
@@ -5331,7 +5356,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             const schemaNameToTry = model$1?.schemaName;
             if (schemaNameToTry) {
                 try {
-                    const { Schema } = await Promise.resolve().then(function () { return require('./Schema-FdzNqyGo.js'); });
+                    const { Schema } = await Promise.resolve().then(function () { return require('./Schema-CLMqGTHn.js'); });
                     const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false });
                     const schemaContext = schemaInstance.getService().getSnapshot().context;
                     if (schemaContext.models?.[modelName]?.properties) {
@@ -5380,7 +5405,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
-                const schemaMod = await Promise.resolve().then(function () { return require('./index-D_ph4zut.js'); });
+                const schemaMod = await Promise.resolve().then(function () { return require('./index-DBGNShZR.js'); });
                 const { ModelPropertyDataTypes } = schemaMod;
                 const KNOWN_MODEL_FALLBACKS = {
                     Post: {
@@ -5427,7 +5452,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 // Infer propertyRecordSchema from metadata when schema is missing (enables persistence)
                 let propSchema = propertySchemas[propertyName];
                 if (!propSchema && isRefTypeFromMeta) {
-                    const schemaMod = await Promise.resolve().then(function () { return require('./index-D_ph4zut.js'); });
+                    const schemaMod = await Promise.resolve().then(function () { return require('./index-DBGNShZR.js'); });
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -5684,9 +5709,9 @@ const runPublish = xstate.fromCallback(({ sendBack, input: { context } }) => {
                 sendBack({ type: 'publishError', error: new Error(`Item not found for seedLocalId: ${seedLocalId}`) });
                 return;
             }
-            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-D2VZHZnu.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-CHhrLQmE.js'); });
             const { getPublishUploads } = getPublishUploadsMod;
-            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-BvmVTKoc.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-i3UrBhza.js'); });
             const { getPublishPayload } = getPublishPayloadMod;
             const uploads = await getPublishUploads(item);
             let uploadedTransactions = [];
@@ -6788,7 +6813,7 @@ const resolveRelatedValue = xstate.fromCallback(({ sendBack, input: { context }
     const { isRelation, propertyValue, propertyName, seedUid, propertyRecordSchema, populatedFromDb, schemaUid, } = context;
     const _resolveRelatedValue = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-D_ph4zut.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DBGNShZR.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
@@ -7792,7 +7817,7 @@ const hydrateFromDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
     // to use dynamically imported ModelPropertyDataTypes
     const _hydrateFromDb = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-D_ph4zut.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DBGNShZR.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -8155,7 +8180,7 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                         };
                         // Merge with schema from file/DB to get validation rules (enum, pattern, etc.) - properties table doesn't store these
                         try {
-                            const { getPropertySchema } = await Promise.resolve().then(function () { return require('./property-DkUtJxV2.js'); });
+                            const { getPropertySchema } = await Promise.resolve().then(function () { return require('./property-CWZoijFu.js'); });
                             let schemaFromFile = await getPropertySchema(normalizedModelName, propertyName);
                             if (!schemaFromFile?.validation) {
                                 // Fallback: get validation from schemaData in database (Schema context may not be loaded yet)
@@ -8620,9 +8645,9 @@ const analyzeInput = xstate.fromCallback(({ sendBack, input: { context, event }
     }
     const _analyzeInput = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-D_ph4zut.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DBGNShZR.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-pxRoOs79.js'); });
+        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-BnS8o5FK.js'); });
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -8820,7 +8845,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-pxRoOs79.js'); });
+        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-BnS8o5FK.js'); });
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, normalizeDataType(propertyRecordSchema.dataType), propertyRecordSchema.validation, propertyRecordSchema.refValueType
             ? normalizeDataType(String(propertyRecordSchema.refValueType))
@@ -9413,7 +9438,7 @@ const saveRelation = xstate.fromCallback(({ sendBack, input: { context, event }
     }
     const _saveRelation = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-D_ph4zut.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DBGNShZR.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
@@ -10368,7 +10393,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await Promise.resolve().then(function () { return require('./index-D_ph4zut.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./index-DBGNShZR.js'); });
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -11677,12 +11702,12 @@ class Item {
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-D2VZHZnu.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-CHhrLQmE.js'); });
             const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this, [], undefined, options);
         };
         this.getPublishPayload = async (uploadedTransactions, options) => {
-            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-BvmVTKoc.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-i3UrBhza.js'); });
             const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions, options);
         };
@@ -13339,7 +13364,7 @@ const runEasSync = xstate.fromPromise(async ({ input, }) => {
         requestPayload: input.requestPayload,
         persistedSnapshot: input.runningSnapshot,
     });
-    const { runSyncFromEas } = await Promise.resolve().then(function () { return require('./syncDbWithEas-DRoys7eo.js'); });
+    const { runSyncFromEas } = await Promise.resolve().then(function () { return require('./syncDbWithEas-DRbf_wzk.js'); });
     try {
         await runSyncFromEas(toRunSyncArg(input.options));
         await finalizeEasSyncProcessRow(rowId, {
@@ -13860,7 +13885,12 @@ const saveAppState = xstate.fromCallback(({ sendBack, input: { key, value } }) =
             });
         }
         else {
-            throw error;
+            sendBack({
+                type: 'saveAppStateError',
+                error: error instanceof Error ? error : new Error(String(error)),
+                key,
+                value,
+            });
         }
     });
 });
@@ -13940,7 +13970,7 @@ const dbInit = xstate.fromCallback(({ sendBack, input: { context } }) => {
         .catch((error) => {
         logger$a('Error in dbInit:', error);
         sendBack({
-            type: 'ERROR',
+            type: 'error',
             error: error instanceof Error ? error : new Error(String(error))
         });
     });
@@ -13963,8 +13993,16 @@ const addModelsToStore = xstate.fromCallback(({ sendBack, input: { context } })
             logger$9('model available:', key);
         }
     };
-    _addModelsToStore().then(() => {
+    _addModelsToStore()
+        .then(() => {
         sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_STORE_SUCCESS });
+    })
+        .catch((error) => {
+        logger$9('[client/actors] [addModelsToStore] Error:', error);
+        sendBack({
+            type: 'error',
+            error: error instanceof Error ? error : new Error(String(error)),
+        });
     });
 });
 
@@ -14094,7 +14132,10 @@ const addModelsToDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
             sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_DB_SUCCESS });
         }
         else {
-            throw error;
+            sendBack({
+                type: 'error',
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
         }
     });
     return () => { };
@@ -14206,7 +14247,10 @@ const saveConfig = xstate.fromCallback(({ sendBack, input: { context } }) => {
             sendBack({ type: ClientManagerEvents.SAVE_CONFIG_SUCCESS });
         }
         else {
-            throw error;
+            sendBack({
+                type: 'error',
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
         }
     });
     return () => { };
@@ -16684,8 +16728,8 @@ function parseAddressesPersistedPayload(value) {
     return { owned, watched };
 }
 
-const { UNINITIALIZED, PLATFORM_CLASSES_INIT, FILE_SYSTEM_INIT, DB_INIT, SAVE_CONFIG, PROCESS_SCHEMA_FILES, ADD_MODELS_TO_STORE, ADD_MODELS_TO_DB, IDLE, } = exports.ClientManagerState;
-const { UPDATE_CONTEXT, PLATFORM_CLASSES_READY, FILE_SYSTEM_READY, DB_READY, SAVE_CONFIG_SUCCESS, SAVE_APP_STATE_SUCCESS, SET_ADDRESSES, ADD_MODELS_TO_STORE_SUCCESS, ADD_MODELS_TO_DB_SUCCESS, PROCESS_SCHEMA_FILES_SUCCESS, } = ClientManagerEvents;
+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, } = exports.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");
 function addressesFromPersistedAddressValue(value) {
     if (!value || typeof value !== "object")
@@ -16729,6 +16773,22 @@ function emitAddressesPersistedIfAddressesKey(event) {
     const payload = parseAddressesPersistedPayload(event.value);
     eventEmitter.emit(ADDRESSES_PERSISTED_EVENT, payload);
 }
+function errorFromEvent(event, fallbackMessage) {
+    const error = event?.error;
+    if (error instanceof Error) {
+        return error;
+    }
+    return new Error(String(error ?? fallbackMessage));
+}
+function failInit(fallbackMessage) {
+    return {
+        target: INIT_FAILED,
+        actions: {
+            type: 'assignInitError',
+            params: { fallbackMessage },
+        },
+    };
+}
 const clientManagerMachine = xstate.setup({
     types: {
         context: {},
@@ -16744,6 +16804,12 @@ const clientManagerMachine = xstate.setup({
         addModelsToDb,
         processSchemaFiles,
     },
+    actions: {
+        assignInitError: xstate.assign(({ event }, params) => ({
+            initError: errorFromEvent(event, params.fallbackMessage),
+            isInitialized: false,
+        })),
+    },
 }).createMachine({
     id: MachineIds.CLIENT_MANAGER,
     initial: UNINITIALIZED,
@@ -16762,6 +16828,7 @@ const clientManagerMachine = xstate.setup({
             actions: xstate.assign({
                 isInitialized: false,
                 initError: undefined,
+                saveError: undefined,
             }),
         },
     },
@@ -16778,16 +16845,7 @@ const clientManagerMachine = xstate.setup({
                 [PLATFORM_CLASSES_READY]: {
                     target: FILE_SYSTEM_INIT,
                 },
-                error: {
-                    actions: xstate.assign(({ event }) => {
-                        const error = event.error instanceof Error
-                            ? event.error
-                            : new Error(String(event.error || 'Platform classes initialization failed'));
-                        return {
-                            initError: error,
-                        };
-                    }),
-                },
+                error: failInit('Platform classes initialization failed'),
             },
             invoke: {
                 src: 'platformClassesInit',
@@ -16795,6 +16853,7 @@ const clientManagerMachine = xstate.setup({
                     event: event,
                     context
                 }),
+                onError: failInit('Platform classes initialization failed'),
             },
         },
         [FILE_SYSTEM_INIT]: {
@@ -16802,19 +16861,12 @@ const clientManagerMachine = xstate.setup({
                 [FILE_SYSTEM_READY]: {
                     target: DB_INIT,
                 },
-                error: {
-                    target: IDLE,
-                    actions: xstate.assign(({ event }) => {
-                        const error = event.error instanceof Error
-                            ? event.error
-                            : new Error(String(event.error ?? 'File system initialization failed'));
-                        return { initError: error };
-                    }),
-                },
+                error: failInit('File system initialization failed'),
             },
             invoke: {
                 src: 'fileSystemInit',
                 input: ({ context }) => ({ context }),
+                onError: failInit('File system initialization failed'),
             },
         },
         [DB_INIT]: {
@@ -16822,10 +16874,12 @@ const clientManagerMachine = xstate.setup({
                 [DB_READY]: {
                     target: SAVE_CONFIG,
                 },
+                error: failInit('Database initialization failed'),
             },
             invoke: {
                 src: 'dbInit',
                 input: ({ context }) => ({ context }),
+                onError: failInit('Database initialization failed'),
             },
         },
         [SAVE_CONFIG]: {
@@ -16833,10 +16887,12 @@ const clientManagerMachine = xstate.setup({
                 [SAVE_CONFIG_SUCCESS]: {
                     target: PROCESS_SCHEMA_FILES,
                 },
+                error: failInit('Saving config failed'),
             },
             invoke: {
                 src: 'saveConfig',
                 input: ({ context }) => ({ context }),
+                onError: failInit('Saving config failed'),
             },
         },
         [PROCESS_SCHEMA_FILES]: {
@@ -16844,19 +16900,12 @@ const clientManagerMachine = xstate.setup({
                 [PROCESS_SCHEMA_FILES_SUCCESS]: {
                     target: ADD_MODELS_TO_STORE,
                 },
-                error: {
-                    target: IDLE,
-                    actions: xstate.assign(({ event }) => {
-                        const error = event.error instanceof Error
-                            ? event.error
-                            : new Error(String(event.error || 'Schema processing failed'));
-                        return { initError: error };
-                    }),
-                },
+                error: failInit('Schema processing failed'),
             },
             invoke: {
                 src: 'processSchemaFiles',
                 input: ({ context }) => ({ context }),
+                onError: failInit('Schema processing failed'),
             },
         },
         [ADD_MODELS_TO_STORE]: {
@@ -16864,10 +16913,12 @@ const clientManagerMachine = xstate.setup({
                 [ADD_MODELS_TO_STORE_SUCCESS]: {
                     target: ADD_MODELS_TO_DB,
                 },
+                error: failInit('Adding models to store failed'),
             },
             invoke: {
                 src: 'addModelsToStore',
                 input: ({ context }) => ({ context }),
+                onError: failInit('Adding models to store failed'),
             },
         },
         [ADD_MODELS_TO_DB]: {
@@ -16875,10 +16926,27 @@ const clientManagerMachine = xstate.setup({
                 [ADD_MODELS_TO_DB_SUCCESS]: {
                     target: IDLE,
                 },
+                error: failInit('Adding models to database failed'),
             },
             invoke: {
                 src: 'addModelsToDb',
                 input: ({ context }) => ({ context }),
+                onError: failInit('Adding models to database failed'),
+            },
+        },
+        [INIT_FAILED]: {
+            entry: xstate.assign({
+                isInitialized: false,
+            }),
+            on: {
+                init: {
+                    target: PLATFORM_CLASSES_INIT,
+                    actions: xstate.assign({
+                        isInitialized: false,
+                        initError: undefined,
+                        saveError: undefined,
+                    }),
+                },
             },
         },
         [IDLE]: {
@@ -16888,9 +16956,10 @@ const clientManagerMachine = xstate.setup({
             on: {
                 [SAVE_APP_STATE_SUCCESS]: {
                     actions: [
-                        xstate.assign(({ event }) => {
+                        xstate.assign(() => {
                             return {
                                 isSaving: false,
+                                saveError: undefined,
                             };
                         }),
                         ({ context, event }) => maybeRunSyncFromEasAfterAddressSave({
@@ -16900,6 +16969,12 @@ const clientManagerMachine = xstate.setup({
                         ({ event }) => emitAddressesPersistedIfAddressesKey(event),
                     ],
                 },
+                [SAVE_APP_STATE_ERROR]: {
+                    actions: xstate.assign(({ event }) => ({
+                        isSaving: false,
+                        saveError: errorFromEvent(event, 'Failed to save app state'),
+                    })),
+                },
                 [SET_ADDRESSES]: {
                     actions: [
                         xstate.assign(({ event, spawn }) => {
@@ -16916,6 +16991,7 @@ const clientManagerMachine = xstate.setup({
                                 ownedAddresses: normalized.owned,
                                 watchedAddresses: normalized.watched,
                                 isSaving: true,
+                                saveError: undefined,
                             };
                         })
                     ],
@@ -16924,6 +17000,8 @@ const clientManagerMachine = xstate.setup({
                     target: PLATFORM_CLASSES_INIT,
                     actions: xstate.assign({
                         isInitialized: false,
+                        initError: undefined,
+                        saveError: undefined,
                     }),
                 },
             },
@@ -16931,6 +17009,30 @@ const clientManagerMachine = xstate.setup({
     },
 });
 
+/**
+ * Coalesce overlapping async init calls onto one in-flight promise.
+ * Skip when already successfully ready. Always clear in-flight on settle
+ * so a failed init can be retried.
+ */
+function createCoalescedAsync(run, shouldSkip) {
+    let inFlight = null;
+    return (arg) => {
+        if (inFlight) {
+            return inFlight;
+        }
+        if (shouldSkip(arg)) {
+            return Promise.resolve();
+        }
+        const pending = run(arg).finally(() => {
+            if (inFlight === pending) {
+                inFlight = null;
+            }
+        });
+        inFlight = pending;
+        return pending;
+    };
+}
+
 function msToUnixSeconds(ms) {
     if (ms == null || !Number.isFinite(ms))
         return 0;
@@ -17479,7 +17581,7 @@ const clientInstance = {
         // ensureInitialized();
         return clientManager;
     },
-    init: async (options) => {
+    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;
@@ -17515,6 +17617,7 @@ const clientInstance = {
                     filesDir: undefined,
                     dbConfig: undefined,
                     initError: undefined,
+                    saveError: undefined,
                 }
             });
             // Wait a moment for the context update to be processed
@@ -17537,15 +17640,12 @@ const clientInstance = {
         }
         try {
             await xstate.waitFor(clientManager, (snapshot) => {
-                // Check for errors in context (for cases where error is set but state hasn't transitioned yet)
-                if (snapshot.context.initError) {
-                    const error = snapshot.context.initError instanceof Error
-                        ? snapshot.context.initError
-                        : new Error(String(snapshot.context.initError));
-                    throw error;
-                }
-                return snapshot.context.isInitialized;
+                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
@@ -17556,12 +17656,21 @@ const clientInstance = {
         }
         // Wire `@seedprotocol/query` local source once DB is ready
         registerSeedQueryLocalSource();
-    },
+    }, () => {
+        const snapshot = clientManager.getSnapshot();
+        return (snapshot.value === exports.ClientManagerState.IDLE &&
+            snapshot.context.isInitialized === true &&
+            !snapshot.context.initError);
+    }),
     setAddresses: async (addresses) => {
         ensureInitialized();
         logger$3('setAddresses', addresses);
         clientManager.send({ type: 'setAddresses', addresses });
         await xstate.waitFor(clientManager, (snapshot) => !snapshot.context.isSaving, { timeout: 10000 });
+        const saveError = clientManager.getSnapshot().context.saveError;
+        if (saveError) {
+            throw saveError instanceof Error ? saveError : new Error(String(saveError));
+        }
         logger$3('setAddresses success', addresses);
     },
     getAddresses: async () => {
@@ -17837,7 +17946,7 @@ const saveDraftLogger = debug('seedSdk:model:saveDraftToDb');
 // Lazy import cache for ModelProperty to avoid circular dependency
 // Eagerly start loading to minimize delay on first access
 let ModelPropertyClass = null;
-const modelPropertyImportPromise = Promise.resolve().then(function () { return require('./ModelProperty-DvIIhBnK.js'); })
+const modelPropertyImportPromise = Promise.resolve().then(function () { return require('./ModelProperty-CGjXNHFW.js'); })
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -17854,7 +17963,7 @@ function getModelProperty() {
 }
 // Lazy import cache for Schema to avoid circular dependency
 let SchemaClass = null;
-const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-FdzNqyGo.js'); })
+const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-CLMqGTHn.js'); })
     .then(module => {
     SchemaClass = module.Schema;
     return SchemaClass;
@@ -19756,7 +19865,7 @@ function resolveSdkDrizzleMigrationsDir(sdkRootDir) {
         })();
     // Also resolve relative to this module so temp-cwd tests / odd roots still find
     // packages/sdk/src/db/drizzle (or dist/db/drizzle after publish).
-    const moduleDir = path.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cjs/index-C-POwaLs.js', document.baseURI).href))));
+    const moduleDir = path.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cjs/index-Bx8ReSFI.js', document.baseURI).href))));
     const candidates = [
         path.join(root, 'db', 'drizzle'), // production: sdkRoot is dist/
         path.join(root, 'dist', 'db', 'drizzle'), // sdk package root with built dist
@@ -19826,7 +19935,7 @@ class NodeDb {
         logger$1('[Db.prepareDb] running migrations from %s', outDir);
         await migrator.migrate(db, { migrationsFolder: outDir });
         this.db = db;
-        const { backfillMetadataPropertyIds } = await Promise.resolve().then(function () { return require('./backfillMetadataPropertyIds-D0o5VwBh.js'); });
+        const { backfillMetadataPropertyIds } = await Promise.resolve().then(function () { return require('./backfillMetadataPropertyIds-B3xNIFjQ.js'); });
         await backfillMetadataPropertyIds();
         return this.db;
     }
@@ -20417,4 +20526,4 @@ exports.versions = versions;
 exports.waitForEntityIdle = waitForEntityIdle;
 exports.withSeed = withSeed;
 exports.writeProcessMachine = writeProcessMachine;
-//# sourceMappingURL=index-C-POwaLs.js.map
+//# sourceMappingURL=index-Bx8ReSFI.js.map