@seedprotocol/sdk 0.7.9-next.1177.ga3e08ed → 0.7.9-next.1306.g4ff6582

package/dist/Schema-PFZwG9Nl.js

@@ -1,4370 +0,0 @@
-import { fromCallback, setup, assign, createActor } from 'xstate';
-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, 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 { 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)
-const VALIDATION_TIMEOUT_MS = 10000;
-const validateSchema = fromCallback(({ sendBack, input: { context } }) => {
-    let hasResponded = false;
-    // Timeout handler to ensure we always respond
-    const timeoutId = setTimeout(() => {
-        if (!hasResponded) {
-            hasResponded = true;
-            sendBack({
-                type: 'validationError',
-                errors: [{
-                        field: 'schema',
-                        message: `Schema validation timed out after ${VALIDATION_TIMEOUT_MS}ms`,
-                        code: 'validation_timeout',
-                        severity: 'error',
-                    }],
-            });
-        }
-    }, VALIDATION_TIMEOUT_MS);
-    // Run validation and ensure event is always sent back
-    // Use Promise.resolve().then() to ensure async event sending
-    // This prevents issues where synchronous validation might not trigger XState properly
-    Promise.resolve().then(() => {
-        try {
-            const result = validationService.validateSchema(context);
-            if (!hasResponded) {
-                hasResponded = true;
-                clearTimeout(timeoutId);
-                if (result.isValid) {
-                    sendBack({ type: 'validationSuccess', errors: [] });
-                }
-                else {
-                    sendBack({ type: 'validationError', errors: result.errors });
-                }
-            }
-        }
-        catch (error) {
-            if (!hasResponded) {
-                hasResponded = true;
-                clearTimeout(timeoutId);
-                // Ensure error is always sent back
-                sendBack({
-                    type: 'validationError',
-                    errors: [{
-                            field: 'schema',
-                            message: error instanceof Error ? error.message : 'Unknown validation error',
-                            code: 'validation_exception',
-                            severity: 'error',
-                        }],
-                });
-            }
-        }
-    });
-    return () => {
-        // Cleanup function - clear timeout if actor is stopped
-        clearTimeout(timeoutId);
-    };
-});
-
-const logger$c = debug('seedSdk:schema:actors:checkExistingSchema');
-/**
- * Query model IDs (schemaFileId) from database for a given schema
- */
-const getModelIdsForSchema = async (schemaId) => {
-    const db = BaseDb.getAppDb();
-    if (!db) {
-        logger$c('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$c(`Found ${modelIds.length} model IDs for schema (id: ${schemaId}): ${modelIds.join(', ')}`);
-        return modelIds;
-    }
-    catch (error) {
-        logger$c(`Error querying model IDs for schema ${schemaId}:`, error);
-        return [];
-    }
-};
-/**
- * Get the full file path for a schema
- */
-const getSchemaFilePath$1 = (name, version, schemaFileId) => {
-    const path = BaseFileManager.getPathModule();
-    const sanitizeSchemaName = (name) => {
-        return name
-            .replace(/[^a-zA-Z0-9\s_-]/g, '_')
-            .replace(/\s+/g, '_')
-            .replace(/^_+|_+$/g, '')
-            .replace(/_+/g, '_');
-    };
-    const sanitizedName = sanitizeSchemaName(name);
-    const filename = `${schemaFileId}_${sanitizedName}_v${version}.json`;
-    const workingDir = BaseFileManager.getWorkingDir();
-    return path.join(workingDir, filename);
-};
-/**
- * Create Model instances for all model IDs to ensure they're cached
- */
-const createModelInstances$1 = async (modelIds, evictionEpoch) => {
-    if (modelIds.length === 0) {
-        return;
-    }
-    try {
-        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');
-            return;
-        }
-        const createPromises = modelIds.map(async (modelFileId) => {
-            try {
-                // Not if the schema was evicted (Schema.destroy, test cleanup) since this check 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$c(`Created/cached Model instance for modelFileId "${modelFileId}"`);
-                }
-            }
-            catch (error) {
-                logger$c(`Error creating Model instance for modelFileId "${modelFileId}": ${error}`);
-            }
-        });
-        await Promise.all(createPromises);
-        logger$c(`Finished creating/caching ${modelIds.length} Model instances`);
-    }
-    catch (error) {
-        logger$c(`Error in createModelInstances: ${error}`);
-    }
-};
-const checkExistingSchema = fromCallback(({ sendBack, input: { context } }) => {
-    const evictionEpoch = currentEvictionEpoch();
-    const _check = async () => {
-        const { schemaName } = context;
-        if (!schemaName) {
-            sendBack({
-                type: 'schemaNotFound',
-            });
-            return;
-        }
-        const db = BaseDb.getAppDb();
-        if (!db) {
-            sendBack({
-                type: 'schemaNotFound',
-            });
-            return;
-        }
-        // Check if this is an internal SDK schema (Seed Protocol) — use static import so consumer bundles resolve correctly
-        const isInternal = isInternalSchema(schemaName);
-        if (isInternal && schemaName === SEED_PROTOCOL_SCHEMA_NAME) {
-            // For Seed Protocol, check if it exists in database
-            try {
-                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
-                        .select()
-                        .from(schemas)
-                        .where(eq(schemas.schemaFileId, schemaFile.id))
-                        .limit(1);
-                    if (existing.length > 0) {
-                        const schemaRecord = existing[0];
-                        let modelIds = [];
-                        if (schemaRecord.id) {
-                            modelIds = await getModelIdsForSchema(schemaRecord.id);
-                            await createModelInstances$1(modelIds, evictionEpoch);
-                        }
-                        sendBack({
-                            type: 'schemaFound',
-                            schema: schemaFile,
-                            schemaRecord,
-                            modelIds,
-                        });
-                        return;
-                    }
-                }
-            }
-            catch (error) {
-                logger$c(`Error checking internal Seed Protocol schema: ${error}`);
-            }
-        }
-        // STEP 1: Query database first for existing schema (prefer drafts)
-        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, try querying by schemaFileId
-        if (dbSchemas.length === 0) {
-            logger$c(`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$c(`Found schema by schemaFileId "${schemaName}" (name in DB: ${schemasByFileId[0].name})`);
-                dbSchemas = schemasByFileId;
-            }
-        }
-        // Try to find by schemaFileId from file
-        const shouldTrySchemaFileId = dbSchemas.length === 0 || (dbSchemas.length > 0 && dbSchemas[0].isDraft === false);
-        if (shouldTrySchemaFileId) {
-            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);
-                try {
-                    const content = await BaseFileManager.readFileAsString(latestFile.filePath);
-                    const fileSchema = JSON.parse(content);
-                    if (fileSchema.id) {
-                        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$c(`Found DRAFT by schemaFileId ${fileSchema.id}`);
-                            dbSchemas = draftsByFileId;
-                        }
-                        else {
-                            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];
-                                if (foundSchema.isDraft === true || dbSchemas.length === 0) {
-                                    dbSchemas = dbSchemasByFileId;
-                                }
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    logger$c(`Error reading file to get schemaFileId: ${error}`);
-                }
-            }
-            // Check all drafts for normalized name match
-            if (dbSchemas.length === 0) {
-                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);
-                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) {
-                                dbSchemas = [draft];
-                                break;
-                            }
-                        }
-                        catch {
-                            continue;
-                        }
-                    }
-                }
-            }
-        }
-        // If schema found in database, return it
-        if (dbSchemas.length > 0) {
-            const dbSchema = dbSchemas[0];
-            logger$c(`Found schema record: name="${dbSchema.name}", isDraft=${dbSchema.isDraft}`);
-            // Load schema from schemaData or file
-            let schemaFile = null;
-            if (dbSchema.isDraft === true && dbSchema.schemaData) {
-                try {
-                    schemaFile = JSON.parse(dbSchema.schemaData);
-                    // Ensure schema.id matches schemaFileId from database
-                    if (dbSchema.schemaFileId && schemaFile.id !== dbSchema.schemaFileId) {
-                        schemaFile.id = dbSchema.schemaFileId;
-                    }
-                    else if (!schemaFile.id && dbSchema.schemaFileId) {
-                        schemaFile.id = dbSchema.schemaFileId;
-                    }
-                    // Merge models from database
-                    if (dbSchema.id) {
-                        const dbModels = await loadModelsFromDbForSchema(dbSchema.id);
-                        if (Object.keys(dbModels).length > 0) {
-                            schemaFile.models = mergeDbModelsIntoSchemaModels(schemaFile.models, dbModels);
-                        }
-                    }
-                }
-                catch (error) {
-                    logger$c(`Error parsing schemaData: ${error}`);
-                }
-            }
-            else if (dbSchema.schemaFileId) {
-                // Try to load from file
-                try {
-                    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) {
-                        const content = await BaseFileManager.readFileAsString(idBasedMatch.filePath);
-                        schemaFile = JSON.parse(content);
-                    }
-                    else {
-                        const filePath = getSchemaFilePath$1(dbSchema.name, dbSchema.version, dbSchema.schemaFileId);
-                        try {
-                            const content = await BaseFileManager.readFileAsString(filePath);
-                            schemaFile = JSON.parse(content);
-                        }
-                        catch {
-                            // File doesn't exist
-                        }
-                    }
-                    // Ensure schema.id matches schemaFileId from database (database is source of truth)
-                    if (schemaFile && dbSchema.schemaFileId) {
-                        if (schemaFile.id !== dbSchema.schemaFileId) {
-                            logger$c(`Fixing schema ID mismatch: file has id="${schemaFile.id}", DB has schemaFileId="${dbSchema.schemaFileId}". Using DB value.`);
-                            schemaFile.id = dbSchema.schemaFileId;
-                        }
-                        else if (!schemaFile.id && dbSchema.schemaFileId) {
-                            logger$c(`Schema missing id, using schemaFileId from database: "${dbSchema.schemaFileId}"`);
-                            schemaFile.id = dbSchema.schemaFileId;
-                        }
-                    }
-                    if (schemaFile && dbSchema.id) {
-                        const dbModels = await loadModelsFromDbForSchema(dbSchema.id);
-                        if (Object.keys(dbModels).length > 0) {
-                            schemaFile.models = mergeDbModelsIntoSchemaModels(schemaFile.models, dbModels);
-                        }
-                    }
-                }
-                catch (error) {
-                    logger$c(`Error loading from file: ${error}`);
-                }
-            }
-            if (schemaFile) {
-                // Query model IDs and create instances
-                let modelIds = [];
-                if (dbSchema.id) {
-                    modelIds = await getModelIdsForSchema(dbSchema.id);
-                    await createModelInstances$1(modelIds, evictionEpoch);
-                }
-                const loadedAt = Date.now();
-                const dbVersion = dbSchema.version || schemaFile.version;
-                const dbUpdatedAt = dbSchema.updatedAt || loadedAt;
-                sendBack({
-                    type: 'schemaFound',
-                    schema: schemaFile,
-                    schemaRecord: dbSchema,
-                    modelIds,
-                    loadedAt,
-                    dbVersion,
-                    dbUpdatedAt,
-                });
-                return;
-            }
-        }
-        // Check for existing schema files (backward compatibility)
-        const completeSchemas = await listCompleteSchemaFiles();
-        const matchingSchemas = completeSchemas.filter((s) => s.name === schemaName);
-        if (matchingSchemas.length > 0) {
-            // Check for matching draft in database
-            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);
-            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;
-                            break;
-                        }
-                    }
-                    catch {
-                        continue;
-                    }
-                }
-            }
-            if (matchingDraft && matchingDraft.schemaData) {
-                try {
-                    const schemaFile = JSON.parse(matchingDraft.schemaData);
-                    let modelIds = [];
-                    if (matchingDraft.id) {
-                        modelIds = await getModelIdsForSchema(matchingDraft.id);
-                        await createModelInstances$1(modelIds, evictionEpoch);
-                    }
-                    const loadedAt = Date.now();
-                    const dbVersion = matchingDraft.version || schemaFile.version;
-                    const dbUpdatedAt = matchingDraft.updatedAt || loadedAt;
-                    sendBack({
-                        type: 'schemaFound',
-                        schema: schemaFile,
-                        schemaRecord: matchingDraft,
-                        modelIds,
-                        loadedAt,
-                        dbVersion,
-                        dbUpdatedAt,
-                    });
-                    return;
-                }
-                catch (error) {
-                    logger$c(`Error parsing draft schemaData: ${error}`);
-                }
-            }
-            // Load from file
-            const latest = matchingSchemas.reduce((prev, current) => current.version > prev.version ? current : prev);
-            const content = await BaseFileManager.readFileAsString(latest.filePath);
-            const schemaFile = JSON.parse(content);
-            // Query model IDs if schema exists in DB
-            let modelIds = [];
-            try {
-                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(schemaRecords[0].id);
-                        await createModelInstances$1(modelIds, evictionEpoch);
-                    }
-                }
-            }
-            catch (error) {
-                logger$c(`Error querying model IDs for schema from file: ${error}`);
-            }
-            const loadedAt = Date.now();
-            const dbVersion = schemaFile.version;
-            const dbUpdatedAt = new Date(schemaFile.metadata.updatedAt).getTime() || loadedAt;
-            sendBack({
-                type: 'schemaFound',
-                schema: schemaFile,
-                schemaRecord: null,
-                modelIds,
-                loadedAt,
-                dbVersion,
-                dbUpdatedAt,
-            });
-            return;
-        }
-        // No schema found
-        sendBack({
-            type: 'schemaNotFound',
-        });
-    };
-    _check().catch((error) => {
-        logger$c('Error in checkExistingSchema:', error);
-        sendBack({
-            type: 'schemaNotFound',
-        });
-    });
-    return () => {
-        // Cleanup function (optional)
-    };
-});
-
-const logger$b = debug('seedSdk:schema:actors:writeSchemaToDb');
-const writeSchemaToDb = fromCallback(({ sendBack, input }) => {
-    const _write = async () => {
-        const { schemaName, schemaFile, existingDbSchema } = input;
-        try {
-            // Check if this is an internal SDK schema (Seed Protocol) — use static import so consumer bundles resolve correctly
-            const isInternal = isInternalSchema(schemaName);
-            let finalSchema;
-            let schemaRecord;
-            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_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) {
-                    // Check if it exists in database
-                    const existing = await db
-                        .select()
-                        .from(schemas)
-                        .where(eq(schemas.schemaFileId, finalSchema.id))
-                        .limit(1);
-                    if (existing.length === 0) {
-                        // Add to database if not present
-                        const schemaData = JSON.stringify(finalSchema, null, 2);
-                        schemaRecord = await addSchemaToDb({
-                            name: schemaName,
-                            version: finalSchema.version,
-                            createdAt: new Date(finalSchema.metadata.createdAt).getTime(),
-                            updatedAt: new Date(finalSchema.metadata.updatedAt).getTime(),
-                        }, finalSchema.id, schemaData, false, // isDraft = false (it's a published internal schema)
-                        false);
-                        logger$b(`Added Seed Protocol schema to database`);
-                    }
-                    else {
-                        schemaRecord = existing[0];
-                        logger$b(`Seed Protocol schema already exists in database`);
-                    }
-                }
-                else {
-                    throw new Error('Database not available for Seed Protocol schema');
-                }
-            }
-            else if (schemaFile) {
-                // Use provided schema file
-                finalSchema = schemaFile;
-                // Ensure schema has an ID
-                if (!finalSchema.id) {
-                    finalSchema.id = generateId();
-                    logger$b(`Generated schema ID for schema: ${finalSchema.id}`);
-                }
-                const schemaData = JSON.stringify(finalSchema, null, 2);
-                schemaRecord = await addSchemaToDb({
-                    name: schemaName,
-                    version: finalSchema.version,
-                    createdAt: new Date(finalSchema.metadata.createdAt).getTime(),
-                    updatedAt: new Date(finalSchema.metadata.updatedAt).getTime(),
-                }, finalSchema.id, schemaData, true, // isDraft = true for new schemas
-                true);
-                logger$b(`Created schema ${schemaName} v${finalSchema.version} in database`);
-            }
-            else {
-                // Create new schema
-                const latestVersion = existingDbSchema?.version
-                    ? existingDbSchema.version + 1
-                    : await getLatestSchemaVersion(schemaName);
-                const newVersion = latestVersion + 1;
-                const now = new Date().toISOString();
-                finalSchema = {
-                    $schema: 'https://seedprotocol.org/schemas/data-model/v1',
-                    version: newVersion,
-                    id: generateId(),
-                    metadata: {
-                        name: schemaName,
-                        createdAt: now,
-                        updatedAt: now,
-                    },
-                    models: {},
-                    enums: {},
-                    migrations: [
-                        {
-                            version: newVersion,
-                            timestamp: now,
-                            description: 'Initial schema',
-                            changes: [],
-                        },
-                    ],
-                };
-                // Save to database as draft
-                const schemaData = JSON.stringify(finalSchema, null, 2);
-                schemaRecord = await addSchemaToDb({
-                    name: schemaName,
-                    version: newVersion,
-                    createdAt: new Date(now).getTime(),
-                    updatedAt: new Date(now).getTime(),
-                }, finalSchema.id, schemaData, true, // isDraft = true
-                true);
-                logger$b(`Created new draft schema ${schemaName} v${newVersion} in database`);
-            }
-            sendBack({
-                type: 'schemaWritten',
-                schemaRecord,
-                schema: finalSchema,
-            });
-        }
-        catch (error) {
-            logger$b(`Error writing schema to database: ${error}`);
-            sendBack({
-                type: 'writeError',
-                error: error instanceof Error ? error : new Error(String(error)),
-            });
-        }
-    };
-    _write().catch((error) => {
-        logger$b('Error in writeSchemaToDb:', error);
-        sendBack({
-            type: 'writeError',
-            error: error instanceof Error ? error : new Error(String(error)),
-        });
-    });
-    return () => {
-        // Cleanup function (optional)
-    };
-});
-
-const logger$a = debug('seedSdk:schema:actors:verifySchemaInDb');
-/**
- * Verify that a schema record exists in the database with retry logic
- * Uses exponential backoff: 100ms, 200ms, 400ms, 800ms, 1600ms
- * Total timeout: ~3.1 seconds
- */
-async function verifyWithRetry$4(verifyFn, maxRetries = 5, initialDelay = 100) {
-    let lastError = null;
-    let delay = initialDelay;
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-        try {
-            return await verifyFn();
-        }
-        catch (error) {
-            lastError = error instanceof Error ? error : new Error(String(error));
-            if (attempt < maxRetries - 1) {
-                logger$a(`Verification attempt ${attempt + 1} failed, retrying in ${delay}ms: ${lastError.message}`);
-                await new Promise(resolve => setTimeout(resolve, delay));
-                delay *= 2; // Exponential backoff
-            }
-        }
-    }
-    throw lastError || new Error('Verification failed after retries');
-}
-const verifySchemaInDb = fromCallback(({ sendBack, input }) => {
-    const _verify = async () => {
-        const { schemaFileId, expectedSchemaId } = input;
-        try {
-            const result = await verifyWithRetry$4(async () => {
-                const db = BaseDb.getAppDb();
-                if (!db) {
-                    throw new Error('Database not available');
-                }
-                // Query for schema by schemaFileId
-                const schemaRecords = await db
-                    .select()
-                    .from(schemas)
-                    .where(eq(schemas.schemaFileId, schemaFileId))
-                    .limit(1);
-                if (schemaRecords.length === 0) {
-                    throw new Error(`Schema with schemaFileId "${schemaFileId}" not found in database`);
-                }
-                const schemaRecord = schemaRecords[0];
-                // If expectedSchemaId is provided, verify it matches
-                if (expectedSchemaId !== undefined && schemaRecord.id !== expectedSchemaId) {
-                    throw new Error(`Schema ID mismatch: expected ${expectedSchemaId}, found ${schemaRecord.id}`);
-                }
-                logger$a(`Schema verified: schemaFileId="${schemaFileId}", schemaId=${schemaRecord.id}`);
-                return schemaRecord.id;
-            });
-            sendBack({
-                type: 'schemaVerified',
-                schemaId: result,
-            });
-        }
-        catch (error) {
-            logger$a(`Schema verification failed after retries: ${error}`);
-            sendBack({
-                type: 'verificationFailed',
-                stage: 'verifySchema',
-                error: error instanceof Error ? error : new Error(String(error)),
-            });
-        }
-    };
-    _verify().catch((error) => {
-        logger$a('Error in verifySchemaInDb:', error);
-        sendBack({
-            type: 'verificationFailed',
-            stage: 'verifySchema',
-            error: error instanceof Error ? error : new Error(String(error)),
-        });
-    });
-    return () => {
-        // Cleanup function (optional)
-    };
-});
-
-const logger$9 = debug('seedSdk:schema:actors:writeModelsToDb');
-const writeModelsToDb = fromCallback(({ sendBack, input }) => {
-    const _write = async () => {
-        const { schema, schemaRecord, schemaName } = input;
-        try {
-            // Check if models already exist in database
-            const db = BaseDb.getAppDb();
-            if (!db) {
-                throw new Error('Database not available');
-            }
-            // Check if models are linked to the schema
-            const modelLinks = await db
-                .select({
-                modelId: modelSchemas.modelId,
-                modelName: 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(schema.models || {});
-            const linkedModelNames = modelLinks
-                .map((link) => link.modelName)
-                .filter((n) => n !== null);
-            const missingModels = expectedModelNames.filter(name => !linkedModelNames.includes(name));
-            // If all models exist, skip writing
-            if (missingModels.length === 0 && modelLinks.length > 0) {
-                logger$9(`All models already exist in database for schema ${schemaName}`);
-                // Extract model IDs from database
-                const modelFileIds = [];
-                for (const link of modelLinks) {
-                    if (link.modelId) {
-                        const modelRecord = await db
-                            .select({ schemaFileId: models.schemaFileId })
-                            .from(models)
-                            .where(eq(models.id, link.modelId))
-                            .limit(1);
-                        if (modelRecord.length > 0 && modelRecord[0].schemaFileId) {
-                            modelFileIds.push(modelRecord[0].schemaFileId);
-                        }
-                    }
-                }
-                sendBack({
-                    type: 'modelsWritten',
-                    modelIds: modelFileIds,
-                });
-                return;
-            }
-            // Check if this is Seed Protocol schema (has different format) — use static import so consumer bundles resolve correctly
-            const isInternal = isInternalSchema(schemaName);
-            let importData;
-            if (isInternal && schemaName === SEED_PROTOCOL_SCHEMA_NAME) {
-                // Convert Seed Protocol schema format to JSON import format
-                importData = {
-                    name: schemaName,
-                    models: Object.fromEntries(Object.entries(schema.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,
-                                };
-                                // 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
-                                if (isDataType(schemaProp.dataType, ModelPropertyDataTypes.List) && schemaProp.refValueType) {
-                                    jsonProp.refValueType = schemaProp.refValueType;
-                                    if (schemaProp.ref || schemaProp.refModelName) {
-                                        jsonProp.ref = schemaProp.refModelName || schemaProp.ref;
-                                    }
-                                }
-                                // Handle storage configuration
-                                if (schemaProp.storageType || schemaProp.localStorageDir || schemaProp.filenameSuffix) {
-                                    jsonProp.storage = {
-                                        type: schemaProp.storageType === 'ItemStorage' ? 'ItemStorage' : 'PropertyStorage',
-                                        path: schemaProp.localStorageDir,
-                                        extension: schemaProp.filenameSuffix,
-                                    };
-                                }
-                                return [propName, jsonProp];
-                            })),
-                        },
-                    ])),
-                };
-            }
-            else {
-                // Standard schema format
-                importData = {
-                    name: schemaName,
-                    models: Object.fromEntries(Object.entries(schema.models || {}).map(([modelName, model]) => [
-                        modelName,
-                        {
-                            ...model,
-                            id: undefined,
-                            properties: model.properties || {},
-                        },
-                    ])),
-                };
-            }
-            // Generate schemaFileIds from JSON file and generate missing ones BEFORE creating models
-            const modelFileIds = new Map();
-            const propertyFileIds = new Map();
-            for (const [modelName, model] of Object.entries(schema.models || {})) {
-                // Generate model ID if missing
-                if (!model.id) {
-                    model.id = generateId();
-                    logger$9(`Generated model ID for ${modelName}: ${model.id}`);
-                }
-                modelFileIds.set(modelName, model.id);
-                const propIds = new Map();
-                for (const [propName, prop] of Object.entries(model.properties || {})) {
-                    // Generate property ID if missing
-                    if (!prop.id) {
-                        prop.id = generateId();
-                        logger$9(`Generated property ID for ${modelName}.${propName}: ${prop.id}`);
-                    }
-                    propIds.set(propName, prop.id);
-                }
-                if (propIds.size > 0) {
-                    propertyFileIds.set(modelName, propIds);
-                }
-            }
-            // Convert JSON models to Model classes. 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);
-            // Add models to database
-            if (Object.keys(modelDefinitions).length > 0) {
-                await addModelsToDb(modelDefinitions, schemaRecord, undefined, {
-                    schemaFileId: schema.id,
-                    modelFileIds,
-                    propertyFileIds,
-                }).finally(rowsWritten.settle);
-                logger$9(`Added ${Object.keys(modelDefinitions).length} models and their properties to database`);
-            }
-            // Extract model IDs that were written
-            const writtenModelIds = Array.from(modelFileIds.values());
-            sendBack({
-                type: 'modelsWritten',
-                modelIds: writtenModelIds,
-            });
-        }
-        catch (error) {
-            logger$9(`Error writing models to database: ${error}`);
-            sendBack({
-                type: 'writeError',
-                error: error instanceof Error ? error : new Error(String(error)),
-            });
-        }
-    };
-    _write().catch((error) => {
-        logger$9('Error in writeModelsToDb:', error);
-        sendBack({
-            type: 'writeError',
-            error: error instanceof Error ? error : new Error(String(error)),
-        });
-    });
-    return () => {
-        // Cleanup function (optional)
-    };
-});
-
-const logger$8 = debug('seedSdk:schema:actors:verifyModelsInDb');
-/**
- * Verify that model records exist in the database for a schema with retry logic
- */
-async function verifyWithRetry$3(verifyFn, maxRetries = 5, initialDelay = 100) {
-    let lastError = null;
-    let delay = initialDelay;
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-        try {
-            return await verifyFn();
-        }
-        catch (error) {
-            lastError = error instanceof Error ? error : new Error(String(error));
-            if (attempt < maxRetries - 1) {
-                logger$8(`Verification attempt ${attempt + 1} failed, retrying in ${delay}ms: ${lastError.message}`);
-                await new Promise(resolve => setTimeout(resolve, delay));
-                delay *= 2; // Exponential backoff
-            }
-        }
-    }
-    throw lastError || new Error('Verification failed after retries');
-}
-const verifyModelsInDb = fromCallback(({ sendBack, input }) => {
-    const _verify = async () => {
-        const { schemaId, expectedModelIds } = input;
-        try {
-            const result = await verifyWithRetry$3(async () => {
-                const db = BaseDb.getAppDb();
-                if (!db) {
-                    throw new Error('Database not available');
-                }
-                // Query for models linked to this schema
-                const modelRecords = await db
-                    .select({
-                    modelFileId: models.schemaFileId,
-                    modelId: models.id,
-                })
-                    .from(modelSchemas)
-                    .innerJoin(models, eq(modelSchemas.modelId, models.id))
-                    .where(eq(modelSchemas.schemaId, schemaId));
-                // If expectedModelIds is provided and empty, it means the schema should have no models
-                // This is valid for empty schemas
-                if (modelRecords.length === 0) {
-                    if (expectedModelIds !== undefined && expectedModelIds.length === 0) {
-                        // Empty schema is expected and valid
-                        logger$8(`Schema ${schemaId} has no models (as expected)`);
-                        return [];
-                    }
-                    throw new Error(`No models found for schema (id: ${schemaId})`);
-                }
-                const modelIds = modelRecords
-                    .map((row) => row.modelFileId)
-                    .filter((id) => id !== null && id !== undefined);
-                // If expectedModelIds provided, verify all are present
-                if (expectedModelIds && expectedModelIds.length > 0) {
-                    const missingIds = expectedModelIds.filter(id => !modelIds.includes(id));
-                    if (missingIds.length > 0) {
-                        throw new Error(`Missing expected model IDs: ${missingIds.join(', ')}. Found: ${modelIds.join(', ')}`);
-                    }
-                }
-                logger$8(`Models verified: schemaId=${schemaId}, found ${modelIds.length} models: ${modelIds.join(', ')}`);
-                return modelIds;
-            });
-            sendBack({
-                type: 'modelsVerified',
-                modelIds: result,
-            });
-        }
-        catch (error) {
-            logger$8(`Model verification failed after retries: ${error}`);
-            sendBack({
-                type: 'verificationFailed',
-                stage: 'verifyModels',
-                error: error instanceof Error ? error : new Error(String(error)),
-            });
-        }
-    };
-    _verify().catch((error) => {
-        logger$8('Error in verifyModelsInDb:', error);
-        sendBack({
-            type: 'verificationFailed',
-            stage: 'verifyModels',
-            error: error instanceof Error ? error : new Error(String(error)),
-        });
-    });
-    return () => {
-        // Cleanup function (optional)
-    };
-});
-
-const logger$7 = debug('seedSdk:schema:actors:createModelInstances');
-/**
- * Create Model instances for all model IDs to ensure they're cached
- * This ensures that Model.getById() in Schema.getContext() will find the instances
- */
-const createModelInstances = fromCallback(({ sendBack, input }) => {
-    const evictionEpoch = currentEvictionEpoch();
-    const _create = async () => {
-        const { modelIds } = input;
-        if (modelIds.length === 0) {
-            logger$7('No model IDs provided, skipping instance creation');
-            sendBack({
-                type: 'instancesCreated',
-                count: 0,
-            });
-            return;
-        }
-        try {
-            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
-            const createPromises = modelIds.map(async (modelFileId) => {
-                try {
-                    // Not if the schema was evicted (Schema.destroy, test cleanup) since this 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$7(`Created/cached Model instance for modelFileId "${modelFileId}"`);
-                        return true;
-                    }
-                    else {
-                        logger$7(`Model.createById returned undefined for modelFileId "${modelFileId}" (may not exist in DB yet)`);
-                        return false;
-                    }
-                }
-                catch (error) {
-                    logger$7(`Error creating Model instance for modelFileId "${modelFileId}": ${error}`);
-                    // Don't throw - continue with other models
-                    return false;
-                }
-            });
-            const results = await Promise.all(createPromises);
-            const successCount = results.filter(Boolean).length;
-            logger$7(`Finished creating/caching ${successCount}/${modelIds.length} Model instances`);
-            sendBack({
-                type: 'instancesCreated',
-                count: successCount,
-            });
-        }
-        catch (error) {
-            logger$7(`Error in createModelInstances: ${error}`);
-            sendBack({
-                type: 'writeError',
-                error: error instanceof Error ? error : new Error(String(error)),
-            });
-        }
-    };
-    _create().catch((error) => {
-        logger$7('Error in createModelInstances:', error);
-        sendBack({
-            type: 'writeError',
-            error: error instanceof Error ? error : new Error(String(error)),
-        });
-    });
-    return () => {
-        // Cleanup function (optional)
-    };
-});
-
-const logger$6 = debug('seedSdk:schema:actors:verifyModelInstancesInCache');
-/**
- * Verify that Model instances exist in the static cache with retry logic
- */
-async function verifyWithRetry$2(verifyFn, maxRetries = 5, initialDelay = 100) {
-    let lastError = null;
-    let delay = initialDelay;
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-        try {
-            return await verifyFn();
-        }
-        catch (error) {
-            lastError = error instanceof Error ? error : new Error(String(error));
-            if (attempt < maxRetries - 1) {
-                logger$6(`Verification attempt ${attempt + 1} failed, retrying in ${delay}ms: ${lastError.message}`);
-                await new Promise(resolve => setTimeout(resolve, delay));
-                delay *= 2; // Exponential backoff
-            }
-        }
-    }
-    throw lastError || new Error('Verification failed after retries');
-}
-const verifyModelInstancesInCache = fromCallback(({ sendBack, input }) => {
-    const _verify = async () => {
-        const { modelIds } = input;
-        if (modelIds.length === 0) {
-            // No models means no instances to verify - this is valid
-            logger$6('No model IDs provided, skipping instance verification');
-            sendBack({
-                type: 'instancesVerified',
-                count: 0,
-            });
-            return;
-        }
-        try {
-            const result = await verifyWithRetry$2(async () => {
-                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 = [];
-                const missingIds = [];
-                for (const modelFileId of modelIds) {
-                    // Try to get instance from cache
-                    const instance = Model.peek(modelFileId);
-                    if (instance) {
-                        verifiedInstances.push(modelFileId);
-                    }
-                    else {
-                        missingIds.push(modelFileId);
-                    }
-                }
-                if (missingIds.length > 0) {
-                    throw new Error(`Model instances not found in cache: ${missingIds.join(', ')}. Found: ${verifiedInstances.length}/${modelIds.length}`);
-                }
-                logger$6(`Model instances verified: ${verifiedInstances.length} instances in cache`);
-                return verifiedInstances.length;
-            });
-            sendBack({
-                type: 'instancesVerified',
-                count: result,
-            });
-        }
-        catch (error) {
-            logger$6(`Model instance verification failed after retries: ${error}`);
-            sendBack({
-                type: 'verificationFailed',
-                stage: 'verifyModelInstances',
-                error: error instanceof Error ? error : new Error(String(error)),
-            });
-        }
-    };
-    _verify().catch((error) => {
-        logger$6('Error in verifyModelInstancesInCache:', error);
-        sendBack({
-            type: 'verificationFailed',
-            stage: 'verifyModelInstances',
-            error: error instanceof Error ? error : new Error(String(error)),
-        });
-    });
-    return () => {
-        // Cleanup function (optional)
-    };
-});
-
-const logger$5 = debug('seedSdk:schema:actors:writePropertiesToDb');
-/**
- * Properties are typically written to DB as part of writeModelsToDb
- * This actor verifies that properties exist and extracts their IDs
- */
-const writePropertiesToDb = fromCallback(({ sendBack, input }) => {
-    const _write = async () => {
-        const { modelIds } = input;
-        try {
-            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;
-            const db = BaseDb.getAppDb();
-            if (!db) {
-                throw new Error('Database not available');
-            }
-            // Get property IDs for all models
-            const propertyIds = [];
-            for (const modelFileId of modelIds) {
-                // Get model DB ID from modelFileId
-                const modelRecords = await db
-                    .select({ id: modelsTable.id })
-                    .from(modelsTable)
-                    .where(eq(modelsTable.schemaFileId, modelFileId))
-                    .limit(1);
-                if (modelRecords.length > 0 && modelRecords[0].id) {
-                    // Get properties for this model
-                    const propertyRecords = await db
-                        .select({ schemaFileId: propertiesTable.schemaFileId })
-                        .from(propertiesTable)
-                        .where(eq(propertiesTable.modelId, modelRecords[0].id));
-                    for (const prop of propertyRecords) {
-                        if (prop.schemaFileId) {
-                            propertyIds.push(prop.schemaFileId);
-                        }
-                    }
-                }
-            }
-            logger$5(`Found ${propertyIds.length} properties for ${modelIds.length} models`);
-            sendBack({
-                type: 'propertiesWritten',
-                propertyIds,
-            });
-        }
-        catch (error) {
-            logger$5(`Error writing/verifying properties to database: ${error}`);
-            sendBack({
-                type: 'writeError',
-                error: error instanceof Error ? error : new Error(String(error)),
-            });
-        }
-    };
-    _write().catch((error) => {
-        logger$5('Error in writePropertiesToDb:', error);
-        sendBack({
-            type: 'writeError',
-            error: error instanceof Error ? error : new Error(String(error)),
-        });
-    });
-    return () => {
-        // Cleanup function (optional)
-    };
-});
-
-const logger$4 = debug('seedSdk:schema:actors:verifyPropertiesInDb');
-/**
- * Verify that property records exist in the database for models with retry logic
- */
-async function verifyWithRetry$1(verifyFn, maxRetries = 5, initialDelay = 100) {
-    let lastError = null;
-    let delay = initialDelay;
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-        try {
-            return await verifyFn();
-        }
-        catch (error) {
-            lastError = error instanceof Error ? error : new Error(String(error));
-            if (attempt < maxRetries - 1) {
-                logger$4(`Verification attempt ${attempt + 1} failed, retrying in ${delay}ms: ${lastError.message}`);
-                await new Promise(resolve => setTimeout(resolve, delay));
-                delay *= 2; // Exponential backoff
-            }
-        }
-    }
-    throw lastError || new Error('Verification failed after retries');
-}
-const verifyPropertiesInDb = fromCallback(({ sendBack, input }) => {
-    const _verify = async () => {
-        const { modelIds, modelFileIds, expectedPropertyIds } = input;
-        // Convert model file IDs to DB IDs if needed
-        let dbModelIds = [];
-        if (modelIds && modelIds.length > 0) {
-            dbModelIds = modelIds;
-        }
-        else if (modelFileIds && modelFileIds.length > 0) {
-            // Convert file IDs to DB IDs
-            const db = BaseDb.getAppDb();
-            if (!db) {
-                throw new Error('Database not available');
-            }
-            for (const modelFileId of modelFileIds) {
-                const modelRecords = await db
-                    .select({ id: models.id })
-                    .from(models)
-                    .where(eq(models.schemaFileId, modelFileId))
-                    .limit(1);
-                if (modelRecords.length > 0 && modelRecords[0].id) {
-                    dbModelIds.push(modelRecords[0].id);
-                }
-            }
-        }
-        if (dbModelIds.length === 0) {
-            // No models means no properties to verify - this is valid
-            logger$4('No models provided, skipping property verification');
-            sendBack({
-                type: 'propertiesVerified',
-                propertyIds: [],
-            });
-            return;
-        }
-        try {
-            const result = await verifyWithRetry$1(async () => {
-                const db = BaseDb.getAppDb();
-                if (!db) {
-                    throw new Error('Database not available');
-                }
-                // Query for properties for all models
-                const allProperties = await Promise.all(dbModelIds.map(async (modelId) => {
-                    const props = await db
-                        .select({
-                        propertyFileId: properties.schemaFileId,
-                        propertyId: properties.id,
-                    })
-                        .from(properties)
-                        .where(eq(properties.modelId, modelId));
-                    return props;
-                }));
-                const propertyIds = allProperties
-                    .flat()
-                    .map((row) => row.propertyFileId)
-                    .filter((id) => id !== null && id !== undefined);
-                // If expectedPropertyIds provided, verify all are present
-                if (expectedPropertyIds && expectedPropertyIds.length > 0) {
-                    const missingIds = expectedPropertyIds.filter(id => !propertyIds.includes(id));
-                    if (missingIds.length > 0) {
-                        throw new Error(`Missing expected property IDs: ${missingIds.join(', ')}. Found: ${propertyIds.join(', ')}`);
-                    }
-                }
-                logger$4(`Properties verified: found ${propertyIds.length} properties for ${dbModelIds.length} models`);
-                return propertyIds;
-            });
-            sendBack({
-                type: 'propertiesVerified',
-                propertyIds: result,
-            });
-        }
-        catch (error) {
-            logger$4(`Property verification failed after retries: ${error}`);
-            sendBack({
-                type: 'verificationFailed',
-                stage: 'verifyProperties',
-                error: error instanceof Error ? error : new Error(String(error)),
-            });
-        }
-    };
-    _verify().catch((error) => {
-        logger$4('Error in verifyPropertiesInDb:', error);
-        sendBack({
-            type: 'verificationFailed',
-            stage: 'verifyProperties',
-            error: error instanceof Error ? error : new Error(String(error)),
-        });
-    });
-    return () => {
-        // Cleanup function (optional)
-    };
-});
-
-const logger$3 = debug('seedSdk:schema:actors:createPropertyInstances');
-/**
- * Create ModelProperty instances for all property IDs to ensure they're cached
- * Properties are typically created when Model instances are created, but this
- * ensures they're all available in the cache
- */
-const createPropertyInstances = fromCallback(({ sendBack, input }) => {
-    const _create = async () => {
-        const { propertyIds, modelIds } = input;
-        if (propertyIds.length === 0) {
-            logger$3('No property IDs provided, skipping instance creation');
-            sendBack({
-                type: 'instancesCreated',
-                count: 0,
-            });
-            return;
-        }
-        try {
-            const modProp = await import('./ModelProperty-i5flwzQG.js');
-            const ModelProperty = modProp?.ModelProperty ?? modProp?.default;
-            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');
-                sendBack({ type: 'instancesCreated', count: 0 });
-                return;
-            }
-            // Properties are typically loaded when Model instances are loaded
-            // But we can verify they exist by checking Model instances
-            let successCount = 0;
-            // For each model, check if properties are loaded
-            for (const modelFileId of modelIds) {
-                const model = Model.peek(modelFileId);
-                if (model && model.properties) {
-                    // Count properties that match our property IDs
-                    for (const prop of model.properties) {
-                        const context = prop._getSnapshotContext();
-                        const propFileId = context._propertyFileId || context.id;
-                        if (propFileId && propertyIds.includes(String(propFileId))) {
-                            successCount++;
-                        }
-                    }
-                }
-            }
-            // Also try to get properties directly by ID
-            for (const propertyFileId of propertyIds) {
-                try {
-                    const property = ModelProperty.getById(propertyFileId);
-                    if (property) {
-                        // Check if we already counted this
-                        // Access _service via type assertion since it's protected
-                        const context = property._service.getSnapshot().context;
-                        const propFileId = context._propertyFileId || context.id;
-                        if (!propertyIds.slice(0, propertyIds.indexOf(propertyFileId)).includes(String(propFileId))) {
-                            successCount++;
-                        }
-                        logger$3(`Found/cached ModelProperty instance for propertyFileId "${propertyFileId}"`);
-                    }
-                }
-                catch (error) {
-                    logger$3(`Error getting ModelProperty instance for propertyFileId "${propertyFileId}": ${error}`);
-                }
-            }
-            logger$3(`Finished verifying/caching ${successCount}/${propertyIds.length} Property instances`);
-            sendBack({
-                type: 'instancesCreated',
-                count: successCount,
-            });
-        }
-        catch (error) {
-            logger$3(`Error in createPropertyInstances: ${error}`);
-            sendBack({
-                type: 'writeError',
-                error: error instanceof Error ? error : new Error(String(error)),
-            });
-        }
-    };
-    _create().catch((error) => {
-        logger$3('Error in createPropertyInstances:', error);
-        sendBack({
-            type: 'writeError',
-            error: error instanceof Error ? error : new Error(String(error)),
-        });
-    });
-    return () => {
-        // Cleanup function (optional)
-    };
-});
-
-const logger$2 = debug('seedSdk:schema:actors:verifyPropertyInstancesInCache');
-/**
- * Verify that ModelProperty instances exist in the static cache with retry logic
- */
-async function verifyWithRetry(verifyFn, maxRetries = 5, initialDelay = 100) {
-    let lastError = null;
-    let delay = initialDelay;
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-        try {
-            return await verifyFn();
-        }
-        catch (error) {
-            lastError = error instanceof Error ? error : new Error(String(error));
-            if (attempt < maxRetries - 1) {
-                logger$2(`Verification attempt ${attempt + 1} failed, retrying in ${delay}ms: ${lastError.message}`);
-                await new Promise(resolve => setTimeout(resolve, delay));
-                delay *= 2; // Exponential backoff
-            }
-        }
-    }
-    throw lastError || new Error('Verification failed after retries');
-}
-const verifyPropertyInstancesInCache = fromCallback(({ sendBack, input }) => {
-    const _verify = async () => {
-        const { propertyIds } = input;
-        if (propertyIds.length === 0) {
-            // No properties means no instances to verify - this is valid
-            logger$2('No property IDs provided, skipping instance verification');
-            sendBack({
-                type: 'instancesVerified',
-                count: 0,
-            });
-            return;
-        }
-        try {
-            const result = await verifyWithRetry(async () => {
-                const mod = await import('./ModelProperty-i5flwzQG.js');
-                const ModelProperty = mod?.ModelProperty ?? mod?.default;
-                if (!ModelProperty) {
-                    throw new Error('ModelProperty not available from dynamic import');
-                }
-                // Check each property ID in the cache
-                const verifiedInstances = [];
-                const missingIds = [];
-                for (const propertyFileId of propertyIds) {
-                    // Try to get instance from cache
-                    const instance = ModelProperty.getById(propertyFileId);
-                    if (instance) {
-                        verifiedInstances.push(propertyFileId);
-                    }
-                    else {
-                        missingIds.push(propertyFileId);
-                    }
-                }
-                if (missingIds.length > 0) {
-                    throw new Error(`Property instances not found in cache: ${missingIds.join(', ')}. Found: ${verifiedInstances.length}/${propertyIds.length}`);
-                }
-                logger$2(`Property instances verified: ${verifiedInstances.length} instances in cache`);
-                return verifiedInstances.length;
-            });
-            sendBack({
-                type: 'instancesVerified',
-                count: result,
-            });
-        }
-        catch (error) {
-            logger$2(`Property instance verification failed after retries: ${error}`);
-            sendBack({
-                type: 'verificationFailed',
-                stage: 'verifyPropertyInstances',
-                error: error instanceof Error ? error : new Error(String(error)),
-            });
-        }
-    };
-    _verify().catch((error) => {
-        logger$2('Error in verifyPropertyInstancesInCache:', error);
-        sendBack({
-            type: 'verificationFailed',
-            stage: 'verifyPropertyInstances',
-            error: error instanceof Error ? error : new Error(String(error)),
-        });
-    });
-    return () => {
-        // Cleanup function (optional)
-    };
-});
-
-const schemaMachine = setup({
-    types: {
-        context: {},
-        input: {},
-        events: {},
-    },
-    actors: {
-        validateSchema,
-        // Staged loading actors
-        checkExistingSchema,
-        writeSchemaToDb,
-        verifySchemaInDb,
-        writeModelsToDb,
-        verifyModelsInDb,
-        createModelInstances,
-        verifyModelInstancesInCache,
-        writePropertiesToDb,
-        verifyPropertiesInDb,
-        createPropertyInstances,
-        verifyPropertyInstancesInCache,
-    },
-    guards: {
-        isSchemaValid: ({ context }) => {
-            return !context._validationErrors || context._validationErrors.length === 0;
-        },
-    },
-}).createMachine({
-    id: 'schema',
-    initial: 'loading',
-    context: ({ input }) => ({
-        schemaName: input.schemaName,
-        _isDraft: false,
-        _editedProperties: new Set(),
-        _validationErrors: undefined,
-        _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;
-                        }
-                        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];
-                        }
-                    }
-                    return newContext;
-                }),
-            }],
-        validateSchema: {
-            target: '.validating',
-        },
-        validationSuccess: {
-            actions: assign(({ context }) => ({
-                ...context,
-                _validationErrors: [],
-            })),
-        },
-        validationError: {
-            actions: assign(({ context, event }) => ({
-                ...context,
-                _validationErrors: event.errors,
-            })),
-        },
-        markAsDraft: {
-            actions: assign(({ context, event }) => ({
-                ...context,
-                _isDraft: true,
-                _isEdited: true,
-                _editedProperties: new Set([
-                    ...(context._editedProperties || []),
-                    event.propertyKey,
-                ]),
-            })),
-        },
-        clearDraft: {
-            actions: assign(({ context, event }) => {
-                const newContext = { ...context };
-                newContext._isDraft = false;
-                newContext._isEdited = false;
-                newContext._editedProperties = new Set();
-                // Update conflict detection metadata if provided
-                if (event._dbUpdatedAt !== undefined) {
-                    newContext._dbUpdatedAt = event._dbUpdatedAt;
-                }
-                if (event._dbVersion !== undefined) {
-                    newContext._dbVersion = event._dbVersion;
-                }
-                // saveNewVersion passes the schema it just wrote: the instance now is that version.
-                const saved = event.savedSchema;
-                if (saved) {
-                    newContext.version = saved.version;
-                    newContext.metadata = saved.metadata;
-                    newContext.migrations = saved.migrations;
-                }
-                return newContext;
-            }),
-        },
-        destroyStarted: {
-            actions: assign({ _destroyError: null }),
-        },
-        destroyError: {
-            actions: assign(({ event }) => ({
-                _destroyError: event.error instanceof Error
-                    ? { message: event.error.message, name: event.error.name }
-                    : { message: String(event.error) },
-            })),
-        },
-    },
-    states: {
-        loading: {
-            initial: 'checkingExisting',
-            states: {
-                // Stage 0: Check for existing schema
-                checkingExisting: {
-                    invoke: {
-                        src: 'checkExistingSchema',
-                        input: ({ context }) => ({ context }),
-                    },
-                    on: {
-                        schemaFound: {
-                            target: '#schema.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,
-                                    _isEdited: event.schemaRecord?.isEdited ?? false,
-                                    _editedProperties: new Set(),
-                                    _validationErrors: undefined,
-                                    id: event.schema.id, // schemaFileId (string)
-                                    _dbId: event.schemaRecord?.id, // Database integer ID
-                                    _loadedAt: event.loadedAt,
-                                    _dbVersion: event.dbVersion,
-                                    _dbUpdatedAt: event.dbUpdatedAt,
-                                    _liveQueryModelIds: event.modelIds || [],
-                                    _schemaRecord: event.schemaRecord,
-                                };
-                            }),
-                        },
-                        schemaNotFound: {
-                            target: 'writingSchema',
-                        },
-                    },
-                },
-                // Stage 1: Write and verify schema
-                writingSchema: {
-                    entry: assign({
-                        _loadingStage: 'writingSchema',
-                    }),
-                    invoke: {
-                        src: 'writeSchemaToDb',
-                        input: ({ context }) => ({
-                            schemaName: context.schemaName,
-                        }),
-                    },
-                    on: {
-                        schemaWritten: {
-                            target: 'verifyingSchema',
-                            actions: assign({
-                                _schemaRecord: ({ event }) => event.schemaRecord,
-                                id: ({ event }) => event.schema.id, // schemaFileId (string)
-                                _dbId: ({ event }) => event.schemaRecord?.id, // Database integer ID
-                                // A schema created in code has these only in the written record; without them
-                                // validation (and so saveNewVersion) failed with "Schema metadata is required".
-                                $schema: ({ context, event }) => context.$schema ?? event.schema.$schema,
-                                version: ({ context, event }) => context.version ?? event.schema.version,
-                                metadata: ({ context, event }) => context.metadata ?? event.schema.metadata,
-                                enums: ({ context, event }) => context.enums ?? event.schema.enums,
-                                migrations: ({ context, event }) => context.migrations ?? event.schema.migrations,
-                                nameMatch: ({ context, event }) => context.nameMatch ?? event.schema.nameMatch,
-                            }),
-                        },
-                        writeError: {
-                            target: '#schema.error',
-                            actions: assign({
-                                _loadingError: ({ event }) => ({
-                                    stage: 'writingSchema',
-                                    error: event.error,
-                                }),
-                            }),
-                        },
-                    },
-                },
-                verifyingSchema: {
-                    entry: assign({
-                        _loadingStage: 'verifyingSchema',
-                    }),
-                    invoke: {
-                        src: 'verifySchemaInDb',
-                        input: ({ context }) => ({
-                            schemaFileId: context.id,
-                            expectedSchemaId: context._dbId,
-                        }),
-                    },
-                    on: {
-                        schemaVerified: {
-                            target: 'writingModels',
-                            actions: assign({
-                                _dbId: ({ event }) => event.schemaId, // Store database integer ID
-                            }),
-                        },
-                        verificationFailed: {
-                            target: '#schema.error',
-                            actions: assign({
-                                _loadingError: ({ event }) => ({
-                                    stage: event.stage,
-                                    error: event.error,
-                                }),
-                            }),
-                        },
-                    },
-                },
-                // Stage 2: Write and verify models
-                writingModels: {
-                    entry: assign({
-                        _loadingStage: 'writingModels',
-                    }),
-                    invoke: {
-                        src: 'writeModelsToDb',
-                        input: ({ context }) => ({
-                            schema: {
-                                id: context.id,
-                                models: context.models || {},
-                                version: context.version || 1,
-                                metadata: context.metadata || { name: context.schemaName, createdAt: '', updatedAt: '' },
-                            },
-                            schemaRecord: context._schemaRecord,
-                            schemaName: context.schemaName,
-                        }),
-                    },
-                    on: {
-                        modelsWritten: {
-                            target: 'verifyingModels',
-                            actions: assign({
-                                _modelIds: ({ event }) => event.modelIds,
-                            }),
-                        },
-                        writeError: {
-                            target: '#schema.error',
-                            actions: assign({
-                                _loadingError: ({ event }) => ({
-                                    stage: 'writingModels',
-                                    error: event.error,
-                                }),
-                            }),
-                        },
-                    },
-                },
-                verifyingModels: {
-                    entry: assign({
-                        _loadingStage: 'verifyingModels',
-                    }),
-                    invoke: {
-                        src: 'verifyModelsInDb',
-                        input: ({ context }) => ({
-                            schemaId: context._dbId,
-                            expectedModelIds: context._modelIds,
-                        }),
-                    },
-                    on: {
-                        modelsVerified: {
-                            target: 'creatingModelInstances',
-                            actions: assign({
-                                _modelIds: ({ event }) => event.modelIds,
-                            }),
-                        },
-                        verificationFailed: {
-                            target: '#schema.error',
-                            actions: assign({
-                                _loadingError: ({ event }) => ({
-                                    stage: event.stage,
-                                    error: event.error,
-                                }),
-                            }),
-                        },
-                    },
-                },
-                // Stage 3: Create and verify model instances
-                creatingModelInstances: {
-                    entry: assign({
-                        _loadingStage: 'creatingModelInstances',
-                    }),
-                    invoke: {
-                        src: 'createModelInstances',
-                        input: ({ context }) => ({
-                            modelIds: context._modelIds || [],
-                            schemaName: context.schemaName,
-                        }),
-                    },
-                    on: {
-                        instancesCreated: {
-                            target: 'verifyingModelInstances',
-                        },
-                        writeError: {
-                            target: '#schema.error',
-                            actions: assign({
-                                _loadingError: ({ event }) => ({
-                                    stage: 'creatingModelInstances',
-                                    error: event.error,
-                                }),
-                            }),
-                        },
-                    },
-                },
-                verifyingModelInstances: {
-                    entry: assign({
-                        _loadingStage: 'verifyingModelInstances',
-                    }),
-                    invoke: {
-                        src: 'verifyModelInstancesInCache',
-                        input: ({ context }) => ({
-                            modelIds: context._modelIds || [],
-                        }),
-                    },
-                    on: {
-                        instancesVerified: {
-                            target: 'writingProperties',
-                        },
-                        verificationFailed: {
-                            target: '#schema.error',
-                            actions: assign({
-                                _loadingError: ({ event }) => ({
-                                    stage: event.stage,
-                                    error: event.error,
-                                }),
-                            }),
-                        },
-                    },
-                },
-                // Stage 4: Write and verify properties
-                writingProperties: {
-                    entry: assign({
-                        _loadingStage: 'writingProperties',
-                    }),
-                    invoke: {
-                        src: 'writePropertiesToDb',
-                        input: ({ context }) => ({
-                            modelIds: context._modelIds || [],
-                        }),
-                    },
-                    on: {
-                        propertiesWritten: {
-                            target: 'verifyingProperties',
-                            actions: assign({
-                                _propertyIds: ({ event }) => event.propertyIds,
-                            }),
-                        },
-                        writeError: {
-                            target: '#schema.error',
-                            actions: assign({
-                                _loadingError: ({ event }) => ({
-                                    stage: 'writingProperties',
-                                    error: event.error,
-                                }),
-                            }),
-                        },
-                    },
-                },
-                verifyingProperties: {
-                    entry: assign({
-                        _loadingStage: 'verifyingProperties',
-                    }),
-                    invoke: {
-                        src: 'verifyPropertiesInDb',
-                        input: ({ context }) => ({
-                            modelFileIds: context._modelIds,
-                            expectedPropertyIds: context._propertyIds,
-                        }),
-                    },
-                    on: {
-                        propertiesVerified: {
-                            target: 'creatingPropertyInstances',
-                            actions: assign({
-                                _propertyIds: ({ event }) => event.propertyIds,
-                            }),
-                        },
-                        verificationFailed: {
-                            target: '#schema.error',
-                            actions: assign({
-                                _loadingError: ({ event }) => ({
-                                    stage: event.stage,
-                                    error: event.error,
-                                }),
-                            }),
-                        },
-                    },
-                },
-                // Stage 5: Create and verify property instances
-                creatingPropertyInstances: {
-                    entry: assign({
-                        _loadingStage: 'creatingPropertyInstances',
-                    }),
-                    invoke: {
-                        src: 'createPropertyInstances',
-                        input: ({ context }) => ({
-                            propertyIds: context._propertyIds || [],
-                            modelIds: context._modelIds || [],
-                        }),
-                    },
-                    on: {
-                        instancesCreated: {
-                            target: 'verifyingPropertyInstances',
-                        },
-                        writeError: {
-                            target: '#schema.error',
-                            actions: assign({
-                                _loadingError: ({ event }) => ({
-                                    stage: 'creatingPropertyInstances',
-                                    error: event.error,
-                                }),
-                            }),
-                        },
-                    },
-                },
-                verifyingPropertyInstances: {
-                    entry: assign({
-                        _loadingStage: 'verifyingPropertyInstances',
-                    }),
-                    invoke: {
-                        src: 'verifyPropertyInstancesInCache',
-                        input: ({ context }) => ({
-                            propertyIds: context._propertyIds || [],
-                        }),
-                    },
-                    on: {
-                        instancesVerified: {
-                            target: '#schema.idle',
-                            actions: assign({
-                                _liveQueryModelIds: ({ context }) => context._modelIds || [],
-                                _loadingStage: undefined,
-                            }),
-                        },
-                        verificationFailed: {
-                            target: '#schema.error',
-                            actions: assign({
-                                _loadingError: ({ event }) => ({
-                                    stage: event.stage,
-                                    error: event.error,
-                                }),
-                            }),
-                        },
-                    },
-                },
-            },
-        },
-        idle: {
-            on: {
-                validateSchema: {
-                    target: 'validating',
-                },
-                reloadFromDb: {
-                    target: 'loading',
-                },
-            },
-            // No `always: hasValidationErrors -> validating` here: validation is re-run when the context changes
-            // (updateContext) or on request (validateSchema). Re-entering while errors exist would loop
-            // forever on a schema that is still invalid.
-        },
-        validating: {
-            on: {
-                // These state-level handlers take precedence over the root ones, so they must store the result
-                // themselves.
-                validationSuccess: {
-                    target: 'idle',
-                    actions: assign(({ context }) => ({
-                        ...context,
-                        _validationErrors: [],
-                    })),
-                },
-                validationError: {
-                    target: 'idle',
-                    actions: assign(({ context, event }) => ({
-                        ...context,
-                        _validationErrors: event.errors,
-                    })),
-                },
-            },
-            invoke: {
-                src: 'validateSchema',
-                input: ({ context }) => ({ context }),
-            },
-        },
-        error: {},
-    },
-});
-
-const logger$1 = debug('seedSdk:helpers:updateSchema');
-// Schema reloads renameModelProperty deferred and that haven't finished yet
-const deferredSchemaReloads = new Set();
-/**
- * Get the file path for a schema file
- */
-/**
- * Sanitize a schema name to be filesystem-safe
- * Replaces all special characters (except alphanumeric, hyphens, underscores) with underscores
- * Converts spaces to underscores
- * Removes leading/trailing underscores
- *
- * @param name - Schema name to sanitize
- * @returns Sanitized name safe for use in filenames
- */
-const sanitizeSchemaName = (name) => {
-    return name
-        .replace(/[^a-zA-Z0-9\s_-]/g, '_') // Replace special chars (except spaces, hyphens, underscores) with underscore
-        .replace(/\s+/g, '_') // Convert spaces to underscores
-        .replace(/^_+|_+$/g, '') // Remove leading/trailing underscores
-        .replace(/_+/g, '_'); // Collapse multiple underscores to single
-};
-/**
- * Get the full file path for a schema
- * Format: {schemaFileId}_{schemaName}_v{version}.json
- *
- * The ID-first format ensures all files for a schema group together when sorted alphabetically.
- *
- * @param name - Schema name
- * @param version - Schema version
- * @param schemaFileId - Schema file ID (required)
- */
-const getSchemaFilePath = (name, version, schemaFileId) => {
-    const path = BaseFileManager.getPathModule();
-    const workingDir = BaseFileManager.getWorkingDir();
-    const sanitizedName = sanitizeSchemaName(name);
-    const filename = schemaFileId
-        ? `${schemaFileId}_${sanitizedName}_v${version}.json`
-        : `${sanitizedName}_v${version}.json`;
-    return path.join(workingDir, filename);
-};
-/**
- * Get schemaFileId from database for a schema
- * @param schemaName - Schema name
- * @returns Schema file ID
- * @throws Error if schema not found or missing schemaFileId
- */
-async function getSchemaFileId(schemaName) {
-    const db = BaseDb.getAppDb();
-    if (!db)
-        throw new Error('Database not available');
-    const dbSchema = await db
-        .select()
-        .from(schemas)
-        .where(eq(schemas.name, schemaName))
-        .orderBy(desc(schemas.version))
-        .limit(1);
-    if (dbSchema.length === 0 || !dbSchema[0].schemaFileId) {
-        throw new Error(`Schema ${schemaName} not found in database or missing schemaFileId`);
-    }
-    return dbSchema[0].schemaFileId;
-}
-/**
- * Write the full schema to a new version file (e.g. when new models were added).
- * Used when _editedProperties contains 'schema:models' and there are no property-level updates.
- * @param schemaName - Schema name
- * @param schema - Full schema object (e.g. from _buildModelsFromInstances)
- * @returns The file path of the new schema version
- */
-async function writeFullSchemaNewVersion(schemaName, schema) {
-    const latestVersion = await getLatestSchemaVersion(schemaName);
-    const newVersion = latestVersion + 1;
-    const schemaWithNewVersion = {
-        ...schema,
-        version: newVersion,
-        metadata: {
-            ...schema.metadata,
-            updatedAt: new Date().toISOString(),
-        },
-        migrations: [
-            ...(schema.migrations || []),
-            {
-                version: newVersion,
-                timestamp: new Date().toISOString(),
-                description: 'New schema version (e.g. new models added)',
-                changes: [{ type: 'full_schema_write' }],
-            },
-        ],
-    };
-    const newFilePath = getSchemaFilePath(schemaName, newVersion, schema.id ?? (await getSchemaFileId(schemaName)));
-    const newContent = JSON.stringify(schemaWithNewVersion, null, 2);
-    await BaseFileManager.saveFile(newFilePath, newContent);
-    await BaseFileManager.waitForFileWithContent(newFilePath);
-    logger$1(`Created new schema version ${newVersion} for ${schemaName} at ${newFilePath}`);
-    return newFilePath;
-}
-/**
- * Get model name from modelId
- * @param modelId - The model ID to look up
- * @returns The model name, or undefined if not found
- */
-async function getModelNameFromId(modelId) {
-    if (!modelId) {
-        return undefined;
-    }
-    const db = BaseDb.getAppDb();
-    if (!db) {
-        throw new Error('Database not found');
-    }
-    const modelRecords = await db
-        .select()
-        .from(models)
-        .where(eq(models.id, modelId))
-        .limit(1);
-    if (modelRecords.length === 0) {
-        return undefined;
-    }
-    return modelRecords[0].name;
-}
-/**
- * Convert a TProperty/ModelPropertyMachineContext to SchemaPropertyUpdate format
- * This function converts the internal property representation to the schema file format
- * @param property - The TProperty instance to convert
- * @param modelName - The name of the model this property belongs to
- * @param propertyName - The name of the property
- * @returns A SchemaPropertyUpdate object ready to be passed to updateModelProperties
- */
-async function convertPropertyToSchemaUpdate(property, modelName, propertyName) {
-    const updates = {};
-    // Convert dataType to type
-    if (property.dataType) {
-        updates.type = property.dataType;
-    }
-    // Handle Relation type
-    if (isDataType(property.dataType, ModelPropertyDataTypes.Relation)) {
-        if (property.ref) {
-            updates.model = property.ref;
-        }
-        else if (property.refModelId) {
-            // If ref is not set but refModelId is, get the model name from the database
-            const refModelName = await getModelNameFromId(property.refModelId);
-            if (refModelName) {
-                updates.model = refModelName;
-            }
-        }
-    }
-    // Handle List type
-    if (isDataType(property.dataType, ModelPropertyDataTypes.List)) {
-        if (property.refValueType) {
-            updates.refValueType = property.refValueType;
-            if (property.ref) {
-                updates.ref = property.ref;
-            }
-            else if (property.refModelId) {
-                // If ref is not set but refModelId is, get the model name from the database
-                const refModelName = await getModelNameFromId(property.refModelId);
-                if (refModelName) {
-                    updates.ref = refModelName;
-                }
-            }
-        }
-    }
-    // Handle required (validation constraint)
-    if (property.required !== undefined) {
-        updates.required = property.required;
-    }
-    // Handle storage configuration (for Text properties with storage)
-    if (property.storageType || property.localStorageDir || property.filenameSuffix) {
-        const storageType = property.storageType || 'ItemStorage'; // Default to ItemStorage if not specified
-        updates.storage = {
-            type: storageType,
-        };
-        if (property.localStorageDir) {
-            updates.storage.path = property.localStorageDir;
-        }
-        if (property.filenameSuffix) {
-            updates.storage.extension = property.filenameSuffix;
-        }
-    }
-    return {
-        modelName,
-        propertyName,
-        updates,
-    };
-}
-/**
- * Update model properties in a schema and create a new version
- * @param schemaName - The name of the schema to update
- * @param propertyUpdates - Array of property updates to apply
- * @param modelUpdates - Optional array of model renames
- * @returns The file path of the new schema version
- * @throws Error if schema not found or updates are invalid
- */
-async function updateModelProperties(schemaName, propertyUpdates, modelUpdates) {
-    // Get the latest version of the schema
-    const latestVersion = await 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`);
-    }
-    // Create a copy of the schema for the new version
-    // Preserve schema ID and all model/property IDs
-    const newVersion = latestVersion + 1;
-    const updatedSchema = {
-        ...schemaFile,
-        version: newVersion,
-        // Preserve schema ID from previous version
-        id: schemaFile.id,
-        metadata: {
-            ...schemaFile.metadata,
-            updatedAt: new Date().toISOString(),
-        },
-        // Deep copy models to preserve IDs
-        models: Object.fromEntries(Object.entries(schemaFile.models).map(([modelName, model]) => [
-            modelName,
-            {
-                ...model,
-                // Preserve model ID
-                id: model.id,
-                // Deep copy properties to preserve IDs
-                properties: Object.fromEntries(Object.entries(model.properties).map(([propName, prop]) => [
-                    propName,
-                    {
-                        ...prop,
-                        // Preserve property ID
-                        id: prop.id,
-                    },
-                ])),
-            },
-        ])),
-        migrations: [
-            ...schemaFile.migrations,
-            {
-                version: newVersion,
-                timestamp: new Date().toISOString(),
-                description: `Updated model properties: ${propertyUpdates.map(u => `${u.modelName}.${u.propertyName}`).join(', ')}`,
-                changes: propertyUpdates.map(update => ({
-                    type: 'property_update',
-                    modelName: update.modelName,
-                    propertyName: update.propertyName,
-                    updates: update.updates,
-                })),
-            },
-        ],
-    };
-    // Apply model renames first (if any)
-    if (modelUpdates && modelUpdates.length > 0) {
-        for (const modelUpdate of modelUpdates) {
-            if (updatedSchema.models[modelUpdate.oldName]) {
-                // Rename the model in the models object
-                updatedSchema.models[modelUpdate.newName] = updatedSchema.models[modelUpdate.oldName];
-                delete updatedSchema.models[modelUpdate.oldName];
-                // Update any property references to this model
-                for (const modelName in updatedSchema.models) {
-                    const model = updatedSchema.models[modelName];
-                    for (const propertyName in model.properties) {
-                        const property = model.properties[propertyName];
-                        if (property.model === modelUpdate.oldName) {
-                            property.model = modelUpdate.newName;
-                        }
-                        if (property.ref === modelUpdate.oldName && (isDataType(property.type, ModelPropertyDataTypes.List) || isDataType(property.dataType, ModelPropertyDataTypes.List))) {
-                            property.ref = modelUpdate.newName;
-                        }
-                        // Legacy: items.model
-                        if (property.items?.model === modelUpdate.oldName) {
-                            property.items.model = modelUpdate.newName;
-                        }
-                    }
-                }
-                // Add to migration changes
-                updatedSchema.migrations[updatedSchema.migrations.length - 1].changes.push({
-                    type: 'model_rename',
-                    oldName: modelUpdate.oldName,
-                    newName: modelUpdate.newName,
-                });
-            }
-        }
-    }
-    // Apply property updates
-    for (const update of propertyUpdates) {
-        const model = updatedSchema.models[update.modelName];
-        if (!model) {
-            throw new Error(`Model ${update.modelName} not found in schema ${schemaName}`);
-        }
-        if (!model.properties[update.propertyName]) {
-            throw new Error(`Property ${update.propertyName} not found in model ${update.modelName} of schema ${schemaName}`);
-        }
-        // Update the property with new values
-        const property = model.properties[update.propertyName];
-        Object.assign(property, update.updates);
-    }
-    // Write the new schema version to file using ID-based naming (preferred)
-    const newFilePath = getSchemaFilePath(schemaName, newVersion, updatedSchema.id ?? undefined);
-    const newContent = JSON.stringify(updatedSchema, null, 2);
-    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(`Created new schema version ${newVersion} for ${schemaName} at ${newFilePath}`);
-    // Load the new schema file to process models and add them to the database
-    // Extract model renames from migrations to pass to database update
-    const modelRenames = new Map();
-    const latestMigration = updatedSchema.migrations[updatedSchema.migrations.length - 1];
-    for (const change of latestMigration.changes) {
-        if (change.type === 'model_rename') {
-            modelRenames.set(change.oldName, change.newName);
-        }
-    }
-    // Load schema with model renames handled
-    await loadSchemaWithRenames(newFilePath, modelRenames);
-    return newFilePath;
-}
-/**
- * Load a schema file and handle model renames in the database
- * This is a helper function that processes model renames before loading
- */
-async function loadSchemaWithRenames(schemaFilePath, modelRenames) {
-    const content = await BaseFileManager.readFileAsString(schemaFilePath);
-    const schemaFile = JSON.parse(content);
-    if (!schemaFile.$schema) {
-        throw new Error(`File ${schemaFilePath} is not a complete schema file (missing $schema field).`);
-    }
-    const schemaName = schemaFile.metadata?.name;
-    const version = schemaFile.version;
-    if (!schemaName) {
-        throw new Error('Schema name is required in metadata.name');
-    }
-    // Convert to JsonImportSchema format for processing
-    // Remove id fields for JsonImportSchema format (they're not part of the import format)
-    const importData = {
-        name: schemaName,
-        models: Object.fromEntries(Object.entries(schemaFile.models).map(([modelName, model]) => [
-            modelName,
-            {
-                description: model.description,
-                properties: Object.fromEntries(Object.entries(model.properties).map(([propName, prop]) => [
-                    propName,
-                    {
-                        type: prop.type || 'string', // Ensure type is present
-                        ...prop,
-                        // Remove id field for import format (not part of JsonImportSchema)
-                    },
-                ])),
-                indexes: model.indexes,
-            },
-        ])),
-    };
-    // Generate schema ID if missing
-    if (!schemaFile.id) {
-        schemaFile.id = generateId();
-        logger$1('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$1(`Generated model ID for ${modelName}:`, model.id);
-        }
-        modelFileIds.set(modelName, model.id);
-        const propIds = new Map();
-        for (const [propName, prop] of Object.entries(model.properties)) {
-            // Generate property ID if missing
-            if (!prop.id) {
-                prop.id = generateId();
-                logger$1(`Generated property ID for ${modelName}.${propName}:`, prop.id);
-            }
-            propIds.set(propName, prop.id);
-        }
-        if (propIds.size > 0) {
-            propertyFileIds.set(modelName, propIds);
-        }
-    }
-    // Convert schema file metadata to schema input for database
-    const schemaInput = {
-        name: schemaName,
-        version,
-        schemaFileId: schemaFile.id || null,
-        schemaData: null,
-        isDraft: false,
-        isEdited: false,
-        createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
-        updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
-    };
-    // Use dynamic import to break circular dependency
-    const _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);
-    // A cached Model keeps the properties it was created with (Model.create ignores the ones passed),
-    // so addModelsToDb must take changed properties from this file, as in loadSchemaFromFile
-    const propertyDefinitions = new Map(Object.entries(importData.models).map(([modelName, modelDef]) => [
-        modelName,
-        jsonPropertiesToSchemaProperties(modelName, modelDef, propertyFileIds.get(modelName)),
-    ]));
-    // 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);
-    // Add models to database with model renames handled and schemaFileIds
-    await addModelsToDb(modelDefinitions, schemaRecord, modelRenames, {
-        schemaFileId: schemaFile.id,
-        modelFileIds,
-        propertyFileIds,
-        propertyDefinitions,
-    }).finally(rowsWritten.settle);
-    // Models are now Model instances, no registration needed
-    // They should be created via Model.create() and are accessible via Model static methods
-    for (const [modelName] of Object.entries(modelDefinitions)) {
-        logger$1('loadSchemaWithRenames - model available:', modelName);
-    }
-    return schemaFilePath;
-}
-/**
- * Rename a property in a model
- * This is a convenience function that updates the property name
- * Note: This creates a new property and you may want to handle the old property separately
- * @param schemaName - The name of the schema
- * @param modelName - The name of the model
- * @param oldPropertyName - The current property name
- * @param newPropertyName - The new property name
- * @returns The file path of the new schema version
- */
-async function renameModelProperty(schemaName, modelName, oldPropertyName, newPropertyName) {
-    // 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[oldPropertyName]) {
-        throw new Error(`Property ${oldPropertyName} not found in model ${modelName} of schema ${schemaName}`);
-    }
-    if (model.properties[newPropertyName]) {
-        throw new Error(`Property ${newPropertyName} already exists in model ${modelName} of schema ${schemaName}`);
-    }
-    // Create new version with renamed property
-    // Preserve all IDs - when renaming, we keep the same property ID
-    const newVersion = latestVersion + 1;
-    const oldProperty = model.properties[oldPropertyName];
-    const updatedSchema = {
-        ...schemaFile,
-        version: newVersion,
-        id: schemaFile.id, // Preserve schema ID
-        metadata: {
-            ...schemaFile.metadata,
-            updatedAt: new Date().toISOString(),
-        },
-        models: {
-            ...schemaFile.models,
-            [modelName]: {
-                ...model,
-                id: model.id, // Preserve model ID
-                properties: {
-                    ...Object.fromEntries(Object.entries(model.properties)
-                        .filter(([name]) => name !== oldPropertyName)
-                        .map(([name, prop]) => [name, { ...prop, id: prop.id }])),
-                    [newPropertyName]: {
-                        ...oldProperty,
-                        id: oldProperty.id, // Preserve property ID when renaming
-                    },
-                },
-            },
-        },
-        migrations: [
-            ...schemaFile.migrations,
-            {
-                version: newVersion,
-                timestamp: new Date().toISOString(),
-                description: `Renamed property ${modelName}.${oldPropertyName} to ${newPropertyName}`,
-                changes: [
-                    {
-                        type: 'property_rename',
-                        modelName,
-                        oldPropertyName,
-                        newPropertyName,
-                    },
-                ],
-            },
-        ],
-    };
-    // Remove the old property name
-    delete updatedSchema.models[modelName].properties[oldPropertyName];
-    // 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(`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_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`);
-    }
-    // Defer loadSchemaFromFile to avoid sync cascade: it triggers addSchemaToDb/addModelsToDb,
-    // which post to BroadcastChannel and cause React invalidates. Running that synchronously
-    // can interrupt the save flow and cause freezes (e.g. updateContext/refetch loops).
-    const reload = new Promise((resolve) => setTimeout(resolve, 100))
-        .then(() => loadSchemaFromFile(newFilePath))
-        .then(() => { }, (err) => {
-        logger$1('Deferred loadSchemaFromFile after rename failed:', err);
-    })
-        .finally(() => deferredSchemaReloads.delete(reload));
-    deferredSchemaReloads.add(reload);
-    return newFilePath;
-}
-
-var updateSchema = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    convertPropertyToSchemaUpdate: convertPropertyToSchemaUpdate,
-    getModelNameFromId: getModelNameFromId,
-    renameModelProperty: renameModelProperty,
-    updateModelProperties: updateModelProperties,
-    writeFullSchemaNewVersion: writeFullSchemaNewVersion
-});
-
-const logger = debug('seedSdk:schema:saveNewVersion');
-const saveDraftLogger = debug('seedSdk:schema:saveDraftToDb');
-// Non-serializable resources per Schema instance (subscriptions, timers, etc.)
-const schemaInstanceState = new ActorKeyedState();
-// Cache client initialization state globally to avoid repeated checks
-let cachedClientInitialized = null;
-let clientCheckTime = 0;
-const CLIENT_CHECK_CACHE_MS = 50; // Cache for 50ms to avoid excessive checks (reduced from 100ms for faster updates)
-// Define tracked properties for the Proxy
-// These properties will be read from/written to the actor context
-const TRACKED_PROPERTIES = [
-    'id', // schemaFileId (string) - public ID
-    '$schema',
-    'version',
-    'metadata',
-    'enums',
-    'migrations',
-    'name', // metadata.name (flattened)
-    'createdAt', // metadata.createdAt (flattened)
-    'updatedAt', // metadata.updatedAt (flattened)
-];
-class Schema {
-    constructor(schemaName) {
-        const serviceInput = {
-            schemaName,
-        };
-        this._service = createActor(schemaMachine, {
-            input: serviceInput,
-        });
-        this._service.start();
-        // Initialize instance state in WeakMap (only non-serializable resources)
-        schemaInstanceState.set(this, {
-            liveQuerySubscription: null,
-        });
-        // Set up liveQuery subscription for cross-instance model updates
-        // This will be initialized once we have the schemaId
-        this._setupLiveQuerySubscription();
-        // Subscribe to schema context changes to update cache keys when schemaFileId becomes available
-        this._service.subscribe((snapshot) => {
-            // Update cache to use id (schemaFileId) as key once we have it (only once)
-            if (snapshot.value === 'idle' && snapshot.context.metadata?.name && snapshot.context.id) {
-                // Use a static Set to track which schemas have had their cache key updated
-                const cacheKeyUpdatedSet = Schema._cacheKeyUpdatedSet || new Set();
-                if (!Schema._cacheKeyUpdatedSet) {
-                    Schema._cacheKeyUpdatedSet = cacheKeyUpdatedSet;
-                }
-                if (!cacheKeyUpdatedSet.has(snapshot.context.id)) {
-                    Schema._updateCacheKey(snapshot.context.schemaName, snapshot.context.id);
-                    cacheKeyUpdatedSet.add(snapshot.context.id);
-                }
-            }
-        });
-        // Note: Property getters/setters are now handled by the Proxy in create()
-    }
-    static create(schemaName, options) {
-        if (!schemaName) {
-            throw new Error('Schema name is required');
-        }
-        const waitForReady = options?.waitForReady !== false;
-        const readyTimeout = options?.readyTimeout ?? DEFAULT_READY_TIMEOUT_MS;
-        const holds = options?.hold === false ? 0 : 1;
-        // First, check if we have an instance cached by name
-        const cached = this.instanceCacheByName.get(schemaName);
-        if (cached) {
-            cached.refCount += holds;
-            const { instance } = cached;
-            if (!waitForReady)
-                return instance;
-            return waitForEntityIdle(instance, { timeout: readyTimeout }).then(() => instance);
-        }
-        // Deduplicate concurrent creates for same schema (prevents many parallel checkExistingSchema loads).
-        // The name cache is set before a pending load is recorded, so a hold was already taken above.
-        if (waitForReady) {
-            const pending = this.pendingSchemaByName.get(schemaName);
-            if (pending) {
-                return pending;
-            }
-        }
-        // Create new instance
-        const newInstance = new this(schemaName);
-        // Wrap instance in Proxy for reactive property access
-        const proxiedInstance = createReactiveProxy({
-            instance: newInstance,
-            service: newInstance._service,
-            trackedProperties: TRACKED_PROPERTIES,
-            getContext: (instance) => {
-                // Handle special cases like metadata.name, models array conversion
-                const context = instance._getSnapshotContext();
-                // Get the schema name, ensuring it's never the ID
-                // Prefer metadata.name, then schemaName (but only if it's not the ID)
-                const schemaFileId = context.id; // id is now the schemaFileId (string)
-                let name = context.metadata?.name;
-                // If metadata.name is not available, use schemaName but only if it's not the ID
-                // This prevents returning the ID when the schema is still loading
-                if (!name) {
-                    name = (context.schemaName && context.schemaName !== schemaFileId)
-                        ? context.schemaName
-                        : undefined;
-                }
-                // Final fallback - if we still don't have a name, use schemaName (even if it might be the ID)
-                // This handles edge cases during loading
-                if (!name) {
-                    name = context.schemaName;
-                }
-                // CRITICAL: Always create a new metadata object to ensure React detects changes
-                // Even if the metadata content is the same, we need a new reference so React re-renders
-                const metadata = context.metadata ? {
-                    ...context.metadata,
-                } : undefined;
-                return {
-                    ...context,
-                    // Always return a new metadata object reference so React detects changes
-                    metadata,
-                    // Flatten metadata properties to top level for convenience
-                    // Fall back to schemaName if metadata.name is not available (handles loading states)
-                    name,
-                    createdAt: context.metadata?.createdAt,
-                    updatedAt: context.metadata?.updatedAt,
-                };
-            },
-            sendUpdate: (instance, prop, value) => {
-                // Handle special property updates
-                if (prop === 'name') {
-                    // Update both metadata.name and schemaName
-                    const context = instance._getSnapshotContext();
-                    const currentMetadata = context.metadata || {
-                        name: schemaName,
-                        createdAt: new Date().toISOString(),
-                        updatedAt: new Date().toISOString(),
-                    };
-                    const oldName = currentMetadata.name || context.schemaName;
-                    const newName = value;
-                    // Only update if the name actually changed
-                    if (oldName !== newName) {
-                        logger(`Updating schema name from "${oldName}" to "${newName}"`);
-                        // Check if service is still running before sending events
-                        let snapshot = instance._service.getSnapshot();
-                        const wasServiceStopped = snapshot.status === 'stopped';
-                        if (wasServiceStopped) {
-                            // CRITICAL: Update the schemaName in the service context BEFORE restarting
-                            // This ensures that when loadOrCreateSchema runs, it looks for the schema with the NEW name
-                            // We need to do this by sending updateContext to a running service, but if it's stopped,
-                            // we need to restart it first, update, then it will reload with the new name
-                            logger(`Service is stopped, will update schemaName to "${newName}" then restart`);
-                            // Start the service first
-                            instance._service.start();
-                            // Immediately update the schemaName so loadOrCreateSchema uses the new name
-                            // This must happen before loadOrCreateSchema runs
-                            instance._service.send({
-                                type: 'updateContext',
-                                schemaName: newName,
-                            });
-                            logger(`Updated schemaName to "${newName}" before loadOrCreateSchema runs`);
-                            // Re-check snapshot after restart - service might be loading or already idle
-                            snapshot = instance._service.getSnapshot();
-                        }
-                        // Build the update event with the new name
-                        const updateEvent = {
-                            type: 'updateContext',
-                            schemaName: newName,
-                            metadata: {
-                                ...(currentMetadata || {
-                                    name: newName,
-                                    createdAt: new Date().toISOString(),
-                                    updatedAt: new Date().toISOString(),
-                                }),
-                                name: newName, // Always use the new name
-                                updatedAt: new Date().toISOString(), // Always update timestamp
-                            },
-                        };
-                        // Check current state after potential restart
-                        const currentState = snapshot.value;
-                        // Check if state is a loading state object (XState v5 nested states)
-                        const isServiceLoading = typeof currentState === 'object' && 'loading' in currentState;
-                        // If service is loading (or was just restarted and might be loading), wait for it to finish
-                        // Otherwise loadOrCreateSchemaSuccess might overwrite our update with old data
-                        if (isServiceLoading || wasServiceStopped) {
-                            logger(`Service is ${isServiceLoading ? 'loading' : 'was stopped'}, will send updateContext after loading completes (current state: ${currentState})`);
-                            // Helper function to send the update
-                            const sendUpdate = () => {
-                                logger(`Sending updateContext with newName="${newName}"`);
-                                instance._service.send(updateEvent);
-                                // Verify the update
-                                setTimeout(() => {
-                                    const verifySnapshot = instance._service.getSnapshot();
-                                    logger(`After updateContext: context schemaName="${verifySnapshot.context.schemaName}", metadata.name="${verifySnapshot.context.metadata?.name}"`);
-                                }, 0);
-                            };
-                            // Check if already idle (might have loaded synchronously)
-                            if (currentState === 'idle') {
-                                // Service is already idle, but loadOrCreateSchemaSuccess might have just fired
-                                // Use a small delay to ensure loadOrCreateSchemaSuccess has been processed
-                                logger(`Service is already idle after restart, will send updateContext after brief delay to ensure loadOrCreateSchemaSuccess processed`);
-                                setTimeout(() => {
-                                    sendUpdate();
-                                }, 10);
-                            }
-                            else {
-                                // Subscribe to wait for loading to complete, then send the update
-                                // Use a small delay after idle to ensure loadOrCreateSchemaSuccess has been processed
-                                const loadingSubscription = instance._service.subscribe((snapshot) => {
-                                    if (snapshot.value === 'idle') {
-                                        loadingSubscription.unsubscribe();
-                                        logger(`Service finished loading, will send updateContext with newName="${newName}" after brief delay`);
-                                        setTimeout(() => {
-                                            sendUpdate();
-                                        }, 10);
-                                    }
-                                    else if (snapshot.value === 'error') {
-                                        loadingSubscription.unsubscribe();
-                                        logger(`Service failed to load, cannot update context`);
-                                    }
-                                });
-                            }
-                        }
-                        else {
-                            // Service is already idle, send update immediately
-                            logger(`Service is already idle, sending updateContext immediately: newName="${newName}", current context schemaName="${snapshot.context.schemaName}"`);
-                            instance._service.send(updateEvent);
-                            // Verify the update
-                            setTimeout(() => {
-                                const verifySnapshot = instance._service.getSnapshot();
-                                logger(`After updateContext: context schemaName="${verifySnapshot.context.schemaName}", metadata.name="${verifySnapshot.context.metadata?.name}"`);
-                            }, 0);
-                        }
-                        // Mark schema as draft when name changes
-                        instance._service.send({
-                            type: 'markAsDraft',
-                            propertyKey: 'schema:name', // Special key for schema name changes
-                        });
-                        // Save draft to database immediately so changes persist
-                        saveDraftLogger(`Name change detected, calling _saveDraftToDb (oldName: "${oldName}", newName: "${newName}")`);
-                        trackDraftSave(instance._service, instance._saveDraftToDb(oldName, newName), `Schema "${newName}"`);
-                    }
-                    else {
-                        logger(`Schema name unchanged: "${oldName}"`);
-                    }
-                }
-                else if (prop === 'models') {
-                    // Models are read-only, computed from Model instances. Array assignment was removed because
-                    // the draft save could run before the new Model instances existed, losing them.
-                    throw new Error('Cannot set schema.models directly. Models are computed from Model instances; ' +
-                        'use Model.create(modelName, schema, { properties }) to add one.');
-                }
-                else if (prop === 'createdAt' || prop === 'updatedAt') {
-                    // Update metadata object
-                    const metadataContext = newInstance._getSnapshotContext();
-                    const currentMetadata = metadataContext.metadata || {
-                        name: schemaName,
-                        createdAt: new Date().toISOString(),
-                        updatedAt: new Date().toISOString(),
-                    };
-                    newInstance._service.send({
-                        type: 'updateContext',
-                        metadata: {
-                            ...currentMetadata,
-                            [prop]: value,
-                            updatedAt: new Date().toISOString(),
-                        },
-                    });
-                }
-                else {
-                    // Standard property update
-                    newInstance._service.send({
-                        type: 'updateContext',
-                        [prop]: value,
-                    });
-                    // Mark schema as draft for other property changes
-                    newInstance._service.send({
-                        type: 'markAsDraft',
-                        propertyKey: prop,
-                    });
-                    // Save draft to database for tracked properties
-                    if (TRACKED_PROPERTIES.includes(prop)) {
-                        const trackedPropContext = newInstance._getSnapshotContext();
-                        const schemaName = trackedPropContext.metadata?.name || trackedPropContext.schemaName;
-                        trackDraftSave(newInstance._service, newInstance._saveDraftToDb(schemaName, schemaName), `Schema "${schemaName}"`);
-                    }
-                }
-            },
-        });
-        // Cache by name initially (will be moved to id-based cache once schemaFileId is available)
-        this.instanceCacheByName.set(schemaName, {
-            instance: proxiedInstance,
-            refCount: holds,
-        });
-        const schema = proxiedInstance;
-        if (!waitForReady)
-            return schema;
-        const readyPromise = waitForEntityIdle(schema, { timeout: readyTimeout }).then(() => schema);
-        this.pendingSchemaByName.set(schemaName, readyPromise);
-        // Clear on both outcomes without a .finally() chain: that derived promise would reject unhandled
-        // whenever readyPromise does, even when the caller handles the rejection.
-        const clearPending = () => {
-            this.pendingSchemaByName.delete(schemaName);
-        };
-        readyPromise.then(clearPending, clearPending);
-        return readyPromise;
-    }
-    /**
-     * Update the cache to use schemaFileId as the key instead of schemaName
-     * This should be called once the schema is loaded and we have the schemaFileId
-     * We keep the instance in BOTH caches for efficient lookups by either name or ID
-     */
-    static _updateCacheKey(schemaName, schemaFileId) {
-        // If we already have an entry with this id, skip (already processed)
-        if (this.instanceCacheById.has(schemaFileId)) {
-            return;
-        }
-        // If we have an instance cached by name, also add it to id-based cache
-        // Keep it in both caches for efficient lookups, as one entry: one hold count for both keys
-        if (this.instanceCacheByName.has(schemaName)) {
-            const cacheEntry = this.instanceCacheByName.get(schemaName);
-            // Add to ID cache (don't remove from name cache)
-            this.instanceCacheById.set(schemaFileId, cacheEntry);
-            logger(`Added schema cache entry to id "${schemaFileId}" (kept in name cache: "${schemaName}")`);
-        }
-    }
-    /**
-     * Get schema instance by schemaFileId (preferred method)
-     * Returns null if not found in cache
-     */
-    static getById(schemaFileId) {
-        const entry = this.instanceCacheById.get(schemaFileId);
-        if (!entry)
-            return null;
-        entry.refCount += 1;
-        return entry.instance;
-    }
-    /**
-     * The cached schema with this file id or name, without taking a hold. For SDK code that reads
-     * the schema and doesn't hand it to a caller; callers that keep it use `create` or `find`.
-     */
-    static peek(schemaFileIdOrName) {
-        return (this.instanceCacheById.get(schemaFileIdOrName)?.instance ??
-            this.instanceCacheByName.get(schemaFileIdOrName)?.instance);
-    }
-    /**
-     * Clear all cached Schema instances.
-     * This is primarily useful for test cleanup.
-     * All cached instances will be unloaded and removed from both caches.
-     */
-    static clearCache() {
-        // Collect all unique instances from both caches
-        const instances = new Set();
-        // Collect from ID-based cache
-        for (const { instance } of this.instanceCacheById.values()) {
-            instances.add(instance);
-        }
-        // Collect from name-based cache
-        for (const { instance } of this.instanceCacheByName.values()) {
-            instances.add(instance);
-        }
-        // Unload all instances (this will properly clean up services and state)
-        for (const instance of instances) {
-            try {
-                instance.unload();
-            }
-            catch {
-                // Ignore errors during cleanup (instance might already be unloaded)
-            }
-        }
-        // Clear both caches and pending map
-        this.instanceCacheById.clear();
-        this.instanceCacheByName.clear();
-        this.pendingSchemaByName.clear();
-    }
-    /**
-     * Create or get schema instance by schemaFileId
-     * Queries the database to find the schema name if not cached
-     * @param schemaFileId - The schema file ID
-     * @returns Schema instance, with a hold taken (unless `hold: false`)
-     */
-    static async createById(schemaFileId, 
-    /** @internal `hold: false` as for `create` */
-    options) {
-        if (!schemaFileId) {
-            throw new Error('Schema file ID is required');
-        }
-        // First, check if we have an instance cached by ID
-        const cachedInstance = options?.hold === false ? this.peek(schemaFileId) : this.getById(schemaFileId);
-        if (cachedInstance) {
-            return cachedInstance;
-        }
-        // Query database to get schema name from ID
-        const db = BaseDb.getAppDb();
-        if (!db) {
-            throw new Error('Database not available');
-        }
-        const dbSchemas = await db
-            .select()
-            .from(schemas)
-            .where(eq(schemas.schemaFileId, schemaFileId))
-            .orderBy(desc(schemas.version))
-            .limit(1);
-        if (dbSchemas.length === 0) {
-            throw new Error(`Schema with ID "${schemaFileId}" not found in database`);
-        }
-        const dbSchema = dbSchemas[0];
-        const schemaName = dbSchema.name;
-        if (!schemaName) {
-            throw new Error(`Schema with ID "${schemaFileId}" has no name in database`);
-        }
-        // Create schema using the name (this will load from database/file)
-        return this.create(schemaName, options?.hold === false ? { hold: false } : undefined);
-    }
-    /**
-     * Find schema instance by schemaFileId
-     * Waits for the schema to be fully loaded (idle state) by default
-     * @param options - Find options including schemaFileId and wait configuration
-     * @returns Schema instance if found, undefined otherwise
-     */
-    static async find({ schemaFileId, waitForReady = true, readyTimeout = DEFAULT_READY_TIMEOUT_MS, }) {
-        if (!schemaFileId) {
-            return undefined;
-        }
-        try {
-            return await findEntity({
-                getById: (id) => Schema.getById(id) ?? undefined,
-                createById: (id) => Schema.createById(id),
-            }, { id: schemaFileId }, {
-                waitForReady,
-                readyTimeout,
-            });
-        }
-        catch {
-            return undefined;
-        }
-    }
-    /**
-     * Get instantiated Schema objects for all schemas (from database and files)
-     * By default, returns only the latest version of each schema and excludes the internal Seed Protocol schema.
-     * Uses loadAllSchemasFromDb() as the single source of truth, which intelligently merges database and file data.
-     * Takes no holds on the instances it returns: a caller that keeps one uses `Schema.create` or `Schema.find`.
-     *
-     * @param options - Configuration options
-     * @param options.includeAllVersions - If true, returns all versions of each schema. Default: false
-     * @param options.includeInternal - If true, includes the internal Seed Protocol schema. Default: false
-     * @returns Array of Schema instances
-     */
-    static async all(options = {}) {
-        const { includeAllVersions = false, includeInternal = false, waitForReady = false, readyTimeout = DEFAULT_READY_TIMEOUT_MS, } = options;
-        try {
-            // Use loadAllSchemasFromDb as single source of truth
-            // This intelligently merges database and file data, including drafts
-            const allSchemasData = await loadAllSchemasFromDb();
-            // Filter internal schemas unless explicitly included
-            let filteredSchemas = includeInternal
-                ? allSchemasData
-                : allSchemasData.filter(schemaData => {
-                    const schema = schemaData.schema;
-                    // Check if this is an internal schema by name or ID
-                    return !isInternalSchema(schema.metadata?.name || '', schema.id);
-                });
-            // Filter to latest versions if needed
-            if (!includeAllVersions) {
-                // Group by schema name and keep only the latest version of each
-                const schemaMap = new Map();
-                for (const schemaData of filteredSchemas) {
-                    const schemaName = schemaData.schema.metadata?.name || '';
-                    if (!schemaName)
-                        continue;
-                    const existing = schemaMap.get(schemaName);
-                    if (!existing || schemaData.schema.version > existing.schema.version) {
-                        schemaMap.set(schemaName, schemaData);
-                    }
-                    else if (schemaData.schema.version === existing.schema.version) {
-                        // If versions are equal, use updatedAt as tiebreaker
-                        const currentUpdatedAt = new Date(schemaData.schema.metadata?.updatedAt || 0).getTime();
-                        const existingUpdatedAt = new Date(existing.schema.metadata?.updatedAt || 0).getTime();
-                        if (currentUpdatedAt > existingUpdatedAt) {
-                            schemaMap.set(schemaName, schemaData);
-                        }
-                    }
-                }
-                filteredSchemas = Array.from(schemaMap.values());
-            }
-            // Create Schema instances using the schemaFileId from filtered data to ensure correct version
-            const schemaInstances = [];
-            const processedSchemaNames = new Set();
-            for (const schemaData of filteredSchemas) {
-                const schemaName = schemaData.schema.metadata?.name;
-                const schemaFileId = schemaData.schema.id;
-                const expectedVersion = schemaData.schema.version;
-                if (!schemaName)
-                    continue;
-                // Skip if we've already processed this schema name (to avoid duplicates)
-                if (processedSchemaNames.has(schemaName)) {
-                    continue;
-                }
-                processedSchemaNames.add(schemaName);
-                // Try to use schemaFileId to ensure we load the correct version
-                // First check if we have a cached instance by schemaFileId. Schema.all takes no holds: it
-                // lists schemas (useSchemas caches the list and never unloads it).
-                if (schemaFileId) {
-                    const cachedById = this.peek(schemaFileId);
-                    if (cachedById) {
-                        // Verify the cached instance has the correct version
-                        const cachedContext = cachedById.getService().getSnapshot().context;
-                        if (cachedContext.version === expectedVersion) {
-                            schemaInstances.push(cachedById);
-                            continue;
-                        }
-                    }
-                }
-                // If no cached instance by ID, check by name but verify version
-                const cachedByName = this.instanceCacheByName.get(schemaName);
-                if (cachedByName) {
-                    const cachedContext = cachedByName.instance.getService().getSnapshot().context;
-                    // Only use cached instance if it has the correct version
-                    if (cachedContext.version === expectedVersion && (!schemaFileId || cachedContext.id === schemaFileId)) {
-                        schemaInstances.push(cachedByName.instance);
-                        continue;
-                    }
-                }
-                // Create new instance - it will load from database
-                // The loadOrCreateSchema actor should query by name and get the latest version
-                // But to ensure we get the correct version, we'll use createById if we have the schemaFileId
-                if (schemaFileId) {
-                    try {
-                        const instance = await this.createById(schemaFileId, { hold: false });
-                        schemaInstances.push(instance);
-                    }
-                    catch {
-                        // Fallback to creating by name if createById fails
-                        schemaInstances.push(this.create(schemaName, { waitForReady: false, hold: false }));
-                    }
-                }
-                else {
-                    schemaInstances.push(this.create(schemaName, { waitForReady: false, hold: false }));
-                }
-            }
-            if (waitForReady && schemaInstances.length > 0) {
-                await Promise.all(schemaInstances.map((s) => waitForEntityIdle(s, {
-                    timeout: readyTimeout,
-                })));
-            }
-            return schemaInstances;
-        }
-        catch (error) {
-            // Fallback to file-based approach if database is unavailable
-            // This maintains backward compatibility for environments without database
-            logger(`Error loading schemas from database, falling back to files: ${error instanceof Error ? error.message : String(error)}`);
-            // Use existing file-based implementation as fallback
-            const allSchemaFiles = await listCompleteSchemaFiles();
-            // Filter out internal schemas unless explicitly included
-            const filteredSchemas = includeInternal
-                ? allSchemaFiles
-                : allSchemaFiles.filter(schema => {
-                    // Check if this is an internal schema by name or ID
-                    return !isInternalSchema(schema.name, schema.schemaFileId);
-                });
-            // If includeAllVersions is false, filter to only latest version of each schema
-            const schemasToUse = includeAllVersions
-                ? filteredSchemas
-                : (() => {
-                    // Group by schema name and keep only the latest version of each
-                    const schemaMap = new Map();
-                    for (const schema of filteredSchemas) {
-                        const existing = schemaMap.get(schema.name);
-                        if (!existing || schema.version > existing.version) {
-                            schemaMap.set(schema.name, schema);
-                        }
-                    }
-                    return Array.from(schemaMap.values());
-                })();
-            // Get unique schema names (one instance per schema name)
-            const uniqueSchemaNames = new Set();
-            for (const schema of schemasToUse) {
-                uniqueSchemaNames.add(schema.name);
-            }
-            // Create Schema instances for each unique schema name
-            const schemaInstances = [];
-            for (const schemaName of uniqueSchemaNames) {
-                schemaInstances.push(this.create(schemaName, { waitForReady: false, hold: false }));
-            }
-            if (waitForReady && schemaInstances.length > 0) {
-                await Promise.all(schemaInstances.map((s) => waitForEntityIdle(s, {
-                    timeout: readyTimeout,
-                })));
-            }
-            return schemaInstances;
-        }
-    }
-    getService() {
-        return this._service;
-    }
-    _getSnapshot() {
-        return this._service.getSnapshot();
-    }
-    _getSnapshotContext() {
-        return this._getSnapshot().context;
-    }
-    get schemaName() {
-        const context = this._getSnapshotContext();
-        const schemaFileId = context.id; // id is now the schemaFileId (string)
-        // Prefer metadata.name if available (most reliable)
-        if (context.metadata?.name) {
-            return context.metadata.name;
-        }
-        // If metadata.name is not available, use schemaName but only if it's not the ID
-        // This prevents returning the ID when the schema is still loading or if an ID was mistakenly passed
-        if (context.schemaName && context.schemaName !== schemaFileId) {
-            return context.schemaName;
-        }
-        // Final fallback - return schemaName even if it might be the ID
-        // This handles edge cases during loading, but should be rare
-        return context.schemaName || '';
-    }
-    get schemaFileId() {
-        return this._getSnapshotContext().id; // id is now the schemaFileId (string)
-    }
-    get id() {
-        return this._getSnapshotContext().id; // id is now the schemaFileId (string)
-    }
-    /**
-     * Returns Model instances for this schema
-     * This is a computed property that reads from the service context
-     * Note: This is NOT reactive - use useModels() hook for reactivity
-     */
-    get models() {
-        const context = this._getSnapshotContext();
-        const schemaName = context.schemaName;
-        // Get model IDs from service context (reactive state)
-        const liveQueryIds = context._liveQueryModelIds || [];
-        // Get pending model IDs (not yet in DB)
-        // Note: schemaId lookup is async, so we skip pending IDs here
-        // They will be included when schemaId is available asynchronously
-        const pendingIds = [];
-        // Combine and deduplicate
-        const allModelIds = [...new Set([...liveQueryIds, ...pendingIds])];
-        // Get Model instances from static cache (from schema load)
-        const seen = new Set();
-        const modelInstances = [];
-        for (const modelFileId of allModelIds) {
-            const model = Model.peek(modelFileId);
-            if (model && modelFileId && !seen.has(modelFileId)) {
-                modelInstances.push(model);
-                seen.add(modelFileId);
-            }
-        }
-        // Include models created at runtime via Model.create() that belong to this schema
-        // (they may not be in _liveQueryModelIds until schema context is updated)
-        if (schemaName) {
-            const cachedForSchema = Model.getCachedInstancesForSchema(schemaName);
-            for (const model of cachedForSchema) {
-                const id = model.id;
-                if (id && !seen.has(id)) {
-                    modelInstances.push(model);
-                    seen.add(id);
-                }
-            }
-        }
-        // Return a new array reference (snapshot at time of access)
-        return [...modelInstances];
-    }
-    get status() {
-        return this._getSnapshot().value;
-    }
-    get isEdited() {
-        const context = this._getSnapshotContext();
-        // First check in-memory state
-        if (context._isEdited !== undefined) {
-            return context._isEdited;
-        }
-        // Fall back to reading from database if we have _dbId
-        if (context._dbId) {
-            // Load from database asynchronously (fire-and-forget for now)
-            // For synchronous getter, we'll need to cache it or make it async
-            // For now, return false if not in context
-            return false;
-        }
-        return false;
-    }
-    get validationErrors() {
-        return this._getSnapshotContext()._validationErrors || [];
-    }
-    /**
-     * The error from the last draft save that an assignment started (e.g. `schema.name = ...`),
-     * such as a ConflictError; undefined once a later one succeeds.
-     */
-    get lastSaveError() {
-        return getDraftSaveError(this._service);
-    }
-    get isValid() {
-        const errors = this.validationErrors;
-        return errors.length === 0;
-    }
-    /**
-     * Validate the schema
-     * @returns Validation result
-     */
-    async validate() {
-        return new Promise((resolve) => {
-            let resolved = false;
-            const subscription = this._service.subscribe((snapshot) => {
-                if (snapshot.value === 'idle' || snapshot.value === 'error') {
-                    if (!resolved) {
-                        resolved = true;
-                        subscription.unsubscribe();
-                        const errors = snapshot.context._validationErrors || [];
-                        resolve({
-                            isValid: errors.length === 0,
-                            errors,
-                        });
-                    }
-                }
-            });
-            this._service.send({ type: 'validateSchema' });
-            // Timeout fallback to ensure we always resolve (15 seconds - longer than actor timeout)
-            setTimeout(() => {
-                if (!resolved) {
-                    resolved = true;
-                    subscription.unsubscribe();
-                    const errors = this._getSnapshotContext()._validationErrors || [];
-                    resolve({
-                        isValid: errors.length === 0,
-                        errors,
-                    });
-                }
-            }, 15000);
-        });
-    }
-    /**
-     * Build the file-format `models` object from this schema's Model instances: every model
-     * (those created at runtime too), each property as its file definition ({ id, type, model,
-     * ref, refValueType, required, storage, validation, ... }).
-     */
-    async _buildModelsFromInstances() {
-        const context = this._getSnapshotContext();
-        const { convertPropertyToSchemaUpdate } = await Promise.resolve().then(function () { return updateSchema; });
-        const models = {};
-        for (const modelInstance of this.models) {
-            try {
-                const modelName = modelInstance.modelName;
-                if (!modelName)
-                    continue;
-                const properties$1 = {};
-                let propertyContexts = (modelInstance.properties ?? []).map((property) => property.getService().getSnapshot().context);
-                // model.properties can still be empty for a model created at runtime (the browser fills
-                // it from a live query): read the rows, preferring each row's cached instance.
-                const modelDbId = modelInstance.getService().getSnapshot().context._dbId;
-                const db = BaseDb.getAppDb();
-                if (propertyContexts.length === 0 && modelDbId && db) {
-                    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;
-                        return cached
-                            ? cached.getService().getSnapshot().context
-                            : {
-                                ...row,
-                                id: row.schemaFileId ?? undefined,
-                                refModelId: row.refModelId ?? undefined,
-                                refValueType: row.refValueType ?? undefined,
-                                storageType: row.storageType ?? undefined,
-                                localStorageDir: row.localStorageDir ?? undefined,
-                                filenameSuffix: row.filenameSuffix ?? undefined,
-                            };
-                    });
-                }
-                const contextModel = context.models?.[modelName];
-                const fromContext = contextModel?.properties;
-                // nameMatch lives only in the schema file (ADR 0009): keep each property's, found by id
-                // first so a renamed property keeps it.
-                const contextNameMatch = (ctx) => {
-                    const defs = Object.values(fromContext ?? {});
-                    const def = (ctx.id ? defs.find((d) => d?.id === ctx.id) : undefined) ?? fromContext?.[ctx.name];
-                    return def?.nameMatch;
-                };
-                for (const ctx of propertyContexts) {
-                    if (!ctx.name)
-                        continue;
-                    const { updates } = await convertPropertyToSchemaUpdate(ctx, modelName, ctx.name);
-                    const nameMatch = contextNameMatch(ctx);
-                    properties$1[ctx.name] = {
-                        ...(ctx.id ? { id: ctx.id } : {}),
-                        ...updates,
-                        ...(ctx.validation ? { validation: ctx.validation } : {}),
-                        ...(ctx.htmlEmbeddedDataUriPolicy ? { htmlEmbeddedDataUriPolicy: ctx.htmlEmbeddedDataUriPolicy } : {}),
-                        ...(nameMatch !== undefined ? { nameMatch } : {}),
-                    };
-                }
-                // No property instances loaded for this model: keep the definitions the schema has.
-                models[modelName] = {
-                    ...(modelInstance.id ? { id: modelInstance.id } : {}),
-                    ...(contextModel?.nameMatch !== undefined ? { nameMatch: contextModel.nameMatch } : {}),
-                    properties: Object.keys(properties$1).length > 0 || !fromContext ? properties$1 : fromContext,
-                };
-            }
-            catch (error) {
-                logger(`Error building model from instance: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        logger(`Built ${Object.keys(models).length} models from Model instances`);
-        return models;
-    }
-    /**
-     * Saves all edited properties to a new schema version.
-     * This writes the changes to a new JSON file and clears the draft flags.
-     * Validates the schema before saving.
-     * Transitions schema from draft (DB-only) to published (file + DB).
-     * @returns The file path of the new schema version
-     */
-    async saveNewVersion() {
-        // Check for conflicts before saving
-        const conflictCheck = await this._checkForConflicts();
-        if (conflictCheck.hasConflict) {
-            const errorMessage = conflictCheck.message || 'Database was updated externally. Please reload the schema and try again.';
-            logger(`CONFLICT DETECTED: ${errorMessage}`);
-            throw new ConflictError(errorMessage, conflictCheck);
-        }
-        const context = this._getSnapshotContext();
-        if (!context._isDraft || !context._editedProperties || context._editedProperties.size === 0) {
-            logger('No changes to save');
-            return '';
-        }
-        // Validate schema before saving
-        const validationResult = await this.validate();
-        if (!validationResult.isValid) {
-            logger(`Schema validation failed with ${validationResult.errors.length} errors`);
-            throw new Error(`Cannot save schema: validation failed. Errors: ${validationResult.errors.map(e => e.message).join(', ')}`);
-        }
-        logger(`Saving new version for schema ${this.schemaName} with ${context._editedProperties.size} edited properties`);
-        // STEP 1: Ensure draft exists in database and update it with current state
-        const db = BaseDb.getAppDb();
-        if (!db) {
-            throw new Error('Database not found');
-        }
-        // Build current schema state from context
-        // CRITICAL: Read models from Model instances, not from Schema context
-        // Model instances are the source of truth for model data
-        const modelsFromInstances = await this._buildModelsFromInstances();
-        const currentSchema = {
-            id: context.id,
-            $schema: context.$schema || 'https://seedprotocol.org/schemas/data-model/v1',
-            version: context.version || 1,
-            metadata: context.metadata || {
-                name: this.schemaName,
-                createdAt: new Date().toISOString(),
-                updatedAt: new Date().toISOString(),
-            },
-            models: modelsFromInstances, // Read from Model instances, not context.models
-            enums: context.enums || {},
-            migrations: context.migrations || [],
-            ...(context.nameMatch !== undefined && { nameMatch: context.nameMatch }),
-        };
-        // Update draft in database with current state
-        await addSchemaToDb({
-            name: this.schemaName,
-            version: currentSchema.version,
-            createdAt: new Date(currentSchema.metadata.createdAt).getTime(),
-            updatedAt: new Date(currentSchema.metadata.updatedAt).getTime(),
-        }, currentSchema.id, JSON.stringify(currentSchema, null, 2), true);
-        const dbSchema = await db
-            .select()
-            .from(schemas)
-            .where(eq(schemas.name, this.schemaName))
-            .limit(1);
-        // Check we have something to save: schema:models (new models) or modelName:propertyName (property edits)
-        const hasSchemaModels = context._editedProperties.has('schema:models');
-        const hasPropertyEdits = [...context._editedProperties].some((key) => {
-            const [modelName, propertyName] = key.split(':');
-            return modelName && propertyName && key !== 'schema:name';
-        });
-        if (!hasSchemaModels && !hasPropertyEdits) {
-            logger('No valid property updates to save');
-            return '';
-        }
-        // Use writeFullSchemaNewVersion for all edits - handles renames, new models, property updates.
-        // Model instances have the correct (current) structure including renamed properties.
-        // STEP 2: Save to new schema version (writes file)
-        const newFilePath = await writeFullSchemaNewVersion(this.schemaName, currentSchema);
-        // STEP 3: After file is written, update database to mark as published (isDraft = false)
-        // Load the file to get the final schema with IDs
-        const fileContent = await BaseFileManager.readFileAsString(newFilePath);
-        const publishedSchema = JSON.parse(fileContent);
-        // Update database record: set isDraft = false and update schemaFileId
-        if (dbSchema.length > 0) {
-            clearNameMatchLevels(); // the stored schema file changes (ADR 0009)
-            await db
-                .update(schemas)
-                .set({
-                isDraft: false,
-                isEdited: false, // Clear isEdited flag after saving to file
-                schemaFileId: publishedSchema.id,
-                schemaData: JSON.stringify(publishedSchema, null, 2),
-                version: publishedSchema.version,
-                updatedAt: new Date(publishedSchema.metadata.updatedAt).getTime(),
-            })
-                .where(eq(schemas.id, dbSchema[0].id));
-        }
-        else {
-            // Create new record if it doesn't exist (shouldn't happen, but safety)
-            await addSchemaToDb({
-                name: this.schemaName,
-                version: publishedSchema.version,
-                createdAt: new Date(publishedSchema.metadata.createdAt).getTime(),
-                updatedAt: new Date(publishedSchema.metadata.updatedAt).getTime(),
-            }, publishedSchema.id, JSON.stringify(publishedSchema, null, 2), false, // isDraft = false (published)
-            false);
-        }
-        // Clear draft flags on Schema and update conflict detection metadata
-        this._service.send({
-            type: 'clearDraft',
-            _dbUpdatedAt: new Date(publishedSchema.metadata.updatedAt).getTime(),
-            _dbVersion: publishedSchema.version,
-            savedSchema: publishedSchema,
-        });
-        // Clear edited flags on all ModelProperty instances and in database
-        const modelPropertyMod = await import('./ModelProperty-i5flwzQG.js');
-        const { ModelProperty } = modelPropertyMod;
-        for (const propertyKey of context._editedProperties) {
-            const [modelName, propertyName] = propertyKey.split(':');
-            const ModelPropertyClass = ModelProperty;
-            // Model names are only unique per schema: pick this schema's instance, which may be keyed by id.
-            const thisSchemaName = this.schemaName;
-            const cachedInstance = [...ModelPropertyClass.instanceCache.values()].find(({ instance }) => {
-                const ctx = instance.getService().getSnapshot().context;
-                return (ctx.modelName === modelName &&
-                    ctx.name === propertyName &&
-                    (!ctx._schemaName || ctx._schemaName === thisSchemaName));
-            });
-            if (cachedInstance) {
-                const modelProperty = cachedInstance.instance;
-                // Update original values to current values and clear edited flag
-                modelProperty.getService().send({
-                    type: 'clearEdited',
-                });
-                // Clear isEdited flag in database
-                try {
-                    if (db && modelName && propertyName) {
-                        // Find this schema's model by name
-                        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) {
-                            // Find property by name and modelId
-                            const propertyRecords = await db
-                                .select({ id: properties.id })
-                                .from(properties)
-                                .where(and(eq(properties.name, propertyName), eq(properties.modelId, modelRecords[0].id)))
-                                .limit(1);
-                            if (propertyRecords.length > 0) {
-                                // Clear isEdited flag in database
-                                await db
-                                    .update(properties)
-                                    .set({ isEdited: false })
-                                    .where(eq(properties.id, propertyRecords[0].id));
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    logger(`Error clearing isEdited flag in database for property ${propertyKey}: ${error}`);
-                }
-            }
-        }
-        // Clear isEdited flags for all models in this schema
-        try {
-            if (db && context._dbId) {
-                // Get all models for this schema
-                const modelRecords = await db
-                    .select({ id: models.id })
-                    .from(modelSchemas)
-                    .innerJoin(models, eq(modelSchemas.modelId, models.id))
-                    .where(eq(modelSchemas.schemaId, context._dbId));
-                // Clear isEdited flag for all models
-                for (const modelRecord of modelRecords) {
-                    if (modelRecord.id) {
-                        await db
-                            .update(models)
-                            .set({ isEdited: false })
-                            .where(eq(models.id, modelRecord.id));
-                    }
-                }
-            }
-        }
-        catch (error) {
-            logger(`Error clearing isEdited flags for models: ${error}`);
-        }
-        logger(`Successfully saved new version for schema ${this.schemaName} and published to file`);
-        return newFilePath;
-    }
-    /**
-     * Check for conflicts between actor context and database
-     * @returns ConflictResult indicating if a conflict exists
-     */
-    async _checkForConflicts() {
-        const context = this._getSnapshotContext();
-        // If we don't have load metadata, can't check for conflicts
-        if (!context._dbUpdatedAt || !context.id) {
-            return { hasConflict: false };
-        }
-        try {
-            const db = BaseDb.getAppDb();
-            if (!db) {
-                return { hasConflict: false }; // Can't check without DB
-            }
-            // Get current DB record
-            const dbSchemas = await db
-                .select()
-                .from(schemas)
-                .where(eq(schemas.schemaFileId, context.id)) // id is now the schemaFileId (string)
-                .orderBy(desc(schemas.version))
-                .limit(1);
-            if (dbSchemas.length === 0) {
-                return { hasConflict: false }; // No DB record, no conflict
-            }
-            const dbRecord = dbSchemas[0];
-            // Check if DB was updated after we loaded
-            const dbUpdatedAt = dbRecord.updatedAt || 0;
-            const localUpdatedAt = context._dbUpdatedAt;
-            if (dbUpdatedAt > localUpdatedAt) {
-                return {
-                    hasConflict: true,
-                    localVersion: context.version,
-                    dbVersion: dbRecord.version,
-                    localUpdatedAt: context.metadata?.updatedAt,
-                    dbUpdatedAt: new Date(dbUpdatedAt).toISOString(),
-                    message: `Database was updated externally. Local version: ${context.version}, DB version: ${dbRecord.version}`,
-                };
-            }
-            return { hasConflict: false };
-        }
-        catch (error) {
-            logger(`Error checking for conflicts: ${error instanceof Error ? error.message : String(error)}`);
-            return { hasConflict: false }; // On error, assume no conflict to allow save
-        }
-    }
-    /**
-     * Reload schema from database
-     * This refreshes the actor context with the latest data from the database
-     */
-    async reload() {
-        logger(`Reloading schema ${this.schemaName} from database`);
-        // Send reload event to machine
-        this._service.send({ type: 'reloadFromDb' });
-        // Wait for reload to complete
-        return new Promise((resolve, reject) => {
-            // Cleared once the reload settles: a pending timer kept Node scripts alive for 10 s.
-            const timer = setTimeout(() => {
-                subscription.unsubscribe();
-                reject(new Error('Timeout waiting for schema reload'));
-            }, 10000);
-            const subscription = this._service.subscribe((snapshot) => {
-                if (snapshot.value === 'idle') {
-                    clearTimeout(timer);
-                    subscription.unsubscribe();
-                    resolve();
-                }
-                else if (snapshot.value === 'error') {
-                    clearTimeout(timer);
-                    subscription.unsubscribe();
-                    reject(new Error('Failed to reload schema from database'));
-                }
-            });
-        });
-    }
-    /**
-     * Save the current schema state to the database as a draft
-     * This persists changes immediately without creating a new file version
-     * @param oldName - Optional old name to look up existing record before name change
-     * @param newName - Optional new name to use (if not provided, uses this.schemaName)
-     */
-    async _saveDraftToDb(oldName, newName) {
-        saveDraftLogger(`_saveDraftToDb called for schema (oldName: "${oldName}", newName: "${newName}")`);
-        // Don't save during initialization - schemas are being loaded from files, not created as drafts
-        // Check this FIRST before doing any expensive work like _getSnapshotContext()
-        if (typeof window !== 'undefined') {
-            const now = Date.now();
-            // Use cached check to avoid expensive operations
-            // Always check if cache is stale or if we previously got false (to allow recovery)
-            const cacheIsStale = cachedClientInitialized === null || (now - clientCheckTime) > CLIENT_CHECK_CACHE_MS;
-            const shouldRecheck = cacheIsStale || cachedClientInitialized === false;
-            saveDraftLogger(`Client check: cacheIsStale=${cacheIsStale}, shouldRecheck=${shouldRecheck}, cachedValue=${cachedClientInitialized}, timeSinceCheck=${now - clientCheckTime}ms`);
-            if (shouldRecheck) {
-                try {
-                    const client = getClient();
-                    const clientSnapshot = client.getService().getSnapshot();
-                    // Check if state is IDLE (primary check) - isInitialized is set in entry action so should be true
-                    // But we check it as a secondary safeguard
-                    const isIdle = clientSnapshot.value === ClientManagerState.IDLE;
-                    const isInitialized = clientSnapshot.context.isInitialized;
-                    // If state is IDLE, trust it even if isInitialized isn't set yet (entry action should set it)
-                    // This aligns with useIsClientReady which only checks the state value
-                    cachedClientInitialized = isIdle && (isInitialized !== false);
-                    clientCheckTime = now;
-                    saveDraftLogger(`Client state checked: state=${clientSnapshot.value}, isIdle=${isIdle}, isInitialized=${isInitialized}, result=${cachedClientInitialized}`);
-                }
-                catch (error) {
-                    // If we can't check client state, assume not initialized to be safe
-                    // But only cache for a short time to allow recovery
-                    cachedClientInitialized = false;
-                    clientCheckTime = now;
-                    saveDraftLogger(`Error checking client state: ${error instanceof Error ? error.message : String(error)}, setting cachedClientInitialized=false`);
-                }
-            }
-            else {
-                saveDraftLogger(`Using cached client state: cachedClientInitialized=${cachedClientInitialized}`);
-            }
-            if (!cachedClientInitialized) {
-                saveDraftLogger(`Client not initialized, skipping save (oldName: "${oldName}", newName: "${newName}")`);
-                // Skip silently during initialization to avoid log spam and reduce overhead
-                return;
-            }
-        }
-        saveDraftLogger(`Client is initialized, proceeding with save (oldName: "${oldName}", newName: "${newName}")`);
-        // Check for conflicts before saving
-        const conflictCheck = await this._checkForConflicts();
-        if (conflictCheck.hasConflict) {
-            const errorMessage = conflictCheck.message || 'Database was updated externally. Please reload the schema and try again.';
-            saveDraftLogger(`CONFLICT DETECTED: ${errorMessage}`);
-            throw new ConflictError(errorMessage, conflictCheck);
-        }
-        const context = this._getSnapshotContext();
-        const schemaName = newName || context.schemaName || oldName || '';
-        const schemaFileId = context.id || ''; // id is now the schemaFileId (string)
-        // Use schemaFileId as the key if available, otherwise use schemaName
-        const saveKey = schemaFileId || schemaName;
-        // Prevent concurrent saves for the same schema
-        if (Schema.savingSchemas.has(saveKey)) {
-            saveDraftLogger(`Schema ${schemaName} (key: ${saveKey}) is already being saved, skipping concurrent save`);
-            return;
-        }
-        Schema.savingSchemas.add(saveKey);
-        saveDraftLogger(`Starting save for schema ${schemaName} (key: ${saveKey}, schemaFileId: ${schemaFileId})`);
-        try {
-            // Get context - if service is stopped, use the last known context or build from metadata
-            let context;
-            try {
-                context = this._getSnapshotContext();
-            }
-            catch {
-                // Service might be stopped, build context from what we know
-                logger(`Service stopped, building context from available data`);
-                context = {
-                    schemaName: newName || oldName || '',
-                    metadata: {
-                        name: newName || oldName || '',
-                        createdAt: new Date().toISOString(),
-                        updatedAt: new Date().toISOString(),
-                    },
-                    version: 1,
-                    _isDraft: true,
-                    _editedProperties: new Set(),
-                };
-            }
-            const db = BaseDb.getAppDb();
-            if (!db) {
-                throw new Error('Database not found');
-            }
-            // Use provided newName or fall back to context schemaName (avoid getter which might be stale)
-            const finalNewName = newName || context.schemaName || this.schemaName;
-            // CRITICAL: If name changed, we MUST look up by old name to find the existing record
-            // Don't use finalNewName if oldName is provided - that would look up by the new name and not find the old record
-            const lookupName = oldName && oldName !== finalNewName ? oldName : finalNewName;
-            // Try to get existing schema ID from database to preserve it
-            // PRIMARY: Look up by schemaFileId (most reliable, independent of name changes)
-            // FALLBACK: Look up by old name if name changed, otherwise by current name
-            let existingSchemaId;
-            let existingSchemaRecord;
-            // PRIMARY: Look up by schemaFileId if we have it (this is the most reliable way)
-            if (context.id) {
-                logger(`Looking up schema by schemaFileId: ${context.id}`);
-                const schemasById = await db
-                    .select()
-                    .from(schemas)
-                    .where(eq(schemas.schemaFileId, context.id)) // id is now the schemaFileId (string)
-                    .limit(1);
-                if (schemasById.length > 0) {
-                    const foundRecord = schemasById[0];
-                    existingSchemaRecord = foundRecord;
-                    existingSchemaId = foundRecord.schemaFileId || context.id;
-                    logger(`Found schema by schemaFileId: ${context.id} (id: ${foundRecord.id}, name: ${foundRecord.name})`);
-                }
-                else {
-                    logger(`No schema found by schemaFileId: ${context.id}`);
-                }
-            }
-            else {
-                logger(`No id (schemaFileId) in context, will look up by name`);
-            }
-            // FALLBACK: If not found by schemaFileId, try by name (for newly created schemas that don't have schemaFileId yet)
-            if (!existingSchemaRecord) {
-                logger(`Looking up schema by name "${lookupName}" (oldName: ${oldName}, finalNewName: ${finalNewName})`);
-                const existingSchemas = await db
-                    .select()
-                    .from(schemas)
-                    .where(eq(schemas.name, lookupName))
-                    .limit(10); // Get multiple to find drafts
-                logger(`Found ${existingSchemas.length} records with name "${lookupName}"`);
-                // If name changed, prefer draft records; otherwise prefer any record
-                if (existingSchemas.length > 0) {
-                    if (oldName && oldName !== finalNewName) {
-                        // When name changes, prefer draft records
-                        const draftRecord = existingSchemas.find((s) => s.isDraft === true);
-                        const selectedRecord = draftRecord || existingSchemas[0];
-                        existingSchemaRecord = selectedRecord;
-                        logger(`Selected ${draftRecord ? 'draft' : 'first'} record (id: ${selectedRecord.id}, isDraft: ${selectedRecord.isDraft})`);
-                    }
-                    else {
-                        const selectedRecord = existingSchemas[0];
-                        existingSchemaRecord = selectedRecord;
-                        logger(`Selected first record (id: ${selectedRecord.id}, isDraft: ${selectedRecord.isDraft})`);
-                    }
-                    if (existingSchemaRecord?.schemaFileId) {
-                        existingSchemaId = existingSchemaRecord.schemaFileId;
-                    }
-                }
-                else {
-                    logger(`No records found with name "${lookupName}"`);
-                }
-            }
-            if (existingSchemaRecord) {
-                logger(`Using existing record (id: ${existingSchemaRecord.id}, name: ${existingSchemaRecord.name}, isDraft: ${existingSchemaRecord.isDraft}, schemaFileId: ${existingSchemaRecord.schemaFileId || 'none'})`);
-            }
-            else {
-                logger(`No existing record found`);
-            }
-            // Build current schema state from context
-            // Use existing schemaFileId if we found one, otherwise use the one from context, or generate new
-            const schemaFileId = existingSchemaId || context.id || generateId(); // id is now the schemaFileId (string)
-            // Build metadata - if name changed, use newName, otherwise use context metadata
-            // Always ensure metadata.name matches finalNewName to prevent inconsistencies
-            const currentMetadata = context.metadata ? {
-                ...context.metadata,
-                name: finalNewName, // Always use the final name (from newName parameter or context)
-                updatedAt: new Date().toISOString(), // Always update timestamp when saving
-            } : {
-                name: finalNewName,
-                createdAt: new Date().toISOString(),
-                updatedAt: new Date().toISOString(),
-            };
-            // CRITICAL: Ensure schema.id always matches schemaFileId (database is source of truth)
-            // Use existingSchemaRecord.schemaFileId if available, otherwise use the calculated schemaFileId
-            const finalSchemaFileId = existingSchemaRecord?.schemaFileId || schemaFileId;
-            // CRITICAL: Read models from Model instances, not from Schema context
-            // Model instances are the source of truth for model data
-            const modelsFromInstances = await this._buildModelsFromInstances();
-            const currentSchema = {
-                $schema: context.$schema || 'https://seedprotocol.org/schemas/data-model/v1',
-                version: context.version || 1,
-                id: finalSchemaFileId, // Always use schemaFileId from database as source of truth
-                metadata: currentMetadata,
-                models: modelsFromInstances, // Read from Model instances, not context.models
-                enums: context.enums || {},
-                migrations: context.migrations || [],
-                ...(context.nameMatch !== undefined && { nameMatch: context.nameMatch }),
-            };
-            // Log if there was a mismatch that we're fixing
-            if (existingSchemaRecord?.schemaFileId && context.id && context.id !== finalSchemaFileId) {
-                saveDraftLogger(`Fixed schema ID mismatch: context.id="${context.id}" does not match DB schemaFileId="${finalSchemaFileId}". Using DB value.`);
-            }
-            saveDraftLogger(`Building schema with metadata.name="${currentMetadata.name}", finalNewName="${finalNewName}"`);
-            // If name changed, we MUST update the existing record (don't create a new one)
-            if (oldName && oldName !== finalNewName) {
-                if (existingSchemaRecord && existingSchemaRecord.id) {
-                    logger(`Updating existing schema record (id: ${existingSchemaRecord.id}) from "${oldName}" to "${finalNewName}"`);
-                    // Update the existing record with the new name
-                    const schemaDataString = JSON.stringify(currentSchema, null, 2);
-                    saveDraftLogger(`Saving schemaData with metadata.name="${currentSchema.metadata.name}", schemaData length=${schemaDataString.length}`);
-                    // CRITICAL: Ensure schemaFileId column matches schema.id (schema.id is now guaranteed to match finalSchemaFileId)
-                    // Always update schemaFileId to match the id in the schema JSON to maintain consistency
-                    clearNameMatchLevels(); // the stored schema file changes (ADR 0009)
-                    const updateData = {
-                        name: finalNewName,
-                        schemaData: schemaDataString,
-                        schemaFileId: finalSchemaFileId, // Always set to match schema.id
-                        version: currentSchema.version,
-                        updatedAt: new Date(currentSchema.metadata.updatedAt).getTime(),
-                        isDraft: true, // Ensure it's marked as a draft when saving via _saveDraftToDb
-                    };
-                    // Log if we're fixing a mismatch
-                    if (existingSchemaRecord.schemaFileId && existingSchemaRecord.schemaFileId !== finalSchemaFileId) {
-                        saveDraftLogger(`Fixing schemaFileId mismatch: DB had "${existingSchemaRecord.schemaFileId}", schema.id is "${finalSchemaFileId}". Updating DB to match schema.id.`);
-                    }
-                    else if (!existingSchemaRecord.schemaFileId && finalSchemaFileId) {
-                        saveDraftLogger(`Setting schemaFileId to ${finalSchemaFileId} (was null)`);
-                    }
-                    await db
-                        .update(schemas)
-                        .set(updateData)
-                        .where(eq(schemas.id, existingSchemaRecord.id));
-                    // Verify what was saved by reading it back
-                    const verifyRecord = await db
-                        .select()
-                        .from(schemas)
-                        .where(eq(schemas.id, existingSchemaRecord.id))
-                        .limit(1);
-                    if (verifyRecord.length > 0 && verifyRecord[0].schemaData) {
-                        try {
-                            const savedSchema = JSON.parse(verifyRecord[0].schemaData);
-                            saveDraftLogger(`Verified saved schemaData: metadata.name="${savedSchema.metadata?.name}", name column="${verifyRecord[0].name}", isDraft=${verifyRecord[0].isDraft}, schemaFileId="${verifyRecord[0].schemaFileId}"`);
-                            if (verifyRecord[0].isDraft !== true) {
-                                saveDraftLogger(`ERROR: isDraft is not true after save! Expected true, got ${verifyRecord[0].isDraft}. This will cause the schema to load from file instead of database!`);
-                                // Try to fix it immediately
-                                await db
-                                    .update(schemas)
-                                    .set({ isDraft: true })
-                                    .where(eq(schemas.id, existingSchemaRecord.id));
-                                saveDraftLogger(`Attempted to fix isDraft by setting it to true again`);
-                                // Verify the fix
-                                const fixedRecord = await db
-                                    .select()
-                                    .from(schemas)
-                                    .where(eq(schemas.id, existingSchemaRecord.id))
-                                    .limit(1);
-                                if (fixedRecord.length > 0) {
-                                    saveDraftLogger(`After fix attempt: isDraft=${fixedRecord[0].isDraft}`);
-                                }
-                            }
-                        }
-                        catch (error) {
-                            saveDraftLogger(`Error parsing saved schemaData for verification: ${error}`);
-                        }
-                    }
-                    else {
-                        saveDraftLogger(`WARNING: Could not verify saved record - record not found or has no schemaData`);
-                    }
-                    // Update the context's id (schemaFileId) and conflict detection metadata
-                    try {
-                        const snapshot = this._service.getSnapshot();
-                        if (snapshot.status !== 'stopped') {
-                            // Use finalSchemaFileId which matches the schema.id
-                            // Also update conflict detection metadata after successful save
-                            this._service.send({
-                                type: 'updateContext',
-                                id: finalSchemaFileId, // id is now the schemaFileId (string)
-                                _dbUpdatedAt: new Date(currentSchema.metadata.updatedAt).getTime(),
-                                _dbVersion: currentSchema.version,
-                            });
-                        }
-                    }
-                    catch (error) {
-                        // Service might be stopped, ignore
-                        logger(`Could not update id (schemaFileId) in context: ${error instanceof Error ? error.message : String(error)}`);
-                    }
-                    logger(`Successfully updated schema name from "${oldName}" to "${finalNewName}" in database`);
-                    Schema.savingSchemas.delete(saveKey);
-                    return;
-                }
-                else {
-                    // Name changed but we didn't find the existing record - try harder to find it
-                    logger(`WARNING: Name changed from "${oldName}" to "${finalNewName}" but existing record not found. Trying additional lookups...`);
-                    // Try to find by looking for ANY draft with the old name (even if it doesn't match exactly)
-                    const allDrafts = await db
-                        .select()
-                        .from(schemas)
-                        .where(eq(schemas.name, oldName))
-                        .limit(1);
-                    if (allDrafts.length > 0 && allDrafts[0].id) {
-                        const foundRecord = allDrafts[0];
-                        logger(`Found existing record by old name "${oldName}" (id: ${foundRecord.id}), updating to new name "${finalNewName}"`);
-                        // Update the existing record with the new name
-                        // CRITICAL: Ensure schemaFileId matches schema.id
-                        clearNameMatchLevels(); // the stored schema file changes (ADR 0009)
-                        await db
-                            .update(schemas)
-                            .set({
-                            name: finalNewName,
-                            schemaData: JSON.stringify(currentSchema, null, 2),
-                            schemaFileId: finalSchemaFileId, // Always set to match schema.id
-                            version: currentSchema.version,
-                            updatedAt: new Date(currentSchema.metadata.updatedAt).getTime(),
-                            isDraft: true, // Ensure it's marked as a draft when saving via _saveDraftToDb
-                        })
-                            .where(eq(schemas.id, foundRecord.id));
-                        // Update context with id (schemaFileId) and conflict detection metadata
-                        try {
-                            const snapshot = this._service.getSnapshot();
-                            if (snapshot.status !== 'stopped' && finalSchemaFileId) {
-                                this._service.send({
-                                    type: 'updateContext',
-                                    id: finalSchemaFileId, // id is now the schemaFileId (string)
-                                    _dbUpdatedAt: new Date(currentSchema.metadata.updatedAt).getTime(),
-                                    _dbVersion: currentSchema.version,
-                                });
-                            }
-                        }
-                        catch {
-                            // Service might be stopped, ignore
-                        }
-                        logger(`Successfully updated schema name from "${oldName}" to "${finalNewName}" in database (found by old name)`);
-                        Schema.savingSchemas.delete(saveKey);
-                        return;
-                    }
-                    // If we still can't find it, this is an error - don't create a duplicate
-                    logger(`ERROR: Could not find existing schema record with name "${oldName}". Cannot update name to "${finalNewName}" without creating a duplicate.`);
-                    Schema.savingSchemas.delete(saveKey);
-                    throw new Error(`Cannot update schema name: existing schema with name "${oldName}" not found in database`);
-                }
-            }
-            // If name changed, we should have already updated the record above and returned
-            // Only call addSchemaToDb if name didn't change (normal save scenario)
-            if (oldName && oldName !== finalNewName) {
-                // This should never happen - we should have updated above and returned
-                // But if we get here, it means the update path didn't work, so we need to handle it
-                logger(`ERROR: Name changed from "${oldName}" to "${finalNewName}" but update path didn't complete. This should not occur.`);
-                Schema.savingSchemas.delete(saveKey);
-                throw new Error(`Failed to update schema name: existing record not found or update failed`);
-            }
-            // Otherwise, use addSchemaToDb which will handle create/update logic (for normal saves, not name changes)
-            await addSchemaToDb({
-                name: finalNewName,
-                version: currentSchema.version,
-                createdAt: new Date(currentSchema.metadata.createdAt).getTime(),
-                updatedAt: new Date(currentSchema.metadata.updatedAt).getTime(),
-            }, currentSchema.id, // schemaFileId
-            JSON.stringify(currentSchema, null, 2), // schemaData
-            true);
-            // Update conflict detection metadata after successful save
-            try {
-                const snapshot = this._service.getSnapshot();
-                if (snapshot.status !== 'stopped') {
-                    this._service.send({
-                        type: 'updateContext',
-                        _dbUpdatedAt: new Date(currentSchema.metadata.updatedAt).getTime(),
-                        _dbVersion: currentSchema.version,
-                    });
-                }
-            }
-            catch {
-                // Service might be stopped, ignore
-            }
-            saveDraftLogger(`Successfully saved draft schema "${finalNewName}" to database (key: ${saveKey})`);
-            logger(`Saved draft schema ${finalNewName} to database`);
-        }
-        catch (error) {
-            saveDraftLogger(`ERROR: Failed to save draft to database for schema "${schemaName}" (key: ${saveKey}): ${error instanceof Error ? error.message : String(error)}`);
-            logger(`Failed to save draft to database: ${error instanceof Error ? error.message : String(error)}`);
-            throw error;
-        }
-        finally {
-            // Always remove from saving set, even if there was an error
-            Schema.savingSchemas.delete(saveKey);
-            saveDraftLogger(`Removed schema from saving set (key: ${saveKey})`);
-        }
-    }
-    /**
-     * Force-evict the cached Schema instance(s) named `schemaName`, ignoring refCounts: stop their live
-     * query and service. Schema.destroy does the same for itself. For code that deletes a schema's rows
-     * without destroying it (test cleanup): a live Schema keeps re-creating its models from its live
-     * query while their rows are being deleted.
-     */
-    static evict(schemaName) {
-        const instances = new Set();
-        for (const { instance } of Schema.instanceCacheById.values())
-            instances.add(instance);
-        for (const { instance } of Schema.instanceCacheByName.values())
-            instances.add(instance);
-        for (const instance of instances) {
-            let context;
-            try {
-                context = instance._getSnapshotContext();
-            }
-            catch {
-                continue;
-            }
-            if (context.schemaName !== schemaName)
-                continue;
-            clearDestroySubscriptions(instance, {
-                instanceState: schemaInstanceState,
-                onUnload: () => schemaInstanceState.delete(instance),
-            });
-            forceRemoveFromCaches(instance, {
-                getCacheKeys: () => [context.id, context.schemaName].filter((k) => !!k),
-                caches: [
-                    Schema.instanceCacheById,
-                    Schema.instanceCacheByName,
-                ],
-            });
-            try {
-                instance._service.stop();
-            }
-            catch {
-                // Service might already be stopped
-            }
-        }
-    }
-    unload() {
-        try {
-            const context = this._getSnapshotContext();
-            const cacheKeys = [];
-            if (context.id) {
-                cacheKeys.push(context.id);
-            }
-            if (context.schemaName) {
-                cacheKeys.push(context.schemaName);
-            }
-            unloadEntity(this, {
-                getCacheKeys: () => cacheKeys,
-                caches: [Schema.instanceCacheById, Schema.instanceCacheByName],
-                instanceState: schemaInstanceState,
-                getService: (instance) => instance._service,
-                onUnload: () => {
-                    // Clean up WeakMap entry
-                    schemaInstanceState.delete(this);
-                    if (context.schemaName)
-                        Model.releaseSchemaHolds(context.schemaName);
-                },
-            });
-        }
-        catch (error) {
-            // Service might be stopped, can't get context - that's okay
-            logger(`Could not get context during unload: ${error instanceof Error ? error.message : String(error)}`);
-            // Still try to clean up what we can
-            const instanceState = schemaInstanceState.get(this);
-            if (instanceState?.liveQuerySubscription) {
-                instanceState.liveQuerySubscription.unsubscribe();
-                instanceState.liveQuerySubscription = null;
-            }
-            schemaInstanceState.delete(this);
-            try {
-                this._service.stop();
-            }
-            catch {
-                // Service might already be stopped
-            }
-        }
-    }
-    /**
-     * Destroy the schema instance completely: remove from caches, delete from database (cascade),
-     * and stop the service. Uses shared destroy helpers.
-     */
-    async destroy() {
-        const context = this._getSnapshotContext();
-        const schemaFileId = context.id;
-        const schemaName = context.schemaName;
-        clearDestroySubscriptions(this, {
-            instanceState: schemaInstanceState,
-            onUnload: () => schemaInstanceState.delete(this),
-        });
-        const cacheKeys = [];
-        if (schemaFileId)
-            cacheKeys.push(schemaFileId);
-        if (schemaName)
-            cacheKeys.push(schemaName);
-        forceRemoveFromCaches(this, {
-            getCacheKeys: () => cacheKeys,
-            caches: [
-                Schema.instanceCacheById,
-                Schema.instanceCacheByName,
-            ],
-        });
-        // Until its rows are gone, nothing may re-create this schema's models. Its own actor stays live
-        // till then, and its live query reacting to destroyStarted could read a model row the drained
-        // write had just landed and re-create (and re-write) that model after the delete below.
-        if (schemaName)
-            recordSchemaDestroy(schemaName);
-        try {
-            await this._destroyRows(schemaFileId, schemaName, context.metadata?.name);
-        }
-        finally {
-            if (schemaName)
-                finishSchemaDestroy(schemaName);
-        }
-    }
-    async _destroyRows(schemaFileId, schemaName, metadataName) {
-        // The rows for this schema's models and properties are deleted below; evict their cached
-        // instances too, or a re-import would get them back with dangling _dbIds.
-        if (schemaName) {
-            const evictedModelNames = Model.evictForSchema(schemaName);
-            const { ModelProperty } = await import('./ModelProperty-i5flwzQG.js');
-            ModelProperty.evictForModels(evictedModelNames, schemaName);
-            // Evicting stops new writes but not ones already running; let those land before deleting their rows
-            const _mod_10 = await import('./errors-D1zHAqjr.js');
-            const _ns_10 = _mod_10.h;
-            const { waitForInFlightWrites } = _ns_10;
-            await waitForInFlightWrites();
-        }
-        await runDestroyLifecycle(this, {
-            getService: (instance) => instance._service,
-            doDestroy: async () => {
-                const db = BaseDb.getAppDb();
-                if (!db || !schemaFileId)
-                    return;
-                const schemaRecords = await db
-                    .select({ id: schemas.id })
-                    .from(schemas)
-                    .where(eq(schemas.schemaFileId, schemaFileId));
-                if (schemaRecords.length === 0)
-                    return;
-                const schemaIds = schemaRecords
-                    .map((r) => r.id)
-                    .filter((id) => id != null);
-                if (schemaIds.length === 0)
-                    return;
-                const drizzleMod = await import('drizzle-orm');
-                const { inArray } = drizzleMod;
-                const joinRows = await db
-                    .select({ modelId: modelSchemas.modelId })
-                    .from(modelSchemas)
-                    .where(inArray(modelSchemas.schemaId, schemaIds));
-                const modelIds = [
-                    ...new Set(joinRows
-                        .map((r) => r.modelId)
-                        .filter((id) => id != null)),
-                ];
-                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) {
-                    await db.delete(properties).where(eq(properties.modelId, modelId));
-                }
-                for (const modelId of modelIds) {
-                    await db.delete(models).where(eq(models.id, modelId));
-                }
-                await db.delete(schemas).where(eq(schemas.schemaFileId, schemaFileId));
-                // Delete the SDK's own copies of this schema's files (all versions) in the working dir.
-                // loadAllSchemasFromDb imports any schema file without a DB row, so leaving them brought
-                // 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_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));
-                for (const file of files) {
-                    if (file.schemaFileId === schemaFileId || names.has(file.name)) {
-                        await fs.promises.unlink(file.filePath).catch(() => { });
-                    }
-                }
-            },
-        });
-    }
-    /**
-     * Set up liveQuery subscription to watch for model changes in the database
-     * This enables cross-instance synchronization (e.g., changes in other tabs/windows)
-     */
-    _setupLiveQuerySubscription() {
-        // Only set up in browser environment where liveQuery is available
-        if (typeof window === 'undefined') {
-            return;
-        }
-        setupEntityLiveQuery(this, {
-            getEntityId: async (schema) => {
-                const db = BaseDb.getAppDb();
-                if (!db) {
-                    return undefined;
-                }
-                const context = schema._getSnapshotContext();
-                const schemaName = context.metadata?.name;
-                if (!schemaName) {
-                    return undefined;
-                }
-                const schemaRecords = await db
-                    .select()
-                    .from(schemas)
-                    .where(eq(schemas.name, schemaName))
-                    .limit(1);
-                if (schemaRecords.length === 0 || !schemaRecords[0].id) {
-                    return undefined;
-                }
-                return schemaRecords[0].id;
-            },
-            buildQuery: async (schemaId) => {
-                const db = BaseDb.getAppDb();
-                if (!db) {
-                    throw new Error('Database not available');
-                }
-                return BaseDb.liveQuery(db
-                    .select({
-                    modelId: modelSchemas.modelId,
-                    modelName: models.name,
-                    modelFileId: models.schemaFileId,
-                })
-                    .from(modelSchemas)
-                    .innerJoin(models, eq(modelSchemas.modelId, models.id))
-                    .where(eq(modelSchemas.schemaId, typeof schemaId === 'string' ? parseInt(schemaId, 10) : schemaId)));
-            },
-            extractEntityIds: (rows) => rows.map(row => row.modelFileId).filter(Boolean),
-            updateContext: (schema, ids) => {
-                // Helper function to send updateContext event with model IDs
-                const sendUpdateContext = () => {
-                    // Double-check instance state still exists
-                    const verifyInstanceState = schemaInstanceState.get(schema);
-                    if (!verifyInstanceState) {
-                        logger(`[Schema._setupLiveQuerySubscription] Instance state cleaned up before sending updateContext`);
-                        return;
-                    }
-                    try {
-                        const snapshot = schema._service.getSnapshot();
-                        if (snapshot.status === 'stopped') {
-                            logger(`[Schema._setupLiveQuerySubscription] Service stopped before sending, skipping`);
-                            return;
-                        }
-                        // Send updateContext with liveQueryModelIds in service context for reactive updates
-                        schema._service.send({
-                            type: 'updateContext',
-                            _liveQueryModelIds: ids, // Store in service context for reactivity
-                            _modelsUpdated: Date.now(), // Internal field for tracking
-                        });
-                        logger(`[Schema._setupLiveQuerySubscription] Sent updateContext event with ${ids.length} model IDs`);
-                    }
-                    catch (error) {
-                        logger(`[Schema._setupLiveQuerySubscription] Error sending updateContext: ${error}`);
-                    }
-                };
-                // Check if service is stopped before sending events
-                const snapshot = schema._service.getSnapshot();
-                const isServiceStopped = snapshot.status === 'stopped';
-                if (isServiceStopped) {
-                    logger(`[Schema._setupLiveQuerySubscription] Service is stopped, restarting before sending updateContext`);
-                    // Restart the service first
-                    schema._service.start();
-                    // Wait for service to be ready (idle state) before sending event
-                    setTimeout(() => {
-                        const delayedInstanceState = schemaInstanceState.get(schema);
-                        if (!delayedInstanceState) {
-                            logger(`[Schema._setupLiveQuerySubscription] Instance state cleaned up during restart delay`);
-                            return;
-                        }
-                        const newSnapshot = schema._service.getSnapshot();
-                        if (newSnapshot.status !== 'stopped') {
-                            sendUpdateContext();
-                        }
-                        else {
-                            logger(`[Schema._setupLiveQuerySubscription] Service still stopped after restart attempt`);
-                        }
-                    }, 10);
-                }
-                else {
-                    // Service is running, send immediately
-                    sendUpdateContext();
-                }
-            },
-            createChildInstances: async (ids) => {
-                // One at a time: an eviction of this schema part way through stops the rest
-                const evictionEpoch = currentEvictionEpoch();
-                for (const id of ids) {
-                    await Model.createById(id, { evictionEpoch, hold: false });
-                }
-            },
-            queryInitialData: async (schemaId) => {
-                const db = BaseDb.getAppDb();
-                if (!db) {
-                    return [];
-                }
-                // Retry logic for initial query
-                const queryInitialModels = async (retries = 3) => {
-                    try {
-                        const initialModels = await db
-                            .select({
-                            modelId: modelSchemas.modelId,
-                            modelName: models.name,
-                            modelFileId: models.schemaFileId,
-                        })
-                            .from(modelSchemas)
-                            .innerJoin(models, eq(modelSchemas.modelId, models.id))
-                            .where(eq(modelSchemas.schemaId, typeof schemaId === 'string' ? parseInt(schemaId, 10) : schemaId));
-                        logger(`[Schema._setupLiveQuerySubscription] Initial query found ${initialModels.length} models`);
-                        if (initialModels.length > 0) {
-                            return initialModels.map((row) => ({
-                                modelId: row.modelId,
-                                modelName: row.modelName,
-                                modelFileId: row.modelFileId || '',
-                            }));
-                        }
-                        else if (retries > 0) {
-                            logger(`[Schema._setupLiveQuerySubscription] No models found, retrying... (${retries} retries left)`);
-                            await new Promise(resolve => setTimeout(resolve, 100));
-                            return queryInitialModels(retries - 1);
-                        }
-                        else {
-                            logger(`[Schema._setupLiveQuerySubscription] No models found in initial query after retries`);
-                            return [];
-                        }
-                    }
-                    catch (error) {
-                        if (retries > 0) {
-                            logger(`[Schema._setupLiveQuerySubscription] Error querying initial models, retrying... (${retries} retries left): ${error}`);
-                            await new Promise(resolve => setTimeout(resolve, 100));
-                            return queryInitialModels(retries - 1);
-                        }
-                        else {
-                            logger(`[Schema._setupLiveQuerySubscription] Error querying initial models after retries: ${error}`);
-                            return [];
-                        }
-                    }
-                };
-                return queryInitialModels();
-            },
-            instanceState: schemaInstanceState,
-            loggerName: 'seedSdk:schema:liveQuery',
-            isReady: (schema) => {
-                const snapshot = schema._service.getSnapshot();
-                return snapshot.value === 'idle' && !!snapshot.context.metadata?.name;
-            },
-        });
-    }
-}
-// Cache by schemaFileId (primary key - doesn't change when name changes)
-Schema.instanceCacheById = new Map();
-// Temporary cache by schemaName (used until schemaFileId is available)
-Schema.instanceCacheByName = new Map();
-// Deduplicate concurrent Schema.create(schemaName) calls - prevents many parallel loads for same schema
-Schema.pendingSchemaByName = new Map();
-// Track which schemas are currently being saved to prevent concurrent saves
-Schema.savingSchemas = new Set();
-
-var Schema$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    Schema: Schema,
-    schemaInstanceState: schemaInstanceState
-});
-
-export { Schema as S, Schema$1 as a, renameModelProperty as r, schemaMachine as s, updateModelProperties as u };
-//# sourceMappingURL=Schema-PFZwG9Nl.js.map