@seedprotocol/sdk 0.6.10 → 0.7.0

package/dist/{Schema-a8uO-hIZ.js → Schema-DOhlrQ-N.js}

@@ -1,14 +1,15 @@
 import { fromCallback, setup, assign, createActor } from 'xstate';
-import { i as getRefValueType, ai as createModelsFromJson, X as listCompleteSchemaFiles, aj as getLatestSchemaVersion, ak as createModelFromJson, k as loadSchemaFromFile, n as waitForEntityIdle, o as createReactiveProxy, q as findEntity, Y as loadAllSchemasFromDb, H as getClient, y as ClientManagerState, ag as unloadEntity, ah as clearDestroySubscriptions, u as forceRemoveFromCaches, v as runDestroyLifecycle } from './ClientManager-ChcmUL47.js';
-import './index-280bL-n4.js';
-import { A as addSchemaToDb, k as isDataType, M as ModelPropertyDataTypes, s as addModelsToDb, E as loadModelsFromDbForSchema } from './db-WbrzEf7c.js';
-import { D as SEED_PROTOCOL_SCHEMA_NAME, a as BaseDb, s as schemas, m as models, i as modelSchemas, p as properties, B as BaseFileManager, J as isInternalSchema } from './BasePathResolver-B6CKqoKw.js';
+import { b as getRefValueType, D as createModelsFromJson, n as listCompleteSchemaFiles, F as getLatestSchemaVersion, l as loadSchemaFromFile, o as loadAllSchemasFromDb, h as getClient } from './ClientManager-DLleL_2e.js';
+import './tabEvents-DYI2GU7i.js';
+import { O as addSchemaToDb, k as isDataType, M as ModelPropertyDataTypes, w as addModelsToDb, S as loadModelsFromDbForSchema } from './db-BJZN0a0a.js';
+import { F as SEED_PROTOCOL_SCHEMA_NAME, B as BaseDb, s as schemas, m as models, i as modelSchemas, p as properties, a as BaseFileManager, K as isInternalSchema } from './BasePathResolver-ndE8XTpw.js';
 import { eq, desc, and } from 'drizzle-orm';
 import debug from 'debug';
 import 'pluralize';
 import { generateId } from './generateId-BopUwD8F.js';
-import { SchemaValidationService } from './SchemaValidationService-Y49vqast.js';
-import { M as Model, w as writeProcessMachine, C as ConflictError, s as setupEntityLiveQuery } from './index-HRHkbVQd.js';
+import { SchemaValidationService } from './SchemaValidationService-DDKr5piy.js';
+import { w as writeProcessMachine, M as Model, C as ConflictError, s as setupEntityLiveQuery } from './index-DtfjeuxC.js';
+import { j as waitForEntityIdle, k as createReactiveProxy, m as findEntity, C as ClientManagerState, V as unloadEntity, U as clearDestroySubscriptions, n as forceRemoveFromCaches, o as runDestroyLifecycle } from './Item-zBFWQDU9.js';
 
 const logger$d = debug('seedSdk:schema:actors:loadOrCreateSchema');
 /**
@@ -52,8 +53,8 @@ const createModelInstances$2 = async (modelIds) => {
         return;
     }
     try {
-        const _mod_0 = await import('./index-HRHkbVQd.js');
-        const _ns_0 = _mod_0.b;
+        const _mod_0 = await import('./index-DtfjeuxC.js');
+        const _ns_0 = _mod_0.c;
         const modelMod = _ns_0;
         const { Model } = modelMod;
         // Create instances for all model IDs in parallel
@@ -167,8 +168,8 @@ const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
             // For Seed Protocol, always load from internal file, never create new
             logger$d(`Loading internal Seed Protocol schema from SDK`);
             try {
-                const _mod_1 = await import('./ClientManager-ChcmUL47.js');
-                const _ns_1 = _mod_1.ao;
+                const _mod_1 = await import('./ClientManager-DLleL_2e.js');
+                const _ns_1 = _mod_1.S;
                 const internalSchema = _ns_1;
                 const schemaFile = internalSchema.default;
                 // Check if it exists in database, if not, add it
@@ -662,8 +663,8 @@ const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
                     // Ensure models are populated (fallback for seed-protocol if missing)
                     if ((!mergedModels || Object.keys(mergedModels).length === 0) && schemaName === 'Seed Protocol') {
                         try {
-                            const _mod_2 = await import('./ClientManager-ChcmUL47.js');
-                            const _ns_2 = _mod_2.ao;
+                            const _mod_2 = await import('./ClientManager-DLleL_2e.js');
+                            const _ns_2 = _mod_2.S;
                             const internalSchema = _ns_2;
                             const internalSchemaFile = internalSchema.default;
                             mergedModels = { ...(internalSchemaFile.models || {}) };
@@ -891,8 +892,8 @@ const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
                     // Ensure models are populated (fallback for seed-protocol if missing)
                     if ((!mergedModels || Object.keys(mergedModels).length === 0) && schemaName === 'Seed Protocol') {
                         try {
-                            const _mod_3 = await import('./ClientManager-ChcmUL47.js');
-                            const _ns_3 = _mod_3.ao;
+                            const _mod_3 = await import('./ClientManager-DLleL_2e.js');
+                            const _ns_3 = _mod_3.S;
                             const internalSchema = _ns_3;
                             const internalSchemaFile = internalSchema.default;
                             mergedModels = { ...(internalSchemaFile.models || {}) };
@@ -982,8 +983,8 @@ const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
                         // Ensure models are populated (fallback for seed-protocol if missing)
                         if ((!mergedModels || Object.keys(mergedModels).length === 0) && schemaName === 'Seed Protocol') {
                             try {
-                                const _mod_4 = await import('./ClientManager-ChcmUL47.js');
-                                const _ns_4 = _mod_4.ao;
+                                const _mod_4 = await import('./ClientManager-DLleL_2e.js');
+                                const _ns_4 = _mod_4.S;
                                 const internalSchema = _ns_4;
                                 const internalSchemaFile = internalSchema.default;
                                 mergedModels = { ...(internalSchemaFile.models || {}) };
@@ -1070,8 +1071,8 @@ const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
                 // If schemaData is missing, try to load from internal schema file for seed-protocol
                 if (!dbSchema.schemaData && schemaName === 'Seed Protocol') {
                     try {
-                        const _mod_5 = await import('./ClientManager-ChcmUL47.js');
-                        const _ns_5 = _mod_5.ao;
+                        const _mod_5 = await import('./ClientManager-DLleL_2e.js');
+                        const _ns_5 = _mod_5.S;
                         const internalSchema = _ns_5;
                         const schemaFile = internalSchema.default;
                         logger$d(`Found seed-protocol schema in internal file (schemaData missing, using internal schema)`);
@@ -1181,8 +1182,8 @@ const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
             // Ensure models are populated (fallback for seed-protocol if missing)
             if ((!mergedModels || Object.keys(mergedModels).length === 0) && schemaName === 'Seed Protocol') {
                 try {
-                    const _mod_6 = await import('./ClientManager-ChcmUL47.js');
-                    const _ns_6 = _mod_6.ao;
+                    const _mod_6 = await import('./ClientManager-DLleL_2e.js');
+                    const _ns_6 = _mod_6.S;
                     const internalSchema = _ns_6;
                     const internalSchemaFile = internalSchema.default;
                     mergedModels = { ...(internalSchemaFile.models || {}) };
@@ -1454,582 +1455,6 @@ const validateSchema = fromCallback(({ sendBack, input: { context } }) => {
     };
 });
 
-const addModelsMachine = setup({
-    types: {
-        context: {},
-        input: {},
-        events: {},
-    },
-    actors: {
-        validateModels: fromCallback(({ sendBack, input }) => {
-            const _validate = async () => {
-                // Check for duplicate model names
-                const newModelNames = Object.keys(input.newModels);
-                const existingModelNames = Object.keys(input.existingModels || {});
-                for (const modelName of newModelNames) {
-                    if (existingModelNames.includes(modelName)) {
-                        throw new Error(`Model "${modelName}" already exists in schema`);
-                    }
-                }
-                // Check for duplicates within new models
-                const seenNames = new Set();
-                for (const modelName of newModelNames) {
-                    if (seenNames.has(modelName)) {
-                        throw new Error(`Duplicate model name detected: "${modelName}". Each model must have a unique name.`);
-                    }
-                    seenNames.add(modelName);
-                }
-                // Basic validation - ensure models have required structure
-                for (const [modelName, modelDef] of Object.entries(input.newModels)) {
-                    if (!modelDef || typeof modelDef !== 'object') {
-                        throw new Error(`Invalid model definition for "${modelName}": must be an object`);
-                    }
-                    if (!modelDef.properties || typeof modelDef.properties !== 'object') {
-                        throw new Error(`Model "${modelName}" must have a "properties" object`);
-                    }
-                }
-                sendBack({ type: 'done', output: { valid: true } });
-            };
-            _validate().catch((error) => {
-                sendBack({ type: 'error', error: error instanceof Error ? error : new Error(String(error)) });
-            });
-            return () => {
-                // Cleanup
-            };
-        }),
-        createModelInstances: fromCallback(({ sendBack, input }) => {
-            const _createInstances = async () => {
-                const debug = (await import('debug')).default;
-                const logger = debug('seedSdk:schema:addModels:createInstances');
-                const schemaMod = await Promise.resolve().then(function () { return Schema$1; });
-                const { Schema: SchemaClass, schemaInstanceState } = schemaMod;
-                const schemaName = input.schemaContext.metadata?.name || input.schemaContext.schemaName;
-                const schemaInstance = SchemaClass.create(schemaName, {
-                    waitForReady: false,
-                });
-                const modelInstances = new Map();
-                // Get instance state to store model instances
-                const instanceState = schemaInstanceState.get(schemaInstance);
-                if (!instanceState) {
-                    throw new Error('Schema instance state not found');
-                }
-                for (const [modelName, modelData] of Object.entries(input.models)) {
-                    try {
-                        logger(`Creating model instance for "${modelName}"`);
-                        // Look up modelFileId from database BEFORE creating the Model instance
-                        let modelFileId = undefined;
-                        try {
-                            const db = BaseDb.getAppDb();
-                            if (db) {
-                                const dbModels = await db
-                                    .select()
-                                    .from(models)
-                                    .where(eq(models.name, modelName))
-                                    .limit(1);
-                                if (dbModels.length > 0 && dbModels[0].schemaFileId) {
-                                    modelFileId = dbModels[0].schemaFileId;
-                                    logger(`Found modelFileId "${modelFileId}" for model "${modelName}" from database`);
-                                }
-                            }
-                        }
-                        catch (error) {
-                            logger(`Error looking up modelFileId from database: ${error}`);
-                        }
-                        // If not found in database, generate a new modelFileId for new models
-                        if (!modelFileId) {
-                            modelFileId = generateId();
-                            logger(`Generated new modelFileId "${modelFileId}" for new model "${modelName}"`);
-                        }
-                        // Create new Model instance with modelFileId
-                        // Model.create() will set _modelFileId in the context automatically
-                        const modelInstance = Model.create(modelName, schemaName, {
-                            modelFileId,
-                            waitForReady: false,
-                        });
-                        const service = modelInstance.getService();
-                        logger(`Created Model instance for "${modelName}" with modelFileId "${modelFileId}"`);
-                        // Wait for the Model service to finish loading (loadOrCreateModel completes)
-                        await new Promise((resolve) => {
-                            let resolved = false;
-                            let subscription = null;
-                            // Check if already idle
-                            const snapshot = service.getSnapshot();
-                            if (snapshot.value === 'idle') {
-                                const currentModelFileId = snapshot.context._modelFileId;
-                                if (currentModelFileId === modelFileId) {
-                                    logger(`ModelFileId "${modelFileId}" correctly set for model "${modelName}"`);
-                                }
-                                else {
-                                    logger(`WARNING: ModelFileId not set for model "${modelName}" (expected: "${modelFileId}", got: "${currentModelFileId || 'undefined'}")`);
-                                    // Try to set it again
-                                    service.send({
-                                        type: 'updateContext',
-                                        _modelFileId: modelFileId,
-                                    });
-                                }
-                                resolved = true;
-                                resolve();
-                                return;
-                            }
-                            // Wait for service to become idle
-                            subscription = service.subscribe((snapshot) => {
-                                if (snapshot.value === 'idle') {
-                                    if (subscription) {
-                                        subscription.unsubscribe();
-                                        subscription = null;
-                                    }
-                                    const currentModelFileId = snapshot.context._modelFileId;
-                                    if (currentModelFileId === modelFileId) {
-                                        logger(`ModelFileId "${modelFileId}" correctly set for model "${modelName}"`);
-                                    }
-                                    else {
-                                        logger(`WARNING: ModelFileId not set for model "${modelName}" (expected: "${modelFileId}", got: "${currentModelFileId || 'undefined'}")`);
-                                        // Try to set it again - but only once to avoid infinite loop
-                                        if (!resolved) {
-                                            service.send({
-                                                type: 'updateContext',
-                                                _modelFileId: modelFileId,
-                                            });
-                                        }
-                                    }
-                                    if (!resolved) {
-                                        resolved = true;
-                                        resolve();
-                                    }
-                                }
-                                else if (snapshot.value === 'error') {
-                                    if (subscription) {
-                                        subscription.unsubscribe();
-                                        subscription = null;
-                                    }
-                                    if (!resolved) {
-                                        resolved = true;
-                                        resolve();
-                                    }
-                                }
-                            });
-                            // Timeout after 2 seconds
-                            setTimeout(() => {
-                                if (subscription) {
-                                    subscription.unsubscribe();
-                                    subscription = null;
-                                }
-                                if (!resolved) {
-                                    resolved = true;
-                                    resolve();
-                                }
-                            }, 2000);
-                        });
-                        // Update the model instance with current data
-                        modelInstance.getService().send({
-                            type: 'updateContext',
-                            properties: modelData.properties || {},
-                        });
-                        // Initialize original values
-                        modelInstance.getService().send({
-                            type: 'initializeOriginalValues',
-                            originalValues: {
-                                _originalValues: {
-                                    properties: modelData.properties ? JSON.parse(JSON.stringify(modelData.properties)) : {},
-                                },
-                            },
-                            isEdited: false,
-                        });
-                        // Store in instance state
-                        if (!instanceState.modelInstances) {
-                            instanceState.modelInstances = new Map();
-                        }
-                        instanceState.modelInstances.set(modelName, modelInstance);
-                        modelInstances.set(modelName, modelInstance);
-                        logger(`Successfully created model instance for "${modelName}"`);
-                    }
-                    catch (error) {
-                        logger(`Error creating model instance for "${modelName}": ${error}`);
-                        throw error;
-                    }
-                }
-                sendBack({
-                    type: 'done',
-                    output: { modelInstances }
-                });
-            };
-            _createInstances().catch((error) => {
-                sendBack({ type: 'error', error: error instanceof Error ? error : new Error(String(error)) });
-            });
-            return () => {
-                // Cleanup
-            };
-        }),
-        collectModelFileIds: fromCallback(({ sendBack, input }) => {
-            const _collectIds = async () => {
-                const debug = (await import('debug')).default;
-                const logger = debug('seedSdk:schema:addModels:collectIds');
-                const modelFileIds = new Map();
-                for (const [modelName, modelInstance] of input.modelInstances.entries()) {
-                    try {
-                        const service = modelInstance.getService();
-                        let modelFileId = undefined;
-                        // Check current snapshot first
-                        const snapshot = service.getSnapshot();
-                        if (snapshot.value === 'idle' && snapshot.context._modelFileId) {
-                            modelFileId = snapshot.context._modelFileId;
-                        }
-                        else {
-                            // If not ready, wait for it to become idle
-                            await new Promise((resolve) => {
-                                const subscription = service.subscribe((snapshot) => {
-                                    if (snapshot.value === 'idle') {
-                                        subscription.unsubscribe();
-                                        if (snapshot.context._modelFileId) {
-                                            modelFileId = snapshot.context._modelFileId;
-                                        }
-                                        resolve();
-                                    }
-                                    else if (snapshot.value === 'error') {
-                                        subscription.unsubscribe();
-                                        resolve();
-                                    }
-                                });
-                                // Timeout after 1 second
-                                setTimeout(() => {
-                                    subscription.unsubscribe();
-                                    resolve();
-                                }, 1000);
-                            });
-                        }
-                        if (modelFileId) {
-                            modelFileIds.set(modelName, modelFileId);
-                            logger(`Collected modelFileId "${modelFileId}" for model "${modelName}"`);
-                        }
-                        else {
-                            logger(`WARNING: modelFileId not found for model "${modelName}" after waiting`);
-                        }
-                    }
-                    catch (error) {
-                        logger(`Error collecting modelFileId for "${modelName}": ${error}`);
-                        // Continue with other models even if one fails
-                    }
-                }
-                sendBack({
-                    type: 'done',
-                    output: { modelFileIds }
-                });
-            };
-            _collectIds().catch((error) => {
-                sendBack({ type: 'error', error: error instanceof Error ? error : new Error(String(error)) });
-            });
-            return () => {
-                // Cleanup
-            };
-        }),
-        persistModelsToDb: fromCallback(({ sendBack, input }) => {
-            const _persist = async () => {
-                const debug = (await import('debug')).default;
-                const logger = debug('seedSdk:schema:addModels:persist');
-                // Only process in browser environment where store is available
-                if (typeof window === 'undefined') {
-                    logger('Not in browser environment, skipping store update');
-                    sendBack({
-                        type: 'done',
-                        output: { addedModels: input.models }
-                    });
-                    return;
-                }
-                const schemaName = input.schemaContext.metadata?.name || input.schemaContext.schemaName;
-                const schemaFileId = input.schemaContext.id; // id is the schemaFileId (string) in SchemaMachineContext
-                const db = BaseDb.getAppDb();
-                if (!db) {
-                    logger('Database not found, skipping model store update');
-                    sendBack({
-                        type: 'done',
-                        output: { addedModels: input.models }
-                    });
-                    return;
-                }
-                // Find schema record - prefer schemaFileId lookup (more reliable), then fall back to name
-                // Retry up to 3 times with a short delay in case schema is still being saved
-                let schemaRecord;
-                const maxRetries = 3;
-                const retryDelay = 100; // ms
-                for (let attempt = 0; attempt < maxRetries && !schemaRecord; attempt++) {
-                    if (attempt > 0) {
-                        logger(`Retry ${attempt}/${maxRetries - 1} to find schema, waiting ${retryDelay}ms...`);
-                        await new Promise(resolve => setTimeout(resolve, retryDelay));
-                    }
-                    // PRIMARY: Look up by schemaFileId if available (most reliable, independent of name changes)
-                    if (schemaFileId) {
-                        logger(`Looking up schema by schemaFileId: ${schemaFileId} (attempt ${attempt + 1})`);
-                        const schemasById = await db
-                            .select()
-                            .from(schemas)
-                            .where(eq(schemas.schemaFileId, schemaFileId))
-                            .limit(1);
-                        if (schemasById.length > 0) {
-                            schemaRecord = schemasById[0];
-                            if (schemaRecord) {
-                                logger(`Found schema by schemaFileId: ${schemaFileId} (id: ${schemaRecord.id}, name: ${schemaRecord.name}, isDraft: ${schemaRecord.isDraft})`);
-                            }
-                            break;
-                        }
-                        else {
-                            logger(`No schema found by schemaFileId: ${schemaFileId}, will try by name`);
-                        }
-                    }
-                    // FALLBACK: If not found by schemaFileId, try by name (prefer draft records)
-                    if (!schemaRecord) {
-                        logger(`Looking up schema by name: "${schemaName}" (attempt ${attempt + 1})`);
-                        const schemasByName = await db
-                            .select()
-                            .from(schemas)
-                            .where(eq(schemas.name, schemaName))
-                            .orderBy(desc(schemas.isDraft), desc(schemas.version))
-                            .limit(10); // Get multiple to find drafts
-                        if (schemasByName.length > 0) {
-                            // Prefer draft records
-                            const draftRecord = schemasByName.find((s) => s.isDraft === true);
-                            schemaRecord = draftRecord || schemasByName[0];
-                            if (schemaRecord) {
-                                logger(`Found schema by name "${schemaName}": selected ${draftRecord ? 'draft' : 'first'} record (id: ${schemaRecord.id}, isDraft: ${schemaRecord.isDraft})`);
-                            }
-                            break;
-                        }
-                    }
-                }
-                if (!schemaRecord) {
-                    logger(`Schema "${schemaName}" (schemaFileId: ${schemaFileId || 'none'}) not found in database after ${maxRetries} attempts, skipping model store update`);
-                    sendBack({
-                        type: 'done',
-                        output: { addedModels: input.models }
-                    });
-                    return;
-                }
-                // Convert schema model format to JSON import format for createModelFromJson
-                const modelDefinitions = {};
-                for (const [modelName, modelDef] of Object.entries(input.models)) {
-                    // Convert properties from schema format to JSON import format
-                    const convertedProperties = {};
-                    if (modelDef.properties) {
-                        for (const [propName, propDef] of Object.entries(modelDef.properties)) {
-                            // Schema format: { dataType, ref, refValueType, storageType, localStorageDir, filenameSuffix }
-                            // JSON import format: { type, model, items, storage: { type, path, extension } }
-                            const schemaProp = propDef;
-                            const jsonProp = {
-                                type: schemaProp.dataType || schemaProp.type,
-                            };
-                            // Handle Relation type
-                            if (schemaProp.ref || schemaProp.refModelName) {
-                                jsonProp.model = schemaProp.refModelName || schemaProp.ref;
-                            }
-                            // Handle List type
-                            if (isDataType(schemaProp.dataType, ModelPropertyDataTypes.List) && schemaProp.refValueType) {
-                                jsonProp.refValueType = schemaProp.refValueType;
-                                if (schemaProp.ref || schemaProp.refModelName) {
-                                    jsonProp.ref = schemaProp.refModelName || schemaProp.ref;
-                                }
-                            }
-                            // Handle storage configuration
-                            if (schemaProp.storageType || schemaProp.localStorageDir || schemaProp.filenameSuffix) {
-                                jsonProp.storage = {
-                                    type: schemaProp.storageType === 'ItemStorage' ? 'ItemStorage' : 'PropertyStorage',
-                                    path: schemaProp.localStorageDir,
-                                    extension: schemaProp.filenameSuffix,
-                                };
-                            }
-                            if (schemaProp.required !== undefined) {
-                                jsonProp.required = schemaProp.required;
-                            }
-                            convertedProperties[propName] = jsonProp;
-                        }
-                    }
-                    // Create model definition in JSON import format
-                    // Note: description is not passed - JSON files can have it but we ignore it at runtime
-                    const jsonModelDef = {
-                        properties: convertedProperties,
-                    };
-                    // Create Model instance
-                    const ModelClass = await createModelFromJson(modelName, jsonModelDef, schemaName);
-                    modelDefinitions[modelName] = ModelClass;
-                    // Model is now accessible via Model static methods, no registration needed
-                    logger(`Created model "${modelName}"`);
-                }
-                // Add models to database with modelFileIds
-                if (Object.keys(modelDefinitions).length > 0) {
-                    await addModelsToDb(modelDefinitions, schemaRecord, undefined, {
-                        schemaFileId: input.schemaContext.id, // id is the schemaFileId (string) in SchemaMachineContext
-                        modelFileIds: input.modelFileIds.size > 0 ? input.modelFileIds : undefined,
-                    });
-                    logger(`Added ${Object.keys(modelDefinitions).length} new models to database`);
-                }
-                sendBack({
-                    type: 'done',
-                    output: { addedModels: input.models }
-                });
-            };
-            _persist().catch((error) => {
-                sendBack({ type: 'error', error: error instanceof Error ? error : new Error(String(error)) });
-            });
-            return () => {
-                // Cleanup
-            };
-        }),
-    },
-}).createMachine({
-    id: 'addModels',
-    initial: 'preparing',
-    context: ({ input }) => ({
-        schemaContext: input.schemaContext,
-        models: input.models,
-        existingModels: input.existingModels,
-        progress: {
-            stage: 'preparing',
-            totalModels: Object.keys(input.models).length,
-            completedModels: 0,
-        },
-    }),
-    states: {
-        preparing: {
-            invoke: {
-                src: 'validateModels',
-                input: ({ context }) => ({
-                    newModels: context.models,
-                    existingModels: context.existingModels,
-                }),
-                onDone: {
-                    target: 'creatingInstances',
-                    actions: assign({
-                        progress: ({ context }) => ({
-                            ...context.progress,
-                            stage: 'creatingInstances',
-                        }),
-                    }),
-                },
-                onError: {
-                    target: 'error',
-                    actions: assign({
-                        errors: ({ context, event }) => [
-                            ...(context.errors || []),
-                            {
-                                modelName: 'validation',
-                                error: event.error instanceof Error ? event.error : new Error(String(event.error))
-                            },
-                        ],
-                    }),
-                },
-            },
-        },
-        creatingInstances: {
-            invoke: {
-                src: 'createModelInstances',
-                input: ({ context }) => ({
-                    schemaContext: context.schemaContext,
-                    models: context.models,
-                }),
-                onDone: {
-                    target: 'collectingIds',
-                    actions: assign({
-                        modelInstances: ({ event }) => {
-                            // Type assertion needed due to XState v5 type inference limitation
-                            const doneEvent = event;
-                            return doneEvent.output?.modelInstances;
-                        },
-                        progress: ({ context }) => ({
-                            ...context.progress,
-                            stage: 'collectingIds',
-                        }),
-                    }),
-                },
-                onError: {
-                    target: 'error',
-                    actions: assign({
-                        errors: ({ context, event }) => [
-                            ...(context.errors || []),
-                            {
-                                modelName: 'createInstances',
-                                error: event.error instanceof Error ? event.error : new Error(String(event.error))
-                            },
-                        ],
-                    }),
-                },
-            },
-        },
-        collectingIds: {
-            invoke: {
-                src: 'collectModelFileIds',
-                input: ({ context }) => ({
-                    modelInstances: context.modelInstances,
-                }),
-                onDone: {
-                    target: 'persisting',
-                    actions: assign({
-                        modelFileIds: ({ event }) => {
-                            // Type assertion needed due to XState v5 type inference limitation
-                            const doneEvent = event;
-                            return doneEvent.output?.modelFileIds;
-                        },
-                        progress: ({ context }) => ({
-                            ...context.progress,
-                            stage: 'persisting',
-                        }),
-                    }),
-                },
-                onError: {
-                    target: 'error',
-                    actions: assign({
-                        errors: ({ context, event }) => [
-                            ...(context.errors || []),
-                            {
-                                modelName: 'collectIds',
-                                error: event.error instanceof Error ? event.error : new Error(String(event.error))
-                            },
-                        ],
-                    }),
-                },
-            },
-        },
-        persisting: {
-            invoke: {
-                src: 'persistModelsToDb',
-                input: ({ context }) => ({
-                    schemaContext: context.schemaContext,
-                    models: context.models,
-                    modelFileIds: context.modelFileIds,
-                }),
-                onDone: {
-                    target: '#addModels.success',
-                    actions: assign({
-                        addedModels: ({ event }) => {
-                            // Type assertion needed due to XState v5 type inference limitation
-                            // Convert through unknown first to avoid type overlap error
-                            const doneEvent = event;
-                            return { addedModels: doneEvent.output?.addedModels };
-                        },
-                    }),
-                },
-                onError: {
-                    target: 'error',
-                    actions: assign({
-                        errors: ({ context, event }) => [
-                            ...(context.errors || []),
-                            { modelName: 'persist', error: event.error instanceof Error ? event.error : new Error(String(event.error)) },
-                        ],
-                    }),
-                },
-            },
-        },
-        success: {
-            id: 'success',
-            type: 'final',
-            output: ({ context }) => ({ addedModels: context.addedModels?.addedModels || [] }),
-        },
-        error: {
-            type: 'final',
-            output: ({ context }) => ({
-                errors: context.errors || [],
-            }),
-        },
-    },
-});
-
 const logger$c = debug('seedSdk:schema:actors:checkExistingSchema');
 /**
  * Query model IDs (schemaFileId) from database for a given schema
@@ -2084,8 +1509,8 @@ const createModelInstances$1 = async (modelIds) => {
         return;
     }
     try {
-        const _mod_7 = await import('./index-HRHkbVQd.js');
-        const _ns_7 = _mod_7.b;
+        const _mod_7 = await import('./index-DtfjeuxC.js');
+        const _ns_7 = _mod_7.c;
         const mod = _ns_7;
         const Model = mod?.Model ?? mod?.default;
         if (!Model) {
@@ -2131,8 +1556,8 @@ const checkExistingSchema = fromCallback(({ sendBack, input: { context } }) => {
         if (isInternal && schemaName === SEED_PROTOCOL_SCHEMA_NAME) {
             // For Seed Protocol, check if it exists in database
             try {
-                const _mod_8 = await import('./ClientManager-ChcmUL47.js');
-                const _ns_8 = _mod_8.ao;
+                const _mod_8 = await import('./ClientManager-DLleL_2e.js');
+                const _ns_8 = _mod_8.S;
                 const internalSchema = _ns_8;
                 const schemaFile = internalSchema.default;
                 if (db && schemaFile.id) {
@@ -2491,8 +1916,8 @@ const writeSchemaToDb = fromCallback(({ sendBack, input }) => {
             if (isInternal && schemaName === SEED_PROTOCOL_SCHEMA_NAME) {
                 // For Seed Protocol, load from internal file
                 logger$b(`Loading internal Seed Protocol schema from SDK`);
-                const _mod_9 = await import('./ClientManager-ChcmUL47.js');
-                const _ns_9 = _mod_9.ao;
+                const _mod_9 = await import('./ClientManager-DLleL_2e.js');
+                const _ns_9 = _mod_9.S;
                 const internalSchema = _ns_9;
                 finalSchema = internalSchema.default;
                 const db = BaseDb.getAppDb();
@@ -2961,8 +2386,8 @@ const createModelInstances = fromCallback(({ sendBack, input }) => {
             return;
         }
         try {
-            const _mod_10 = await import('./index-HRHkbVQd.js');
-            const _ns_10 = _mod_10.b;
+            const _mod_10 = await import('./index-DtfjeuxC.js');
+            const _ns_10 = _mod_10.c;
             const modelMod = _ns_10;
             const { Model } = modelMod;
             // Create instances for all model IDs in parallel
@@ -3049,8 +2474,8 @@ const verifyModelInstancesInCache = fromCallback(({ sendBack, input }) => {
         }
         try {
             const result = await verifyWithRetry$2(async () => {
-                const _mod_11 = await import('./index-HRHkbVQd.js');
-                const _ns_11 = _mod_11.b;
+                const _mod_11 = await import('./index-DtfjeuxC.js');
+                const _ns_11 = _mod_11.c;
                 const modelMod = _ns_11;
                 const { Model } = modelMod;
                 // Check each model ID in the cache
@@ -3108,8 +2533,8 @@ const writePropertiesToDb = fromCallback(({ sendBack, input }) => {
     const _write = async () => {
         const { modelIds } = input;
         try {
-            const _mod_12 = await import('./BasePathResolver-B6CKqoKw.js');
-            const _ns_12 = _mod_12.M;
+            const _mod_12 = await import('./BasePathResolver-ndE8XTpw.js');
+            const _ns_12 = _mod_12.N;
             const modelSchemaMod = _ns_12;
             const { models: modelsTable, properties: propertiesTable } = modelSchemaMod;
             const drizzleMod = await import('drizzle-orm');
@@ -3298,10 +2723,10 @@ const createPropertyInstances = fromCallback(({ sendBack, input }) => {
             return;
         }
         try {
-            const modProp = await import('./ModelProperty-D79uV42p.js');
+            const modProp = await import('./ModelProperty-lth9L37R.js');
             const ModelProperty = modProp?.ModelProperty ?? modProp?.default;
-            const _mod_13 = await import('./index-HRHkbVQd.js');
-            const _ns_13 = _mod_13.b;
+            const _mod_13 = await import('./index-DtfjeuxC.js');
+            const _ns_13 = _mod_13.c;
             const modModel = _ns_13;
             const Model = modModel?.Model ?? modModel?.default;
             if (!ModelProperty || !Model) {
@@ -3407,7 +2832,7 @@ const verifyPropertyInstancesInCache = fromCallback(({ sendBack, input }) => {
         }
         try {
             const result = await verifyWithRetry(async () => {
-                const mod = await import('./ModelProperty-D79uV42p.js');
+                const mod = await import('./ModelProperty-lth9L37R.js');
                 const ModelProperty = mod?.ModelProperty ?? mod?.default;
                 if (!ModelProperty) {
                     throw new Error('ModelProperty not available from dynamic import');
@@ -3467,7 +2892,6 @@ const schemaMachine = setup({
     actors: {
         loadOrCreateSchema,
         validateSchema,
-        addModelsMachine,
         writeProcessMachine,
         // Staged loading actors
         checkExistingSchema,
@@ -3486,9 +2910,6 @@ const schemaMachine = setup({
         isSchemaValid: ({ context }) => {
             return !context._validationErrors || context._validationErrors.length === 0;
         },
-        hasValidationErrors: ({ context }) => {
-            return !!context._validationErrors && context._validationErrors.length > 0;
-        },
     },
 }).createMachine({
     id: 'schema',
@@ -3572,22 +2993,15 @@ const schemaMachine = setup({
             }),
         },
         destroyStarted: {
-            actions: assign({ _destroyInProgress: true, _destroyError: null }),
-        },
-        destroyDone: {
-            actions: assign({ _destroyInProgress: false }),
+            actions: assign({ _destroyError: null }),
         },
         destroyError: {
             actions: assign(({ event }) => ({
-                _destroyInProgress: false,
                 _destroyError: event.error instanceof Error
                     ? { message: event.error.message, name: event.error.name }
                     : { message: String(event.error) },
             })),
         },
-        clearDestroyError: {
-            actions: assign({ _destroyError: null }),
-        },
     },
     states: {
         loading: {
@@ -3976,9 +3390,6 @@ const schemaMachine = setup({
                 },
             }),
             on: {
-                addModels: {
-                    target: 'addingModels',
-                },
                 validateSchema: {
                     target: 'validating',
                 },
@@ -3996,122 +3407,27 @@ const schemaMachine = setup({
                     },
                 },
             },
-            always: {
-                guard: 'hasValidationErrors',
-                target: 'validating',
-            },
-        },
-        addingModels: {
-            entry: assign({
-                // Move first pending item to current if not already set
-                _pendingModelAdditions: ({ context, event }) => {
-                    const pending = context._pendingModelAdditions || [];
-                    // If event has models, it's a new request - add to queue if we're already processing
-                    if (event.models) {
-                        return [
-                            ...pending,
-                            {
-                                models: event.models,
-                                timestamp: Date.now(),
-                            },
-                        ];
-                    }
-                    return pending;
-                },
-            }),
-            invoke: {
-                src: 'addModelsMachine',
-                input: ({ context }) => {
-                    // Get models from first item in pending queue, or from context if queue is empty
-                    const pending = context._pendingModelAdditions || [];
-                    const models = pending.length > 0 ? pending[0].models : {};
-                    return {
-                        schemaContext: context,
-                        models,
-                        existingModels: context.models || {},
-                    };
-                },
-                onDone: {
-                    actions: [
-                        assign({
-                            models: ({ context, event }) => {
-                                const addedModels = event.output?.addedModels || {};
-                                return {
-                                    ...(context.models || {}),
-                                    ...addedModels,
-                                };
-                            },
-                            _pendingModelAdditions: ({ context }) => {
-                                // Remove first item from queue (the one we just processed)
-                                const pending = context._pendingModelAdditions || [];
-                                return pending.length > 1 ? pending.slice(1) : undefined;
-                            },
-                        }),
-                        // Trigger validation after models are added
-                        ({ self }) => {
-                            self.send({ type: 'validateSchema' });
-                        },
-                    ],
-                },
-                onError: {
-                    actions: assign({
-                        _modelAdditionErrors: ({ context, event }) => {
-                            const existing = context._modelAdditionErrors || [];
-                            return [
-                                ...existing,
-                                {
-                                    error: event.error instanceof Error ? event.error : new Error(String(event.error)),
-                                    timestamp: Date.now(),
-                                },
-                            ];
-                        },
-                        _pendingModelAdditions: ({ context }) => {
-                            // Remove first item from queue even on error, so we can process next
-                            const pending = context._pendingModelAdditions || [];
-                            return pending.length > 1 ? pending.slice(1) : undefined;
-                        },
-                    }),
-                },
-            },
-            on: {
-                // Queue additional requests while processing
-                addModels: {
-                    actions: assign({
-                        _pendingModelAdditions: ({ context, event }) => {
-                            const existing = context._pendingModelAdditions || [];
-                            return [
-                                ...existing,
-                                {
-                                    models: event.models,
-                                    timestamp: Date.now(),
-                                },
-                            ];
-                        },
-                    }),
-                },
-            },
-            always: [
-                {
-                    // If there are pending additions after processing, process next one
-                    guard: ({ context }) => {
-                        const pending = context._pendingModelAdditions || [];
-                        return pending.length > 0;
-                    },
-                    target: 'addingModels',
-                },
-                {
-                    // No more pending, return to idle
-                    target: 'idle',
-                },
-            ],
+            // No `always: hasValidationErrors -> validating` here: validation is re-run when the context changes
+            // (updateContext) or on request (validateSchema). Re-entering while errors exist would loop
+            // forever on a schema that is still invalid.
         },
         validating: {
             on: {
+                // These state-level handlers take precedence over the root ones, so they must store the result
+                // themselves.
                 validationSuccess: {
                     target: 'idle',
+                    actions: assign(({ context }) => ({
+                        ...context,
+                        _validationErrors: [],
+                    })),
                 },
                 validationError: {
                     target: 'idle',
+                    actions: assign(({ context, event }) => ({
+                        ...context,
+                        _validationErrors: event.errors,
+                    })),
                 },
             },
             invoke: {
@@ -4429,8 +3745,8 @@ async function loadSchemaWithRenames(schemaFilePath, modelRenames) {
         updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
     };
     // Use dynamic import to break circular dependency
-    const _mod_14 = await import('./db-WbrzEf7c.js');
-    const _ns_14 = _mod_14.Q;
+    const _mod_14 = await import('./db-BJZN0a0a.js');
+    const _ns_14 = _mod_14.Z;
     const dbMod = _ns_14;
     const { addSchemaToDb, addModelsToDb } = dbMod;
     // Add schema to database with schemaFileId
@@ -4542,10 +3858,10 @@ async function renameModelProperty(schemaName, modelName, oldPropertyName, newPr
     await BaseFileManager.waitForFileWithContent(newFilePath);
     logger$1(`Renamed property ${oldPropertyName} to ${newPropertyName} in schema ${schemaName} v${newVersion}`);
     // Migrate metadata rows so ItemProperty values follow the new name (prevents duplicate ItemProperties)
-    const _mod_15 = await import('./db-WbrzEf7c.js');
-    const _ns_15 = _mod_15.Q;
+    const _mod_15 = await import('./db-BJZN0a0a.js');
+    const _ns_15 = _mod_15.Z;
     const { migrateMetadataForPropertyRename } = _ns_15;
-    const migratedCount = await migrateMetadataForPropertyRename(modelName, oldPropertyName, newPropertyName, oldProperty.id);
+    const migratedCount = await migrateMetadataForPropertyRename(modelName, oldPropertyName, newPropertyName, oldProperty.id, { schemaName });
     if (migratedCount > 0) {
         logger$1(`Migrated ${migratedCount} metadata rows for property rename`);
     }
@@ -4820,7 +4136,6 @@ class Schema {
         // Initialize instance state in WeakMap (only non-serializable resources)
         schemaInstanceState.set(this, {
             liveQuerySubscription: null,
-            modelInstances: new Map(),
         });
         // Set up liveQuery subscription for cross-instance model updates
         // This will be initialized once we have the schemaId
@@ -5030,118 +4345,10 @@ class Schema {
                     }
                 }
                 else if (prop === 'models') {
-                    // Models are read-only computed values from Model instances
-                    // Cannot be set directly - models are managed via Model instances
-                    throw new Error('Cannot set schema.models directly. Models are computed from Model instances.');
-                    /* DISABLED CODE - See comment above
-                    // Convert array of Model instances or plain objects back to object format
-                    let modelsObject: { [key: string]: any }
-                    if (Array.isArray(value)) {
-                      modelsObject = {}
-                      const seenNames = new Set<string>()
-                      
-                      // Check for duplicate model names
-                      for (const model of value) {
-                        // Handle Model instances
-                        if (model instanceof Model) {
-                          const modelName = model.modelName!
-                          if (seenNames.has(modelName)) {
-                            throw new Error(
-                              `Duplicate model name detected: "${modelName}". Each model must have a unique name.`
-                            )
-                          }
-                          seenNames.add(modelName)
-                          modelsObject[modelName] = {
-                            properties: model.properties || {},
-                          }
-                        } else if (model && typeof model === 'object' && 'name' in model) {
-                          // Handle plain objects
-                          const modelName = model.name as string
-                          if (seenNames.has(modelName)) {
-                            throw new Error(
-                              `Duplicate model name detected: "${modelName}". Each model must have a unique name.`
-                            )
-                          }
-                          seenNames.add(modelName)
-                          const { name, ...modelData } = model
-                          modelsObject[name] = modelData
-                        }
-                      }
-                    } else {
-                      modelsObject = value || {}
-                      // Check for duplicates in object format too
-                      const modelNames = Object.keys(modelsObject)
-                      const seenNames = new Set<string>()
-                      for (const modelName of modelNames) {
-                        if (seenNames.has(modelName)) {
-                          throw new Error(
-                            `Duplicate model name detected: "${modelName}". Each model must have a unique name.`
-                          )
-                        }
-                        seenNames.add(modelName)
-                      }
-                    }
-                    
-                    const context = newInstance._getSnapshotContext()
-                    
-                    // Check if service is still running before sending events
-                    let snapshot = newInstance._service.getSnapshot()
-                    const wasServiceStopped = snapshot.status === 'stopped'
-                    
-                    if (wasServiceStopped) {
-                      logger(`Service is stopped, will restart before adding models`)
-                      newInstance._service.start()
-                      snapshot = newInstance._service.getSnapshot()
-                    }
-                    
-                    // Check current state after potential restart
-                    const currentState = snapshot.value
-                    // Check if state is a loading state object (XState v5 nested states)
-                    const isServiceLoading = typeof currentState === 'object' && 'loading' in currentState
-                    
-                    // If service is loading, wait for it to finish before adding models
-                    if (isServiceLoading || wasServiceStopped) {
-                      logger(`Service is ${isServiceLoading ? 'loading' : 'was stopped'}, will add models after loading completes`)
-                      
-                      const loadingSubscription = newInstance._service.subscribe((snapshot) => {
-                        if (snapshot.value === 'idle') {
-                          loadingSubscription.unsubscribe()
-                          logger(`Service finished loading, sending addModels event`)
-                          newInstance._service.send({
-                            type: 'addModels',
-                            models: modelsObject,
-                          })
-                        } else if (snapshot.value === 'error') {
-                          loadingSubscription.unsubscribe()
-                          logger(`Service failed to load, cannot add models`)
-                        }
-                      })
-                    } else {
-                      // Service is ready, send addModels event immediately
-                      // The state machine will handle all the complexity (validation, instance creation, ID collection, persistence)
-                      logger(`Service is ready, sending addModels event`)
-                      newInstance._service.send({
-                        type: 'addModels',
-                        models: modelsObject,
-                      })
-                    }
-                    
-                    // Mark schema as draft when models change
-                    newInstance._service.send({
-                      type: 'markAsDraft',
-                      propertyKey: 'schema:models',
-                    })
-                    
-                    // Save draft to database immediately so changes persist
-                    newInstance._saveDraftToDb().catch((error) => {
-                      logger(`Failed to save draft to database: ${error instanceof Error ? error.message : String(error)}`)
-                    })
-                    
-                    // Update client context so useSchema and useSchemas hooks reflect the change
-                    newInstance._updateClientContext().catch(() => {
-                      // Silently fail if not in browser environment
-                    })
-                    */
+                    // Models are read-only, computed from Model instances. Array assignment was removed because
+                    // the draft save could run before the new Model instances existed, losing them.
+                    throw new Error('Cannot set schema.models directly. Models are computed from Model instances; ' +
+                        'use Model.create(modelName, schema, { properties }) to add one.');
                 }
                 else if (prop === 'createdAt' || prop === 'updatedAt') {
                     // Update metadata object
@@ -5192,7 +4399,12 @@ class Schema {
             return schema;
         const readyPromise = waitForEntityIdle(schema, { timeout: readyTimeout }).then(() => schema);
         this.pendingSchemaByName.set(schemaName, readyPromise);
-        readyPromise.finally(() => this.pendingSchemaByName.delete(schemaName));
+        // Clear on both outcomes without a .finally() chain: that derived promise would reject unhandled
+        // whenever readyPromise does, even when the caller handles the rejection.
+        const clearPending = () => {
+            this.pendingSchemaByName.delete(schemaName);
+        };
+        readyPromise.then(clearPending, clearPending);
         return readyPromise;
     }
     /**
@@ -5753,13 +4965,19 @@ class Schema {
             _dbVersion: publishedSchema.version,
         });
         // Clear edited flags on all ModelProperty instances and in database
-        const modelPropertyMod = await import('./ModelProperty-D79uV42p.js');
+        const modelPropertyMod = await import('./ModelProperty-lth9L37R.js');
         const { ModelProperty } = modelPropertyMod;
         for (const propertyKey of context._editedProperties) {
             const [modelName, propertyName] = propertyKey.split(':');
-            const cacheKey = `${modelName}:${propertyName}`;
             const ModelPropertyClass = ModelProperty;
-            const cachedInstance = ModelPropertyClass.instanceCache.get(cacheKey);
+            // Model names are only unique per schema: pick this schema's instance, which may be keyed by id.
+            const thisSchemaName = this.schemaName;
+            const cachedInstance = [...ModelPropertyClass.instanceCache.values()].find(({ instance }) => {
+                const ctx = instance.getService().getSnapshot().context;
+                return (ctx.modelName === modelName &&
+                    ctx.name === propertyName &&
+                    (!ctx._schemaName || ctx._schemaName === thisSchemaName));
+            });
             if (cachedInstance) {
                 const modelProperty = cachedInstance.instance;
                 modelProperty.getService().getSnapshot().context;
@@ -5770,12 +4988,12 @@ class Schema {
                 // Clear isEdited flag in database
                 try {
                     if (db && modelName && propertyName) {
-                        // Find model by name
-                        const modelRecords = await db
-                            .select({ id: models.id })
-                            .from(models)
-                            .where(eq(models.name, modelName))
-                            .limit(1);
+                        // Find this schema's model by name
+                        const _mod_16 = await import('./db-BJZN0a0a.js');
+                        const _ns_16 = _mod_16.Y;
+                        const { resolveModelRecord } = _ns_16;
+                        const modelRecord = await resolveModelRecord(modelName, { schemaName: thisSchemaName }, db);
+                        const modelRecords = modelRecord ? [modelRecord] : [];
                         if (modelRecords.length > 0) {
                             // Find property by name and modelId
                             const propertyRecords = await db
@@ -6337,6 +5555,18 @@ class Schema {
                 Schema.instanceCacheByName,
             ],
         });
+        // The rows for this schema's models and properties are deleted below; evict their cached
+        // instances too, or a re-import would get them back with dangling _dbIds.
+        if (schemaName) {
+            const evictedModelNames = Model.evictForSchema(schemaName);
+            const { ModelProperty } = await import('./ModelProperty-lth9L37R.js');
+            ModelProperty.evictForModels(evictedModelNames, schemaName);
+            // Evicting stops new writes but not ones already running; let those land before deleting their rows
+            const _mod_17 = await import('./index-DtfjeuxC.js');
+            const _ns_17 = _mod_17.b;
+            const { waitForInFlightWrites } = _ns_17;
+            await waitForInFlightWrites();
+        }
         await runDestroyLifecycle(this, {
             getService: (instance) => instance._service,
             doDestroy: async () => {
@@ -6556,4 +5786,4 @@ var Schema$1 = /*#__PURE__*/Object.freeze({
 });
 
 export { Schema as S, deletePropertyFromModel as a, Schema$1 as b, deleteModelFromSchema as d, renameModelProperty as r, schemaMachine as s, updateModelProperties as u };
-//# sourceMappingURL=Schema-a8uO-hIZ.js.map
+//# sourceMappingURL=Schema-DOhlrQ-N.js.map