@seedprotocol/sdk 0.7.8 → 0.7.9-next.1177.ga3e08ed

package/dist/{Schema-CX9CTtho.js → Schema-PFZwG9Nl.js}

@@ -1,1268 +1,13 @@
 import { fromCallback, setup, assign, createActor } from 'xstate';
-import { ay as SEED_PROTOCOL_SCHEMA_NAME, G as BaseDb, B as schemas, aQ as addSchemaToDb, i as isDataType, M as ModelPropertyDataTypes, aj as generateId, R as addModelsToDb, t as models, r as modelSchemas, w as properties, Q as BaseFileManager, aU as loadModelsFromDbForSchema, aV as mergeDbModelsIntoSchemaModels, aN as isInternalSchema, aW as clearNameMatchLevels } from './index-C0SetTd1.js';
-import { h as getRefValueType, T as createRowsWrittenSignal, U as createModelsFromJson, F as listCompleteSchemaFiles, V as getLatestSchemaVersion, l as loadSchemaFromFile, W as jsonPropertiesToSchemaProperties, G as loadAllSchemasFromDb, z as getClient } from './ClientManager-B1r_8P5Z.js';
+import { L as BaseDb, aq as SEED_PROTOCOL_SCHEMA_NAME, J as schemas, Q as BaseFileManager, aL as loadModelsFromDbForSchema, aM as mergeDbModelsIntoSchemaModels, aF as isInternalSchema, p as models, z as modelSchemas, aN as addSchemaToDb, ad as generateId, i as isDataType, M as ModelPropertyDataTypes, aO as addModelsToDb, E as properties, aP as clearNameMatchLevels } from './index-Dx_GTdyQ.js';
+import { SchemaValidationService } from './SchemaValidationService-DnGKel4V.js';
+import { A as listCompleteSchemaFiles, N as getLatestSchemaVersion, O as createRowsWrittenSignal, P as createModelsFromJson, l as loadSchemaFromFile, Q as jsonPropertiesToSchemaProperties, B as loadAllSchemasFromDb, v as getClient } from './ClientManager-GZfXErDX.js';
 import { eq, desc, and } from 'drizzle-orm';
 import debug from 'debug';
-import { c as currentEvictionEpoch, w as writeProcessMachine, M as Model, g as getDraftSaveError, C as ConflictError, r as recordSchemaDestroy, f as finishSchemaDestroy, e as setupEntityLiveQuery, t as trackDraftSave } from './errors-rIWK7gwJ.js';
+import { c as currentEvictionEpoch, M as Model, g as getDraftSaveError, C as ConflictError, r as recordSchemaDestroy, f as finishSchemaDestroy, e as setupEntityLiveQuery, t as trackDraftSave } from './errors-D1zHAqjr.js';
 import 'pluralize';
 import '@seedprotocol/eas';
-import { SchemaValidationService } from './SchemaValidationService-T5mqnY8q.js';
-import { ak as ActorKeyedState, Q as DEFAULT_READY_TIMEOUT_MS, C as waitForEntityIdle, R as createReactiveProxy, T as findEntity, X as ClientManagerState, al as clearDestroySubscriptions, U as forceRemoveFromCaches, am as unloadEntity, V as runDestroyLifecycle } from './Item-CjTEShfk.js';
-
-const logger$d = debug('seedSdk:schema:actors:loadOrCreateSchema');
-/**
- * Query model IDs (schemaFileId) from database for a given schema
- * This is used to populate _liveQueryModelIds immediately when loading a schema
- * @param schemaId - The database ID of the schema
- * @returns Array of model file IDs (schemaFileId) for models linked to this schema
- */
-const getModelIdsForSchema$1 = async (schemaId) => {
-    const db = BaseDb.getAppDb();
-    if (!db) {
-        logger$d('Database not available, cannot query model IDs');
-        return [];
-    }
-    try {
-        const modelRecords = await db
-            .select({
-            modelFileId: models.schemaFileId,
-        })
-            .from(modelSchemas)
-            .innerJoin(models, eq(modelSchemas.modelId, models.id))
-            .where(eq(modelSchemas.schemaId, schemaId));
-        const modelIds = modelRecords
-            .map((row) => row.modelFileId)
-            .filter((id) => id !== null && id !== undefined);
-        logger$d(`Found ${modelIds.length} model IDs for schema (id: ${schemaId}): ${modelIds.join(', ')}`);
-        return modelIds;
-    }
-    catch (error) {
-        logger$d(`Error querying model IDs for schema ${schemaId}:`, error);
-        return [];
-    }
-};
-/**
- * Create Model instances for all model IDs to ensure they're cached before getContext runs
- * This ensures that Model.getById() in Schema.getContext() will find the instances
- * @param modelIds - Array of model file IDs to create instances for
- */
-const createModelInstances$2 = async (modelIds, evictionEpoch) => {
-    if (modelIds.length === 0) {
-        return;
-    }
-    try {
-        const _mod_0 = await import('./errors-rIWK7gwJ.js');
-        const _ns_0 = _mod_0.i;
-        const modelMod = _ns_0;
-        const { Model } = modelMod;
-        // 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) => {
-            try {
-                // Not if the schema was evicted (Schema.destroy, test cleanup) since this load started
-                const schemaHold = Model.takeSchemaHold(modelFileId);
-                const model = await Model.createById(modelFileId, { evictionEpoch, ...(!schemaHold && { hold: false }) });
-                if (!model && schemaHold)
-                    Model.dropSchemaHold(modelFileId);
-                if (model) {
-                    logger$d(`Created/cached Model instance for modelFileId "${modelFileId}"`);
-                }
-                else {
-                    logger$d(`Model.createById returned undefined for modelFileId "${modelFileId}" (may not exist in DB yet)`);
-                }
-            }
-            catch (error) {
-                logger$d(`Error creating Model instance for modelFileId "${modelFileId}": ${error}`);
-                // Don't throw - continue with other models
-            }
-        });
-        await Promise.all(createPromises);
-        logger$d(`Finished creating/caching ${modelIds.length} Model instances`);
-    }
-    catch (error) {
-        logger$d(`Error in createModelInstances: ${error}`);
-        // Don't throw - this is best-effort to pre-populate cache
-    }
-};
-/**
- * Verify that properties are persisted to the database for a given model
- * This is important in browser environments where database writes may not be immediately visible
- * @param modelId - Database ID of the model
- * @param modelName - Name of the model (for logging)
- * @param maxRetries - Maximum number of retry attempts
- * @param retryDelay - Delay between retries in milliseconds
- * @returns Promise that resolves when properties are found, or rejects if not found after max retries
- */
-const verifyPropertiesPersisted = async (modelId, modelName, maxRetries = 10, retryDelay = 100) => {
-    const db = BaseDb.getAppDb();
-    if (!db) {
-        throw new Error('Database not available for property verification');
-    }
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-        const props = await db
-            .select()
-            .from(properties)
-            .where(eq(properties.modelId, modelId))
-            .limit(1);
-        if (props.length > 0) {
-            logger$d(`Verified properties exist for model "${modelName}" (modelId: ${modelId}) after ${attempt + 1} attempt(s)`);
-            return;
-        }
-        if (attempt < maxRetries - 1) {
-            logger$d(`Properties not yet visible for model "${modelName}" (modelId: ${modelId}), retrying in ${retryDelay}ms (attempt ${attempt + 1}/${maxRetries})`);
-            await new Promise(resolve => setTimeout(resolve, retryDelay));
-        }
-    }
-    throw new Error(`Properties not found for model "${modelName}" (modelId: ${modelId}) after ${maxRetries} attempts. This may indicate a database write issue in the browser environment.`);
-};
-/**
- * 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
-};
-/**
- * Generate filename 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 getSchemaFilename = (name, version, schemaFileId) => {
-    const sanitizedName = sanitizeSchemaName$1(name);
-    return `${schemaFileId}_${sanitizedName}_v${version}.json`;
-};
-/**
- * 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 = BaseFileManager.getPathModule();
-    const filename = getSchemaFilename(name, version, schemaFileId);
-    const workingDir = BaseFileManager.getWorkingDir();
-    return path.join(workingDir, filename);
-};
-const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
-    const evictionEpoch = currentEvictionEpoch();
-    const _loadOrCreateSchema = async () => {
-        const { schemaName } = context;
-        // 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 = isInternalSchema(schemaName);
-        if (isInternal && schemaName === SEED_PROTOCOL_SCHEMA_NAME) {
-            // For Seed Protocol, always load from internal file, never create new
-            logger$d(`Loading internal Seed Protocol schema from SDK`);
-            try {
-                const _mod_1 = await import('./ClientManager-B1r_8P5Z.js');
-                const _ns_1 = _mod_1.Y;
-                const internalSchema = _ns_1;
-                const schemaFile = internalSchema.default;
-                // Check if it exists in database, if not, add it
-                const db = BaseDb.getAppDb();
-                if (db && schemaFile.id) {
-                    const existing = await db
-                        .select()
-                        .from(schemas)
-                        .where(eq(schemas.schemaFileId, schemaFile.id))
-                        .limit(1);
-                    let schemaRecord = existing.length > 0 ? existing[0] : null;
-                    if (existing.length === 0) {
-                        // Add to database if not present
-                        const schemaData = JSON.stringify(schemaFile, null, 2);
-                        schemaRecord = await addSchemaToDb({
-                            name: schemaName,
-                            version: schemaFile.version,
-                            createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
-                            updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
-                        }, schemaFile.id, schemaData, false);
-                        logger$d(`Added Seed Protocol schema to database`);
-                        // Also add models and properties to database
-                        // Convert to JsonImportSchema format for processing
-                        const importData = {
-                            name: schemaName,
-                            models: Object.fromEntries(Object.entries(schemaFile.models || {}).map(([modelName, model]) => [
-                                modelName,
-                                {
-                                    ...model,
-                                    // Remove id field for import format
-                                    id: undefined,
-                                    properties: Object.fromEntries(Object.entries(model.properties || {}).map(([propName, prop]) => {
-                                        const schemaProp = prop;
-                                        const jsonProp = {
-                                            type: schemaProp.dataType || schemaProp.type,
-                                        };
-                                        // Copy other properties
-                                        Object.keys(schemaProp).forEach(key => {
-                                            if (key !== 'id' && key !== 'dataType') {
-                                                jsonProp[key] = schemaProp[key];
-                                            }
-                                        });
-                                        // Handle Relation type
-                                        if (schemaProp.ref || schemaProp.refModelName) {
-                                            jsonProp.model = schemaProp.refModelName || schemaProp.ref;
-                                        }
-                                        // Handle List type (case-insensitive refValueType)
-                                        const listRefValueType = getRefValueType(schemaProp);
-                                        if (isDataType(schemaProp.dataType, ModelPropertyDataTypes.List) && listRefValueType) {
-                                            jsonProp.refValueType = listRefValueType;
-                                            if (schemaProp.ref || schemaProp.refModelName) {
-                                                jsonProp.ref = schemaProp.refModelName || schemaProp.ref;
-                                            }
-                                        }
-                                        // Handle storage configuration
-                                        if (schemaProp.storageType || schemaProp.localStorageDir || schemaProp.filenameSuffix) {
-                                            jsonProp.storage = {
-                                                type: schemaProp.storageType === 'ItemStorage' ? 'ItemStorage' : 'PropertyStorage',
-                                                path: schemaProp.localStorageDir,
-                                                extension: schemaProp.filenameSuffix,
-                                            };
-                                        }
-                                        return [propName, jsonProp];
-                                    })),
-                                },
-                            ])),
-                        };
-                        // Generate schema ID if missing
-                        if (!schemaFile.id) {
-                            schemaFile.id = 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 = generateId();
-                                logger$d(`Generated model ID for ${modelName}:`, model.id);
-                                // Update the schemaFile object so it's included in schemaData
-                                schemaFile.models[modelName].id = 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 = generateId();
-                                    logger$d(`Generated property ID for ${modelName}.${propName}:`, prop.id);
-                                    // Update the schemaFile object so it's included in schemaData
-                                    schemaFile.models[modelName].properties[propName].id = 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.
-                        // addModelsToDb below writes their rows; the models adopt them once it has run.
-                        const rowsWritten = createRowsWrittenSignal();
-                        const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds, schemaRecord ? rowsWritten.promise : undefined);
-                        // Add models to database and link them to the schema with schemaFileIds
-                        if (Object.keys(modelDefinitions).length > 0 && schemaRecord) {
-                            await addModelsToDb(modelDefinitions, schemaRecord, undefined, {
-                                schemaFileId: schemaFile.id,
-                                modelFileIds,
-                                propertyFileIds,
-                            }).finally(rowsWritten.settle);
-                            logger$d(`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 modelLinks = await db
-                                .select({
-                                modelId: modelSchemas.modelId,
-                                modelName: models.name,
-                            })
-                                .from(modelSchemas)
-                                .innerJoin(models, eq(modelSchemas.modelId, models.id))
-                                .where(eq(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) {
-                                await verifyPropertiesPersisted(seedModelLink.modelId, 'Seed', 10, 100);
-                            }
-                            else if (modelLinks.length > 0 && modelLinks[0].modelId) {
-                                // Fallback to first model if Seed not found
-                                await verifyPropertiesPersisted(modelLinks[0].modelId, modelLinks[0].modelName || 'unknown', 10, 100);
-                            }
-                        }
-                    }
-                    else {
-                        // 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
-                        // Check if models are linked to the schema
-                        const modelLinks = await db
-                            .select({
-                            modelId: modelSchemas.modelId,
-                            modelName: models.name,
-                        })
-                            .from(modelSchemas)
-                            .innerJoin(models, eq(modelSchemas.modelId, models.id))
-                            .where(eq(modelSchemas.schemaId, schemaRecord.id));
-                        // Check if we have all expected models
-                        const expectedModelNames = Object.keys(schemaFile.models || {});
-                        const linkedModelNames = modelLinks
-                            .map((link) => link.modelName)
-                            .filter((n) => n !== null);
-                        const missingModels = expectedModelNames.filter(name => !linkedModelNames.includes(name));
-                        // Check if properties exist for linked models
-                        let missingProperties = false;
-                        if (modelLinks.length > 0) {
-                            for (const link of modelLinks) {
-                                if (link.modelId) {
-                                    const props = await db
-                                        .select()
-                                        .from(properties)
-                                        .where(eq(properties.modelId, link.modelId))
-                                        .limit(1);
-                                    if (props.length === 0) {
-                                        missingProperties = true;
-                                        break;
-                                    }
-                                }
-                            }
-                        }
-                        // If models are missing or properties are missing, add them
-                        if (missingModels.length > 0 || missingProperties || modelLinks.length === 0) {
-                            logger$d(`Seed Protocol schema exists but models/properties incomplete (missing models: ${missingModels.length}, missing properties: ${missingProperties}), adding them now`);
-                            // Convert SchemaFileFormat to JsonImportSchema format
-                            // Schema format: { dataType, ref, refValueType, storageType, localStorageDir, filenameSuffix }
-                            // JSON import format: { type, model, items, storage: { type, path, extension } }
-                            const importData = {
-                                name: schemaName,
-                                models: Object.fromEntries(Object.entries(schemaFile.models || {}).map(([modelName, model]) => [
-                                    modelName,
-                                    {
-                                        ...model,
-                                        id: undefined,
-                                        properties: Object.fromEntries(Object.entries(model.properties || {}).map(([propName, prop]) => {
-                                            const schemaProp = prop;
-                                            const jsonProp = {
-                                                type: schemaProp.dataType || schemaProp.type,
-                                            };
-                                            // Handle Relation type
-                                            if (schemaProp.ref || schemaProp.refModelName) {
-                                                jsonProp.model = schemaProp.refModelName || schemaProp.ref;
-                                            }
-                                            // Handle List type (support both refValueType and legacy items, case-insensitive)
-                                            if (isDataType(schemaProp.dataType, ModelPropertyDataTypes.List) || isDataType(schemaProp.type, ModelPropertyDataTypes.List)) {
-                                                const refValueType = getRefValueType(schemaProp);
-                                                if (refValueType) {
-                                                    jsonProp.refValueType = refValueType;
-                                                    const ref = schemaProp.ref ?? schemaProp.refModelName ?? schemaProp.items?.model;
-                                                    if (ref)
-                                                        jsonProp.ref = ref;
-                                                }
-                                            }
-                                            // Handle storage configuration
-                                            if (schemaProp.storageType || schemaProp.localStorageDir || schemaProp.filenameSuffix) {
-                                                jsonProp.storage = {
-                                                    type: schemaProp.storageType === 'ItemStorage' ? 'ItemStorage' : 'PropertyStorage',
-                                                    path: schemaProp.localStorageDir,
-                                                    extension: schemaProp.filenameSuffix,
-                                                };
-                                            }
-                                            return [propName, jsonProp];
-                                        })),
-                                    },
-                                ])),
-                            };
-                            // Generate schema ID if missing
-                            if (!schemaFile.id) {
-                                schemaFile.id = 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 = generateId();
-                                    logger$d(`Generated model ID for ${modelName}:`, model.id);
-                                    // Update the schemaFile object so it's included in schemaData
-                                    schemaFile.models[modelName].id = 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 = generateId();
-                                        logger$d(`Generated property ID for ${modelName}.${propName}:`, prop.id);
-                                        // Update the schemaFile object so it's included in schemaData
-                                        schemaFile.models[modelName].properties[propName].id = 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.
-                            // addModelsToDb below writes their rows; the models adopt them once it has run.
-                            const rowsWritten = createRowsWrittenSignal();
-                            const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds, rowsWritten.promise);
-                            // Verify all expected models are in modelDefinitions
-                            const missingFromDefinitions = expectedModelNames.filter(name => !Object.keys(modelDefinitions).includes(name));
-                            if (missingFromDefinitions.length > 0) {
-                                console.warn(`[loadOrCreateSchema] WARNING: Some expected models are missing from modelDefinitions: ${missingFromDefinitions.join(', ')}`);
-                            }
-                            if (Object.keys(modelDefinitions).length > 0) {
-                                await addModelsToDb(modelDefinitions, schemaRecord, undefined, {
-                                    schemaFileId: schemaFile.id,
-                                    modelFileIds,
-                                    propertyFileIds,
-                                }).finally(rowsWritten.settle);
-                                logger$d(`Added ${Object.keys(modelDefinitions).length} models and their properties to database for existing Seed Protocol schema`);
-                                // Small delay to ensure database writes are visible (important for browser environments)
-                                await new Promise(resolve => setTimeout(resolve, 200));
-                                // Verify properties are persisted (important for browser environments)
-                                // Re-query model links to get updated model IDs
-                                // Retry querying until all expected models are visible
-                                const expectedModelNames = Object.keys(schemaFile.models || {});
-                                let updatedModelLinks = [];
-                                const maxRetries = 10;
-                                const retryDelay = 100;
-                                for (let attempt = 0; attempt < maxRetries; attempt++) {
-                                    updatedModelLinks = await db
-                                        .select({
-                                        modelId: modelSchemas.modelId,
-                                        modelName: models.name,
-                                    })
-                                        .from(modelSchemas)
-                                        .innerJoin(models, eq(modelSchemas.modelId, models.id))
-                                        .where(eq(modelSchemas.schemaId, schemaRecord.id));
-                                    const linkedModelNames = updatedModelLinks
-                                        .map((link) => link.modelName)
-                                        .filter((n) => n !== null);
-                                    const allModelsPresent = expectedModelNames.every(name => linkedModelNames.includes(name));
-                                    if (allModelsPresent) {
-                                        break;
-                                    }
-                                    if (attempt < maxRetries - 1) {
-                                        await new Promise(resolve => setTimeout(resolve, retryDelay));
-                                    }
-                                }
-                                // Verify properties for at least one model (Seed model if available)
-                                const seedModelLink = updatedModelLinks.find((link) => link.modelName === 'Seed');
-                                if (seedModelLink && seedModelLink.modelId) {
-                                    await verifyPropertiesPersisted(seedModelLink.modelId, 'Seed', 10, 100);
-                                }
-                                else if (updatedModelLinks.length > 0 && updatedModelLinks[0].modelId) {
-                                    // Fallback to first model if Seed not found
-                                    await verifyPropertiesPersisted(updatedModelLinks[0].modelId, updatedModelLinks[0].modelName || 'unknown', 10, 100);
-                                }
-                            }
-                        }
-                        else {
-                            logger$d(`Seed Protocol schema exists with all models and properties already in database`);
-                        }
-                    }
-                    // Query model IDs from database to populate _liveQueryModelIds immediately
-                    let modelIds = [];
-                    if (schemaRecord && schemaRecord.id) {
-                        modelIds = await getModelIdsForSchema$1(schemaRecord.id);
-                        // Create Model instances so they're cached before getContext runs
-                        await createModelInstances$2(modelIds, evictionEpoch);
-                    }
-                    sendBack({
-                        type: 'loadOrCreateSchemaSuccess',
-                        schema: schemaFile,
-                        _liveQueryModelIds: modelIds,
-                    });
-                    return;
-                }
-                else {
-                    // No database available, send schema without model IDs
-                    sendBack({
-                        type: 'loadOrCreateSchemaSuccess',
-                        schema: schemaFile,
-                        _liveQueryModelIds: [],
-                    });
-                    return;
-                }
-            }
-            catch (error) {
-                logger$d(`Error loading internal Seed Protocol schema: ${error}`);
-                // Fall through to normal loading logic
-            }
-        }
-        if (!schemaName) {
-            throw new Error('Schema name is required');
-        }
-        const db = BaseDb.getAppDb();
-        if (!db) {
-            throw new Error('Database not found');
-        }
-        // STEP 1: Query database first for existing schema (prefer drafts)
-        // First try by name (most common case)
-        let dbSchemas = await db
-            .select()
-            .from(schemas)
-            .where(eq(schemas.name, schemaName))
-            .orderBy(desc(schemas.isDraft), desc(schemas.version))
-            .limit(1);
-        // If not found by name, also try querying by schemaFileId directly
-        // This handles the case where an ID is passed instead of a name (e.g., 'test-schema-1')
-        if (dbSchemas.length === 0) {
-            logger$d(`No schema found by name "${schemaName}", trying to find by schemaFileId`);
-            const schemasByFileId = await db
-                .select()
-                .from(schemas)
-                .where(eq(schemas.schemaFileId, schemaName))
-                .orderBy(desc(schemas.isDraft), desc(schemas.version))
-                .limit(1);
-            if (schemasByFileId.length > 0) {
-                logger$d(`Found schema by schemaFileId "${schemaName}" (name in DB: ${schemasByFileId[0].name})`);
-                dbSchemas = schemasByFileId;
-            }
-        }
-        // If not found by name, or if found but it's not a draft, try to find by schemaFileId from file
-        // This handles the case where a draft's name was changed but we're loading by the old name
-        const shouldTrySchemaFileId = dbSchemas.length === 0 || (dbSchemas.length > 0 && dbSchemas[0].isDraft === false);
-        if (shouldTrySchemaFileId) {
-            // First, try to get schemaFileId from file if it exists
-            const completeSchemas = await listCompleteSchemaFiles();
-            const matchingFileSchemas = completeSchemas.filter((s) => s.name === schemaName);
-            if (matchingFileSchemas.length > 0) {
-                const latestFile = matchingFileSchemas.reduce((prev, current) => current.version > prev.version ? current : prev);
-                // Read file to get schemaFileId
-                try {
-                    const content = await BaseFileManager.readFileAsString(latestFile.filePath);
-                    const fileSchema = JSON.parse(content);
-                    if (fileSchema.id) {
-                        // Look up by schemaFileId - query for DRAFTS first, then published
-                        // This ensures we find the draft even if there's also a published version
-                        const draftsByFileId = await db
-                            .select()
-                            .from(schemas)
-                            .where(and(eq(schemas.schemaFileId, fileSchema.id), eq(schemas.isDraft, true)))
-                            .orderBy(desc(schemas.version))
-                            .limit(1);
-                        if (draftsByFileId.length > 0) {
-                            logger$d(`Found DRAFT by schemaFileId ${fileSchema.id} (name in DB: ${draftsByFileId[0].name}, requested name: ${schemaName})`);
-                            dbSchemas = draftsByFileId;
-                        }
-                        else {
-                            // No draft found, check for any record with this schemaFileId
-                            const dbSchemasByFileId = await db
-                                .select()
-                                .from(schemas)
-                                .where(eq(schemas.schemaFileId, fileSchema.id))
-                                .orderBy(desc(schemas.isDraft), desc(schemas.version))
-                                .limit(1);
-                            if (dbSchemasByFileId.length > 0) {
-                                const foundSchema = dbSchemasByFileId[0];
-                                logger$d(`Found schema by schemaFileId ${fileSchema.id} (name in DB: ${foundSchema.name}, requested name: ${schemaName}, isDraft: ${foundSchema.isDraft})`);
-                                // Always prefer the one found by schemaFileId if we didn't find anything by name
-                                // OR if the one found by schemaFileId is a draft (even if we found a non-draft by name)
-                                if (foundSchema.isDraft === true || dbSchemas.length === 0) {
-                                    dbSchemas = dbSchemasByFileId;
-                                    logger$d(`Using schema found by schemaFileId (isDraft: ${foundSchema.isDraft})`);
-                                }
-                                else if (foundSchema.isDraft === false && dbSchemas.length > 0 && dbSchemas[0].isDraft === false) {
-                                    // Both are non-drafts, prefer the one found by schemaFileId (more reliable)
-                                    dbSchemas = dbSchemasByFileId;
-                                    logger$d(`Both schemas are non-drafts, using the one found by schemaFileId`);
-                                }
-                                else {
-                                    logger$d(`Keeping schema found by name (isDraft: ${dbSchemas[0].isDraft}) over schemaFileId result (isDraft: ${foundSchema.isDraft})`);
-                                }
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    logger$d(`Error reading file to get schemaFileId: ${error}`);
-                }
-            }
-            // If still not found and no file exists, try querying all drafts to see if any have metadata.name matching
-            // This handles the case where a draft was renamed but there's no file (draft-only schema)
-            if (dbSchemas.length === 0) {
-                logger$d(`No schema found by name "${schemaName}" and no matching file, checking all drafts for potential match`);
-                const allDrafts = await db
-                    .select()
-                    .from(schemas)
-                    .where(eq(schemas.isDraft, true))
-                    .orderBy(desc(schemas.version));
-                logger$d(`Checking ${allDrafts.length} drafts for normalized name match`);
-                // Check each draft's schemaData to see if metadata.name matches
-                // Use case-insensitive and normalized comparison to handle name changes like "blog-schema" -> "Blog Schema"
-                const normalizeName = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, '');
-                const normalizedRequested = normalizeName(schemaName);
-                logger$d(`Normalized requested name: "${schemaName}" -> "${normalizedRequested}"`);
-                for (const draft of allDrafts) {
-                    if (draft.schemaData) {
-                        try {
-                            const draftSchema = JSON.parse(draft.schemaData);
-                            const draftMetadataName = draftSchema.metadata?.name || '';
-                            const draftDbName = draft.name || '';
-                            // Check if normalized names match (handles "blog-schema" vs "Blog Schema")
-                            const normalizedDraftMetadata = normalizeName(draftMetadataName);
-                            const normalizedDraftDb = normalizeName(draftDbName);
-                            logger$d(`Checking draft: DB name="${draftDbName}" (normalized: "${normalizedDraftDb}"), metadata.name="${draftMetadataName}" (normalized: "${normalizedDraftMetadata}")`);
-                            if (normalizedDraftMetadata === normalizedRequested || normalizedDraftDb === normalizedRequested) {
-                                dbSchemas = [draft];
-                                logger$d(`Found draft by normalized name match: DB name="${draftDbName}", metadata.name="${draftMetadataName}", requested="${schemaName}" (normalized: "${normalizedRequested}")`);
-                                break;
-                            }
-                        }
-                        catch (error) {
-                            logger$d(`Error parsing draft schemaData: ${error}`);
-                            // Skip drafts with invalid schemaData
-                            continue;
-                        }
-                    }
-                    else {
-                        logger$d(`Draft ${draft.name} (id: ${draft.id}) has no schemaData, skipping`);
-                    }
-                }
-                if (dbSchemas.length === 0) {
-                    logger$d(`No draft found matching normalized name "${normalizedRequested}"`);
-                }
-            }
-        }
-        if (dbSchemas.length > 0) {
-            const dbSchema = dbSchemas[0];
-            logger$d(`Found schema record: name="${dbSchema.name}", isDraft=${dbSchema.isDraft}, hasSchemaData=${!!dbSchema.schemaData}, schemaFileId="${dbSchema.schemaFileId}"`);
-            // If it's a draft, load from schemaData
-            if (dbSchema.isDraft === true && dbSchema.schemaData) {
-                try {
-                    const schemaFile = JSON.parse(dbSchema.schemaData);
-                    logger$d(`Found draft schema ${schemaName} v${schemaFile.version} in database (DB name: ${dbSchema.name}, metadata.name: ${schemaFile.metadata?.name})`);
-                    // CRITICAL: Ensure schema.id matches schemaFileId from database (database is source of truth)
-                    if (dbSchema.schemaFileId && schemaFile.id !== dbSchema.schemaFileId) {
-                        logger$d(`Fixing schema ID mismatch: schema.id="${schemaFile.id}" does not match schemaFileId="${dbSchema.schemaFileId}" from database. Using database value as source of truth.`);
-                        schemaFile.id = dbSchema.schemaFileId;
-                    }
-                    else if (!schemaFile.id && dbSchema.schemaFileId) {
-                        logger$d(`Schema missing id, using schemaFileId from database: "${dbSchema.schemaFileId}"`);
-                        schemaFile.id = dbSchema.schemaFileId;
-                    }
-                    // Verify metadata matches what we expect
-                    if (schemaFile.metadata?.name !== dbSchema.name) {
-                        logger$d(`WARNING: Metadata name mismatch! DB name="${dbSchema.name}", metadata.name="${schemaFile.metadata?.name}"`);
-                    }
-                    // Build merged models without mutating schemaFile (read-only approach)
-                    let mergedModels = { ...(schemaFile.models || {}) };
-                    // Ensure models are populated (fallback for seed-protocol if missing)
-                    if ((!mergedModels || Object.keys(mergedModels).length === 0) && schemaName === 'Seed Protocol') {
-                        try {
-                            const _mod_2 = await import('./ClientManager-B1r_8P5Z.js');
-                            const _ns_2 = _mod_2.Y;
-                            const internalSchema = _ns_2;
-                            const internalSchemaFile = internalSchema.default;
-                            mergedModels = { ...(internalSchemaFile.models || {}) };
-                            logger$d(`Populated models for seed-protocol schema from internal file`);
-                        }
-                        catch (error) {
-                            logger$d(`Error loading internal seed-protocol schema for models:`, error);
-                        }
-                    }
-                    // CRITICAL: Merge models from database (model_schemas join table) with models from schemaData
-                    // This ensures models added to the database are included even if they're not in schemaData
-                    if (dbSchema.id) {
-                        const dbModels = await loadModelsFromDbForSchema(dbSchema.id);
-                        if (Object.keys(dbModels).length > 0) {
-                            logger$d(`Found ${Object.keys(dbModels).length} models in database for schema ${schemaName}: ${Object.keys(dbModels).join(', ')}`);
-                            // Merge: database models take precedence for properties, but preserve schemaData models for full structure
-                            mergedModels = mergeDbModelsIntoSchemaModels(mergedModels, dbModels);
-                        }
-                    }
-                    // Create new schemaFile object with merged models (read-only approach)
-                    const finalSchemaFile = {
-                        ...schemaFile,
-                        models: mergedModels,
-                    };
-                    // Query model IDs from database to populate _liveQueryModelIds immediately
-                    let modelIds = [];
-                    if (dbSchema.id) {
-                        modelIds = await getModelIdsForSchema$1(dbSchema.id);
-                        // Create Model instances so they're cached before getContext runs
-                        await createModelInstances$2(modelIds, evictionEpoch);
-                    }
-                    // Track conflict detection metadata
-                    const loadedAt = Date.now();
-                    const dbVersion = dbSchema.version;
-                    const dbUpdatedAt = dbSchema.updatedAt || loadedAt;
-                    sendBack({
-                        type: 'loadOrCreateSchemaSuccess',
-                        schema: finalSchemaFile,
-                        loadedAt,
-                        dbVersion,
-                        dbUpdatedAt,
-                        _liveQueryModelIds: modelIds,
-                    });
-                    return;
-                }
-                catch (error) {
-                    logger$d(`Error parsing schemaData for ${schemaName}:`, error);
-                    // Fall through to file-based loading
-                }
-            }
-            // If it's not a draft and has schemaFileId, try to load from file
-            // BUT: First check if there's a draft with the same schemaFileId (in case name changed)
-            if (dbSchema.isDraft === false && dbSchema.schemaFileId) {
-                logger$d(`Schema is not a draft (isDraft=${dbSchema.isDraft}), checking if there's a draft with same schemaFileId before loading from file`);
-                // Check for a draft with the same schemaFileId (handles name changes)
-                const draftsByFileId = await db
-                    .select()
-                    .from(schemas)
-                    .where(and(eq(schemas.schemaFileId, dbSchema.schemaFileId), eq(schemas.isDraft, true)))
-                    .orderBy(desc(schemas.version))
-                    .limit(1);
-                if (draftsByFileId.length > 0 && draftsByFileId[0].schemaData) {
-                    logger$d(`Found draft with same schemaFileId (name: "${draftsByFileId[0].name}"), using it instead of published version`);
-                    try {
-                        const schemaFile = JSON.parse(draftsByFileId[0].schemaData);
-                        logger$d(`Found draft schema ${schemaName} v${schemaFile.version} in database (DB name: ${draftsByFileId[0].name}, metadata.name: ${schemaFile.metadata?.name})`);
-                        // CRITICAL: Ensure schema.id matches schemaFileId from database (database is source of truth)
-                        if (draftsByFileId[0].schemaFileId && schemaFile.id !== draftsByFileId[0].schemaFileId) {
-                            logger$d(`Fixing schema ID mismatch: schema.id="${schemaFile.id}" does not match schemaFileId="${draftsByFileId[0].schemaFileId}" from database. Using database value as source of truth.`);
-                            schemaFile.id = draftsByFileId[0].schemaFileId;
-                        }
-                        else if (!schemaFile.id && draftsByFileId[0].schemaFileId) {
-                            logger$d(`Schema missing id, using schemaFileId from database: "${draftsByFileId[0].schemaFileId}"`);
-                            schemaFile.id = draftsByFileId[0].schemaFileId;
-                        }
-                        // CRITICAL: Merge models from database (model_schemas join table) with models from schemaData
-                        // This ensures models added to the database are included even if they're not in schemaData
-                        if (draftsByFileId[0].id) {
-                            const dbModels = await loadModelsFromDbForSchema(draftsByFileId[0].id);
-                            if (Object.keys(dbModels).length > 0) {
-                                logger$d(`Found ${Object.keys(dbModels).length} models in database for draft schema ${schemaName}: ${Object.keys(dbModels).join(', ')}`);
-                                // Merge: database models take precedence for properties, but preserve schemaData models for full structure
-                                let mergedModels = { ...(schemaFile.models || {}) };
-                                mergedModels = mergeDbModelsIntoSchemaModels(mergedModels, dbModels);
-                                // Update schemaFile with merged models
-                                schemaFile.models = mergedModels;
-                            }
-                        }
-                        // Query model IDs from database to populate _liveQueryModelIds immediately
-                        let modelIds = [];
-                        if (draftsByFileId[0].id) {
-                            modelIds = await getModelIdsForSchema$1(draftsByFileId[0].id);
-                            // Create Model instances so they're cached before getContext runs
-                            await createModelInstances$2(modelIds, evictionEpoch);
-                        }
-                        // Track conflict detection metadata
-                        const loadedAt = Date.now();
-                        const dbVersion = draftsByFileId[0].version || schemaFile.version;
-                        const dbUpdatedAt = draftsByFileId[0].updatedAt || loadedAt;
-                        sendBack({
-                            type: 'loadOrCreateSchemaSuccess',
-                            schema: schemaFile,
-                            loadedAt,
-                            dbVersion,
-                            dbUpdatedAt,
-                            _liveQueryModelIds: modelIds,
-                        });
-                        return;
-                    }
-                    catch (error) {
-                        logger$d(`Error parsing draft schemaData: ${error}, falling back to file`);
-                    }
-                }
-                logger$d(`No draft found with same schemaFileId, will try to load from file instead of schemaData`);
-                // Try ID-based file lookup first (preferred)
-                let schemaFile = null;
-                if (dbSchema.schemaFileId) {
-                    try {
-                        // Try to find file by schemaFileId in the complete schemas list
-                        const completeSchemas = await listCompleteSchemaFiles();
-                        // Match version too: the row is per schema name, so after a new version is imported
-                        // under a new id it can carry the newer version with the older version's schemaFileId.
-                        const idBasedMatch = completeSchemas.find((s) => s.schemaFileId === dbSchema.schemaFileId && s.version === dbSchema.version);
-                        if (idBasedMatch) {
-                            logger$d(`Found schema file by schemaFileId: ${idBasedMatch.filePath}`);
-                            const content = await BaseFileManager.readFileAsString(idBasedMatch.filePath);
-                            schemaFile = JSON.parse(content);
-                        }
-                        else {
-                            // Try direct file path lookup by ID
-                            const idBasedPath = getSchemaFilePath$2(dbSchema.name, dbSchema.version, dbSchema.schemaFileId);
-                            try {
-                                const content = await BaseFileManager.readFileAsString(idBasedPath);
-                                schemaFile = JSON.parse(content);
-                                logger$d(`Found schema file by direct ID-based path: ${idBasedPath}`);
-                            }
-                            catch {
-                                // ID-based file doesn't exist, fall through to name-based
-                            }
-                        }
-                    }
-                    catch (error) {
-                        logger$d(`Error loading ID-based file: ${error}, falling back to name-based`);
-                    }
-                }
-                // Fall back to name-based file lookup (backward compatibility)
-                if (!schemaFile) {
-                    const completeSchemas = await listCompleteSchemaFiles();
-                    const matchingSchemas = completeSchemas.filter((s) => s.name === schemaName);
-                    if (matchingSchemas.length > 0) {
-                        // Find the schema with the highest version
-                        const latest = matchingSchemas.reduce((prev, current) => current.version > prev.version ? current : prev);
-                        // Read the file directly to get SchemaFileFormat
-                        const content = await BaseFileManager.readFileAsString(latest.filePath);
-                        schemaFile = JSON.parse(content);
-                    }
-                }
-                if (schemaFile) {
-                    // Build merged models without mutating schemaFile (read-only approach)
-                    let mergedModels = { ...(schemaFile.models || {}) };
-                    // Ensure models are populated (fallback for seed-protocol if missing)
-                    if ((!mergedModels || Object.keys(mergedModels).length === 0) && schemaName === 'Seed Protocol') {
-                        try {
-                            const _mod_3 = await import('./ClientManager-B1r_8P5Z.js');
-                            const _ns_3 = _mod_3.Y;
-                            const internalSchema = _ns_3;
-                            const internalSchemaFile = internalSchema.default;
-                            mergedModels = { ...(internalSchemaFile.models || {}) };
-                            logger$d(`Populated models for seed-protocol schema from internal file`);
-                        }
-                        catch (error) {
-                            logger$d(`Error loading internal seed-protocol schema for models:`, error);
-                        }
-                    }
-                    // CRITICAL: Merge models from database (model_schemas join table) with models from file
-                    // This ensures models added to the database are included even if they're not in the file
-                    if (dbSchema.id) {
-                        const dbModels = await loadModelsFromDbForSchema(dbSchema.id);
-                        if (Object.keys(dbModels).length > 0) {
-                            logger$d(`Found ${Object.keys(dbModels).length} models in database for schema ${schemaName}: ${Object.keys(dbModels).join(', ')}`);
-                            // Merge: database models take precedence for properties, but preserve file models for full structure
-                            mergedModels = mergeDbModelsIntoSchemaModels(mergedModels, dbModels);
-                        }
-                    }
-                    logger$d(`Found existing schema ${schemaName} v${schemaFile.version} from file`);
-                    // Debug: Log what we're sending
-                    logger$d(`Sending schema with ${Object.keys(schemaFile.models || {}).length} models: ${Object.keys(schemaFile.models || {}).join(', ')}`);
-                    // Query model IDs from database to populate _liveQueryModelIds immediately
-                    let modelIds = [];
-                    if (dbSchema.id) {
-                        modelIds = await getModelIdsForSchema$1(dbSchema.id);
-                        // Create Model instances so they're cached before getContext runs
-                        await createModelInstances$2(modelIds, evictionEpoch);
-                    }
-                    // Track conflict detection metadata from DB record
-                    const loadedAt = Date.now();
-                    const dbVersion = dbSchema.version || schemaFile.version;
-                    const dbUpdatedAt = dbSchema.updatedAt || loadedAt;
-                    sendBack({
-                        type: 'loadOrCreateSchemaSuccess',
-                        schema: schemaFile,
-                        loadedAt,
-                        dbVersion,
-                        dbUpdatedAt,
-                        _liveQueryModelIds: modelIds,
-                    });
-                    return;
-                }
-                // File doesn't exist, but we have schemaData in database - use it as fallback
-                if (dbSchema.schemaData) {
-                    try {
-                        const schemaFile = JSON.parse(dbSchema.schemaData);
-                        logger$d(`Found published schema ${schemaName} v${schemaFile.version} in database (file not found, using schemaData)`);
-                        // Build merged models without mutating schemaFile (read-only approach)
-                        let mergedModels = { ...(schemaFile.models || {}) };
-                        // Ensure models are populated (fallback for seed-protocol if missing)
-                        if ((!mergedModels || Object.keys(mergedModels).length === 0) && schemaName === 'Seed Protocol') {
-                            try {
-                                const _mod_4 = await import('./ClientManager-B1r_8P5Z.js');
-                                const _ns_4 = _mod_4.Y;
-                                const internalSchema = _ns_4;
-                                const internalSchemaFile = internalSchema.default;
-                                mergedModels = { ...(internalSchemaFile.models || {}) };
-                                logger$d(`Populated models for seed-protocol schema from internal file`);
-                            }
-                            catch (error) {
-                                logger$d(`Error loading internal seed-protocol schema for models:`, error);
-                            }
-                        }
-                        // CRITICAL: Merge models from database (model_schemas join table) with models from schemaData
-                        // This ensures models added to the database are included even if they're not in schemaData
-                        if (dbSchema.id) {
-                            const dbModels = await loadModelsFromDbForSchema(dbSchema.id);
-                            if (Object.keys(dbModels).length > 0) {
-                                logger$d(`Found ${Object.keys(dbModels).length} models in database for schema ${schemaName}: ${Object.keys(dbModels).join(', ')}`);
-                                // Merge: database models take precedence for properties, but preserve schemaData models for full structure
-                                mergedModels = mergeDbModelsIntoSchemaModels(mergedModels, dbModels);
-                            }
-                        }
-                        // Query model IDs from database to populate _liveQueryModelIds immediately
-                        let modelIds = [];
-                        if (dbSchema.id) {
-                            modelIds = await getModelIdsForSchema$1(dbSchema.id);
-                            // Create Model instances so they're cached before getContext runs
-                            await createModelInstances$2(modelIds, evictionEpoch);
-                        }
-                        // Track conflict detection metadata
-                        const loadedAt = Date.now();
-                        const dbVersion = dbSchema.version || schemaFile.version;
-                        const dbUpdatedAt = dbSchema.updatedAt || loadedAt;
-                        sendBack({
-                            type: 'loadOrCreateSchemaSuccess',
-                            schema: schemaFile,
-                            loadedAt,
-                            dbVersion,
-                            dbUpdatedAt,
-                            _liveQueryModelIds: modelIds,
-                        });
-                        return;
-                    }
-                    catch (error) {
-                        logger$d(`Error parsing schemaData for published schema ${schemaName}:`, error);
-                        // Fall through to try internal schema or file-based loading
-                    }
-                }
-                // If schemaData is missing, try to load from internal schema file for seed-protocol
-                if (!dbSchema.schemaData && schemaName === 'Seed Protocol') {
-                    try {
-                        const _mod_5 = await import('./ClientManager-B1r_8P5Z.js');
-                        const _ns_5 = _mod_5.Y;
-                        const internalSchema = _ns_5;
-                        const schemaFile = internalSchema.default;
-                        logger$d(`Found seed-protocol schema in internal file (schemaData missing, using internal schema)`);
-                        // Update database with schemaData for future loads
-                        const schemaData = JSON.stringify(schemaFile, null, 2);
-                        await addSchemaToDb({
-                            name: schemaName,
-                            version: dbSchema.version,
-                            createdAt: dbSchema.createdAt || new Date().getTime(),
-                            updatedAt: new Date().getTime(),
-                        }, dbSchema.schemaFileId || schemaFile.id, schemaData, false);
-                        // Query model IDs from database to populate _liveQueryModelIds immediately
-                        let modelIds = [];
-                        if (dbSchema.id) {
-                            modelIds = await getModelIdsForSchema$1(dbSchema.id);
-                            // Create Model instances so they're cached before getContext runs
-                            await createModelInstances$2(modelIds, evictionEpoch);
-                        }
-                        sendBack({
-                            type: 'loadOrCreateSchemaSuccess',
-                            schema: schemaFile,
-                            _liveQueryModelIds: modelIds,
-                        });
-                        return;
-                    }
-                    catch (error) {
-                        logger$d(`Error loading internal seed-protocol schema:`, error);
-                        // Fall through to file-based loading
-                    }
-                }
-            }
-        }
-        // STEP 2: Check for existing schema files (for backward compatibility)
-        // BUT: Only load from file if we didn't find a draft in the database
-        // This prevents loading old file data when a draft with a renamed schema exists
-        const completeSchemas = await listCompleteSchemaFiles();
-        const matchingSchemas = completeSchemas.filter((s) => s.name === schemaName);
-        if (matchingSchemas.length > 0) {
-            // Before loading from file, check if there's a draft in the database that might match
-            // (This handles the case where the schema was renamed but the file still has the old name)
-            const allDrafts = await db
-                .select()
-                .from(schemas)
-                .where(eq(schemas.isDraft, true))
-                .orderBy(desc(schemas.version));
-            const normalizeName = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, '');
-            const normalizedRequested = normalizeName(schemaName);
-            // Check if any draft matches by normalized name
-            let matchingDraft = null;
-            for (const draft of allDrafts) {
-                if (draft.schemaData) {
-                    try {
-                        const draftSchema = JSON.parse(draft.schemaData);
-                        const draftMetadataName = draftSchema.metadata?.name || '';
-                        const draftDbName = draft.name || '';
-                        const normalizedDraftMetadata = normalizeName(draftMetadataName);
-                        const normalizedDraftDb = normalizeName(draftDbName);
-                        if (normalizedDraftMetadata === normalizedRequested || normalizedDraftDb === normalizedRequested) {
-                            matchingDraft = draft;
-                            logger$d(`Found matching draft in database (DB name: "${draftDbName}", metadata.name: "${draftMetadataName}") - preferring it over file with old name "${schemaName}"`);
-                            break;
-                        }
-                    }
-                    catch {
-                        continue;
-                    }
-                }
-            }
-            // If we found a matching draft, use it instead of the file
-            if (matchingDraft && matchingDraft.schemaData) {
-                try {
-                    const schemaFile = JSON.parse(matchingDraft.schemaData);
-                    logger$d(`Loading draft from database instead of file (draft has name "${matchingDraft.name}", file has "${schemaName}")`);
-                    // Query model IDs from database to populate _liveQueryModelIds immediately
-                    let modelIds = [];
-                    if (matchingDraft.id) {
-                        modelIds = await getModelIdsForSchema$1(matchingDraft.id);
-                        // Create Model instances so they're cached before getContext runs
-                        await createModelInstances$2(modelIds, evictionEpoch);
-                    }
-                    // Track conflict detection metadata
-                    const loadedAt = Date.now();
-                    const dbVersion = matchingDraft.version || schemaFile.version;
-                    const dbUpdatedAt = matchingDraft.updatedAt || loadedAt;
-                    sendBack({
-                        type: 'loadOrCreateSchemaSuccess',
-                        schema: schemaFile,
-                        loadedAt,
-                        dbVersion,
-                        dbUpdatedAt,
-                        _liveQueryModelIds: modelIds,
-                    });
-                    return;
-                }
-                catch (error) {
-                    logger$d(`Error parsing draft schemaData, falling back to file: ${error}`);
-                }
-            }
-            // No matching draft found, proceed with loading from file
-            // Find the schema with the highest version
-            const latest = matchingSchemas.reduce((prev, current) => current.version > prev.version ? current : prev);
-            // Read the file directly to get SchemaFileFormat
-            const content = await BaseFileManager.readFileAsString(latest.filePath);
-            const schemaFile = JSON.parse(content);
-            // Build merged models without mutating schemaFile (read-only approach)
-            let mergedModels = { ...(schemaFile.models || {}) };
-            // Ensure models are populated (fallback for seed-protocol if missing)
-            if ((!mergedModels || Object.keys(mergedModels).length === 0) && schemaName === 'Seed Protocol') {
-                try {
-                    const _mod_6 = await import('./ClientManager-B1r_8P5Z.js');
-                    const _ns_6 = _mod_6.Y;
-                    const internalSchema = _ns_6;
-                    const internalSchemaFile = internalSchema.default;
-                    mergedModels = { ...(internalSchemaFile.models || {}) };
-                    logger$d(`Populated models for seed-protocol schema from internal file`);
-                }
-                catch (error) {
-                    logger$d(`Error loading internal seed-protocol schema for models:`, error);
-                }
-            }
-            logger$d(`Found existing schema ${schemaName} v${schemaFile.version} from file`);
-            // Query model IDs from database if schema exists in DB
-            let modelIds = [];
-            try {
-                const db = BaseDb.getAppDb();
-                if (db && schemaFile.id) {
-                    const schemaRecords = await db
-                        .select()
-                        .from(schemas)
-                        .where(eq(schemas.schemaFileId, schemaFile.id))
-                        .limit(1);
-                    if (schemaRecords.length > 0 && schemaRecords[0].id) {
-                        modelIds = await getModelIdsForSchema$1(schemaRecords[0].id);
-                        // Create Model instances so they're cached before getContext runs
-                        await createModelInstances$2(modelIds, evictionEpoch);
-                    }
-                }
-            }
-            catch (error) {
-                logger$d(`Error querying model IDs for schema from file: ${error}`);
-            }
-            // Track conflict detection metadata (no DB record, use file metadata)
-            const loadedAt = Date.now();
-            const dbVersion = schemaFile.version;
-            const dbUpdatedAt = new Date(schemaFile.metadata.updatedAt).getTime() || loadedAt;
-            sendBack({
-                type: 'loadOrCreateSchemaSuccess',
-                schema: schemaFile,
-                loadedAt,
-                dbVersion,
-                dbUpdatedAt,
-                _liveQueryModelIds: modelIds,
-            });
-            return;
-        }
-        // STEP 3: Before creating new schema, check database one more time for any existing record
-        // This handles the case where a schema exists in DB but wasn't found by name (e.g., name mismatch)
-        // or where the file lookup failed but the DB has the correct schemaFileId
-        let existingDbSchema;
-        try {
-            const dbCheck = await db
-                .select()
-                .from(schemas)
-                .where(eq(schemas.name, schemaName))
-                .orderBy(desc(schemas.version))
-                .limit(1);
-            if (dbCheck.length > 0) {
-                const foundSchema = dbCheck[0];
-                existingDbSchema = foundSchema;
-                logger$d(`Found existing DB record for "${schemaName}" before creating new schema (schemaFileId: ${foundSchema.schemaFileId}, isDraft: ${foundSchema.isDraft})`);
-                // If we have a schemaFileId, check if file exists with that ID
-                if (foundSchema.schemaFileId) {
-                    const filePath = getSchemaFilePath$2(schemaName, foundSchema.version, foundSchema.schemaFileId);
-                    const fileExists = await BaseFileManager.pathExists(filePath);
-                    if (fileExists) {
-                        logger$d(`File exists for schemaFileId ${foundSchema.schemaFileId}, loading it instead of creating new schema`);
-                        const content = await BaseFileManager.readFileAsString(filePath);
-                        const schemaFile = JSON.parse(content);
-                        // Ensure schema.id matches schemaFileId from database
-                        if (schemaFile.id !== foundSchema.schemaFileId) {
-                            logger$d(`Fixing schema ID mismatch: file has id="${schemaFile.id}", DB has schemaFileId="${foundSchema.schemaFileId}". Using DB value.`);
-                            schemaFile.id = foundSchema.schemaFileId;
-                        }
-                        // Query model IDs from database to populate _liveQueryModelIds immediately
-                        let modelIds = [];
-                        if (foundSchema.id) {
-                            modelIds = await getModelIdsForSchema$1(foundSchema.id);
-                            // Create Model instances so they're cached before getContext runs
-                            await createModelInstances$2(modelIds, evictionEpoch);
-                        }
-                        // Track conflict detection metadata
-                        const loadedAt = Date.now();
-                        const dbVersion = foundSchema.version || schemaFile.version;
-                        const dbUpdatedAt = foundSchema.updatedAt || loadedAt;
-                        sendBack({
-                            type: 'loadOrCreateSchemaSuccess',
-                            schema: schemaFile,
-                            loadedAt,
-                            dbVersion,
-                            dbUpdatedAt,
-                            _liveQueryModelIds: modelIds,
-                        });
-                        return;
-                    }
-                }
-                // If it's a draft, load it from schemaData
-                if (foundSchema.isDraft === true && foundSchema.schemaData) {
-                    try {
-                        const schemaFile = JSON.parse(foundSchema.schemaData);
-                        // Ensure schema.id matches schemaFileId from database
-                        if (foundSchema.schemaFileId && schemaFile.id !== foundSchema.schemaFileId) {
-                            logger$d(`Fixing schema ID mismatch: schemaData has id="${schemaFile.id}", DB has schemaFileId="${foundSchema.schemaFileId}". Using DB value.`);
-                            schemaFile.id = foundSchema.schemaFileId;
-                        }
-                        logger$d(`Loading existing draft from database instead of creating new schema`);
-                        // Query model IDs from database to populate _liveQueryModelIds immediately
-                        let modelIds = [];
-                        if (foundSchema.id) {
-                            modelIds = await getModelIdsForSchema$1(foundSchema.id);
-                            // Create Model instances so they're cached before getContext runs
-                            await createModelInstances$2(modelIds, evictionEpoch);
-                        }
-                        // Track conflict detection metadata
-                        const loadedAt = Date.now();
-                        const dbVersion = foundSchema.version || schemaFile.version;
-                        const dbUpdatedAt = foundSchema.updatedAt || loadedAt;
-                        sendBack({
-                            type: 'loadOrCreateSchemaSuccess',
-                            schema: schemaFile,
-                            loadedAt,
-                            dbVersion,
-                            dbUpdatedAt,
-                            _liveQueryModelIds: modelIds,
-                        });
-                        return;
-                    }
-                    catch (error) {
-                        logger$d(`Error parsing existing draft schemaData: ${error}, will create new schema`);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            logger$d(`Error checking database before creating new schema: ${error}, proceeding with creation`);
-        }
-        // STEP 4: Create new schema as draft in database (NOT in file yet)
-        const latestVersion = existingDbSchema?.version ? existingDbSchema.version + 1 : await getLatestSchemaVersion(schemaName);
-        const newVersion = latestVersion + 1;
-        const now = new Date().toISOString();
-        const newSchema = {
-            $schema: 'https://seedprotocol.org/schemas/data-model/v1',
-            version: newVersion,
-            id: generateId(), // Generate schema ID when first written
-            metadata: {
-                name: schemaName,
-                createdAt: now,
-                updatedAt: now,
-            },
-            models: {},
-            enums: {},
-            migrations: [
-                {
-                    version: newVersion,
-                    timestamp: now,
-                    description: 'Initial schema',
-                    changes: [],
-                },
-            ],
-        };
-        // Save to database as draft FIRST (before creating any file)
-        const schemaData = JSON.stringify(newSchema, null, 2);
-        await addSchemaToDb({
-            name: schemaName,
-            version: newVersion,
-            createdAt: new Date(now).getTime(),
-            updatedAt: new Date(now).getTime(),
-        }, newSchema.id, // schemaFileId
-        schemaData, // Full schema content
-        true);
-        logger$d(`Created new draft schema ${schemaName} v${newVersion} in database`);
-        // Query model IDs from database for newly created schema
-        let modelIds = [];
-        try {
-            const db = BaseDb.getAppDb();
-            if (db && newSchema.id) {
-                const schemaRecords = await db
-                    .select()
-                    .from(schemas)
-                    .where(eq(schemas.schemaFileId, newSchema.id))
-                    .limit(1);
-                if (schemaRecords.length > 0 && schemaRecords[0].id) {
-                    modelIds = await getModelIdsForSchema$1(schemaRecords[0].id);
-                    // Create Model instances so they're cached before getContext runs
-                    await createModelInstances$2(modelIds, evictionEpoch);
-                }
-            }
-        }
-        catch (error) {
-            logger$d(`Error querying model IDs for new schema: ${error}`);
-        }
-        // Track conflict detection metadata for new schema
-        const loadedAt = Date.now();
-        const dbVersion = newVersion;
-        const dbUpdatedAt = new Date(now).getTime();
-        sendBack({
-            type: 'loadOrCreateSchemaSuccess',
-            schema: newSchema,
-            loadedAt,
-            dbVersion,
-            dbUpdatedAt,
-            _liveQueryModelIds: modelIds,
-        });
-    };
-    _loadOrCreateSchema().catch((error) => {
-        logger$d('Error loading or creating schema:', error);
-        sendBack({ type: 'loadOrCreateSchemaError', error });
-    });
-    return () => {
-        // Cleanup function (optional)
-    };
-});
+import { aj as ActorKeyedState, N as DEFAULT_READY_TIMEOUT_MS, B as waitForEntityIdle, P as createReactiveProxy, R as findEntity, W as ClientManagerState, ak as clearDestroySubscriptions, S as forceRemoveFromCaches, al as unloadEntity, T as runDestroyLifecycle } from './Item-0oDoTPhi.js';
 
 const validationService = new SchemaValidationService();
 // Validation timeout in milliseconds (10 seconds)
@@ -1378,9 +123,9 @@ const createModelInstances$1 = async (modelIds, evictionEpoch) => {
         return;
     }
     try {
-        const _mod_7 = await import('./errors-rIWK7gwJ.js');
-        const _ns_7 = _mod_7.i;
-        const mod = _ns_7;
+        const _mod_0 = await import('./errors-D1zHAqjr.js');
+        const _ns_0 = _mod_0.i;
+        const mod = _ns_0;
         const Model = mod?.Model ?? mod?.default;
         if (!Model) {
             logger$c('Model not available from dynamic import');
@@ -1430,9 +175,9 @@ const checkExistingSchema = fromCallback(({ sendBack, input: { context } }) => {
         if (isInternal && schemaName === SEED_PROTOCOL_SCHEMA_NAME) {
             // For Seed Protocol, check if it exists in database
             try {
-                const _mod_8 = await import('./ClientManager-B1r_8P5Z.js');
-                const _ns_8 = _mod_8.Y;
-                const internalSchema = _ns_8;
+                const _mod_1 = await import('./ClientManager-GZfXErDX.js');
+                const _ns_1 = _mod_1.T;
+                const internalSchema = _ns_1;
                 const schemaFile = internalSchema.default;
                 if (db && schemaFile.id) {
                     const existing = await db
@@ -1766,9 +511,9 @@ const writeSchemaToDb = fromCallback(({ sendBack, input }) => {
             if (isInternal && schemaName === SEED_PROTOCOL_SCHEMA_NAME) {
                 // For Seed Protocol, load from internal file
                 logger$b(`Loading internal Seed Protocol schema from SDK`);
-                const _mod_9 = await import('./ClientManager-B1r_8P5Z.js');
-                const _ns_9 = _mod_9.Y;
-                const internalSchema = _ns_9;
+                const _mod_2 = await import('./ClientManager-GZfXErDX.js');
+                const _ns_2 = _mod_2.T;
+                const internalSchema = _ns_2;
                 finalSchema = internalSchema.default;
                 const db = BaseDb.getAppDb();
                 if (db && finalSchema.id) {
@@ -2239,9 +984,9 @@ const createModelInstances = fromCallback(({ sendBack, input }) => {
             return;
         }
         try {
-            const _mod_10 = await import('./errors-rIWK7gwJ.js');
-            const _ns_10 = _mod_10.i;
-            const modelMod = _ns_10;
+            const _mod_3 = await import('./errors-D1zHAqjr.js');
+            const _ns_3 = _mod_3.i;
+            const modelMod = _ns_3;
             const { Model } = modelMod;
             // Create instances for all model IDs in parallel
             // Model.createById() will check cache first, then query DB and create if needed
@@ -2331,9 +1076,9 @@ const verifyModelInstancesInCache = fromCallback(({ sendBack, input }) => {
         }
         try {
             const result = await verifyWithRetry$2(async () => {
-                const _mod_11 = await import('./errors-rIWK7gwJ.js');
-                const _ns_11 = _mod_11.i;
-                const modelMod = _ns_11;
+                const _mod_4 = await import('./errors-D1zHAqjr.js');
+                const _ns_4 = _mod_4.i;
+                const modelMod = _ns_4;
                 const { Model } = modelMod;
                 // Check each model ID in the cache
                 const verifiedInstances = [];
@@ -2390,9 +1135,9 @@ const writePropertiesToDb = fromCallback(({ sendBack, input }) => {
     const _write = async () => {
         const { modelIds } = input;
         try {
-            const _mod_12 = await import('./index-C0SetTd1.js');
-            const _ns_12 = _mod_12.bj;
-            const modelSchemaMod = _ns_12;
+            const _mod_5 = await import('./index-Dx_GTdyQ.js');
+            const _ns_5 = _mod_5.ba;
+            const modelSchemaMod = _ns_5;
             const { models: modelsTable, properties: propertiesTable } = modelSchemaMod;
             const drizzleMod = await import('drizzle-orm');
             const { eq } = drizzleMod;
@@ -2580,11 +1325,11 @@ const createPropertyInstances = fromCallback(({ sendBack, input }) => {
             return;
         }
         try {
-            const modProp = await import('./ModelProperty-C3749Wjq.js');
+            const modProp = await import('./ModelProperty-i5flwzQG.js');
             const ModelProperty = modProp?.ModelProperty ?? modProp?.default;
-            const _mod_13 = await import('./errors-rIWK7gwJ.js');
-            const _ns_13 = _mod_13.i;
-            const modModel = _ns_13;
+            const _mod_6 = await import('./errors-D1zHAqjr.js');
+            const _ns_6 = _mod_6.i;
+            const modModel = _ns_6;
             const Model = modModel?.Model ?? modModel?.default;
             if (!ModelProperty || !Model) {
                 logger$3('ModelProperty or Model not available from dynamic import');
@@ -2689,7 +1434,7 @@ const verifyPropertyInstancesInCache = fromCallback(({ sendBack, input }) => {
         }
         try {
             const result = await verifyWithRetry(async () => {
-                const mod = await import('./ModelProperty-C3749Wjq.js');
+                const mod = await import('./ModelProperty-i5flwzQG.js');
                 const ModelProperty = mod?.ModelProperty ?? mod?.default;
                 if (!ModelProperty) {
                     throw new Error('ModelProperty not available from dynamic import');
@@ -2747,9 +1492,7 @@ const schemaMachine = setup({
         events: {},
     },
     actors: {
-        loadOrCreateSchema,
         validateSchema,
-        writeProcessMachine,
         // Staged loading actors
         checkExistingSchema,
         writeSchemaToDb,
@@ -2779,34 +1522,47 @@ const schemaMachine = setup({
         _liveQueryModelIds: [],
     }),
     on: {
-        updateContext: {
-            actions: assign(({ context, event }) => {
-                const newContext = Object.assign({}, context);
-                // Check if this is only updating internal fields
-                Object.keys(event).every((key) => {
-                    return key === 'type' || key.startsWith('_');
-                });
-                for (let i = 0; i < Object.keys(event).length; i++) {
-                    const key = Object.keys(event)[i];
-                    if (key === 'type') {
-                        continue;
+        updateContext: [{
+                actions: assign(({ context, event }) => {
+                    const newContext = Object.assign({}, context);
+                    // Check if this is only updating internal fields
+                    Object.keys(event).every((key) => {
+                        return key === 'type' || key.startsWith('_');
+                    });
+                    for (let i = 0; i < Object.keys(event).length; i++) {
+                        const key = Object.keys(event)[i];
+                        if (key === 'type') {
+                            continue;
+                        }
+                        if (key in newContext || key.startsWith('_')) {
+                            newContext[key] = event[key];
+                        }
                     }
-                    if (key in newContext || key.startsWith('_')) {
-                        newContext[key] = event[key];
+                    // Clear validation errors on context update (will be re-validated if needed)
+                    newContext._validationErrors = undefined;
+                    return newContext;
+                }),
+                // Only trigger validation if we're updating non-internal fields
+                guard: ({ event }) => {
+                    return !Object.keys(event).every((key) => {
+                        return key === 'type' || key.startsWith('_');
+                    });
+                },
+                target: '.validating',
+            }, {
+                // Internal-only updates (e.g. the _dbUpdatedAt refresh after a draft save) are applied
+                // without re-validating. Dropping them made the next save's conflict check compare
+                // against a stale _dbUpdatedAt.
+                actions: assign(({ context, event }) => {
+                    const newContext = Object.assign({}, context);
+                    for (const key of Object.keys(event)) {
+                        if (key.startsWith('_')) {
+                            newContext[key] = event[key];
+                        }
                     }
-                }
-                // Clear validation errors on context update (will be re-validated if needed)
-                newContext._validationErrors = undefined;
-                return newContext;
-            }),
-            // Only trigger validation if we're updating non-internal fields
-            guard: ({ event }) => {
-                return !Object.keys(event).every((key) => {
-                    return key === 'type' || key.startsWith('_');
-                });
-            },
-            target: '.validating',
-        },
+                    return newContext;
+                }),
+            }],
         validateSchema: {
             target: '.validating',
         },
@@ -3209,61 +1965,8 @@ const schemaMachine = setup({
                     },
                 },
             },
-            on: {
-                // Keep backward compatibility with old loadOrCreateSchema (for external callers)
-                loadOrCreateSchemaSuccess: {
-                    target: 'idle',
-                    actions: assign(({ event }) => {
-                        return {
-                            schemaName: event.schema.metadata.name,
-                            $schema: event.schema.$schema,
-                            version: event.schema.version,
-                            metadata: event.schema.metadata,
-                            models: event.schema.models,
-                            enums: event.schema.enums,
-                            migrations: event.schema.migrations,
-                            nameMatch: event.schema.nameMatch,
-                            _isDraft: false,
-                            _editedProperties: new Set(),
-                            _validationErrors: undefined,
-                            id: event.schema.id, // schemaFileId (string)
-                            _dbId: event._dbId, // Database integer ID
-                            _loadedAt: event.loadedAt,
-                            _dbVersion: event.dbVersion,
-                            _dbUpdatedAt: event.dbUpdatedAt,
-                            _liveQueryModelIds: event._liveQueryModelIds || [],
-                        };
-                    }),
-                },
-                loadOrCreateSchemaError: {
-                    target: 'error',
-                },
-            },
         },
         idle: {
-            entry: assign({
-                writeProcess: ({ spawn, context }) => {
-                    if (!context.writeProcess && context.id) {
-                        return spawn(writeProcessMachine, {
-                            input: {
-                                entityType: 'schema',
-                                entityId: context.id,
-                                entityData: {
-                                    name: context.schemaName,
-                                    $schema: context.$schema,
-                                    version: context.version,
-                                    metadata: context.metadata,
-                                    models: context.models,
-                                    enums: context.enums,
-                                    migrations: context.migrations,
-                                    nameMatch: context.nameMatch,
-                                },
-                            },
-                        });
-                    }
-                    return context.writeProcess;
-                },
-            }),
             on: {
                 validateSchema: {
                     target: 'validating',
@@ -3271,16 +1974,6 @@ const schemaMachine = setup({
                 reloadFromDb: {
                     target: 'loading',
                 },
-                requestWrite: {
-                    actions: ({ context, event }) => {
-                        if (context.writeProcess) {
-                            context.writeProcess.send({
-                                type: 'startWrite',
-                                data: event.data,
-                            });
-                        }
-                    },
-                },
             },
             // No `always: hasValidationErrors -> validating` here: validation is re-run when the context changes
             // (updateContext) or on request (validateSchema). Re-entering while errors exist would loop
@@ -3709,9 +2402,9 @@ async function loadSchemaWithRenames(schemaFilePath, modelRenames) {
         updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
     };
     // Use dynamic import to break circular dependency
-    const _mod_14 = await import('./index-C0SetTd1.js');
-    const _ns_14 = _mod_14.bo;
-    const dbMod = _ns_14;
+    const _mod_7 = await import('./index-Dx_GTdyQ.js');
+    const _ns_7 = _mod_7.bf;
+    const dbMod = _ns_7;
     const { addSchemaToDb, addModelsToDb } = dbMod;
     // Add schema to database with schemaFileId
     const schemaRecord = await addSchemaToDb(schemaInput, schemaFile.id);
@@ -3833,9 +2526,9 @@ async function renameModelProperty(schemaName, modelName, oldPropertyName, newPr
     await BaseFileManager.waitForFileWithContent(newFilePath);
     logger$1(`Renamed property ${oldPropertyName} to ${newPropertyName} in schema ${schemaName} v${newVersion}`);
     // Migrate metadata rows so ItemProperty values follow the new name (prevents duplicate ItemProperties)
-    const _mod_15 = await import('./index-C0SetTd1.js');
-    const _ns_15 = _mod_15.bo;
-    const { migrateMetadataForPropertyRename } = _ns_15;
+    const _mod_8 = await import('./index-Dx_GTdyQ.js');
+    const _ns_8 = _mod_8.bf;
+    const { migrateMetadataForPropertyRename } = _ns_8;
     const migratedCount = await migrateMetadataForPropertyRename(modelName, oldPropertyName, newPropertyName, oldProperty.id, { schemaName });
     if (migratedCount > 0) {
         logger$1(`Migrated ${migratedCount} metadata rows for property rename`);
@@ -3852,238 +2545,10 @@ async function renameModelProperty(schemaName, modelName, oldPropertyName, newPr
     deferredSchemaReloads.add(reload);
     return newFilePath;
 }
-/**
- * Delete a model from a schema
- * @param schemaName - The name of the schema
- * @param modelName - The name of the model to delete
- * @param options - Optional deletion options
- * @returns The file path of the new schema version
- * @throws Error if schema or model not found
- */
-async function deleteModelFromSchema(schemaName, modelName, options = {}) {
-    const { removeReferencingProperties = false } = options;
-    // Get the latest version
-    const latestVersion = await 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(schemaName, latestVersion, schemaFileId);
-    const content = await BaseFileManager.readFileAsString(latestFilePath);
-    const schemaFile = JSON.parse(content);
-    if (!schemaFile.$schema) {
-        throw new Error(`Schema file ${latestFilePath} is not a complete schema file`);
-    }
-    if (!schemaFile.models[modelName]) {
-        throw new Error(`Model ${modelName} not found in schema ${schemaName}`);
-    }
-    // Create new version without the model
-    // Preserve IDs for remaining models and properties
-    const newVersion = latestVersion + 1;
-    const updatedSchema = {
-        ...schemaFile,
-        version: newVersion,
-        id: schemaFile.id, // Preserve schema ID
-        metadata: {
-            ...schemaFile.metadata,
-            updatedAt: new Date().toISOString(),
-        },
-        // Preserve IDs for remaining models and their properties
-        models: Object.fromEntries(Object.entries(schemaFile.models)
-            .filter(([name]) => name !== modelName)
-            .map(([name, model]) => [
-            name,
-            {
-                ...model,
-                id: model.id, // Preserve model ID
-                properties: Object.fromEntries(Object.entries(model.properties).map(([propName, prop]) => [
-                    propName,
-                    { ...prop, id: prop.id }, // Preserve property ID
-                ])),
-            },
-        ])),
-        migrations: [
-            ...schemaFile.migrations,
-            {
-                version: newVersion,
-                timestamp: new Date().toISOString(),
-                description: `Deleted model ${modelName} from schema`,
-                changes: [
-                    {
-                        type: 'model_delete',
-                        modelName,
-                        removeReferencingProperties,
-                    },
-                ],
-            },
-        ],
-    };
-    // Remove the model
-    delete updatedSchema.models[modelName];
-    // Handle properties that reference this model
-    const propertiesToRemove = [];
-    for (const [otherModelName, model] of Object.entries(updatedSchema.models)) {
-        for (const [propertyName, property] of Object.entries(model.properties)) {
-            // Check if property references the deleted model
-            if (property.model === modelName || property.ref === modelName || property.items?.model === modelName) {
-                if (removeReferencingProperties) {
-                    // Mark for removal
-                    propertiesToRemove.push({ modelName: otherModelName, propertyName });
-                }
-                else {
-                    // Remove the reference (set to null or remove model field)
-                    if (property.model === modelName) {
-                        delete property.model;
-                    }
-                    if (property.ref === modelName && (isDataType(property.type, ModelPropertyDataTypes.List) || isDataType(property.dataType, ModelPropertyDataTypes.List))) {
-                        delete property.ref;
-                    }
-                    if (property.items?.model === modelName) {
-                        delete property.items.model;
-                    }
-                }
-            }
-        }
-    }
-    // Remove properties if requested
-    if (removeReferencingProperties) {
-        for (const { modelName: mName, propertyName } of propertiesToRemove) {
-            delete updatedSchema.models[mName].properties[propertyName];
-            updatedSchema.migrations[updatedSchema.migrations.length - 1].changes.push({
-                type: 'property_delete',
-                modelName: mName,
-                propertyName,
-                reason: `Referenced deleted model ${modelName}`,
-            });
-        }
-    }
-    else {
-        // Update migration to note which properties were updated
-        const updatedProperties = [];
-        for (const [otherModelName, model] of Object.entries(updatedSchema.models)) {
-            for (const [propertyName, property] of Object.entries(model.properties)) {
-                if (property.model === modelName || property.ref === modelName || property.items?.model === modelName) {
-                    updatedProperties.push({ modelName: otherModelName, propertyName });
-                }
-            }
-        }
-        if (updatedProperties.length > 0) {
-            updatedSchema.migrations[updatedSchema.migrations.length - 1].changes.push({
-                type: 'properties_updated',
-                properties: updatedProperties,
-                reason: `Removed references to deleted model ${modelName}`,
-            });
-        }
-    }
-    // Write the new schema version using ID-based naming (preferred)
-    const newFilePath = getSchemaFilePath(schemaName, newVersion, updatedSchema.id ?? undefined);
-    const newContent = JSON.stringify(updatedSchema, null, 2);
-    // Ensure the directory exists before saving
-    const path = BaseFileManager.getPathModule();
-    const dir = path.dirname(newFilePath);
-    await BaseFileManager.createDirIfNotExists(dir);
-    await 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 BaseFileManager.waitForFileWithContent(newFilePath);
-    logger$1(`Deleted model ${modelName} from schema ${schemaName} v${newVersion}`);
-    // Load the new schema file
-    await loadSchemaFromFile(newFilePath);
-    return newFilePath;
-}
-/**
- * Delete a property from a model in a schema
- * @param schemaName - The name of the schema
- * @param modelName - The name of the model
- * @param propertyName - The name of the property to delete
- * @param options - Optional deletion options
- * @returns The file path of the new schema version
- * @throws Error if schema, model, or property not found
- */
-async function deletePropertyFromModel(schemaName, modelName, propertyName, _options = {}) {
-    // Get the latest version
-    const latestVersion = await 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(schemaName, latestVersion, schemaFileId);
-    const content = await BaseFileManager.readFileAsString(latestFilePath);
-    const schemaFile = JSON.parse(content);
-    if (!schemaFile.$schema) {
-        throw new Error(`Schema file ${latestFilePath} is not a complete schema file`);
-    }
-    const model = schemaFile.models[modelName];
-    if (!model) {
-        throw new Error(`Model ${modelName} not found in schema ${schemaName}`);
-    }
-    if (!model.properties[propertyName]) {
-        throw new Error(`Property ${propertyName} not found in model ${modelName} of schema ${schemaName}`);
-    }
-    // Create new version without the property
-    // Preserve IDs for schema, models, and remaining properties
-    const newVersion = latestVersion + 1;
-    const updatedSchema = {
-        ...schemaFile,
-        version: newVersion,
-        id: schemaFile.id, // Preserve schema ID
-        metadata: {
-            ...schemaFile.metadata,
-            updatedAt: new Date().toISOString(),
-        },
-        models: Object.fromEntries(Object.entries(schemaFile.models).map(([mName, m]) => [
-            mName,
-            {
-                ...m,
-                id: m.id, // Preserve model ID
-                properties: Object.fromEntries(Object.entries(m.properties)
-                    .filter(([propName]) => !(mName === modelName && propName === propertyName))
-                    .map(([propName, prop]) => [
-                    propName,
-                    { ...prop, id: prop.id }, // Preserve property ID
-                ])),
-            },
-        ])),
-        migrations: [
-            ...schemaFile.migrations,
-            {
-                version: newVersion,
-                timestamp: new Date().toISOString(),
-                description: `Deleted property ${modelName}.${propertyName} from schema`,
-                changes: [
-                    {
-                        type: 'property_delete',
-                        modelName,
-                        propertyName,
-                    },
-                ],
-            },
-        ],
-    };
-    // Write the new schema version using ID-based naming (preferred)
-    const newFilePath = getSchemaFilePath(schemaName, newVersion, updatedSchema.id ?? undefined);
-    const newContent = JSON.stringify(updatedSchema, null, 2);
-    // Ensure the directory exists before saving
-    const path = BaseFileManager.getPathModule();
-    const dir = path.dirname(newFilePath);
-    await BaseFileManager.createDirIfNotExists(dir);
-    await 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 BaseFileManager.waitForFileWithContent(newFilePath);
-    logger$1(`Deleted property ${propertyName} from model ${modelName} in schema ${schemaName} v${newVersion}`);
-    // Load the new schema file
-    await loadSchemaFromFile(newFilePath);
-    return newFilePath;
-}
 
 var updateSchema = /*#__PURE__*/Object.freeze({
     __proto__: null,
     convertPropertyToSchemaUpdate: convertPropertyToSchemaUpdate,
-    deleteModelFromSchema: deleteModelFromSchema,
-    deletePropertyFromModel: deletePropertyFromModel,
     getModelNameFromId: getModelNameFromId,
     renameModelProperty: renameModelProperty,
     updateModelProperties: updateModelProperties,
@@ -4834,7 +3299,7 @@ class Schema {
                 const modelDbId = modelInstance.getService().getSnapshot().context._dbId;
                 const db = BaseDb.getAppDb();
                 if (propertyContexts.length === 0 && modelDbId && db) {
-                    const { ModelProperty } = await import('./ModelProperty-C3749Wjq.js');
+                    const { ModelProperty } = await import('./ModelProperty-i5flwzQG.js');
                     const rows = await db.select().from(properties).where(eq(properties.modelId, modelDbId));
                     propertyContexts = rows.map((row) => {
                         const cached = row.schemaFileId ? ModelProperty.getById(row.schemaFileId) : undefined;
@@ -5000,7 +3465,7 @@ class Schema {
             savedSchema: publishedSchema,
         });
         // Clear edited flags on all ModelProperty instances and in database
-        const modelPropertyMod = await import('./ModelProperty-C3749Wjq.js');
+        const modelPropertyMod = await import('./ModelProperty-i5flwzQG.js');
         const { ModelProperty } = modelPropertyMod;
         for (const propertyKey of context._editedProperties) {
             const [modelName, propertyName] = propertyKey.split(':');
@@ -5023,9 +3488,9 @@ class Schema {
                 try {
                     if (db && modelName && propertyName) {
                         // Find this schema's model by name
-                        const _mod_16 = await import('./index-C0SetTd1.js');
-                        const _ns_16 = _mod_16.bn;
-                        const { resolveModelRecord } = _ns_16;
+                        const _mod_9 = await import('./index-Dx_GTdyQ.js');
+                        const _ns_9 = _mod_9.be;
+                        const { resolveModelRecord } = _ns_9;
                         const modelRecord = await resolveModelRecord(modelName, { schemaName: thisSchemaName }, db);
                         const modelRecords = modelRecord ? [modelRecord] : [];
                         if (modelRecords.length > 0) {
@@ -5655,12 +4120,12 @@ class Schema {
         // instances too, or a re-import would get them back with dangling _dbIds.
         if (schemaName) {
             const evictedModelNames = Model.evictForSchema(schemaName);
-            const { ModelProperty } = await import('./ModelProperty-C3749Wjq.js');
+            const { ModelProperty } = await import('./ModelProperty-i5flwzQG.js');
             ModelProperty.evictForModels(evictedModelNames, schemaName);
             // Evicting stops new writes but not ones already running; let those land before deleting their rows
-            const _mod_17 = await import('./errors-rIWK7gwJ.js');
-            const _ns_17 = _mod_17.h;
-            const { waitForInFlightWrites } = _ns_17;
+            const _mod_10 = await import('./errors-D1zHAqjr.js');
+            const _ns_10 = _mod_10.h;
+            const { waitForInFlightWrites } = _ns_10;
             await waitForInFlightWrites();
         }
         await runDestroyLifecycle(this, {
@@ -5691,7 +4156,7 @@ class Schema {
                         .map((r) => r.modelId)
                         .filter((id) => id != null)),
                 ];
-                const { detachModelRows } = await import('./detachRowsBeforeDelete-Bo_pky-R.js');
+                const { detachModelRows } = await import('./detachRowsBeforeDelete-DXFYSHRR.js');
                 await detachModelRows(db, modelIds);
                 await db.delete(modelSchemas).where(inArray(modelSchemas.schemaId, schemaIds));
                 for (const modelId of modelIds) {
@@ -5706,9 +4171,9 @@ class Schema {
                 // the destroyed schema back on the next Schema.all().
                 // Match on name as well as id: versions imported from complete schema files can each
                 // have their own id, and any version left behind would bring the schema back.
-                const _mod_18 = await import('./ClientManager-B1r_8P5Z.js');
-                const _ns_18 = _mod_18.X;
-                const { listCompleteSchemaFiles } = _ns_18;
+                const _mod_11 = await import('./ClientManager-GZfXErDX.js');
+                const _ns_11 = _mod_11.S;
+                const { listCompleteSchemaFiles } = _ns_11;
                 const files = await listCompleteSchemaFiles().catch(() => []);
                 const fs = await BaseFileManager.getFs();
                 const names = new Set([schemaName, metadataName].filter(Boolean));
@@ -5901,5 +4366,5 @@ var Schema$1 = /*#__PURE__*/Object.freeze({
     schemaInstanceState: schemaInstanceState
 });
 
-export { Schema as S, deletePropertyFromModel as a, Schema$1 as b, deleteModelFromSchema as d, renameModelProperty as r, schemaMachine as s, updateModelProperties as u };
-//# sourceMappingURL=Schema-CX9CTtho.js.map
+export { Schema as S, Schema$1 as a, renameModelProperty as r, schemaMachine as s, updateModelProperties as u };
+//# sourceMappingURL=Schema-PFZwG9Nl.js.map