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

package/dist/errors-D1zHAqjr.js

@@ -1,4006 +0,0 @@
-import { fromCallback, fromPromise, setup, assign, createActor } from 'xstate';
-import { L as BaseDb, p as models, E as properties, ad as generateId, aF as isInternalSchema, aG as writeModelToDb, aH as writePropertyToDb, z as modelSchemas, J as schemas, A as AmbiguousModelError, aI as renameModelInDb, aJ as currentNameMatchLevels, a as TProperty } from './index-Dx_GTdyQ.js';
-import { eq, and, isNull, or } from 'drizzle-orm';
-import debug from 'debug';
-import { L as isActorStopped, aj as ActorKeyedState, B as waitForEntityIdle, N as DEFAULT_READY_TIMEOUT_MS, P as createReactiveProxy, R as findEntity, W as ClientManagerState, I as Item, ak as clearDestroySubscriptions, S as forceRemoveFromCaches, al as unloadEntity, T as runDestroyLifecycle } from './Item-0oDoTPhi.js';
-import { v as getClient } from './ClientManager-GZfXErDX.js';
-import { modelPropertiesToObject } from './model-oHA3YhOd.js';
-import { localNamesInBestMatchTier } from '@seedprotocol/eas';
-import { Type } from '@sinclair/typebox';
-
-const logger$7 = debug('seedSdk:model:actors:loadOrCreateModel');
-/**
- * Create ModelProperty instances for all property IDs to ensure they're cached
- * This ensures that ModelProperty.getById() in Model.properties getter will find the instances
- * @param propertyFileIds - Array of property file IDs to create instances for
- */
-const createPropertyInstances = async (propertyFileIds) => {
-    if (propertyFileIds.length === 0) {
-        return;
-    }
-    try {
-        const mod = await import('./ModelProperty-i5flwzQG.js');
-        const ModelProperty = mod?.ModelProperty ?? mod?.default;
-        if (!ModelProperty) {
-            logger$7('createPropertyInstances: ModelProperty not available from dynamic import');
-            return;
-        }
-        // Create instances for all property IDs in parallel
-        // ModelProperty.createById() will check cache first, then query DB and create if needed
-        const createPromises = propertyFileIds.map(async (propertyFileId) => {
-            try {
-                const property = await ModelProperty.createById(propertyFileId);
-                if (property) {
-                    logger$7(`Created/cached ModelProperty instance for propertyFileId "${propertyFileId}"`);
-                }
-                else {
-                    logger$7(`ModelProperty.createById returned undefined for propertyFileId "${propertyFileId}" (may not exist in DB yet)`);
-                }
-            }
-            catch (error) {
-                logger$7(`Error creating ModelProperty instance for propertyFileId "${propertyFileId}": ${error}`);
-                // Don't throw - continue with other properties
-            }
-        });
-        await Promise.all(createPromises);
-        logger$7(`Finished creating/caching ${propertyFileIds.length} ModelProperty instances`);
-    }
-    catch (error) {
-        logger$7(`Error in createPropertyInstances: ${error}`);
-        // Don't throw - this is best-effort to pre-populate cache
-    }
-};
-const loadOrCreateModel = fromCallback(({ sendBack, input: { context }, self }) => {
-    const _loadOrCreateModel = async () => {
-        const { modelName, schemaName, id, _idFromSchema } = context; // id is now the schemaFileId (string)
-        if (!modelName || !schemaName) {
-            throw new Error('Model name and schema name are required');
-        }
-        // CRITICAL: Model instances load their data from database, not from Schema context.
-        // Schema is read-only with respect to Model instances.
-        const db = BaseDb.getAppDb();
-        let schemaFileId = id; // id is now the schemaFileId (string)
-        let modelRecord = null;
-        let foundBySchemaFileId = false; // Track if model was found by schemaFileId
-        let existingNumbersFromSchemaContext = null; // When we fall through (same name, different id), schema model occupies base name
-        // Step 1: Load from database FIRST (primary source of truth)
-        if (db) {
-            try {
-                // Try to find model by schemaFileId if provided
-                if (schemaFileId) {
-                    const dbModels = await db
-                        .select()
-                        .from(models)
-                        .where(eq(models.schemaFileId, schemaFileId))
-                        .limit(1);
-                    if (dbModels.length > 0) {
-                        modelRecord = dbModels[0];
-                        foundBySchemaFileId = true;
-                        logger$7(`Found model "${modelName}" in database by schemaFileId "${schemaFileId}"`);
-                    }
-                }
-                // If not found by ID, try by name
-                // But if we have a schemaFileId and the model found by name has a different schemaFileId,
-                // don't use it - we're creating a new model from a schema file with a specific ID
-                if (!modelRecord) {
-                    // Model names are only unique per schema: prefer this schema's row, and otherwise only
-                    // consider same-name rows that no schema claims yet (never another schema's model).
-                    const _mod_0 = await import('./index-Dx_GTdyQ.js');
-                    const _ns_0 = _mod_0.bd;
-                    const { modelSchemas } = _ns_0;
-                    const _mod_1 = await import('./index-Dx_GTdyQ.js');
-                    const _ns_1 = _mod_1.bc;
-                    const { schemas: schemasTable } = _ns_1;
-                    let dbModels = await db
-                        .select({
-                        id: models.id,
-                        name: models.name,
-                        schemaFileId: models.schemaFileId,
-                        isEdited: models.isEdited,
-                    })
-                        .from(models)
-                        .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
-                        .innerJoin(schemasTable, eq(modelSchemas.schemaId, schemasTable.id))
-                        .where(and(eq(models.name, modelName), eq(schemasTable.name, schemaName)))
-                        .limit(1);
-                    if (dbModels.length === 0) {
-                        dbModels = await db
-                            .select({
-                            id: models.id,
-                            name: models.name,
-                            schemaFileId: models.schemaFileId,
-                            isEdited: models.isEdited,
-                        })
-                            .from(models)
-                            .leftJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
-                            // Stubs only: an unlinked row with a schemaFileId is a deleted schema's leftover, not ours
-                            .where(and(eq(models.name, modelName), isNull(modelSchemas.id), isNull(models.schemaFileId)))
-                            .limit(1);
-                    }
-                    if (dbModels.length > 0) {
-                        const foundModel = dbModels[0];
-                        const dbSchemaFileId = foundModel.schemaFileId;
-                        // CRITICAL: If we found a model in the database by name, check if there's already a cached instance
-                        // with that schemaFileId. If so, we should use that instance's schemaFileId for the current instance.
-                        // This handles the case where Model.create was called with a generated ID, but the model
-                        // already exists in the database with a different ID. By updating the current instance's
-                        // schemaFileId to match the database, both will point to the same cached instance.
-                        // Skip for schema models (_idFromSchema): their id is authoritative, and a same-name row
-                        // with a different id belongs to another schema (e.g. two schemas that each define "Post").
-                        if (dbSchemaFileId && !(_idFromSchema && schemaFileId && schemaFileId !== dbSchemaFileId)) {
-                            try {
-                                const modelMod = await Promise.resolve().then(function () { return Model$1; });
-                                const { Model } = modelMod;
-                                // Access instanceCacheById via type assertion since it's protected
-                                const cacheById = Model.instanceCacheById;
-                                if (cacheById.has(dbSchemaFileId)) {
-                                    logger$7(`Model "${modelName}" found in database by name with schemaFileId "${dbSchemaFileId}", and a cached instance already exists. Updating current instance to use the same schemaFileId.`);
-                                    // Update the current instance's schemaFileId to match the database
-                                    // This ensures both instances point to the same cached instance
-                                    modelRecord = foundModel;
-                                    schemaFileId = dbSchemaFileId;
-                                    logger$7(`Using existing cached instance with schemaFileId "${schemaFileId}" for model "${modelName}"`);
-                                }
-                            }
-                            catch (error) {
-                                logger$7(`Error checking Model cache for schemaFileId "${dbSchemaFileId}": ${error}`);
-                                // Fall through to normal processing
-                            }
-                        }
-                        // If we have a schemaFileId and it doesn't match the found model's schemaFileId,
-                        // this is a new model - don't use the existing model (will be renamed if duplicate)
-                        // UNLESS we found a cached instance above (in which case modelRecord is already set)
-                        if (!modelRecord && schemaFileId && dbSchemaFileId && schemaFileId !== dbSchemaFileId) {
-                            logger$7(`Model "${modelName}" found by name but has different schemaFileId (provided: "${schemaFileId}", db: "${dbSchemaFileId}"). Creating new model (will check for duplicates).`);
-                            // Don't set modelRecord - we'll create a new model with potentially renamed name
-                        }
-                        else if (!modelRecord && schemaFileId && !dbSchemaFileId) {
-                            // We have a schemaFileId but the found model doesn't have one - this is a new model
-                            // Don't reuse the existing model, create a new one (will be renamed if duplicate)
-                            logger$7(`Model "${modelName}" found by name but found model has no schemaFileId. Creating new model with schemaFileId "${schemaFileId}" (will check for duplicates).`);
-                            // Don't set modelRecord - we'll create a new model
-                        }
-                        else if (!modelRecord) {
-                            // Only reuse existing model if:
-                            // 1. No schemaFileId was provided (loading existing model), OR
-                            // 2. schemaFileId matches (same model)
-                            logger$7(`Model "${modelName}" found by name, reusing existing model (schemaFileId: provided="${schemaFileId}", db="${dbSchemaFileId}")`);
-                            modelRecord = foundModel;
-                            // Only use database schemaFileId if no id was explicitly provided
-                            // If an id was provided, we should use it (it might be creating a new model with a specific ID)
-                            if (!id && dbSchemaFileId) {
-                                schemaFileId = dbSchemaFileId;
-                                logger$7(`Using database schemaFileId "${schemaFileId}" for model "${modelName}" (no ID was provided)`);
-                            }
-                            else if (id) {
-                                logger$7(`Preserving provided id (schemaFileId) "${schemaFileId}" for model "${modelName}" (ignoring database schemaFileId "${dbSchemaFileId}")`);
-                            }
-                            logger$7(`Found model "${modelName}" in database by name, schemaFileId: "${schemaFileId}"`);
-                        }
-                    }
-                }
-                // If we found the model record, load its properties from database
-                if (modelRecord && modelRecord.id) {
-                    const propertyRecords = await db
-                        .select()
-                        .from(properties)
-                        .where(eq(properties.modelId, modelRecord.id));
-                    // Properties are now loaded via liveQuery, not passed through context
-                    // The property records are used by liveQuery to populate ModelProperty instances
-                    // Pre-create ModelProperty instances for all property IDs to ensure they're cached
-                    // This ensures that ModelProperty.getById() in Model.properties getter will find the instances
-                    const propertyFileIds = propertyRecords
-                        .map((record) => record.schemaFileId)
-                        .filter((id) => id !== null && id !== undefined);
-                    if (propertyFileIds.length > 0) {
-                        // Not for a model stopped meanwhile (unloaded, or evicted with its schema)
-                        if (!isActorStopped(self))
-                            await createPropertyInstances(propertyFileIds);
-                    }
-                    // Generate schemaFileId if not set
-                    if (!schemaFileId) {
-                        schemaFileId = generateId();
-                        logger$7(`Generated id (schemaFileId) "${schemaFileId}" for model "${modelName}"`);
-                    }
-                    // Include _dbId from database record so properties can be created if needed
-                    // Even if we found an existing model, we may still need to create properties
-                    // if _pendingPropertyDefinitions are provided
-                    // Track conflict detection metadata
-                    const loadedAt = Date.now();
-                    // Note: models table doesn't have updatedAt or version, so we use loadedAt for _dbUpdatedAt
-                    // In the future, if models table gets these fields, we should use them
-                    const dbUpdatedAt = loadedAt;
-                    // CRITICAL: Include _liveQueryPropertyIds in loadOrCreateModelSuccess event
-                    // This ensures the properties getter works immediately, even before _setupLiveQuerySubscription runs
-                    // We already have the property IDs from the database query, so include them now
-                    sendBack({
-                        type: 'loadOrCreateModelSuccess',
-                        model: {
-                            id: schemaFileId, // schemaFileId (string) - public ID
-                            _dbId: modelRecord.id, // Database integer ID - internal only
-                            _liveQueryPropertyIds: propertyFileIds, // Property IDs from database query
-                            _propertiesUpdated: Date.now(), // Timestamp for tracking
-                            _isEdited: modelRecord.isEdited ?? false, // Load isEdited from database
-                            _loadedAt: loadedAt,
-                            _dbUpdatedAt: dbUpdatedAt,
-                        },
-                    });
-                    return;
-                }
-            }
-            catch (error) {
-                logger$7(`Error loading model from database: ${error}`);
-                // Fall through to create new model
-            }
-        }
-        // Step 2: Fallback to Schema context (only if database doesn't have the model)
-        // This handles the case where model exists in schema file but not yet in database
-        try {
-            const _mod_2 = await import('./Schema-PFZwG9Nl.js');
-            const _ns_2 = _mod_2.a;
-            const schemaMod = _ns_2;
-            const { Schema } = schemaMod;
-            // Stopped meanwhile (unloaded, or evicted with its schema): don't load the schema again
-            if (isActorStopped(self))
-                return;
-            const schema = Schema.create(schemaName, { waitForReady: false, hold: false });
-            const schemaSnapshot = schema.getService().getSnapshot();
-            // Wait for schema to load if it's still loading
-            // Check if state is a loading state object (XState v5 nested states)
-            const isLoading = typeof schemaSnapshot.value === 'object' && 'loading' in schemaSnapshot.value;
-            if (isLoading) {
-                await new Promise((resolve, reject) => {
-                    const subscription = schema.getService().subscribe((snapshot) => {
-                        if (snapshot.value === 'idle' || snapshot.value === 'error') {
-                            subscription.unsubscribe();
-                            if (snapshot.value === 'error') {
-                                reject(new Error('Schema failed to load'));
-                            }
-                            else {
-                                resolve();
-                            }
-                        }
-                    });
-                });
-            }
-            const schemaContext = schema.getService().getSnapshot().context;
-            // Check by name first; also check by schemaFileId so we recognize the schema model even when context is keyed differently or not yet updated
-            if (schemaContext.models) {
-                const byName = schemaContext.models[modelName];
-                const schemaModelId = byName?.id ?? null;
-                if (schemaFileId === schemaModelId) {
-                    logger$7(`Found model "${modelName}" in Schema context (database fallback)`);
-                    if (!schemaFileId) {
-                        schemaFileId = generateId();
-                        logger$7(`Generated id (schemaFileId) "${schemaFileId}" for model "${modelName}"`);
-                    }
-                    sendBack({
-                        type: 'loadOrCreateModelSuccess',
-                        model: { id: schemaFileId },
-                    });
-                    return;
-                }
-                // Same name but different id: runtime create colliding with schema model name; fall through
-                if (byName) {
-                    existingNumbersFromSchemaContext = new Set([0]);
-                }
-                else if (schemaFileId) {
-                    // Schema context may not have model by name yet (e.g. still loading). If our id appears in any schema model, we're the schema model.
-                    for (const def of Object.values(schemaContext.models)) {
-                        if (def?.id === schemaFileId) {
-                            logger$7(`Found model in Schema context by id "${schemaFileId}" (database fallback)`);
-                            sendBack({
-                                type: 'loadOrCreateModelSuccess',
-                                model: { id: schemaFileId },
-                            });
-                            return;
-                        }
-                    }
-                }
-            }
-        }
-        catch (error) {
-            logger$7(`Error loading model from Schema context: ${error}`);
-            // Fall through to create new model
-        }
-        // Step 3: Check for duplicate names in database before creating new model
-        // Skip duplicate check only if we found a model record to use (modelRecord is set)
-        // OR if the model was found by schemaFileId (preserving original name from schema file)
-        // OR if this is an internal schema (Seed Protocol) - internal schemas should preserve original names
-        // Otherwise, check for duplicates when creating a new model
-        // NOTE: We should NOT skip duplicate check just because schemaFileId exists - that could be a newly generated ID
-        // for a new model that needs to be renamed if it's a duplicate
-        let finalModelName = modelName;
-        if (db) {
-            // Check if this is an internal schema (Seed Protocol)
-            const isInternal = isInternalSchema(schemaName);
-            // Only skip duplicate check if:
-            // 1. We found a model record to use (modelRecord is set), OR
-            // 2. The model was found by schemaFileId (preserving original name from schema file), OR
-            // 3. This is an internal schema (internal schemas should preserve original names from schema files), OR
-            // 4. This instance was created with modelFileId from schema (_idFromSchema) - schema models keep their name
-            const shouldSkipDuplicateCheck = modelRecord !== null || foundBySchemaFileId || isInternal || !!_idFromSchema;
-            logger$7(`Duplicate check: modelRecord=${modelRecord !== null}, foundBySchemaFileId=${foundBySchemaFileId}, isInternal=${isInternal}, _idFromSchema=${!!_idFromSchema}, schemaFileId=${schemaFileId}, shouldSkip=${shouldSkipDuplicateCheck}`);
-            if (!shouldSkipDuplicateCheck) {
-                try {
-                    const lowerModelName = modelName.toLowerCase();
-                    const existingNumbers = new Set(existingNumbersFromSchemaContext ?? []);
-                    // First, check Model cache for models (includes models from imported schemas that may not be in DB yet)
-                    try {
-                        const modelMod = await Promise.resolve().then(function () { return Model$1; });
-                        const { Model } = modelMod;
-                        // Check name-based cache for this schema
-                        // Skip the current model (context.id): Model.create() adds the new instance to the cache
-                        // before this callback runs, so we must not count it as a duplicate.
-                        logger$7(`Checking Model cache for duplicates in schema "${schemaName}"`);
-                        const currentModelFileId = schemaFileId ?? null;
-                        const cacheByName = Model.instanceCacheByName;
-                        for (const [nameKey, cachedModelFileId] of cacheByName.entries()) {
-                            if (currentModelFileId && cachedModelFileId === currentModelFileId)
-                                continue; // skip self
-                            const [cachedSchemaName, cachedModelName] = nameKey.split(':', 2);
-                            if (cachedSchemaName === schemaName && cachedModelName) {
-                                const lowerCachedName = cachedModelName.toLowerCase();
-                                if (lowerCachedName === lowerModelName) {
-                                    existingNumbers.add(0); // Base name exists
-                                    logger$7(`Found duplicate in Model cache: "${cachedModelName}" matches "${modelName}"`);
-                                }
-                                else if (lowerCachedName.startsWith(lowerModelName + ' ')) {
-                                    // Check if it's the base name followed by a space and a number
-                                    const suffix = lowerCachedName.slice(lowerModelName.length + 1);
-                                    const number = parseInt(suffix, 10);
-                                    if (!isNaN(number) && suffix === number.toString()) {
-                                        existingNumbers.add(number);
-                                        logger$7(`Found numbered variant in Model cache: "${cachedModelName}" (number: ${number})`);
-                                    }
-                                }
-                            }
-                        }
-                        // Also check legacy cache (skip current model by id)
-                        const legacyCache = Model.instanceCache;
-                        for (const [nameKey, entry] of legacyCache?.entries() || []) {
-                            const legacyId = entry?.instance?._getSnapshotContext?.()?.id;
-                            if (currentModelFileId && legacyId === currentModelFileId)
-                                continue; // skip self
-                            const [cachedSchemaName, cachedModelName] = nameKey.split(':', 2);
-                            if (cachedSchemaName === schemaName && cachedModelName) {
-                                const lowerCachedName = cachedModelName.toLowerCase();
-                                if (lowerCachedName === lowerModelName) {
-                                    existingNumbers.add(0); // Base name exists
-                                    logger$7(`Found duplicate in Model legacy cache: "${cachedModelName}" matches "${modelName}"`);
-                                }
-                                else if (lowerCachedName.startsWith(lowerModelName + ' ')) {
-                                    // Check if it's the base name followed by a space and a number
-                                    const suffix = lowerCachedName.slice(lowerModelName.length + 1);
-                                    const number = parseInt(suffix, 10);
-                                    if (!isNaN(number) && suffix === number.toString()) {
-                                        existingNumbers.add(number);
-                                        logger$7(`Found numbered variant in Model legacy cache: "${cachedModelName}" (number: ${number})`);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    catch (error) {
-                        logger$7(`Error checking Model cache for duplicates: ${error}`);
-                        // Continue with database check
-                    }
-                    // Also check database for models (in case they're persisted but not in Schema context)
-                    if (db) {
-                        const _mod_3 = await import('./index-Dx_GTdyQ.js');
-                        const _ns_3 = _mod_3.bd;
-                        const modelSchemaSchemaMod = _ns_3;
-                        const { modelSchemas } = modelSchemaSchemaMod;
-                        const _mod_4 = await import('./index-Dx_GTdyQ.js');
-                        const _ns_4 = _mod_4.bc;
-                        const schemaSchemaMod = _ns_4;
-                        const { schemas: schemasTable } = schemaSchemaMod;
-                        // Query all models for this schema to check for duplicates (case-insensitive)
-                        logger$7(`Checking database for duplicate model names in schema "${schemaName}"`);
-                        const allModelsForSchema = await db
-                            .select({
-                            name: models.name,
-                        })
-                            .from(models)
-                            .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
-                            .innerJoin(schemasTable, eq(modelSchemas.schemaId, schemasTable.id))
-                            .where(eq(schemasTable.name, schemaName));
-                        logger$7(`Found ${allModelsForSchema.length} models in database for schema "${schemaName}": ${allModelsForSchema.map((m) => m.name).join(', ')}`);
-                        if (allModelsForSchema.length === 0 && modelName.includes('Shared')) {
-                            logger$7(`[DEBUG] No models found in database for schema "${schemaName}" when checking for duplicate "${modelName}"`);
-                        }
-                        // Check for exact match (case-insensitive) or matches with number suffix
-                        for (const dbModel of allModelsForSchema) {
-                            const lowerDbName = dbModel.name.toLowerCase();
-                            if (lowerDbName === lowerModelName) {
-                                existingNumbers.add(0); // Base name exists
-                                logger$7(`Found duplicate in database: "${dbModel.name}" matches "${modelName}"`);
-                            }
-                            else if (lowerDbName.startsWith(lowerModelName + ' ')) {
-                                // Check if it's the base name followed by a space and a number
-                                const suffix = lowerDbName.slice(lowerModelName.length + 1);
-                                const number = parseInt(suffix, 10);
-                                if (!isNaN(number) && suffix === number.toString()) {
-                                    existingNumbers.add(number);
-                                    logger$7(`Found numbered variant in database: "${dbModel.name}" (number: ${number})`);
-                                }
-                            }
-                        }
-                    }
-                    // If duplicates found, generate unique name
-                    logger$7(`Duplicate check results: existingNumbers=${Array.from(existingNumbers).join(', ')}, hasBaseName=${existingNumbers.has(0)}`);
-                    if (existingNumbers.has(0)) {
-                        let nextNumber = 1;
-                        while (existingNumbers.has(nextNumber)) {
-                            nextNumber++;
-                        }
-                        finalModelName = `${modelName} ${nextNumber}`;
-                        logger$7(`Found duplicate model name "${modelName}" in schema "${schemaName}", using unique name "${finalModelName}"`);
-                    }
-                    else {
-                        logger$7(`No duplicate found for model name "${modelName}" in schema "${schemaName}"`);
-                    }
-                }
-                catch (error) {
-                    logger$7(`Error checking for duplicate model names: ${error}`);
-                    // Continue with original name if check fails
-                }
-            }
-            else {
-                if (foundBySchemaFileId) {
-                    logger$7(`Preserving original model name "${modelName}" for model found by schemaFileId (schemaFileId: ${schemaFileId})`);
-                }
-                else if (modelRecord) {
-                    logger$7(`Using existing model name "${modelName}" from database (modelRecord found)`);
-                }
-                else if (isInternal) {
-                    logger$7(`Preserving original model name "${modelName}" for internal schema "${schemaName}" (skipping duplicate check)`);
-                }
-            }
-        }
-        // Step 4: Create new empty model (not found in database or Schema context)
-        logger$7(`Creating new model "${finalModelName}" in schema "${schemaName}"`);
-        // Generate schemaFileId for new model
-        if (!schemaFileId) {
-            schemaFileId = generateId();
-            logger$7(`Generated id (schemaFileId) "${schemaFileId}" for new model "${finalModelName}"`);
-        }
-        // Runtime creates use a placeholder cache key in Model.create; move it to the final name. Skip when schema model (_idFromSchema).
-        if (!_idFromSchema) {
-            const modelMod = await Promise.resolve().then(function () { return Model$1; });
-            const { Model } = modelMod;
-            Model.updateNameIndex('__pending__' + schemaFileId, finalModelName, schemaName, schemaFileId);
-        }
-        // If model name was changed, store it in a temporary internal field so loadOrCreateModelSuccess can apply it
-        // This avoids the issue where updateContext with modelName triggers validation and state transition
-        // We use _pendingModelName (internal field) which won't trigger validation
-        if (finalModelName !== modelName) {
-            logger$7(`Model name changed from "${modelName}" to "${finalModelName}", storing in _pendingModelName for loadOrCreateModelSuccess`);
-            // Store the final name in a temporary internal field that will be picked up by loadOrCreateModelSuccess
-            sendBack({
-                type: 'updateContext',
-                _pendingModelName: finalModelName,
-            });
-        }
-        else {
-            logger$7(`Model name unchanged: "${modelName}"`);
-        }
-        // Mark schema as draft when a new model is created so saveNewVersion() can persist it
-        try {
-            const _mod_5 = await import('./Schema-PFZwG9Nl.js');
-            const _ns_5 = _mod_5.a;
-            const schemaMod = _ns_5;
-            const { Schema } = schemaMod;
-            if (!isActorStopped(self)) {
-                const schema = Schema.create(schemaName, { waitForReady: false, hold: false });
-                schema.getService().send({ type: 'markAsDraft', propertyKey: 'schema:models' });
-            }
-        }
-        catch (err) {
-            logger$7(`Failed to mark schema as draft after creating model: ${err}`);
-        }
-        sendBack({
-            type: 'loadOrCreateModelSuccess',
-            model: {
-                id: schemaFileId, // schemaFileId (string) - public ID
-            },
-        });
-    };
-    _loadOrCreateModel().catch((error) => {
-        logger$7('Error loading or creating model:', error);
-        sendBack({ type: 'loadOrCreateModelError', error });
-    });
-});
-
-const logger$6 = debug('seedSdk:model:actors:validateModel');
-// Validation timeout in milliseconds (10 seconds)
-const VALIDATION_TIMEOUT_MS = 10000;
-const validateModel = fromCallback(({ sendBack, input: { context }, self }) => {
-    let hasResponded = false;
-    // Timeout handler to ensure we always respond
-    const timeoutId = setTimeout(() => {
-        if (!hasResponded) {
-            hasResponded = true;
-            sendBack({
-                type: 'validationError',
-                errors: [{
-                        field: 'model',
-                        message: `Model validation timed out after ${VALIDATION_TIMEOUT_MS}ms`,
-                        code: 'validation_timeout',
-                        severity: 'error',
-                    }],
-            });
-        }
-    }, VALIDATION_TIMEOUT_MS);
-    const _validateModel = async () => {
-        try {
-            // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await import('./SchemaValidationService-DnGKel4V.js');
-            const { SchemaValidationService } = validationServiceMod;
-            const validationService = new SchemaValidationService();
-            const _mod_6 = await import('./Schema-PFZwG9Nl.js');
-            const _ns_6 = _mod_6.a;
-            const schemaMod = _ns_6;
-            const { Schema } = schemaMod;
-            // Validate model structure
-            const structureResult = validationService.validateModelStructure(context);
-            if (!structureResult.isValid) {
-                if (!hasResponded) {
-                    hasResponded = true;
-                    clearTimeout(timeoutId);
-                    sendBack({ type: 'validationError', errors: structureResult.errors });
-                }
-                return;
-            }
-            // If we have schema name, validate against schema
-            // CRITICAL: Use validateModelAgainstSchema which doesn't require the model to be in schema context
-            // This allows validation BEFORE registration, preventing update loops
-            // Stopped meanwhile (unloaded, or evicted with its schema): don't load the schema again
-            if (isActorStopped(self))
-                return;
-            if (context.schemaName) {
-                try {
-                    const schema = Schema.create(context.schemaName, { waitForReady: false, hold: false });
-                    const schemaSnapshot = schema.getService().getSnapshot();
-                    const schemaStatus = schemaSnapshot.value;
-                    // Only validate against schema if it's loaded (in idle state)
-                    if (schemaStatus === 'idle') {
-                        const schemaContext = schemaSnapshot.context;
-                        // Use validateModelAgainstSchema which validates the model data directly
-                        // without requiring it to be in schema.models. This prevents loops because:
-                        // 1. Model validates against schema (model NOT in schema context yet)
-                        // 2. If valid, model gets registered with schema
-                        // 3. No need for manual updates because model is already correct (liveQuery handles updates)
-                        const schemaResult = validationService.validateModelAgainstSchema(schemaContext, context.modelName, context);
-                        if (!schemaResult.isValid) {
-                            if (!hasResponded) {
-                                hasResponded = true;
-                                clearTimeout(timeoutId);
-                                sendBack({ type: 'validationError', errors: schemaResult.errors });
-                            }
-                            return;
-                        }
-                    }
-                    else {
-                        logger$6(`Schema is in ${schemaStatus} state, skipping schema validation`);
-                        // Continue with structure validation only
-                    }
-                }
-                catch (error) {
-                    logger$6('Error validating model against schema:', error);
-                    // Continue with structure validation only
-                }
-            }
-            // All validations passed
-            if (!hasResponded) {
-                hasResponded = true;
-                clearTimeout(timeoutId);
-                sendBack({ type: 'validationSuccess', errors: [] });
-            }
-        }
-        catch (error) {
-            if (!hasResponded) {
-                hasResponded = true;
-                clearTimeout(timeoutId);
-                logger$6('Error in validateModel:', error);
-                sendBack({
-                    type: 'validationError',
-                    errors: [{
-                            field: 'model',
-                            message: error instanceof Error ? error.message : 'Unknown validation error',
-                            code: 'validation_exception',
-                            severity: 'error',
-                        }],
-                });
-            }
-        }
-    };
-    _validateModel().catch((error) => {
-        if (!hasResponded) {
-            hasResponded = true;
-            clearTimeout(timeoutId);
-            logger$6('Error in validateModel:', error);
-            sendBack({
-                type: 'validationError',
-                errors: [{
-                        field: 'model',
-                        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$5 = debug('seedSdk:model:actors:createModelProperties');
-const createModelProperties = fromCallback(({ sendBack, input, self }) => {
-    // The model was stopped (unloaded, or evicted with its schema by Schema.destroy / test cleanup) while
-    // this ran: stopping it stops this actor too, but can't cancel the awaits below. A stopped model
-    // creates no properties (they'd be cached for a model that's gone, and write rows under it).
-    const stopped = () => isActorStopped(self);
-    const _createProperties = async () => {
-        const { context, propertyDefinitions } = input;
-        const { id, _dbId, modelName, schemaName } = context;
-        if (!id || !_dbId || !modelName) {
-            throw new Error('Model ID, file ID, and name are required to create properties');
-        }
-        if (!propertyDefinitions || Object.keys(propertyDefinitions).length === 0) {
-            logger$5('No property definitions provided, skipping property creation');
-            sendBack({ type: 'createModelPropertiesSuccess' });
-            return;
-        }
-        logger$5(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await import('./ModelProperty-i5flwzQG.js');
-        const ModelProperty = mod?.ModelProperty ?? mod?.default;
-        if (!ModelProperty) {
-            logger$5('ModelProperty not available from dynamic import');
-            sendBack({ type: 'createModelPropertiesError', error: new Error('ModelProperty not available') });
-            return;
-        }
-        const drizzleMod = await import('drizzle-orm');
-        const { and, eq } = drizzleMod;
-        const db = BaseDb.getAppDb();
-        for (const [propName, propData] of Object.entries(propertyDefinitions)) {
-            // The model's own write (writeModelToDb) normally stored this property already, under
-            // propData.id or an id it generated. Reuse that row so the instance gets the same id
-            // and doesn't write the property a second time.
-            const propertyRecord = db
-                ? (await db
-                    .select()
-                    .from(properties)
-                    .where(propData.id
-                    ? eq(properties.schemaFileId, propData.id)
-                    : and(eq(properties.modelId, _dbId), eq(properties.name, propName)))
-                    .limit(1))[0]
-                : undefined;
-            // Otherwise use provided ID or generate a random one
-            // IDs should be generated in the import process before creating properties
-            const _mod_7 = await import('./index-Dx_GTdyQ.js');
-            const _ns_7 = _mod_7.bh;
-            const { generateId } = _ns_7;
-            const propertyFileId = propData.id || propertyRecord?.schemaFileId || generateId();
-            logger$5(`Creating property "${propName}" with fileId "${propertyFileId}"`);
-            // Query database to get refModelId if the property has ref/refModelName
-            // The property should already be in DB from addModelsToDb
-            let refModelId = propData.refModelId;
-            if (!refModelId && (propData.ref || propData.refModelName) && db) {
-                try {
-                    const refModelName = propData.refModelName || propData.ref;
-                    // First try to get refModelId from the property record in the database
-                    if (propertyRecord?.refModelId) {
-                        refModelId = propertyRecord.refModelId;
-                        logger$5(`Found refModelId ${refModelId} from database for property "${propName}"`);
-                    }
-                    else if (refModelName) {
-                        // Fallback: resolve the ref by name within this model's schema
-                        const _mod_8 = await import('./index-Dx_GTdyQ.js');
-                        const _ns_8 = _mod_8.be;
-                        const { resolveModelRecord } = _ns_8;
-                        const refModelRecord = await resolveModelRecord(refModelName, { schemaName }, db);
-                        if (refModelRecord?.id) {
-                            refModelId = refModelRecord.id;
-                            logger$5(`Resolved refModelId ${refModelId} from model name "${refModelName}" for property "${propName}"`);
-                        }
-                    }
-                }
-                catch (error) {
-                    logger$5(`Error fetching refModelId for property "${propName}":`, error);
-                    // Continue without refModelId - it will be resolved later in _initializeOriginalValues
-                }
-            }
-            if (stopped()) {
-                logger$5(`Model "${modelName}" was stopped while creating its properties; not creating the rest`);
-                return;
-            }
-            // Create ModelProperty instance
-            // This will load from DB if it exists, or create new instance
-            // The property should already be in DB from writeModelToDb
-            // Note: propertyFileId is the schemaFileId (string), not the database ID (number)
-            // We pass it as _propertyFileId so getById() can find the instance
-            const property = await ModelProperty.create({
-                name: propName,
-                modelName,
-                modelId: _dbId,
-                dataType: propData.dataType,
-                ref: propData.ref,
-                refModelName: propData.refModelName,
-                refModelId,
-                refValueType: propData.refValueType,
-                // Definitions built from DB rows may lack storage settings; the row has them.
-                storageType: propData.storageType ?? propertyRecord?.storageType ?? undefined,
-                localStorageDir: propData.localStorageDir ?? propertyRecord?.localStorageDir ?? undefined,
-                filenameSuffix: propData.filenameSuffix ?? propertyRecord?.filenameSuffix ?? undefined,
-                required: propData.required,
-                // Rules defined in code live only on the instance (the properties table has no column
-                // for them); getPropertySchema reads them from here when no schema file has them.
-                validation: propData.validation,
-                htmlEmbeddedDataUriPolicy: propData.htmlEmbeddedDataUriPolicy,
-                _propertyFileId: propertyFileId, // Store schemaFileId for getById() lookups
-                _dbId: propertyRecord?.schemaFileId === propertyFileId ? propertyRecord.id : undefined, // Already persisted: skip the write
-            }, { schemaName }); // Use 'as any' because _propertyFileId is not in TProperty type
-            // The model keeps its properties; an app's unload of the same instance doesn't stop them.
-            ModelProperty.adoptForModel(property);
-        }
-        logger$5(`Successfully created all properties for model "${modelName}"`);
-        sendBack({ type: 'createModelPropertiesSuccess' });
-    };
-    _createProperties().catch((error) => {
-        logger$5(`Error creating model properties: ${error}`);
-        sendBack({
-            type: 'createModelPropertiesError',
-            error: error instanceof Error ? error : new Error(String(error))
-        });
-    });
-    return () => {
-        // Cleanup function (optional)
-    };
-});
-
-/**
- * Eviction epochs: lets work that was started before a schema's Model/ModelProperty instances were
- * evicted (Schema.destroy, test cleanup) tell, when it finishes, that it must not put instances for
- * that schema back in the caches. Stopping the evicted actors can't cancel such work (a DB lookup
- * that ends in Model.create, a model's property creation), and finishing it after the eviction would
- * rebuild instances from rows that are about to be deleted, which then write themselves again.
- *
- * Capture `currentEvictionEpoch()` when the work starts; before creating or caching an instance, skip
- * it when `schemaEvictedSince(schemaName, epoch)`. Work started after an eviction is unaffected.
- */
-let epoch = 0;
-const lastEvictionBySchema = new Map();
-// Schemas whose destroy() is still running (by name)
-const destroyingSchemas = new Map();
-// Single models destroyed (Model.destroy), by modelFileId
-const lastDestroyByModelId = new Map();
-// Models whose destroy() is still deleting their rows
-const destroyingModelIds = new Map();
-function currentEvictionEpoch() {
-    return epoch;
-}
-/** Called by Model.evictForSchema. */
-function recordSchemaEviction(schemaName) {
-    epoch += 1;
-    lastEvictionBySchema.set(schemaName, epoch);
-}
-/**
- * Called by Schema.destroy before it evicts the schema's models; `finishSchemaDestroy` once its rows
- * are gone. The schema's actor stays live until then, and work it starts meanwhile (its live query
- * reading a model row the drained write just landed) captures an epoch after the eviction, so the
- * epoch alone can't tell it to stay away.
- */
-function recordSchemaDestroy(schemaName) {
-    recordSchemaEviction(schemaName);
-    destroyingSchemas.set(schemaName, (destroyingSchemas.get(schemaName) ?? 0) + 1);
-}
-function finishSchemaDestroy(schemaName) {
-    const remaining = (destroyingSchemas.get(schemaName) ?? 1) - 1;
-    if (remaining > 0)
-        destroyingSchemas.set(schemaName, remaining);
-    else
-        destroyingSchemas.delete(schemaName);
-    // Work that read a row during the destroy and checks after it must still see the eviction
-    recordSchemaEviction(schemaName);
-}
-/**
- * True when the schema is being destroyed, or its instances were evicted after `since` (an epoch
- * from currentEvictionEpoch).
- */
-function schemaEvictedSince(schemaName, since) {
-    if (!schemaName)
-        return false;
-    if (destroyingSchemas.has(schemaName))
-        return true;
-    if (epoch === since)
-        return false;
-    return (lastEvictionBySchema.get(schemaName) ?? 0) > since;
-}
-/**
- * Called by Model.destroy before it clears the caches; `finishModelDestroy` once its rows are gone.
- * Until then a lookup by id still finds the row, so it must not re-cache the model either.
- */
-function recordModelDestroy(modelFileId) {
-    epoch += 1;
-    lastDestroyByModelId.set(modelFileId, epoch);
-    destroyingModelIds.set(modelFileId, (destroyingModelIds.get(modelFileId) ?? 0) + 1);
-}
-function finishModelDestroy(modelFileId) {
-    const remaining = (destroyingModelIds.get(modelFileId) ?? 1) - 1;
-    if (remaining > 0)
-        destroyingModelIds.set(modelFileId, remaining);
-    else
-        destroyingModelIds.delete(modelFileId);
-}
-/**
- * True when the model is being destroyed, or was destroyed after `since` (an epoch from
- * currentEvictionEpoch): a lookup that read its row must not create or cache an instance.
- */
-function modelDestroyedSince(modelFileId, since) {
-    if (!modelFileId)
-        return false;
-    if (destroyingModelIds.has(modelFileId))
-        return true;
-    if (epoch === since)
-        return false;
-    return (lastDestroyByModelId.get(modelFileId) ?? 0) > since;
-}
-/**
- * True when any schema was evicted after `since` or is being destroyed (cheap check before looking up
- * which schemas apply).
- */
-function anyEvictionSince(since) {
-    return epoch !== since || destroyingSchemas.size > 0;
-}
-
-const logger$4 = debug('seedSdk:write:validateEntity');
-// XState v5 type inference bug: fromPromise types are inverted
-// We use type assertion to work around this
-const validateEntity = fromPromise(async ({ input }) => {
-    // Type assertion to fix XState v5 type inference bug
-    // Convert through unknown to avoid type overlap error
-    const entityInput = input;
-    // Validation awaits imports before looking up the schema; the entity can be evicted with its
-    // schema meanwhile (Schema.destroy, test cleanup). Schema.create would then load the evicted
-    // schema again, and its load re-creates the schema's models from rows being deleted.
-    const evictionEpoch = currentEvictionEpoch();
-    /** The schema to validate against; throws (validation then skips the schema check) once it was evicted. */
-    const schemaForValidation = async (schemaName) => {
-        const _mod_9 = await import('./Schema-PFZwG9Nl.js');
-        const _ns_9 = _mod_9.a;
-        const { Schema } = _ns_9;
-        if (schemaEvictedSince(schemaName, evictionEpoch)) {
-            throw new Error(`Schema "${schemaName}" was evicted during validation`);
-        }
-        return Schema.create(schemaName, { waitForReady: false, hold: false });
-    };
-    const _validate = async () => {
-        try {
-            const msg = `[validateEntity] Starting validation for ${entityInput.entityType}`;
-            logger$4(msg);
-            logger$4(`[validateEntity] Entity data:`, entityInput.entityData);
-            let result = { isValid: true, errors: [] };
-            if (entityInput.entityType === 'model') {
-                const structureMsg = `[validateEntity] Validating model structure`;
-                logger$4(structureMsg);
-                // Use existing Model validation
-                const validationServiceMod = await import('./SchemaValidationService-DnGKel4V.js');
-                const { SchemaValidationService } = validationServiceMod;
-                const validationService = new SchemaValidationService();
-                // Validate model structure
-                const structureResult = validationService.validateModelStructure(entityInput.entityData);
-                const structureResultMsg = `[validateEntity] Structure validation result: isValid=${structureResult.isValid}, errors=${structureResult.errors?.length || 0}`;
-                logger$4(structureResultMsg);
-                if (!structureResult.isValid) {
-                    result = {
-                        isValid: false,
-                        errors: structureResult.errors,
-                    };
-                }
-                else {
-                    // If schema name provided, validate against schema
-                    if (entityInput.entityData.schemaName) {
-                        try {
-                            logger$4(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
-                            const schema = await schemaForValidation(entityInput.entityData.schemaName);
-                            const schemaSnapshot = schema.getService().getSnapshot();
-                            const schemaStatus = schemaSnapshot.value;
-                            logger$4(`[validateEntity] Schema status: ${schemaStatus}`);
-                            if (schemaStatus === 'idle') {
-                                const schemaContext = schemaSnapshot.context;
-                                logger$4(`[validateEntity] Running validateModelAgainstSchema`);
-                                const schemaResult = validationService.validateModelAgainstSchema(schemaContext, entityInput.entityData.modelName, entityInput.entityData);
-                                logger$4(`[validateEntity] Schema validation result:`, schemaResult);
-                                if (!schemaResult.isValid) {
-                                    result = {
-                                        isValid: false,
-                                        errors: schemaResult.errors,
-                                    };
-                                }
-                            }
-                            else {
-                                logger$4(`[validateEntity] Schema not in idle state (${schemaStatus}), skipping schema validation`);
-                            }
-                        }
-                        catch (error) {
-                            logger$4('Error validating model against schema:', error);
-                            // Continue with structure validation only
-                        }
-                    }
-                    else {
-                        logger$4(`[validateEntity] No schemaName provided, skipping schema validation`);
-                    }
-                }
-            }
-            else if (entityInput.entityType === 'modelProperty') {
-                // Use existing ModelProperty validation
-                const validationServiceMod = await import('./SchemaValidationService-DnGKel4V.js');
-                const { SchemaValidationService } = validationServiceMod;
-                const validationService = new SchemaValidationService();
-                // Validate property structure
-                const structureResult = validationService.validatePropertyStructure(entityInput.entityData);
-                if (!structureResult.isValid) {
-                    result = {
-                        isValid: false,
-                        errors: structureResult.errors,
-                    };
-                }
-                else {
-                    // If schema name and model name provided, validate against schema
-                    if (entityInput.entityData._schemaName && entityInput.entityData.modelName) {
-                        try {
-                            const schema = await schemaForValidation(entityInput.entityData._schemaName);
-                            const schemaSnapshot = schema.getService().getSnapshot();
-                            const schemaStatus = schemaSnapshot.value;
-                            if (schemaStatus === 'idle') {
-                                const schemaContext = schemaSnapshot.context;
-                                if (schemaContext.models && Object.keys(schemaContext.models).length > 0) {
-                                    const schemaResult = validationService.validateProperty(schemaContext, entityInput.entityData.modelName, entityInput.entityData.name || '', entityInput.entityData);
-                                    if (!schemaResult.isValid) {
-                                        result = {
-                                            isValid: false,
-                                            errors: schemaResult.errors,
-                                        };
-                                    }
-                                }
-                            }
-                        }
-                        catch (error) {
-                            logger$4('Error validating property against schema:', error);
-                            // Continue with structure validation only
-                        }
-                    }
-                }
-            }
-            // Return the result - fromPromise will automatically put this in event.output
-            const completeMsg = `[validateEntity] Validation complete: isValid=${result.isValid}, errors=${result.errors?.length || 0}`;
-            logger$4(completeMsg);
-            logger$4(`[validateEntity] Validation complete:`, result);
-            return result;
-        }
-        catch (error) {
-            const errorMsg = `[validateEntity] Error in validateEntity: ${error instanceof Error ? error.message : String(error)}`;
-            logger$4(errorMsg);
-            logger$4('Error in validateEntity:', error);
-            // Throw error - fromPromise will automatically create error.platform event
-            throw error;
-        }
-    };
-    return await _validate();
-});
-
-const logger$3 = debug('seedSdk:write:writeToDatabase');
-// Writes that have started. Stopping a write process's actor can't cancel one, so code that deletes rows
-// under live instances (Schema.destroy, test cleanup) waits for these after evicting the instances.
-const inFlightWrites = new Set();
-/**
- * Resolves once every database write started so far has finished (or after timeoutMs). Evict/stop the
- * instances first so no new writes start while waiting.
- */
-const waitForInFlightWrites = async (timeoutMs = 5000) => {
-    const deadline = Date.now() + timeoutMs;
-    while (inFlightWrites.size > 0 && Date.now() < deadline) {
-        await Promise.race([
-            Promise.allSettled([...inFlightWrites]),
-            new Promise((resolve) => setTimeout(resolve, deadline - Date.now())),
-        ]);
-    }
-};
-const writeToDatabase = fromCallback(({ sendBack, input }) => {
-    const _write = async () => {
-        try {
-            const db = BaseDb.getAppDb();
-            if (!db) {
-                throw new Error('Database not available');
-            }
-            let output = input.entityData;
-            if (input.entityType === 'model') {
-                const writeMsg = `Writing model to database: ${input.entityData.modelName} (schemaId: ${input.entityData.schemaId})`;
-                logger$3(writeMsg);
-                logger$3(`Writing model to database:`, {
-                    modelFileId: input.entityId,
-                    modelName: input.entityData.modelName,
-                    schemaId: input.entityData.schemaId,
-                });
-                await writeModelToDb(input.entityId, input.entityData);
-                // Get _dbId from database after write
-                const db = BaseDb.getAppDb();
-                if (db) {
-                    const modelRecords = await db
-                        .select({ id: models.id })
-                        .from(models)
-                        .where(eq(models.schemaFileId, input.entityId)) // entityId is now the schemaFileId (string)
-                        .limit(1);
-                    if (modelRecords.length > 0 && modelRecords[0].id) {
-                        output = { ...input.entityData, _dbId: modelRecords[0].id }; // Store as _dbId (database integer ID)
-                    }
-                    else {
-                        output = input.entityData;
-                    }
-                }
-                else {
-                    output = input.entityData;
-                }
-                const successMsg = `Successfully wrote model "${input.entityData.modelName}" to database`;
-                logger$3(successMsg);
-            }
-            else if (input.entityType === 'modelProperty') {
-                // Use current ModelProperty context when available so a user rename before the
-                // initial write completes is not overwritten by the stale requestWrite payload.
-                let dataToWrite = input.entityData;
-                try {
-                    const mod = await import('./ModelProperty-i5flwzQG.js');
-                    const ModelProperty = mod?.ModelProperty ?? mod?.default;
-                    if (ModelProperty && typeof ModelProperty.getById === 'function') {
-                        const instance = ModelProperty.getById(input.entityId);
-                        if (instance && typeof instance._getSnapshotContext === 'function') {
-                            const ctx = instance._getSnapshotContext();
-                            const ctxName = ctx.name ?? input.entityData.name;
-                            dataToWrite = {
-                                ...input.entityData,
-                                name: ctxName,
-                                dataType: ctx.dataType ?? input.entityData.dataType,
-                                refModelId: ctx.refModelId ?? input.entityData.refModelId,
-                                refValueType: ctx.refValueType ?? input.entityData.refValueType,
-                                refModelName: ctx.refModelName ?? input.entityData.refModelName,
-                                storageType: ctx.storageType ?? input.entityData.storageType,
-                                localStorageDir: ctx.localStorageDir ?? input.entityData.localStorageDir,
-                                filenameSuffix: ctx.filenameSuffix ?? input.entityData.filenameSuffix,
-                                required: ctx.required ?? input.entityData.required,
-                            };
-                        }
-                    }
-                }
-                catch (_) {
-                    // Fall back to input.entityData if instance not available
-                }
-                await writePropertyToDb(input.entityId, dataToWrite);
-                output = input.entityData;
-            }
-            else {
-                throw new Error(`Unknown entity type: ${input.entityType}`);
-            }
-            // Send success event explicitly - callback actors don't trigger onDone
-            sendBack({
-                type: 'writeSuccess',
-                output,
-            });
-        }
-        catch (error) {
-            logger$3('Error in writeToDatabase:', error);
-            sendBack({
-                type: 'writeError',
-                error: error instanceof Error ? error : new Error(String(error)),
-            });
-        }
-    };
-    const write = _write().catch((error) => {
-        logger$3('Error in writeToDatabase promise:', error);
-        sendBack({
-            type: 'writeError',
-            error: error instanceof Error ? error : new Error(String(error)),
-        });
-    });
-    inFlightWrites.add(write);
-    write.finally(() => inFlightWrites.delete(write));
-    return () => {
-        // Cleanup function (optional)
-    };
-});
-
-var writeToDatabase$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    waitForInFlightWrites: waitForInFlightWrites,
-    writeToDatabase: writeToDatabase
-});
-
-const logger$2 = debug('seedSdk:write:writeProcessMachine');
-const writeProcessMachine = setup({
-    types: {
-        context: {},
-        input: {},
-        events: {},
-    },
-    actors: {
-        validateEntity,
-        writeToDatabase,
-    },
-}).createMachine({
-    id: 'writeProcess',
-    initial: 'idle',
-    context: ({ input }) => ({
-        entityType: input.entityType,
-        entityId: input.entityId,
-        entityData: input.entityData || {},
-        validationErrors: [],
-        error: null,
-        pendingWrite: null,
-    }),
-    states: {
-        idle: {
-            on: {
-                startWrite: {
-                    target: 'validating',
-                    actions: [
-                        assign({
-                            pendingWrite: ({ event }) => ({
-                                data: event.data,
-                                timestamp: Date.now(),
-                            }),
-                        }),
-                        ({ event, context }) => {
-                            logger$2(`[startWrite] Received startWrite for ${context.entityType} "${context.entityId}"`);
-                            logger$2(`[startWrite] Data:`, event.data);
-                        },
-                    ],
-                },
-            },
-        },
-        validating: {
-            entry: ({ context }) => {
-                const msg = `[validating] Entering validating state for ${context.entityType} "${context.entityId}"`;
-                logger$2(msg);
-                logger$2(`[validating] Entity data:`, context.pendingWrite?.data || context.entityData);
-            },
-            invoke: {
-                src: 'validateEntity',
-                input: ({ context }) => {
-                    const entityData = context.pendingWrite?.data || context.entityData;
-                    logger$2(`[validating] Invoking validateEntity with:`, { entityType: context.entityType, entityData });
-                    return {
-                        entityType: context.entityType,
-                        entityData,
-                    };
-                },
-                onDone: [
-                    {
-                        target: 'writing',
-                        guard: ({ event }) => {
-                            // The output might be the result directly, or it might be wrapped in an event
-                            let result;
-                            if (event.output && typeof event.output === 'object' && 'isValid' in event.output) {
-                                result = event.output;
-                            }
-                            else if (event.output && typeof event.output === 'object' && 'type' in event.output) {
-                                // If it's wrapped in an event, extract the result
-                                result = event.output;
-                            }
-                            else {
-                                console.error(`[validating] Unexpected event.output format! Event:`, event);
-                                return false;
-                            }
-                            if (!result || typeof result.isValid !== 'boolean') {
-                                console.error(`[validating] Invalid result format! Result:`, result);
-                                return false;
-                            }
-                            const resultMsg = `[validating] Validation result: isValid=${result.isValid}, errors=${result.errors?.length || 0}`;
-                            logger$2(resultMsg);
-                            logger$2(`[validating] Validation result:`, result);
-                            return result.isValid;
-                        },
-                        actions: [
-                            assign({
-                                validationErrors: [],
-                            }),
-                            ({ context }) => {
-                                const msg = `[validating] Validation passed, transitioning to writing for ${context.entityType} "${context.entityId}"`;
-                                logger$2(msg);
-                            },
-                        ],
-                    },
-                    {
-                        target: 'error',
-                        actions: [
-                            assign({
-                                validationErrors: ({ event }) => {
-                                    const result = event.output;
-                                    return result.errors || [];
-                                },
-                                error: ({ event }) => {
-                                    const result = event.output;
-                                    return new Error(`Validation failed: ${result.errors.map(e => e.message).join(', ')}`);
-                                },
-                            }),
-                            ({ context, event }) => {
-                                const result = event.output;
-                                logger$2(`[validating] Validation failed for ${context.entityType} "${context.entityId}":`, result.errors);
-                            },
-                        ],
-                    },
-                ],
-                onError: {
-                    target: 'error',
-                    actions: [
-                        assign({
-                            error: ({ event }) => event.error instanceof Error ? event.error : new Error(String(event.error)),
-                        }),
-                        ({ context, event }) => {
-                            const errorMsg = `[validating] Validation error for ${context.entityType} "${context.entityId}": ${event.error}`;
-                            logger$2(errorMsg);
-                            console.error(errorMsg, event.error); // Always log to console
-                        },
-                    ],
-                },
-            },
-        },
-        writing: {
-            invoke: {
-                src: 'writeToDatabase',
-                input: ({ context }) => {
-                    const entityData = context.pendingWrite?.data || context.entityData;
-                    logger$2(`[writing] Calling writeToDatabase for ${context.entityType} "${context.entityId}"`);
-                    logger$2(`[writing] Entity data:`, entityData);
-                    return {
-                        entityType: context.entityType,
-                        entityId: context.entityId,
-                        entityData,
-                    };
-                },
-            },
-            on: {
-                writeSuccess: {
-                    target: 'success',
-                    actions: [
-                        assign({
-                            pendingWrite: null,
-                            entityData: ({ context, event }) => {
-                                // Update entityData with any returned data from write
-                                return event.output || context.entityData;
-                            },
-                        }),
-                        ({ context }) => {
-                            logger$2(`[writing] Write successful for ${context.entityType} "${context.entityId}"`);
-                        },
-                    ],
-                },
-                writeError: {
-                    target: 'error',
-                    actions: [
-                        assign({
-                            error: ({ event }) => event.error instanceof Error ? event.error : new Error(String(event.error)),
-                        }),
-                        ({ context, event }) => {
-                            const errorMsg = `[writing] Write error for ${context.entityType} "${context.entityId}": ${event.error}`;
-                            logger$2(errorMsg);
-                            // Nothing else reports a failed persist to the caller, so always log to console
-                            console.error(errorMsg, event.error);
-                        },
-                    ],
-                },
-            },
-        },
-        success: {
-            after: {
-                2000: { target: 'idle' }, // Auto-reset after 2s
-            },
-        },
-        error: {},
-    },
-});
-
-const logger$1 = debug('seedSdk:model:modelMachine');
-const modelMachine = setup({
-    types: {
-        context: {},
-        input: {},
-        events: {},
-    },
-    actors: {
-        loadOrCreateModel,
-        validateModel,
-        createModelProperties,
-        writeProcessMachine,
-    },
-    guards: {
-        isModelValid: ({ context }) => {
-            return !context._validationErrors || context._validationErrors.length === 0;
-        },
-    },
-    actions: {
-        assignValidationErrors: assign(({ context, event }) => {
-            if (event.type === 'validationError') {
-                return {
-                    ...context,
-                    _validationErrors: event.errors,
-                };
-            }
-            return context;
-        }),
-    },
-}).createMachine({
-    id: 'model',
-    initial: 'loading',
-    context: ({ input }) => ({
-        id: input.id,
-        _dbId: undefined,
-        modelName: input.modelName,
-        schemaName: input.schemaName,
-        _pendingPropertyDefinitions: input._pendingPropertyDefinitions,
-        _idFromSchema: input._idFromSchema,
-        _isDraft: false,
-        _editedProperties: new Set(),
-        _validationErrors: undefined,
-        writeProcess: undefined,
-        _liveQueryPropertyIds: [], // Initialize empty array
-    }),
-    on: {
-        updateContext: [
-            {
-                // Always update context first (no guard, always runs)
-                actions: [
-                    assign(({ context, event }) => {
-                        const newContext = { ...context };
-                        // Check if this is only updating internal fields
-                        const onlyInternalFields = Object.keys(event).every((key) => {
-                            return key === 'type' || key.startsWith('_');
-                        });
-                        // Update the context with new values
-                        for (let i = 0; i < Object.keys(event).length; i++) {
-                            const key = Object.keys(event)[i];
-                            if (key === 'type') {
-                                continue;
-                            }
-                            const eventValue = event[key];
-                            // Ensure arrays are properly copied (create new reference)
-                            newContext[key] = Array.isArray(eventValue) ? [...eventValue] : eventValue;
-                        }
-                        // Compare with original values and set _isEdited flag (only for non-internal updates)
-                        // Note: properties are not in context - they're computed from ModelProperty instances
-                        // Property changes are tracked via ModelProperty._isEdited flags
-                        if (!onlyInternalFields && context._originalValues) {
-                            const hasChanges = Object.keys(event).some((key) => {
-                                if (key === 'type' || key.startsWith('_') || key === 'properties')
-                                    return false;
-                                const newValue = newContext[key];
-                                const oldValue = context._originalValues?.[key];
-                                // Deep comparison for objects/arrays
-                                if (typeof newValue === 'object' && typeof oldValue === 'object') {
-                                    return JSON.stringify(newValue) !== JSON.stringify(oldValue);
-                                }
-                                return newValue !== oldValue;
-                            });
-                            newContext._isEdited = hasChanges;
-                        }
-                        // Clear validation errors on context update (will be re-validated if needed)
-                        newContext._validationErrors = undefined;
-                        return newContext;
-                    }),
-                    // Verify the context was updated and create property instances if needed
-                    ({ event, self }) => {
-                        if (event._liveQueryPropertyIds !== undefined) {
-                            const newPropertyIds = event._liveQueryPropertyIds;
-                            // The model can be evicted with its schema (Schema.destroy, test cleanup) before the
-                            // timer and import below run: then create nothing, and drop lookups an eviction overtakes.
-                            const evictionEpoch = currentEvictionEpoch();
-                            // Use setTimeout to check after assign has been applied
-                            setTimeout(() => {
-                                const snapshot = self.getSnapshot();
-                                if (snapshot.status === 'stopped')
-                                    return;
-                                // Create ModelProperty instances for any new property IDs
-                                if (Array.isArray(newPropertyIds) && newPropertyIds.length > 0) {
-                                    // Import and create instances asynchronously (fire-and-forget)
-                                    import('./ModelProperty-i5flwzQG.js').then(({ ModelProperty }) => {
-                                        if (self.getSnapshot().status === 'stopped')
-                                            return;
-                                        const createPromises = newPropertyIds.map(async (propertyFileId) => {
-                                            try {
-                                                const property = await ModelProperty.createById(propertyFileId, { evictionEpoch });
-                                                if (property) {
-                                                    logger$1(`[modelMachine] Created/cached ModelProperty instance for propertyFileId "${propertyFileId}" after _liveQueryPropertyIds update`);
-                                                }
-                                            }
-                                            catch (error) {
-                                                logger$1(`[modelMachine] Error creating ModelProperty instance for propertyFileId "${propertyFileId}": ${error}`);
-                                            }
-                                        });
-                                        Promise.all(createPromises).catch((error) => {
-                                            logger$1(`[modelMachine] Error creating property instances: ${error}`);
-                                        });
-                                    }).catch((error) => {
-                                        logger$1(`[modelMachine] Error importing ModelProperty: ${error}`);
-                                    });
-                                }
-                            }, 0);
-                        }
-                    },
-                ],
-                // Don't transition - stay in current state, context will be updated
-            },
-            {
-                // Conditionally trigger validation for non-internal updates
-                guard: ({ event }) => {
-                    return !Object.keys(event).every((key) => {
-                        return key === 'type' || key.startsWith('_');
-                    });
-                },
-                target: '.validating',
-            },
-        ],
-        validateModel: {
-            target: '.validating',
-        },
-        validationSuccess: {
-            actions: assign(({ context }) => ({
-                ...context,
-                _validationErrors: [],
-            })),
-        },
-        validationError: {
-            actions: 'assignValidationErrors',
-        },
-        initializeOriginalValues: {
-            actions: assign(({ context, event }) => ({
-                ...context,
-                _originalValues: event.originalValues,
-                _isEdited: event.isEdited ?? false,
-                _validationErrors: undefined,
-            })),
-        },
-        markAsDraft: {
-            actions: assign(({ context, event }) => ({
-                ...context,
-                _isEdited: true,
-                _editedProperties: new Set([
-                    ...(context._editedProperties || []),
-                    event.propertyKey,
-                ]),
-            })),
-        },
-        clearDraft: {
-            actions: assign(({ context }) => ({
-                ...context,
-                _isEdited: false,
-                _editedProperties: new Set(),
-                _originalValues: {
-                // Properties are not stored in context - they're computed from ModelProperty instances
-                // Properties serialization happens separately when initializing original values
-                },
-            })),
-        },
-        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: {
-            on: {
-                loadOrCreateModelSuccess: {
-                    target: 'idle',
-                    actions: assign(({ context, event }) => {
-                        const hasPendingProps = !!(context._pendingPropertyDefinitions && Object.keys(context._pendingPropertyDefinitions).length > 0);
-                        logger$1(`[loadOrCreateModelSuccess] Preserving _pendingPropertyDefinitions: ${hasPendingProps} (${Object.keys(context._pendingPropertyDefinitions || {}).length} properties)`);
-                        // Check if there's a pending model name update (set before this event to avoid validation trigger)
-                        const finalModelName = context._pendingModelName || context.modelName;
-                        if (context._pendingModelName) {
-                            logger$1(`[loadOrCreateModelSuccess] Applying pending model name: "${context.modelName}" -> "${finalModelName}"`);
-                        }
-                        return {
-                            ...context,
-                            id: event.model.id, // schemaFileId (string)
-                            _dbId: event.model._dbId, // Database integer ID
-                            _isEdited: event.model._isEdited ?? false, // Load isEdited from database
-                            _editedProperties: new Set(),
-                            _validationErrors: undefined,
-                            // Use final model name (may have been set via _pendingModelName to avoid validation trigger)
-                            modelName: finalModelName,
-                            // Clear the temporary field
-                            _pendingModelName: undefined,
-                            // Preserve _pendingPropertyDefinitions if it exists
-                            _pendingPropertyDefinitions: context._pendingPropertyDefinitions,
-                            // Preserve _liveQueryPropertyIds if provided (set by loadOrCreateModel when loading from DB)
-                            _liveQueryPropertyIds: event.model._liveQueryPropertyIds ?? context._liveQueryPropertyIds ?? [],
-                            // Preserve conflict detection metadata if provided
-                            _loadedAt: event.model._loadedAt,
-                            _dbVersion: event.model._dbVersion,
-                            _dbUpdatedAt: event.model._dbUpdatedAt,
-                            _originalValues: {
-                            // Properties are not stored in context - they're computed from ModelProperty instances
-                            // Properties will be loaded via liveQuery after model creation
-                            },
-                        };
-                    }),
-                },
-                loadOrCreateModelError: {
-                    target: 'error',
-                },
-            },
-            invoke: {
-                src: 'loadOrCreateModel',
-                input: ({ context }) => ({ context }),
-            },
-        },
-        idle: {
-            entry: assign({
-                writeProcess: ({ context, spawn }) => {
-                    if (!context.writeProcess && context.id) {
-                        logger$1(`[idle entry] Spawning writeProcess for model "${context.modelName}" (${context.id})`);
-                        return spawn(writeProcessMachine, {
-                            input: {
-                                entityType: 'model',
-                                entityId: context.id,
-                                entityData: {
-                                    modelName: context.modelName,
-                                    schemaName: context.schemaName,
-                                    // Properties are not stored in context - they'll be provided via requestWrite event
-                                },
-                            },
-                        });
-                    }
-                    return context.writeProcess;
-                },
-            }),
-            on: {
-                refreshProperties: {
-                    actions: () => {
-                        // This event will be handled by the Model instance's subscription
-                        // The Model will call _refreshPropertiesFromDb when it receives this event
-                        logger$1(`[idle] refreshProperties event received, will be handled by Model instance`);
-                    },
-                },
-                validateModel: {
-                    target: 'validating',
-                },
-                reloadFromDb: {
-                    target: 'loading',
-                },
-                requestWrite: {
-                    actions: ({ context, event }) => {
-                        if (context.writeProcess) {
-                            logger$1(`[requestWrite] Sending startWrite to writeProcess with data:`, event.data);
-                            context.writeProcess.send({
-                                type: 'startWrite',
-                                data: event.data,
-                            });
-                        }
-                        else {
-                            logger$1(`[requestWrite] ERROR: writeProcess not available for model "${context.modelName}" (${context.id})`);
-                        }
-                    },
-                },
-                writeSuccess: [
-                    {
-                        guard: ({ context }) => {
-                            // If we have pending property definitions, transition to creatingProperties
-                            const hasPending = !!(context._pendingPropertyDefinitions && Object.keys(context._pendingPropertyDefinitions).length > 0);
-                            logger$1(`[writeSuccess guard] hasPending: ${hasPending}, _pendingPropertyDefinitions keys: ${context._pendingPropertyDefinitions ? Object.keys(context._pendingPropertyDefinitions).length : 0}`);
-                            return hasPending;
-                        },
-                        target: 'creatingProperties',
-                        actions: assign(({ context, event }) => {
-                            logger$1(`[writeSuccess] Transitioning to creatingProperties for model "${context.modelName}"`);
-                            // Update _dbId from write output if available (writeToDatabase returns _dbId, not id)
-                            const newContext = { ...context };
-                            const dbId = event.output?._dbId ?? event.output?.id;
-                            if (dbId != null) {
-                                newContext._dbId = dbId;
-                                logger$1(`[writeSuccess] Updated _dbId to ${dbId}`);
-                            }
-                            return newContext;
-                        }),
-                    },
-                    {
-                        target: 'idle',
-                        actions: assign(({ context, event }) => {
-                            // Update _dbId from write output if available (writeToDatabase returns _dbId, not id)
-                            const newContext = { ...context };
-                            const dbId = event.output?._dbId ?? event.output?.id;
-                            if (dbId != null) {
-                                newContext._dbId = dbId;
-                            }
-                            return newContext;
-                        }),
-                    },
-                ],
-            },
-            // No `always: hasValidationErrors -> validating` here: validation is re-run when the context changes
-            // (updateContext) or on request (validateModel). Re-entering while errors exist would loop forever on a
-            // model that is still invalid.
-        },
-        validating: {
-            on: {
-                validationSuccess: {
-                    target: 'idle',
-                    actions: assign(({ context }) => ({
-                        ...context,
-                        _validationErrors: [],
-                    })),
-                },
-                validationError: {
-                    target: 'idle',
-                    actions: 'assignValidationErrors',
-                },
-            },
-            invoke: {
-                src: 'validateModel',
-                input: ({ context }) => ({ context }),
-            },
-        },
-        creatingProperties: {
-            entry: ({ context }) => {
-                logger$1(`[creatingProperties entry] Starting property creation for model "${context.modelName}" with ${Object.keys(context._pendingPropertyDefinitions || {}).length} properties`);
-            },
-            invoke: {
-                src: 'createModelProperties',
-                input: ({ context }) => {
-                    logger$1(`[creatingProperties invoke] Invoking createModelProperties with ${Object.keys(context._pendingPropertyDefinitions || {}).length} property definitions`);
-                    return {
-                        context,
-                        propertyDefinitions: context._pendingPropertyDefinitions || {},
-                    };
-                },
-            },
-            on: {
-                createModelPropertiesSuccess: {
-                    target: 'idle',
-                    actions: [
-                        assign(({ context }) => {
-                            // Only clear _pendingPropertyDefinitions, preserve everything else including _liveQueryPropertyIds
-                            return {
-                                ...context,
-                                _pendingPropertyDefinitions: undefined,
-                            };
-                        }),
-                        ({ self }) => {
-                            // Trigger property refresh after properties are created
-                            // This ensures _liveQueryPropertyIds is updated in Node.js where liveQuery isn't available
-                            setTimeout(() => {
-                                if (self.getSnapshot().status === 'stopped')
-                                    return;
-                                self.send({ type: 'refreshProperties' });
-                            }, 100); // Small delay to ensure properties are written to DB
-                        },
-                    ],
-                },
-                createModelPropertiesError: {
-                    target: 'error',
-                    actions: ({ event }) => {
-                        logger$1('Error creating model properties:', event.error);
-                    },
-                },
-            },
-        },
-        error: {},
-    },
-});
-
-/**
- * Error thrown when a conflict is detected between actor context and database
- */
-class ConflictError extends Error {
-    constructor(message, conflict) {
-        super(message);
-        this.name = 'ConflictError';
-        this.conflict = conflict;
-        Object.setPrototypeOf(this, ConflictError.prototype);
-    }
-}
-
-/**
- * Set up liveQuery subscription for an entity
- * This enables cross-instance synchronization (e.g., changes in other tabs/windows)
- *
- * @param instance - Entity instance
- * @param config - LiveQuery configuration
- */
-function setupEntityLiveQuery(instance, config) {
-    const isBrowser = typeof window !== 'undefined';
-    const logger = debug(config.loggerName);
-    // Use a closure variable to track setup state per instance
-    const setupState = { subscriptionSetUp: false };
-    const setupLiveQuery = async (entityId) => {
-        if (setupState.subscriptionSetUp) {
-            return;
-        }
-        setupState.subscriptionSetUp = true;
-        logger(`Setting up liveQuery for entity ID: ${entityId}`);
-        try {
-            // Query initial data if provided (for Node.js compatibility)
-            if (config.queryInitialData) {
-                const initialRows = await config.queryInitialData(entityId);
-                const initialIds = config.extractEntityIds(initialRows);
-                if (initialIds.length > 0) {
-                    logger(`Initial query returned ${initialIds.length} entities`);
-                    // Create child instances if provided (not for a stopped entity: an unloaded or evicted
-                    // parent must not re-cache its children)
-                    if (isActorStopped(instance.getService()))
-                        return;
-                    if (config.createChildInstances) {
-                        await config.createChildInstances(initialIds);
-                    }
-                    // Update context with initial IDs (the queries above can outlive the instance)
-                    if (isActorStopped(instance.getService()))
-                        return;
-                    config.updateContext(instance, initialIds);
-                }
-            }
-            // Only set up liveQuery subscription in browser environment
-            if (isBrowser) {
-                // buildQuery can be async to allow dynamic imports
-                const queryResult = config.buildQuery(entityId);
-                const query$ = queryResult instanceof Promise ? await queryResult : queryResult;
-                const instanceState = config.instanceState.get(instance);
-                if (!instanceState) {
-                    logger('Instance state not found');
-                    return;
-                }
-                // Unloaded or destroyed while setup awaited: subscribing now would leak the query.
-                if (isActorStopped(instance.getService()))
-                    return;
-                // Subscribe to liveQuery updates
-                const subscription = query$.subscribe({
-                    next: async (rows) => {
-                        // Check if instance state still exists (hasn't been cleaned up)
-                        const currentInstanceState = config.instanceState.get(instance);
-                        if (!currentInstanceState) {
-                            logger('Instance state was cleaned up, skipping update');
-                            return;
-                        }
-                        logger(`Query returned ${rows.length} rows`);
-                        const ids = config.extractEntityIds(rows);
-                        // Create child instances if provided (before updating context; not for a stopped entity)
-                        if (isActorStopped(instance.getService()))
-                            return;
-                        if (config.createChildInstances && ids.length > 0) {
-                            // Nothing awaits this handler, so a child that fails to load (its row deleted while it
-                            // loads, say) would be an unhandled rejection. Skip this result; a later one tries again.
-                            try {
-                                await config.createChildInstances(ids);
-                            }
-                            catch (error) {
-                                logger(`createChildInstances failed: ${error}`);
-                                return;
-                            }
-                        }
-                        // Update context with new IDs
-                        if (isActorStopped(instance.getService()))
-                            return;
-                        config.updateContext(instance, ids);
-                    },
-                    error: (error) => {
-                        logger(`LiveQuery error: ${error}`);
-                    },
-                });
-                instanceState.liveQuerySubscription = subscription;
-                logger(`LiveQuery subscription set up for entity ID: ${entityId}`);
-            }
-            else {
-                logger('Skipping liveQuery subscription in Node.js environment');
-            }
-        }
-        catch (error) {
-            logger(`Error setting up subscription: ${error}`);
-            setupState.subscriptionSetUp = false; // Reset on error so we can retry
-        }
-    };
-    // The entity's DB row can be written after the entity goes idle (e.g. a schema import writes its
-    // models' rows after the Model instances loaded from the schema file). Nothing changes the
-    // entity's snapshot then, so an idle entity's id is also retried on a timer until found or the
-    // actor stops. Only while idle and not writing (canRetryEntityId): a busy entity's own snapshots
-    // drive the lookup, and finding its row mid-write handed a Model its _dbId before its write (and
-    // its properties' rows) had finished.
-    let retryIndex = 0;
-    let retryTimer;
-    const scheduleRetry = () => {
-        if (retryTimer !== undefined || retryIndex >= ENTITY_ID_RETRY_DELAYS_MS.length)
-            return;
-        retryTimer = setTimeout(() => {
-            retryTimer = undefined;
-            // Busy: its next snapshot retries
-            if (instance.getService().getSnapshot().value !== 'idle')
-                return;
-            if (config.canRetryEntityId && !config.canRetryEntityId(instance))
-                return;
-            retryIndex++;
-            void trySetup();
-        }, ENTITY_ID_RETRY_DELAYS_MS[retryIndex]);
-    };
-    const trySetup = async () => {
-        if (setupState.subscriptionSetUp || isActorStopped(instance.getService()))
-            return;
-        if (config.isReady && !config.isReady(instance)) {
-            if (config.waitForReady) {
-                await config.waitForReady(instance);
-            }
-            else {
-                return; // Not ready yet, will retry on next snapshot
-            }
-        }
-        let entityId;
-        try {
-            entityId = await config.getEntityId(instance);
-        }
-        catch (error) {
-            logger(`Error getting entity ID: ${error}`);
-        }
-        if (!entityId) {
-            scheduleRetry();
-            return;
-        }
-        // Once we have entity ID, set up the liveQuery subscription (only once)
-        if (!setupState.subscriptionSetUp) {
-            await setupLiveQuery(entityId);
-        }
-        if (setupState.subscriptionSetUp) {
-            setupSubscription.unsubscribe();
-            if (retryTimer !== undefined)
-                clearTimeout(retryTimer);
-        }
-    };
-    // Set up liveQuery subscription as soon as we have entity ID
-    const setupSubscription = instance.getService().subscribe({
-        next: () => {
-            void trySetup();
-        },
-        complete: () => {
-            if (retryTimer !== undefined)
-                clearTimeout(retryTimer);
-        },
-    });
-    // Also check current state immediately in case entity ID is already available
-    void trySetup();
-}
-/** Backoff for retrying an entity's id when its DB row isn't there yet (~60s in total). */
-const ENTITY_ID_RETRY_DELAYS_MS = [50, 100, 200, 400, 800, 1600, ...Array(28).fill(2000)];
-
-/**
- * Returns model rows (id, name, schemaFileId, isEdited) for building Model instances.
- * When schemaIdentifier is provided, only returns models for that schema (join models -> model_schemas -> schemas).
- * schemaIdentifier can be either schema name or schema file ID.
- */
-const getModelsData = async (schemaIdentifier) => {
-    const appDb = BaseDb.getAppDb();
-    if (!appDb) {
-        return [];
-    }
-    if (schemaIdentifier !== undefined && schemaIdentifier !== '') {
-        const runQuery = () => appDb
-            .select({
-            id: models.id,
-            name: models.name,
-            schemaFileId: models.schemaFileId,
-            isEdited: models.isEdited,
-        })
-            .from(models)
-            .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
-            .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
-            .where(or(eq(schemas.name, schemaIdentifier), eq(schemas.schemaFileId, schemaIdentifier)));
-        let rows = await runQuery();
-        // Retry when we get 0 rows (read-after-write consistency; SQLocal/async may not see the write immediately).
-        for (let i = 0; i < 4 && rows.length === 0; i++) {
-            await new Promise((r) => setTimeout(r, 150));
-            rows = await runQuery();
-        }
-        return rows;
-    }
-    const rows = await appDb
-        .select({
-        id: models.id,
-        name: models.name,
-        schemaFileId: models.schemaFileId,
-        isEdited: models.isEdited,
-    })
-        .from(models);
-    return rows;
-};
-
-/**
- * Errors from draft saves that assignment starts in the background (schema/model renames and
- * tracked-property edits). Nothing awaits those saves, so the error is kept for `lastSaveError`
- * instead of only being logged. Keyed by the instance's service, which the instance and its
- * proxy share.
- */
-const draftSaveErrors = new WeakMap();
-function getDraftSaveError(service) {
-    return draftSaveErrors.get(service);
-}
-/** Run a background draft save, recording its failure (or clearing an earlier one on success). */
-function trackDraftSave(service, save, label) {
-    save.then(() => {
-        draftSaveErrors.delete(service);
-    }, (error) => {
-        const recorded = error instanceof Error ? error : new Error(String(error));
-        draftSaveErrors.set(service, recorded);
-        console.warn(`[seed] ${label}: draft save failed (see lastSaveError):`, recorded.message);
-    });
-}
-
-const logger = debug('seedSdk:model:Model');
-const saveDraftLogger = debug('seedSdk:model:saveDraftToDb');
-// Lazy import cache for ModelProperty to avoid circular dependency
-// Eagerly start loading to minimize delay on first access
-let ModelPropertyClass = null;
-const modelPropertyImportPromise = import('./ModelProperty-i5flwzQG.js')
-    .then(module => {
-    ModelPropertyClass = module.ModelProperty;
-    return ModelPropertyClass;
-})
-    .catch(() => {
-    // If import fails, ModelPropertyClass remains null
-    return null;
-});
-function getModelProperty() {
-    // Return cached class if available (synchronous access)
-    // Note: On first access before import completes, this will return null
-    // and the getter will return empty array, which matches the original behavior
-    return ModelPropertyClass;
-}
-// Mutable state per Model instance
-const modelInstanceState = new ActorKeyedState();
-// Settles once the properties passed to Model.create exist, or rejects when they can't be created.
-// The model reaches idle before its write, so idle alone doesn't mean they exist yet. Keyed by the
-// actor because callers hold the proxy, not the instance.
-const pendingPropertyCreation = new WeakMap();
-// 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
-    'modelName',
-    'schemaName',
-];
-class Model {
-    static trackPendingWrite(modelFileId, schemaId) {
-        this.pendingWrites.set(modelFileId, {
-            modelFileId,
-            schemaId,
-            status: 'pending',
-            timestamp: Date.now(),
-        });
-    }
-    static getPendingModelIds(schemaId) {
-        return Array.from(this.pendingWrites.entries())
-            .filter(([_, write]) => write.schemaId === schemaId && write.status !== 'error')
-            .map(([modelFileId]) => modelFileId);
-    }
-    // 'name' is available as an alias for 'modelName' via the proxy
-    constructor(modelName, schemaName, id, // schemaFileId (string) - public ID
-    initialContext, idFromSchema // true when id was provided via options (schema model), not generated
-    ) {
-        const serviceInput = {
-            modelName,
-            schemaName,
-            ...(id ? { id } : {}),
-            ...(initialContext?._pendingPropertyDefinitions ? { _pendingPropertyDefinitions: initialContext._pendingPropertyDefinitions } : {}),
-            _idFromSchema: !!idFromSchema,
-        };
-        this._service = createActor(modelMachine, {
-            input: serviceInput,
-        });
-        this._service.start();
-        // Initialize instance state in WeakMap
-        modelInstanceState.set(this, {
-            liveQuerySubscription: null,
-        });
-        // Set up liveQuery subscription for cross-instance property updates
-        this._setupLiveQuerySubscription();
-        // Subscribe to refresh properties after they're created (for Node.js where liveQuery isn't available)
-        let previousState;
-        this._service.subscribe((snapshot) => {
-            // Check if we just transitioned to idle from creatingProperties state
-            if (snapshot.value === 'idle' && previousState === 'creatingProperties') {
-                // Small delay to ensure properties are written to DB
-                setTimeout(() => {
-                    this._refreshPropertiesFromDb().catch((error) => {
-                        logger(`[Model constructor] Error refreshing properties: ${error}`);
-                    });
-                }, 200);
-            }
-            previousState = snapshot.value;
-        });
-        // Note: Property getters/setters are now handled by the Proxy in create()
-    }
-    /**
-     * Resolves once the model is idle and any properties passed to Model.create exist.
-     * Rejects if it errors, times out, or its properties can't be created.
-     */
-    static async waitUntilReady(instance, timeout) {
-        const startedAt = Date.now();
-        await waitForEntityIdle(instance, { timeout });
-        const propertyCreation = pendingPropertyCreation.get(instance.getService());
-        if (!propertyCreation)
-            return instance;
-        const remaining = Math.max(0, timeout - (Date.now() - startedAt));
-        let timer;
-        try {
-            await Promise.race([
-                propertyCreation,
-                new Promise((_, reject) => {
-                    timer = setTimeout(() => {
-                        const modelName = instance.getService().getSnapshot().context.modelName;
-                        reject(new Error(`Model "${modelName}" did not finish creating its properties within ${timeout}ms`));
-                    }, remaining);
-                }),
-            ]);
-        }
-        finally {
-            clearTimeout(timer);
-        }
-        return instance;
-    }
-    /**
-     * Gives an idle, valid model the row someone else wrote for its id, the way its own write would
-     * (writeSuccess with the row's id, which goes on to create its properties from their rows).
-     * Returns false when there is no such row, so the model writes it.
-     */
-    static async adoptPersistedRow(instance) {
-        const snapshot = instance.getService().getSnapshot();
-        if (snapshot.value !== 'idle' || snapshot.context._validationErrors?.length || !snapshot.context.id) {
-            return false;
-        }
-        const db = BaseDb.getAppDb();
-        if (!db)
-            return false;
-        const [row] = await db
-            .select({ id: models.id })
-            .from(models)
-            .where(eq(models.schemaFileId, snapshot.context.id))
-            .limit(1);
-        if (!row || isActorStopped(instance.getService()))
-            return false;
-        logger(`Model "${snapshot.context.modelName}" adopts model row ${row.id} written by its schema import`);
-        instance.getService().send({ type: 'writeSuccess', output: { _dbId: row.id } });
-        return true;
-    }
-    /**
-     * True when a name-cached instance belongs to a different model than the requested modelFileId.
-     * A schema re-imported under the same name can give its models new ids while the previous
-     * instances are still cached by name; Model.create must not hand those back for the new id.
-     */
-    static isOtherModelId(cachedId, requestedId) {
-        return !!requestedId && !!cachedId && cachedId !== requestedId;
-    }
-    /**
-     * Find a unique model name by checking for duplicates (case-insensitive) in the cache
-     * If duplicates are found, appends an incrementing number to make it unique
-     *
-     * @param modelName - The desired model name
-     * @param schemaName - The schema name
-     * @param skipAllChecks - If true, skip all duplicate checks and return original name (used when creating schema models to preserve original names)
-     * @returns A unique model name
-     */
-    static findUniqueModelName(modelName, schemaName, skipAllChecks = false) {
-        // If skipAllChecks is true (schema models), preserve original name
-        if (skipAllChecks) {
-            return modelName;
-        }
-        const lowerModelName = modelName.toLowerCase();
-        // Check all cached models for this schema
-        const existingNames = new Set();
-        const existingNumbers = new Set();
-        // Check name-based cache
-        for (const nameKey of this.instanceCacheByName.keys()) {
-            const [cachedSchemaName, cachedModelName] = nameKey.split(':', 2);
-            if (cachedSchemaName === schemaName && cachedModelName) {
-                const lowerCachedName = cachedModelName.toLowerCase();
-                existingNames.add(lowerCachedName);
-                // If it matches the base name (case-insensitive), check if it has a number suffix
-                if (lowerCachedName === lowerModelName) {
-                    existingNumbers.add(0); // Base name exists
-                }
-                else if (lowerCachedName.startsWith(lowerModelName + ' ')) {
-                    // Check if it's the base name followed by a space and a number
-                    const suffix = lowerCachedName.slice(lowerModelName.length + 1);
-                    const number = parseInt(suffix, 10);
-                    if (!isNaN(number) && suffix === number.toString()) {
-                        existingNumbers.add(number);
-                    }
-                }
-            }
-        }
-        // Check legacy cache
-        for (const [nameKey] of this.instanceCache.keys()) {
-            const [cachedSchemaName, cachedModelName] = nameKey.split(':', 2);
-            if (cachedSchemaName === schemaName && cachedModelName) {
-                const lowerCachedName = cachedModelName.toLowerCase();
-                existingNames.add(lowerCachedName);
-                // If it matches the base name (case-insensitive), check if it has a number suffix
-                if (lowerCachedName === lowerModelName) {
-                    existingNumbers.add(0); // Base name exists
-                }
-                else if (lowerCachedName.startsWith(lowerModelName + ' ')) {
-                    // Check if it's the base name followed by a space and a number
-                    const suffix = lowerCachedName.slice(lowerModelName.length + 1);
-                    const number = parseInt(suffix, 10);
-                    if (!isNaN(number) && suffix === number.toString()) {
-                        existingNumbers.add(number);
-                    }
-                }
-            }
-        }
-        // If no duplicates found (no base name match and no numbered variants), return original name
-        if (existingNumbers.size === 0) {
-            return modelName;
-        }
-        // Find the next available number, starting from 1
-        let nextNumber = 1;
-        while (existingNumbers.has(nextNumber)) {
-            nextNumber++;
-        }
-        // Return the name with the number appended
-        return `${modelName} ${nextNumber}`;
-    }
-    static create(modelName, schemaNameOrSchema, // Schema type - using any to avoid circular dependency
-    options) {
-        if (!modelName) {
-            throw new Error('Model name is required');
-        }
-        const waitForReady = options?.waitForReady !== false;
-        const readyTimeout = options?.readyTimeout ?? DEFAULT_READY_TIMEOUT_MS;
-        const holds = options?.hold === false ? 0 : 1;
-        // Extract schema name and instance
-        let schemaName;
-        let schemaInstance; // Using any to avoid circular dependency with Schema
-        if (typeof schemaNameOrSchema === 'string') {
-            schemaName = schemaNameOrSchema;
-        }
-        else {
-            schemaInstance = schemaNameOrSchema;
-            schemaName = schemaInstance.schemaName;
-        }
-        if (!schemaName) {
-            throw new Error('Schema name is required');
-        }
-        // Support both modelFileId (documented) and id (backward compatibility)
-        const id = options?.modelFileId || options?.id; // schemaFileId (string) - public ID
-        const registerWithSchema = options?.registerWithSchema !== false && schemaInstance !== undefined;
-        // Step 1: Check ID-based cache first (if ID provided)
-        const cachedById = id ? this.instanceCacheById.get(id) : undefined;
-        if (cachedById) {
-            cachedById.refCount += holds;
-            const { instance } = cachedById;
-            logger(`Model.create: Found instance in ID cache for "${modelName}" (ID: ${id})`);
-            if (!waitForReady)
-                return instance;
-            return this.waitUntilReady(instance, readyTimeout);
-        }
-        // Step 2: Check for duplicate names and generate unique name if needed (before checking cache)
-        // This allows us to create new models with renamed versions when duplicates exist
-        // Skip all duplicate checks if modelFileId is provided (schema models should preserve original names)
-        const skipAllChecks = !!id; // If id (modelFileId) is provided, this is a schema model - skip schema check to preserve name
-        const uniqueModelName = this.findUniqueModelName(modelName, schemaName, skipAllChecks);
-        // Step 3: Check name-based index with ORIGINAL name first (before using unique name)
-        // Only return existing instance if the unique name matches the original (no rename needed)
-        // If a rename is needed, we'll create a new model with the unique name
-        let resolvedId = id;
-        const originalNameKey = `${schemaName}:${modelName}`;
-        // Step 3: When we have no id (runtime create), do not return from name cache. Each create('My Model')
-        // must get a new instance with an incremented name (My Model, My Model 1, ...). If the only cached
-        // instance with this name is the schema model (_idFromSchema), ensure we fall through to create new.
-        if (!resolvedId) {
-            const cachedId = this.instanceCacheByName.get(originalNameKey);
-            if (cachedId && this.instanceCacheById.has(cachedId)) {
-                const { instance } = this.instanceCacheById.get(cachedId);
-                const ctx = instance._getSnapshotContext();
-                if (ctx._idFromSchema) {
-                    resolvedId = undefined;
-                }
-                // Never return by name when !id (runtime create); fall through to create new with unique name
-            }
-        }
-        // Step 4: Check legacy cache with original name. Skip when !id (runtime create) so duplicate
-        // create('My Model') calls get new instances with incremented names.
-        if (id && uniqueModelName === modelName) {
-            const legacyKey = `${schemaName}:${modelName}`;
-            const legacyEntry = this.instanceCache.get(legacyKey);
-            if (legacyEntry) {
-                const { instance } = legacyEntry;
-                const ctx = instance._getSnapshotContext();
-                if (!ctx._idFromSchema && !this.isOtherModelId(ctx.id, id)) {
-                    legacyEntry.refCount += holds;
-                    logger(`Model.create: Found instance in legacy cache for "${modelName}"`);
-                    const existingId = instance._getSnapshotContext().id;
-                    if (existingId) {
-                        this.instanceCacheById.set(existingId, legacyEntry);
-                        this.instanceCacheByName.set(legacyKey, existingId);
-                    }
-                    if (!waitForReady)
-                        return instance;
-                    return this.waitUntilReady(instance, readyTimeout);
-                }
-            }
-        }
-        // Step 5: When a rename is needed (uniqueModelName !== modelName), do NOT return a cached
-        // instance. The only cached instance with the original name at this point is the
-        // schema-defined model (created with modelFileId); returning it would give the user the
-        // schema model instead of a new runtime model with the unique name (e.g. "New model 1").
-        if (uniqueModelName !== modelName) {
-            logger(`Model.create: Found duplicate name "${modelName}" in schema "${schemaName}", using unique name "${uniqueModelName}"`);
-        }
-        // Step 6a: Generate ID now when needed so we can use a placeholder cache key for runtime creates
-        if (!resolvedId) {
-            resolvedId = generateId();
-            logger(`Model.create: Generated new id (schemaFileId) "${resolvedId}" for model "${modelName}"`);
-        }
-        // Create name-based cache key. When no id (runtime create), use a placeholder so we don't
-        // overwrite the schema model's entry (e.g. "New model"); loadOrCreateModel will replace it with the final name.
-        const nameKey = id
-            ? `${schemaName}:${uniqueModelName}`
-            : `${schemaName}:__pending__${resolvedId}`;
-        // Step 6: Check legacy cache with unique name (backward compatibility during migration)
-        // This is a fallback in case an instance was cached with a unique name
-        if (this.instanceCache.has(nameKey) &&
-            !this.isOtherModelId(this.instanceCache.get(nameKey).instance._getSnapshotContext().id, id)) {
-            const legacyEntry = this.instanceCache.get(nameKey);
-            legacyEntry.refCount += holds;
-            const { instance } = legacyEntry;
-            logger(`Model.create: Found instance in legacy cache for "${modelName}"`);
-            // Migrate to new cache structure
-            const context = instance._getSnapshotContext();
-            const existingId = context.id; // id is now the schemaFileId (string)
-            if (existingId) {
-                this.instanceCacheById.set(existingId, legacyEntry);
-                this.instanceCacheByName.set(nameKey, existingId);
-            }
-            if (!waitForReady)
-                return instance;
-            return this.waitUntilReady(instance, readyTimeout);
-        }
-        // Step 7: Create new instance with id in initial context
-        // This ensures loadOrCreateModel sees the ID immediately
-        // Pass _pendingPropertyDefinitions in initial context to avoid race condition with loadOrCreateModel
-        // This is the proper XState way - include it in the initial input so it's available from the start
-        const initialContext = options?.properties
-            ? { _pendingPropertyDefinitions: JSON.parse(JSON.stringify(options.properties)) }
-            : undefined;
-        // Use the unique model name for the instance (idFromSchema: true when id was provided, so schema model is not renamed)
-        const newInstance = new this(uniqueModelName, schemaName, resolvedId, initialContext, !!id);
-        if (options?.properties) {
-            logger(`[Model.create] Created instance with _pendingPropertyDefinitions in initial context (${Object.keys(options.properties).length} properties) for model "${uniqueModelName}"`);
-        }
-        // Called by the write trigger below when the properties will never be created
-        let failPropertyCreation = () => { };
-        if (options?.properties && Object.keys(options.properties).length > 0) {
-            const service = newInstance.getService();
-            const propertyCreation = new Promise((resolve, reject) => {
-                const subscription = service.subscribe({
-                    next: (snapshot) => {
-                        if (snapshot.value === 'idle' && !snapshot.context._pendingPropertyDefinitions) {
-                            subscription.unsubscribe();
-                            resolve();
-                        }
-                        else if (snapshot.value === 'error') {
-                            failPropertyCreation('the model is in an error state');
-                        }
-                    },
-                    complete: () => failPropertyCreation('the model was unloaded'),
-                });
-                failPropertyCreation = (reason) => {
-                    subscription.unsubscribe();
-                    reject(new Error(`Model "${service.getSnapshot().context.modelName}" could not create its properties: ${reason}`));
-                };
-            });
-            // Only waitUntilReady reports this; without waitForReady nobody awaits it
-            propertyCreation.catch(() => { });
-            pendingPropertyCreation.set(service, propertyCreation);
-        }
-        // Step 7: Set initial model data if provided
-        // Note: description is not supported - JSON files can have it but we ignore it at runtime
-        if (options) {
-            const updates = {};
-            if (Object.keys(updates).length > 0) {
-                newInstance._service.send({
-                    type: 'updateContext',
-                    ...updates,
-                });
-                // Initialize original values
-                // Note: properties are not stored in context, they're computed from ModelProperty instances
-                newInstance._service.send({
-                    type: 'initializeOriginalValues',
-                    originalValues: {},
-                    isEdited: false,
-                });
-            }
-        }
-        // Wrap instance in Proxy for reactive property access. `name` is an alias for `modelName`.
-        const sendUpdate = (target, prop, value) => {
-            if (prop === 'modelName') {
-                // Model name change - need to update Schema and database
-                const context = target._getSnapshotContext();
-                const oldName = context.modelName;
-                const newName = value;
-                if (oldName === newName) {
-                    logger(`Model name unchanged: "${oldName}"`);
-                    return;
-                }
-                logger(`Updating model name from "${oldName}" to "${newName}"`);
-                // Update Model instance cache using new ID-based structure
-                const modelFileId = context.id; // id is now the schemaFileId (string)
-                if (modelFileId) {
-                    Model.updateNameIndex(oldName, newName, context.schemaName, modelFileId);
-                }
-                else {
-                    // Fallback to legacy cache if no ID (shouldn't happen, but safety)
-                    const oldCacheKey = `${context.schemaName}:${oldName}`;
-                    const newCacheKey = `${context.schemaName}:${newName}`;
-                    if (Model.instanceCache.has(oldCacheKey)) {
-                        const entry = Model.instanceCache.get(oldCacheKey);
-                        Model.instanceCache.delete(oldCacheKey);
-                        Model.instanceCache.set(newCacheKey, entry);
-                    }
-                }
-                // Update Model context
-                target._service.send({
-                    type: 'updateContext',
-                    modelName: newName,
-                });
-                // Mark model as draft
-                target._service.send({
-                    type: 'markAsDraft',
-                    propertyKey: 'modelName',
-                });
-                // Save draft to database immediately so changes persist
-                trackDraftSave(target._service, target._saveDraftToDb(oldName, newName), `Model "${newName}"`);
-                // NOTE: Schema is not notified of model name changes during edits.
-                // Schema will read from Model instances when persisting/saving.
-            }
-            else {
-                // Standard property update
-                target._service.send({
-                    type: 'updateContext',
-                    [prop]: value,
-                });
-            }
-        };
-        const proxiedInstance = createReactiveProxy({
-            instance: newInstance,
-            service: newInstance._service,
-            trackedProperties: TRACKED_PROPERTIES,
-            getContext: (target) => target._getSnapshotContext(),
-            sendUpdate,
-            resolve: (target, prop) => {
-                if (prop === 'name') {
-                    return {
-                        get: () => target._getSnapshotContext().modelName,
-                        set: (value) => sendUpdate(target, 'modelName', value),
-                    };
-                }
-                return undefined;
-            },
-            virtualKeys: () => ['name'],
-            onSet: (_target, prop) => {
-                if (prop === 'properties') {
-                    // Properties are read-only computed values from ModelProperty instances
-                    throw new Error('Cannot set model.properties directly. Properties are computed from ModelProperty instances.');
-                }
-                if (prop === 'description') {
-                    // Description is not supported - JSON files can have it but we ignore it at runtime
-                    throw new Error('Cannot set model.description. Description is not supported in runtime Model instances.');
-                }
-            },
-        });
-        // Step 8: Store in new ID-based cache
-        // resolvedId is guaranteed to be defined at this point (generated if not provided).
-        // The ID and legacy caches share one entry: one hold count for the instance.
-        const entry = { instance: proxiedInstance, refCount: holds };
-        this.instanceCacheById.set(resolvedId, entry);
-        // Step 9: Store in name-based index (placeholder key when !id; loadOrCreateModel will replace with final name)
-        this.instanceCacheByName.set(nameKey, resolvedId);
-        // Step 9b: When created with id (schema model) and unique name, also register original name so create(modelName) returns same instance
-        if (id && uniqueModelName !== modelName) {
-            this.instanceCacheByName.set(originalNameKey, resolvedId);
-        }
-        // Step 10: Also store in legacy cache (for backward compatibility during migration)
-        this.instanceCache.set(nameKey, entry);
-        logger(`Model.create: Created new instance for "${uniqueModelName}" (ID: ${id})`);
-        // Model instance is now cached and accessible via Model.getById() and Model.getByName()
-        // No wrapper or store registration needed
-        // Step 11: Register with schema if requested, OR trigger write if properties are provided
-        // If properties are provided, we need to write the model to get modelId for property creation
-        // If schema provided, trigger write process instead of registration
-        // When schemaName is passed as string (e.g. useCreateModel), we must trigger write so runtime-created
-        // models get persisted to DB and show up in useModels (which queries the database).
-        const hasProperties = !!options?.properties && Object.keys(options.properties).length > 0;
-        const shouldTriggerWrite = (registerWithSchema && schemaInstance) ||
-            hasProperties ||
-            typeof schemaNameOrSchema === 'string';
-        // Every DB load (createById, getByNameAsync, ...) also passes a string schema and no properties.
-        // Such a model adopts its existing row: writing it again rewrote each property row and cleared is_edited.
-        const adoptExistingRow = !!options?.persistedBy || (typeof schemaNameOrSchema === 'string' && !hasProperties);
-        if (shouldTriggerWrite) {
-            queueMicrotask(async () => {
-                try {
-                    // Wait for model to reach idle state (validation complete)
-                    await new Promise((resolve) => {
-                        // Cleared once the model settles: a pending timer kept Node scripts alive for 10 s.
-                        const timer = setTimeout(() => {
-                            subscription.unsubscribe();
-                            resolve();
-                        }, 10000);
-                        const subscription = proxiedInstance._service.subscribe((snapshot) => {
-                            // Wait for idle state (validation complete) or error state
-                            if (snapshot.value === 'idle' || snapshot.value === 'error') {
-                                clearTimeout(timer);
-                                subscription.unsubscribe();
-                                resolve();
-                            }
-                        });
-                    });
-                    // The caller writes this model's rows; wait for that so two writers don't write them at once
-                    if (options?.persistedBy) {
-                        await options.persistedBy.catch(() => { });
-                    }
-                    // Unloaded or evicted (e.g. Schema.destroy) while it loaded: a stopped model never writes
-                    if (isActorStopped(proxiedInstance._service)) {
-                        failPropertyCreation('the model was unloaded');
-                        return;
-                    }
-                    if (adoptExistingRow && (await Model.adoptPersistedRow(proxiedInstance))) {
-                        return;
-                    }
-                    // Only write if validation passed (model is in idle state, not error)
-                    const finalSnapshot = proxiedInstance._service.getSnapshot();
-                    if (finalSnapshot.value === 'idle' && (!finalSnapshot.context._validationErrors || finalSnapshot.context._validationErrors.length === 0)) {
-                        logger(`Model validation passed, triggering write process`);
-                        // Get schema ID from schema instance or look it up by schema name
-                        let schemaId;
-                        if (schemaInstance) {
-                            const schemaContext = schemaInstance._getSnapshotContext();
-                            // First, try to use _dbId directly from schema context (most reliable)
-                            // But verify it exists in database before using it
-                            if (schemaContext._dbId && typeof schemaContext._dbId === 'number' && schemaContext._dbId > 0) {
-                                try {
-                                    const db = BaseDb.getAppDb();
-                                    if (db) {
-                                        const verifySchema = await db
-                                            .select({ id: schemas.id })
-                                            .from(schemas)
-                                            .where(eq(schemas.id, schemaContext._dbId))
-                                            .limit(1);
-                                        if (verifySchema.length > 0) {
-                                            schemaId = schemaContext._dbId;
-                                            logger(`Using schema _dbId directly from Schema context: ${schemaId} (verified in database)`);
-                                        }
-                                        else {
-                                            logger(`WARNING: Schema _dbId ${schemaContext._dbId} from context does not exist in database. Falling back to schemaFileId lookup.`);
-                                        }
-                                    }
-                                }
-                                catch (error) {
-                                    logger(`WARNING: Could not verify schema _dbId: ${error}. Falling back to schemaFileId lookup.`);
-                                }
-                            }
-                            // Fall back to database lookup by schemaFileId if _dbId wasn't available or invalid
-                            if (!schemaId) {
-                                // Fall back to database lookup by schemaFileId
-                                const schemaFileId = schemaContext.id; // id is the schemaFileId (string) in SchemaMachineContext
-                                if (schemaFileId) {
-                                    try {
-                                        const db = BaseDb.getAppDb();
-                                        if (db) {
-                                            const schemaRecords = await db
-                                                .select()
-                                                .from(schemas)
-                                                .where(eq(schemas.schemaFileId, schemaFileId))
-                                                .limit(1);
-                                            if (schemaRecords.length > 0) {
-                                                schemaId = schemaRecords[0].id;
-                                                logger(`Found schemaId ${schemaId} by schemaFileId lookup: ${schemaFileId}`);
-                                            }
-                                            else {
-                                                logger(`WARNING: Schema not found in database by schemaFileId: ${schemaFileId}. Schema may not be fully loaded yet.`);
-                                            }
-                                        }
-                                    }
-                                    catch (error) {
-                                        logger(`Error looking up schemaId: ${error}`);
-                                    }
-                                }
-                                else {
-                                    logger(`WARNING: Schema instance has no schemaFileId (id) in context`);
-                                }
-                            }
-                        }
-                        else if (schemaName) {
-                            // If no schema instance but we have schema name, look it up by name
-                            try {
-                                const db = BaseDb.getAppDb();
-                                if (db) {
-                                    const schemaRecords = await db
-                                        .select()
-                                        .from(schemas)
-                                        .where(eq(schemas.name, schemaName))
-                                        .limit(1);
-                                    if (schemaRecords.length > 0) {
-                                        schemaId = schemaRecords[0].id;
-                                        logger(`Found schemaId ${schemaId} by schema name lookup: ${schemaName}`);
-                                    }
-                                    else {
-                                        logger(`WARNING: Schema not found in database by name: ${schemaName}`);
-                                    }
-                                }
-                            }
-                            catch (error) {
-                                logger(`Error looking up schemaId by name: ${error}`);
-                            }
-                        }
-                        // Validate schemaId before proceeding
-                        if (!schemaId || !Number.isInteger(schemaId) || schemaId <= 0) {
-                            logger(`ERROR: Invalid schemaId (${schemaId}) for model "${finalSnapshot.context.modelName}". Cannot trigger write process.`);
-                            logger(`Schema context:`, {
-                                schemaFileId: schemaInstance ? schemaInstance._getSnapshotContext().id : 'N/A',
-                                _dbId: schemaInstance ? schemaInstance._getSnapshotContext()._dbId : 'N/A',
-                                schemaName: schemaName || 'N/A',
-                            });
-                            failPropertyCreation(`its schema "${schemaName}" was not found in the database`);
-                        }
-                        else if (finalSnapshot.context.id) {
-                            // Verify schema exists in database before proceeding (additional safety check)
-                            try {
-                                const db = BaseDb.getAppDb();
-                                if (db) {
-                                    const schemaCheck = await db
-                                        .select({ id: schemas.id })
-                                        .from(schemas)
-                                        .where(eq(schemas.id, schemaId))
-                                        .limit(1);
-                                    if (schemaCheck.length === 0) {
-                                        const errorMsg = `Schema with id ${schemaId} does not exist in database. Cannot create model "${finalSnapshot.context.modelName}".`;
-                                        logger(`ERROR: ${errorMsg}`);
-                                        throw new Error(errorMsg);
-                                    }
-                                    logger(`Verified schema ${schemaId} exists in database before creating model "${finalSnapshot.context.modelName}"`);
-                                }
-                                else {
-                                    logger(`WARNING: Database not available for schema verification. Proceeding anyway.`);
-                                }
-                            }
-                            catch (error) {
-                                // If it's our validation error, re-throw it
-                                if (error instanceof Error && error.message.includes('does not exist in database')) {
-                                    throw error;
-                                }
-                                logger(`WARNING: Could not verify schema exists in database: ${error}. Proceeding anyway.`);
-                            }
-                            const pendingModelFileId = finalSnapshot.context.id;
-                            const pendingSchemaId = schemaId;
-                            // Wait for writeProcess to be spawned (it's spawned in idle state entry action)
-                            // Retry a few times if writeProcess isn't available yet
-                            let retries = 0;
-                            const maxRetries = 10;
-                            const checkAndSend = async () => {
-                                // Unloaded or evicted (e.g. Schema.destroy) before the write started: nothing to write to
-                                if (isActorStopped(proxiedInstance._service)) {
-                                    failPropertyCreation('the model was unloaded');
-                                    return;
-                                }
-                                const currentSnapshot = proxiedInstance._service.getSnapshot();
-                                if (currentSnapshot.context.writeProcess) {
-                                    // Track pending write (only once it really starts: a stopped model leaves none behind)
-                                    Model.trackPendingWrite(pendingModelFileId, pendingSchemaId); // id is now the schemaFileId (string)
-                                    logger(`Triggering write process for model "${finalSnapshot.context.modelName}" (schemaId: ${schemaId})`);
-                                    // Use pending property definitions if available, otherwise convert from ModelProperty instances
-                                    let propertiesObject = {};
-                                    if (currentSnapshot.context._pendingPropertyDefinitions) {
-                                        // Use the original property definitions for the write
-                                        // Convert dataType to type for validation compatibility
-                                        propertiesObject = JSON.parse(JSON.stringify(currentSnapshot.context._pendingPropertyDefinitions));
-                                        for (const [propName, propData] of Object.entries(propertiesObject)) {
-                                            if (propData.dataType && !propData.type) {
-                                                propertiesObject[propName] = {
-                                                    ...propData,
-                                                    type: propData.dataType,
-                                                };
-                                            }
-                                        }
-                                    }
-                                    else {
-                                        // Fallback: convert ModelProperty instances to object format
-                                        const properties = proxiedInstance.properties || [];
-                                        propertiesObject = modelPropertiesToObject(properties);
-                                    }
-                                    // Set up subscription to writeProcess to detect write success BEFORE sending request
-                                    const writeProcess = currentSnapshot.context.writeProcess;
-                                    // Check current state - if already in success, handle immediately
-                                    const currentWriteState = writeProcess.getSnapshot();
-                                    if (currentWriteState.value === 'success') {
-                                        proxiedInstance._service.send({
-                                            type: 'writeSuccess',
-                                            output: currentWriteState.context.entityData,
-                                        });
-                                    }
-                                    else {
-                                        // Set up subscription to catch future state changes
-                                        const writeSubscription = writeProcess.subscribe((writeSnapshot) => {
-                                            if (writeSnapshot.value === 'success') {
-                                                writeSubscription.unsubscribe();
-                                                const currentContext = proxiedInstance._service.getSnapshot().context;
-                                                logger(`[writeProcess subscription] Write succeeded, sending writeSuccess event. Has _pendingPropertyDefinitions: ${!!(currentContext._pendingPropertyDefinitions && Object.keys(currentContext._pendingPropertyDefinitions).length > 0)}`);
-                                                // Send writeSuccess event to model machine
-                                                proxiedInstance._service.send({
-                                                    type: 'writeSuccess',
-                                                    output: writeSnapshot.context.entityData,
-                                                });
-                                            }
-                                            else if (writeSnapshot.value === 'error') {
-                                                writeSubscription.unsubscribe();
-                                                const errorContext = writeSnapshot.context;
-                                                logger(`Write process failed for model "${finalSnapshot.context.modelName}": ${errorContext.error?.message || 'Unknown error'}`);
-                                                logger(`Write process error details:`, errorContext.error);
-                                                logger(`Validation errors:`, errorContext.validationErrors);
-                                                failPropertyCreation(`writing the model failed: ${errorContext.error?.message || 'Unknown error'}`);
-                                            }
-                                        });
-                                    }
-                                    proxiedInstance._service.send({
-                                        type: 'requestWrite',
-                                        data: {
-                                            modelFileId: finalSnapshot.context.id, // id is now the schemaFileId (string)
-                                            modelName: finalSnapshot.context.modelName,
-                                            schemaName: finalSnapshot.context.schemaName,
-                                            schemaId,
-                                            properties: propertiesObject,
-                                        },
-                                    });
-                                }
-                                else if (retries < maxRetries) {
-                                    retries++;
-                                    setTimeout(checkAndSend, 50); // Retry after 50ms
-                                }
-                                else {
-                                    logger(`ERROR: writeProcess not available after ${maxRetries} retries for model "${finalSnapshot.context.modelName}"`);
-                                    failPropertyCreation('its write process never started');
-                                }
-                            };
-                            // Start checking immediately, but also allow time for entry action to complete
-                            setTimeout(checkAndSend, 0);
-                        }
-                        else {
-                            logger(`Cannot trigger write process: missing schemaId (${schemaId}) or id (${finalSnapshot.context.id})`);
-                            failPropertyCreation('it has no id');
-                        }
-                    }
-                    else {
-                        logger(`Model validation failed or model in error state, skipping write process`);
-                        failPropertyCreation('the model failed validation');
-                    }
-                }
-                catch (error) {
-                    logger(`Failed to trigger write process: ${error instanceof Error ? error.message : String(error)}`);
-                    failPropertyCreation(error instanceof Error ? error.message : String(error));
-                }
-            });
-        }
-        if (!waitForReady)
-            return proxiedInstance;
-        return this.waitUntilReady(proxiedInstance, readyTimeout);
-    }
-    /**
-     * Get Model instance by modelFileId (O(1) lookup). Takes a hold on the instance; release it with
-     * `unload()`.
-     */
-    static getById(modelFileId) {
-        const entry = this.instanceCacheById.get(modelFileId);
-        if (!entry)
-            return undefined;
-        entry.refCount += 1;
-        return entry.instance;
-    }
-    /**
-     * @internal For a Schema loading its models: true when this load should take the schema's hold
-     * on the model (pass no `hold` option), false when the schema already holds it (pass
-     * `hold: false`). After a true, call `dropSchemaHold` if the load returns no model.
-     */
-    static takeSchemaHold(modelFileId) {
-        if (!modelFileId || this.schemaHeldModelIds.has(modelFileId))
-            return false;
-        this.schemaHeldModelIds.add(modelFileId);
-        return true;
-    }
-    /** @internal The load `takeSchemaHold` approved found no model: there is no hold to release. */
-    static dropSchemaHold(modelFileId) {
-        this.schemaHeldModelIds.delete(modelFileId);
-    }
-    /** @internal A Schema's last unload: releases its hold on each of its models. */
-    static releaseSchemaHolds(schemaName) {
-        for (const modelFileId of [...this.schemaHeldModelIds]) {
-            const model = this.peek(modelFileId);
-            if (!model) {
-                this.schemaHeldModelIds.delete(modelFileId);
-                continue;
-            }
-            if (model._getSnapshotContext().schemaName !== schemaName)
-                continue;
-            this.schemaHeldModelIds.delete(modelFileId);
-            model.unload();
-        }
-    }
-    /**
-     * The cached Model with this modelFileId, without taking a hold. For SDK code that reads the
-     * model and doesn't hand it to a caller; callers that keep it use `getById`, `find` or `create`.
-     */
-    static peek(modelFileId) {
-        return this.instanceCacheById.get(modelFileId)?.instance;
-    }
-    /**
-     * Get Model instance by name (O(1) lookup via name→ID mapping). Takes a hold on the instance;
-     * release it with `unload()`.
-     *
-     * @param modelName - The name of the model
-     * @param schemaName - The schema name (optional, will query DB if not provided)
-     * @returns The Model instance if found, undefined otherwise
-     */
-    static getByName(modelName, schemaName) {
-        const model = this.peekByName(modelName, schemaName);
-        return model?.id ? this.getById(model.id) : undefined;
-    }
-    /**
-     * `getByName` without taking a hold. Without `schemaName` it searches every cached schema and
-     * throws AmbiguousModelError when models from several schemas share the name; callers that know
-     * the schema or model id should use Model.resolve() instead.
-     */
-    static peekByName(modelName, schemaName) {
-        if (schemaName) {
-            const id = this.instanceCacheByName.get(`${schemaName}:${modelName}`);
-            return id ? this.peek(id) : undefined;
-        }
-        return this._getUniqueCachedModel(modelName, (cachedModelName) => cachedModelName === modelName);
-    }
-    /**
-     * The one cached Model whose name matches (no hold taken), or AmbiguousModelError if models from
-     * several schemas do.
-     */
-    static _getUniqueCachedModel(label, matches) {
-        const matchesById = new Map(); // modelFileId -> schemaName
-        for (const [nameKey, id] of this.instanceCacheByName.entries()) {
-            const separator = nameKey.lastIndexOf(':');
-            const cachedModelName = nameKey.slice(separator + 1);
-            if (id && cachedModelName && matches(cachedModelName) && this.instanceCacheById.has(id)) {
-                matchesById.set(id, nameKey.slice(0, separator));
-            }
-        }
-        if (matchesById.size > 1) {
-            throw new AmbiguousModelError(label, [...matchesById.values()]);
-        }
-        const [matchId] = matchesById.keys();
-        return matchId ? this.peek(matchId) : undefined;
-    }
-    /**
-     * Resolve a cached Model from the most specific scope available: modelFileId (Model.id), then
-     * schemaName + modelName, then modelName alone. Takes no hold.
-     */
-    static resolve(modelName, scope = {}) {
-        if (scope.modelFileId) {
-            const byId = this.peek(scope.modelFileId);
-            if (byId)
-                return byId;
-        }
-        if (!modelName)
-            return undefined;
-        if (scope.schemaName) {
-            const bySchema = this.peekByName(modelName, scope.schemaName);
-            if (bySchema)
-                return bySchema;
-        }
-        return this.peekByName(modelName);
-    }
-    /**
-     * Find Model by modelType (an EAS model name, as seeds.type stores it). Matched as ADR 0008
-     * matches EAS names: `new_model` finds "New model", and `htmlpage` (an older SDK's name) finds
-     * "HTMLPage", unless HTMLPage's nameMatch (ADR 0009) is `exact`. Only the tightest matching tier
-     * counts; matches in several schemas are ambiguous. Takes no hold.
-     */
-    static findByModelType(modelType) {
-        if (!modelType)
-            return undefined;
-        const cachedNames = [...this.instanceCacheByName.keys()].map((key) => key.slice(key.lastIndexOf(':') + 1));
-        // Each name at its nameMatch level (ADR 0009), as last loaded.
-        const levels = currentNameMatchLevels();
-        const best = localNamesInBestMatchTier(modelType, cachedNames, { level: (name) => levels.model(name) });
-        return this._getUniqueCachedModel(modelType, (cachedModelName) => best.has(cachedModelName));
-    }
-    /**
-     * Get all Model instances for a schema from cache only (synchronous). Takes no holds.
-     * Includes models created at runtime via Model.create() that may not yet be in schema context.
-     */
-    static getCachedInstancesForSchema(schemaName) {
-        const instances = [];
-        const seen = new Set();
-        for (const [nameKey, id] of this.instanceCacheByName.entries()) {
-            const [cachedSchemaName] = nameKey.split(':');
-            if (cachedSchemaName === schemaName && id && !seen.has(id)) {
-                const instance = this.peek(id);
-                if (instance) {
-                    instances.push(instance);
-                    seen.add(id);
-                }
-            }
-        }
-        for (const [nameKey, entry] of this.instanceCache.entries()) {
-            const [cachedSchemaName] = nameKey.split(':');
-            if (cachedSchemaName === schemaName) {
-                const context = entry.instance._getSnapshotContext();
-                const id = context.id;
-                if (id && !seen.has(id)) {
-                    instances.push(entry.instance);
-                    seen.add(id);
-                }
-            }
-        }
-        return instances;
-    }
-    /**
-     * Async Model.resolve(): exact cache hit by modelFileId or schemaName+modelName, else the DB row for
-     * that scope (instantiating the Model), and only then the name-only fallback. Takes no hold.
-     */
-    static async resolveAsync(modelName, scope = {}) {
-        if (scope.modelFileId) {
-            const byId = this.peek(scope.modelFileId);
-            if (byId)
-                return byId;
-        }
-        if (modelName && scope.schemaName) {
-            const bySchema = this.peekByName(modelName, scope.schemaName);
-            if (bySchema)
-                return bySchema;
-        }
-        if (scope.modelFileId || scope.schemaName) {
-            const db = BaseDb.getAppDb();
-            if (db) {
-                const evictionEpoch = currentEvictionEpoch();
-                try {
-                    const rows = await db
-                        .select({
-                        modelFileId: models.schemaFileId,
-                        modelName: models.name,
-                        schemaName: schemas.name,
-                    })
-                        .from(models)
-                        .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
-                        .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
-                        .where(scope.modelFileId
-                        ? eq(models.schemaFileId, scope.modelFileId)
-                        : and(eq(models.name, modelName ?? ''), eq(schemas.name, scope.schemaName)))
-                        .limit(1);
-                    const record = rows[0];
-                    if (record?.modelName && record.schemaName && record.modelFileId) {
-                        // Its schema was evicted, or it was destroyed, while we read the row: don't bring it back.
-                        if (schemaEvictedSince(record.schemaName, evictionEpoch))
-                            return undefined;
-                        if (modelDestroyedSince(record.modelFileId, evictionEpoch))
-                            return undefined;
-                        return this.create(record.modelName, record.schemaName, { id: record.modelFileId, hold: false });
-                    }
-                }
-                catch (error) {
-                    logger(`Model.resolveAsync: scoped lookup failed for "${modelName}": ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-        }
-        return modelName ? this.getByNameAsync(modelName, undefined, { hold: false }) : undefined;
-    }
-    /**
-     * Get Model instance by name, querying database if not in cache
-     * This is an async version that can query the database when schemaName is not provided
-     *
-     * @param modelName - The name of the model
-     * @param schemaName - Optional schema name (will query DB if not provided)
-     * @returns The Model instance if found, undefined otherwise. Takes a hold unless `hold: false`.
-     */
-    static async getByNameAsync(modelName, schemaName, options) {
-        // First try cache
-        const cached = options?.hold === false ? this.peekByName(modelName, schemaName) : this.getByName(modelName, schemaName);
-        if (cached) {
-            return cached;
-        }
-        // If not in cache and schemaName not provided, query database
-        if (!schemaName) {
-            const db = BaseDb.getAppDb();
-            if (!db) {
-                return undefined;
-            }
-            const evictionEpoch = options?.evictionEpoch ?? currentEvictionEpoch();
-            try {
-                // Query model by name (throws AmbiguousModelError when several schemas define it)
-                const _mod_10 = await import('./index-Dx_GTdyQ.js');
-                const _ns_10 = _mod_10.be;
-                const { resolveModelRecord } = _ns_10;
-                const resolved = await resolveModelRecord(modelName, {}, db);
-                if (!resolved?.schemaFileId) {
-                    return undefined;
-                }
-                const modelRecords = await db
-                    .select({
-                    modelFileId: models.schemaFileId,
-                    modelName: models.name,
-                    schemaName: schemas.name,
-                })
-                    .from(models)
-                    .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
-                    .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
-                    .where(eq(models.id, resolved.id))
-                    .limit(1);
-                if (modelRecords.length === 0) {
-                    return undefined;
-                }
-                const record = modelRecords[0];
-                if (!record.modelName || !record.schemaName || !record.modelFileId) {
-                    return undefined;
-                }
-                // Its schema was evicted, or it was destroyed, while we read the row: don't bring it back.
-                if (schemaEvictedSince(record.schemaName, evictionEpoch)) {
-                    return undefined;
-                }
-                if (modelDestroyedSince(record.modelFileId, evictionEpoch)) {
-                    return undefined;
-                }
-                // Create model instance (will be cached)
-                return this.create(record.modelName, record.schemaName, {
-                    id: record.modelFileId, // id is now the schemaFileId (string)
-                    ...(options?.hold === false && { hold: false }),
-                });
-            }
-            catch (error) {
-                if (error instanceof AmbiguousModelError)
-                    throw error;
-                logger(`Model.getByNameAsync: Error looking up model by name "${modelName}": ${error instanceof Error ? error.message : String(error)}`);
-                return undefined;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Create or get Model instance by modelFileId
-     * Checks cache first, then database if not found
-     *
-     * @param modelFileId - The model file ID to look up
-     * @returns The Model instance if found, undefined otherwise
-     */
-    static async createById(modelFileId, options) {
-        if (!modelFileId) {
-            return undefined;
-        }
-        // Step 1: Check cache first (fast path)
-        const cached = options?.hold === false ? this.peek(modelFileId) : this.getById(modelFileId);
-        if (cached) {
-            logger(`Model.createById: Found instance in cache for ID "${modelFileId}"`);
-            return cached;
-        }
-        // Step 2: Query database to get modelName and schemaName
-        const db = BaseDb.getAppDb();
-        if (!db) {
-            logger(`Model.createById: Database not available for ID "${modelFileId}"`);
-            return undefined;
-        }
-        const evictionEpoch = options?.evictionEpoch ?? currentEvictionEpoch();
-        try {
-            // Query model by schemaFileId and join to get schema name
-            const modelRecords = await db
-                .select({
-                modelId: models.id,
-                modelName: models.name,
-                schemaName: schemas.name,
-            })
-                .from(models)
-                .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
-                .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
-                .where(eq(models.schemaFileId, modelFileId))
-                .limit(1);
-            if (modelRecords.length === 0) {
-                logger(`Model.createById: Model not found in database for ID "${modelFileId}"`);
-                return undefined;
-            }
-            const { modelName, schemaName } = modelRecords[0];
-            if (!modelName || !schemaName) {
-                logger(`Model.createById: Missing modelName or schemaName for ID "${modelFileId}"`);
-                return undefined;
-            }
-            // Its schema was evicted while we read the row (e.g. a Schema live query in flight during
-            // Schema.destroy or test cleanup): don't bring the model back.
-            if (schemaEvictedSince(schemaName, evictionEpoch)) {
-                logger(`Model.createById: schema "${schemaName}" was evicted during the lookup of "${modelFileId}"`);
-                return undefined;
-            }
-            // Destroyed while we read the row: destroy() clears the caches before it deletes the rows
-            if (modelDestroyedSince(modelFileId, evictionEpoch)) {
-                logger(`Model.createById: model "${modelFileId}" was destroyed during the lookup`);
-                return undefined;
-            }
-            // Step 3: Create model using existing create method (which will handle caching)
-            logger(`Model.createById: Creating model "${modelName}" in schema "${schemaName}" from ID "${modelFileId}"`);
-            return this.create(modelName, schemaName, {
-                id: modelFileId, // id is now the schemaFileId (string)
-                ...(options?.hold === false && { hold: false }),
-            });
-        }
-        catch (error) {
-            logger(`Model.createById: Error looking up model by ID "${modelFileId}": ${error instanceof Error ? error.message : String(error)}`);
-            return undefined;
-        }
-    }
-    /**
-     * Find Model instance by modelFileId, modelName/schemaName, or both
-     * Waits for the model to be fully loaded (idle state) by default
-     * @param options - Find options including lookup parameters and wait configuration
-     * @returns Model instance if found, undefined otherwise
-     */
-    static async find({ modelFileId, modelName, schemaName, waitForReady = true, readyTimeout = DEFAULT_READY_TIMEOUT_MS, }) {
-        return await findEntity({
-            getById: (id) => Model.getById(id),
-            createById: (id) => Model.createById(id),
-            getByName: (name, ...args) => {
-                const schemaName = args[0];
-                return Model.getByName(name, schemaName);
-            },
-            createByName: async (name, ...args) => {
-                const schemaName = args[0];
-                return Model.getByNameAsync(name, schemaName);
-            },
-        }, {
-            id: modelFileId,
-            name: modelName,
-            schemaName,
-        }, {
-            waitForReady,
-            readyTimeout,
-        });
-    }
-    /**
-     * Get all Model instances for a schema by schemaFileId or schemaName
-     * Queries database for all models with the given schemaId/schemaName and returns Model instances
-     *
-     * @param schemaIdentifier - The schema file ID or schema name to get models for
-     * @returns Array of Model instances for the schema
-     */
-    static async createBySchemaId(schemaIdentifier) {
-        if (!schemaIdentifier) {
-            return [];
-        }
-        const db = BaseDb.getAppDb();
-        if (!db) {
-            logger(`Model.createBySchemaId: Database not available for schema "${schemaIdentifier}"`);
-            return [];
-        }
-        const evictionEpoch = currentEvictionEpoch();
-        try {
-            // Query all models for this schema - support both schemaFileId and schema name
-            const modelRecords = await db
-                .select({
-                modelFileId: models.schemaFileId,
-                modelName: models.name,
-                schemaName: schemas.name,
-            })
-                .from(schemas)
-                .innerJoin(modelSchemas, eq(schemas.id, modelSchemas.schemaId))
-                .innerJoin(models, eq(modelSchemas.modelId, models.id))
-                .where(or(eq(schemas.schemaFileId, schemaIdentifier), eq(schemas.name, schemaIdentifier)));
-            if (modelRecords.length === 0) {
-                logger(`Model.createBySchemaId: No models found in database for schema "${schemaIdentifier}"`);
-                return [];
-            }
-            // Create Model instances for each model (create() handles caching)
-            const modelInstances = [];
-            for (const record of modelRecords) {
-                if (!record.modelName || !record.schemaName || !record.modelFileId) {
-                    continue;
-                }
-                // Its schema was evicted, or the model destroyed, while we read the rows: don't bring it back.
-                if (schemaEvictedSince(record.schemaName, evictionEpoch)) {
-                    continue;
-                }
-                if (modelDestroyedSince(record.modelFileId, evictionEpoch)) {
-                    continue;
-                }
-                // Check cache first
-                const cached = this.getById(record.modelFileId);
-                if (cached) {
-                    modelInstances.push(cached);
-                }
-                else {
-                    // Create model instance (will be cached)
-                    const model = this.create(record.modelName, record.schemaName, {
-                        id: record.modelFileId, // id is now the schemaFileId (string)
-                        waitForReady: false,
-                    });
-                    modelInstances.push(model);
-                }
-            }
-            logger(`Model.createBySchemaId: Found ${modelInstances.length} models for schema "${schemaIdentifier}"`);
-            return modelInstances;
-        }
-        catch (error) {
-            logger(`Model.createBySchemaId: Error looking up models for schema "${schemaIdentifier}": ${error instanceof Error ? error.message : String(error)}`);
-            return [];
-        }
-    }
-    /**
-     * Get all Model instances, optionally filtered by schema.
-     * When DB is available, loads from DB via getModelsData; otherwise returns from cache.
-     * With waitForReady, waits for each model to be ready (idle, with any properties from Model.create
-     * created) and leaves out models that error or time out. Takes no holds: a caller that keeps a
-     * model uses `Model.find` or `Model.create`.
-     */
-    static async all(schemaName, options) {
-        const { waitForReady = false, readyTimeout = DEFAULT_READY_TIMEOUT_MS } = options ?? {};
-        const appDb = BaseDb.getAppDb();
-        if (!appDb) {
-            const instances = [];
-            const seen = new Set();
-            if (schemaName !== undefined && schemaName !== '') {
-                for (const [nameKey, id] of this.instanceCacheByName.entries()) {
-                    const [cachedSchemaName] = nameKey.split(':');
-                    if (cachedSchemaName === schemaName) {
-                        const instance = this.peek(id);
-                        if (instance && !seen.has(id)) {
-                            instances.push(instance);
-                            seen.add(id);
-                        }
-                    }
-                }
-                for (const [nameKey, entry] of this.instanceCache.entries()) {
-                    const [cachedSchemaName] = nameKey.split(':');
-                    if (cachedSchemaName === schemaName) {
-                        const context = entry.instance._getSnapshotContext();
-                        const id = context.id;
-                        if (id && !seen.has(id)) {
-                            instances.push(entry.instance);
-                            seen.add(id);
-                        }
-                    }
-                }
-            }
-            else {
-                for (const [id, entry] of this.instanceCacheById.entries()) {
-                    if (!seen.has(id)) {
-                        instances.push(entry.instance);
-                        seen.add(id);
-                    }
-                }
-                for (const entry of this.instanceCache.values()) {
-                    const context = entry.instance._getSnapshotContext();
-                    const id = context.id;
-                    if (id && !seen.has(id)) {
-                        instances.push(entry.instance);
-                        seen.add(id);
-                    }
-                }
-            }
-            return instances;
-        }
-        const rows = await getModelsData(schemaName);
-        const instances = [];
-        const seen = new Set();
-        for (const row of rows) {
-            // A model can appear more than once (e.g. duplicate model_schemas links); return it once.
-            if (row.schemaFileId && !seen.has(row.schemaFileId)) {
-                const instance = await this.createById(row.schemaFileId, { hold: false });
-                if (instance && !seen.has(instance.id ?? row.schemaFileId)) {
-                    instances.push(instance);
-                    seen.add(instance.id ?? row.schemaFileId);
-                }
-            }
-        }
-        // Merge in any instances from cache for this schema (e.g. just-created model not yet visible in DB read).
-        if (schemaName !== undefined && schemaName !== '') {
-            for (const [nameKey, id] of this.instanceCacheByName.entries()) {
-                const [cachedSchemaName] = nameKey.split(':');
-                if (cachedSchemaName === schemaName && id && !seen.has(id)) {
-                    const instance = this.peek(id);
-                    if (instance) {
-                        instances.push(instance);
-                        seen.add(id);
-                    }
-                }
-            }
-            for (const [nameKey, entry] of this.instanceCache.entries()) {
-                const [cachedSchemaName] = nameKey.split(':');
-                if (cachedSchemaName === schemaName) {
-                    const context = entry.instance._getSnapshotContext();
-                    const id = context.id;
-                    if (id && !seen.has(id)) {
-                        instances.push(entry.instance);
-                        seen.add(id);
-                    }
-                }
-            }
-        }
-        if (waitForReady && instances.length > 0) {
-            // Leave out models that errored or didn't get ready in time. Don't re-read their state afterwards:
-            // a ready model can already be validating again, and it still belongs in the result.
-            const ready = await Promise.all(instances.map((m) => this.waitUntilReady(m, readyTimeout).then(() => true, (error) => {
-                logger(`Model.all: leaving out a model that isn't ready: ${error instanceof Error ? error.message : String(error)}`);
-                return false;
-            })));
-            return instances.filter((_, i) => ready[i]);
-        }
-        return instances;
-    }
-    /**
-     * Update name index when model name changes
-     */
-    static updateNameIndex(oldName, newName, schemaName, modelFileId) {
-        const oldKey = `${schemaName}:${oldName}`;
-        const newKey = `${schemaName}:${newName}`;
-        // Update name index
-        if (this.instanceCacheByName.has(oldKey)) {
-            this.instanceCacheByName.delete(oldKey);
-        }
-        this.instanceCacheByName.set(newKey, modelFileId);
-        // Also update legacy cache if it exists
-        if (this.instanceCache.has(oldKey)) {
-            const entry = this.instanceCache.get(oldKey);
-            this.instanceCache.delete(oldKey);
-            this.instanceCache.set(newKey, entry);
-        }
-        logger(`Model.updateNameIndex: Updated name mapping from "${oldName}" to "${newName}" (ID: ${modelFileId})`);
-    }
-    getService() {
-        return this._service;
-    }
-    _getSnapshot() {
-        return this._service.getSnapshot();
-    }
-    _getSnapshotContext() {
-        return this._getSnapshot().context;
-    }
-    /**
-     * 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 by id (schemaFileId) - most reliable lookup
-            const dbModels = await db
-                .select()
-                .from(models)
-                .where(eq(models.schemaFileId, context.id)) // id is now the schemaFileId (string)
-                .limit(1);
-            if (dbModels.length === 0) {
-                return { hasConflict: false }; // No DB record, no conflict
-            }
-            // Check if DB was updated after we loaded
-            // Note: models table doesn't have updatedAt, so we can't do timestamp comparison
-            // For now, we'll just check if the record exists and matches
-            // In the future, if models table gets updatedAt, we can compare timestamps
-            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
-        }
-    }
-    /**
-     * Saves model name changes to the database immediately (draft save)
-     * This is called when modelName is changed to persist the change immediately
-     * @param oldName - The old model name (if name changed)
-     * @param newName - The new model name
-     */
-    async _saveDraftToDb(oldName, newName) {
-        saveDraftLogger(`_saveDraftToDb called for model (oldName: "${oldName}", newName: "${newName}")`);
-        // Don't save during initialization - models 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 = Model.cachedClientInitialized === null || (now - Model.clientCheckTime) > Model.CLIENT_CHECK_CACHE_MS;
-            const shouldRecheck = cacheIsStale || Model.cachedClientInitialized === false;
-            saveDraftLogger(`Client check: cacheIsStale=${cacheIsStale}, shouldRecheck=${shouldRecheck}, cachedValue=${Model.cachedClientInitialized}, timeSinceCheck=${now - Model.clientCheckTime}ms`);
-            if (shouldRecheck) {
-                try {
-                    // Use dynamic import for browser compatibility (require() doesn't work in browsers)
-                    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
-                    Model.cachedClientInitialized = isIdle && (isInitialized !== false);
-                    Model.clientCheckTime = now;
-                    saveDraftLogger(`Client state checked: state=${clientSnapshot.value}, isIdle=${isIdle}, isInitialized=${isInitialized}, result=${Model.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
-                    Model.cachedClientInitialized = false;
-                    Model.clientCheckTime = now;
-                    saveDraftLogger(`Error checking client state: ${error instanceof Error ? error.message : String(error)}, setting cachedClientInitialized=false`);
-                }
-            }
-            else {
-                saveDraftLogger(`Using cached client state: cachedClientInitialized=${Model.cachedClientInitialized}`);
-            }
-            if (!Model.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 model and try again.';
-            saveDraftLogger(`CONFLICT DETECTED: ${errorMessage}`);
-            throw new ConflictError(errorMessage, conflictCheck);
-        }
-        const context = this._getSnapshotContext();
-        const modelFileId = context.id || ''; // id is now the schemaFileId (string)
-        const modelName = newName || context.modelName || oldName || '';
-        // Use modelFileId as the key if available, otherwise use schemaName:modelName
-        const saveKey = modelFileId || `${context.schemaName}:${modelName}`;
-        // Prevent concurrent saves for the same model
-        if (Model.savingModels.has(saveKey)) {
-            saveDraftLogger(`Model ${modelName} (key: ${saveKey}) is already being saved, skipping concurrent save`);
-            return;
-        }
-        Model.savingModels.add(saveKey);
-        saveDraftLogger(`Starting save for model ${modelName} (key: ${saveKey}, id: ${modelFileId})`);
-        try {
-            const db = BaseDb.getAppDb();
-            if (!db) {
-                throw new Error('Database not found');
-            }
-            // If name changed, use renameModelInDb
-            if (oldName && newName && oldName !== newName) {
-                saveDraftLogger(`Renaming model from "${oldName}" to "${newName}"`);
-                await renameModelInDb(oldName, newName, context.schemaName);
-                saveDraftLogger(`Successfully renamed model from "${oldName}" to "${newName}"`);
-            }
-            else {
-                // For other tracked properties, we would save here
-                // Currently only modelName is saved immediately, so this is a no-op
-                saveDraftLogger(`No name change detected, skipping save (modelName: "${modelName}")`);
-            }
-            // Update conflict detection metadata after successful save
-            // Note: models table doesn't have updatedAt, so we use current timestamp
-            const now = Date.now();
-            this._service.send({
-                type: 'updateContext',
-                _dbUpdatedAt: now,
-            });
-        }
-        catch (error) {
-            logger(`Failed to save draft to database: ${error instanceof Error ? error.message : String(error)}`);
-            // Don't throw - allow operation to continue
-        }
-        finally {
-            // Always remove from saving set
-            Model.savingModels.delete(saveKey);
-            saveDraftLogger(`Finished save for model ${modelName} (key: ${saveKey})`);
-        }
-    }
-    get status() {
-        return this._getSnapshot().value;
-    }
-    /** The error from the last draft save a rename started, or undefined once a later one succeeds. */
-    get lastSaveError() {
-        return getDraftSaveError(this._service);
-    }
-    get validationErrors() {
-        return this._getSnapshotContext()._validationErrors || [];
-    }
-    get isValid() {
-        const errors = this.validationErrors;
-        return errors.length === 0;
-    }
-    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 id() {
-        return this._getSnapshotContext().id; // id is now the schemaFileId (string)
-    }
-    get name() {
-        return this._getSnapshotContext().modelName;
-    }
-    /**
-     * Returns ModelProperty instances for this model
-     * This is a computed property that reads from the service context
-     * Note: This is NOT reactive - use useModelProperties() hook for reactivity
-     */
-    get properties() {
-        const snapshot = this._service.getSnapshot();
-        const context = snapshot.context;
-        // Get property IDs from liveQuery (stored in context, not instanceState)
-        const liveQueryIds = context._liveQueryPropertyIds || [];
-        // Get _dbId from context for pending writes lookup
-        const dbId = context._dbId; // _dbId is the database integer ID
-        // Get pending property IDs (synchronous - uses static Map)
-        // Lazy import ModelProperty to avoid circular dependency
-        const ModelProperty = getModelProperty();
-        if (!ModelProperty) {
-            // If ModelProperty is not yet loaded, return empty array
-            // It will be available on subsequent accesses after the async import completes
-            return [];
-        }
-        const pendingIds = dbId ? ModelProperty.getPendingPropertyIds(dbId) : [];
-        // Combine and deduplicate
-        const allPropertyIds = [...new Set([...liveQueryIds, ...pendingIds])];
-        // Get ModelProperty instances from static cache (synchronous)
-        const propertyInstances = [];
-        for (const propertyFileId of allPropertyIds) {
-            const property = ModelProperty.getById(propertyFileId);
-            if (property) {
-                propertyInstances.push(property);
-            }
-            // Note: Cannot create properties asynchronously in this synchronous getter
-            // Properties will be created elsewhere when needed
-        }
-        // Return a new array reference (snapshot at time of access)
-        return [...propertyInstances];
-    }
-    /**
-     * Validate the model
-     * @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: 'validateModel' });
-            // 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);
-        });
-    }
-    /**
-     * Create a new item instance from this model
-     * Automatically injects the model name, so you don't need to pass it explicitly.
-     *
-     * @example
-     * const Post = Model.create('Post', schema)
-     * const post = await Post.create({ title: 'My Post', content: '...' })
-     *
-     * @param values - Item property values (modelName is automatically injected)
-     * @returns The created item instance
-     */
-    async create(values) {
-        if (!this.modelName) {
-            throw new Error('Cannot create item: model name is not set on this Model instance');
-        }
-        const item = await Item.create({
-            modelName: this.modelName,
-            schemaName: this.schemaName,
-            modelInstance: this,
-            ...values,
-        });
-        return item;
-    }
-    /**
-     * Reload model from database
-     * This refreshes the actor context with the latest data from the database
-     */
-    async reload() {
-        logger(`Reloading model ${this.modelName} from database`);
-        // Send reload event to machine (which will trigger loadOrCreateModel)
-        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 model 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 model from database'));
-                }
-            });
-        });
-    }
-    /**
-     * Force-evict every cached Model belonging to a schema, ignoring refCounts, and stop their services.
-     * Used by Schema.destroy(): once the DB rows are gone, cached instances would keep a dangling _dbId
-     * and be handed back by Model.create/Model.all after the schema is re-imported.
-     * @returns names of the evicted models (so callers can evict their ModelProperty instances)
-     */
-    static evictForSchema(schemaName) {
-        // Work already running for this schema's models must not re-cache them when it finishes.
-        recordSchemaEviction(schemaName);
-        const instances = new Set();
-        for (const { instance } of this.instanceCacheById.values())
-            instances.add(instance);
-        for (const { instance } of this.instanceCache.values())
-            instances.add(instance);
-        const evictedNames = [];
-        for (const instance of instances) {
-            let context;
-            try {
-                context = instance._getSnapshotContext();
-            }
-            catch {
-                continue;
-            }
-            if (context.schemaName !== schemaName)
-                continue;
-            const nameKey = `${context.schemaName}:${context.modelName}`;
-            if (context.id)
-                this.schemaHeldModelIds.delete(context.id);
-            clearDestroySubscriptions(instance, { instanceState: modelInstanceState });
-            forceRemoveFromCaches(instance, {
-                getCacheKeys: () => (context.id ? [context.id, nameKey] : [nameKey]),
-                caches: [
-                    Model.instanceCacheById,
-                    Model.instanceCacheByName,
-                    Model.instanceCache,
-                ],
-            });
-            try {
-                instance._service.stop();
-            }
-            catch {
-                // Service might already be stopped
-            }
-            if (context.modelName)
-                evictedNames.push(context.modelName);
-        }
-        return evictedNames;
-    }
-    /**
-     * Unload the model instance and clean up resources
-     */
-    unload() {
-        try {
-            const context = this._getSnapshotContext();
-            const modelFileId = context.id; // id is now the schemaFileId (string)
-            const nameKey = `${context.schemaName}:${context.modelName}`;
-            const cacheKeys = [];
-            if (modelFileId) {
-                cacheKeys.push(modelFileId);
-            }
-            cacheKeys.push(nameKey);
-            unloadEntity(this, {
-                getCacheKeys: () => cacheKeys,
-                caches: [Model.instanceCacheById, Model.instanceCache],
-                secondaryCaches: [Model.instanceCacheByName],
-                instanceState: modelInstanceState,
-                getService: (instance) => instance._service,
-            });
-        }
-        catch (error) {
-            logger(`Error during unload: ${error instanceof Error ? error.message : String(error)}`);
-            // Still try to stop service
-            try {
-                this._service.stop();
-            }
-            catch {
-                // Service might already be stopped
-            }
-        }
-    }
-    /**
-     * Destroy the model instance completely: remove from caches, delete from database,
-     * update Schema context, stop service. Uses shared destroy helpers.
-     */
-    async destroy() {
-        const context = this._getSnapshotContext();
-        const modelFileId = context.id;
-        const modelName = context.modelName;
-        const schemaName = context.schemaName;
-        const nameKey = schemaName && modelName ? `${schemaName}:${modelName}` : '';
-        clearDestroySubscriptions(this, { instanceState: modelInstanceState });
-        // Before the caches are cleared, so a lookup by id already reading the row doesn't re-cache it
-        if (modelFileId)
-            recordModelDestroy(modelFileId);
-        if (modelFileId)
-            Model.schemaHeldModelIds.delete(modelFileId);
-        const cacheKeys = [];
-        if (modelFileId)
-            cacheKeys.push(modelFileId);
-        if (nameKey)
-            cacheKeys.push(nameKey);
-        forceRemoveFromCaches(this, {
-            getCacheKeys: () => cacheKeys,
-            caches: [
-                Model.instanceCacheById,
-                Model.instanceCacheByName,
-                Model.instanceCache,
-            ],
-        });
-        const destroying = runDestroyLifecycle(this, {
-            getService: (instance) => instance._service,
-            doDestroy: async () => {
-                const db = BaseDb.getAppDb();
-                if (db && modelFileId) {
-                    const drizzleMod = await import('drizzle-orm');
-                    const { eq } = drizzleMod;
-                    const modelRecords = await db
-                        .select()
-                        .from(models)
-                        .where(eq(models.schemaFileId, modelFileId))
-                        .limit(1);
-                    if (modelRecords.length > 0) {
-                        const modelId = modelRecords[0].id;
-                        const { detachModelRows } = await import('./detachRowsBeforeDelete-DXFYSHRR.js');
-                        await detachModelRows(db, [typeof modelId === 'string' ? parseInt(modelId, 10) : modelId]);
-                        await db.delete(modelSchemas).where(eq(modelSchemas.modelId, modelId));
-                        await db
-                            .delete(properties)
-                            .where(eq(properties.modelId, typeof modelId === 'string' ? parseInt(modelId, 10) : modelId));
-                        await db.delete(models).where(eq(models.id, modelId));
-                    }
-                }
-                if (schemaName && modelName) {
-                    // Imported here, not at module load: Model and Schema import each other.
-                    const _mod_11 = await import('./Schema-PFZwG9Nl.js');
-                    const _ns_11 = _mod_11.a;
-                    const { Schema } = _ns_11;
-                    const schema = Schema.create(schemaName, { waitForReady: false, hold: false });
-                    const schemaContext = schema.getService().getSnapshot().context;
-                    if (schemaContext.models?.[modelName]) {
-                        const updatedModels = { ...schemaContext.models };
-                        delete updatedModels[modelName];
-                        schema.getService().send({ type: 'updateContext', models: updatedModels });
-                        schema.getService().send({ type: 'markAsDraft', propertyKey: `model:${modelName}` });
-                        await new Promise((resolve) => setTimeout(resolve, 100));
-                    }
-                }
-            },
-        });
-        try {
-            await destroying;
-        }
-        finally {
-            if (modelFileId)
-                finishModelDestroy(modelFileId);
-        }
-    }
-    /**
-     * Set up liveQuery subscription to watch for property changes in the database
-     * This enables cross-instance synchronization (e.g., changes in other tabs/windows)
-     */
-    _setupLiveQuerySubscription() {
-        setupEntityLiveQuery(this, {
-            getEntityId: async (model) => {
-                const context = model._getSnapshotContext();
-                let dbId = context._dbId; // _dbId is the database integer ID
-                const modelName = context.modelName;
-                if (!modelName) {
-                    return undefined;
-                }
-                // If we don't have _dbId yet, try to find it in the database
-                if (!dbId) {
-                    try {
-                        const db = BaseDb.getAppDb();
-                        if (!db) {
-                            return undefined;
-                        }
-                        // Model names are only unique per schema: find this model's row by its id (schemaFileId).
-                        const _mod_12 = await import('./index-Dx_GTdyQ.js');
-                        const _ns_12 = _mod_12.be;
-                        const { resolveModelRecord } = _ns_12;
-                        const modelRecord = await resolveModelRecord(modelName, { modelFileId: context.id, schemaName: context.schemaName }, db);
-                        if (!modelRecord?.id) {
-                            return undefined;
-                        }
-                        // Until this model's own row is written, the lookup falls back to the name and can find a
-                        // same-named model in another schema. Taking that row would load its properties into this
-                        // model; wait for the row with this model's id instead (the caller retries).
-                        if (context.id && modelRecord.schemaFileId !== context.id) {
-                            return undefined;
-                        }
-                        dbId = modelRecord.id;
-                        // Update context with _dbId (unless the model was stopped while the lookup ran)
-                        if (isActorStopped(model._service))
-                            return undefined;
-                        model._service.send({
-                            type: 'updateContext',
-                            _dbId: dbId,
-                        });
-                    }
-                    catch (error) {
-                        logger(`[Model._setupLiveQuerySubscription] Error finding model: ${error}`);
-                        return undefined;
-                    }
-                }
-                return dbId;
-            },
-            buildQuery: async (modelId) => {
-                return BaseDb.liveQuery((sql) => sql `
-            SELECT id, name, data_type as dataType, model_id as modelId, ref_model_id as refModelId, ref_value_type as refValueType, schema_file_id as schemaFileId
-            FROM properties
-            WHERE model_id = ${modelId}
-          `);
-            },
-            extractEntityIds: (rows) => rows
-                .map(row => row.schemaFileId)
-                .filter((id) => id !== null && id !== undefined),
-            updateContext: (model, ids) => {
-                model._service.send({
-                    type: 'updateContext',
-                    _liveQueryPropertyIds: ids, // Store in service context for reactivity
-                    _propertiesUpdated: Date.now(), // Internal field for tracking
-                });
-            },
-            createChildInstances: async (ids) => {
-                await modelPropertyImportPromise;
-                const ModelProperty = getModelProperty();
-                if (!ModelProperty) {
-                    logger('[Model._setupLiveQuerySubscription] ModelProperty not yet loaded');
-                    return;
-                }
-                const createPromises = ids.map(async (propertyFileId) => {
-                    try {
-                        await ModelProperty.createById(propertyFileId);
-                    }
-                    catch (error) {
-                        logger(`[Model._setupLiveQuerySubscription] Error creating ModelProperty instance for propertyFileId "${propertyFileId}": ${error}`);
-                    }
-                });
-                await Promise.all(createPromises);
-            },
-            queryInitialData: async (modelId) => {
-                const db = BaseDb.getAppDb();
-                if (!db) {
-                    return [];
-                }
-                const initialProperties = await db
-                    .select({ schemaFileId: properties.schemaFileId })
-                    .from(properties)
-                    .where(eq(properties.modelId, typeof modelId === 'string' ? parseInt(modelId, 10) : modelId));
-                return initialProperties.map((row) => ({
-                    schemaFileId: row.schemaFileId,
-                }));
-            },
-            // The model writes from its writeProcess child while itself idle; wait for that write to end.
-            canRetryEntityId: (model) => {
-                const writeProcess = model._getSnapshotContext().writeProcess;
-                const writeState = writeProcess?.getSnapshot().value;
-                return writeState !== 'validating' && writeState !== 'writing';
-            },
-            instanceState: modelInstanceState,
-            loggerName: 'seedSdk:model:liveQuery',
-        });
-    }
-    /**
-     * Refresh property IDs from database (useful in Node.js where liveQuery isn't available)
-     */
-    async _refreshPropertiesFromDb() {
-        const snapshot = this._service.getSnapshot();
-        const dbId = snapshot.context._dbId; // _dbId is the database integer ID
-        const modelName = snapshot.context.modelName;
-        if (!dbId || !modelName) {
-            return;
-        }
-        try {
-            const db = BaseDb.getAppDb();
-            if (!db) {
-                return;
-            }
-            const propertyRows = await db
-                .select({ schemaFileId: properties.schemaFileId })
-                .from(properties)
-                .where(eq(properties.modelId, dbId)); // Use _dbId (database integer ID)
-            // Stopped while querying: don't re-cache ModelProperty instances for an evicted/unloaded model
-            if (isActorStopped(this._service))
-                return;
-            const propertyIds = propertyRows
-                .map((row) => row.schemaFileId)
-                .filter((id) => id !== null && id !== undefined);
-            // CRITICAL: Create ModelProperty instances BEFORE updating context
-            // This ensures they're in the cache when the properties getter is called
-            if (propertyIds.length > 0) {
-                try {
-                    await modelPropertyImportPromise;
-                    const ModelProperty = getModelProperty();
-                    if (!ModelProperty) {
-                        logger('[Model._refreshPropertiesFromDb] ModelProperty not yet loaded');
-                    }
-                    else {
-                        const createPromises = propertyIds.map(async (propertyFileId) => {
-                            try {
-                                const property = await ModelProperty.createById(propertyFileId);
-                                if (property) {
-                                    logger(`[Model._refreshPropertiesFromDb] Created/cached ModelProperty instance for propertyFileId "${propertyFileId}"`);
-                                }
-                                else {
-                                    logger(`[Model._refreshPropertiesFromDb] ModelProperty.createById returned undefined for propertyFileId "${propertyFileId}"`);
-                                }
-                            }
-                            catch (error) {
-                                logger(`[Model._refreshPropertiesFromDb] Error creating ModelProperty instance for propertyFileId "${propertyFileId}": ${error}`);
-                            }
-                        });
-                        await Promise.all(createPromises);
-                    }
-                }
-                catch (error) {
-                    logger(`[Model._refreshPropertiesFromDb] Error importing ModelProperty or creating instances: ${error}`);
-                }
-            }
-            // Update context with refreshed property IDs AFTER creating instances (the awaits above can
-            // outlive the instance)
-            if (isActorStopped(this._service))
-                return;
-            this._service.send({
-                type: 'updateContext',
-                _liveQueryPropertyIds: propertyIds,
-                _propertiesUpdated: Date.now(),
-            });
-        }
-        catch (error) {
-            logger(`[Model._refreshPropertiesFromDb] Error refreshing properties: ${error}`);
-        }
-    }
-    /**
-     * Public method to refresh properties from database
-     */
-    async refreshProperties() {
-        await this._refreshPropertiesFromDb();
-    }
-    /**
-     * Refresh the property ids of every cached Model whose DB row is `dbId`. Called when a property
-     * write for that model finishes: until then `properties` includes it as a pending write, and in Node
-     * (no reactive liveQuery) nothing else adds it to `_liveQueryPropertyIds`.
-     */
-    static async refreshPropertiesForDbId(dbId) {
-        const instances = new Set();
-        for (const { instance } of this.instanceCacheById.values())
-            instances.add(instance);
-        for (const { instance } of this.instanceCache.values())
-            instances.add(instance);
-        for (const instance of instances) {
-            let context;
-            try {
-                context = instance._getSnapshotContext();
-            }
-            catch {
-                continue;
-            }
-            if (context._dbId !== dbId)
-                continue;
-            await instance._refreshPropertiesFromDb();
-        }
-    }
-}
-// Primary cache: ID-based (never changes on rename)
-Model.instanceCacheById = new Map();
-// Secondary index: name lookup (updated on rename)
-Model.instanceCacheByName = new Map();
-// Legacy cache: kept temporarily for backward compatibility during migration
-Model.instanceCache = new Map();
-// Static tracking for pending writes
-Model.pendingWrites = new Map();
-// Track which models are currently being saved to prevent concurrent saves
-Model.savingModels = new Set();
-// Cache client initialization state globally to avoid repeated checks
-Model.cachedClientInitialized = null;
-Model.clientCheckTime = 0;
-Model.CLIENT_CHECK_CACHE_MS = 50; // Cache for 50ms to avoid excessive checks
-/**
- * Models their schema holds, by modelFileId. A schema's first load of a model takes one hold for
- * the schema, and the schema's last unload releases it (releaseSchemaHolds), so a user's unload
- * can't drop a model out of `schema.models` while the schema is loaded.
- */
-Model.schemaHeldModelIds = new Set();
-
-var Model$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    Model: Model
-});
-
-// Export the Model class
-const TModelValues = Type.Record(Type.String(), Type.Any());
-const TModelSchema = Type.Record(Type.String(), TProperty);
-
-/**
- * Thrown by Item.create when values don't fit the model: unknown keys, wrong types, or values
- * that break the property's validation rules. Nothing is left written: most values are checked
- * before anything is written, and File/Image/Html/ItemStorage values, checked as they're saved,
- * have their draft removed.
- */
-class ItemCreateValidationError extends Error {
-    constructor(modelName, problems) {
-        super(`Cannot create ${modelName}: ` + problems.map((p) => `${p.property}: ${p.message}`).join('; '));
-        this.name = 'ItemCreateValidationError';
-        this.modelName = modelName;
-        this.problems = problems;
-        Object.setPrototypeOf(this, ItemCreateValidationError.prototype);
-    }
-}
-/**
- * Thrown by Item.create when a File/Image/Html/ItemStorage value couldn't be saved for a reason
- * other than its rules (those throw ItemCreateValidationError). The draft is removed, as for
- * ItemCreateValidationError. `cause` holds the save's own error, e.g. an OwnershipError.
- */
-class ItemCreateError extends Error {
-    constructor(message, details) {
-        super(message, details.cause === undefined ? undefined : { cause: details.cause });
-        this.name = 'ItemCreateError';
-        this.code = details.code;
-        this.modelName = details.modelName;
-        this.property = details.property;
-        this.seedLocalId = details.seedLocalId;
-        Object.setPrototypeOf(this, ItemCreateError.prototype);
-    }
-}
-/** Thrown by Item.create when no model with that name exists (in the given schema, if any). */
-class UnknownModelError extends Error {
-    constructor(modelName, schemaName) {
-        super(`Model "${modelName}" not found${schemaName ? ` in schema "${schemaName}"` : ''}.`);
-        this.name = 'UnknownModelError';
-        this.modelName = modelName;
-        this.schemaName = schemaName;
-        Object.setPrototypeOf(this, UnknownModelError.prototype);
-    }
-}
-
-var errors = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ItemCreateError: ItemCreateError,
-    ItemCreateValidationError: ItemCreateValidationError,
-    UnknownModelError: UnknownModelError
-});
-
-export { ConflictError as C, ItemCreateValidationError as I, Model as M, TModelSchema as T, UnknownModelError as U, TModelValues as a, anyEvictionSince as b, currentEvictionEpoch as c, ItemCreateError as d, setupEntityLiveQuery as e, finishSchemaDestroy as f, getDraftSaveError as g, writeToDatabase$1 as h, Model$1 as i, errors as j, recordSchemaDestroy as r, schemaEvictedSince as s, trackDraftSave as t, writeProcessMachine as w };
-//# sourceMappingURL=errors-D1zHAqjr.js.map