@seedprotocol/sdk 0.7.3-next.654.g52217f6 → 0.7.3

package/dist/cjs/ModelProperty-DXZ39Wyv.js

@@ -1,1978 +0,0 @@
-'use strict';
-
-var xstate = require('xstate');
-require('reflect-metadata');
-var main_cjs = require('./index-C4XlgCJ4.js');
-require('pluralize');
-var drizzleOrm = require('drizzle-orm');
-var debug = require('debug');
-var Schema = require('./Schema-DdP109QD.js');
-require('immer');
-require('drizzle-orm/sqlite-core');
-require('@seedprotocol/arweave');
-require('@seedprotocol/eas');
-require('@sinclair/typebox');
-require('drizzle-orm/casing');
-require('lodash-es');
-require('@noble/hashes/sha256');
-require('@noble/hashes/sha3');
-require('@noble/hashes/utils');
-require('nanoid');
-require('nanoid-dictionary');
-require('@seedprotocol/query');
-require('rxjs');
-require('fs/promises');
-require('fs');
-require('path');
-require('url');
-require('node:url');
-require('@libsql/client');
-require('drizzle-orm/libsql');
-require('drizzle-orm/libsql/migrator');
-require('js-yaml');
-require('child_process');
-require('@seedprotocol/arweave/node');
-require('@seedprotocol/eas/node');
-require('./SchemaValidationService-CSXxx7sQ.js');
-require('@sinclair/typebox/value');
-
-const logger$3 = debug('seedSdk:modelProperty:actors:saveToSchema');
-/**
- * Get schema name from model
- * This function finds which schema contains the given model
- * Exported so it can be reused by ModelProperty for setting schema name
- */
-async function getSchemaNameFromModel(modelName) {
-    // Get the latest schema files and find which one contains this model
-    const schemaHelpersMod = await Promise.resolve().then(function () { return require('./index-C4XlgCJ4.js'); }).then(function (n) { return n.schema$1; });
-    const { listLatestSchemaFiles } = schemaHelpersMod;
-    const latestSchemas = await listLatestSchemaFiles();
-    for (const schema of latestSchemas) {
-        try {
-            const fileManagerMod = await Promise.resolve().then(function () { return require('./index-C4XlgCJ4.js'); }).then(function (n) { return n.BaseFileManager$1; });
-            const { BaseFileManager } = fileManagerMod;
-            const content = await BaseFileManager.readFileAsString(schema.filePath);
-            const schemaFile = JSON.parse(content);
-            if (schemaFile.models && schemaFile.models[modelName]) {
-                return schema.name;
-            }
-        }
-        catch (error) {
-            logger$3('Error reading schema file:', error);
-            continue;
-        }
-    }
-    return undefined;
-}
-const saveToSchema = xstate.fromCallback(({ sendBack, input: { context }, self }) => {
-    const _saveToSchema = async () => {
-        // Use dynamic import to break circular dependency
-        const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-CSXxx7sQ.js'); });
-        const { SchemaValidationService } = validationServiceMod;
-        const validationService = new SchemaValidationService();
-        // Validate property structure before saving
-        const validationResult = validationService.validatePropertyStructure(context);
-        if (!validationResult.isValid) {
-            throw new Error(`Property validation failed: ${validationResult.errors.map(e => e.message).join(', ')}`);
-        }
-        // Validate required fields
-        if (!context.name) {
-            throw new Error('Property name is required');
-        }
-        if (!context.dataType) {
-            throw new Error('Data type is required');
-        }
-        if (!context.modelName) {
-            throw new Error(`Model not found for modelId: ${context.modelId}`);
-        }
-        // Persist to database only - schema file is updated only when user calls Schema.saveNewVersion()
-        const dbMod = await Promise.resolve().then(function () { return require('./index-C4XlgCJ4.js'); }).then(function (n) { return n.db; });
-        const { savePropertyToDb } = dbMod;
-        await savePropertyToDb(context);
-        // Mark schema as draft so user knows to save
-        const schemaName = context._schemaName ?? (await getSchemaNameFromModel(context.modelName));
-        if (schemaName) {
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-DdP109QD.js'); });
-            const { Schema } = schemaMod;
-            // Stopped meanwhile (unloaded, or evicted with its schema): don't load the schema again
-            if (main_cjs.isActorStopped(self))
-                return;
-            const schema = Schema.create(schemaName, { waitForReady: false });
-            schema.getService().send({
-                type: 'markAsDraft',
-                propertyKey: `${context.modelName}:${context.name}`,
-            });
-        }
-        logger$3(`Successfully saved property ${context.modelName}:${context.name} to database`);
-    };
-    _saveToSchema().then(() => {
-        sendBack({ type: 'saveToSchemaSuccess' });
-    }).catch((error) => {
-        logger$3('Error saving to schema:', error);
-        sendBack({ type: 'saveToSchemaError', error });
-    });
-    return () => {
-        // Cleanup function (optional)
-    };
-});
-
-const logger$2 = debug('seedSdk:modelProperty:actors:compareAndMarkDraft');
-const compareAndMarkDraft = xstate.fromCallback(({ sendBack, input: { context }, self }) => {
-    const _compareAndMarkDraft = async () => {
-        // Fill modelName/dataType from _originalValues when missing, then from DB by schemaFileId
-        let fullContext = {
-            ...context,
-            modelName: context.modelName ?? context._originalValues?.modelName,
-            dataType: context.dataType ?? context._originalValues?.dataType,
-        };
-        const schemaFileIdForResolve = fullContext._propertyFileId || (typeof fullContext.id === 'string' ? fullContext.id : undefined);
-        if (schemaFileIdForResolve && (fullContext.modelName === undefined || fullContext.dataType === undefined)) {
-            try {
-                const dbMod = await Promise.resolve().then(function () { return require('./index-C4XlgCJ4.js'); }).then(function (n) { return n.db; });
-                const { getPropertyModelNameAndDataType, getModelNameByModelId } = dbMod;
-                let fromDb;
-                for (let attempt = 0; attempt < 6; attempt++) {
-                    fromDb = await getPropertyModelNameAndDataType(schemaFileIdForResolve);
-                    if (fromDb)
-                        break;
-                    if (attempt < 5)
-                        await new Promise((r) => setTimeout(r, 40));
-                }
-                if (fromDb) {
-                    fullContext = {
-                        ...fullContext,
-                        modelName: fullContext.modelName ?? fromDb.modelName,
-                        dataType: fullContext.dataType ?? fromDb.dataType,
-                    };
-                }
-                if (fullContext.modelName === undefined && schemaFileIdForResolve) {
-                    const mod = await Promise.resolve().then(function () { return ModelProperty$1; });
-                    const ModelProperty = mod?.ModelProperty ?? mod?.default;
-                    const pendingModelId = ModelProperty?.getPendingModelId?.(schemaFileIdForResolve);
-                    if (pendingModelId != null) {
-                        const modelName = await getModelNameByModelId(pendingModelId);
-                        if (modelName) {
-                            fullContext = { ...fullContext, modelName };
-                        }
-                    }
-                }
-            }
-            catch {
-                // ignore
-            }
-        }
-        const schemaFileId = fullContext._propertyFileId || (typeof fullContext.id === 'string' ? fullContext.id : undefined);
-        // If _originalValues is not set, we still need to save to database if the property exists
-        // This handles the case where the name is changed before _originalValues is initialized
-        if (!fullContext._originalValues) {
-            logger$2('No original values to compare against');
-            logger$2(`[compareAndMarkDraft] Context: modelName=${fullContext.modelName}, name=${fullContext.name}, id=${fullContext.id}, _propertyFileId=${fullContext._propertyFileId}`);
-            // If we have a name and modelName, try to save to database anyway
-            // This ensures name changes are persisted even if _originalValues isn't initialized yet
-            // We need either schemaFileId (id or _propertyFileId) to find the property in the database
-            if (fullContext.modelName && fullContext.name && schemaFileId) {
-                logger$2(`[compareAndMarkDraft] _originalValues not set, but saving to database anyway for property ${context.modelName}:${context.name} (schemaFileId: ${schemaFileId})`);
-                try {
-                    const dbMod = await Promise.resolve().then(function () { return require('./index-C4XlgCJ4.js'); }).then(function (n) { return n.db; });
-                    const { savePropertyToDb } = dbMod;
-                    // Ensure _propertyFileId is set for savePropertyToDb to find the property
-                    const contextWithFileId = {
-                        ...fullContext,
-                        _propertyFileId: schemaFileId,
-                    };
-                    await savePropertyToDb(contextWithFileId);
-                    logger$2(`[compareAndMarkDraft] Successfully saved property ${fullContext.modelName}:${fullContext.name} to database (no _originalValues)`);
-                }
-                catch (error) {
-                    logger$2(`[compareAndMarkDraft] Error saving property to database (no _originalValues): ${error}`);
-                    // Don't throw - this is a best-effort save, but log the error for debugging
-                    console.error(`[compareAndMarkDraft] Failed to save property ${fullContext.modelName}:${fullContext.name}:`, error);
-                }
-            }
-            else {
-                logger$2(`[compareAndMarkDraft] Cannot save property ${fullContext.modelName}:${fullContext.name} - missing required fields (schemaFileId: ${schemaFileId})`);
-            }
-            return;
-        }
-        logger$2(`[compareAndMarkDraft] Comparing: context.name=${fullContext.name}, _originalValues.name=${fullContext._originalValues?.name}`);
-        // Compare current values with original
-        // Only compare property fields, not internal fields
-        const propertyFields = ['name', 'dataType', 'ref', 'refModelName', 'refModelId', 'refValueType', 'storageType', 'localStorageDir', 'filenameSuffix', 'modelName', 'modelId', 'required'];
-        const hasChanges = propertyFields.some(key => {
-            const currentValue = fullContext[key];
-            const originalValue = fullContext._originalValues?.[key];
-            // Handle name changes specifically
-            if (key === 'name') {
-                const nameChanged = currentValue !== originalValue;
-                if (nameChanged) {
-                    logger$2(`[compareAndMarkDraft] Name change detected: "${originalValue}" -> "${currentValue}"`);
-                }
-                return nameChanged;
-            }
-            // Handle ref fields - compare by name
-            if (key === 'ref' || key === 'refModelName') {
-                const currentRef = fullContext.refModelName || fullContext.ref;
-                const originalRef = fullContext._originalValues?.refModelName || fullContext._originalValues?.ref;
-                // Both undefined/null means no ref, so they're the same
-                if (!currentRef && !originalRef)
-                    return false;
-                return currentRef !== originalRef;
-            }
-            // For other fields, compare values (handling undefined/null)
-            if (currentValue === undefined && originalValue === undefined)
-                return false;
-            if (currentValue === null && originalValue === null)
-                return false;
-            if (currentValue === undefined && originalValue === null)
-                return false;
-            if (currentValue === null && originalValue === undefined)
-                return false;
-            return currentValue !== originalValue;
-        });
-        if (hasChanges) {
-            logger$2(`Property ${fullContext.modelName}:${fullContext.name} has changes, marking as edited`);
-            logger$2(`[compareAndMarkDraft] Context when saving: id=${fullContext.id}, _propertyFileId=${fullContext._propertyFileId}, name=${fullContext.name}, _originalValues.name=${fullContext._originalValues?.name}`);
-            // Use dynamic import to break circular dependency
-            const dbMod = await Promise.resolve().then(function () { return require('./index-C4XlgCJ4.js'); }).then(function (n) { return n.db; });
-            const { savePropertyToDb } = dbMod;
-            // Save to database (but not JSON file) - always save to DB when there are changes
-            try {
-                await savePropertyToDb(fullContext);
-                logger$2(`[compareAndMarkDraft] Successfully saved property ${fullContext.modelName}:${fullContext.name} to database`);
-            }
-            catch (error) {
-                logger$2(`[compareAndMarkDraft] Error saving property to database: ${error}`);
-                throw error;
-            }
-            // Mark schema as draft if schema name is available
-            if (fullContext._schemaName) {
-                // Get the Schema instance and mark it as draft
-                const schemaMod = await Promise.resolve().then(function () { return require('./Schema-DdP109QD.js'); });
-                const { Schema } = schemaMod;
-                // Stopped meanwhile (unloaded, or evicted with its schema): don't load the schema again
-                if (main_cjs.isActorStopped(self))
-                    return;
-                const schema = Schema.create(fullContext._schemaName, {
-                    waitForReady: false,
-                });
-                // Send event to Schema machine to mark as draft
-                schema.getService().send({
-                    type: 'markAsDraft',
-                    propertyKey: `${fullContext.modelName}:${fullContext.name}`,
-                });
-            }
-        }
-        else {
-            // No changes - clear edited flag in database and context
-            logger$2(`Property ${fullContext.modelName}:${fullContext.name} has no changes`);
-            // Clear isEdited flag in database
-            try {
-                const seedSchemaMod = await Promise.resolve().then(function () { return require('./index-C4XlgCJ4.js'); }).then(function (n) { return n.schema; });
-                const { properties: propertiesTable, models: modelsTable } = seedSchemaMod;
-                const drizzleMod = await import('drizzle-orm');
-                const { eq, and } = drizzleMod;
-                const db = main_cjs.BaseDb.getAppDb();
-                if (db && fullContext.modelName && fullContext.name) {
-                    // Find this property's model (model names are only unique per schema)
-                    const { resolveModelRecord } = await Promise.resolve().then(function () { return require('./index-C4XlgCJ4.js'); }).then(function (n) { return n.resolveModelRecord$1; });
-                    const modelRecord = await resolveModelRecord(fullContext.modelName, {
-                        modelId: typeof fullContext.modelId === 'number' ? fullContext.modelId : undefined,
-                        schemaName: fullContext._schemaName,
-                    }, db);
-                    const modelRecords = modelRecord ? [modelRecord] : [];
-                    if (modelRecords.length > 0) {
-                        // Find property by name and modelId
-                        const propertyRecords = await db
-                            .select({ id: propertiesTable.id })
-                            .from(propertiesTable)
-                            .where(and(eq(propertiesTable.name, fullContext.name), eq(propertiesTable.modelId, modelRecords[0].id)))
-                            .limit(1);
-                        if (propertyRecords.length > 0) {
-                            // Clear isEdited flag in database
-                            await db
-                                .update(propertiesTable)
-                                .set({ isEdited: false })
-                                .where(eq(propertiesTable.id, propertyRecords[0].id));
-                            logger$2(`Cleared isEdited flag in database for property ${fullContext.modelName}:${fullContext.name}`);
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                logger$2(`Error clearing isEdited flag in database: ${error}`);
-            }
-            sendBack({
-                type: 'clearEdited',
-            });
-        }
-    };
-    _compareAndMarkDraft().then(() => {
-        sendBack({ type: 'compareAndMarkDraftSuccess' });
-    }).catch((error) => {
-        logger$2('Error comparing and marking draft:', error);
-        sendBack({ type: 'compareAndMarkDraftError', error });
-    });
-    return () => {
-        // Cleanup function (optional)
-    };
-});
-
-const logger$1 = debug('seedSdk:modelProperty:actors:validateProperty');
-const validateProperty = xstate.fromCallback(({ sendBack, input: { context }, self }) => {
-    const _validateProperty = async () => {
-        // Use full context for validation: fill modelName/dataType from _originalValues when missing, then
-        // from DB by schemaFileId (context.id) so just-created renames don't fail structure validation.
-        let fullContext = {
-            ...context,
-            modelName: context.modelName ?? context._originalValues?.modelName,
-            dataType: context.dataType ?? context._originalValues?.dataType,
-        };
-        const schemaFileId = typeof context.id === 'string' ? context.id : undefined;
-        if (schemaFileId && (fullContext.modelName === undefined || fullContext.dataType === undefined)) {
-            // Brief wait so trackPendingWrite from ModelProperty.create() has time to run (it's in setTimeout(0))
-            await new Promise((r) => setTimeout(r, 60));
-            try {
-                const dbMod = await Promise.resolve().then(function () { return require('./index-C4XlgCJ4.js'); }).then(function (n) { return n.db; });
-                const { getPropertyModelNameAndDataType, getModelNameByModelId } = dbMod;
-                // Try pending write first (property row may not exist yet)
-                if (fullContext.modelName === undefined && schemaFileId) {
-                    const mod = await Promise.resolve().then(function () { return ModelProperty$1; });
-                    const ModelProperty = mod?.ModelProperty ?? mod?.default;
-                    const pendingModelId = ModelProperty?.getPendingModelId?.(schemaFileId);
-                    if (pendingModelId != null) {
-                        const modelName = await getModelNameByModelId(pendingModelId);
-                        if (modelName) {
-                            fullContext = { ...fullContext, modelName };
-                        }
-                    }
-                }
-                // Then DB property lookup with retry (catches row after initial write)
-                let fromDb;
-                for (let attempt = 0; attempt < 6; attempt++) {
-                    fromDb = await getPropertyModelNameAndDataType(schemaFileId);
-                    if (fromDb)
-                        break;
-                    if (attempt < 5)
-                        await new Promise((r) => setTimeout(r, 40));
-                }
-                if (fromDb) {
-                    fullContext = {
-                        ...fullContext,
-                        modelName: fullContext.modelName ?? fromDb.modelName,
-                        dataType: fullContext.dataType ?? fromDb.dataType,
-                    };
-                }
-                // If still no modelName, try pending write again (may have been set during retries)
-                if (fullContext.modelName === undefined && schemaFileId) {
-                    const mod = await Promise.resolve().then(function () { return ModelProperty$1; });
-                    const ModelProperty = mod?.ModelProperty ?? mod?.default;
-                    const pendingModelId = ModelProperty?.getPendingModelId?.(schemaFileId);
-                    if (pendingModelId != null) {
-                        const modelName = await getModelNameByModelId(pendingModelId);
-                        if (modelName) {
-                            fullContext = { ...fullContext, modelName };
-                        }
-                    }
-                }
-            }
-            catch {
-                // ignore
-            }
-        }
-        // Last resort for structure validation: TProperty requires dataType; allow name+id to pass if we have schemaFileId
-        if (fullContext.dataType === undefined && (fullContext.modelName !== undefined || schemaFileId)) {
-            fullContext = { ...fullContext, dataType: (fullContext.dataType ?? context._originalValues?.dataType) || 'Text' };
-        }
-        // Use dynamic imports to break circular dependencies
-        const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-CSXxx7sQ.js'); });
-        const { SchemaValidationService } = validationServiceMod;
-        const validationService = new SchemaValidationService();
-        const schemaMod = await Promise.resolve().then(function () { return require('./Schema-DdP109QD.js'); });
-        const { Schema } = schemaMod;
-        // Validate property structure
-        const structureResult = validationService.validatePropertyStructure(fullContext);
-        if (!structureResult.isValid) {
-            sendBack({ type: 'validationError', errors: structureResult.errors });
-            return;
-        }
-        // If we have schema name and model name, validate against schema
-        // Stopped meanwhile (unloaded, or evicted with its schema): don't load the schema again
-        if (main_cjs.isActorStopped(self))
-            return;
-        if (fullContext._schemaName && fullContext.modelName) {
-            try {
-                const schema = Schema.create(fullContext._schemaName, {
-                    waitForReady: false,
-                });
-                const schemaSnapshot = schema.getService().getSnapshot();
-                const schemaStatus = schemaSnapshot.value;
-                // Only validate against schema if it's loaded (in idle state)
-                // If still loading, skip schema validation and only do structure validation
-                if (schemaStatus === 'idle') {
-                    const schemaContext = schemaSnapshot.context;
-                    // Check if models are actually loaded
-                    if (schemaContext.models && Object.keys(schemaContext.models).length > 0) {
-                        // If property name has changed, validate against the original name (from schema file)
-                        // This handles the case where a property is renamed - the schema file still has the old name
-                        const propertyNameToValidate = fullContext._originalValues?.name && fullContext._originalValues.name !== fullContext.name
-                            ? fullContext._originalValues.name
-                            : fullContext.name || '';
-                        const schemaResult = validationService.validateProperty(schemaContext, fullContext.modelName, propertyNameToValidate, fullContext);
-                        if (!schemaResult.isValid) {
-                            // If property was renamed, some validation errors are expected (like property_not_found, missing_type)
-                            // Only fail if it's a critical error that's not related to the rename
-                            const isRenamed = fullContext._originalValues?.name && fullContext._originalValues.name !== fullContext.name;
-                            const criticalErrors = schemaResult.errors.filter(err => {
-                                // Allow property_not_found and missing_type errors when property is renamed
-                                if (isRenamed && (err.code === 'property_not_found' || err.code === 'missing_type')) {
-                                    return false; // Not critical
-                                }
-                                // For non-renamed properties, only allow property_not_found if we're validating with the same name
-                                if (err.code === 'property_not_found' && propertyNameToValidate === fullContext.name) {
-                                    return false; // Not critical
-                                }
-                                return true; // Critical error
-                            });
-                            if (criticalErrors.length > 0) {
-                                sendBack({ type: 'validationError', errors: criticalErrors });
-                                return;
-                            }
-                            // Continue with validation - rename-related errors are acceptable
-                        }
-                    }
-                    else {
-                        logger$1('Schema models not loaded yet, skipping schema validation');
-                        // Continue with structure validation only
-                    }
-                }
-                else {
-                    logger$1(`Schema is in ${schemaStatus} state, skipping schema validation`);
-                    // Continue with structure validation only
-                }
-            }
-            catch (error) {
-                logger$1('Error validating property against schema:', error);
-                // Continue with structure validation only
-            }
-        }
-        // All validations passed
-        sendBack({ type: 'validationSuccess', errors: [] });
-    };
-    _validateProperty().catch((error) => {
-        logger$1('Error in validateProperty:', error);
-        sendBack({
-            type: 'validationError',
-            errors: [{
-                    field: 'property',
-                    message: error instanceof Error ? error.message : 'Unknown validation error',
-                    code: 'validation_exception',
-                    severity: 'error',
-                }],
-        });
-    });
-    return () => {
-        // Cleanup function (optional)
-    };
-});
-
-const modelPropertyMachine = xstate.setup({
-    types: {
-        context: {},
-        input: {},
-        events: {},
-    },
-    actors: {
-        saveToSchema,
-        compareAndMarkDraft,
-        validateProperty,
-        writeProcessMachine: main_cjs.writeProcessMachine,
-    },
-    guards: {
-        isPropertyValid: ({ context }) => {
-            const valid = !context._validationErrors || context._validationErrors.length === 0;
-            return valid;
-        },
-    },
-    actions: {
-        assignValidationErrors: xstate.assign(({ context, event }) => {
-            if (event.type === 'validationError') {
-                return {
-                    ...context,
-                    _validationErrors: event.errors,
-                };
-            }
-            return context;
-        }),
-    },
-}).createMachine({
-    id: 'modelProperty',
-    initial: 'idle',
-    context: ({ input }) => {
-        const context = input;
-        return context;
-    },
-    on: {
-        updateContext: {
-            actions: xstate.assign(({ context, event }) => {
-                const newContext = Object.assign({}, 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;
-                    }
-                    let value = event[key];
-                    // Convert null to undefined for optional fields (TypeBox validation expects undefined, not null)
-                    // This is especially important for refValueType, refModelId, etc.
-                    if (value === null && (key === 'refValueType' || key === 'refModelId' || key === 'ref' || key === 'refModelName')) {
-                        value = undefined;
-                    }
-                    newContext[key] = value;
-                }
-                // Preserve modelName and dataType from context or _originalValues so validation and savePropertyToDb
-                // never run with missing required/needed fields (e.g. when a just-created property is renamed before
-                // the full context is available from the creator).
-                if (newContext.modelName === undefined && context._originalValues?.modelName !== undefined) {
-                    newContext.modelName = context._originalValues.modelName;
-                }
-                if (newContext.dataType === undefined && context._originalValues?.dataType !== undefined) {
-                    newContext.dataType = context._originalValues.dataType;
-                }
-                // Compare with original values and set _isEdited flag (only for non-internal updates)
-                if (!onlyInternalFields && context._originalValues) {
-                    const hasChanges = Object.keys(event).some((key) => {
-                        if (key === 'type' || key.startsWith('_'))
-                            return false;
-                        return newContext[key] !== context._originalValues?.[key];
-                    });
-                    newContext._isEdited = hasChanges;
-                }
-                // Clear validation errors on context update (will be re-validated if needed)
-                newContext._validationErrors = undefined;
-                // Convert null to undefined for optional fields (TypeBox validation expects undefined, not null)
-                // This is especially important for refValueType, refModelId, etc.
-                const optionalFields = ['refValueType', 'refModelId', 'ref', 'refModelName'];
-                for (const field of optionalFields) {
-                    if (newContext[field] === null) {
-                        newContext[field] = undefined;
-                    }
-                }
-                return newContext;
-            }),
-            // Only trigger validation and compareAndMarkDraft if we're updating non-internal fields
-            guard: ({ event }) => {
-                const shouldTransition = !Object.keys(event).every((key) => {
-                    return key === 'type' || key.startsWith('_');
-                });
-                return shouldTransition;
-            },
-            target: '.validating',
-        },
-        validateProperty: {
-            target: '.validating',
-        },
-        validationSuccess: {
-            actions: xstate.assign(({ context, event }) => ({
-                ...context,
-                _validationErrors: [],
-            })),
-        },
-        validationError: {
-            actions: 'assignValidationErrors',
-            // Note: State-specific transitions are handled in child states
-            // This root handler ensures errors are always assigned to context
-        },
-        initializeOriginalValues: {
-            actions: xstate.assign(({ context, event }) => ({
-                ...context,
-                _originalValues: event.originalValues,
-                // Senders don't know the schema name; keep one setSchemaName already stored.
-                _schemaName: event.schemaName ?? context._schemaName,
-                _isEdited: event.isEdited ?? false,
-                _validationErrors: undefined,
-            })),
-        },
-        clearEdited: {
-            actions: xstate.assign(({ context }) => ({
-                ...context,
-                _isEdited: false,
-                _originalValues: { ...context },
-            })),
-        },
-        setSchemaName: {
-            actions: xstate.assign(({ context, event }) => ({
-                ...context,
-                _schemaName: event.schemaName,
-            })),
-        },
-        destroyStarted: {
-            actions: xstate.assign({ _destroyError: null }),
-        },
-        destroyError: {
-            actions: xstate.assign(({ event }) => ({
-                _destroyError: event.error instanceof Error
-                    ? { message: event.error.message, name: event.error.name }
-                    : { message: String(event.error) },
-            })),
-        },
-    },
-    states: {
-        idle: {
-            on: {
-                saveToSchema: { target: 'saveToSchema' },
-                validateProperty: {
-                    target: 'validating',
-                },
-                requestWrite: {
-                    actions: ({ context, event }) => {
-                        if (context.writeProcess) {
-                            context.writeProcess.send({
-                                type: 'startWrite',
-                                data: event.data,
-                            });
-                        }
-                    },
-                },
-            },
-            entry: xstate.assign({
-                writeProcess: ({ spawn, context }) => {
-                    // Spawn writeProcess if we have id (schemaFileId)
-                    // New properties will have id generated
-                    const entityId = context.id;
-                    if (!context.writeProcess && entityId) {
-                        return spawn(main_cjs.writeProcessMachine, {
-                            input: {
-                                entityType: 'modelProperty',
-                                entityId: String(entityId),
-                                entityData: context,
-                            },
-                        });
-                    }
-                    return context.writeProcess;
-                },
-            }),
-        },
-        validating: {
-            on: {
-                saveToSchema: { target: 'saveToSchema' },
-                validationSuccess: {
-                    target: 'compareAndMarkDraft',
-                    actions: xstate.assign(({ context }) => ({
-                        ...context,
-                        _validationErrors: [],
-                    })),
-                },
-                // validationError: Uses root handler for assignment, but needs state-specific transition
-                validationError: {
-                    target: 'idle',
-                    actions: 'assignValidationErrors',
-                },
-            },
-            invoke: {
-                src: 'validateProperty',
-                input: ({ context }) => ({ context }),
-            },
-        },
-        compareAndMarkDraft: {
-            on: {
-                saveToSchema: { target: 'saveToSchema' },
-                compareAndMarkDraftSuccess: {
-                    target: 'idle',
-                },
-                compareAndMarkDraftError: {
-                    target: 'idle',
-                },
-            },
-            invoke: {
-                src: 'compareAndMarkDraft',
-                input: ({ context }) => ({ context }),
-            },
-        },
-        saveToSchema: {
-            // Gate the save in a transient child. An `always` on this parent targeting `.saving` re-enters
-            // the invoking child on every microstep and never settles (save() ran the process out of memory).
-            initial: 'checking',
-            on: {
-                // Apply updateContext but do not re-invoke saveToSchema actor (avoids infinite loop).
-                // Context is updated; in-flight save completes with original context.
-                updateContext: [
-                    {
-                        guard: ({ context, event }) => {
-                            const onlyInternal = Object.keys(event).every((k) => k === 'type' || k.startsWith('_'));
-                            return !onlyInternal && event.name !== undefined && event.name !== context.name;
-                        },
-                        actions: xstate.assign(({ context, event }) => {
-                            const newContext = Object.assign({}, context);
-                            const onlyInternalFields = Object.keys(event).every((key) => key === 'type' || key.startsWith('_'));
-                            for (const key of Object.keys(event)) {
-                                if (key === 'type')
-                                    continue;
-                                let value = event[key];
-                                if (value === null && ['refValueType', 'refModelId', 'ref', 'refModelName'].includes(key))
-                                    value = undefined;
-                                newContext[key] = value;
-                            }
-                            if (newContext.modelName === undefined && context._originalValues?.modelName !== undefined) {
-                                newContext.modelName = context._originalValues.modelName;
-                            }
-                            if (newContext.dataType === undefined && context._originalValues?.dataType !== undefined) {
-                                newContext.dataType = context._originalValues.dataType;
-                            }
-                            if (!onlyInternalFields && context._originalValues) {
-                                const hasChanges = Object.keys(event).some((key) => {
-                                    if (key === 'type' || key.startsWith('_'))
-                                        return false;
-                                    return newContext[key] !== context._originalValues?.[key];
-                                });
-                                newContext._isEdited = hasChanges;
-                            }
-                            newContext._validationErrors = undefined;
-                            return newContext;
-                        }),
-                    },
-                    {
-                        actions: xstate.assign(({ context, event }) => {
-                            const newContext = Object.assign({}, context);
-                            const onlyInternalFields = Object.keys(event).every((key) => key === 'type' || key.startsWith('_'));
-                            for (const key of Object.keys(event)) {
-                                if (key === 'type')
-                                    continue;
-                                let value = event[key];
-                                if (value === null && ['refValueType', 'refModelId', 'ref', 'refModelName'].includes(key))
-                                    value = undefined;
-                                newContext[key] = value;
-                            }
-                            if (newContext.modelName === undefined && context._originalValues?.modelName !== undefined) {
-                                newContext.modelName = context._originalValues.modelName;
-                            }
-                            if (newContext.dataType === undefined && context._originalValues?.dataType !== undefined) {
-                                newContext.dataType = context._originalValues.dataType;
-                            }
-                            if (!onlyInternalFields && context._originalValues) {
-                                const hasChanges = Object.keys(event).some((key) => {
-                                    if (key === 'type' || key.startsWith('_'))
-                                        return false;
-                                    return newContext[key] !== context._originalValues?.[key];
-                                });
-                                newContext._isEdited = hasChanges;
-                            }
-                            newContext._validationErrors = undefined;
-                            return newContext;
-                        }),
-                    },
-                ],
-                // validationError: Uses root handler for assignment, but needs state-specific transition
-                validationError: {
-                    target: 'idle',
-                    actions: 'assignValidationErrors',
-                },
-            },
-            states: {
-                checking: {
-                    always: [
-                        { guard: 'isPropertyValid', target: 'saving' },
-                        { target: '#modelProperty.idle' },
-                    ],
-                },
-                saving: {
-                    on: {
-                        saveToSchemaSuccess: {
-                            target: '#modelProperty.idle',
-                        },
-                        saveToSchemaError: {
-                            target: '#modelProperty.idle',
-                        },
-                    },
-                    invoke: {
-                        src: 'saveToSchema',
-                        input: ({ context }) => ({ context }),
-                    },
-                },
-            },
-        },
-    },
-});
-
-/**
- * Returns property rows for a model identified by modelFileId (model's schemaFileId).
- * Resolves modelFileId -> modelId via models table, then selects all properties where modelId = ?.
- * Each row includes schemaFileId for use with ModelProperty.createById(schemaFileId).
- */
-const getModelPropertiesData = async (modelFileId) => {
-    const appDb = main_cjs.BaseDb.getAppDb();
-    if (!appDb || !modelFileId) {
-        return [];
-    }
-    const modelRows = await appDb
-        .select({ id: main_cjs.models.id })
-        .from(main_cjs.models)
-        .where(drizzleOrm.eq(main_cjs.models.schemaFileId, modelFileId))
-        .limit(1);
-    if (modelRows.length === 0) {
-        return [];
-    }
-    const modelId = modelRows[0].id;
-    const rows = await appDb
-        .select()
-        .from(main_cjs.properties)
-        .where(drizzleOrm.eq(main_cjs.properties.modelId, modelId));
-    return rows;
-};
-
-const logger = debug('seedSdk:modelProperty:ModelProperty');
-// Define the property keys from TProperty
-const TPropertyKeys = [
-    'id',
-    'name',
-    'dataType',
-    'ref',
-    'modelId',
-    'refModelId',
-    'refValueType',
-    'storageType',
-    'localStorageDir',
-    'filenameSuffix',
-    'modelName',
-    'refModelName',
-];
-class ModelProperty {
-    constructor(property) {
-        /** currentEvictionEpoch() at construction: lookups started for this instance don't outlive an eviction. */
-        this._evictionEpoch = main_cjs.currentEvictionEpoch();
-        // id is now the schemaFileId (string), _dbId is the database integer ID
-        // Preserve _propertyFileId if it exists in the property object (from getPropertySchema)
-        // Convert null to undefined for optional fields (TypeBox validation expects undefined, not null)
-        const serviceInput = {
-            ...property,
-            _propertyFileId: property._propertyFileId || property.id,
-            refValueType: property.refValueType ?? undefined,
-            refModelId: property.refModelId ?? undefined,
-            ref: property.ref ?? undefined,
-            refModelName: property.refModelName ?? undefined,
-        };
-        this._service = xstate.createActor(modelPropertyMachine, {
-            input: serviceInput,
-        });
-        this._service.start();
-        // Initialize original values from the input property
-        this._initializeOriginalValues(property);
-        // Note: Property getters/setters are now handled by the Proxy in create()
-    }
-    /**
-     * Send from fire-and-forget async work (DB lookups started in the constructor), which can finish
-     * after the instance was unloaded or evicted with its schema.
-     */
-    _sendIfRunning(event) {
-        if (main_cjs.isActorStopped(this._service))
-            return;
-        this._service.send(event);
-    }
-    /**
-     * Initialize original values and schema name for tracking changes
-     * This is called asynchronously after construction
-     * If the property was loaded from the database and differs from the schema file,
-     * it will be marked as edited.
-     */
-    _initializeOriginalValues(property) {
-        // Resolve refModelId if ref/refModelName is provided but refModelId is missing
-        const refModelName = property.refModelName || property.ref;
-        if (refModelName && !property.refModelId) {
-            // Resolve refModelId asynchronously and update context
-            this._resolveRefModelId(refModelName, property).then((refModelId) => {
-                if (refModelId) {
-                    // Update the context with the resolved refModelId
-                    this._sendIfRunning({
-                        type: 'updateContext',
-                        refModelId,
-                    });
-                }
-            }).catch(() => {
-                // Ignore errors - model might not exist yet
-            });
-        }
-        // Get schema file values to use as "original" values
-        // This allows us to detect if the property was edited (DB value differs from schema file)
-        this._getSchemaFileValues(property).then((schemaFileValues) => {
-            // Use schema file values as original (not the current property values)
-            // This way, if current values differ from schema file, _isEdited will be true
-            const originalValues = schemaFileValues || {};
-            // Compare current property values with schema file values to determine if edited
-            // Only compare schema-relevant fields, not database-specific fields like id, modelId
-            let isEdited = false;
-            if (schemaFileValues) {
-                // Fields that are schema-relevant and should be compared
-                const schemaRelevantFields = [
-                    'dataType',
-                    'ref',
-                    'refModelName',
-                    'refValueType',
-                    'storageType',
-                    'localStorageDir',
-                    'filenameSuffix',
-                ];
-                // Check if any schema-relevant field differs between current property and schema file
-                isEdited = schemaRelevantFields.some((key) => {
-                    const currentValue = property[key];
-                    const originalValue = schemaFileValues[key];
-                    // Handle ref fields - compare by name
-                    if (key === 'ref' || key === 'refModelName') {
-                        const currentRef = property.refModelName || property.ref;
-                        const originalRef = schemaFileValues.refModelName || schemaFileValues.ref;
-                        // Both undefined/null means no ref, so they're the same
-                        if (!currentRef && !originalRef)
-                            return false;
-                        return currentRef !== originalRef;
-                    }
-                    // For other fields, compare values (handling undefined/null)
-                    if (currentValue === undefined && originalValue === undefined)
-                        return false;
-                    if (currentValue === null && originalValue === null)
-                        return false;
-                    if (currentValue === undefined && originalValue === null)
-                        return false;
-                    if (currentValue === null && originalValue === undefined)
-                        return false;
-                    return currentValue !== originalValue;
-                });
-            }
-            else {
-                // No schema file values found - this is a runtime-created property
-                // Use current property as original, but mark as edited since it hasn't been exported to file
-                TPropertyKeys.forEach((key) => {
-                    if (property[key] !== undefined) {
-                        originalValues[key] = property[key];
-                    }
-                });
-                // For runtime-created properties, set isEdited = true initially
-                isEdited = true;
-            }
-            // Initialize with original values, including isEdited flag
-            // Load isEdited from database if property exists in DB (async, fire-and-forget)
-            this._loadIsEditedFromDb(property, isEdited).then((isEditedFromDb) => {
-                this._sendIfRunning({
-                    type: 'initializeOriginalValues',
-                    originalValues,
-                    schemaName: undefined, // Will be set later if needed
-                    isEdited: isEditedFromDb,
-                });
-            }).catch(() => {
-                // If we can't load from DB, use computed isEdited value
-                this._sendIfRunning({
-                    type: 'initializeOriginalValues',
-                    originalValues,
-                    schemaName: undefined, // Will be set later if needed
-                    isEdited,
-                });
-            });
-        }).catch(() => {
-            // If we can't get schema file values, use current property as original
-            const originalValues = {};
-            TPropertyKeys.forEach((key) => {
-                if (property[key] !== undefined) {
-                    originalValues[key] = property[key];
-                }
-            });
-            this._sendIfRunning({
-                type: 'initializeOriginalValues',
-                originalValues,
-                schemaName: undefined,
-            });
-        });
-        // Get schema name from model asynchronously (fire-and-forget)
-        if (property.modelName) {
-            this._setSchemaName(property).catch(() => {
-                // If we can't get schema name, that's okay - it will be set later if needed
-            });
-        }
-    }
-    /**
-     * Load isEdited flag from database if property exists in DB
-     * @param property - The property data
-     * @param fallbackIsEdited - Fallback value if property doesn't exist in DB
-     * @returns The isEdited flag from database or fallback value
-     */
-    async _loadIsEditedFromDb(property, fallbackIsEdited) {
-        if (!property.modelName || !property.name) {
-            return fallbackIsEdited;
-        }
-        try {
-            const db = main_cjs.BaseDb.getAppDb();
-            if (!db) {
-                return fallbackIsEdited;
-            }
-            // Find this property's model (by modelId when known; model names are only unique per schema)
-            const { resolveModelRecord } = await Promise.resolve().then(function () { return require('./index-C4XlgCJ4.js'); }).then(function (n) { return n.resolveModelRecord$1; });
-            const modelRecord = await resolveModelRecord(property.modelName, this._ownerModelScope(property), db);
-            const modelRecords = modelRecord ? [modelRecord] : [];
-            if (modelRecords.length === 0) {
-                return fallbackIsEdited;
-            }
-            // Find property by name and modelId
-            const propertyRecords = await db
-                .select({ isEdited: main_cjs.properties.isEdited })
-                .from(main_cjs.properties)
-                .where(drizzleOrm.and(drizzleOrm.eq(main_cjs.properties.name, property.name), drizzleOrm.eq(main_cjs.properties.modelId, modelRecords[0].id)))
-                .limit(1);
-            if (propertyRecords.length > 0) {
-                return propertyRecords[0].isEdited ?? false;
-            }
-        }
-        catch (error) {
-            // Ignore errors - use fallback value
-        }
-        return fallbackIsEdited;
-    }
-    /**
-     * Resolve refModelId from refModelName by querying the database
-     * @param refModelName - The name of the referenced model
-     * @returns The database ID of the referenced model, or undefined if not found
-     */
-    async _resolveRefModelId(refModelName, property) {
-        if (!refModelName) {
-            return undefined;
-        }
-        try {
-            const db = main_cjs.BaseDb.getAppDb();
-            if (!db) {
-                return undefined;
-            }
-            // Resolve the ref within the owning model's schema
-            const { resolveRefModelRecord } = await Promise.resolve().then(function () { return require('./index-C4XlgCJ4.js'); }).then(function (n) { return n.resolveModelRecord$1; });
-            const refModelRecord = await resolveRefModelRecord(refModelName, property ? this._ownerModelScope(property) : { schemaName: this._getSnapshotContext()._schemaName }, db);
-            if (refModelRecord?.id) {
-                return refModelRecord.id;
-            }
-        }
-        catch (error) {
-            // Ignore errors - model might not exist yet or database not available
-            logger(`Error resolving refModelId for model "${refModelName}":`, error);
-        }
-        return undefined;
-    }
-    /** Which model this property belongs to: its models row id and/or schema. */
-    _ownerModelScope(property) {
-        const context = this._getSnapshotContext();
-        const modelId = property.modelId ?? context.modelId;
-        return {
-            modelId: typeof modelId === 'number' ? modelId : undefined,
-            schemaName: context._schemaName,
-        };
-    }
-    /**
-     * Get schema file values for this property to use as "original" values
-     * This allows comparison with database values to detect edits
-     */
-    async _getSchemaFileValues(property) {
-        if (!property.modelName || !property.name) {
-            return undefined;
-        }
-        try {
-            const { modelId, schemaName } = this._ownerModelScope(property);
-            // Synchronous cache hits first: callers compare against these values right after construction,
-            // so an extra await here lets every property look "edited" (a draft save each). Only then the
-            // DB (by modelId), and never instantiate a Model while its own properties are initializing.
-            let model = schemaName ? main_cjs.Model.getByName(property.modelName, schemaName) : undefined;
-            if (!model) {
-                try {
-                    model = main_cjs.Model.getByName(property.modelName);
-                }
-                catch {
-                    model = undefined; // ambiguous name; resolve by modelId below
-                }
-            }
-            if (!model && modelId) {
-                const { resolveModelRecord } = await Promise.resolve().then(function () { return require('./index-C4XlgCJ4.js'); }).then(function (n) { return n.resolveModelRecord$1; });
-                const modelFileId = (await resolveModelRecord(property.modelName, { modelId }))?.schemaFileId;
-                model = modelFileId ? main_cjs.Model.getById(modelFileId) : undefined;
-            }
-            // Evicted (with its schema) or unloaded while the lookups above ran: don't instantiate its model
-            // again from rows that are being deleted.
-            if (!model && main_cjs.isActorStopped(this._service))
-                return undefined;
-            if (!model) {
-                try {
-                    // The epoch from when this instance was built: an eviction of the model's schema since
-                    // then (this instance may already be stopped) must not re-create the model.
-                    model = await main_cjs.Model.getByNameAsync(property.modelName, undefined, {
-                        evictionEpoch: this._evictionEpoch,
-                    });
-                }
-                catch {
-                    model = undefined;
-                }
-            }
-            if (!model || !model.properties || model.properties.length === 0) {
-                return undefined;
-            }
-            const schema = main_cjs.modelPropertiesToObject(model.properties);
-            // Get the schema file value for this property
-            const schemaFileValue = schema[property.name];
-            if (!schemaFileValue) {
-                return undefined;
-            }
-            // Return schema file values as original values
-            const originalValues = {
-                name: property.name,
-                modelName: property.modelName,
-                dataType: schemaFileValue.dataType,
-                storageType: schemaFileValue.storageType,
-                localStorageDir: schemaFileValue.localStorageDir,
-                filenameSuffix: schemaFileValue.filenameSuffix,
-            };
-            // Handle ref fields
-            if (schemaFileValue.ref) {
-                originalValues.ref = schemaFileValue.ref;
-                originalValues.refModelName = schemaFileValue.ref;
-                // Try to get refModelId from database
-                const refModelId = await this._resolveRefModelId(schemaFileValue.ref, property);
-                if (refModelId) {
-                    originalValues.refModelId = refModelId;
-                }
-            }
-            if (schemaFileValue.refValueType) {
-                originalValues.refValueType = schemaFileValue.refValueType;
-            }
-            return originalValues;
-        }
-        catch (error) {
-            return undefined;
-        }
-    }
-    /**
-     * Set the schema name for this property by looking it up from the model
-     * Tries database first (more reliable), then falls back to schema files
-     */
-    async _setSchemaName(property) {
-        try {
-            // create() sets the schema name right after construction when its caller knows it. Don't look it
-            // up then: the file fallback below reads and parses every schema file, per property.
-            await Promise.resolve();
-            if (this._getSnapshotContext()._schemaName)
-                return;
-            let schemaName;
-            // From the property data: the instance's own modelId field is never assigned (the reactive proxy
-            // serves values from the machine context), so reading this.modelId skipped the DB lookup.
-            const { modelId } = this._ownerModelScope(property);
-            // Try to get schema name from database first (more reliable)
-            if (modelId) {
-                try {
-                    const db = main_cjs.BaseDb.getAppDb();
-                    if (db) {
-                        const modelSchemaRecords = await db
-                            .select({
-                            schemaName: main_cjs.schemas.name,
-                        })
-                            .from(main_cjs.modelSchemas)
-                            .innerJoin(main_cjs.schemas, drizzleOrm.eq(main_cjs.modelSchemas.schemaId, main_cjs.schemas.id))
-                            .innerJoin(main_cjs.models, drizzleOrm.eq(main_cjs.modelSchemas.modelId, main_cjs.models.id))
-                            .where(drizzleOrm.eq(main_cjs.models.id, modelId))
-                            .limit(1);
-                        if (modelSchemaRecords.length > 0) {
-                            schemaName = modelSchemaRecords[0].schemaName;
-                        }
-                    }
-                }
-                catch (error) {
-                    // Database lookup failed, continue to file-based lookup
-                }
-            }
-            // Fall back to schema file lookup if database didn't work
-            if (!schemaName) {
-                schemaName = await getSchemaNameFromModel(property.modelName);
-            }
-            if (schemaName) {
-                // Update the context with the schema name using dedicated event
-                this._sendIfRunning({
-                    type: 'setSchemaName',
-                    schemaName,
-                });
-            }
-        }
-        catch (error) {
-            // If we can't get schema name, that's okay - it will be set later if needed
-        }
-    }
-    /**
-     * Resolve schema name from DB when _schemaName is missing (e.g. destroy ran before _setSchemaName finished).
-     * Uses context.id (schemaFileId) and context.modelId to query properties → model_schemas → schemas.
-     */
-    async _resolveSchemaNameForDestroy(db, context) {
-        try {
-            let modelId = context.modelId;
-            const schemaFileId = context.id ?? context._propertyFileId;
-            // If we don't have modelId, get it from the property row by schemaFileId
-            if (modelId == null && schemaFileId) {
-                const propRows = await db
-                    .select({ modelId: main_cjs.properties.modelId })
-                    .from(main_cjs.properties)
-                    .where(drizzleOrm.eq(main_cjs.properties.schemaFileId, schemaFileId))
-                    .limit(1);
-                if (propRows.length > 0 && propRows[0].modelId != null) {
-                    modelId = propRows[0].modelId;
-                }
-            }
-            if (modelId == null)
-                return undefined;
-            // Resolve modelFileId (string) to database ID (number) if needed - modelSchemas.modelId expects number
-            const modelIdNum = typeof modelId === 'string' ? await main_cjs.getModelIdByFileId(modelId) : modelId;
-            const modelSchemaRecords = await db
-                .select({ schemaName: main_cjs.schemas.name })
-                .from(main_cjs.modelSchemas)
-                .innerJoin(main_cjs.schemas, drizzleOrm.eq(main_cjs.modelSchemas.schemaId, main_cjs.schemas.id))
-                .where(drizzleOrm.eq(main_cjs.modelSchemas.modelId, modelIdNum))
-                .limit(1);
-            return modelSchemaRecords.length > 0 ? modelSchemaRecords[0].schemaName ?? undefined : undefined;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    /**
-     * Manually set the schema name for this property
-     * Useful when you know the schema name from context (e.g., when working with Schema instances)
-     */
-    setSchemaName(schemaName) {
-        this._service.send({
-            type: 'setSchemaName',
-            schemaName,
-        });
-    }
-    static create(property, options) {
-        if (!property) {
-            throw new Error('Property is required');
-        }
-        const waitForReady = options?.waitForReady !== false;
-        const readyTimeout = options?.readyTimeout ?? 5000;
-        const schemaName = options?.schemaName;
-        // Handle 'type' field from JSON schema format - convert to 'dataType'
-        // Normalize to PascalCase so lowercase values from JSON (e.g. 'text') work
-        const propertyWithId = { ...property };
-        const rawType = propertyWithId.dataType ?? propertyWithId.type;
-        if (rawType) {
-            propertyWithId.dataType = main_cjs.normalizeDataType(rawType);
-        }
-        if (typeof propertyWithId.refValueType === 'string') {
-            propertyWithId.refValueType = main_cjs.normalizeDataType(propertyWithId.refValueType);
-        }
-        // Ensure id (schemaFileId) is set correctly
-        // Priority: _propertyFileId > id (if string) > generate new
-        // If id is a number (old format), use _propertyFileId instead
-        if (typeof propertyWithId.id === 'number') {
-            // id is a database integer ID, not schemaFileId - use _propertyFileId if available
-            if (propertyWithId._propertyFileId) {
-                propertyWithId.id = propertyWithId._propertyFileId;
-            }
-            else {
-                // Fallback: generate new schemaFileId (shouldn't happen, but safety)
-                propertyWithId.id = main_cjs.generateId();
-                logger(`ModelProperty.create: id was a number, generated new schemaFileId "${propertyWithId.id}" for property "${property.name}"`);
-            }
-        }
-        else if (!propertyWithId.id && propertyWithId._propertyFileId) {
-            // id is not set but _propertyFileId is available - use it
-            propertyWithId.id = propertyWithId._propertyFileId;
-        }
-        else if (!propertyWithId.id) {
-            // Generate id (schemaFileId) if not provided (for new properties)
-            // This ensures new properties can trigger write process
-            propertyWithId.id = main_cjs.generateId();
-            logger(`ModelProperty.create: Generated new id (schemaFileId) "${propertyWithId.id}" for property "${property.name}"`);
-        }
-        // Create cache key from modelName and name, or use id
-        let cacheKey = propertyWithId.modelName && propertyWithId.name
-            ? `${propertyWithId.modelName}:${propertyWithId.name}`
-            : propertyWithId.id
-                ? `id:${propertyWithId.id}`
-                : propertyWithId.name || 'unnamed';
-        // Model names are only unique per schema: a cached "Post:title" may be another schema's
-        // property. If the ids say it's a different property, key this one by its own id instead.
-        // (Not by file id: the same property is often created first with a generated id, then its real one.)
-        const isOtherProperty = (cachedContext) => (typeof propertyWithId.modelId === 'number' &&
-            typeof cachedContext.modelId === 'number' &&
-            cachedContext.modelId !== propertyWithId.modelId) ||
-            (!!schemaName && !!cachedContext._schemaName && cachedContext._schemaName !== schemaName);
-        const cachedByName = this.instanceCache.get(cacheKey);
-        if (cachedByName && propertyWithId.id && isOtherProperty(cachedByName.instance._getSnapshotContext())) {
-            // Reuse this property's own id-keyed entry if it already has one.
-            cacheKey = `id:${propertyWithId.id}`;
-            for (const [key, { instance }] of this.instanceCache.entries()) {
-                if (!key.startsWith('id:'))
-                    continue;
-                const ctx = instance._getSnapshotContext();
-                if (ctx.modelName === propertyWithId.modelName && ctx.name === propertyWithId.name && !isOtherProperty(ctx)) {
-                    cacheKey = key;
-                    break;
-                }
-            }
-        }
-        // Check if instance exists in cache
-        if (this.instanceCache.has(cacheKey)) {
-            const { instance, refCount } = this.instanceCache.get(cacheKey);
-            const cachedContext = instance._getSnapshotContext();
-            // Update cached instance if new property data has fields that the cached instance doesn't have
-            // This handles cases where the property was created without ref initially, but now we have ref from schema
-            const needsUpdate = {};
-            if (propertyWithId.ref && !cachedContext.ref) {
-                needsUpdate.ref = propertyWithId.ref;
-            }
-            if (propertyWithId.refModelName && !cachedContext.refModelName) {
-                needsUpdate.refModelName = propertyWithId.refModelName;
-            }
-            if (propertyWithId.refModelId && !cachedContext.refModelId) {
-                needsUpdate.refModelId = propertyWithId.refModelId;
-            }
-            if (Object.keys(needsUpdate).length > 0) {
-                instance._service.send({
-                    type: 'updateContext',
-                    ...needsUpdate,
-                });
-            }
-            this.instanceCache.set(cacheKey, {
-                instance,
-                refCount: refCount + 1,
-            });
-            if (!waitForReady)
-                return instance;
-            return main_cjs.waitForEntityIdle(instance, { timeout: readyTimeout }).then(() => instance);
-        }
-        const newInstance = new this(propertyWithId);
-        // Set schema name before async operations so getModelId can resolve the correct model
-        if (schemaName) {
-            newInstance._service.send({
-                type: 'setSchemaName',
-                schemaName,
-            });
-        }
-        // Wrap instance in Proxy for reactive property access
-        const proxiedInstance = main_cjs.createReactiveProxy({
-            instance: newInstance,
-            service: newInstance._service,
-            trackedProperties: TPropertyKeys,
-            getContext: (instance) => {
-                const context = instance._getSnapshotContext();
-                return context;
-            },
-            sendUpdate: (instance, prop, value) => {
-                const currentContext = instance._getSnapshotContext();
-                if (currentContext[prop] === value)
-                    return; // No-op, avoid triggering machine
-                instance._service.send({
-                    type: 'updateContext',
-                    [prop]: value,
-                });
-            },
-        });
-        this.instanceCache.set(cacheKey, {
-            instance: proxiedInstance,
-            refCount: 1,
-        });
-        this.indexCachedInstance(cacheKey, proxiedInstance);
-        // Trigger write process if property has modelId (or modelName) and id (schemaFileId)
-        // Wait for service to be ready (idle state) and have writeProcess spawned
-        const propertyFileId = propertyWithId.id; // id is now the schemaFileId (string)
-        const hasModelId = propertyWithId.modelId || propertyWithId.modelName;
-        // A _dbId means the data was loaded from an existing row (createById, getPropertySchema), so
-        // there's nothing to write. Writing it back anyway raced deletes of that row's model (FK error).
-        const isPersisted = typeof propertyWithId._dbId === 'number';
-        if (hasModelId && propertyFileId && !isPersisted) {
-            // 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 service = proxiedInstance.getService();
-                const snapshot = service.getSnapshot();
-                // Unloaded or evicted (e.g. Schema.destroy) before the write started: nothing to write to
-                if (main_cjs.isActorStopped(service))
-                    return;
-                if (snapshot.value === 'idle' && snapshot.context.writeProcess) {
-                    const writeProcess = snapshot.context.writeProcess;
-                    // Resolve dbModelId - convert from string (modelFileId) to number (database ID) if needed
-                    let resolvedModelId = undefined;
-                    if (propertyWithId.modelId) {
-                        if (typeof propertyWithId.modelId === 'number') {
-                            resolvedModelId = propertyWithId.modelId;
-                        }
-                        else if (typeof propertyWithId.modelId === 'string') {
-                            // modelId is a string (modelFileId), need to convert to database ID
-                            try {
-                                resolvedModelId = await main_cjs.getModelIdByFileId(propertyWithId.modelId);
-                                logger(`Converted modelFileId "${propertyWithId.modelId}" to database modelId: ${resolvedModelId}`);
-                            }
-                            catch (error) {
-                                logger(`Failed to convert modelFileId "${propertyWithId.modelId}" to database ID: ${error}`);
-                                console.error(`[ModelProperty.create] Failed to convert modelFileId: ${error}`);
-                            }
-                        }
-                    }
-                    // If we still don't have a modelId, try to resolve it from modelName
-                    if (!resolvedModelId && propertyWithId.modelName) {
-                        try {
-                            // Get schemaName from context if available
-                            const schemaName = snapshot.context._schemaName;
-                            resolvedModelId = await main_cjs.getModelId(propertyWithId.modelName, schemaName);
-                            logger(`Resolved modelId for model "${propertyWithId.modelName}": ${resolvedModelId}`);
-                        }
-                        catch (error) {
-                            logger(`Failed to resolve modelId for model "${propertyWithId.modelName}": ${error}`);
-                            console.error(`[ModelProperty.create] Failed to resolve modelId: ${error}`);
-                        }
-                    }
-                    if (!resolvedModelId) {
-                        logger(`ERROR: Cannot write property "${property.name}" - no modelId available`);
-                        console.error(`[ModelProperty.create] ERROR: Cannot write property "${property.name}" - no modelId available. modelId: ${propertyWithId.modelId}, modelName: ${propertyWithId.modelName}`);
-                        // Don't clear pending write here - it might resolve later
-                        return;
-                    }
-                    // Resolving the modelId awaited the DB; the instance may have been stopped meanwhile
-                    if (main_cjs.isActorStopped(service))
-                        return;
-                    // Track pending write now that we have the resolved modelId
-                    this.trackPendingWrite(propertyFileId, resolvedModelId);
-                    logger(`Triggering write process for property "${property.name}" (modelId: ${resolvedModelId}, propertyFileId: ${propertyFileId})`);
-                    // Check current write state
-                    const currentWriteState = writeProcess.getSnapshot();
-                    if (currentWriteState.value === 'success') {
-                        // Write already succeeded
-                        void this.completePendingWrite(propertyFileId, resolvedModelId);
-                    }
-                    else {
-                        // Set up subscription to catch future state changes
-                        const writeSubscription = writeProcess.subscribe((writeSnapshot) => {
-                            if (writeSnapshot.value === 'success') {
-                                writeSubscription.unsubscribe();
-                                logger(`[writeProcess subscription] Write succeeded for property "${property.name}" (propertyFileId: ${propertyFileId})`);
-                                void this.completePendingWrite(propertyFileId, resolvedModelId);
-                            }
-                            else if (writeSnapshot.value === 'error') {
-                                writeSubscription.unsubscribe();
-                                const errorContext = writeSnapshot.context;
-                                logger(`Write process failed for property "${property.name}" (propertyFileId: ${propertyFileId}): ${errorContext.error?.message || 'Unknown error'}`);
-                                logger(`Write process error details:`, errorContext.error);
-                                // Mark pending write as error
-                                this.clearPendingWrite(propertyFileId, 'error');
-                            }
-                        });
-                    }
-                    const propertyData = {
-                        modelId: resolvedModelId,
-                        name: property.name,
-                        dataType: property.dataType,
-                        refModelId: property.refModelId,
-                        refValueType: property.refValueType,
-                        required: property.required,
-                        storageType: property.storageType,
-                        localStorageDir: property.localStorageDir,
-                        filenameSuffix: property.filenameSuffix,
-                    };
-                    service.send({
-                        type: 'requestWrite',
-                        data: propertyData,
-                    });
-                }
-                else if (retries < maxRetries) {
-                    retries++;
-                    setTimeout(checkAndSend, 50); // Retry after 50ms
-                }
-                else {
-                    logger(`ERROR: writeProcess not available after ${maxRetries} retries for property "${property.name}" (propertyFileId: ${propertyFileId})`);
-                    console.error(`[ModelProperty.create] ERROR: writeProcess not available after ${maxRetries} retries for property "${property.name}" (propertyFileId: ${propertyFileId})`);
-                    // Mark as error if we couldn't even start the write process
-                    this.clearPendingWrite(propertyFileId, 'error');
-                }
-            };
-            // Start checking after a short delay to allow state machine to initialize
-            setTimeout(checkAndSend, 0);
-        }
-        if (!waitForReady)
-            return proxiedInstance;
-        return main_cjs.waitForEntityIdle(proxiedInstance, { timeout: readyTimeout }).then(() => proxiedInstance);
-    }
-    /** Whether an idIndex entry still points at a cached instance with that id. */
-    static isIndexEntryCurrent(propertyFileId, entry) {
-        if (this.instanceCache.get(entry.cacheKey)?.instance !== entry.instance)
-            return false;
-        try {
-            return entry.instance._getSnapshotContext().id === propertyFileId;
-        }
-        catch {
-            return false;
-        }
-    }
-    /** Add a newly cached instance to idIndex, and keep its entry current when its id changes. */
-    static indexCachedInstance(cacheKey, instance) {
-        const index = (id) => {
-            if (!id)
-                return;
-            const existing = this.idIndex.get(id);
-            // Keep the instance cached first, as the old scan in insertion order returned
-            if (existing && existing.instance !== instance && this.isIndexEntryCurrent(id, existing))
-                return;
-            this.idIndex.set(id, { cacheKey, instance });
-        };
-        let indexedId = instance._getSnapshotContext().id;
-        index(indexedId);
-        instance._service.subscribe((snapshot) => {
-            const id = snapshot.context.id;
-            if (id === indexedId)
-                return;
-            indexedId = id;
-            index(id);
-        });
-    }
-    /**
-     * Get ModelProperty instance by propertyFileId from static cache
-     */
-    static getById(propertyFileId) {
-        if (!propertyFileId)
-            return undefined;
-        const indexed = this.idIndex.get(propertyFileId);
-        if (!indexed)
-            return undefined;
-        if (this.isIndexEntryCurrent(propertyFileId, indexed))
-            return indexed.instance;
-        // The indexed instance left the cache or changed id; another cached instance may still have it.
-        // Cache key might be "modelName:propertyName" or "id:propertyId"
-        this.idIndex.delete(propertyFileId);
-        for (const [cacheKey, { instance }] of this.instanceCache.entries()) {
-            // id is now the schemaFileId (string)
-            if (instance._getSnapshotContext().id === propertyFileId) {
-                this.idIndex.set(propertyFileId, { cacheKey, instance });
-                return instance;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Create or get ModelProperty instance by propertyFileId
-     * Queries the database to find the property if not cached
-     */
-    static async createById(propertyFileId, options) {
-        if (!propertyFileId) {
-            return undefined;
-        }
-        // First, check if we have an instance cached
-        const cachedInstance = this.getById(propertyFileId);
-        if (cachedInstance) {
-            return cachedInstance;
-        }
-        // Query database to get property data from ID
-        const db = main_cjs.BaseDb.getAppDb();
-        if (!db) {
-            return undefined;
-        }
-        const evictionEpoch = options?.evictionEpoch ?? main_cjs.currentEvictionEpoch();
-        const propertyRecords = await db
-            .select()
-            .from(main_cjs.properties)
-            .where(drizzleOrm.eq(main_cjs.properties.schemaFileId, propertyFileId))
-            .limit(1);
-        if (propertyRecords.length === 0) {
-            return undefined;
-        }
-        const propertyRecord = propertyRecords[0];
-        // Get model name
-        const modelRecords = await db
-            .select({ name: main_cjs.models.name })
-            .from(main_cjs.models)
-            .where(drizzleOrm.eq(main_cjs.models.id, propertyRecord.modelId))
-            .limit(1);
-        if (modelRecords.length === 0) {
-            return undefined;
-        }
-        const modelName = modelRecords[0].name;
-        // Build property data
-        // id is now the schemaFileId (string), _dbId is the database integer ID
-        const propertyData = {
-            id: propertyFileId, // schemaFileId (string) - public ID
-            _dbId: propertyRecord.id ?? undefined, // Database integer ID - internal only
-            name: propertyRecord.name,
-            dataType: propertyRecord.dataType,
-            modelId: propertyRecord.modelId,
-            modelName,
-            refModelId: propertyRecord.refModelId || undefined,
-            refValueType: propertyRecord.refValueType ? propertyRecord.refValueType : undefined,
-            required: propertyRecord.required ?? false,
-            storageType: propertyRecord.storageType ?? undefined,
-            localStorageDir: propertyRecord.localStorageDir ?? undefined,
-            filenameSuffix: propertyRecord.filenameSuffix ?? undefined,
-        };
-        // Load isEdited from database
-        const isEditedFromDb = propertyRecord.isEdited ?? false;
-        // Get ref model name if applicable
-        if (propertyRecord.refModelId) {
-            const refModelRecords = await db
-                .select({ name: main_cjs.models.name })
-                .from(main_cjs.models)
-                .where(drizzleOrm.eq(main_cjs.models.id, propertyRecord.refModelId))
-                .limit(1);
-            if (refModelRecords.length > 0) {
-                propertyData.refModelName = refModelRecords[0].name;
-                propertyData.ref = refModelRecords[0].name;
-            }
-        }
-        // Its model's schema was evicted while we read the rows (e.g. a model's property lookup in flight
-        // during Schema.destroy or test cleanup): don't bring the property back.
-        if (main_cjs.anyEvictionSince(evictionEpoch)) {
-            const schemaRows = await db
-                .select({ name: main_cjs.schemas.name })
-                .from(main_cjs.modelSchemas)
-                .innerJoin(main_cjs.schemas, drizzleOrm.eq(main_cjs.schemas.id, main_cjs.modelSchemas.schemaId))
-                .where(drizzleOrm.eq(main_cjs.modelSchemas.modelId, propertyRecord.modelId));
-            if (schemaRows.length === 0 ||
-                schemaRows.some((row) => main_cjs.schemaEvictedSince(row.name, evictionEpoch))) {
-                return undefined;
-            }
-        }
-        // Create ModelProperty instance (sync for createById so we can send updateContext)
-        const instance = this.create(propertyData, { waitForReady: false });
-        // Set isEdited from database after creation
-        if (isEditedFromDb) {
-            instance._service.send({
-                type: 'updateContext',
-                _isEdited: true,
-            });
-        }
-        return instance;
-    }
-    /**
-     * Find ModelProperty instance by propertyFileId
-     * Waits for the property to be fully loaded (idle state) by default
-     * @param options - Find options including propertyFileId and wait configuration
-     * @returns ModelProperty instance if found, undefined otherwise
-     */
-    static async find({ propertyFileId, waitForReady = true, readyTimeout = 5000, }) {
-        if (!propertyFileId) {
-            return undefined;
-        }
-        return await main_cjs.findEntity({
-            getById: (id) => ModelProperty.getById(id),
-            createById: (id) => ModelProperty.createById(id),
-        }, { id: propertyFileId }, {
-            waitForReady,
-            readyTimeout,
-        });
-    }
-    /**
-     * Get all ModelProperty instances for a model.
-     * Loads property rows from DB for the given modelFileId, creates instances via createById, optionally waits for idle.
-     */
-    static async all(modelFileId, options) {
-        const { waitForReady = false, readyTimeout = 5000 } = options ?? {};
-        if (!modelFileId) {
-            return [];
-        }
-        const rows = await getModelPropertiesData(modelFileId);
-        const instances = [];
-        for (const row of rows) {
-            if (row.schemaFileId) {
-                const instance = await this.createById(row.schemaFileId);
-                if (instance) {
-                    instances.push(instance);
-                }
-            }
-        }
-        if (waitForReady && instances.length > 0) {
-            await Promise.all(instances.map((p) => main_cjs.waitForEntityIdle(p, {
-                timeout: readyTimeout,
-            })));
-        }
-        return instances;
-    }
-    /**
-     * Track a pending write for a property
-     */
-    static trackPendingWrite(propertyFileId, modelId) {
-        this.pendingWrites.set(propertyFileId, {
-            propertyFileId,
-            modelId,
-            status: 'pending',
-            timestamp: Date.now(),
-        });
-    }
-    /**
-     * A property write succeeded: add the property to its model's property ids, then drop the pending
-     * write. In that order, `Model.properties` (property ids + pending writes) never misses it; in Node,
-     * where the Model has no reactive liveQuery, nothing else would add it.
-     */
-    static async completePendingWrite(propertyFileId, modelId) {
-        try {
-            await main_cjs.Model.refreshPropertiesForDbId(modelId);
-        }
-        catch (error) {
-            logger(`Refreshing properties of model ${modelId} after writing "${propertyFileId}" failed: ${error}`);
-        }
-        this.clearPendingWrite(propertyFileId, 'success');
-    }
-    /**
-     * Clear or update pending write status
-     */
-    static clearPendingWrite(propertyFileId, status = 'success') {
-        const write = this.pendingWrites.get(propertyFileId);
-        if (write) {
-            if (status === 'success') {
-                // Remove successful writes from pendingWrites
-                this.pendingWrites.delete(propertyFileId);
-                logger(`Cleared pending write for property "${propertyFileId}" (status: success)`);
-            }
-            else {
-                // Update status to error but keep in map (for debugging/retry purposes)
-                write.status = 'error';
-                this.pendingWrites.set(propertyFileId, write);
-                logger(`Marked pending write as error for property "${propertyFileId}"`);
-            }
-        }
-    }
-    /**
-     * Get all pending property IDs for a model
-     */
-    static getPendingPropertyIds(modelId) {
-        return Array.from(this.pendingWrites.entries())
-            .filter(([_, write]) => write.modelId === modelId && write.status !== 'error')
-            .map(([propertyFileId]) => propertyFileId);
-    }
-    /**
-     * Get modelId for a property that has a pending write (row may not be in DB yet).
-     * Used to resolve modelName when validating a just-created property rename.
-     */
-    static getPendingModelId(propertyFileId) {
-        return this.pendingWrites.get(propertyFileId)?.modelId;
-    }
-    getService() {
-        return this._service;
-    }
-    _getSnapshot() {
-        return this._service.getSnapshot();
-    }
-    _getSnapshotContext() {
-        return this._getSnapshot().context;
-    }
-    get path() {
-        const workingDir = main_cjs.BaseFileManager.getWorkingDir();
-        if (!this.localStorageDir || !this.name || !this.filenameSuffix) {
-            return undefined;
-        }
-        return `${workingDir}/${this.localStorageDir}/${this.name}${this.filenameSuffix || ''}`;
-    }
-    get status() {
-        return this._getSnapshot().value;
-    }
-    get isEdited() {
-        const context = this._getSnapshotContext();
-        // First check in-memory state
-        if (context._isEdited !== undefined) {
-            return context._isEdited;
-        }
-        // Fall back to reading from database if we have _dbId
-        if (context._dbId) {
-            // Load from database asynchronously (fire-and-forget for now)
-            // For synchronous getter, we'll need to cache it or make it async
-            // For now, return false if not in context
-            return false;
-        }
-        return false;
-    }
-    get validationErrors() {
-        return this._getSnapshotContext()._validationErrors || [];
-    }
-    get isValid() {
-        const errors = this.validationErrors;
-        return errors.length === 0;
-    }
-    /**
-     * Validate the property
-     * @returns Validation result
-     */
-    async validate() {
-        return new Promise((resolve) => {
-            let resolved = false;
-            const subscription = this._service.subscribe((snapshot) => {
-                const state = snapshot.value;
-                // Wait for validation to complete (idle state after validating)
-                if (state === 'idle' && !resolved) {
-                    resolved = true;
-                    subscription.unsubscribe();
-                    const errors = snapshot.context._validationErrors || [];
-                    resolve({
-                        isValid: errors.length === 0,
-                        errors,
-                    });
-                }
-            });
-            this._service.send({ type: 'validateProperty' });
-            // Timeout fallback
-            setTimeout(() => {
-                if (!resolved) {
-                    resolved = true;
-                    subscription.unsubscribe();
-                    const errors = this._getSnapshotContext()._validationErrors || [];
-                    resolve({
-                        isValid: errors.length === 0,
-                        errors,
-                    });
-                }
-            }, 5000);
-        });
-    }
-    save() {
-        const snapshot = this._service.getSnapshot();
-        const isAlreadySaving = typeof snapshot.value === 'object' && snapshot.value !== null && 'saveToSchema' in snapshot.value;
-        if (isAlreadySaving) {
-            return;
-        }
-        const context = snapshot.context;
-        if (!context._isEdited)
-            return; // No changes to persist
-        // Validation will happen automatically in the machine before saving
-        this._service.send({
-            type: 'saveToSchema',
-        });
-    }
-    /**
-     * Reload property from database
-     * This refreshes the actor context with the latest data from the database
-     * Note: ModelProperty doesn't have a dedicated load actor, so this will
-     * re-initialize from the current property data
-     */
-    async reload() {
-        // ModelProperty doesn't have a separate load mechanism
-        // It's loaded as part of the Model/Schema
-        // This method is provided for API consistency
-        // To actually reload, you'd need to reload the parent Model or Schema
-        logger('ModelProperty.reload() called - ModelProperty is loaded as part of Model/Schema. Reload the parent Model or Schema instead.');
-        // No-op for now, but could be enhanced to reload from DB if needed
-    }
-    /**
-     * Force-evict cached ModelProperty instances for the given models, ignoring refCounts, and stop
-     * their services. Used by Schema.destroy() so a re-imported schema gets fresh instances instead of
-     * ones holding a deleted row's _dbId.
-     */
-    static evictForModels(modelNames, schemaName) {
-        if (modelNames.length === 0)
-            return;
-        const names = new Set(modelNames);
-        for (const [cacheKey, { instance }] of this.instanceCache.entries()) {
-            let context;
-            try {
-                context = instance._getSnapshotContext();
-            }
-            catch {
-                continue;
-            }
-            if (!context.modelName || !names.has(context.modelName))
-                continue;
-            if (schemaName && context._schemaName && context._schemaName !== schemaName)
-                continue;
-            this.instanceCache.delete(cacheKey);
-            try {
-                instance._service.stop();
-            }
-            catch {
-                // Service might already be stopped
-            }
-        }
-    }
-    unload() {
-        // ModelProperty doesn't have liveQuery subscriptions or complex cache management
-        // Just stop the service
-        try {
-            this._service.stop();
-        }
-        catch (error) {
-            // Service might already be stopped
-        }
-    }
-    /**
-     * Destroy the model property: remove from caches, delete from database, update Schema context, stop service.
-     */
-    async destroy() {
-        const context = this._getSnapshotContext();
-        // Stored under "modelName:name", or "id:<id>" when another schema's same-name property holds that key
-        const cacheKeys = [...ModelProperty.instanceCache.entries()]
-            .filter(([, entry]) => {
-            try {
-                return entry.instance._getSnapshotContext().id === context.id;
-            }
-            catch {
-                return false;
-            }
-        })
-            .map(([key]) => key);
-        if (cacheKeys.length === 0 && context.modelName && context.name) {
-            cacheKeys.push(`${context.modelName}:${context.name}`);
-        }
-        if (cacheKeys.length === 0)
-            return;
-        main_cjs.forceRemoveFromCaches(this, {
-            getCacheKeys: () => cacheKeys,
-            caches: [ModelProperty.instanceCache],
-        });
-        await main_cjs.runDestroyLifecycle(this, {
-            getService: (instance) => instance._service,
-            doDestroy: async () => {
-                const db = main_cjs.BaseDb.getAppDb();
-                let schemaName = context._schemaName;
-                const modelName = context.modelName;
-                const propertyName = context.name;
-                if (!modelName || !propertyName)
-                    return;
-                // Resolve schema name from DB when _schemaName is missing (e.g. destroy ran before _setSchemaName finished)
-                if (!schemaName && db) {
-                    schemaName = await this._resolveSchemaNameForDestroy(db, context);
-                }
-                if (db && schemaName) {
-                    const propertyRecords = await db
-                        .select({ propertyId: main_cjs.properties.id })
-                        .from(main_cjs.properties)
-                        .innerJoin(main_cjs.models, drizzleOrm.eq(main_cjs.properties.modelId, main_cjs.models.id))
-                        .innerJoin(main_cjs.modelSchemas, drizzleOrm.eq(main_cjs.models.id, main_cjs.modelSchemas.modelId))
-                        .innerJoin(main_cjs.schemas, drizzleOrm.eq(main_cjs.modelSchemas.schemaId, main_cjs.schemas.id))
-                        .where(drizzleOrm.and(drizzleOrm.eq(main_cjs.schemas.name, schemaName), drizzleOrm.eq(main_cjs.models.name, modelName), drizzleOrm.eq(main_cjs.properties.name, propertyName)))
-                        .limit(1);
-                    if (propertyRecords.length > 0 && propertyRecords[0].propertyId != null) {
-                        await db
-                            .delete(main_cjs.properties)
-                            .where(drizzleOrm.eq(main_cjs.properties.id, propertyRecords[0].propertyId));
-                    }
-                }
-                if (schemaName) {
-                    const schema = Schema.Schema.create(schemaName, { waitForReady: false });
-                    const snapshot = schema.getService().getSnapshot();
-                    const schemaContext = snapshot.context;
-                    if (schemaContext.models?.[modelName]?.properties?.[propertyName]) {
-                        const updatedModels = { ...schemaContext.models };
-                        const updatedProperties = { ...updatedModels[modelName].properties };
-                        delete updatedProperties[propertyName];
-                        updatedModels[modelName] = { ...updatedModels[modelName], properties: updatedProperties };
-                        schema.getService().send({ type: 'updateContext', models: updatedModels });
-                        schema.getService().send({ type: 'markAsDraft', propertyKey: `property:${modelName}:${propertyName}` });
-                    }
-                }
-            },
-        });
-    }
-}
-ModelProperty.instanceCache = new Map();
-/**
- * propertyFileId -> where the instance with that id is cached, so getById doesn't scan the cache
- * (a model's properties are looked up one by one, which made loading one model O(n²)).
- * Every cached instance's current id has an entry: it's added when the instance is cached and
- * again whenever its context id changes (a property is often created with a generated id and
- * then gets its real one). Entries aren't removed when an instance leaves the cache or changes
- * id; getById checks an entry before using it.
- */
-ModelProperty.idIndex = new Map();
-// Pending writes tracking
-ModelProperty.pendingWrites = new Map();
-
-var ModelProperty$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ModelProperty: ModelProperty
-});
-
-exports.ModelProperty = ModelProperty;
-//# sourceMappingURL=ModelProperty-DXZ39Wyv.js.map