@seedprotocol/sdk 0.4.2 → 0.4.3

package/dist/ModelProperty-Cr3BmgkC.js

@@ -0,0 +1,2218 @@
+import { fromCallback, setup, assign, createActor } from 'xstate';
+import { a as ModelPropertyDataTypes, ad as getLatestSchemaVersion, s as BaseFileManager, p as BaseDb, q as models, ae as writeProcessMachine, af as generateId, ag as createReactiveProxy, ah as findEntity } from './json-I3vJhXo8.js';
+import 'pluralize';
+import { eq } from 'drizzle-orm';
+import debug from 'debug';
+
+const logger$4 = debug('seedSdk:helpers:updateSchema');
+/**
+ * Get the file path for a schema file
+ */
+/**
+ * Sanitize a schema name to be filesystem-safe
+ * Replaces all special characters (except alphanumeric, hyphens, underscores) with underscores
+ * Converts spaces to underscores
+ * Removes leading/trailing underscores
+ *
+ * @param name - Schema name to sanitize
+ * @returns Sanitized name safe for use in filenames
+ */
+const sanitizeSchemaName = (name) => {
+    return name
+        .replace(/[^a-zA-Z0-9\s_-]/g, '_') // Replace special chars (except spaces, hyphens, underscores) with underscore
+        .replace(/\s+/g, '_') // Convert spaces to underscores
+        .replace(/^_+|_+$/g, '') // Remove leading/trailing underscores
+        .replace(/_+/g, '_'); // Collapse multiple underscores to single
+};
+/**
+ * Get the full file path for a schema
+ * Format: {schemaFileId}_{schemaName}_v{version}.json
+ *
+ * The ID-first format ensures all files for a schema group together when sorted alphabetically.
+ *
+ * @param name - Schema name
+ * @param version - Schema version
+ * @param schemaFileId - Schema file ID (required)
+ */
+const getSchemaFilePath = (name, version, schemaFileId) => {
+    const path = BaseFileManager.getPathModule();
+    const workingDir = BaseFileManager.getWorkingDir();
+    const sanitizedName = sanitizeSchemaName(name);
+    const filename = schemaFileId
+        ? `${schemaFileId}_${sanitizedName}_v${version}.json`
+        : `${sanitizedName}_v${version}.json`;
+    return path.join(workingDir, filename);
+};
+/**
+ * Get schemaFileId from database for a schema
+ * @param schemaName - Schema name
+ * @returns Schema file ID
+ * @throws Error if schema not found or missing schemaFileId
+ */
+async function getSchemaFileId(schemaName) {
+    const { BaseDb } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aI; });
+    const db = BaseDb.getAppDb();
+    const { schemas } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aN; });
+    const { eq, desc } = await import('drizzle-orm');
+    const dbSchema = await db
+        .select()
+        .from(schemas)
+        .where(eq(schemas.name, schemaName))
+        .orderBy(desc(schemas.version))
+        .limit(1);
+    if (dbSchema.length === 0 || !dbSchema[0].schemaFileId) {
+        throw new Error(`Schema ${schemaName} not found in database or missing schemaFileId`);
+    }
+    return dbSchema[0].schemaFileId;
+}
+/**
+ * Get model name from modelId
+ * @param modelId - The model ID to look up
+ * @returns The model name, or undefined if not found
+ */
+async function getModelNameFromId(modelId) {
+    if (!modelId) {
+        return undefined;
+    }
+    const db = BaseDb.getAppDb();
+    if (!db) {
+        throw new Error('Database not found');
+    }
+    const modelRecords = await db
+        .select()
+        .from(models)
+        .where(eq(models.id, modelId))
+        .limit(1);
+    if (modelRecords.length === 0) {
+        return undefined;
+    }
+    return modelRecords[0].name;
+}
+/**
+ * Convert a TProperty/ModelPropertyMachineContext to SchemaPropertyUpdate format
+ * This function converts the internal property representation to the schema file format
+ * @param property - The TProperty instance to convert
+ * @param modelName - The name of the model this property belongs to
+ * @param propertyName - The name of the property
+ * @returns A SchemaPropertyUpdate object ready to be passed to updateModelProperties
+ */
+async function convertPropertyToSchemaUpdate(property, modelName, propertyName) {
+    const updates = {};
+    // Convert dataType to type
+    if (property.dataType) {
+        updates.type = property.dataType;
+    }
+    // Handle Relation type
+    if (property.dataType === ModelPropertyDataTypes.Relation) {
+        if (property.ref) {
+            updates.model = property.ref;
+        }
+        else if (property.refModelId) {
+            // If ref is not set but refModelId is, get the model name from the database
+            const refModelName = await getModelNameFromId(property.refModelId);
+            if (refModelName) {
+                updates.model = refModelName;
+            }
+        }
+    }
+    // Handle List type
+    if (property.dataType === ModelPropertyDataTypes.List) {
+        if (property.refValueType) {
+            updates.items = {
+                type: property.refValueType,
+            };
+            if (property.ref) {
+                updates.items.model = property.ref;
+            }
+            else if (property.refModelId) {
+                // If ref is not set but refModelId is, get the model name from the database
+                const refModelName = await getModelNameFromId(property.refModelId);
+                if (refModelName) {
+                    updates.items.model = refModelName;
+                }
+            }
+        }
+    }
+    // Handle storage configuration (for Text properties with storage)
+    if (property.storageType || property.localStorageDir || property.filenameSuffix) {
+        const storageType = property.storageType || 'ItemStorage'; // Default to ItemStorage if not specified
+        updates.storage = {
+            type: storageType,
+        };
+        if (property.localStorageDir) {
+            updates.storage.path = property.localStorageDir;
+        }
+        if (property.filenameSuffix) {
+            updates.storage.extension = property.filenameSuffix;
+        }
+    }
+    return {
+        modelName,
+        propertyName,
+        updates,
+    };
+}
+/**
+ * Update model properties in a schema and create a new version
+ * @param schemaName - The name of the schema to update
+ * @param propertyUpdates - Array of property updates to apply
+ * @param modelUpdates - Optional array of model renames
+ * @returns The file path of the new schema version
+ * @throws Error if schema not found or updates are invalid
+ */
+async function updateModelProperties(schemaName, propertyUpdates, modelUpdates) {
+    // Get the latest version of the schema
+    const latestVersion = await getLatestSchemaVersion(schemaName);
+    if (latestVersion === 0) {
+        throw new Error(`Schema ${schemaName} not found`);
+    }
+    // Get schemaFileId from database
+    const schemaFileId = await getSchemaFileId(schemaName);
+    // Load the latest schema file
+    const latestFilePath = getSchemaFilePath(schemaName, latestVersion, schemaFileId);
+    const content = await BaseFileManager.readFileAsString(latestFilePath);
+    const schemaFile = JSON.parse(content);
+    if (!schemaFile.$schema) {
+        throw new Error(`Schema file ${latestFilePath} is not a complete schema file`);
+    }
+    // Create a copy of the schema for the new version
+    // Preserve schema ID and all model/property IDs
+    const newVersion = latestVersion + 1;
+    const updatedSchema = {
+        ...schemaFile,
+        version: newVersion,
+        // Preserve schema ID from previous version
+        id: schemaFile.id,
+        metadata: {
+            ...schemaFile.metadata,
+            updatedAt: new Date().toISOString(),
+        },
+        // Deep copy models to preserve IDs
+        models: Object.fromEntries(Object.entries(schemaFile.models).map(([modelName, model]) => [
+            modelName,
+            {
+                ...model,
+                // Preserve model ID
+                id: model.id,
+                // Deep copy properties to preserve IDs
+                properties: Object.fromEntries(Object.entries(model.properties).map(([propName, prop]) => [
+                    propName,
+                    {
+                        ...prop,
+                        // Preserve property ID
+                        id: prop.id,
+                    },
+                ])),
+            },
+        ])),
+        migrations: [
+            ...schemaFile.migrations,
+            {
+                version: newVersion,
+                timestamp: new Date().toISOString(),
+                description: `Updated model properties: ${propertyUpdates.map(u => `${u.modelName}.${u.propertyName}`).join(', ')}`,
+                changes: propertyUpdates.map(update => ({
+                    type: 'property_update',
+                    modelName: update.modelName,
+                    propertyName: update.propertyName,
+                    updates: update.updates,
+                })),
+            },
+        ],
+    };
+    // Apply model renames first (if any)
+    if (modelUpdates && modelUpdates.length > 0) {
+        for (const modelUpdate of modelUpdates) {
+            if (updatedSchema.models[modelUpdate.oldName]) {
+                // Rename the model in the models object
+                updatedSchema.models[modelUpdate.newName] = updatedSchema.models[modelUpdate.oldName];
+                delete updatedSchema.models[modelUpdate.oldName];
+                // Update any property references to this model
+                for (const modelName in updatedSchema.models) {
+                    const model = updatedSchema.models[modelName];
+                    for (const propertyName in model.properties) {
+                        const property = model.properties[propertyName];
+                        if (property.model === modelUpdate.oldName) {
+                            property.model = modelUpdate.newName;
+                        }
+                        if (property.items?.model === modelUpdate.oldName) {
+                            property.items.model = modelUpdate.newName;
+                        }
+                    }
+                }
+                // Add to migration changes
+                updatedSchema.migrations[updatedSchema.migrations.length - 1].changes.push({
+                    type: 'model_rename',
+                    oldName: modelUpdate.oldName,
+                    newName: modelUpdate.newName,
+                });
+            }
+        }
+    }
+    // Apply property updates
+    for (const update of propertyUpdates) {
+        const model = updatedSchema.models[update.modelName];
+        if (!model) {
+            throw new Error(`Model ${update.modelName} not found in schema ${schemaName}`);
+        }
+        if (!model.properties[update.propertyName]) {
+            throw new Error(`Property ${update.propertyName} not found in model ${update.modelName} of schema ${schemaName}`);
+        }
+        // Update the property with new values
+        const property = model.properties[update.propertyName];
+        Object.assign(property, update.updates);
+    }
+    // Write the new schema version to file using ID-based naming (preferred)
+    const newFilePath = getSchemaFilePath(schemaName, newVersion, updatedSchema.id ?? undefined);
+    const newContent = JSON.stringify(updatedSchema, null, 2);
+    await BaseFileManager.saveFile(newFilePath, newContent);
+    // Wait for the file to be available with content (important for browser/OPFS where writes may not be immediately readable)
+    await BaseFileManager.waitForFileWithContent(newFilePath);
+    logger$4(`Created new schema version ${newVersion} for ${schemaName} at ${newFilePath}`);
+    // Load the new schema file to process models and add them to the database
+    // Extract model renames from migrations to pass to database update
+    const modelRenames = new Map();
+    const latestMigration = updatedSchema.migrations[updatedSchema.migrations.length - 1];
+    for (const change of latestMigration.changes) {
+        if (change.type === 'model_rename') {
+            modelRenames.set(change.oldName, change.newName);
+        }
+    }
+    // Load schema with model renames handled
+    await loadSchemaWithRenames(newFilePath, modelRenames);
+    return newFilePath;
+}
+/**
+ * Load a schema file and handle model renames in the database
+ * This is a helper function that processes model renames before loading
+ */
+async function loadSchemaWithRenames(schemaFilePath, modelRenames) {
+    const content = await BaseFileManager.readFileAsString(schemaFilePath);
+    const schemaFile = JSON.parse(content);
+    if (!schemaFile.$schema) {
+        throw new Error(`File ${schemaFilePath} is not a complete schema file (missing $schema field).`);
+    }
+    const schemaName = schemaFile.metadata?.name;
+    const version = schemaFile.version;
+    if (!schemaName) {
+        throw new Error('Schema name is required in metadata.name');
+    }
+    // Convert to JsonImportSchema format for processing
+    // Remove id fields for JsonImportSchema format (they're not part of the import format)
+    const importData = {
+        name: schemaName,
+        models: Object.fromEntries(Object.entries(schemaFile.models).map(([modelName, model]) => [
+            modelName,
+            {
+                description: model.description,
+                properties: Object.fromEntries(Object.entries(model.properties).map(([propName, prop]) => [
+                    propName,
+                    {
+                        type: prop.type || 'string', // Ensure type is present
+                        ...prop,
+                        // Remove id field for import format (not part of JsonImportSchema)
+                    },
+                ])),
+                indexes: model.indexes,
+            },
+        ])),
+    };
+    // Use dynamic import to break circular dependency
+    const { createModelsFromJson } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aW; });
+    // Generate schema ID if missing
+    if (!schemaFile.id) {
+        const { generateId } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aL; });
+        schemaFile.id = generateId();
+        logger$4('Generated schema ID for schema:', schemaFile.id);
+    }
+    // Extract schemaFileIds from JSON file and generate missing ones BEFORE creating models
+    // This ensures Model instances are created with correct IDs
+    const modelFileIds = new Map();
+    const propertyFileIds = new Map();
+    const { generateId } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aL; });
+    for (const [modelName, model] of Object.entries(schemaFile.models)) {
+        // Generate model ID if missing
+        if (!model.id) {
+            model.id = generateId();
+            logger$4(`Generated model ID for ${modelName}:`, model.id);
+        }
+        modelFileIds.set(modelName, model.id);
+        const propIds = new Map();
+        for (const [propName, prop] of Object.entries(model.properties)) {
+            // Generate property ID if missing
+            if (!prop.id) {
+                prop.id = generateId();
+                logger$4(`Generated property ID for ${modelName}.${propName}:`, prop.id);
+            }
+            propIds.set(propName, prop.id);
+        }
+        if (propIds.size > 0) {
+            propertyFileIds.set(modelName, propIds);
+        }
+    }
+    // Convert JSON models to Model classes, passing modelFileIds and propertyFileIds so Model instances use correct IDs
+    const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds);
+    // Convert schema file metadata to schema input for database
+    const schemaInput = {
+        name: schemaName,
+        version,
+        schemaFileId: schemaFile.id || null,
+        schemaData: null,
+        isDraft: false,
+        isEdited: false,
+        createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
+        updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
+    };
+    // Use dynamic import to break circular dependency
+    const { addSchemaToDb, addModelsToDb } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aR; });
+    // Add schema to database with schemaFileId
+    const schemaRecord = await addSchemaToDb(schemaInput, schemaFile.id);
+    // Add models to database with model renames handled and schemaFileIds
+    await addModelsToDb(modelDefinitions, schemaRecord, modelRenames, {
+        schemaFileId: schemaFile.id,
+        modelFileIds,
+        propertyFileIds,
+    });
+    // Models are now Model instances, no registration needed
+    // They should be created via Model.create() and are accessible via Model static methods
+    for (const [modelName] of Object.entries(modelDefinitions)) {
+        logger$4('loadSchemaWithRenames - model available:', modelName);
+    }
+    return schemaFilePath;
+}
+/**
+ * Rename a property in a model
+ * This is a convenience function that updates the property name
+ * Note: This creates a new property and you may want to handle the old property separately
+ * @param schemaName - The name of the schema
+ * @param modelName - The name of the model
+ * @param oldPropertyName - The current property name
+ * @param newPropertyName - The new property name
+ * @returns The file path of the new schema version
+ */
+async function renameModelProperty(schemaName, modelName, oldPropertyName, newPropertyName) {
+    // Get the latest version
+    const latestVersion = await getLatestSchemaVersion(schemaName);
+    if (latestVersion === 0) {
+        throw new Error(`Schema ${schemaName} not found`);
+    }
+    // Get schemaFileId from database
+    const schemaFileId = await getSchemaFileId(schemaName);
+    // Load the latest schema file
+    const latestFilePath = getSchemaFilePath(schemaName, latestVersion, schemaFileId);
+    const content = await BaseFileManager.readFileAsString(latestFilePath);
+    const schemaFile = JSON.parse(content);
+    if (!schemaFile.$schema) {
+        throw new Error(`Schema file ${latestFilePath} is not a complete schema file`);
+    }
+    const model = schemaFile.models[modelName];
+    if (!model) {
+        throw new Error(`Model ${modelName} not found in schema ${schemaName}`);
+    }
+    if (!model.properties[oldPropertyName]) {
+        throw new Error(`Property ${oldPropertyName} not found in model ${modelName} of schema ${schemaName}`);
+    }
+    if (model.properties[newPropertyName]) {
+        throw new Error(`Property ${newPropertyName} already exists in model ${modelName} of schema ${schemaName}`);
+    }
+    // Create new version with renamed property
+    // Preserve all IDs - when renaming, we keep the same property ID
+    const newVersion = latestVersion + 1;
+    const oldProperty = model.properties[oldPropertyName];
+    const updatedSchema = {
+        ...schemaFile,
+        version: newVersion,
+        id: schemaFile.id, // Preserve schema ID
+        metadata: {
+            ...schemaFile.metadata,
+            updatedAt: new Date().toISOString(),
+        },
+        models: {
+            ...schemaFile.models,
+            [modelName]: {
+                ...model,
+                id: model.id, // Preserve model ID
+                properties: {
+                    ...Object.fromEntries(Object.entries(model.properties)
+                        .filter(([name]) => name !== oldPropertyName)
+                        .map(([name, prop]) => [name, { ...prop, id: prop.id }])),
+                    [newPropertyName]: {
+                        ...oldProperty,
+                        id: oldProperty.id, // Preserve property ID when renaming
+                    },
+                },
+            },
+        },
+        migrations: [
+            ...schemaFile.migrations,
+            {
+                version: newVersion,
+                timestamp: new Date().toISOString(),
+                description: `Renamed property ${modelName}.${oldPropertyName} to ${newPropertyName}`,
+                changes: [
+                    {
+                        type: 'property_rename',
+                        modelName,
+                        oldPropertyName,
+                        newPropertyName,
+                    },
+                ],
+            },
+        ],
+    };
+    // Remove the old property name
+    delete updatedSchema.models[modelName].properties[oldPropertyName];
+    // Write the new schema version using ID-based naming (preferred)
+    const newFilePath = getSchemaFilePath(schemaName, newVersion, updatedSchema.id ?? undefined);
+    const newContent = JSON.stringify(updatedSchema, null, 2);
+    // Ensure the directory exists before saving
+    const path = BaseFileManager.getPathModule();
+    const dir = path.dirname(newFilePath);
+    await BaseFileManager.createDirIfNotExists(dir);
+    await BaseFileManager.saveFile(newFilePath, newContent);
+    // Wait for the file to be available with content (important for browser/OPFS where writes may not be immediately readable)
+    await BaseFileManager.waitForFileWithContent(newFilePath);
+    logger$4(`Renamed property ${oldPropertyName} to ${newPropertyName} in schema ${schemaName} v${newVersion}`);
+    // Use dynamic import to break circular dependency
+    const { loadSchemaFromFile } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aW; });
+    // Load the new schema file
+    await loadSchemaFromFile(newFilePath);
+    return newFilePath;
+}
+/**
+ * Delete a model from a schema
+ * @param schemaName - The name of the schema
+ * @param modelName - The name of the model to delete
+ * @param options - Optional deletion options
+ * @returns The file path of the new schema version
+ * @throws Error if schema or model not found
+ */
+async function deleteModelFromSchema(schemaName, modelName, options = {}) {
+    const { removeReferencingProperties = false } = options;
+    // Get the latest version
+    const latestVersion = await getLatestSchemaVersion(schemaName);
+    if (latestVersion === 0) {
+        throw new Error(`Schema ${schemaName} not found`);
+    }
+    // Get schemaFileId from database
+    const schemaFileId = await getSchemaFileId(schemaName);
+    // Load the latest schema file
+    const latestFilePath = getSchemaFilePath(schemaName, latestVersion, schemaFileId);
+    const content = await BaseFileManager.readFileAsString(latestFilePath);
+    const schemaFile = JSON.parse(content);
+    if (!schemaFile.$schema) {
+        throw new Error(`Schema file ${latestFilePath} is not a complete schema file`);
+    }
+    if (!schemaFile.models[modelName]) {
+        throw new Error(`Model ${modelName} not found in schema ${schemaName}`);
+    }
+    // Create new version without the model
+    // Preserve IDs for remaining models and properties
+    const newVersion = latestVersion + 1;
+    const updatedSchema = {
+        ...schemaFile,
+        version: newVersion,
+        id: schemaFile.id, // Preserve schema ID
+        metadata: {
+            ...schemaFile.metadata,
+            updatedAt: new Date().toISOString(),
+        },
+        // Preserve IDs for remaining models and their properties
+        models: Object.fromEntries(Object.entries(schemaFile.models)
+            .filter(([name]) => name !== modelName)
+            .map(([name, model]) => [
+            name,
+            {
+                ...model,
+                id: model.id, // Preserve model ID
+                properties: Object.fromEntries(Object.entries(model.properties).map(([propName, prop]) => [
+                    propName,
+                    { ...prop, id: prop.id }, // Preserve property ID
+                ])),
+            },
+        ])),
+        migrations: [
+            ...schemaFile.migrations,
+            {
+                version: newVersion,
+                timestamp: new Date().toISOString(),
+                description: `Deleted model ${modelName} from schema`,
+                changes: [
+                    {
+                        type: 'model_delete',
+                        modelName,
+                        removeReferencingProperties,
+                    },
+                ],
+            },
+        ],
+    };
+    // Remove the model
+    delete updatedSchema.models[modelName];
+    // Handle properties that reference this model
+    const propertiesToRemove = [];
+    for (const [otherModelName, model] of Object.entries(updatedSchema.models)) {
+        for (const [propertyName, property] of Object.entries(model.properties)) {
+            // Check if property references the deleted model
+            if (property.model === modelName || property.items?.model === modelName) {
+                if (removeReferencingProperties) {
+                    // Mark for removal
+                    propertiesToRemove.push({ modelName: otherModelName, propertyName });
+                }
+                else {
+                    // Remove the reference (set to null or remove model field)
+                    if (property.model === modelName) {
+                        delete property.model;
+                    }
+                    if (property.items?.model === modelName) {
+                        delete property.items.model;
+                        // If items only had model, we might want to remove items entirely
+                        // But for now, just remove the model reference
+                    }
+                }
+            }
+        }
+    }
+    // Remove properties if requested
+    if (removeReferencingProperties) {
+        for (const { modelName: mName, propertyName } of propertiesToRemove) {
+            delete updatedSchema.models[mName].properties[propertyName];
+            updatedSchema.migrations[updatedSchema.migrations.length - 1].changes.push({
+                type: 'property_delete',
+                modelName: mName,
+                propertyName,
+                reason: `Referenced deleted model ${modelName}`,
+            });
+        }
+    }
+    else {
+        // Update migration to note which properties were updated
+        const updatedProperties = [];
+        for (const [otherModelName, model] of Object.entries(updatedSchema.models)) {
+            for (const [propertyName, property] of Object.entries(model.properties)) {
+                if (property.model === modelName || property.items?.model === modelName) {
+                    updatedProperties.push({ modelName: otherModelName, propertyName });
+                }
+            }
+        }
+        if (updatedProperties.length > 0) {
+            updatedSchema.migrations[updatedSchema.migrations.length - 1].changes.push({
+                type: 'properties_updated',
+                properties: updatedProperties,
+                reason: `Removed references to deleted model ${modelName}`,
+            });
+        }
+    }
+    // Write the new schema version using ID-based naming (preferred)
+    const newFilePath = getSchemaFilePath(schemaName, newVersion, updatedSchema.id ?? undefined);
+    const newContent = JSON.stringify(updatedSchema, null, 2);
+    // Ensure the directory exists before saving
+    const path = BaseFileManager.getPathModule();
+    const dir = path.dirname(newFilePath);
+    await BaseFileManager.createDirIfNotExists(dir);
+    await BaseFileManager.saveFile(newFilePath, newContent);
+    // Wait for the file to be available with content (important for browser/OPFS where writes may not be immediately readable)
+    await BaseFileManager.waitForFileWithContent(newFilePath);
+    logger$4(`Deleted model ${modelName} from schema ${schemaName} v${newVersion}`);
+    // Use dynamic import to break circular dependency
+    const { loadSchemaFromFile } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aW; });
+    // Load the new schema file
+    await loadSchemaFromFile(newFilePath);
+    return newFilePath;
+}
+/**
+ * Delete a property from a model in a schema
+ * @param schemaName - The name of the schema
+ * @param modelName - The name of the model
+ * @param propertyName - The name of the property to delete
+ * @param options - Optional deletion options
+ * @returns The file path of the new schema version
+ * @throws Error if schema, model, or property not found
+ */
+async function deletePropertyFromModel(schemaName, modelName, propertyName, options = {}) {
+    // Get the latest version
+    const latestVersion = await getLatestSchemaVersion(schemaName);
+    if (latestVersion === 0) {
+        throw new Error(`Schema ${schemaName} not found`);
+    }
+    // Get schemaFileId from database
+    const schemaFileId = await getSchemaFileId(schemaName);
+    // Load the latest schema file
+    const latestFilePath = getSchemaFilePath(schemaName, latestVersion, schemaFileId);
+    const content = await BaseFileManager.readFileAsString(latestFilePath);
+    const schemaFile = JSON.parse(content);
+    if (!schemaFile.$schema) {
+        throw new Error(`Schema file ${latestFilePath} is not a complete schema file`);
+    }
+    const model = schemaFile.models[modelName];
+    if (!model) {
+        throw new Error(`Model ${modelName} not found in schema ${schemaName}`);
+    }
+    if (!model.properties[propertyName]) {
+        throw new Error(`Property ${propertyName} not found in model ${modelName} of schema ${schemaName}`);
+    }
+    // Create new version without the property
+    // Preserve IDs for schema, models, and remaining properties
+    const newVersion = latestVersion + 1;
+    const updatedSchema = {
+        ...schemaFile,
+        version: newVersion,
+        id: schemaFile.id, // Preserve schema ID
+        metadata: {
+            ...schemaFile.metadata,
+            updatedAt: new Date().toISOString(),
+        },
+        models: Object.fromEntries(Object.entries(schemaFile.models).map(([mName, m]) => [
+            mName,
+            {
+                ...m,
+                id: m.id, // Preserve model ID
+                properties: Object.fromEntries(Object.entries(m.properties)
+                    .filter(([propName]) => !(mName === modelName && propName === propertyName))
+                    .map(([propName, prop]) => [
+                    propName,
+                    { ...prop, id: prop.id }, // Preserve property ID
+                ])),
+            },
+        ])),
+        migrations: [
+            ...schemaFile.migrations,
+            {
+                version: newVersion,
+                timestamp: new Date().toISOString(),
+                description: `Deleted property ${modelName}.${propertyName} from schema`,
+                changes: [
+                    {
+                        type: 'property_delete',
+                        modelName,
+                        propertyName,
+                    },
+                ],
+            },
+        ],
+    };
+    // Write the new schema version using ID-based naming (preferred)
+    const newFilePath = getSchemaFilePath(schemaName, newVersion, updatedSchema.id ?? undefined);
+    const newContent = JSON.stringify(updatedSchema, null, 2);
+    // Ensure the directory exists before saving
+    const path = BaseFileManager.getPathModule();
+    const dir = path.dirname(newFilePath);
+    await BaseFileManager.createDirIfNotExists(dir);
+    await BaseFileManager.saveFile(newFilePath, newContent);
+    // Wait for the file to be available with content (important for browser/OPFS where writes may not be immediately readable)
+    await BaseFileManager.waitForFileWithContent(newFilePath);
+    logger$4(`Deleted property ${propertyName} from model ${modelName} in schema ${schemaName} v${newVersion}`);
+    // Use dynamic import to break circular dependency
+    const { loadSchemaFromFile } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aW; });
+    // Load the new schema file
+    await loadSchemaFromFile(newFilePath);
+    return newFilePath;
+}
+
+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 { listLatestSchemaFiles } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aT; });
+    const latestSchemas = await listLatestSchemaFiles();
+    for (const schema of latestSchemas) {
+        try {
+            const { BaseFileManager } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aK; });
+            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 = fromCallback(({ sendBack, input: { context } }) => {
+    const _saveToSchema = async () => {
+        // Use dynamic import to break circular dependency
+        const { SchemaValidationService } = await import('./SchemaValidationService-cTlURuDt.js');
+        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}`);
+        }
+        // Get schema name from model
+        const schemaName = await getSchemaNameFromModel(context.modelName);
+        if (!schemaName) {
+            throw new Error(`Schema not found for model: ${context.modelName}`);
+        }
+        // Convert property context to SchemaPropertyUpdate
+        const propertyUpdate = await convertPropertyToSchemaUpdate(context, context.modelName, context.name);
+        // Update the schema with the property changes
+        await updateModelProperties(schemaName, [propertyUpdate]);
+        // Clear isEdited flag in database after saving to schema file
+        try {
+            const { BaseDb } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aI; });
+            const { properties: propertiesTable, models: modelsTable } = await import('./index-r45w9hEq.js').then(function (n) { return n.s; });
+            const { eq, and } = await import('drizzle-orm');
+            const db = BaseDb.getAppDb();
+            if (db && context.modelName && context.name) {
+                // Find model by name
+                const modelRecords = await db
+                    .select({ id: modelsTable.id })
+                    .from(modelsTable)
+                    .where(eq(modelsTable.name, context.modelName))
+                    .limit(1);
+                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, context.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$3(`Cleared isEdited flag in database for property ${context.modelName}:${context.name}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            logger$3(`Error clearing isEdited flag in database: ${error}`);
+        }
+        logger$3(`Successfully saved property ${context.name} to schema ${schemaName}`);
+    };
+    _saveToSchema().then(() => {
+        sendBack({ type: 'saveToSchemaSuccess' });
+    }).catch((error) => {
+        logger$3('Error saving to schema:', error);
+        sendBack({ type: 'saveToSchemaError', error });
+    });
+    return () => {
+        // Cleanup function (optional)
+    };
+});
+
+var saveToSchema$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getSchemaNameFromModel: getSchemaNameFromModel,
+    saveToSchema: saveToSchema
+});
+
+const logger$2 = debug('seedSdk:modelProperty:actors:compareAndMarkDraft');
+const compareAndMarkDraft = fromCallback(({ sendBack, input: { context } }) => {
+    const _compareAndMarkDraft = async () => {
+        // 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 (!context._originalValues) {
+            logger$2('No original values to compare against');
+            logger$2(`[compareAndMarkDraft] Context: modelName=${context.modelName}, name=${context.name}, id=${context.id}, _propertyFileId=${context._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
+            const schemaFileId = context._propertyFileId || (typeof context.id === 'string' ? context.id : undefined);
+            if (context.modelName && context.name && schemaFileId) {
+                logger$2(`[compareAndMarkDraft] _originalValues not set, but saving to database anyway for property ${context.modelName}:${context.name} (schemaFileId: ${schemaFileId})`);
+                try {
+                    const { savePropertyToDb } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aR; });
+                    // Ensure _propertyFileId is set for savePropertyToDb to find the property
+                    const contextWithFileId = {
+                        ...context,
+                        _propertyFileId: schemaFileId,
+                    };
+                    await savePropertyToDb(contextWithFileId);
+                    logger$2(`[compareAndMarkDraft] Successfully saved property ${context.modelName}:${context.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 ${context.modelName}:${context.name}:`, error);
+                }
+            }
+            else {
+                logger$2(`[compareAndMarkDraft] Cannot save property ${context.modelName}:${context.name} - missing required fields (schemaFileId: ${schemaFileId})`);
+            }
+            return;
+        }
+        logger$2(`[compareAndMarkDraft] Comparing: context.name=${context.name}, _originalValues.name=${context._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'];
+        const hasChanges = propertyFields.some(key => {
+            const currentValue = context[key];
+            const originalValue = context._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 = context.refModelName || context.ref;
+                const originalRef = context._originalValues?.refModelName || context._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 ${context.modelName}:${context.name} has changes, marking as edited`);
+            logger$2(`[compareAndMarkDraft] Context when saving: id=${context.id}, _propertyFileId=${context._propertyFileId}, name=${context.name}, _originalValues.name=${context._originalValues?.name}`);
+            // Use dynamic import to break circular dependency
+            const { savePropertyToDb } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aR; });
+            // Save to database (but not JSON file) - always save to DB when there are changes
+            try {
+                await savePropertyToDb(context);
+                logger$2(`[compareAndMarkDraft] Successfully saved property ${context.modelName}:${context.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 (context._schemaName) {
+                // Get the Schema instance and mark it as draft
+                const { Schema } = await import('./Schema-DeKabJ0T.js');
+                const schema = Schema.create(context._schemaName);
+                // Send event to Schema machine to mark as draft
+                schema.getService().send({
+                    type: 'markAsDraft',
+                    propertyKey: `${context.modelName}:${context.name}`,
+                });
+            }
+        }
+        else {
+            // No changes - clear edited flag in database and context
+            logger$2(`Property ${context.modelName}:${context.name} has no changes`);
+            // Clear isEdited flag in database
+            try {
+                const { BaseDb } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aI; });
+                const { properties: propertiesTable, models: modelsTable } = await import('./index-r45w9hEq.js').then(function (n) { return n.s; });
+                const { eq, and } = await import('drizzle-orm');
+                const db = BaseDb.getAppDb();
+                if (db && context.modelName && context.name) {
+                    // Find model by name
+                    const modelRecords = await db
+                        .select({ id: modelsTable.id })
+                        .from(modelsTable)
+                        .where(eq(modelsTable.name, context.modelName))
+                        .limit(1);
+                    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, context.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 ${context.modelName}:${context.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 = fromCallback(({ sendBack, input: { context } }) => {
+    const _validateProperty = async () => {
+        console.log('[validateProperty] Starting validation for property:', context.name);
+        console.log('[validateProperty] Context:', {
+            name: context.name,
+            modelName: context.modelName,
+            _schemaName: context._schemaName,
+            _originalValues: context._originalValues
+        });
+        // Use dynamic imports to break circular dependencies
+        const { SchemaValidationService } = await import('./SchemaValidationService-cTlURuDt.js');
+        const validationService = new SchemaValidationService();
+        const { Schema } = await import('./Schema-DeKabJ0T.js');
+        // Validate property structure
+        console.log('[validateProperty] Validating property structure...');
+        const structureResult = validationService.validatePropertyStructure(context);
+        console.log('[validateProperty] Structure validation result:', structureResult.isValid);
+        if (!structureResult.isValid) {
+            console.log('[validateProperty] Structure validation failed:', structureResult.errors);
+            sendBack({ type: 'validationError', errors: structureResult.errors });
+            return;
+        }
+        console.log('[validateProperty] Structure validation passed');
+        // If we have schema name and model name, validate against schema
+        console.log('[validateProperty] Checking schema validation:', { hasSchemaName: !!context._schemaName, hasModelName: !!context.modelName });
+        if (context._schemaName && context.modelName) {
+            try {
+                console.log('[validateProperty] Creating schema instance:', context._schemaName);
+                const schema = Schema.create(context._schemaName);
+                const schemaSnapshot = schema.getService().getSnapshot();
+                const schemaStatus = schemaSnapshot.value;
+                console.log('[validateProperty] Schema status:', schemaStatus);
+                // 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;
+                    console.log('[validateProperty] Schema context models:', schemaContext.models ? Object.keys(schemaContext.models).length : 'null');
+                    // 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 = context._originalValues?.name && context._originalValues.name !== context.name
+                            ? context._originalValues.name
+                            : context.name || '';
+                        console.log('[validateProperty] Validating against schema:', {
+                            modelName: context.modelName,
+                            propertyNameToValidate,
+                            originalName: context._originalValues?.name,
+                            currentName: context.name
+                        });
+                        const schemaResult = validationService.validateProperty(schemaContext, context.modelName, propertyNameToValidate, context);
+                        console.log('[validateProperty] Schema validation result:', { isValid: schemaResult.isValid, errors: schemaResult.errors.length, errorCodes: schemaResult.errors.map(e => e.code) });
+                        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 = context._originalValues?.name && context._originalValues.name !== context.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 === context.name) {
+                                    return false; // Not critical
+                                }
+                                return true; // Critical error
+                            });
+                            console.log('[validateProperty] Filtered critical errors:', {
+                                totalErrors: schemaResult.errors.length,
+                                criticalErrors: criticalErrors.length,
+                                errorCodes: schemaResult.errors.map(e => e.code),
+                                criticalErrorCodes: criticalErrors.map(e => e.code)
+                            });
+                            if (criticalErrors.length > 0) {
+                                console.log('[validateProperty] Sending validationError with critical errors');
+                                sendBack({ type: 'validationError', errors: criticalErrors });
+                                return;
+                            }
+                            console.log('[validateProperty] No critical errors, continuing with validation');
+                            // Continue with validation - rename-related errors are acceptable
+                        }
+                    }
+                    else {
+                        console.log('[validateProperty] Schema models not loaded yet, skipping schema validation');
+                        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) {
+                console.log('[validateProperty] Error validating property against schema:', error);
+                logger$1('Error validating property against schema:', error);
+                // Continue with structure validation only
+            }
+        }
+        else {
+            console.log('[validateProperty] Skipping schema validation (no _schemaName or modelName)');
+        }
+        // All validations passed
+        console.log('[validateProperty] All validations passed, sending validationSuccess');
+        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 = setup({
+    types: {
+        context: {},
+        input: {},
+        events: {},
+    },
+    actors: {
+        saveToSchema,
+        compareAndMarkDraft,
+        validateProperty,
+        writeProcessMachine,
+    },
+    guards: {
+        isPropertyValid: ({ context }) => {
+            return !context._validationErrors || context._validationErrors.length === 0;
+        },
+        hasValidationErrors: ({ context }) => {
+            return !!context._validationErrors && context._validationErrors.length > 0;
+        },
+    },
+    actions: {
+        assignValidationErrors: assign(({ context, event }) => {
+            if (event.type === 'validationError') {
+                return {
+                    ...context,
+                    _validationErrors: event.errors,
+                };
+            }
+            return context;
+        }),
+    },
+}).createMachine({
+    id: 'modelProperty',
+    initial: 'idle',
+    context: ({ input }) => {
+        const context = input;
+        console.log('[modelPropertyMachine] Initializing context with input:', JSON.stringify({
+            name: context.name,
+            modelName: context.modelName,
+            ref: context.ref,
+            refModelName: context.refModelName,
+            refModelId: context.refModelId,
+            dataType: context.dataType,
+        }, null, 2));
+        return context;
+    },
+    on: {
+        updateContext: {
+            actions: 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('_');
+                });
+                // Debug logging
+                if (event.name !== undefined) {
+                    console.log(`[modelPropertyMachine] updateContext with name change: "${context.name}" -> "${event.name}"`);
+                    console.log(`[modelPropertyMachine] onlyInternalFields: ${onlyInternalFields}, has _originalValues: ${!!context._originalValues}`);
+                }
+                // 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;
+                }
+                // 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('_');
+                });
+                if (event.name !== undefined) {
+                    console.log(`[modelPropertyMachine] updateContext guard result: ${shouldTransition} (will ${shouldTransition ? 'transition' : 'not transition'} to validating)`);
+                }
+                return shouldTransition;
+            },
+            target: '.validating',
+        },
+        validateProperty: {
+            target: '.validating',
+        },
+        validationSuccess: {
+            actions: 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: assign(({ context, event }) => ({
+                ...context,
+                _originalValues: event.originalValues,
+                _schemaName: event.schemaName,
+                _isEdited: event.isEdited ?? false,
+                _validationErrors: undefined,
+            })),
+        },
+        clearEdited: {
+            actions: assign(({ context }) => ({
+                ...context,
+                _isEdited: false,
+                _originalValues: { ...context },
+            })),
+        },
+        setSchemaName: {
+            actions: assign(({ context, event }) => ({
+                ...context,
+                _schemaName: event.schemaName,
+            })),
+        },
+    },
+    states: {
+        idle: {
+            entry: 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(writeProcessMachine, {
+                            input: {
+                                entityType: 'modelProperty',
+                                entityId: String(entityId),
+                                entityData: context,
+                            },
+                        });
+                    }
+                    return context.writeProcess;
+                },
+            }),
+            on: {
+                validateProperty: {
+                    target: 'validating',
+                },
+                requestWrite: {
+                    actions: ({ context, event }) => {
+                        if (context.writeProcess) {
+                            context.writeProcess.send({
+                                type: 'startWrite',
+                                data: event.data,
+                            });
+                        }
+                    },
+                },
+            },
+        },
+        validating: {
+            entry: () => {
+                console.log('[modelPropertyMachine] Entered validating state');
+            },
+            on: {
+                validationSuccess: {
+                    target: 'compareAndMarkDraft',
+                    actions: assign(({ context, event }) => {
+                        console.log('[modelPropertyMachine] validationSuccess, transitioning to compareAndMarkDraft');
+                        return {
+                            ...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: {
+            entry: () => {
+                console.log('[modelPropertyMachine] Entered compareAndMarkDraft state');
+            },
+            on: {
+                compareAndMarkDraftSuccess: {
+                    target: 'idle',
+                },
+                compareAndMarkDraftError: {
+                    target: 'idle',
+                },
+            },
+            invoke: {
+                src: 'compareAndMarkDraft',
+                input: ({ context }) => {
+                    console.log('[modelPropertyMachine] Invoking compareAndMarkDraft with context:', {
+                        name: context.name,
+                        _originalValues: context._originalValues,
+                        modelName: context.modelName,
+                        id: context.id,
+                        _propertyFileId: context._propertyFileId
+                    });
+                    return { context };
+                },
+            },
+        },
+        saveToSchema: {
+            always: {
+                guard: 'isPropertyValid',
+                target: '.saving',
+            },
+            initial: 'saving',
+            on: {
+                // validationError: Uses root handler for assignment, but needs state-specific transition
+                validationError: {
+                    target: 'idle',
+                    actions: 'assignValidationErrors',
+                },
+            },
+            invoke: {
+                src: 'validateProperty',
+                input: ({ context }) => ({ context }),
+            },
+            states: {
+                saving: {
+                    on: {
+                        saveToSchemaSuccess: {
+                            target: '#modelProperty.idle',
+                        },
+                        saveToSchemaError: {
+                            target: '#modelProperty.idle',
+                        },
+                    },
+                    invoke: {
+                        src: 'saveToSchema',
+                        input: ({ context }) => ({ context }),
+                    },
+                },
+            },
+        },
+    },
+});
+
+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) {
+        // 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 = 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()
+    }
+    /**
+     * 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).then((refModelId) => {
+                if (refModelId) {
+                    // Update the context with the resolved refModelId
+                    this._service.send({
+                        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._service.send({
+                    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._service.send({
+                    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._service.send({
+                type: 'initializeOriginalValues',
+                originalValues,
+                schemaName: undefined,
+            });
+        });
+        // Get schema name from model asynchronously (fire-and-forget)
+        if (property.modelName) {
+            this._setSchemaName(property.modelName).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 { BaseDb } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aI; });
+            const { properties: propertiesTable, models: modelsTable } = await import('./index-r45w9hEq.js').then(function (n) { return n.s; });
+            const { eq, and } = await import('drizzle-orm');
+            const db = BaseDb.getAppDb();
+            if (!db) {
+                return fallbackIsEdited;
+            }
+            // Find model by name
+            const modelRecords = await db
+                .select({ id: modelsTable.id })
+                .from(modelsTable)
+                .where(eq(modelsTable.name, property.modelName))
+                .limit(1);
+            if (modelRecords.length === 0) {
+                return fallbackIsEdited;
+            }
+            // Find property by name and modelId
+            const propertyRecords = await db
+                .select({ isEdited: propertiesTable.isEdited })
+                .from(propertiesTable)
+                .where(and(eq(propertiesTable.name, property.name), eq(propertiesTable.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) {
+        if (!refModelName) {
+            return undefined;
+        }
+        try {
+            const { BaseDb } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aI; });
+            const seedSchema = await import('./index-r45w9hEq.js').then(function (n) { return n.s; });
+            const modelsTable = seedSchema.models;
+            const { eq } = await import('drizzle-orm');
+            const db = BaseDb.getAppDb();
+            if (!db) {
+                return undefined;
+            }
+            const refModelRecords = await db
+                .select()
+                .from(modelsTable)
+                .where(eq(modelsTable.name, refModelName))
+                .limit(1);
+            if (refModelRecords.length > 0 && refModelRecords[0].id) {
+                return refModelRecords[0].id;
+            }
+        }
+        catch (error) {
+            // Ignore errors - model might not exist yet or database not available
+            logger(`Error resolving refModelId for model "${refModelName}":`, error);
+        }
+        return undefined;
+    }
+    /**
+     * 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 { Model } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aS; });
+            const { modelPropertiesToObject } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aP; });
+            const model = await Model.getByNameAsync(property.modelName);
+            if (!model || !model.properties || model.properties.length === 0) {
+                return undefined;
+            }
+            const schema = 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);
+                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(modelName) {
+        try {
+            let schemaName;
+            // Try to get schema name from database first (more reliable)
+            if (this.modelId) {
+                try {
+                    const { BaseDb } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aI; });
+                    const seedSchema = await import('./index-r45w9hEq.js').then(function (n) { return n.s; });
+                    const modelsTable = seedSchema.models;
+                    const modelSchemas = seedSchema.modelSchemas;
+                    const schemas = seedSchema.schemas;
+                    const { eq } = await import('drizzle-orm');
+                    const db = BaseDb.getAppDb();
+                    if (db) {
+                        const modelSchemaRecords = await db
+                            .select({
+                            schemaName: schemas.name,
+                        })
+                            .from(modelSchemas)
+                            .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
+                            .innerJoin(modelsTable, eq(modelSchemas.modelId, modelsTable.id))
+                            .where(eq(modelsTable.id, this.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) {
+                const { getSchemaNameFromModel } = await Promise.resolve().then(function () { return saveToSchema$1; });
+                schemaName = await getSchemaNameFromModel(modelName);
+            }
+            if (schemaName) {
+                // Update the context with the schema name using dedicated event
+                this._service.send({
+                    type: 'setSchemaName',
+                    schemaName,
+                });
+            }
+        }
+        catch (error) {
+            // If we can't get schema name, that's okay - it will be set later if needed
+        }
+    }
+    /**
+     * 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) {
+        if (!property) {
+            throw new Error('Property is required');
+        }
+        // Debug: Log what's being passed to create()
+        console.log(`[ModelProperty.create] Input property data:`, JSON.stringify({
+            name: property.name,
+            modelName: property.modelName,
+            ref: property.ref,
+            refModelName: property.refModelName,
+            refModelId: property.refModelId,
+            dataType: property.dataType,
+            type: property.type, // Check if it's using 'type' instead of 'dataType'
+        }, null, 2));
+        // Handle 'type' field from JSON schema format - convert to 'dataType'
+        const propertyWithId = { ...property };
+        if (propertyWithId.type && !propertyWithId.dataType) {
+            propertyWithId.dataType = propertyWithId.type;
+        }
+        // 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 = 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 = generateId();
+            logger(`ModelProperty.create: Generated new id (schemaFileId) "${propertyWithId.id}" for property "${property.name}"`);
+        }
+        // Create cache key from modelName and name, or use id
+        const cacheKey = propertyWithId.modelName && propertyWithId.name
+            ? `${propertyWithId.modelName}:${propertyWithId.name}`
+            : propertyWithId.id
+                ? `id:${propertyWithId.id}`
+                : propertyWithId.name || 'unnamed';
+        // Check if instance exists in cache
+        if (this.instanceCache.has(cacheKey)) {
+            const { instance, refCount } = this.instanceCache.get(cacheKey);
+            const cachedContext = instance._getSnapshotContext();
+            console.log(`[ModelProperty.create] Returning cached instance for ${cacheKey}, context has ref:`, cachedContext.ref);
+            // 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) {
+                console.log(`[ModelProperty.create] Updating cached instance with missing fields:`, needsUpdate);
+                instance._service.send({
+                    type: 'updateContext',
+                    ...needsUpdate,
+                });
+            }
+            this.instanceCache.set(cacheKey, {
+                instance,
+                refCount: refCount + 1,
+            });
+            return instance;
+        }
+        // Debug: Log what's being passed to the constructor
+        console.log(`[ModelProperty.create] propertyWithId before constructor:`, JSON.stringify({
+            name: propertyWithId.name,
+            modelName: propertyWithId.modelName,
+            ref: propertyWithId.ref,
+            refModelName: propertyWithId.refModelName,
+            refModelId: propertyWithId.refModelId,
+            dataType: propertyWithId.dataType,
+        }, null, 2));
+        const newInstance = new this(propertyWithId);
+        // Debug: Log what's being passed to the constructor
+        console.log(`[ModelProperty.create] Creating instance for ${propertyWithId.modelName}:${propertyWithId.name}`, {
+            ref: propertyWithId.ref,
+            refModelName: propertyWithId.refModelName,
+            refModelId: propertyWithId.refModelId,
+            dataType: propertyWithId.dataType
+        });
+        // Wrap instance in Proxy for reactive property access
+        const proxiedInstance = createReactiveProxy({
+            instance: newInstance,
+            service: newInstance._service,
+            trackedProperties: TPropertyKeys,
+            getContext: (instance) => {
+                const context = instance._getSnapshotContext();
+                return context;
+            },
+            sendUpdate: (instance, prop, value) => {
+                if (prop === 'name') {
+                    const currentContext = instance._getSnapshotContext();
+                    console.log(`[ModelProperty.sendUpdate] Name change: "${currentContext.name}" -> "${value}"`);
+                    console.log(`[ModelProperty.sendUpdate] Current state: ${instance._service.getSnapshot().value}`);
+                    console.log(`[ModelProperty.sendUpdate] Has _originalValues: ${!!currentContext._originalValues}`);
+                }
+                instance._service.send({
+                    type: 'updateContext',
+                    [prop]: value,
+                });
+                if (prop === 'name') {
+                    // Check state after sending
+                    setTimeout(() => {
+                        const newState = instance._service.getSnapshot().value;
+                        console.log(`[ModelProperty.sendUpdate] State after name change: ${newState}`);
+                    }, 10);
+                }
+            },
+        });
+        this.instanceCache.set(cacheKey, {
+            instance: proxiedInstance,
+            refCount: 1,
+        });
+        // 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;
+        if (hasModelId && propertyFileId) {
+            // 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();
+                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 {
+                                const { getModelIdByFileId } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aR; });
+                                resolvedModelId = await 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 {
+                            const { getModelId } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aR; });
+                            // Get schemaName from context if available
+                            const schemaName = snapshot.context._schemaName;
+                            resolvedModelId = await 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;
+                    }
+                    // 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, clear pending write immediately
+                        this.clearPendingWrite(propertyFileId, 'success');
+                    }
+                    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})`);
+                                // Clear pending write on success
+                                this.clearPendingWrite(propertyFileId, 'success');
+                            }
+                            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,
+                        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);
+        }
+        return proxiedInstance;
+    }
+    /**
+     * Get ModelProperty instance by propertyFileId from static cache
+     */
+    static getById(propertyFileId) {
+        if (!propertyFileId)
+            return undefined;
+        // Search through cache to find by propertyFileId
+        // Cache key might be "modelName:propertyName" or "id:propertyId"
+        for (const [cacheKey, { instance }] of this.instanceCache.entries()) {
+            const context = instance._getSnapshotContext();
+            // id is now the schemaFileId (string)
+            if (context.id === propertyFileId) {
+                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) {
+        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 { BaseDb } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aI; });
+        const { properties: propertiesTable, models: modelsTable } = await import('./index-r45w9hEq.js').then(function (n) { return n.s; });
+        const { eq } = await import('drizzle-orm');
+        const db = BaseDb.getAppDb();
+        console.log('db', !!db);
+        if (!db) {
+            console.log('db not found');
+            return undefined;
+        }
+        const testRecords = await db
+            .select()
+            .from(propertiesTable)
+            .limit(100);
+        console.log('testRecords', testRecords);
+        const propertyRecords = await db
+            .select()
+            .from(propertiesTable)
+            .where(eq(propertiesTable.schemaFileId, propertyFileId))
+            .limit(1);
+        console.log('propertyRecords', propertyRecords);
+        if (propertyRecords.length === 0) {
+            return undefined;
+        }
+        const propertyRecord = propertyRecords[0];
+        // Get model name
+        const modelRecords = await db
+            .select({ name: modelsTable.name })
+            .from(modelsTable)
+            .where(eq(modelsTable.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,
+        };
+        // Load isEdited from database
+        const isEditedFromDb = propertyRecord.isEdited ?? false;
+        // Get ref model name if applicable
+        if (propertyRecord.refModelId) {
+            const refModelRecords = await db
+                .select({ name: modelsTable.name })
+                .from(modelsTable)
+                .where(eq(modelsTable.id, propertyRecord.refModelId))
+                .limit(1);
+            if (refModelRecords.length > 0) {
+                propertyData.refModelName = refModelRecords[0].name;
+                propertyData.ref = refModelRecords[0].name;
+            }
+        }
+        // Create ModelProperty instance
+        const instance = this.create(propertyData);
+        // 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 findEntity({
+            getById: (id) => ModelProperty.getById(id),
+            createById: (id) => ModelProperty.createById(id),
+        }, { id: propertyFileId }, {
+            waitForReady,
+            readyTimeout,
+        });
+    }
+    /**
+     * Track a pending write for a property
+     */
+    static trackPendingWrite(propertyFileId, modelId) {
+        this.pendingWrites.set(propertyFileId, {
+            propertyFileId,
+            modelId,
+            status: 'pending',
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * 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);
+    }
+    getService() {
+        return this._service;
+    }
+    _getSnapshot() {
+        return this._service.getSnapshot();
+    }
+    _getSnapshotContext() {
+        return this._getSnapshot().context;
+    }
+    get path() {
+        const workingDir = 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() {
+        // 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
+    }
+    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
+        }
+    }
+}
+ModelProperty.instanceCache = new Map();
+// Pending writes tracking
+ModelProperty.pendingWrites = new Map();
+
+var ModelProperty$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ModelProperty: ModelProperty
+});
+
+export { ModelProperty as M, deleteModelFromSchema as a, ModelProperty$1 as b, convertPropertyToSchemaUpdate as c, deletePropertyFromModel as d, renameModelProperty as r, updateModelProperties as u };
+//# sourceMappingURL=ModelProperty-Cr3BmgkC.js.map