@seedprotocol/sdk 0.4.3 → 0.4.5

package/dist/{ModelProperty-Cr3BmgkC.js → ModelProperty-CGdkocQ8.js}

@@ -1,713 +1,22 @@
 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 { c as convertPropertyToSchemaUpdate, u as updateModelProperties, S as Schema } from './Schema-D1eqDHyt.js';
+import { p as BaseDb, ad as writeProcessMachine, q as models, r as properties, M as Model, o as modelPropertiesToObject, W as schemas, G as modelSchemas, ae as generateId, af as waitForEntityIdle, ag as createReactiveProxy, ah as findEntity, x as BaseFileManager, ai as forceRemoveFromCaches, aj as runDestroyLifecycle, ak as getModelIdByFileId, al as getModelId } from './index-DPll6EAp.js';
 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;
-}
+import { eq, and } from 'drizzle-orm';
+import './SchemaValidationService-DyttFaV_.js';
+import '@sinclair/typebox/value';
+import 'reflect-metadata';
+import 'pluralize';
+import '@sinclair/typebox';
+import 'drizzle-orm/sqlite-core';
+import 'nanoid';
+import 'nanoid-dictionary';
+import 'ethers';
+import 'rxjs';
+import 'lodash-es';
+import 'drizzle-orm/casing';
+import 'eventemitter3';
+import 'arweave';
 
 const logger$3 = debug('seedSdk:modelProperty:actors:saveToSchema');
 /**
@@ -717,11 +26,11 @@ const logger$3 = debug('seedSdk:modelProperty:actors:saveToSchema');
  */
 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 { listLatestSchemaFiles } = await import('./index-DPll6EAp.js').then(function (n) { return n.aU; });
     const latestSchemas = await listLatestSchemaFiles();
     for (const schema of latestSchemas) {
         try {
-            const { BaseFileManager } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aK; });
+            const { BaseFileManager } = await import('./index-DPll6EAp.js').then(function (n) { return n.aS; });
             const content = await BaseFileManager.readFileAsString(schema.filePath);
             const schemaFile = JSON.parse(content);
             if (schemaFile.models && schemaFile.models[modelName]) {
@@ -738,7 +47,7 @@ async function getSchemaNameFromModel(modelName) {
 const saveToSchema = fromCallback(({ sendBack, input: { context } }) => {
     const _saveToSchema = async () => {
         // Use dynamic import to break circular dependency
-        const { SchemaValidationService } = await import('./SchemaValidationService-cTlURuDt.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-DyttFaV_.js');
         const validationService = new SchemaValidationService();
         // Validate property structure before saving
         const validationResult = validationService.validatePropertyStructure(context);
@@ -766,8 +75,7 @@ const saveToSchema = fromCallback(({ sendBack, input: { context } }) => {
         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 { properties: propertiesTable, models: modelsTable } = await import('./index-2FcQHgKp.js').then(function (n) { return n.s; });
             const { eq, and } = await import('drizzle-orm');
             const db = BaseDb.getAppDb();
             if (db && context.modelName && context.name) {
@@ -811,54 +119,89 @@ const saveToSchema = fromCallback(({ sendBack, input: { context } }) => {
     };
 });
 
-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 () => {
+        // Fill modelName/dataType from _originalValues when missing, then from DB by schemaFileId
+        let fullContext = {
+            ...context,
+            modelName: context.modelName ?? context._originalValues?.modelName,
+            dataType: context.dataType ?? context._originalValues?.dataType,
+        };
+        const schemaFileIdForResolve = fullContext._propertyFileId || (typeof fullContext.id === 'string' ? fullContext.id : undefined);
+        if (schemaFileIdForResolve && (fullContext.modelName === undefined || fullContext.dataType === undefined)) {
+            try {
+                const { getPropertyModelNameAndDataType, getModelNameByModelId } = await import('./index-DPll6EAp.js').then(function (n) { return n.aT; });
+                let fromDb;
+                for (let attempt = 0; attempt < 6; attempt++) {
+                    fromDb = await getPropertyModelNameAndDataType(schemaFileIdForResolve);
+                    if (fromDb)
+                        break;
+                    if (attempt < 5)
+                        await new Promise((r) => setTimeout(r, 40));
+                }
+                if (fromDb) {
+                    fullContext = {
+                        ...fullContext,
+                        modelName: fullContext.modelName ?? fromDb.modelName,
+                        dataType: fullContext.dataType ?? fromDb.dataType,
+                    };
+                }
+                if (fullContext.modelName === undefined && schemaFileIdForResolve) {
+                    const mod = await Promise.resolve().then(function () { return ModelProperty$1; });
+                    const ModelProperty = mod?.ModelProperty ?? mod?.default;
+                    const pendingModelId = ModelProperty?.getPendingModelId?.(schemaFileIdForResolve);
+                    if (pendingModelId != null) {
+                        const modelName = await getModelNameByModelId(pendingModelId);
+                        if (modelName) {
+                            fullContext = { ...fullContext, modelName };
+                        }
+                    }
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        const schemaFileId = fullContext._propertyFileId || (typeof fullContext.id === 'string' ? fullContext.id : undefined);
         // If _originalValues is not set, we still need to save to database if the property exists
         // This handles the case where the name is changed before _originalValues is initialized
-        if (!context._originalValues) {
+        if (!fullContext._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}`);
+            logger$2(`[compareAndMarkDraft] Context: modelName=${fullContext.modelName}, name=${fullContext.name}, id=${fullContext.id}, _propertyFileId=${fullContext._propertyFileId}`);
             // If we have a name and modelName, try to save to database anyway
             // This ensures name changes are persisted even if _originalValues isn't initialized yet
             // We need either schemaFileId (id or _propertyFileId) to find the property in the database
-            const schemaFileId = context._propertyFileId || (typeof context.id === 'string' ? context.id : undefined);
-            if (context.modelName && context.name && schemaFileId) {
+            if (fullContext.modelName && fullContext.name && schemaFileId) {
                 logger$2(`[compareAndMarkDraft] _originalValues not set, but saving to database anyway for property ${context.modelName}:${context.name} (schemaFileId: ${schemaFileId})`);
                 try {
-                    const { savePropertyToDb } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aR; });
+                    const { savePropertyToDb } = await import('./index-DPll6EAp.js').then(function (n) { return n.aT; });
                     // Ensure _propertyFileId is set for savePropertyToDb to find the property
                     const contextWithFileId = {
-                        ...context,
+                        ...fullContext,
                         _propertyFileId: schemaFileId,
                     };
                     await savePropertyToDb(contextWithFileId);
-                    logger$2(`[compareAndMarkDraft] Successfully saved property ${context.modelName}:${context.name} to database (no _originalValues)`);
+                    logger$2(`[compareAndMarkDraft] Successfully saved property ${fullContext.modelName}:${fullContext.name} to database (no _originalValues)`);
                 }
                 catch (error) {
                     logger$2(`[compareAndMarkDraft] Error saving property to database (no _originalValues): ${error}`);
                     // Don't throw - this is a best-effort save, but log the error for debugging
-                    console.error(`[compareAndMarkDraft] Failed to save property ${context.modelName}:${context.name}:`, error);
+                    console.error(`[compareAndMarkDraft] Failed to save property ${fullContext.modelName}:${fullContext.name}:`, error);
                 }
             }
             else {
-                logger$2(`[compareAndMarkDraft] Cannot save property ${context.modelName}:${context.name} - missing required fields (schemaFileId: ${schemaFileId})`);
+                logger$2(`[compareAndMarkDraft] Cannot save property ${fullContext.modelName}:${fullContext.name} - missing required fields (schemaFileId: ${schemaFileId})`);
             }
             return;
         }
-        logger$2(`[compareAndMarkDraft] Comparing: context.name=${context.name}, _originalValues.name=${context._originalValues?.name}`);
+        logger$2(`[compareAndMarkDraft] Comparing: context.name=${fullContext.name}, _originalValues.name=${fullContext._originalValues?.name}`);
         // Compare current values with original
         // Only compare property fields, not internal fields
         const propertyFields = ['name', 'dataType', 'ref', 'refModelName', 'refModelId', 'refValueType', 'storageType', 'localStorageDir', 'filenameSuffix', 'modelName', 'modelId'];
         const hasChanges = propertyFields.some(key => {
-            const currentValue = context[key];
-            const originalValue = context._originalValues?.[key];
+            const currentValue = fullContext[key];
+            const originalValue = fullContext._originalValues?.[key];
             // Handle name changes specifically
             if (key === 'name') {
                 const nameChanged = currentValue !== originalValue;
@@ -869,8 +212,8 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context } }) => {
             }
             // 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;
+                const currentRef = fullContext.refModelName || fullContext.ref;
+                const originalRef = fullContext._originalValues?.refModelName || fullContext._originalValues?.ref;
                 // Both undefined/null means no ref, so they're the same
                 if (!currentRef && !originalRef)
                     return false;
@@ -888,53 +231,54 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context } }) => {
             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}`);
+            logger$2(`Property ${fullContext.modelName}:${fullContext.name} has changes, marking as edited`);
+            logger$2(`[compareAndMarkDraft] Context when saving: id=${fullContext.id}, _propertyFileId=${fullContext._propertyFileId}, name=${fullContext.name}, _originalValues.name=${fullContext._originalValues?.name}`);
             // Use dynamic import to break circular dependency
-            const { savePropertyToDb } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aR; });
+            const { savePropertyToDb } = await import('./index-DPll6EAp.js').then(function (n) { return n.aT; });
             // 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`);
+                await savePropertyToDb(fullContext);
+                logger$2(`[compareAndMarkDraft] Successfully saved property ${fullContext.modelName}:${fullContext.name} to database`);
             }
             catch (error) {
                 logger$2(`[compareAndMarkDraft] Error saving property to database: ${error}`);
                 throw error;
             }
             // Mark schema as draft if schema name is available
-            if (context._schemaName) {
+            if (fullContext._schemaName) {
                 // Get the Schema instance and mark it as draft
-                const { Schema } = await import('./Schema-DeKabJ0T.js');
-                const schema = Schema.create(context._schemaName);
+                const { Schema } = await import('./Schema-D1eqDHyt.js').then(function (n) { return n.b; });
+                const schema = Schema.create(fullContext._schemaName, {
+                    waitForReady: false,
+                });
                 // Send event to Schema machine to mark as draft
                 schema.getService().send({
                     type: 'markAsDraft',
-                    propertyKey: `${context.modelName}:${context.name}`,
+                    propertyKey: `${fullContext.modelName}:${fullContext.name}`,
                 });
             }
         }
         else {
             // No changes - clear edited flag in database and context
-            logger$2(`Property ${context.modelName}:${context.name} has no changes`);
+            logger$2(`Property ${fullContext.modelName}:${fullContext.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 { properties: propertiesTable, models: modelsTable } = await import('./index-2FcQHgKp.js').then(function (n) { return n.s; });
                 const { eq, and } = await import('drizzle-orm');
                 const db = BaseDb.getAppDb();
-                if (db && context.modelName && context.name) {
+                if (db && fullContext.modelName && fullContext.name) {
                     // Find model by name
                     const modelRecords = await db
                         .select({ id: modelsTable.id })
                         .from(modelsTable)
-                        .where(eq(modelsTable.name, context.modelName))
+                        .where(eq(modelsTable.name, fullContext.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)))
+                            .where(and(eq(propertiesTable.name, fullContext.name), eq(propertiesTable.modelId, modelRecords[0].id)))
                             .limit(1);
                         if (propertyRecords.length > 0) {
                             // Clear isEdited flag in database
@@ -942,7 +286,7 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context } }) => {
                                 .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}`);
+                            logger$2(`Cleared isEdited flag in database for property ${fullContext.modelName}:${fullContext.name}`);
                         }
                     }
                 }
@@ -969,20 +313,82 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context } }) => {
 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);
+        // Use full context for validation: fill modelName/dataType from _originalValues when missing, then
+        // from DB by schemaFileId (context.id) so just-created renames don't fail structure validation.
+        let fullContext = {
+            ...context,
+            modelName: context.modelName ?? context._originalValues?.modelName,
+            dataType: context.dataType ?? context._originalValues?.dataType,
+        };
+        const schemaFileId = typeof context.id === 'string' ? context.id : undefined;
+        if (schemaFileId && (fullContext.modelName === undefined || fullContext.dataType === undefined)) {
+            // Brief wait so trackPendingWrite from ModelProperty.create() has time to run (it's in setTimeout(0))
+            await new Promise((r) => setTimeout(r, 60));
+            try {
+                const { getPropertyModelNameAndDataType, getModelNameByModelId } = await import('./index-DPll6EAp.js').then(function (n) { return n.aT; });
+                // Try pending write first (property row may not exist yet)
+                if (fullContext.modelName === undefined && schemaFileId) {
+                    const mod = await Promise.resolve().then(function () { return ModelProperty$1; });
+                    const ModelProperty = mod?.ModelProperty ?? mod?.default;
+                    const pendingModelId = ModelProperty?.getPendingModelId?.(schemaFileId);
+                    if (pendingModelId != null) {
+                        const modelName = await getModelNameByModelId(pendingModelId);
+                        if (modelName) {
+                            fullContext = { ...fullContext, modelName };
+                        }
+                    }
+                }
+                // Then DB property lookup with retry (catches row after initial write)
+                let fromDb;
+                for (let attempt = 0; attempt < 6; attempt++) {
+                    fromDb = await getPropertyModelNameAndDataType(schemaFileId);
+                    if (fromDb)
+                        break;
+                    if (attempt < 5)
+                        await new Promise((r) => setTimeout(r, 40));
+                }
+                if (fromDb) {
+                    fullContext = {
+                        ...fullContext,
+                        modelName: fullContext.modelName ?? fromDb.modelName,
+                        dataType: fullContext.dataType ?? fromDb.dataType,
+                    };
+                }
+                // If still no modelName, try pending write again (may have been set during retries)
+                if (fullContext.modelName === undefined && schemaFileId) {
+                    const mod = await Promise.resolve().then(function () { return ModelProperty$1; });
+                    const ModelProperty = mod?.ModelProperty ?? mod?.default;
+                    const pendingModelId = ModelProperty?.getPendingModelId?.(schemaFileId);
+                    if (pendingModelId != null) {
+                        const modelName = await getModelNameByModelId(pendingModelId);
+                        if (modelName) {
+                            fullContext = { ...fullContext, modelName };
+                        }
+                    }
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        // Last resort for structure validation: TProperty requires dataType; allow name+id to pass if we have schemaFileId
+        if (fullContext.dataType === undefined && (fullContext.modelName !== undefined || schemaFileId)) {
+            fullContext = { ...fullContext, dataType: (fullContext.dataType ?? context._originalValues?.dataType) || 'Text' };
+        }
+        console.log('[validateProperty] Starting validation for property:', fullContext.name);
         console.log('[validateProperty] Context:', {
-            name: context.name,
-            modelName: context.modelName,
-            _schemaName: context._schemaName,
-            _originalValues: context._originalValues
+            name: fullContext.name,
+            modelName: fullContext.modelName,
+            _schemaName: fullContext._schemaName,
+            _originalValues: fullContext._originalValues
         });
         // Use dynamic imports to break circular dependencies
-        const { SchemaValidationService } = await import('./SchemaValidationService-cTlURuDt.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-DyttFaV_.js');
         const validationService = new SchemaValidationService();
-        const { Schema } = await import('./Schema-DeKabJ0T.js');
+        const { Schema } = await import('./Schema-D1eqDHyt.js').then(function (n) { return n.b; });
         // Validate property structure
         console.log('[validateProperty] Validating property structure...');
-        const structureResult = validationService.validatePropertyStructure(context);
+        const structureResult = validationService.validatePropertyStructure(fullContext);
         console.log('[validateProperty] Structure validation result:', structureResult.isValid);
         if (!structureResult.isValid) {
             console.log('[validateProperty] Structure validation failed:', structureResult.errors);
@@ -991,11 +397,13 @@ const validateProperty = fromCallback(({ sendBack, input: { context } }) => {
         }
         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) {
+        console.log('[validateProperty] Checking schema validation:', { hasSchemaName: !!fullContext._schemaName, hasModelName: !!fullContext.modelName });
+        if (fullContext._schemaName && fullContext.modelName) {
             try {
-                console.log('[validateProperty] Creating schema instance:', context._schemaName);
-                const schema = Schema.create(context._schemaName);
+                console.log('[validateProperty] Creating schema instance:', fullContext._schemaName);
+                const schema = Schema.create(fullContext._schemaName, {
+                    waitForReady: false,
+                });
                 const schemaSnapshot = schema.getService().getSnapshot();
                 const schemaStatus = schemaSnapshot.value;
                 console.log('[validateProperty] Schema status:', schemaStatus);
@@ -1008,28 +416,28 @@ const validateProperty = fromCallback(({ sendBack, input: { context } }) => {
                     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 || '';
+                        const propertyNameToValidate = fullContext._originalValues?.name && fullContext._originalValues.name !== fullContext.name
+                            ? fullContext._originalValues.name
+                            : fullContext.name || '';
                         console.log('[validateProperty] Validating against schema:', {
-                            modelName: context.modelName,
+                            modelName: fullContext.modelName,
                             propertyNameToValidate,
-                            originalName: context._originalValues?.name,
-                            currentName: context.name
+                            originalName: fullContext._originalValues?.name,
+                            currentName: fullContext.name
                         });
-                        const schemaResult = validationService.validateProperty(schemaContext, context.modelName, propertyNameToValidate, context);
+                        const schemaResult = validationService.validateProperty(schemaContext, fullContext.modelName, propertyNameToValidate, fullContext);
                         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 isRenamed = fullContext._originalValues?.name && fullContext._originalValues.name !== fullContext.name;
                             const criticalErrors = schemaResult.errors.filter(err => {
                                 // Allow property_not_found and missing_type errors when property is renamed
                                 if (isRenamed && (err.code === 'property_not_found' || err.code === 'missing_type')) {
                                     return false; // Not critical
                                 }
                                 // For non-renamed properties, only allow property_not_found if we're validating with the same name
-                                if (err.code === 'property_not_found' && propertyNameToValidate === context.name) {
+                                if (err.code === 'property_not_found' && propertyNameToValidate === fullContext.name) {
                                     return false; // Not critical
                                 }
                                 return true; // Critical error
@@ -1163,6 +571,15 @@ const modelPropertyMachine = setup({
                     }
                     newContext[key] = value;
                 }
+                // Preserve modelName and dataType from context or _originalValues so validation and savePropertyToDb
+                // never run with missing required/needed fields (e.g. when a just-created property is renamed before
+                // the full context is available from the creator).
+                if (newContext.modelName === undefined && context._originalValues?.modelName !== undefined) {
+                    newContext.modelName = context._originalValues.modelName;
+                }
+                if (newContext.dataType === undefined && context._originalValues?.dataType !== undefined) {
+                    newContext.dataType = context._originalValues.dataType;
+                }
                 // Compare with original values and set _isEdited flag (only for non-internal updates)
                 if (!onlyInternalFields && context._originalValues) {
                     const hasChanges = Object.keys(event).some((key) => {
@@ -1232,6 +649,23 @@ const modelPropertyMachine = setup({
                 _schemaName: event.schemaName,
             })),
         },
+        destroyStarted: {
+            actions: assign({ _destroyInProgress: true, _destroyError: null }),
+        },
+        destroyDone: {
+            actions: assign({ _destroyInProgress: false }),
+        },
+        destroyError: {
+            actions: assign(({ event }) => ({
+                _destroyInProgress: false,
+                _destroyError: event.error instanceof Error
+                    ? { message: event.error.message, name: event.error.name }
+                    : { message: String(event.error) },
+            })),
+        },
+        clearDestroyError: {
+            actions: assign({ _destroyError: null }),
+        },
     },
     states: {
         idle: {
@@ -1357,6 +791,32 @@ const modelPropertyMachine = setup({
     },
 });
 
+/**
+ * Returns property rows for a model identified by modelFileId (model's schemaFileId).
+ * Resolves modelFileId -> modelId via models table, then selects all properties where modelId = ?.
+ * Each row includes schemaFileId for use with ModelProperty.createById(schemaFileId).
+ */
+const getModelPropertiesData = async (modelFileId) => {
+    const appDb = BaseDb.getAppDb();
+    if (!appDb || !modelFileId) {
+        return [];
+    }
+    const modelRows = await appDb
+        .select({ id: models.id })
+        .from(models)
+        .where(eq(models.schemaFileId, modelFileId))
+        .limit(1);
+    if (modelRows.length === 0) {
+        return [];
+    }
+    const modelId = modelRows[0].id;
+    const rows = await appDb
+        .select()
+        .from(properties)
+        .where(eq(properties.modelId, modelId));
+    return rows;
+};
+
 const logger = debug('seedSdk:modelProperty:ModelProperty');
 // Define the property keys from TProperty
 const TPropertyKeys = [
@@ -1523,27 +983,24 @@ class ModelProperty {
             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))
+                .select({ id: models.id })
+                .from(models)
+                .where(eq(models.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)))
+                .select({ isEdited: properties.isEdited })
+                .from(properties)
+                .where(and(eq(properties.name, property.name), eq(properties.modelId, modelRecords[0].id)))
                 .limit(1);
             if (propertyRecords.length > 0) {
                 return propertyRecords[0].isEdited ?? false;
@@ -1564,18 +1021,14 @@ class ModelProperty {
             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))
+                .from(models)
+                .where(eq(models.name, refModelName))
                 .limit(1);
             if (refModelRecords.length > 0 && refModelRecords[0].id) {
                 return refModelRecords[0].id;
@@ -1596,8 +1049,6 @@ class ModelProperty {
             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;
@@ -1646,12 +1097,6 @@ class ModelProperty {
             // 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
@@ -1660,8 +1105,8 @@ class ModelProperty {
                         })
                             .from(modelSchemas)
                             .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
-                            .innerJoin(modelsTable, eq(modelSchemas.modelId, modelsTable.id))
-                            .where(eq(modelsTable.id, this.modelId))
+                            .innerJoin(models, eq(modelSchemas.modelId, models.id))
+                            .where(eq(models.id, this.modelId))
                             .limit(1);
                         if (modelSchemaRecords.length > 0) {
                             schemaName = modelSchemaRecords[0].schemaName;
@@ -1674,7 +1119,6 @@ class ModelProperty {
             }
             // 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) {
@@ -1699,10 +1143,12 @@ class ModelProperty {
             schemaName,
         });
     }
-    static create(property) {
+    static create(property, options) {
         if (!property) {
             throw new Error('Property is required');
         }
+        const waitForReady = options?.waitForReady !== false;
+        const readyTimeout = options?.readyTimeout ?? 5000;
         // Debug: Log what's being passed to create()
         console.log(`[ModelProperty.create] Input property data:`, JSON.stringify({
             name: property.name,
@@ -1776,7 +1222,9 @@ class ModelProperty {
                 instance,
                 refCount: refCount + 1,
             });
-            return instance;
+            if (!waitForReady)
+                return instance;
+            return waitForEntityIdle(instance, { timeout: readyTimeout }).then(() => instance);
         }
         // Debug: Log what's being passed to the constructor
         console.log(`[ModelProperty.create] propertyWithId before constructor:`, JSON.stringify({
@@ -1851,7 +1299,6 @@ class ModelProperty {
                         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}`);
                             }
@@ -1864,7 +1311,6 @@ class ModelProperty {
                     // 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);
@@ -1938,7 +1384,9 @@ class ModelProperty {
             // Start checking after a short delay to allow state machine to initialize
             setTimeout(checkAndSend, 0);
         }
-        return proxiedInstance;
+        if (!waitForReady)
+            return proxiedInstance;
+        return waitForEntityIdle(proxiedInstance, { timeout: readyTimeout }).then(() => proxiedInstance);
     }
     /**
      * Get ModelProperty instance by propertyFileId from static cache
@@ -1971,9 +1419,6 @@ class ModelProperty {
             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) {
@@ -1982,13 +1427,13 @@ class ModelProperty {
         }
         const testRecords = await db
             .select()
-            .from(propertiesTable)
+            .from(properties)
             .limit(100);
         console.log('testRecords', testRecords);
         const propertyRecords = await db
             .select()
-            .from(propertiesTable)
-            .where(eq(propertiesTable.schemaFileId, propertyFileId))
+            .from(properties)
+            .where(eq(properties.schemaFileId, propertyFileId))
             .limit(1);
         console.log('propertyRecords', propertyRecords);
         if (propertyRecords.length === 0) {
@@ -1997,9 +1442,9 @@ class ModelProperty {
         const propertyRecord = propertyRecords[0];
         // Get model name
         const modelRecords = await db
-            .select({ name: modelsTable.name })
-            .from(modelsTable)
-            .where(eq(modelsTable.id, propertyRecord.modelId))
+            .select({ name: models.name })
+            .from(models)
+            .where(eq(models.id, propertyRecord.modelId))
             .limit(1);
         if (modelRecords.length === 0) {
             return undefined;
@@ -2022,17 +1467,17 @@ class ModelProperty {
         // 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))
+                .select({ name: models.name })
+                .from(models)
+                .where(eq(models.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);
+        // Create ModelProperty instance (sync for createById so we can send updateContext)
+        const instance = this.create(propertyData, { waitForReady: false });
         // Set isEdited from database after creation
         if (isEditedFromDb) {
             instance._service.send({
@@ -2060,6 +1505,32 @@ class ModelProperty {
             readyTimeout,
         });
     }
+    /**
+     * Get all ModelProperty instances for a model.
+     * Loads property rows from DB for the given modelFileId, creates instances via createById, optionally waits for idle.
+     */
+    static async all(modelFileId, options) {
+        const { waitForReady = false, readyTimeout = 5000 } = options ?? {};
+        if (!modelFileId) {
+            return [];
+        }
+        const rows = await getModelPropertiesData(modelFileId);
+        const instances = [];
+        for (const row of rows) {
+            if (row.schemaFileId) {
+                const instance = await this.createById(row.schemaFileId);
+                if (instance) {
+                    instances.push(instance);
+                }
+            }
+        }
+        if (waitForReady && instances.length > 0) {
+            await Promise.all(instances.map((p) => waitForEntityIdle(p, {
+                timeout: readyTimeout,
+            })));
+        }
+        return instances;
+    }
     /**
      * Track a pending write for a property
      */
@@ -2098,6 +1569,13 @@ class ModelProperty {
             .filter(([_, write]) => write.modelId === modelId && write.status !== 'error')
             .map(([propertyFileId]) => propertyFileId);
     }
+    /**
+     * Get modelId for a property that has a pending write (row may not be in DB yet).
+     * Used to resolve modelName when validating a just-created property rename.
+     */
+    static getPendingModelId(propertyFileId) {
+        return this.pendingWrites.get(propertyFileId)?.modelId;
+    }
     getService() {
         return this._service;
     }
@@ -2204,6 +1682,60 @@ class ModelProperty {
             // Service might already be stopped
         }
     }
+    /**
+     * Destroy the model property: remove from caches, delete from database, update Schema context, stop service.
+     */
+    async destroy() {
+        const context = this._getSnapshotContext();
+        const cacheKey = context.modelName && context.name
+            ? `${context.modelName}:${context.name}`
+            : (context.id ?? '');
+        if (!cacheKey)
+            return;
+        forceRemoveFromCaches(this, {
+            getCacheKeys: () => [cacheKey],
+            caches: [ModelProperty.instanceCache],
+        });
+        await runDestroyLifecycle(this, {
+            getService: (instance) => instance._service,
+            doDestroy: async () => {
+                const db = BaseDb.getAppDb();
+                const schemaName = context._schemaName;
+                const modelName = context.modelName;
+                const propertyName = context.name;
+                if (!modelName || !propertyName)
+                    return;
+                if (db && schemaName) {
+                    const propertyRecords = await db
+                        .select({ propertyId: properties.id })
+                        .from(properties)
+                        .innerJoin(models, eq(properties.modelId, models.id))
+                        .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
+                        .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
+                        .where(and(eq(schemas.name, schemaName), eq(models.name, modelName), eq(properties.name, propertyName)))
+                        .limit(1);
+                    if (propertyRecords.length > 0 && propertyRecords[0].propertyId != null) {
+                        await db
+                            .delete(properties)
+                            .where(eq(properties.id, propertyRecords[0].propertyId));
+                    }
+                }
+                if (schemaName) {
+                    const schema = Schema.create(schemaName, { waitForReady: false });
+                    const snapshot = schema.getService().getSnapshot();
+                    const schemaContext = snapshot.context;
+                    if (schemaContext.models?.[modelName]?.properties?.[propertyName]) {
+                        const updatedModels = { ...schemaContext.models };
+                        const updatedProperties = { ...updatedModels[modelName].properties };
+                        delete updatedProperties[propertyName];
+                        updatedModels[modelName] = { ...updatedModels[modelName], properties: updatedProperties };
+                        schema.getService().send({ type: 'updateContext', models: updatedModels });
+                        schema.getService().send({ type: 'markAsDraft', propertyKey: `property:${modelName}:${propertyName}` });
+                    }
+                }
+            },
+        });
+    }
 }
 ModelProperty.instanceCache = new Map();
 // Pending writes tracking
@@ -2214,5 +1746,5 @@ var ModelProperty$1 = /*#__PURE__*/Object.freeze({
     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
+export { ModelProperty };
+//# sourceMappingURL=ModelProperty-CGdkocQ8.js.map