@seedprotocol/sdk 0.6.9 → 0.7.0

package/dist/cjs/{Schema-BiJIPLEL.js → Schema-qEp5mH1N.js}

@@ -1,11 +1,11 @@
 'use strict';
 
 var xstate = require('xstate');
-var main_cjs = require('./index-CSNtEnbF.js');
+var main_cjs = require('./index-C66AfYDG.js');
 var drizzleOrm = require('drizzle-orm');
 var debug = require('debug');
 require('pluralize');
-var SchemaValidationService = require('./SchemaValidationService-DtYs_CNY.js');
+var SchemaValidationService = require('./SchemaValidationService-CWEnZmOH.js');
 require('immer');
 require('reflect-metadata');
 require('drizzle-orm/sqlite-core');
@@ -76,7 +76,7 @@ const createModelInstances$2 = async (modelIds) => {
         return;
     }
     try {
-        const modelMod = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.Model$1; });
+        const modelMod = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.Model$1; });
         const { Model } = modelMod;
         // Create instances for all model IDs in parallel
         // Model.createById() will check cache first, then query DB and create if needed
@@ -189,7 +189,7 @@ const loadOrCreateSchema = xstate.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 internalSchema = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
+                const internalSchema = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
                 const schemaFile = internalSchema.default;
                 // Check if it exists in database, if not, add it
                 const db = main_cjs.BaseDb.getAppDb();
@@ -682,7 +682,7 @@ const loadOrCreateSchema = xstate.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 internalSchema = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
+                            const internalSchema = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
                             const internalSchemaFile = internalSchema.default;
                             mergedModels = { ...(internalSchemaFile.models || {}) };
                             logger$d(`Populated models for seed-protocol schema from internal file`);
@@ -909,7 +909,7 @@ const loadOrCreateSchema = xstate.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 internalSchema = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
+                            const internalSchema = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
                             const internalSchemaFile = internalSchema.default;
                             mergedModels = { ...(internalSchemaFile.models || {}) };
                             logger$d(`Populated models for seed-protocol schema from internal file`);
@@ -998,7 +998,7 @@ const loadOrCreateSchema = xstate.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 internalSchema = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
+                                const internalSchema = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
                                 const internalSchemaFile = internalSchema.default;
                                 mergedModels = { ...(internalSchemaFile.models || {}) };
                                 logger$d(`Populated models for seed-protocol schema from internal file`);
@@ -1084,7 +1084,7 @@ const loadOrCreateSchema = xstate.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 internalSchema = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
+                        const internalSchema = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
                         const schemaFile = internalSchema.default;
                         logger$d(`Found seed-protocol schema in internal file (schemaData missing, using internal schema)`);
                         // Update database with schemaData for future loads
@@ -1193,7 +1193,7 @@ const loadOrCreateSchema = xstate.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 internalSchema = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
+                    const internalSchema = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
                     const internalSchemaFile = internalSchema.default;
                     mergedModels = { ...(internalSchemaFile.models || {}) };
                     logger$d(`Populated models for seed-protocol schema from internal file`);
@@ -1464,582 +1464,6 @@ const validateSchema = xstate.fromCallback(({ sendBack, input: { context } }) =>
     };
 });
 
-const addModelsMachine = xstate.setup({
-    types: {
-        context: {},
-        input: {},
-        events: {},
-    },
-    actors: {
-        validateModels: xstate.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: xstate.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 = main_cjs.BaseDb.getAppDb();
-                            if (db) {
-                                const dbModels = await db
-                                    .select()
-                                    .from(main_cjs.models)
-                                    .where(drizzleOrm.eq(main_cjs.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 = main_cjs.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 = main_cjs.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: xstate.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: xstate.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 = main_cjs.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(main_cjs.schemas)
-                            .where(drizzleOrm.eq(main_cjs.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(main_cjs.schemas)
-                            .where(drizzleOrm.eq(main_cjs.schemas.name, schemaName))
-                            .orderBy(drizzleOrm.desc(main_cjs.schemas.isDraft), drizzleOrm.desc(main_cjs.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 (main_cjs.isDataType(schemaProp.dataType, main_cjs.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 main_cjs.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 main_cjs.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: xstate.assign({
-                        progress: ({ context }) => ({
-                            ...context.progress,
-                            stage: 'creatingInstances',
-                        }),
-                    }),
-                },
-                onError: {
-                    target: 'error',
-                    actions: xstate.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: xstate.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: xstate.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: xstate.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: xstate.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: xstate.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: xstate.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
@@ -2094,7 +1518,7 @@ const createModelInstances$1 = async (modelIds) => {
         return;
     }
     try {
-        const mod = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.Model$1; });
+        const mod = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.Model$1; });
         const Model = mod?.Model ?? mod?.default;
         if (!Model) {
             logger$c('Model not available from dynamic import');
@@ -2139,7 +1563,7 @@ const checkExistingSchema = xstate.fromCallback(({ sendBack, input: { context }
         if (isInternal && schemaName === main_cjs.SEED_PROTOCOL_SCHEMA_NAME) {
             // For Seed Protocol, check if it exists in database
             try {
-                const internalSchema = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
+                const internalSchema = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
                 const schemaFile = internalSchema.default;
                 if (db && schemaFile.id) {
                     const existing = await db
@@ -2497,7 +1921,7 @@ const writeSchemaToDb = xstate.fromCallback(({ sendBack, input }) => {
             if (isInternal && schemaName === main_cjs.SEED_PROTOCOL_SCHEMA_NAME) {
                 // For Seed Protocol, load from internal file
                 logger$b(`Loading internal Seed Protocol schema from SDK`);
-                const internalSchema = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
+                const internalSchema = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
                 finalSchema = internalSchema.default;
                 const db = main_cjs.BaseDb.getAppDb();
                 if (db && finalSchema.id) {
@@ -2965,7 +2389,7 @@ const createModelInstances = xstate.fromCallback(({ sendBack, input }) => {
             return;
         }
         try {
-            const modelMod = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.Model$1; });
+            const modelMod = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.Model$1; });
             const { Model } = modelMod;
             // Create instances for all model IDs in parallel
             // Model.createById() will check cache first, then query DB and create if needed
@@ -3051,7 +2475,7 @@ const verifyModelInstancesInCache = xstate.fromCallback(({ sendBack, input }) =>
         }
         try {
             const result = await verifyWithRetry$2(async () => {
-                const modelMod = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.Model$1; });
+                const modelMod = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.Model$1; });
                 const { Model } = modelMod;
                 // Check each model ID in the cache
                 const verifiedInstances = [];
@@ -3108,7 +2532,7 @@ const writePropertiesToDb = xstate.fromCallback(({ sendBack, input }) => {
     const _write = async () => {
         const { modelIds } = input;
         try {
-            const modelSchemaMod = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.ModelSchema; });
+            const modelSchemaMod = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.ModelSchema; });
             const { models: modelsTable, properties: propertiesTable } = modelSchemaMod;
             const drizzleMod = await import('drizzle-orm');
             const { eq } = drizzleMod;
@@ -3296,9 +2720,9 @@ const createPropertyInstances = xstate.fromCallback(({ sendBack, input }) => {
             return;
         }
         try {
-            const modProp = await Promise.resolve().then(function () { return require('./ModelProperty-D9FGaGuE.js'); });
+            const modProp = await Promise.resolve().then(function () { return require('./ModelProperty-BEsIHAjk.js'); });
             const ModelProperty = modProp?.ModelProperty ?? modProp?.default;
-            const modModel = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.Model$1; });
+            const modModel = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.Model$1; });
             const Model = modModel?.Model ?? modModel?.default;
             if (!ModelProperty || !Model) {
                 logger$3('ModelProperty or Model not available from dynamic import');
@@ -3403,7 +2827,7 @@ const verifyPropertyInstancesInCache = xstate.fromCallback(({ sendBack, input })
         }
         try {
             const result = await verifyWithRetry(async () => {
-                const mod = await Promise.resolve().then(function () { return require('./ModelProperty-D9FGaGuE.js'); });
+                const mod = await Promise.resolve().then(function () { return require('./ModelProperty-BEsIHAjk.js'); });
                 const ModelProperty = mod?.ModelProperty ?? mod?.default;
                 if (!ModelProperty) {
                     throw new Error('ModelProperty not available from dynamic import');
@@ -3463,7 +2887,6 @@ const schemaMachine = xstate.setup({
     actors: {
         loadOrCreateSchema,
         validateSchema,
-        addModelsMachine,
         writeProcessMachine: main_cjs.writeProcessMachine,
         // Staged loading actors
         checkExistingSchema,
@@ -3482,9 +2905,6 @@ const schemaMachine = xstate.setup({
         isSchemaValid: ({ context }) => {
             return !context._validationErrors || context._validationErrors.length === 0;
         },
-        hasValidationErrors: ({ context }) => {
-            return !!context._validationErrors && context._validationErrors.length > 0;
-        },
     },
 }).createMachine({
     id: 'schema',
@@ -3568,22 +2988,15 @@ const schemaMachine = xstate.setup({
             }),
         },
         destroyStarted: {
-            actions: xstate.assign({ _destroyInProgress: true, _destroyError: null }),
-        },
-        destroyDone: {
-            actions: xstate.assign({ _destroyInProgress: false }),
+            actions: xstate.assign({ _destroyError: null }),
         },
         destroyError: {
             actions: xstate.assign(({ event }) => ({
-                _destroyInProgress: false,
                 _destroyError: event.error instanceof Error
                     ? { message: event.error.message, name: event.error.name }
                     : { message: String(event.error) },
             })),
         },
-        clearDestroyError: {
-            actions: xstate.assign({ _destroyError: null }),
-        },
     },
     states: {
         loading: {
@@ -3972,9 +3385,6 @@ const schemaMachine = xstate.setup({
                 },
             }),
             on: {
-                addModels: {
-                    target: 'addingModels',
-                },
                 validateSchema: {
                     target: 'validating',
                 },
@@ -3992,122 +3402,27 @@ const schemaMachine = xstate.setup({
                     },
                 },
             },
-            always: {
-                guard: 'hasValidationErrors',
-                target: 'validating',
-            },
-        },
-        addingModels: {
-            entry: xstate.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: [
-                        xstate.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: xstate.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: xstate.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: xstate.assign(({ context }) => ({
+                        ...context,
+                        _validationErrors: [],
+                    })),
                 },
                 validationError: {
                     target: 'idle',
+                    actions: xstate.assign(({ context, event }) => ({
+                        ...context,
+                        _validationErrors: event.errors,
+                    })),
                 },
             },
             invoke: {
@@ -4248,7 +3563,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
@@ -4458,118 +3772,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
@@ -4620,7 +3826,12 @@ class Schema {
             return schema;
         const readyPromise = main_cjs.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;
     }
     /**
@@ -5181,13 +4392,19 @@ class Schema {
             _dbVersion: publishedSchema.version,
         });
         // Clear edited flags on all ModelProperty instances and in database
-        const modelPropertyMod = await Promise.resolve().then(function () { return require('./ModelProperty-D9FGaGuE.js'); });
+        const modelPropertyMod = await Promise.resolve().then(function () { return require('./ModelProperty-BEsIHAjk.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;
@@ -5198,12 +4415,10 @@ class Schema {
                 // Clear isEdited flag in database
                 try {
                     if (db && modelName && propertyName) {
-                        // Find model by name
-                        const modelRecords = await db
-                            .select({ id: main_cjs.models.id })
-                            .from(main_cjs.models)
-                            .where(drizzleOrm.eq(main_cjs.models.name, modelName))
-                            .limit(1);
+                        // Find this schema's model by name
+                        const { resolveModelRecord } = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.resolveModelRecord$1; });
+                        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
@@ -5765,6 +4980,16 @@ 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 = main_cjs.Model.evictForSchema(schemaName);
+            const { ModelProperty } = await Promise.resolve().then(function () { return require('./ModelProperty-BEsIHAjk.js'); });
+            ModelProperty.evictForModels(evictedModelNames, schemaName);
+            // Evicting stops new writes but not ones already running; let those land before deleting their rows
+            const { waitForInFlightWrites } = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.writeToDatabase; });
+            await waitForInFlightWrites();
+        }
         await main_cjs.runDestroyLifecycle(this, {
             getService: (instance) => instance._service,
             doDestroy: async () => {
@@ -5977,12 +5202,6 @@ Schema.pendingSchemaByName = new Map();
 // Track which schemas are currently being saved to prevent concurrent saves
 Schema.savingSchemas = new Set();
 
-var Schema$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    Schema: Schema,
-    schemaInstanceState: schemaInstanceState
-});
-
 exports.Schema = Schema;
 exports.schemaInstanceState = schemaInstanceState;
-//# sourceMappingURL=Schema-BiJIPLEL.js.map
+//# sourceMappingURL=Schema-qEp5mH1N.js.map