@seedprotocol/sdk 0.4.3 → 0.4.5

package/dist/cjs/{Schema-B5cr_JVK.js → Schema-CVs9J6eP.js}

@@ -1,38 +1,388 @@
 'use strict';
 
 var xstate = require('xstate');
-var main_cjs = require('./index-BmIVfqGN.js');
+var main_cjs = require('./index-BeKPbbk0.js');
 var drizzleOrm = require('drizzle-orm');
 var debug = require('debug');
-var SchemaValidationService = require('./SchemaValidationService-BgIzc3-r.js');
-var ModelProperty = require('./ModelProperty-MkN5Rmx7.js');
-require('immer');
-require('reflect-metadata');
-require('drizzle-orm/sqlite-core');
-require('nanoid');
-require('nanoid-dictionary');
+var SchemaValidationService = require('./SchemaValidationService-CDKcVRFQ.js');
 require('pluralize');
-require('ethers');
-require('rxjs');
-require('lodash-es');
-require('eventemitter3');
-require('drizzle-orm/casing');
-require('@sinclair/typebox');
-require('fs/promises');
-require('fs');
-require('path');
-require('@libsql/client');
-require('drizzle-orm/libsql');
-require('drizzle-kit/api');
-require('js-yaml');
-require('arweave');
-require('ts-import');
-require('glob');
-require('rimraf');
-require('child_process');
-require('url');
-require('graphql-request');
-require('@sinclair/typebox/value');
+
+const logger$d = debug('seedSdk:helpers:updateSchema');
+/**
+ * Get the file path for a schema file
+ */
+/**
+ * Sanitize a schema name to be filesystem-safe
+ * Replaces all special characters (except alphanumeric, hyphens, underscores) with underscores
+ * Converts spaces to underscores
+ * Removes leading/trailing underscores
+ *
+ * @param name - Schema name to sanitize
+ * @returns Sanitized name safe for use in filenames
+ */
+const sanitizeSchemaName$1 = (name) => {
+    return name
+        .replace(/[^a-zA-Z0-9\s_-]/g, '_') // Replace special chars (except spaces, hyphens, underscores) with underscore
+        .replace(/\s+/g, '_') // Convert spaces to underscores
+        .replace(/^_+|_+$/g, '') // Remove leading/trailing underscores
+        .replace(/_+/g, '_'); // Collapse multiple underscores to single
+};
+/**
+ * Get the full file path for a schema
+ * Format: {schemaFileId}_{schemaName}_v{version}.json
+ *
+ * The ID-first format ensures all files for a schema group together when sorted alphabetically.
+ *
+ * @param name - Schema name
+ * @param version - Schema version
+ * @param schemaFileId - Schema file ID (required)
+ */
+const getSchemaFilePath$2 = (name, version, schemaFileId) => {
+    const path = main_cjs.BaseFileManager.getPathModule();
+    const workingDir = main_cjs.BaseFileManager.getWorkingDir();
+    const sanitizedName = sanitizeSchemaName$1(name);
+    const filename = schemaFileId
+        ? `${schemaFileId}_${sanitizedName}_v${version}.json`
+        : `${sanitizedName}_v${version}.json`;
+    return path.join(workingDir, filename);
+};
+/**
+ * Get schemaFileId from database for a schema
+ * @param schemaName - Schema name
+ * @returns Schema file ID
+ * @throws Error if schema not found or missing schemaFileId
+ */
+async function getSchemaFileId(schemaName) {
+    const db = main_cjs.BaseDb.getAppDb();
+    if (!db)
+        throw new Error('Database not available');
+    const dbSchema = await db
+        .select()
+        .from(main_cjs.schemas)
+        .where(drizzleOrm.eq(main_cjs.schemas.name, schemaName))
+        .orderBy(drizzleOrm.desc(main_cjs.schemas.version))
+        .limit(1);
+    if (dbSchema.length === 0 || !dbSchema[0].schemaFileId) {
+        throw new Error(`Schema ${schemaName} not found in database or missing schemaFileId`);
+    }
+    return dbSchema[0].schemaFileId;
+}
+/**
+ * Write the full schema to a new version file (e.g. when new models were added).
+ * Used when _editedProperties contains 'schema:models' and there are no property-level updates.
+ * @param schemaName - Schema name
+ * @param schema - Full schema object (e.g. from _buildModelsFromInstances)
+ * @returns The file path of the new schema version
+ */
+async function writeFullSchemaNewVersion(schemaName, schema) {
+    const latestVersion = await main_cjs.getLatestSchemaVersion(schemaName);
+    const newVersion = latestVersion + 1;
+    const schemaWithNewVersion = {
+        ...schema,
+        version: newVersion,
+        metadata: {
+            ...schema.metadata,
+            updatedAt: new Date().toISOString(),
+        },
+        migrations: [
+            ...(schema.migrations || []),
+            {
+                version: newVersion,
+                timestamp: new Date().toISOString(),
+                description: 'New schema version (e.g. new models added)',
+                changes: [{ type: 'full_schema_write' }],
+            },
+        ],
+    };
+    const newFilePath = getSchemaFilePath$2(schemaName, newVersion, schema.id ?? (await getSchemaFileId(schemaName)));
+    const newContent = JSON.stringify(schemaWithNewVersion, null, 2);
+    await main_cjs.BaseFileManager.saveFile(newFilePath, newContent);
+    await main_cjs.BaseFileManager.waitForFileWithContent(newFilePath);
+    logger$d(`Created new schema version ${newVersion} for ${schemaName} at ${newFilePath}`);
+    return newFilePath;
+}
+/**
+ * Get model name from modelId
+ * @param modelId - The model ID to look up
+ * @returns The model name, or undefined if not found
+ */
+async function getModelNameFromId(modelId) {
+    if (!modelId) {
+        return undefined;
+    }
+    const db = main_cjs.BaseDb.getAppDb();
+    if (!db) {
+        throw new Error('Database not found');
+    }
+    const modelRecords = await db
+        .select()
+        .from(main_cjs.models)
+        .where(drizzleOrm.eq(main_cjs.models.id, modelId))
+        .limit(1);
+    if (modelRecords.length === 0) {
+        return undefined;
+    }
+    return modelRecords[0].name;
+}
+/**
+ * Convert a TProperty/ModelPropertyMachineContext to SchemaPropertyUpdate format
+ * This function converts the internal property representation to the schema file format
+ * @param property - The TProperty instance to convert
+ * @param modelName - The name of the model this property belongs to
+ * @param propertyName - The name of the property
+ * @returns A SchemaPropertyUpdate object ready to be passed to updateModelProperties
+ */
+async function convertPropertyToSchemaUpdate(property, modelName, propertyName) {
+    const updates = {};
+    // Convert dataType to type
+    if (property.dataType) {
+        updates.type = property.dataType;
+    }
+    // Handle Relation type
+    if (property.dataType === main_cjs.ModelPropertyDataTypes.Relation) {
+        if (property.ref) {
+            updates.model = property.ref;
+        }
+        else if (property.refModelId) {
+            // If ref is not set but refModelId is, get the model name from the database
+            const refModelName = await getModelNameFromId(property.refModelId);
+            if (refModelName) {
+                updates.model = refModelName;
+            }
+        }
+    }
+    // Handle List type
+    if (property.dataType === main_cjs.ModelPropertyDataTypes.List) {
+        if (property.refValueType) {
+            updates.items = {
+                type: property.refValueType,
+            };
+            if (property.ref) {
+                updates.items.model = property.ref;
+            }
+            else if (property.refModelId) {
+                // If ref is not set but refModelId is, get the model name from the database
+                const refModelName = await getModelNameFromId(property.refModelId);
+                if (refModelName) {
+                    updates.items.model = refModelName;
+                }
+            }
+        }
+    }
+    // Handle storage configuration (for Text properties with storage)
+    if (property.storageType || property.localStorageDir || property.filenameSuffix) {
+        const storageType = property.storageType || 'ItemStorage'; // Default to ItemStorage if not specified
+        updates.storage = {
+            type: storageType,
+        };
+        if (property.localStorageDir) {
+            updates.storage.path = property.localStorageDir;
+        }
+        if (property.filenameSuffix) {
+            updates.storage.extension = property.filenameSuffix;
+        }
+    }
+    return {
+        modelName,
+        propertyName,
+        updates,
+    };
+}
+/**
+ * Update model properties in a schema and create a new version
+ * @param schemaName - The name of the schema to update
+ * @param propertyUpdates - Array of property updates to apply
+ * @param modelUpdates - Optional array of model renames
+ * @returns The file path of the new schema version
+ * @throws Error if schema not found or updates are invalid
+ */
+async function updateModelProperties(schemaName, propertyUpdates, modelUpdates) {
+    // Get the latest version of the schema
+    const latestVersion = await main_cjs.getLatestSchemaVersion(schemaName);
+    if (latestVersion === 0) {
+        throw new Error(`Schema ${schemaName} not found`);
+    }
+    // Get schemaFileId from database
+    const schemaFileId = await getSchemaFileId(schemaName);
+    // Load the latest schema file
+    const latestFilePath = getSchemaFilePath$2(schemaName, latestVersion, schemaFileId);
+    const content = await main_cjs.BaseFileManager.readFileAsString(latestFilePath);
+    const schemaFile = JSON.parse(content);
+    if (!schemaFile.$schema) {
+        throw new Error(`Schema file ${latestFilePath} is not a complete schema file`);
+    }
+    // Create a copy of the schema for the new version
+    // Preserve schema ID and all model/property IDs
+    const newVersion = latestVersion + 1;
+    const updatedSchema = {
+        ...schemaFile,
+        version: newVersion,
+        // Preserve schema ID from previous version
+        id: schemaFile.id,
+        metadata: {
+            ...schemaFile.metadata,
+            updatedAt: new Date().toISOString(),
+        },
+        // Deep copy models to preserve IDs
+        models: Object.fromEntries(Object.entries(schemaFile.models).map(([modelName, model]) => [
+            modelName,
+            {
+                ...model,
+                // Preserve model ID
+                id: model.id,
+                // Deep copy properties to preserve IDs
+                properties: Object.fromEntries(Object.entries(model.properties).map(([propName, prop]) => [
+                    propName,
+                    {
+                        ...prop,
+                        // Preserve property ID
+                        id: prop.id,
+                    },
+                ])),
+            },
+        ])),
+        migrations: [
+            ...schemaFile.migrations,
+            {
+                version: newVersion,
+                timestamp: new Date().toISOString(),
+                description: `Updated model properties: ${propertyUpdates.map(u => `${u.modelName}.${u.propertyName}`).join(', ')}`,
+                changes: propertyUpdates.map(update => ({
+                    type: 'property_update',
+                    modelName: update.modelName,
+                    propertyName: update.propertyName,
+                    updates: update.updates,
+                })),
+            },
+        ],
+    };
+    // Apply property updates
+    for (const update of propertyUpdates) {
+        const model = updatedSchema.models[update.modelName];
+        if (!model) {
+            throw new Error(`Model ${update.modelName} not found in schema ${schemaName}`);
+        }
+        if (!model.properties[update.propertyName]) {
+            throw new Error(`Property ${update.propertyName} not found in model ${update.modelName} of schema ${schemaName}`);
+        }
+        // Update the property with new values
+        const property = model.properties[update.propertyName];
+        Object.assign(property, update.updates);
+    }
+    // Write the new schema version to file using ID-based naming (preferred)
+    const newFilePath = getSchemaFilePath$2(schemaName, newVersion, updatedSchema.id ?? undefined);
+    const newContent = JSON.stringify(updatedSchema, null, 2);
+    await main_cjs.BaseFileManager.saveFile(newFilePath, newContent);
+    // Wait for the file to be available with content (important for browser/OPFS where writes may not be immediately readable)
+    await main_cjs.BaseFileManager.waitForFileWithContent(newFilePath);
+    logger$d(`Created new schema version ${newVersion} for ${schemaName} at ${newFilePath}`);
+    // Load the new schema file to process models and add them to the database
+    // Extract model renames from migrations to pass to database update
+    const modelRenames = new Map();
+    const latestMigration = updatedSchema.migrations[updatedSchema.migrations.length - 1];
+    for (const change of latestMigration.changes) {
+        if (change.type === 'model_rename') {
+            modelRenames.set(change.oldName, change.newName);
+        }
+    }
+    // Load schema with model renames handled
+    await loadSchemaWithRenames(newFilePath, modelRenames);
+    return newFilePath;
+}
+/**
+ * Load a schema file and handle model renames in the database
+ * This is a helper function that processes model renames before loading
+ */
+async function loadSchemaWithRenames(schemaFilePath, modelRenames) {
+    const content = await main_cjs.BaseFileManager.readFileAsString(schemaFilePath);
+    const schemaFile = JSON.parse(content);
+    if (!schemaFile.$schema) {
+        throw new Error(`File ${schemaFilePath} is not a complete schema file (missing $schema field).`);
+    }
+    const schemaName = schemaFile.metadata?.name;
+    const version = schemaFile.version;
+    if (!schemaName) {
+        throw new Error('Schema name is required in metadata.name');
+    }
+    // Convert to JsonImportSchema format for processing
+    // Remove id fields for JsonImportSchema format (they're not part of the import format)
+    const importData = {
+        name: schemaName,
+        models: Object.fromEntries(Object.entries(schemaFile.models).map(([modelName, model]) => [
+            modelName,
+            {
+                description: model.description,
+                properties: Object.fromEntries(Object.entries(model.properties).map(([propName, prop]) => [
+                    propName,
+                    {
+                        type: prop.type || 'string', // Ensure type is present
+                        ...prop,
+                        // Remove id field for import format (not part of JsonImportSchema)
+                    },
+                ])),
+                indexes: model.indexes,
+            },
+        ])),
+    };
+    // Generate schema ID if missing
+    if (!schemaFile.id) {
+        schemaFile.id = main_cjs.generateId();
+        logger$d('Generated schema ID for schema:', schemaFile.id);
+    }
+    // Extract schemaFileIds from JSON file and generate missing ones BEFORE creating models
+    // This ensures Model instances are created with correct IDs
+    const modelFileIds = new Map();
+    const propertyFileIds = new Map();
+    for (const [modelName, model] of Object.entries(schemaFile.models)) {
+        // Generate model ID if missing
+        if (!model.id) {
+            model.id = main_cjs.generateId();
+            logger$d(`Generated model ID for ${modelName}:`, model.id);
+        }
+        modelFileIds.set(modelName, model.id);
+        const propIds = new Map();
+        for (const [propName, prop] of Object.entries(model.properties)) {
+            // Generate property ID if missing
+            if (!prop.id) {
+                prop.id = main_cjs.generateId();
+                logger$d(`Generated property ID for ${modelName}.${propName}:`, prop.id);
+            }
+            propIds.set(propName, prop.id);
+        }
+        if (propIds.size > 0) {
+            propertyFileIds.set(modelName, propIds);
+        }
+    }
+    // Convert JSON models to Model classes, passing modelFileIds and propertyFileIds so Model instances use correct IDs
+    const modelDefinitions = await main_cjs.createModelsFromJson(importData, modelFileIds, propertyFileIds);
+    // Convert schema file metadata to schema input for database
+    const schemaInput = {
+        name: schemaName,
+        version,
+        schemaFileId: schemaFile.id || null,
+        schemaData: null,
+        isDraft: false,
+        isEdited: false,
+        createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
+        updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
+    };
+    // Use dynamic import to break circular dependency
+    const { addSchemaToDb, addModelsToDb } = await Promise.resolve().then(function () { return require('./index-BeKPbbk0.js'); }).then(function (n) { return n.db; });
+    // Add schema to database with schemaFileId
+    const schemaRecord = await addSchemaToDb(schemaInput, schemaFile.id);
+    // Add models to database with model renames handled and schemaFileIds
+    await addModelsToDb(modelDefinitions, schemaRecord, modelRenames, {
+        schemaFileId: schemaFile.id,
+        modelFileIds,
+        propertyFileIds,
+    });
+    // Models are now Model instances, no registration needed
+    // They should be created via Model.create() and are accessible via Model static methods
+    for (const [modelName] of Object.entries(modelDefinitions)) {
+        logger$d('loadSchemaWithRenames - model available:', modelName);
+    }
+    return schemaFilePath;
+}
 
 const logger$c = debug('seedSdk:schema:actors:loadOrCreateSchema');
 /**
@@ -48,14 +398,13 @@ const getModelIdsForSchema$1 = async (schemaId) => {
         return [];
     }
     try {
-        const { modelSchemas, models: modelsTable } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.schema; });
         const modelRecords = await db
             .select({
-            modelFileId: modelsTable.schemaFileId,
+            modelFileId: main_cjs.models.schemaFileId,
         })
-            .from(modelSchemas)
-            .innerJoin(modelsTable, drizzleOrm.eq(modelSchemas.modelId, modelsTable.id))
-            .where(drizzleOrm.eq(modelSchemas.schemaId, schemaId));
+            .from(main_cjs.modelSchemas)
+            .innerJoin(main_cjs.models, drizzleOrm.eq(main_cjs.modelSchemas.modelId, main_cjs.models.id))
+            .where(drizzleOrm.eq(main_cjs.modelSchemas.schemaId, schemaId));
         const modelIds = modelRecords
             .map((row) => row.modelFileId)
             .filter((id) => id !== null && id !== undefined);
@@ -77,7 +426,7 @@ const createModelInstances$2 = async (modelIds) => {
         return;
     }
     try {
-        const { Model } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.Model$1; });
+        const { Model } = await Promise.resolve().then(function () { return require('./index-BeKPbbk0.js'); }).then(function (n) { return n.Model$1; });
         // Create instances for all model IDs in parallel
         // Model.createById() will check cache first, then query DB and create if needed
         const createPromises = modelIds.map(async (modelFileId) => {
@@ -117,13 +466,11 @@ const verifyPropertiesPersisted = async (modelId, modelName, maxRetries = 10, re
     if (!db) {
         throw new Error('Database not available for property verification');
     }
-    const { properties: propertiesTable } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.ModelSchema; });
-    const { eq } = await import('drizzle-orm');
     for (let attempt = 0; attempt < maxRetries; attempt++) {
         const props = await db
             .select()
-            .from(propertiesTable)
-            .where(eq(propertiesTable.modelId, modelId))
+            .from(main_cjs.properties)
+            .where(drizzleOrm.eq(main_cjs.properties.modelId, modelId))
             .limit(1);
         if (props.length > 0) {
             logger$c(`Verified properties exist for model "${modelName}" (modelId: ${modelId}) after ${attempt + 1} attempt(s)`);
@@ -185,15 +532,14 @@ const getSchemaFilePath$1 = (name, version, schemaFileId) => {
 const loadOrCreateSchema = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const _loadOrCreateSchema = async () => {
         const { schemaName } = context;
-        // Check if this is an internal SDK schema (should not create files in app directory)
-        const { isInternalSchema, SEED_PROTOCOL_SCHEMA_NAME } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.constants$1; });
-        const isInternal = isInternalSchema(schemaName);
-        if (isInternal && schemaName === SEED_PROTOCOL_SCHEMA_NAME) {
+        // Check if this is an internal SDK schema (should not create files in app directory) — use static import so consumer bundles resolve correctly
+        const isInternal = main_cjs.isInternalSchema(schemaName);
+        if (isInternal && schemaName === main_cjs.SEED_PROTOCOL_SCHEMA_NAME) {
             // For Seed Protocol, always load from internal file, never create new
             logger$c(`Loading internal Seed Protocol schema from SDK`);
             console.log('[loadOrCreateSchema] Loading internal Seed Protocol schema from SDK');
             try {
-                const internalSchema = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
+                const internalSchema = await Promise.resolve().then(function () { return require('./index-BeKPbbk0.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
                 const schemaFile = internalSchema.default;
                 console.log('[loadOrCreateSchema] Loaded schema file, models count:', Object.keys(schemaFile.models || {}).length);
                 // Check if it exists in database, if not, add it
@@ -218,8 +564,6 @@ const loadOrCreateSchema = xstate.fromCallback(({ sendBack, input: { context } }
                         logger$c(`Added Seed Protocol schema to database`);
                         // Also add models and properties to database
                         // Convert to JsonImportSchema format for processing
-                        const { createModelsFromJson } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.json; });
-                        const { addModelsToDb } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.db; });
                         const importData = {
                             name: schemaName,
                             models: Object.fromEntries(Object.entries(schemaFile.models || {}).map(([modelName, model]) => [
@@ -297,10 +641,10 @@ const loadOrCreateSchema = xstate.fromCallback(({ sendBack, input: { context } }
                             }
                         }
                         // Convert JSON models to Model classes, passing modelFileIds and propertyFileIds so Model instances use correct IDs
-                        const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds);
+                        const modelDefinitions = await main_cjs.createModelsFromJson(importData, modelFileIds, propertyFileIds);
                         // Add models to database and link them to the schema with schemaFileIds
                         if (Object.keys(modelDefinitions).length > 0 && schemaRecord) {
-                            await addModelsToDb(modelDefinitions, schemaRecord, undefined, {
+                            await main_cjs.addModelsToDb(modelDefinitions, schemaRecord, undefined, {
                                 schemaFileId: schemaFile.id,
                                 modelFileIds,
                                 propertyFileIds,
@@ -308,16 +652,14 @@ const loadOrCreateSchema = xstate.fromCallback(({ sendBack, input: { context } }
                             logger$c(`Added ${Object.keys(modelDefinitions).length} models and their properties to database for Seed Protocol schema`);
                             // Verify properties are persisted (important for browser environments)
                             // Query the database to get model IDs that were just created
-                            const { modelSchemas } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.ModelSchemaSchema; });
-                            const { models: modelsTable } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.ModelSchema; });
                             const modelLinks = await db
                                 .select({
-                                modelId: modelSchemas.modelId,
-                                modelName: modelsTable.name,
+                                modelId: main_cjs.modelSchemas.modelId,
+                                modelName: main_cjs.models.name,
                             })
-                                .from(modelSchemas)
-                                .innerJoin(modelsTable, drizzleOrm.eq(modelSchemas.modelId, modelsTable.id))
-                                .where(drizzleOrm.eq(modelSchemas.schemaId, schemaRecord.id));
+                                .from(main_cjs.modelSchemas)
+                                .innerJoin(main_cjs.models, drizzleOrm.eq(main_cjs.modelSchemas.modelId, main_cjs.models.id))
+                                .where(drizzleOrm.eq(main_cjs.modelSchemas.schemaId, schemaRecord.id));
                             // Verify properties for at least one model (Seed model if available)
                             const seedModelLink = modelLinks.find((link) => link.modelName === 'Seed');
                             if (seedModelLink && seedModelLink.modelId) {
@@ -333,18 +675,15 @@ const loadOrCreateSchema = xstate.fromCallback(({ sendBack, input: { context } }
                         // Schema exists, but always ensure models/properties are in database
                         // This handles the case where schema was added but models weren't (from previous code)
                         // or where models were added but properties weren't
-                        const { modelSchemas } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.ModelSchemaSchema; });
-                        const { models: modelsTable } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.ModelSchema; });
-                        const { properties: propertiesTable } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.ModelSchema; });
                         // Check if models are linked to the schema
                         const modelLinks = await db
                             .select({
-                            modelId: modelSchemas.modelId,
-                            modelName: modelsTable.name,
+                            modelId: main_cjs.modelSchemas.modelId,
+                            modelName: main_cjs.models.name,
                         })
-                            .from(modelSchemas)
-                            .innerJoin(modelsTable, drizzleOrm.eq(modelSchemas.modelId, modelsTable.id))
-                            .where(drizzleOrm.eq(modelSchemas.schemaId, schemaRecord.id));
+                            .from(main_cjs.modelSchemas)
+                            .innerJoin(main_cjs.models, drizzleOrm.eq(main_cjs.modelSchemas.modelId, main_cjs.models.id))
+                            .where(drizzleOrm.eq(main_cjs.modelSchemas.schemaId, schemaRecord.id));
                         // Check if we have all expected models
                         const expectedModelNames = Object.keys(schemaFile.models || {});
                         const linkedModelNames = modelLinks
@@ -359,8 +698,8 @@ const loadOrCreateSchema = xstate.fromCallback(({ sendBack, input: { context } }
                                 if (link.modelId) {
                                     const props = await db
                                         .select()
-                                        .from(propertiesTable)
-                                        .where(drizzleOrm.eq(propertiesTable.modelId, link.modelId))
+                                        .from(main_cjs.properties)
+                                        .where(drizzleOrm.eq(main_cjs.properties.modelId, link.modelId))
                                         .limit(1);
                                     if (props.length === 0) {
                                         missingProperties = true;
@@ -374,8 +713,6 @@ const loadOrCreateSchema = xstate.fromCallback(({ sendBack, input: { context } }
                         if (missingModels.length > 0 || missingProperties || modelLinks.length === 0) {
                             logger$c(`Seed Protocol schema exists but models/properties incomplete (missing models: ${missingModels.length}, missing properties: ${missingProperties}), adding them now`);
                             console.log(`[loadOrCreateSchema] Adding models/properties: missingModels=${missingModels.length}, missingProperties=${missingProperties}, modelLinks=${modelLinks.length}`);
-                            const { createModelsFromJson } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.json; });
-                            const { addModelsToDb } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.db; });
                             // Convert SchemaFileFormat to JsonImportSchema format
                             // Schema format: { dataType, ref, refValueType, storageType, localStorageDir, filenameSuffix }
                             // JSON import format: { type, model, items, storage: { type, path, extension } }
@@ -449,7 +786,7 @@ const loadOrCreateSchema = xstate.fromCallback(({ sendBack, input: { context } }
                                 }
                             }
                             // Convert JSON models to Model classes, passing modelFileIds and propertyFileIds so Model instances use correct IDs
-                            const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds);
+                            const modelDefinitions = await main_cjs.createModelsFromJson(importData, modelFileIds, propertyFileIds);
                             console.log(`[loadOrCreateSchema] createModelsFromJson returned ${Object.keys(modelDefinitions).length} models: ${Object.keys(modelDefinitions).join(', ')}`);
                             console.log(`[loadOrCreateSchema] Expected ${expectedModelNames.length} models from schema file: ${expectedModelNames.join(', ')}`);
                             // Verify all expected models are in modelDefinitions
@@ -459,7 +796,7 @@ const loadOrCreateSchema = xstate.fromCallback(({ sendBack, input: { context } }
                             }
                             if (Object.keys(modelDefinitions).length > 0) {
                                 console.log(`[loadOrCreateSchema] Calling addModelsToDb with ${Object.keys(modelDefinitions).length} models: ${Object.keys(modelDefinitions).join(', ')}`);
-                                await addModelsToDb(modelDefinitions, schemaRecord, undefined, {
+                                await main_cjs.addModelsToDb(modelDefinitions, schemaRecord, undefined, {
                                     schemaFileId: schemaFile.id,
                                     modelFileIds,
                                     propertyFileIds,
@@ -478,12 +815,12 @@ const loadOrCreateSchema = xstate.fromCallback(({ sendBack, input: { context } }
                                 for (let attempt = 0; attempt < maxRetries; attempt++) {
                                     updatedModelLinks = await db
                                         .select({
-                                        modelId: modelSchemas.modelId,
-                                        modelName: modelsTable.name,
+                                        modelId: main_cjs.modelSchemas.modelId,
+                                        modelName: main_cjs.models.name,
                                     })
-                                        .from(modelSchemas)
-                                        .innerJoin(modelsTable, drizzleOrm.eq(modelSchemas.modelId, modelsTable.id))
-                                        .where(drizzleOrm.eq(modelSchemas.schemaId, schemaRecord.id));
+                                        .from(main_cjs.modelSchemas)
+                                        .innerJoin(main_cjs.models, drizzleOrm.eq(main_cjs.modelSchemas.modelId, main_cjs.models.id))
+                                        .where(drizzleOrm.eq(main_cjs.modelSchemas.schemaId, schemaRecord.id));
                                     const linkedModelNames = updatedModelLinks
                                         .map((link) => link.modelName)
                                         .filter((n) => n !== null);
@@ -702,7 +1039,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-BmIVfqGN.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
+                            const internalSchema = await Promise.resolve().then(function () { return require('./index-BeKPbbk0.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
                             const internalSchemaFile = internalSchema.default;
                             mergedModels = { ...(internalSchemaFile.models || {}) };
                             logger$c(`Populated models for seed-protocol schema from internal file`);
@@ -897,7 +1234,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-BmIVfqGN.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
+                            const internalSchema = await Promise.resolve().then(function () { return require('./index-BeKPbbk0.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
                             const internalSchemaFile = internalSchema.default;
                             mergedModels = { ...(internalSchemaFile.models || {}) };
                             logger$c(`Populated models for seed-protocol schema from internal file`);
@@ -969,7 +1306,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-BmIVfqGN.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
+                                const internalSchema = await Promise.resolve().then(function () { return require('./index-BeKPbbk0.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
                                 const internalSchemaFile = internalSchema.default;
                                 mergedModels = { ...(internalSchemaFile.models || {}) };
                                 logger$c(`Populated models for seed-protocol schema from internal file`);
@@ -1038,7 +1375,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-BmIVfqGN.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
+                        const internalSchema = await Promise.resolve().then(function () { return require('./index-BeKPbbk0.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
                         const schemaFile = internalSchema.default;
                         logger$c(`Found seed-protocol schema in internal file (schemaData missing, using internal schema)`);
                         // Update database with schemaData for future loads
@@ -1147,7 +1484,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-BmIVfqGN.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
+                    const internalSchema = await Promise.resolve().then(function () { return require('./index-BeKPbbk0.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
                     const internalSchemaFile = internalSchema.default;
                     mergedModels = { ...(internalSchemaFile.models || {}) };
                     logger$c(`Populated models for seed-protocol schema from internal file`);
@@ -1463,18 +1800,15 @@ const addModelsMachine = xstate.setup({
         }),
         createModelInstances: xstate.fromCallback(({ sendBack, input }) => {
             const _createInstances = async () => {
-                const { Schema } = await Promise.resolve().then(function () { return Schema$1; });
-                const { BaseDb } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.BaseDb$1; });
-                const { models: modelsTable } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.ModelSchema; });
-                const { eq } = await import('drizzle-orm');
-                const { generateId } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.index; });
                 const debug = (await import('debug')).default;
                 const logger = debug('seedSdk:schema:addModels:createInstances');
+                const { Schema: SchemaClass, schemaInstanceState } = await Promise.resolve().then(function () { return Schema$1; });
                 const schemaName = input.schemaContext.metadata?.name || input.schemaContext.schemaName;
-                const schemaInstance = Schema.create(schemaName);
+                const schemaInstance = SchemaClass.create(schemaName, {
+                    waitForReady: false,
+                });
                 const modelInstances = new Map();
                 // Get instance state to store model instances
-                const { schemaInstanceState } = await Promise.resolve().then(function () { return Schema$1; });
                 const instanceState = schemaInstanceState.get(schemaInstance);
                 if (!instanceState) {
                     throw new Error('Schema instance state not found');
@@ -1485,12 +1819,12 @@ const addModelsMachine = xstate.setup({
                         // Look up modelFileId from database BEFORE creating the Model instance
                         let modelFileId = undefined;
                         try {
-                            const db = BaseDb.getAppDb();
+                            const db = main_cjs.BaseDb.getAppDb();
                             if (db) {
                                 const dbModels = await db
                                     .select()
-                                    .from(modelsTable)
-                                    .where(eq(modelsTable.name, modelName))
+                                    .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;
@@ -1503,12 +1837,15 @@ const addModelsMachine = xstate.setup({
                         }
                         // If not found in database, generate a new modelFileId for new models
                         if (!modelFileId) {
-                            modelFileId = generateId();
+                            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 });
+                        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)
@@ -1689,11 +2026,6 @@ const addModelsMachine = xstate.setup({
             const _persist = async () => {
                 const debug = (await import('debug')).default;
                 const logger = debug('seedSdk:schema:addModels:persist');
-                const { createModelFromJson } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.json; });
-                const { addModelsToDb } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.db; });
-                const { BaseDb } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.BaseDb$1; });
-                const { schemas: schemasTable } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.SchemaSchema; });
-                const { eq } = await import('drizzle-orm');
                 // Only process in browser environment where store is available
                 if (typeof window === 'undefined') {
                     logger('Not in browser environment, skipping store update');
@@ -1705,7 +2037,7 @@ const addModelsMachine = xstate.setup({
                 }
                 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();
+                const db = main_cjs.BaseDb.getAppDb();
                 if (!db) {
                     logger('Database not found, skipping model store update');
                     sendBack({
@@ -1729,8 +2061,8 @@ const addModelsMachine = xstate.setup({
                         logger(`Looking up schema by schemaFileId: ${schemaFileId} (attempt ${attempt + 1})`);
                         const schemasById = await db
                             .select()
-                            .from(schemasTable)
-                            .where(eq(schemasTable.schemaFileId, schemaFileId))
+                            .from(main_cjs.schemas)
+                            .where(drizzleOrm.eq(main_cjs.schemas.schemaFileId, schemaFileId))
                             .limit(1);
                         if (schemasById.length > 0) {
                             schemaRecord = schemasById[0];
@@ -1746,12 +2078,11 @@ const addModelsMachine = xstate.setup({
                     // 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 { desc } = await import('drizzle-orm');
                         const schemasByName = await db
                             .select()
-                            .from(schemasTable)
-                            .where(eq(schemasTable.name, schemaName))
-                            .orderBy(desc(schemasTable.isDraft), desc(schemasTable.version))
+                            .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
@@ -1813,14 +2144,14 @@ const addModelsMachine = xstate.setup({
                         properties: convertedProperties,
                     };
                     // Create Model instance
-                    const ModelClass = await createModelFromJson(modelName, jsonModelDef, schemaName);
+                    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 addModelsToDb(modelDefinitions, schemaRecord, undefined, {
+                    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,
                     });
@@ -2007,14 +2338,13 @@ const getModelIdsForSchema = async (schemaId) => {
         return [];
     }
     try {
-        const { modelSchemas, models: modelsTable } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.schema; });
         const modelRecords = await db
             .select({
-            modelFileId: modelsTable.schemaFileId,
+            modelFileId: main_cjs.models.schemaFileId,
         })
-            .from(modelSchemas)
-            .innerJoin(modelsTable, drizzleOrm.eq(modelSchemas.modelId, modelsTable.id))
-            .where(drizzleOrm.eq(modelSchemas.schemaId, schemaId));
+            .from(main_cjs.modelSchemas)
+            .innerJoin(main_cjs.models, drizzleOrm.eq(main_cjs.modelSchemas.modelId, main_cjs.models.id))
+            .where(drizzleOrm.eq(main_cjs.modelSchemas.schemaId, schemaId));
         const modelIds = modelRecords
             .map((row) => row.modelFileId)
             .filter((id) => id !== null && id !== undefined);
@@ -2051,7 +2381,12 @@ const createModelInstances$1 = async (modelIds) => {
         return;
     }
     try {
-        const { Model } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.Model$1; });
+        const mod = await Promise.resolve().then(function () { return require('./index-BeKPbbk0.js'); }).then(function (n) { return n.Model$1; });
+        const Model = mod?.Model ?? mod?.default;
+        if (!Model) {
+            logger$b('Model not available from dynamic import');
+            return;
+        }
         const createPromises = modelIds.map(async (modelFileId) => {
             try {
                 const model = await Model.createById(modelFileId);
@@ -2086,13 +2421,12 @@ const checkExistingSchema = xstate.fromCallback(({ sendBack, input: { context }
             });
             return;
         }
-        // Check if this is an internal SDK schema (Seed Protocol)
-        const { isInternalSchema, SEED_PROTOCOL_SCHEMA_NAME } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.constants$1; });
-        const isInternal = isInternalSchema(schemaName);
-        if (isInternal && schemaName === SEED_PROTOCOL_SCHEMA_NAME) {
+        // Check if this is an internal SDK schema (Seed Protocol) — use static import so consumer bundles resolve correctly
+        const isInternal = main_cjs.isInternalSchema(schemaName);
+        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-BmIVfqGN.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
+                const internalSchema = await Promise.resolve().then(function () { return require('./index-BeKPbbk0.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
                 const schemaFile = internalSchema.default;
                 if (db && schemaFile.id) {
                     const existing = await db
@@ -2443,15 +2777,14 @@ const writeSchemaToDb = xstate.fromCallback(({ sendBack, input }) => {
     const _write = async () => {
         const { schemaName, schemaFile, existingDbSchema } = input;
         try {
-            // Check if this is an internal SDK schema (Seed Protocol)
-            const { isInternalSchema, SEED_PROTOCOL_SCHEMA_NAME } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.constants$1; });
-            const isInternal = isInternalSchema(schemaName);
+            // Check if this is an internal SDK schema (Seed Protocol) — use static import so consumer bundles resolve correctly
+            const isInternal = main_cjs.isInternalSchema(schemaName);
             let finalSchema;
             let schemaRecord;
-            if (isInternal && schemaName === SEED_PROTOCOL_SCHEMA_NAME) {
+            if (isInternal && schemaName === main_cjs.SEED_PROTOCOL_SCHEMA_NAME) {
                 // For Seed Protocol, load from internal file
                 logger$a(`Loading internal Seed Protocol schema from SDK`);
-                const internalSchema = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
+                const internalSchema = await Promise.resolve().then(function () { return require('./index-BeKPbbk0.js'); }).then(function (n) { return n.SEEDPROTOCOL_Seed_Protocol_v1; });
                 finalSchema = internalSchema.default;
                 const db = main_cjs.BaseDb.getAppDb();
                 if (db && finalSchema.id) {
@@ -2647,23 +2980,19 @@ const writeModelsToDb = xstate.fromCallback(({ sendBack, input }) => {
         const { schema, schemaRecord, schemaName } = input;
         try {
             // Check if models already exist in database
-            const { BaseDb } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.BaseDb$1; });
-            const { modelSchemas } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.ModelSchemaSchema; });
-            const { models: modelsTable } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.ModelSchema; });
-            const { eq } = await import('drizzle-orm');
-            const db = BaseDb.getAppDb();
+            const db = main_cjs.BaseDb.getAppDb();
             if (!db) {
                 throw new Error('Database not available');
             }
             // Check if models are linked to the schema
             const modelLinks = await db
                 .select({
-                modelId: modelSchemas.modelId,
-                modelName: modelsTable.name,
+                modelId: main_cjs.modelSchemas.modelId,
+                modelName: main_cjs.models.name,
             })
-                .from(modelSchemas)
-                .innerJoin(modelsTable, eq(modelSchemas.modelId, modelsTable.id))
-                .where(eq(modelSchemas.schemaId, schemaRecord.id));
+                .from(main_cjs.modelSchemas)
+                .innerJoin(main_cjs.models, drizzleOrm.eq(main_cjs.modelSchemas.modelId, main_cjs.models.id))
+                .where(drizzleOrm.eq(main_cjs.modelSchemas.schemaId, schemaRecord.id));
             // Check if we have all expected models
             const expectedModelNames = Object.keys(schema.models || {});
             const linkedModelNames = modelLinks
@@ -2678,9 +3007,9 @@ const writeModelsToDb = xstate.fromCallback(({ sendBack, input }) => {
                 for (const link of modelLinks) {
                     if (link.modelId) {
                         const modelRecord = await db
-                            .select({ schemaFileId: modelsTable.schemaFileId })
-                            .from(modelsTable)
-                            .where(eq(modelsTable.id, link.modelId))
+                            .select({ schemaFileId: main_cjs.models.schemaFileId })
+                            .from(main_cjs.models)
+                            .where(drizzleOrm.eq(main_cjs.models.id, link.modelId))
                             .limit(1);
                         if (modelRecord.length > 0 && modelRecord[0].schemaFileId) {
                             modelFileIds.push(modelRecord[0].schemaFileId);
@@ -2693,13 +3022,10 @@ const writeModelsToDb = xstate.fromCallback(({ sendBack, input }) => {
                 });
                 return;
             }
-            // Convert SchemaFileFormat to JsonImportSchema format
-            const { createModelsFromJson } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.json; });
-            // Check if this is Seed Protocol schema (has different format)
-            const { isInternalSchema, SEED_PROTOCOL_SCHEMA_NAME } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.constants$1; });
-            const isInternal = isInternalSchema(schemaName);
+            // Check if this is Seed Protocol schema (has different format) — use static import so consumer bundles resolve correctly
+            const isInternal = main_cjs.isInternalSchema(schemaName);
             let importData;
-            if (isInternal && schemaName === SEED_PROTOCOL_SCHEMA_NAME) {
+            if (isInternal && schemaName === main_cjs.SEED_PROTOCOL_SCHEMA_NAME) {
                 // Convert Seed Protocol schema format to JSON import format
                 importData = {
                     name: schemaName,
@@ -2782,7 +3108,7 @@ const writeModelsToDb = xstate.fromCallback(({ sendBack, input }) => {
                 }
             }
             // Convert JSON models to Model classes
-            const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds);
+            const modelDefinitions = await main_cjs.createModelsFromJson(importData, modelFileIds, propertyFileIds);
             // Add models to database
             if (Object.keys(modelDefinitions).length > 0) {
                 await main_cjs.addModelsToDb(modelDefinitions, schemaRecord, undefined, {
@@ -2926,7 +3252,7 @@ const createModelInstances = xstate.fromCallback(({ sendBack, input }) => {
             return;
         }
         try {
-            const { Model } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.Model$1; });
+            const { Model } = await Promise.resolve().then(function () { return require('./index-BeKPbbk0.js'); }).then(function (n) { return n.Model$1; });
             // Create instances for all model IDs in parallel
             // Model.createById() will check cache first, then query DB and create if needed
             const createPromises = modelIds.map(async (modelFileId) => {
@@ -3011,7 +3337,7 @@ const verifyModelInstancesInCache = xstate.fromCallback(({ sendBack, input }) =>
         }
         try {
             const result = await verifyWithRetry$2(async () => {
-                const { Model } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.Model$1; });
+                const { Model } = await Promise.resolve().then(function () { return require('./index-BeKPbbk0.js'); }).then(function (n) { return n.Model$1; });
                 // Check each model ID in the cache
                 const verifiedInstances = [];
                 const missingIds = [];
@@ -3067,10 +3393,9 @@ const writePropertiesToDb = xstate.fromCallback(({ sendBack, input }) => {
     const _write = async () => {
         const { modelIds } = input;
         try {
-            const { BaseDb } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.BaseDb$1; });
-            const { models: modelsTable, properties: propertiesTable } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.ModelSchema; });
+            const { models: modelsTable, properties: propertiesTable } = await Promise.resolve().then(function () { return require('./index-BeKPbbk0.js'); }).then(function (n) { return n.ModelSchema; });
             const { eq } = await import('drizzle-orm');
-            const db = BaseDb.getAppDb();
+            const db = main_cjs.BaseDb.getAppDb();
             if (!db) {
                 throw new Error('Database not available');
             }
@@ -3254,8 +3579,15 @@ const createPropertyInstances = xstate.fromCallback(({ sendBack, input }) => {
             return;
         }
         try {
-            const { ModelProperty } = await Promise.resolve().then(function () { return require('./ModelProperty-MkN5Rmx7.js'); }).then(function (n) { return n.ModelProperty$1; });
-            const { Model } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.Model$1; });
+            const modProp = await Promise.resolve().then(function () { return require('./ModelProperty-BeJvgKMw.js'); });
+            const ModelProperty = modProp?.ModelProperty ?? modProp?.default;
+            const modModel = await Promise.resolve().then(function () { return require('./index-BeKPbbk0.js'); }).then(function (n) { return n.Model$1; });
+            const Model = modModel?.Model ?? modModel?.default;
+            if (!ModelProperty || !Model) {
+                logger$2('ModelProperty or Model not available from dynamic import');
+                sendBack({ type: 'instancesCreated', count: 0 });
+                return;
+            }
             // Properties are typically loaded when Model instances are loaded
             // But we can verify they exist by checking Model instances
             let successCount = 0;
@@ -3354,7 +3686,11 @@ const verifyPropertyInstancesInCache = xstate.fromCallback(({ sendBack, input })
         }
         try {
             const result = await verifyWithRetry(async () => {
-                const { ModelProperty } = await Promise.resolve().then(function () { return require('./ModelProperty-MkN5Rmx7.js'); }).then(function (n) { return n.ModelProperty$1; });
+                const mod = await Promise.resolve().then(function () { return require('./ModelProperty-BeJvgKMw.js'); });
+                const ModelProperty = mod?.ModelProperty ?? mod?.default;
+                if (!ModelProperty) {
+                    throw new Error('ModelProperty not available from dynamic import');
+                }
                 // Check each property ID in the cache
                 const verifiedInstances = [];
                 const missingIds = [];
@@ -3514,6 +3850,23 @@ const schemaMachine = xstate.setup({
                 return newContext;
             }),
         },
+        destroyStarted: {
+            actions: xstate.assign({ _destroyInProgress: true, _destroyError: null }),
+        },
+        destroyDone: {
+            actions: xstate.assign({ _destroyInProgress: false }),
+        },
+        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: {
@@ -4107,10 +4460,12 @@ class Schema {
         });
         // Note: Property getters/setters are now handled by the Proxy in create()
     }
-    static create(schemaName) {
+    static create(schemaName, options) {
         if (!schemaName) {
             throw new Error('Schema name is required');
         }
+        const waitForReady = options?.waitForReady !== false;
+        const readyTimeout = options?.readyTimeout ?? 5000;
         // First, check if we have an instance cached by name
         if (this.instanceCacheByName.has(schemaName)) {
             const { instance, refCount } = this.instanceCacheByName.get(schemaName);
@@ -4118,7 +4473,9 @@ class Schema {
                 instance,
                 refCount: refCount + 1,
             });
-            return instance;
+            if (!waitForReady)
+                return instance;
+            return main_cjs.waitForEntityIdle(instance, { timeout: readyTimeout }).then(() => instance);
         }
         // Create new instance
         const newInstance = new this(schemaName);
@@ -4441,9 +4798,10 @@ class Schema {
             instance: proxiedInstance,
             refCount: 1,
         });
-        // The proxiedInstance is Proxied<Schema> which preserves all methods
-        // TypeScript recognizes this as Schema with all methods intact
-        return proxiedInstance;
+        const schema = proxiedInstance;
+        if (!waitForReady)
+            return schema;
+        return main_cjs.waitForEntityIdle(schema, { timeout: readyTimeout }).then(() => schema);
     }
     /**
      * Update the cache to use schemaFileId as the key instead of schemaName
@@ -4480,7 +4838,7 @@ class Schema {
             });
             return instance;
         }
-        return undefined;
+        return null;
     }
     /**
      * Clear all cached Schema instances.
@@ -4527,17 +4885,15 @@ class Schema {
             return cachedInstance;
         }
         // Query database to get schema name from ID
-        const { BaseDb } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.BaseDb$1; });
-        const { schemas: schemasTable } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.SchemaSchema; });
-        const db = BaseDb.getAppDb();
+        const db = main_cjs.BaseDb.getAppDb();
         if (!db) {
             throw new Error('Database not available');
         }
         const dbSchemas = await db
             .select()
-            .from(schemasTable)
-            .where(drizzleOrm.eq(schemasTable.schemaFileId, schemaFileId))
-            .orderBy(drizzleOrm.desc(schemasTable.version))
+            .from(main_cjs.schemas)
+            .where(drizzleOrm.eq(main_cjs.schemas.schemaFileId, schemaFileId))
+            .orderBy(drizzleOrm.desc(main_cjs.schemas.version))
             .limit(1);
         if (dbSchemas.length === 0) {
             throw new Error(`Schema with ID "${schemaFileId}" not found in database`);
@@ -4584,7 +4940,7 @@ class Schema {
      * @returns Array of Schema instances
      */
     static async all(options = {}) {
-        const { includeAllVersions = false, includeInternal = false } = options;
+        const { includeAllVersions = false, includeInternal = false, waitForReady = false, readyTimeout = 5000, } = options;
         try {
             // Use loadAllSchemasFromDb as single source of truth
             // This intelligently merges database and file data, including drafts
@@ -4667,13 +5023,18 @@ class Schema {
                     }
                     catch (error) {
                         // Fallback to creating by name if createById fails
-                        schemaInstances.push(this.create(schemaName));
+                        schemaInstances.push(this.create(schemaName, { waitForReady: false }));
                     }
                 }
                 else {
-                    schemaInstances.push(this.create(schemaName));
+                    schemaInstances.push(this.create(schemaName, { waitForReady: false }));
                 }
             }
+            if (waitForReady && schemaInstances.length > 0) {
+                await Promise.all(schemaInstances.map((s) => main_cjs.waitForEntityIdle(s, {
+                    timeout: readyTimeout,
+                })));
+            }
             return schemaInstances;
         }
         catch (error) {
@@ -4711,7 +5072,12 @@ class Schema {
             // Create Schema instances for each unique schema name
             const schemaInstances = [];
             for (const schemaName of uniqueSchemaNames) {
-                schemaInstances.push(this.create(schemaName));
+                schemaInstances.push(this.create(schemaName, { waitForReady: false }));
+            }
+            if (waitForReady && schemaInstances.length > 0) {
+                await Promise.all(schemaInstances.map((s) => main_cjs.waitForEntityIdle(s, {
+                    timeout: readyTimeout,
+                })));
             }
             return schemaInstances;
         }
@@ -4754,6 +5120,7 @@ class Schema {
      */
     get models() {
         const context = this._getSnapshotContext();
+        const schemaName = context.schemaName;
         // Get model IDs from service context (reactive state)
         const liveQueryIds = context._liveQueryModelIds || [];
         // Get pending model IDs (not yet in DB)
@@ -4762,15 +5129,27 @@ class Schema {
         const pendingIds = [];
         // Combine and deduplicate
         const allModelIds = [...new Set([...liveQueryIds, ...pendingIds])];
-        // Get Model instances from static cache
+        // Get Model instances from static cache (from schema load)
+        const seen = new Set();
         const modelInstances = [];
         for (const modelFileId of allModelIds) {
             const model = main_cjs.Model.getById(modelFileId);
-            if (model) {
+            if (model && modelFileId && !seen.has(modelFileId)) {
                 modelInstances.push(model);
+                seen.add(modelFileId);
+            }
+        }
+        // Include models created at runtime via Model.create() that belong to this schema
+        // (they may not be in _liveQueryModelIds until schema context is updated)
+        if (schemaName) {
+            const cachedForSchema = main_cjs.Model.getCachedInstancesForSchema(schemaName);
+            for (const model of cachedForSchema) {
+                const id = model.id;
+                if (id && !seen.has(id)) {
+                    modelInstances.push(model);
+                    seen.add(id);
+                }
             }
-            // Note: Cannot create models asynchronously in this synchronous getter
-            // Models will be created elsewhere when needed
         }
         // Return a new array reference (snapshot at time of access)
         return [...modelInstances];
@@ -4887,9 +5266,6 @@ class Schema {
             throw new main_cjs.ConflictError(errorMessage, conflictCheck);
         }
         const context = this._getSnapshotContext();
-        const { BaseDb } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.BaseDb$1; });
-        const { schemas: schemasTable } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.SchemaSchema; });
-        const { addSchemaToDb } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.db; });
         if (!context._isDraft || !context._editedProperties || context._editedProperties.size === 0) {
             logger('No changes to save');
             return '';
@@ -4902,7 +5278,7 @@ class Schema {
         }
         logger(`Saving new version for schema ${this.schemaName} with ${context._editedProperties.size} edited properties`);
         // STEP 1: Ensure draft exists in database and update it with current state
-        const db = BaseDb.getAppDb();
+        const db = main_cjs.BaseDb.getAppDb();
         if (!db) {
             throw new Error('Database not found');
         }
@@ -4923,14 +5299,20 @@ class Schema {
             migrations: context.migrations || [],
         };
         // Update draft in database with current state
-        await addSchemaToDb({
+        await main_cjs.addSchemaToDb({
             name: this.schemaName,
             version: currentSchema.version,
             createdAt: new Date(currentSchema.metadata.createdAt).getTime(),
             updatedAt: new Date(currentSchema.metadata.updatedAt).getTime(),
         }, currentSchema.id, JSON.stringify(currentSchema, null, 2), true);
+        const dbSchema = await db
+            .select()
+            .from(main_cjs.schemas)
+            .where(drizzleOrm.eq(main_cjs.schemas.name, this.schemaName))
+            .limit(1);
         // Collect all edited properties and convert them to SchemaPropertyUpdate format
         const propertyUpdates = [];
+        const { ModelProperty } = await Promise.resolve().then(function () { return require('./ModelProperty-BeJvgKMw.js'); });
         for (const propertyKey of context._editedProperties) {
             // Skip schema-level changes (like schema name changes)
             if (propertyKey === 'schema:name') {
@@ -4944,7 +5326,7 @@ class Schema {
             }
             // Get ModelProperty instance from cache
             const cacheKey = `${modelName}:${propertyName}`;
-            const ModelPropertyClass = ModelProperty.ModelProperty;
+            const ModelPropertyClass = ModelProperty;
             const cachedInstance = ModelPropertyClass.instanceCache.get(cacheKey);
             if (!cachedInstance) {
                 logger(`ModelProperty instance not found for ${cacheKey}`);
@@ -4953,29 +5335,48 @@ class Schema {
             const modelProperty = cachedInstance.instance;
             const propertyContext = modelProperty.getService().getSnapshot().context;
             // Convert to SchemaPropertyUpdate
-            const propertyUpdate = await ModelProperty.convertPropertyToSchemaUpdate(propertyContext, modelName, propertyName);
+            const propertyUpdate = await convertPropertyToSchemaUpdate(propertyContext, modelName, propertyName);
             propertyUpdates.push(propertyUpdate);
         }
         if (propertyUpdates.length === 0) {
+            // When only new models were added, _editedProperties contains 'schema:models' and we write the full schema
+            if (context._editedProperties.has('schema:models')) {
+                const newFilePath = await writeFullSchemaNewVersion(this.schemaName, currentSchema);
+                const fileContent = await main_cjs.BaseFileManager.readFileAsString(newFilePath);
+                const publishedSchema = JSON.parse(fileContent);
+                if (dbSchema.length > 0) {
+                    await db
+                        .update(main_cjs.schemas)
+                        .set({
+                        isDraft: false,
+                        isEdited: false,
+                        schemaFileId: publishedSchema.id,
+                        schemaData: JSON.stringify(publishedSchema, null, 2),
+                        version: publishedSchema.version,
+                        updatedAt: new Date(publishedSchema.metadata.updatedAt).getTime(),
+                    })
+                        .where(drizzleOrm.eq(main_cjs.schemas.id, dbSchema[0].id));
+                }
+                this._service.send({
+                    type: 'clearDraft',
+                    _dbUpdatedAt: new Date(publishedSchema.metadata.updatedAt).getTime(),
+                    _dbVersion: publishedSchema.version,
+                });
+                return newFilePath;
+            }
             logger('No valid property updates to save');
             return '';
         }
         // STEP 2: Save to new schema version (writes file)
-        const newFilePath = await ModelProperty.updateModelProperties(this.schemaName, propertyUpdates);
+        const newFilePath = await updateModelProperties(this.schemaName, propertyUpdates);
         // STEP 3: After file is written, update database to mark as published (isDraft = false)
         // Load the file to get the final schema with IDs
-        const { BaseFileManager } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.BaseFileManager$1; });
-        const fileContent = await BaseFileManager.readFileAsString(newFilePath);
+        const fileContent = await main_cjs.BaseFileManager.readFileAsString(newFilePath);
         const publishedSchema = JSON.parse(fileContent);
         // Update database record: set isDraft = false and update schemaFileId
-        const dbSchema = await db
-            .select()
-            .from(schemasTable)
-            .where(drizzleOrm.eq(schemasTable.name, this.schemaName))
-            .limit(1);
         if (dbSchema.length > 0) {
             await db
-                .update(schemasTable)
+                .update(main_cjs.schemas)
                 .set({
                 isDraft: false,
                 isEdited: false, // Clear isEdited flag after saving to file
@@ -4984,11 +5385,11 @@ class Schema {
                 version: publishedSchema.version,
                 updatedAt: new Date(publishedSchema.metadata.updatedAt).getTime(),
             })
-                .where(drizzleOrm.eq(schemasTable.id, dbSchema[0].id));
+                .where(drizzleOrm.eq(main_cjs.schemas.id, dbSchema[0].id));
         }
         else {
             // Create new record if it doesn't exist (shouldn't happen, but safety)
-            await addSchemaToDb({
+            await main_cjs.addSchemaToDb({
                 name: this.schemaName,
                 version: publishedSchema.version,
                 createdAt: new Date(publishedSchema.metadata.createdAt).getTime(),
@@ -5003,11 +5404,10 @@ class Schema {
             _dbVersion: publishedSchema.version,
         });
         // Clear edited flags on all ModelProperty instances and in database
-        const { properties: propertiesTable, models: modelsTable } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.schema; });
         for (const propertyKey of context._editedProperties) {
             const [modelName, propertyName] = propertyKey.split(':');
             const cacheKey = `${modelName}:${propertyName}`;
-            const ModelPropertyClass = ModelProperty.ModelProperty;
+            const ModelPropertyClass = ModelProperty;
             const cachedInstance = ModelPropertyClass.instanceCache.get(cacheKey);
             if (cachedInstance) {
                 const modelProperty = cachedInstance.instance;
@@ -5021,23 +5421,23 @@ class Schema {
                     if (db && modelName && propertyName) {
                         // Find model by name
                         const modelRecords = await db
-                            .select({ id: modelsTable.id })
-                            .from(modelsTable)
-                            .where(drizzleOrm.eq(modelsTable.name, modelName))
+                            .select({ id: main_cjs.models.id })
+                            .from(main_cjs.models)
+                            .where(drizzleOrm.eq(main_cjs.models.name, modelName))
                             .limit(1);
                         if (modelRecords.length > 0) {
                             // Find property by name and modelId
                             const propertyRecords = await db
-                                .select({ id: propertiesTable.id })
-                                .from(propertiesTable)
-                                .where(drizzleOrm.and(drizzleOrm.eq(propertiesTable.name, propertyName), drizzleOrm.eq(propertiesTable.modelId, modelRecords[0].id)))
+                                .select({ id: main_cjs.properties.id })
+                                .from(main_cjs.properties)
+                                .where(drizzleOrm.and(drizzleOrm.eq(main_cjs.properties.name, propertyName), drizzleOrm.eq(main_cjs.properties.modelId, modelRecords[0].id)))
                                 .limit(1);
                             if (propertyRecords.length > 0) {
                                 // Clear isEdited flag in database
                                 await db
-                                    .update(propertiesTable)
+                                    .update(main_cjs.properties)
                                     .set({ isEdited: false })
-                                    .where(drizzleOrm.eq(propertiesTable.id, propertyRecords[0].id));
+                                    .where(drizzleOrm.eq(main_cjs.properties.id, propertyRecords[0].id));
                             }
                         }
                     }
@@ -5051,19 +5451,18 @@ class Schema {
         try {
             if (db && context._dbId) {
                 // Get all models for this schema
-                const { modelSchemas, models: modelsTable } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.schema; });
                 const modelRecords = await db
-                    .select({ id: modelsTable.id })
-                    .from(modelSchemas)
-                    .innerJoin(modelsTable, drizzleOrm.eq(modelSchemas.modelId, modelsTable.id))
-                    .where(drizzleOrm.eq(modelSchemas.schemaId, context._dbId));
+                    .select({ id: main_cjs.models.id })
+                    .from(main_cjs.modelSchemas)
+                    .innerJoin(main_cjs.models, drizzleOrm.eq(main_cjs.modelSchemas.modelId, main_cjs.models.id))
+                    .where(drizzleOrm.eq(main_cjs.modelSchemas.schemaId, context._dbId));
                 // Clear isEdited flag for all models
                 for (const modelRecord of modelRecords) {
                     if (modelRecord.id) {
                         await db
-                            .update(modelsTable)
+                            .update(main_cjs.models)
                             .set({ isEdited: false })
-                            .where(drizzleOrm.eq(modelsTable.id, modelRecord.id));
+                            .where(drizzleOrm.eq(main_cjs.models.id, modelRecord.id));
                     }
                 }
             }
@@ -5166,14 +5565,11 @@ class Schema {
             saveDraftLogger(`Client check: cacheIsStale=${cacheIsStale}, shouldRecheck=${shouldRecheck}, cachedValue=${cachedClientInitialized}, timeSinceCheck=${now - clientCheckTime}ms`);
             if (shouldRecheck) {
                 try {
-                    // Use dynamic import for browser compatibility (require() doesn't work in browsers)
-                    const { getClient } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.ClientManager$1; });
-                    const { ClientManagerState } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.constants; });
-                    const client = getClient();
+                    const client = main_cjs.getClient();
                     const clientSnapshot = client.getService().getSnapshot();
                     // Check if state is IDLE (primary check) - isInitialized is set in entry action so should be true
                     // But we check it as a secondary safeguard
-                    const isIdle = clientSnapshot.value === ClientManagerState.IDLE;
+                    const isIdle = clientSnapshot.value === main_cjs.ClientManagerState.IDLE;
                     const isInitialized = clientSnapshot.context.isInitialized;
                     // If state is IDLE, trust it even if isInitialized isn't set yet (entry action should set it)
                     // This aligns with useIsClientReady which only checks the state value
@@ -5239,11 +5635,7 @@ class Schema {
                     _editedProperties: new Set(),
                 };
             }
-            const { addSchemaToDb } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.db; });
-            const { generateId } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.index; });
-            const { BaseDb } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.BaseDb$1; });
-            const { schemas: schemasTable } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.SchemaSchema; });
-            const db = BaseDb.getAppDb();
+            const db = main_cjs.BaseDb.getAppDb();
             if (!db) {
                 throw new Error('Database not found');
             }
@@ -5262,8 +5654,8 @@ class Schema {
                 logger(`Looking up schema by schemaFileId: ${context.id}`);
                 const schemasById = await db
                     .select()
-                    .from(schemasTable)
-                    .where(drizzleOrm.eq(schemasTable.schemaFileId, context.id)) // id is now the schemaFileId (string)
+                    .from(main_cjs.schemas)
+                    .where(drizzleOrm.eq(main_cjs.schemas.schemaFileId, context.id)) // id is now the schemaFileId (string)
                     .limit(1);
                 if (schemasById.length > 0) {
                     const foundRecord = schemasById[0];
@@ -5283,8 +5675,8 @@ class Schema {
                 logger(`Looking up schema by name "${lookupName}" (oldName: ${oldName}, finalNewName: ${finalNewName})`);
                 const existingSchemas = await db
                     .select()
-                    .from(schemasTable)
-                    .where(drizzleOrm.eq(schemasTable.name, lookupName))
+                    .from(main_cjs.schemas)
+                    .where(drizzleOrm.eq(main_cjs.schemas.name, lookupName))
                     .limit(10); // Get multiple to find drafts
                 logger(`Found ${existingSchemas.length} records with name "${lookupName}"`);
                 // If name changed, prefer draft records; otherwise prefer any record
@@ -5317,7 +5709,7 @@ class Schema {
             }
             // Build current schema state from context
             // Use existing schemaFileId if we found one, otherwise use the one from context, or generate new
-            const schemaFileId = existingSchemaId || context.id || generateId(); // id is now the schemaFileId (string)
+            const schemaFileId = existingSchemaId || context.id || main_cjs.generateId(); // id is now the schemaFileId (string)
             // Build metadata - if name changed, use newName, otherwise use context metadata
             // Always ensure metadata.name matches finalNewName to prevent inconsistencies
             const currentMetadata = context.metadata ? {
@@ -5374,14 +5766,14 @@ class Schema {
                         saveDraftLogger(`Setting schemaFileId to ${finalSchemaFileId} (was null)`);
                     }
                     await db
-                        .update(schemasTable)
+                        .update(main_cjs.schemas)
                         .set(updateData)
-                        .where(drizzleOrm.eq(schemasTable.id, existingSchemaRecord.id));
+                        .where(drizzleOrm.eq(main_cjs.schemas.id, existingSchemaRecord.id));
                     // Verify what was saved by reading it back
                     const verifyRecord = await db
                         .select()
-                        .from(schemasTable)
-                        .where(drizzleOrm.eq(schemasTable.id, existingSchemaRecord.id))
+                        .from(main_cjs.schemas)
+                        .where(drizzleOrm.eq(main_cjs.schemas.id, existingSchemaRecord.id))
                         .limit(1);
                     if (verifyRecord.length > 0 && verifyRecord[0].schemaData) {
                         try {
@@ -5391,15 +5783,15 @@ class Schema {
                                 saveDraftLogger(`ERROR: isDraft is not true after save! Expected true, got ${verifyRecord[0].isDraft}. This will cause the schema to load from file instead of database!`);
                                 // Try to fix it immediately
                                 await db
-                                    .update(schemasTable)
+                                    .update(main_cjs.schemas)
                                     .set({ isDraft: true })
-                                    .where(drizzleOrm.eq(schemasTable.id, existingSchemaRecord.id));
+                                    .where(drizzleOrm.eq(main_cjs.schemas.id, existingSchemaRecord.id));
                                 saveDraftLogger(`Attempted to fix isDraft by setting it to true again`);
                                 // Verify the fix
                                 const fixedRecord = await db
                                     .select()
-                                    .from(schemasTable)
-                                    .where(drizzleOrm.eq(schemasTable.id, existingSchemaRecord.id))
+                                    .from(main_cjs.schemas)
+                                    .where(drizzleOrm.eq(main_cjs.schemas.id, existingSchemaRecord.id))
                                     .limit(1);
                                 if (fixedRecord.length > 0) {
                                     saveDraftLogger(`After fix attempt: isDraft=${fixedRecord[0].isDraft}`);
@@ -5441,8 +5833,8 @@ class Schema {
                     // Try to find by looking for ANY draft with the old name (even if it doesn't match exactly)
                     const allDrafts = await db
                         .select()
-                        .from(schemasTable)
-                        .where(drizzleOrm.eq(schemasTable.name, oldName))
+                        .from(main_cjs.schemas)
+                        .where(drizzleOrm.eq(main_cjs.schemas.name, oldName))
                         .limit(1);
                     if (allDrafts.length > 0 && allDrafts[0].id) {
                         const foundRecord = allDrafts[0];
@@ -5450,7 +5842,7 @@ class Schema {
                         // Update the existing record with the new name
                         // CRITICAL: Ensure schemaFileId matches schema.id
                         await db
-                            .update(schemasTable)
+                            .update(main_cjs.schemas)
                             .set({
                             name: finalNewName,
                             schemaData: JSON.stringify(currentSchema, null, 2),
@@ -5459,7 +5851,7 @@ class Schema {
                             updatedAt: new Date(currentSchema.metadata.updatedAt).getTime(),
                             isDraft: true, // Ensure it's marked as a draft when saving via _saveDraftToDb
                         })
-                            .where(drizzleOrm.eq(schemasTable.id, foundRecord.id));
+                            .where(drizzleOrm.eq(main_cjs.schemas.id, foundRecord.id));
                         // Update context with id (schemaFileId) and conflict detection metadata
                         try {
                             const snapshot = this._service.getSnapshot();
@@ -5495,7 +5887,7 @@ class Schema {
                 throw new Error(`Failed to update schema name: existing record not found or update failed`);
             }
             // Otherwise, use addSchemaToDb which will handle create/update logic (for normal saves, not name changes)
-            await addSchemaToDb({
+            await main_cjs.addSchemaToDb({
                 name: finalNewName,
                 version: currentSchema.version,
                 createdAt: new Date(currentSchema.metadata.createdAt).getTime(),
@@ -5570,6 +5962,68 @@ class Schema {
             }
         }
     }
+    /**
+     * Destroy the schema instance completely: remove from caches, delete from database (cascade),
+     * and stop the service. Uses shared destroy helpers.
+     */
+    async destroy() {
+        const context = this._getSnapshotContext();
+        const schemaFileId = context.id;
+        const schemaName = context.schemaName;
+        main_cjs.clearDestroySubscriptions(this, {
+            instanceState: schemaInstanceState,
+            onUnload: () => schemaInstanceState.delete(this),
+        });
+        const cacheKeys = [];
+        if (schemaFileId)
+            cacheKeys.push(schemaFileId);
+        if (schemaName)
+            cacheKeys.push(schemaName);
+        main_cjs.forceRemoveFromCaches(this, {
+            getCacheKeys: () => cacheKeys,
+            caches: [
+                Schema.instanceCacheById,
+                Schema.instanceCacheByName,
+            ],
+        });
+        await main_cjs.runDestroyLifecycle(this, {
+            getService: (instance) => instance._service,
+            doDestroy: async () => {
+                const db = main_cjs.BaseDb.getAppDb();
+                if (!db || !schemaFileId)
+                    return;
+                const schemaRecords = await db
+                    .select({ id: main_cjs.schemas.id })
+                    .from(main_cjs.schemas)
+                    .where(drizzleOrm.eq(main_cjs.schemas.schemaFileId, schemaFileId));
+                if (schemaRecords.length === 0)
+                    return;
+                const schemaIds = schemaRecords
+                    .map((r) => r.id)
+                    .filter((id) => id != null);
+                if (schemaIds.length === 0)
+                    return;
+                const { inArray } = await import('drizzle-orm');
+                const joinRows = await db
+                    .select({ modelId: main_cjs.modelSchemas.modelId })
+                    .from(main_cjs.modelSchemas)
+                    .where(inArray(main_cjs.modelSchemas.schemaId, schemaIds));
+                const modelIds = [
+                    ...new Set(joinRows
+                        .map((r) => r.modelId)
+                        .filter((id) => id != null)),
+                ];
+                await db.delete(main_cjs.modelSchemas).where(inArray(main_cjs.modelSchemas.schemaId, schemaIds));
+                for (const modelId of modelIds) {
+                    await db.delete(main_cjs.properties).where(drizzleOrm.eq(main_cjs.properties.modelId, modelId));
+                }
+                for (const modelId of modelIds) {
+                    await db.delete(main_cjs.models).where(drizzleOrm.eq(main_cjs.models.id, modelId));
+                }
+                await db.delete(main_cjs.schemas).where(drizzleOrm.eq(main_cjs.schemas.schemaFileId, schemaFileId));
+            },
+        });
+    }
     /**
      * Set up liveQuery subscription to watch for model changes in the database
      * This enables cross-instance synchronization (e.g., changes in other tabs/windows)
@@ -5581,10 +6035,7 @@ class Schema {
         }
         main_cjs.setupEntityLiveQuery(this, {
             getEntityId: async (schema) => {
-                const { BaseDb } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.BaseDb$1; });
-                const { schemas: schemasTable } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.schema; });
-                const { eq } = await import('drizzle-orm');
-                const db = BaseDb.getAppDb();
+                const db = main_cjs.BaseDb.getAppDb();
                 if (!db) {
                     return undefined;
                 }
@@ -5595,8 +6046,8 @@ class Schema {
                 }
                 const schemaRecords = await db
                     .select()
-                    .from(schemasTable)
-                    .where(eq(schemasTable.name, schemaName))
+                    .from(main_cjs.schemas)
+                    .where(drizzleOrm.eq(main_cjs.schemas.name, schemaName))
                     .limit(1);
                 if (schemaRecords.length === 0 || !schemaRecords[0].id) {
                     return undefined;
@@ -5604,22 +6055,19 @@ class Schema {
                 return schemaRecords[0].id;
             },
             buildQuery: async (schemaId) => {
-                const { BaseDb } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.BaseDb$1; });
-                const { modelSchemas, models: modelsTable } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.schema; });
-                const { eq } = await import('drizzle-orm');
-                const db = BaseDb.getAppDb();
+                const db = main_cjs.BaseDb.getAppDb();
                 if (!db) {
                     throw new Error('Database not available');
                 }
-                return BaseDb.liveQuery(db
+                return main_cjs.BaseDb.liveQuery(db
                     .select({
-                    modelId: modelSchemas.modelId,
-                    modelName: modelsTable.name,
-                    modelFileId: modelsTable.schemaFileId,
+                    modelId: main_cjs.modelSchemas.modelId,
+                    modelName: main_cjs.models.name,
+                    modelFileId: main_cjs.models.schemaFileId,
                 })
-                    .from(modelSchemas)
-                    .innerJoin(modelsTable, eq(modelSchemas.modelId, modelsTable.id))
-                    .where(eq(modelSchemas.schemaId, typeof schemaId === 'string' ? parseInt(schemaId, 10) : schemaId)));
+                    .from(main_cjs.modelSchemas)
+                    .innerJoin(main_cjs.models, drizzleOrm.eq(main_cjs.modelSchemas.modelId, main_cjs.models.id))
+                    .where(drizzleOrm.eq(main_cjs.modelSchemas.schemaId, typeof schemaId === 'string' ? parseInt(schemaId, 10) : schemaId)));
             },
             extractEntityIds: (rows) => rows.map(row => row.modelFileId).filter(Boolean),
             updateContext: (schema, ids) => {
@@ -5678,16 +6126,12 @@ class Schema {
                 }
             },
             createChildInstances: async (ids) => {
-                const { Model } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.Model$1; });
                 for (const id of ids) {
-                    await Model.createById(id);
+                    await main_cjs.Model.createById(id);
                 }
             },
             queryInitialData: async (schemaId) => {
-                const { BaseDb } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.BaseDb$1; });
-                const { modelSchemas, models: modelsTable } = await Promise.resolve().then(function () { return require('./index-BmIVfqGN.js'); }).then(function (n) { return n.schema; });
-                const { eq } = await import('drizzle-orm');
-                const db = BaseDb.getAppDb();
+                const db = main_cjs.BaseDb.getAppDb();
                 if (!db) {
                     return [];
                 }
@@ -5696,13 +6140,13 @@ class Schema {
                     try {
                         const initialModels = await db
                             .select({
-                            modelId: modelSchemas.modelId,
-                            modelName: modelsTable.name,
-                            modelFileId: modelsTable.schemaFileId,
+                            modelId: main_cjs.modelSchemas.modelId,
+                            modelName: main_cjs.models.name,
+                            modelFileId: main_cjs.models.schemaFileId,
                         })
-                            .from(modelSchemas)
-                            .innerJoin(modelsTable, eq(modelSchemas.modelId, modelsTable.id))
-                            .where(eq(modelSchemas.schemaId, typeof schemaId === 'string' ? parseInt(schemaId, 10) : schemaId));
+                            .from(main_cjs.modelSchemas)
+                            .innerJoin(main_cjs.models, drizzleOrm.eq(main_cjs.modelSchemas.modelId, main_cjs.models.id))
+                            .where(drizzleOrm.eq(main_cjs.modelSchemas.schemaId, typeof schemaId === 'string' ? parseInt(schemaId, 10) : schemaId));
                         logger(`[Schema._setupLiveQuerySubscription] Initial query found ${initialModels.length} models`);
                         if (initialModels.length > 0) {
                             return initialModels.map((row) => ({
@@ -5758,5 +6202,7 @@ var Schema$1 = /*#__PURE__*/Object.freeze({
 });
 
 exports.Schema = Schema;
-exports.schemaInstanceState = schemaInstanceState;
-//# sourceMappingURL=Schema-B5cr_JVK.js.map
+exports.Schema$1 = Schema$1;
+exports.convertPropertyToSchemaUpdate = convertPropertyToSchemaUpdate;
+exports.updateModelProperties = updateModelProperties;
+//# sourceMappingURL=Schema-CVs9J6eP.js.map