@seedprotocol/sdk 0.6.6 → 0.6.7

package/dist/index-BFpbtEsg.js

@@ -0,0 +1,3492 @@
+import { fromCallback, fromPromise, setup, assign, createActor } from 'xstate';
+import { a as BaseDb, m as models, p as properties, G as isInternalSchema, i as modelSchemas, s as schemas } from './BasePathResolver-qV0apdVY.js';
+import { eq, or } from 'drizzle-orm';
+import { C as ClientManagerState, d as TProperty } from './constants-DSqHBPNe.js';
+import debug from 'debug';
+import { generateId } from './generateId-BopUwD8F.js';
+import { w as writeModelToDb, k as writePropertyToDb, l as addSchemaToDb, r as renameModelInDb } from './db-CceyWksv.js';
+import { w as waitForEntityIdle, a8 as getInvariantSafePropertyDescriptor, m as findEntity, B as getClient, I as Item, a9 as unloadEntity, aa as clearDestroySubscriptions, n as forceRemoveFromCaches, o as runDestroyLifecycle } from './ClientManager-Y5EWQuJj.js';
+import { modelPropertiesToObject } from './model-DGMe-TTm.js';
+import { toSnakeCase } from 'drizzle-orm/casing';
+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-DuB5nk6A.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 } }) => {
+    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) {
+                    const dbModels = await db
+                        .select()
+                        .from(models)
+                        .where(eq(models.name, modelName))
+                        .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.
+                        if (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) {
+                        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_0 = await import('./Schema-BYM-GNdE.js');
+            const _ns_0 = _mod_0.b;
+            const schemaMod = _ns_0;
+            const { Schema } = schemaMod;
+            const schema = Schema.create(schemaName, { waitForReady: 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_1 = await import('./BasePathResolver-qV0apdVY.js');
+                        const _ns_1 = _mod_1.N;
+                        const modelSchemaSchemaMod = _ns_1;
+                        const { modelSchemas } = modelSchemaSchemaMod;
+                        const _mod_2 = await import('./BasePathResolver-qV0apdVY.js');
+                        const _ns_2 = _mod_2.L;
+                        const schemaSchemaMod = _ns_2;
+                        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_3 = await import('./Schema-BYM-GNdE.js');
+            const _ns_3 = _mod_3.b;
+            const schemaMod = _ns_3;
+            const { Schema } = schemaMod;
+            const schema = Schema.create(schemaName, { waitForReady: 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 } }) => {
+    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-Dr6nmwPm.js');
+            const { SchemaValidationService } = validationServiceMod;
+            const validationService = new SchemaValidationService();
+            const _mod_4 = await import('./Schema-BYM-GNdE.js');
+            const _ns_4 = _mod_4.b;
+            const schemaMod = _ns_4;
+            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
+            if (context.schemaName) {
+                try {
+                    const schema = Schema.create(context.schemaName, {
+                        waitForReady: 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 }) => {
+    const _createProperties = async () => {
+        const { context, propertyDefinitions } = input;
+        const { id, _dbId, modelName } = 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-DuB5nk6A.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 { eq } = drizzleMod;
+        const db = BaseDb.getAppDb();
+        for (const [propName, propData] of Object.entries(propertyDefinitions)) {
+            // Use provided ID or generate a random one
+            // IDs should be generated in the import process before creating properties
+            const { generateId } = await import('./generateId-BopUwD8F.js');
+            const propertyFileId = propData.id || 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
+                    const propertyRecords = await db
+                        .select()
+                        .from(properties)
+                        .where(eq(properties.schemaFileId, propertyFileId))
+                        .limit(1);
+                    if (propertyRecords.length > 0 && propertyRecords[0].refModelId) {
+                        refModelId = propertyRecords[0].refModelId;
+                        logger$5(`Found refModelId ${refModelId} from database for property "${propName}"`);
+                    }
+                    else if (refModelName) {
+                        // Fallback: query models table directly by name
+                        const refModelRecords = await db
+                            .select()
+                            .from(models)
+                            .where(eq(models.name, refModelName))
+                            .limit(1);
+                        if (refModelRecords.length > 0 && refModelRecords[0].id) {
+                            refModelId = refModelRecords[0].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
+                }
+            }
+            // 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
+            await ModelProperty.create({
+                name: propName,
+                modelName,
+                modelId: _dbId,
+                dataType: propData.dataType,
+                ref: propData.ref,
+                refModelName: propData.refModelName,
+                refModelId,
+                refValueType: propData.refValueType,
+                storageType: propData.storageType,
+                localStorageDir: propData.localStorageDir,
+                filenameSuffix: propData.filenameSuffix,
+                required: propData.required,
+                _propertyFileId: propertyFileId, // Store schemaFileId for getById() lookups
+            }); // Use 'as any' because _propertyFileId is not in TProperty type
+        }
+        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)
+    };
+});
+
+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;
+    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-Dr6nmwPm.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 _mod_5 = await import('./Schema-BYM-GNdE.js');
+                            const _ns_5 = _mod_5.b;
+                            const schemaMod = _ns_5;
+                            const { Schema } = schemaMod;
+                            const schema = Schema.create(entityInput.entityData.schemaName, {
+                                waitForReady: false,
+                            });
+                            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-Dr6nmwPm.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 _mod_6 = await import('./Schema-BYM-GNdE.js');
+                            const _ns_6 = _mod_6.b;
+                            const schemaMod = _ns_6;
+                            const { Schema } = schemaMod;
+                            const schema = Schema.create(entityInput.entityData._schemaName, {
+                                waitForReady: false,
+                            });
+                            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
+                        }
+                    }
+                }
+            }
+            else if (entityInput.entityType === 'schema') {
+                // Schema validation - use existing validation
+                const validationServiceMod = await import('./SchemaValidationService-Dr6nmwPm.js');
+                const { SchemaValidationService } = validationServiceMod;
+                const validationService = new SchemaValidationService();
+                const schemaResult = validationService.validateSchema(entityInput.entityData);
+                if (!schemaResult.isValid) {
+                    result = {
+                        isValid: false,
+                        errors: schemaResult.errors,
+                    };
+                }
+            }
+            // 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();
+    // @ts-ignore - XState v5 type inference bug: fromPromise incorrectly expects output type to match input type
+});
+
+const logger$3 = debug('seedSdk:write:writeToDatabase');
+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-DuB5nk6A.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,
+                            };
+                        }
+                    }
+                }
+                catch (_) {
+                    // Fall back to input.entityData if instance not available
+                }
+                await writePropertyToDb(input.entityId, dataToWrite);
+                output = input.entityData;
+            }
+            else if (input.entityType === 'schema') {
+                const schemaRecord = await addSchemaToDb(input.entityData, input.entityId, // schemaFileId (string)
+                input.entityData.schemaData, input.entityData.isDraft);
+                output = { ...input.entityData, _dbId: schemaRecord.id }; // Store as _dbId (database integer ID)
+            }
+            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)),
+            });
+        }
+    };
+    _write().catch((error) => {
+        logger$3('Error in writeToDatabase promise:', error);
+        sendBack({
+            type: 'writeError',
+            error: error instanceof Error ? error : new Error(String(error)),
+        });
+    });
+    return () => {
+        // Cleanup function (optional)
+    };
+});
+
+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: [],
+        writeStatus: 'idle',
+        error: null,
+        retryCount: 0,
+        pendingWrite: null,
+    }),
+    states: {
+        idle: {
+            on: {
+                startWrite: {
+                    target: 'validating',
+                    actions: [
+                        assign({
+                            pendingWrite: ({ event }) => ({
+                                data: event.data,
+                                timestamp: Date.now(),
+                            }),
+                            writeStatus: 'validating',
+                        }),
+                        ({ 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: [],
+                                writeStatus: 'writing',
+                            }),
+                            ({ 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 || [];
+                                },
+                                writeStatus: 'error',
+                                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)),
+                            writeStatus: '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
+                        },
+                    ],
+                },
+            },
+            on: {
+                reset: 'idle',
+            },
+        },
+        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({
+                            writeStatus: 'success',
+                            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)),
+                            writeStatus: 'error',
+                            retryCount: ({ context }) => context.retryCount + 1,
+                        }),
+                        ({ context, event }) => {
+                            logger$2(`[writing] Write error for ${context.entityType} "${context.entityId}":`, event.error);
+                        },
+                    ],
+                },
+                reset: 'idle',
+            },
+        },
+        success: {
+            after: {
+                2000: { target: 'idle' }, // Auto-reset after 2s
+            },
+            on: {
+                reset: 'idle',
+            },
+            entry: assign({
+                writeStatus: 'success',
+            }),
+        },
+        error: {
+            on: {
+                retry: {
+                    target: 'validating',
+                    guard: ({ context }) => context.retryCount < 3,
+                    actions: assign({
+                        error: null,
+                    }),
+                },
+                revert: {
+                    target: 'idle',
+                    actions: assign({
+                        pendingWrite: null,
+                        writeStatus: 'idle',
+                        error: null,
+                    }),
+                },
+                reset: 'idle',
+            },
+        },
+    },
+});
+
+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;
+        },
+        hasValidationErrors: ({ 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
+                    ({ context, event, self }) => {
+                        if (event._liveQueryPropertyIds !== undefined) {
+                            const newPropertyIds = event._liveQueryPropertyIds;
+                            // Use setTimeout to check after assign has been applied
+                            setTimeout(() => {
+                                self.getSnapshot();
+                                // 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-DuB5nk6A.js').then(({ ModelProperty }) => {
+                                        const createPromises = newPropertyIds.map(async (propertyFileId) => {
+                                            try {
+                                                const property = await ModelProperty.createById(propertyFileId);
+                                                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, event }) => ({
+                ...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({ _destroyInProgress: true, _destroyError: null }),
+        },
+        destroyDone: {
+            actions: assign({ _destroyInProgress: false }),
+        },
+        destroyError: {
+            actions: assign(({ event }) => ({
+                _destroyInProgress: false,
+                _destroyError: event.error instanceof Error
+                    ? { message: event.error.message, name: event.error.name }
+                    : { message: String(event.error) },
+            })),
+        },
+        clearDestroyError: {
+            actions: assign({ _destroyError: null }),
+        },
+    },
+    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: ({ self }) => {
+                        // 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;
+                        }),
+                    },
+                ],
+            },
+            always: {
+                guard: 'hasValidationErrors',
+                target: 'validating',
+            },
+        },
+        validating: {
+            on: {
+                validationSuccess: {
+                    target: 'idle',
+                    actions: assign(({ context, event }) => ({
+                        ...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,
+                            };
+                        }),
+                        ({ context, self }) => {
+                            // Trigger property refresh after properties are created
+                            // This ensures _liveQueryPropertyIds is updated in Node.js where liveQuery isn't available
+                            setTimeout(() => {
+                                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
+                    if (config.createChildInstances) {
+                        await config.createChildInstances(initialIds);
+                    }
+                    // Update context with initial IDs
+                    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;
+                }
+                // 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)
+                        if (config.createChildInstances && ids.length > 0) {
+                            await config.createChildInstances(ids);
+                        }
+                        // Update context with new IDs
+                        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
+        }
+    };
+    // Set up liveQuery subscription as soon as we have entity ID
+    const setupSubscription = instance.getService().subscribe(async (snapshot) => {
+        // Check if entity is ready
+        if (config.isReady && !config.isReady(instance)) {
+            if (config.waitForReady) {
+                await config.waitForReady(instance);
+            }
+            else {
+                return; // Not ready yet, will retry on next snapshot
+            }
+        }
+        // Get entity ID
+        const entityId = await config.getEntityId(instance);
+        if (!entityId) {
+            return; // Need entity ID to proceed
+        }
+        // Once we have entity ID, set up the liveQuery subscription (only once)
+        if (!setupState.subscriptionSetUp) {
+            await setupLiveQuery(entityId);
+            if (setupState.subscriptionSetUp) {
+                setupSubscription.unsubscribe();
+            }
+        }
+    });
+    // Also check current state immediately in case entity ID is already available
+    instance.getService().getSnapshot();
+    if (config.isReady && !config.isReady(instance)) {
+        // Not ready yet, will be handled by subscription
+        return;
+    }
+    config.getEntityId(instance).then((entityId) => {
+        if (entityId && !setupState.subscriptionSetUp) {
+            setupLiveQuery(entityId).catch((error) => {
+                logger(`Error in immediate setup: ${error}`);
+            });
+        }
+    }).catch((error) => {
+        logger(`Error getting entity ID: ${error}`);
+    });
+}
+
+/**
+ * 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;
+};
+
+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-DuB5nk6A.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;
+}
+// Lazy import cache for Schema to avoid circular dependency
+let SchemaClass = null;
+const schemaImportPromise = (async () => { const _mod_7 = await import('./Schema-BYM-GNdE.js'); return _mod_7.b; })()
+    .then(module => {
+    SchemaClass = module.Schema;
+    return SchemaClass;
+})
+    .catch(() => {
+    // If import fails, SchemaClass remains null
+    return null;
+});
+// WeakMap to store mutable state per Model instance
+// This avoids issues with read-only properties when instances are frozen by Immer
+const modelInstanceState = 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()
+    }
+    /**
+     * 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, modelFileId] of this.instanceCacheByName.entries()) {
+            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);
+                    }
+                }
+            }
+        }
+        // Also check schema context models (case-insensitive)
+        // This ensures runtime-created models are renamed if they conflict with schema-defined models
+        try {
+            // Use lazy-loaded Schema class to avoid circular dependency
+            if (SchemaClass) {
+                const schema = SchemaClass.create(schemaName);
+                const schemaContext = schema.getService().getSnapshot().context;
+                if (schemaContext.models) {
+                    for (const schemaModelName of Object.keys(schemaContext.models)) {
+                        const lowerSchemaModelName = schemaModelName.toLowerCase();
+                        // If it matches the base name (case-insensitive), check if it has a number suffix
+                        if (lowerSchemaModelName === lowerModelName) {
+                            existingNumbers.add(0); // Base name exists in schema
+                        }
+                        else if (lowerSchemaModelName.startsWith(lowerModelName + ' ')) {
+                            // Check if it's the base name followed by a space and a number
+                            const suffix = lowerSchemaModelName.slice(lowerModelName.length + 1);
+                            const number = parseInt(suffix, 10);
+                            if (!isNaN(number) && suffix === number.toString()) {
+                                existingNumbers.add(number);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // If schema check fails, continue with cache-only check
+            // This is a best-effort check and shouldn't block model creation
+        }
+        // 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
+        // Start from 1 if base name exists, otherwise check if we can use 1
+        let nextNumber = existingNumbers.has(0) ? 1 : 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 ?? 5000;
+        // 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)
+        if (id && this.instanceCacheById.has(id)) {
+            const { instance, refCount } = this.instanceCacheById.get(id);
+            this.instanceCacheById.set(id, {
+                instance,
+                refCount: refCount + 1,
+            });
+            logger(`Model.create: Found instance in ID cache for "${modelName}" (ID: ${id})`);
+            if (!waitForReady)
+                return instance;
+            return waitForEntityIdle(instance, { timeout: readyTimeout }).then(() => instance);
+        }
+        // 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, refCount } = 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}`;
+            if (this.instanceCache.has(legacyKey)) {
+                const { instance, refCount } = this.instanceCache.get(legacyKey);
+                const ctx = instance._getSnapshotContext();
+                if (!ctx._idFromSchema) {
+                    this.instanceCache.set(legacyKey, {
+                        instance,
+                        refCount: refCount + 1,
+                    });
+                    logger(`Model.create: Found instance in legacy cache for "${modelName}"`);
+                    const existingId = instance._getSnapshotContext().id;
+                    if (existingId) {
+                        this.instanceCacheById.set(existingId, { instance, refCount: refCount + 1 });
+                        this.instanceCacheByName.set(legacyKey, existingId);
+                    }
+                    if (!waitForReady)
+                        return instance;
+                    return waitForEntityIdle(instance, { timeout: readyTimeout }).then(() => instance);
+                }
+            }
+        }
+        // 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)) {
+            const { instance, refCount } = this.instanceCache.get(nameKey);
+            this.instanceCache.set(nameKey, {
+                instance,
+                refCount: refCount + 1,
+            });
+            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, { instance, refCount: refCount + 1 });
+                this.instanceCacheByName.set(nameKey, existingId);
+            }
+            if (!waitForReady)
+                return instance;
+            return waitForEntityIdle(instance, { timeout: readyTimeout }).then(() => instance);
+        }
+        // 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}"`);
+        }
+        // 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
+        // Create a custom proxy that handles 'name' as an alias for 'modelName'
+        const proxiedInstance = new Proxy(newInstance, {
+            get(target, prop) {
+                // Handle special properties
+                if (prop === '_service') {
+                    return Reflect.get(target, prop);
+                }
+                // Handle 'name' as an alias for 'modelName'
+                if (prop === 'name') {
+                    const context = target._getSnapshotContext();
+                    return context.modelName;
+                }
+                // Handle 'id' property - returns the schemaFileId (string)
+                if (prop === 'id') {
+                    const context = target._getSnapshotContext();
+                    return context.id; // id is now the schemaFileId (string)
+                }
+                // Handle tracked properties
+                if (typeof prop === 'string' && TRACKED_PROPERTIES.includes(prop)) {
+                    const context = target._getSnapshotContext();
+                    return context[prop];
+                }
+                // Handle 'properties' getter - not tracked, but accessible via getter
+                if (typeof prop === 'string' && prop === 'properties') {
+                    // Delegate to the getter method on the instance
+                    return target.properties;
+                }
+                // For methods and other properties, use Reflect
+                return Reflect.get(target, prop);
+            },
+            set(target, prop, value) {
+                // Handle special properties
+                if (prop === '_service') {
+                    return Reflect.set(target, prop, value);
+                }
+                // Handle 'name' as an alias for 'modelName'
+                if (prop === 'name') {
+                    prop = 'modelName';
+                }
+                // Handle tracked properties
+                if (typeof prop === 'string' && TRACKED_PROPERTIES.includes(prop)) {
+                    // Use the sendUpdate logic
+                    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 true;
+                        }
+                        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
+                        target._saveDraftToDb(oldName, newName).catch((error) => {
+                            logger(`Failed to save draft to database: ${error instanceof Error ? error.message : String(error)}`);
+                        });
+                        // NOTE: Schema is not notified of model name changes during edits.
+                        // Schema will read from Model instances when persisting/saving.
+                    }
+                    else if (prop === 'properties') {
+                        // Properties are read-only computed values from ModelProperty instances
+                        // Cannot be set directly - properties are managed via ModelProperty instances
+                        throw new Error('Cannot set model.properties directly. Properties are computed from ModelProperty instances.');
+                    }
+                    else 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.');
+                    }
+                    else {
+                        // Standard property update
+                        target._service.send({
+                            type: 'updateContext',
+                            [prop]: value,
+                        });
+                    }
+                    return true;
+                }
+                // For non-tracked properties, use Reflect
+                return Reflect.set(target, prop, value);
+            },
+            has(target, prop) {
+                // Handle 'name' as an alias for 'modelName'
+                if (prop === 'name') {
+                    return true;
+                }
+                // Handle 'id' property
+                if (prop === 'id') {
+                    return true;
+                }
+                // Check tracked properties
+                if (typeof prop === 'string' && TRACKED_PROPERTIES.includes(prop)) {
+                    const context = target._getSnapshotContext();
+                    return prop in context;
+                }
+                return Reflect.has(target, prop);
+            },
+            ownKeys(target) {
+                // Include 'name' and 'id' in ownKeys
+                const keys = Reflect.ownKeys(target);
+                const additionalKeys = [];
+                if (!keys.includes('name')) {
+                    additionalKeys.push('name');
+                }
+                if (!keys.includes('id')) {
+                    additionalKeys.push('id');
+                }
+                return additionalKeys.length > 0 ? [...keys, ...additionalKeys] : keys;
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                // Handle 'name' as an alias for 'modelName'
+                if (prop === 'name') {
+                    return getInvariantSafePropertyDescriptor(target, prop, {
+                        value: target._getSnapshotContext().modelName,
+                    });
+                }
+                // Handle 'id' property - returns the modelFileId
+                if (prop === 'id') {
+                    return getInvariantSafePropertyDescriptor(target, prop, {
+                        value: target._getSnapshotContext().id, // id is now the schemaFileId (string)
+                        writable: false, // id is read-only
+                    });
+                }
+                let invent;
+                if (typeof prop === 'string' && TRACKED_PROPERTIES.includes(prop)) {
+                    const context = target._getSnapshotContext();
+                    if (prop in context) {
+                        invent = { value: context[prop] };
+                    }
+                }
+                return getInvariantSafePropertyDescriptor(target, prop, invent);
+            },
+        });
+        // Step 8: Store in new ID-based cache
+        // resolvedId is guaranteed to be defined at this point (generated if not provided)
+        this.instanceCacheById.set(resolvedId, {
+            instance: proxiedInstance,
+            refCount: 1,
+        });
+        // 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, {
+            instance: proxiedInstance,
+            refCount: 1,
+        });
+        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 shouldTriggerWrite = (registerWithSchema && schemaInstance) ||
+            (options?.properties && Object.keys(options.properties).length > 0) ||
+            typeof schemaNameOrSchema === 'string';
+        if (shouldTriggerWrite) {
+            queueMicrotask(async () => {
+                try {
+                    // Wait for model to reach idle state (validation complete)
+                    await new Promise((resolve) => {
+                        const subscription = proxiedInstance._service.subscribe((snapshot) => {
+                            // Wait for idle state (validation complete) or error state
+                            if (snapshot.value === 'idle' || snapshot.value === 'error') {
+                                subscription.unsubscribe();
+                                resolve();
+                            }
+                        });
+                        // Timeout after 10 seconds
+                        setTimeout(() => {
+                            subscription.unsubscribe();
+                            resolve();
+                        }, 10000);
+                    });
+                    // 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',
+                            });
+                        }
+                        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.`);
+                            }
+                            // Track pending write
+                            Model.trackPendingWrite(finalSnapshot.context.id, schemaId); // id is now the schemaFileId (string)
+                            // 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 () => {
+                                const currentSnapshot = proxiedInstance._service.getSnapshot();
+                                if (currentSnapshot.context.writeProcess) {
+                                    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);
+                                            }
+                                        });
+                                    }
+                                    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}"`);
+                                }
+                            };
+                            // 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})`);
+                        }
+                    }
+                    else {
+                        logger(`Model validation failed or model in error state, skipping write process`);
+                    }
+                }
+                catch (error) {
+                    logger(`Failed to trigger write process: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            });
+        }
+        if (!waitForReady)
+            return proxiedInstance;
+        return waitForEntityIdle(proxiedInstance, { timeout: readyTimeout }).then(() => proxiedInstance);
+    }
+    /**
+     * Get Model instance by modelFileId (O(1) lookup)
+     */
+    static getById(modelFileId) {
+        const entry = this.instanceCacheById.get(modelFileId);
+        if (entry) {
+            // Increment ref count
+            this.instanceCacheById.set(modelFileId, {
+                instance: entry.instance,
+                refCount: entry.refCount + 1,
+            });
+            return entry.instance;
+        }
+        return undefined;
+    }
+    /**
+     * Get Model instance by name (O(1) lookup via name→ID mapping)
+     *
+     * @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) {
+        if (schemaName) {
+            const nameKey = `${schemaName}:${modelName}`;
+            const id = this.instanceCacheByName.get(nameKey);
+            if (!id) {
+                return undefined;
+            }
+            return this.getById(id);
+        }
+        // If schemaName not provided, try to find in cache by searching all name keys
+        for (const [nameKey, id] of this.instanceCacheByName.entries()) {
+            const [, cachedModelName] = nameKey.split(':');
+            if (cachedModelName === modelName) {
+                return this.getById(id);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Find Model by modelType (snake_case from DB/metadata).
+     * Handles model names with spaces: "new_model" -> finds "New model" (toSnakeCase("New model") === "new_model").
+     */
+    static findByModelType(modelType) {
+        if (!modelType)
+            return undefined;
+        for (const [nameKey, id] of this.instanceCacheByName.entries()) {
+            const parts = nameKey.split(':', 2);
+            const cachedModelName = parts[1];
+            if (cachedModelName && toSnakeCase(cachedModelName) === modelType) {
+                return this.getById(id);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Get all Model instances for a schema from cache only (synchronous).
+     * 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.getById(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;
+    }
+    /**
+     * 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
+     */
+    static async getByNameAsync(modelName, schemaName) {
+        // First try cache
+        const cached = 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;
+            }
+            try {
+                // Query model by name
+                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.name, modelName))
+                    .limit(1);
+                if (modelRecords.length === 0) {
+                    return undefined;
+                }
+                const record = modelRecords[0];
+                if (!record.modelName || !record.schemaName || !record.modelFileId) {
+                    return undefined;
+                }
+                // Create model instance (will be cached)
+                return this.create(record.modelName, record.schemaName, {
+                    id: record.modelFileId, // id is now the schemaFileId (string)
+                });
+            }
+            catch (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) {
+        if (!modelFileId) {
+            return undefined;
+        }
+        // Step 1: Check cache first (fast path)
+        const cached = 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;
+        }
+        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;
+            }
+            // 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)
+            });
+        }
+        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 = 5000, }) {
+        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 [];
+        }
+        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;
+                }
+                // 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.
+     * Supports waitForReady to wait for each model to reach idle state before returning.
+     */
+    static async all(schemaName, options) {
+        const { waitForReady = false, readyTimeout = 5000 } = 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.getById(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 [nameKey, entry] of this.instanceCache.entries()) {
+                    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) {
+            if (row.schemaFileId) {
+                const instance = await this.createById(row.schemaFileId);
+                if (instance) {
+                    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.getById(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) {
+            await Promise.all(instances.map((m) => waitForEntityIdle(m, {
+                timeout: readyTimeout,
+                throwOnError: false,
+            })));
+            return instances.filter((m) => m._getSnapshot?.().value === 'idle');
+        }
+        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
+            }
+            const dbRecord = dbModels[0];
+            // 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;
+    }
+    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) => {
+            const subscription = this._service.subscribe((snapshot) => {
+                if (snapshot.value === 'idle') {
+                    subscription.unsubscribe();
+                    resolve();
+                }
+                else if (snapshot.value === 'error') {
+                    subscription.unsubscribe();
+                    reject(new Error('Failed to reload model from database'));
+                }
+            });
+            // Timeout after 10 seconds
+            setTimeout(() => {
+                subscription.unsubscribe();
+                reject(new Error('Timeout waiting for model reload'));
+            }, 10000);
+        });
+    }
+    /**
+     * 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 });
+        const cacheKeys = [];
+        if (modelFileId)
+            cacheKeys.push(modelFileId);
+        if (nameKey)
+            cacheKeys.push(nameKey);
+        forceRemoveFromCaches(this, {
+            getCacheKeys: () => cacheKeys,
+            caches: [
+                Model.instanceCacheById,
+                Model.instanceCacheByName,
+                Model.instanceCache,
+            ],
+        });
+        await 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;
+                        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) {
+                    const Schema = await schemaImportPromise;
+                    if (!Schema)
+                        throw new Error('Schema not loaded');
+                    const schema = Schema.create(schemaName, { waitForReady: 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));
+                    }
+                }
+            },
+        });
+    }
+    /**
+     * 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;
+                        }
+                        const modelRecords = await db
+                            .select()
+                            .from(models)
+                            .where(eq(models.name, modelName))
+                            .limit(1);
+                        if (modelRecords.length === 0 || !modelRecords[0].id) {
+                            return undefined;
+                        }
+                        dbId = modelRecords[0].id;
+                        // Update context with _dbId
+                        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,
+                }));
+            },
+            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)
+            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
+            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();
+    }
+}
+// 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
+
+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);
+
+export { ConflictError as C, Model as M, TModelSchema as T, TModelValues as a, Model$1 as b, setupEntityLiveQuery as s, writeProcessMachine as w };
+//# sourceMappingURL=index-BFpbtEsg.js.map