@seedprotocol/sdk 0.4.4 → 0.4.5

package/dist/{Schema-ClTcpgbt.js → Schema-D1eqDHyt.js}

@@ -1,22 +1,737 @@
 import { fromCallback, setup, assign, createActor } from 'xstate';
-import { aG as SEED_PROTOCOL_SCHEMA_NAME, p as BaseDb, W as schemas, aH as addSchemaToDb, ag as generateId, ae as createModelsFromJson, a2 as addModelsToDb, q as models, G as modelSchemas, r as properties, aE as listCompleteSchemaFiles, s as BaseFileManager, aI as loadModelsFromDbForSchema, ad as getLatestSchemaVersion, aJ as isInternalSchema, aK as createModelFromJson, M as Model, af as writeProcessMachine, ah as waitForEntityIdle, ai as createReactiveProxy, aj as findEntity, aq as loadAllSchemasFromDb, aL as ConflictError, aM as unloadEntity, aN as clearDestroySubscriptions, ak as forceRemoveFromCaches, al as runDestroyLifecycle, aO as setupEntityLiveQuery } from './ClientManager-DoHUt8tU.js';
+import { a as ModelPropertyDataTypes, aG as getLatestSchemaVersion, x as BaseFileManager, p as BaseDb, q as models, W as schemas, ae as generateId, aH as createModelsFromJson, aa as loadSchemaFromFile, aI as SEED_PROTOCOL_SCHEMA_NAME, aJ as addSchemaToDb, a2 as addModelsToDb, G as modelSchemas, r as properties, aE as listCompleteSchemaFiles, aK as loadModelsFromDbForSchema, aL as isInternalSchema, aM as createModelFromJson, M as Model, ad as writeProcessMachine, af as waitForEntityIdle, ag as createReactiveProxy, ah as findEntity, aq as loadAllSchemasFromDb, aN as ConflictError, am as getClient, an as ClientManagerState, aO as unloadEntity, aP as clearDestroySubscriptions, ai as forceRemoveFromCaches, aj as runDestroyLifecycle, aQ as setupEntityLiveQuery } from './index-DPll6EAp.js';
 import { eq, desc, and } from 'drizzle-orm';
 import debug from 'debug';
-import { SchemaValidationService } from './SchemaValidationService-BfoEiHNr.js';
-import { M as ModelProperty, c as convertPropertyToSchemaUpdate, w as writeFullSchemaNewVersion, u as updateModelProperties } from './ModelProperty-gjcA83Mq.js';
+import { SchemaValidationService } from './SchemaValidationService-DyttFaV_.js';
 import 'pluralize';
-import 'rxjs';
-import 'lodash-es';
-import 'drizzle-orm/casing';
-import '@sinclair/typebox';
-import 'arweave';
-import 'eventemitter3';
-import 'drizzle-orm/sqlite-core';
-import 'nanoid';
-import 'nanoid-dictionary';
-import 'ethers';
-import '@sinclair/typebox/value';
-import 'reflect-metadata';
+
+const logger$d = 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$1 = (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$2 = (name, version, schemaFileId) => {
+    const path = BaseFileManager.getPathModule();
+    const workingDir = BaseFileManager.getWorkingDir();
+    const sanitizedName = sanitizeSchemaName$1(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 db = BaseDb.getAppDb();
+    if (!db)
+        throw new Error('Database not available');
+    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;
+}
+/**
+ * Write the full schema to a new version file (e.g. when new models were added).
+ * Used when _editedProperties contains 'schema:models' and there are no property-level updates.
+ * @param schemaName - Schema name
+ * @param schema - Full schema object (e.g. from _buildModelsFromInstances)
+ * @returns The file path of the new schema version
+ */
+async function writeFullSchemaNewVersion(schemaName, schema) {
+    const latestVersion = await getLatestSchemaVersion(schemaName);
+    const newVersion = latestVersion + 1;
+    const schemaWithNewVersion = {
+        ...schema,
+        version: newVersion,
+        metadata: {
+            ...schema.metadata,
+            updatedAt: new Date().toISOString(),
+        },
+        migrations: [
+            ...(schema.migrations || []),
+            {
+                version: newVersion,
+                timestamp: new Date().toISOString(),
+                description: 'New schema version (e.g. new models added)',
+                changes: [{ type: 'full_schema_write' }],
+            },
+        ],
+    };
+    const newFilePath = getSchemaFilePath$2(schemaName, newVersion, schema.id ?? (await getSchemaFileId(schemaName)));
+    const newContent = JSON.stringify(schemaWithNewVersion, null, 2);
+    await BaseFileManager.saveFile(newFilePath, newContent);
+    await BaseFileManager.waitForFileWithContent(newFilePath);
+    logger$d(`Created new schema version ${newVersion} for ${schemaName} at ${newFilePath}`);
+    return newFilePath;
+}
+/**
+ * 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$2(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$2(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$d(`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,
+            },
+        ])),
+    };
+    // Generate schema ID if missing
+    if (!schemaFile.id) {
+        schemaFile.id = generateId();
+        logger$d('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();
+    for (const [modelName, model] of Object.entries(schemaFile.models)) {
+        // Generate model ID if missing
+        if (!model.id) {
+            model.id = generateId();
+            logger$d(`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$d(`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('./index-DPll6EAp.js').then(function (n) { return n.aT; });
+    // 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$d('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$2(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$2(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$d(`Renamed property ${oldPropertyName} to ${newPropertyName} in schema ${schemaName} v${newVersion}`);
+    // 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$2(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$2(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$d(`Deleted model ${modelName} from schema ${schemaName} v${newVersion}`);
+    // 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$2(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$2(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$d(`Deleted property ${propertyName} from model ${modelName} in schema ${schemaName} v${newVersion}`);
+    // Load the new schema file
+    await loadSchemaFromFile(newFilePath);
+    return newFilePath;
+}
 
 const logger$c = debug('seedSdk:schema:actors:loadOrCreateSchema');
 /**
@@ -60,7 +775,7 @@ const createModelInstances$2 = async (modelIds) => {
         return;
     }
     try {
-        const { Model } = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aX; });
+        const { Model } = await import('./index-DPll6EAp.js').then(function (n) { return n.aW; });
         // Create instances for all model IDs in parallel
         // Model.createById() will check cache first, then query DB and create if needed
         const createPromises = modelIds.map(async (modelFileId) => {
@@ -173,7 +888,7 @@ const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
             logger$c(`Loading internal Seed Protocol schema from SDK`);
             console.log('[loadOrCreateSchema] Loading internal Seed Protocol schema from SDK');
             try {
-                const internalSchema = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aZ; });
+                const internalSchema = await import('./index-DPll6EAp.js').then(function (n) { return n.aV; });
                 const schemaFile = internalSchema.default;
                 console.log('[loadOrCreateSchema] Loaded schema file, models count:', Object.keys(schemaFile.models || {}).length);
                 // Check if it exists in database, if not, add it
@@ -673,7 +1388,7 @@ const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
                     // Ensure models are populated (fallback for seed-protocol if missing)
                     if ((!mergedModels || Object.keys(mergedModels).length === 0) && schemaName === 'Seed Protocol') {
                         try {
-                            const internalSchema = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aZ; });
+                            const internalSchema = await import('./index-DPll6EAp.js').then(function (n) { return n.aV; });
                             const internalSchemaFile = internalSchema.default;
                             mergedModels = { ...(internalSchemaFile.models || {}) };
                             logger$c(`Populated models for seed-protocol schema from internal file`);
@@ -868,7 +1583,7 @@ const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
                     // Ensure models are populated (fallback for seed-protocol if missing)
                     if ((!mergedModels || Object.keys(mergedModels).length === 0) && schemaName === 'Seed Protocol') {
                         try {
-                            const internalSchema = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aZ; });
+                            const internalSchema = await import('./index-DPll6EAp.js').then(function (n) { return n.aV; });
                             const internalSchemaFile = internalSchema.default;
                             mergedModels = { ...(internalSchemaFile.models || {}) };
                             logger$c(`Populated models for seed-protocol schema from internal file`);
@@ -940,7 +1655,7 @@ const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
                         // Ensure models are populated (fallback for seed-protocol if missing)
                         if ((!mergedModels || Object.keys(mergedModels).length === 0) && schemaName === 'Seed Protocol') {
                             try {
-                                const internalSchema = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aZ; });
+                                const internalSchema = await import('./index-DPll6EAp.js').then(function (n) { return n.aV; });
                                 const internalSchemaFile = internalSchema.default;
                                 mergedModels = { ...(internalSchemaFile.models || {}) };
                                 logger$c(`Populated models for seed-protocol schema from internal file`);
@@ -1009,7 +1724,7 @@ const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
                 // If schemaData is missing, try to load from internal schema file for seed-protocol
                 if (!dbSchema.schemaData && schemaName === 'Seed Protocol') {
                     try {
-                        const internalSchema = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aZ; });
+                        const internalSchema = await import('./index-DPll6EAp.js').then(function (n) { return n.aV; });
                         const schemaFile = internalSchema.default;
                         logger$c(`Found seed-protocol schema in internal file (schemaData missing, using internal schema)`);
                         // Update database with schemaData for future loads
@@ -1118,7 +1833,7 @@ const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
             // Ensure models are populated (fallback for seed-protocol if missing)
             if ((!mergedModels || Object.keys(mergedModels).length === 0) && schemaName === 'Seed Protocol') {
                 try {
-                    const internalSchema = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aZ; });
+                    const internalSchema = await import('./index-DPll6EAp.js').then(function (n) { return n.aV; });
                     const internalSchemaFile = internalSchema.default;
                     mergedModels = { ...(internalSchemaFile.models || {}) };
                     logger$c(`Populated models for seed-protocol schema from internal file`);
@@ -1434,20 +2149,15 @@ const addModelsMachine = setup({
         }),
         createModelInstances: fromCallback(({ sendBack, input }) => {
             const _createInstances = async () => {
-                const { Schema } = await Promise.resolve().then(function () { return Schema$1; });
-                const { BaseDb } = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aP; });
-                const { models: modelsTable } = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aQ; });
-                const { eq } = await import('drizzle-orm');
-                const { generateId } = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aS; });
                 const debug = (await import('debug')).default;
                 const logger = debug('seedSdk:schema:addModels:createInstances');
+                const { Schema: SchemaClass, schemaInstanceState } = await Promise.resolve().then(function () { return Schema$1; });
                 const schemaName = input.schemaContext.metadata?.name || input.schemaContext.schemaName;
-                const schemaInstance = Schema.create(schemaName, {
+                const schemaInstance = SchemaClass.create(schemaName, {
                     waitForReady: false,
                 });
                 const modelInstances = new Map();
                 // Get instance state to store model instances
-                const { schemaInstanceState } = await Promise.resolve().then(function () { return Schema$1; });
                 const instanceState = schemaInstanceState.get(schemaInstance);
                 if (!instanceState) {
                     throw new Error('Schema instance state not found');
@@ -1462,8 +2172,8 @@ const addModelsMachine = setup({
                             if (db) {
                                 const dbModels = await db
                                     .select()
-                                    .from(modelsTable)
-                                    .where(eq(modelsTable.name, modelName))
+                                    .from(models)
+                                    .where(eq(models.name, modelName))
                                     .limit(1);
                                 if (dbModels.length > 0 && dbModels[0].schemaFileId) {
                                     modelFileId = dbModels[0].schemaFileId;
@@ -1665,9 +2375,6 @@ const addModelsMachine = setup({
             const _persist = async () => {
                 const debug = (await import('debug')).default;
                 const logger = debug('seedSdk:schema:addModels:persist');
-                const { BaseDb } = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aP; });
-                const { schemas: schemasTable } = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aU; });
-                const { eq } = await import('drizzle-orm');
                 // Only process in browser environment where store is available
                 if (typeof window === 'undefined') {
                     logger('Not in browser environment, skipping store update');
@@ -1703,8 +2410,8 @@ const addModelsMachine = setup({
                         logger(`Looking up schema by schemaFileId: ${schemaFileId} (attempt ${attempt + 1})`);
                         const schemasById = await db
                             .select()
-                            .from(schemasTable)
-                            .where(eq(schemasTable.schemaFileId, schemaFileId))
+                            .from(schemas)
+                            .where(eq(schemas.schemaFileId, schemaFileId))
                             .limit(1);
                         if (schemasById.length > 0) {
                             schemaRecord = schemasById[0];
@@ -1720,12 +2427,11 @@ const addModelsMachine = setup({
                     // FALLBACK: If not found by schemaFileId, try by name (prefer draft records)
                     if (!schemaRecord) {
                         logger(`Looking up schema by name: "${schemaName}" (attempt ${attempt + 1})`);
-                        const { desc } = await import('drizzle-orm');
                         const schemasByName = await db
                             .select()
-                            .from(schemasTable)
-                            .where(eq(schemasTable.name, schemaName))
-                            .orderBy(desc(schemasTable.isDraft), desc(schemasTable.version))
+                            .from(schemas)
+                            .where(eq(schemas.name, schemaName))
+                            .orderBy(desc(schemas.isDraft), desc(schemas.version))
                             .limit(10); // Get multiple to find drafts
                         if (schemasByName.length > 0) {
                             // Prefer draft records
@@ -2024,7 +2730,7 @@ const createModelInstances$1 = async (modelIds) => {
         return;
     }
     try {
-        const mod = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aX; });
+        const mod = await import('./index-DPll6EAp.js').then(function (n) { return n.aW; });
         const Model = mod?.Model ?? mod?.default;
         if (!Model) {
             logger$b('Model not available from dynamic import');
@@ -2069,7 +2775,7 @@ const checkExistingSchema = fromCallback(({ sendBack, input: { context } }) => {
         if (isInternal && schemaName === SEED_PROTOCOL_SCHEMA_NAME) {
             // For Seed Protocol, check if it exists in database
             try {
-                const internalSchema = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aZ; });
+                const internalSchema = await import('./index-DPll6EAp.js').then(function (n) { return n.aV; });
                 const schemaFile = internalSchema.default;
                 if (db && schemaFile.id) {
                     const existing = await db
@@ -2427,7 +3133,7 @@ const writeSchemaToDb = fromCallback(({ sendBack, input }) => {
             if (isInternal && schemaName === SEED_PROTOCOL_SCHEMA_NAME) {
                 // For Seed Protocol, load from internal file
                 logger$a(`Loading internal Seed Protocol schema from SDK`);
-                const internalSchema = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aZ; });
+                const internalSchema = await import('./index-DPll6EAp.js').then(function (n) { return n.aV; });
                 finalSchema = internalSchema.default;
                 const db = BaseDb.getAppDb();
                 if (db && finalSchema.id) {
@@ -2895,7 +3601,7 @@ const createModelInstances = fromCallback(({ sendBack, input }) => {
             return;
         }
         try {
-            const { Model } = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aX; });
+            const { Model } = await import('./index-DPll6EAp.js').then(function (n) { return n.aW; });
             // Create instances for all model IDs in parallel
             // Model.createById() will check cache first, then query DB and create if needed
             const createPromises = modelIds.map(async (modelFileId) => {
@@ -2980,7 +3686,7 @@ const verifyModelInstancesInCache = fromCallback(({ sendBack, input }) => {
         }
         try {
             const result = await verifyWithRetry$2(async () => {
-                const { Model } = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aX; });
+                const { Model } = await import('./index-DPll6EAp.js').then(function (n) { return n.aW; });
                 // Check each model ID in the cache
                 const verifiedInstances = [];
                 const missingIds = [];
@@ -3036,8 +3742,7 @@ const writePropertiesToDb = fromCallback(({ sendBack, input }) => {
     const _write = async () => {
         const { modelIds } = input;
         try {
-            const { BaseDb } = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aP; });
-            const { models: modelsTable, properties: propertiesTable } = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aQ; });
+            const { models: modelsTable, properties: propertiesTable } = await import('./index-DPll6EAp.js').then(function (n) { return n.aR; });
             const { eq } = await import('drizzle-orm');
             const db = BaseDb.getAppDb();
             if (!db) {
@@ -3223,9 +3928,9 @@ const createPropertyInstances = fromCallback(({ sendBack, input }) => {
             return;
         }
         try {
-            const modProp = await import('./ModelProperty-gjcA83Mq.js').then(function (n) { return n.b; });
+            const modProp = await import('./ModelProperty-CGdkocQ8.js');
             const ModelProperty = modProp?.ModelProperty ?? modProp?.default;
-            const modModel = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aX; });
+            const modModel = await import('./index-DPll6EAp.js').then(function (n) { return n.aW; });
             const Model = modModel?.Model ?? modModel?.default;
             if (!ModelProperty || !Model) {
                 logger$2('ModelProperty or Model not available from dynamic import');
@@ -3330,7 +4035,7 @@ const verifyPropertyInstancesInCache = fromCallback(({ sendBack, input }) => {
         }
         try {
             const result = await verifyWithRetry(async () => {
-                const mod = await import('./ModelProperty-gjcA83Mq.js').then(function (n) { return n.b; });
+                const mod = await import('./ModelProperty-CGdkocQ8.js');
                 const ModelProperty = mod?.ModelProperty ?? mod?.default;
                 if (!ModelProperty) {
                     throw new Error('ModelProperty not available from dynamic import');
@@ -4910,7 +5615,6 @@ class Schema {
             throw new ConflictError(errorMessage, conflictCheck);
         }
         const context = this._getSnapshotContext();
-        const { addSchemaToDb } = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aW; });
         if (!context._isDraft || !context._editedProperties || context._editedProperties.size === 0) {
             logger('No changes to save');
             return '';
@@ -4957,6 +5661,7 @@ class Schema {
             .limit(1);
         // Collect all edited properties and convert them to SchemaPropertyUpdate format
         const propertyUpdates = [];
+        const { ModelProperty } = await import('./ModelProperty-CGdkocQ8.js');
         for (const propertyKey of context._editedProperties) {
             // Skip schema-level changes (like schema name changes)
             if (propertyKey === 'schema:name') {
@@ -4986,7 +5691,6 @@ class Schema {
             // When only new models were added, _editedProperties contains 'schema:models' and we write the full schema
             if (context._editedProperties.has('schema:models')) {
                 const newFilePath = await writeFullSchemaNewVersion(this.schemaName, currentSchema);
-                const { BaseFileManager } = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aR; });
                 const fileContent = await BaseFileManager.readFileAsString(newFilePath);
                 const publishedSchema = JSON.parse(fileContent);
                 if (dbSchema.length > 0) {
@@ -5016,7 +5720,6 @@ class Schema {
         const newFilePath = await updateModelProperties(this.schemaName, propertyUpdates);
         // STEP 3: After file is written, update database to mark as published (isDraft = false)
         // Load the file to get the final schema with IDs
-        const { BaseFileManager } = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aR; });
         const fileContent = await BaseFileManager.readFileAsString(newFilePath);
         const publishedSchema = JSON.parse(fileContent);
         // Update database record: set isDraft = false and update schemaFileId
@@ -5211,9 +5914,6 @@ class Schema {
             saveDraftLogger(`Client check: cacheIsStale=${cacheIsStale}, shouldRecheck=${shouldRecheck}, cachedValue=${cachedClientInitialized}, timeSinceCheck=${now - clientCheckTime}ms`);
             if (shouldRecheck) {
                 try {
-                    // Use dynamic import for browser compatibility (require() doesn't work in browsers)
-                    const { getClient } = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.a_; });
-                    const { ClientManagerState } = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aT; });
                     const client = getClient();
                     const clientSnapshot = client.getService().getSnapshot();
                     // Check if state is IDLE (primary check) - isInitialized is set in entry action so should be true
@@ -5284,8 +5984,6 @@ class Schema {
                     _editedProperties: new Set(),
                 };
             }
-            const { addSchemaToDb } = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aW; });
-            const { generateId } = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aS; });
             const db = BaseDb.getAppDb();
             if (!db) {
                 throw new Error('Database not found');
@@ -5852,5 +6550,5 @@ var Schema$1 = /*#__PURE__*/Object.freeze({
     schemaInstanceState: schemaInstanceState
 });
 
-export { Schema, schemaInstanceState };
-//# sourceMappingURL=Schema-ClTcpgbt.js.map
+export { Schema as S, deleteModelFromSchema as a, Schema$1 as b, convertPropertyToSchemaUpdate as c, deletePropertyFromModel as d, renameModelProperty as r, updateModelProperties as u };
+//# sourceMappingURL=Schema-D1eqDHyt.js.map