@seedprotocol/sdk 0.7.3 → 0.7.4-next.784.g879c6a3

package/dist/{Schema-CpMNEnUO.js → Schema-Dc5EA8Yb.js}

@@ -1,12 +1,12 @@
 import { fromCallback, setup, assign, createActor } from 'xstate';
-import { g as getRefValueType, G as createModelsFromJson, p as listCompleteSchemaFiles, H as getLatestSchemaVersion, l as loadSchemaFromFile, J as jsonPropertiesToSchemaProperties, q as loadAllSchemasFromDb, k as getClient } from './ClientManager-i3nJASkg.js';
-import { aq as SEED_PROTOCOL_SCHEMA_NAME, E as BaseDb, z as schemas, aI as addSchemaToDb, i as isDataType, M as ModelPropertyDataTypes, $ as generateId, a2 as addModelsToDb, s as models, q as modelSchemas, u as properties, J as BaseFileManager, aK as loadModelsFromDbForSchema, aF as isInternalSchema } from './BasePathResolver-Cm4apKRb.js';
+import { g as getRefValueType, G as createModelsFromJson, p as listCompleteSchemaFiles, H as getLatestSchemaVersion, l as loadSchemaFromFile, J as jsonPropertiesToSchemaProperties, q as loadAllSchemasFromDb, k as getClient } from './ClientManager-De-vKHGe.js';
+import { aq as SEED_PROTOCOL_SCHEMA_NAME, E as BaseDb, z as schemas, aI as addSchemaToDb, i as isDataType, M as ModelPropertyDataTypes, $ as generateId, a2 as addModelsToDb, s as models, q as modelSchemas, u as properties, J as BaseFileManager, aK as loadModelsFromDbForSchema, aF as isInternalSchema } from './BasePathResolver-DxdS0wJ0.js';
 import { eq, desc, and } from 'drizzle-orm';
 import debug from 'debug';
-import { c as currentEvictionEpoch, w as writeProcessMachine, M as Model, C as ConflictError, d as setupEntityLiveQuery } from './index-8O3Uow-Y.js';
+import { c as currentEvictionEpoch, w as writeProcessMachine, t as trackDraftSave, M as Model, g as getDraftSaveError, C as ConflictError, r as recordSchemaDestroy, f as finishSchemaDestroy, d as setupEntityLiveQuery } from './errors-Cl8rbtKR.js';
 import 'pluralize';
-import { SchemaValidationService } from './SchemaValidationService-DieV4KL-.js';
-import { D as DEFAULT_READY_TIMEOUT_MS, n as waitForEntityIdle, o as createReactiveProxy, q as findEntity, C as ClientManagerState, a0 as clearDestroySubscriptions, t as forceRemoveFromCaches, a1 as unloadEntity, u as runDestroyLifecycle } from './Item-DBFchXpC.js';
+import { SchemaValidationService } from './SchemaValidationService-DViJ056F.js';
+import { D as DEFAULT_READY_TIMEOUT_MS, n as waitForEntityIdle, o as createReactiveProxy, q as findEntity, C as ClientManagerState, a0 as clearDestroySubscriptions, t as forceRemoveFromCaches, a1 as unloadEntity, u as runDestroyLifecycle } from './Item-cq9VcsAY.js';
 
 const logger$d = debug('seedSdk:schema:actors:loadOrCreateSchema');
 /**
@@ -50,8 +50,8 @@ const createModelInstances$2 = async (modelIds, evictionEpoch) => {
         return;
     }
     try {
-        const _mod_0 = await import('./index-8O3Uow-Y.js');
-        const _ns_0 = _mod_0.f;
+        const _mod_0 = await import('./errors-Cl8rbtKR.js');
+        const _ns_0 = _mod_0.h;
         const modelMod = _ns_0;
         const { Model } = modelMod;
         // Create instances for all model IDs in parallel
@@ -167,7 +167,7 @@ const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
             // For Seed Protocol, always load from internal file, never create new
             logger$d(`Loading internal Seed Protocol schema from SDK`);
             try {
-                const _mod_1 = await import('./ClientManager-i3nJASkg.js');
+                const _mod_1 = await import('./ClientManager-De-vKHGe.js');
                 const _ns_1 = _mod_1.S;
                 const internalSchema = _ns_1;
                 const schemaFile = internalSchema.default;
@@ -662,7 +662,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 _mod_2 = await import('./ClientManager-i3nJASkg.js');
+                            const _mod_2 = await import('./ClientManager-De-vKHGe.js');
                             const _ns_2 = _mod_2.S;
                             const internalSchema = _ns_2;
                             const internalSchemaFile = internalSchema.default;
@@ -850,7 +850,9 @@ const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
                     try {
                         // Try to find file by schemaFileId in the complete schemas list
                         const completeSchemas = await listCompleteSchemaFiles();
-                        const idBasedMatch = completeSchemas.find((s) => s.schemaFileId === dbSchema.schemaFileId);
+                        // Match version too: the row is per schema name, so after a new version is imported
+                        // under a new id it can carry the newer version with the older version's schemaFileId.
+                        const idBasedMatch = completeSchemas.find((s) => s.schemaFileId === dbSchema.schemaFileId && s.version === dbSchema.version);
                         if (idBasedMatch) {
                             logger$d(`Found schema file by schemaFileId: ${idBasedMatch.filePath}`);
                             const content = await BaseFileManager.readFileAsString(idBasedMatch.filePath);
@@ -891,7 +893,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 _mod_3 = await import('./ClientManager-i3nJASkg.js');
+                            const _mod_3 = await import('./ClientManager-De-vKHGe.js');
                             const _ns_3 = _mod_3.S;
                             const internalSchema = _ns_3;
                             const internalSchemaFile = internalSchema.default;
@@ -982,7 +984,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 _mod_4 = await import('./ClientManager-i3nJASkg.js');
+                                const _mod_4 = await import('./ClientManager-De-vKHGe.js');
                                 const _ns_4 = _mod_4.S;
                                 const internalSchema = _ns_4;
                                 const internalSchemaFile = internalSchema.default;
@@ -1070,7 +1072,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 _mod_5 = await import('./ClientManager-i3nJASkg.js');
+                        const _mod_5 = await import('./ClientManager-De-vKHGe.js');
                         const _ns_5 = _mod_5.S;
                         const internalSchema = _ns_5;
                         const schemaFile = internalSchema.default;
@@ -1181,7 +1183,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 _mod_6 = await import('./ClientManager-i3nJASkg.js');
+                    const _mod_6 = await import('./ClientManager-De-vKHGe.js');
                     const _ns_6 = _mod_6.S;
                     const internalSchema = _ns_6;
                     const internalSchemaFile = internalSchema.default;
@@ -1508,8 +1510,8 @@ const createModelInstances$1 = async (modelIds, evictionEpoch) => {
         return;
     }
     try {
-        const _mod_7 = await import('./index-8O3Uow-Y.js');
-        const _ns_7 = _mod_7.f;
+        const _mod_7 = await import('./errors-Cl8rbtKR.js');
+        const _ns_7 = _mod_7.h;
         const mod = _ns_7;
         const Model = mod?.Model ?? mod?.default;
         if (!Model) {
@@ -1557,7 +1559,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 _mod_8 = await import('./ClientManager-i3nJASkg.js');
+                const _mod_8 = await import('./ClientManager-De-vKHGe.js');
                 const _ns_8 = _mod_8.S;
                 const internalSchema = _ns_8;
                 const schemaFile = internalSchema.default;
@@ -1724,7 +1726,9 @@ const checkExistingSchema = fromCallback(({ sendBack, input: { context } }) => {
                 // Try to load from file
                 try {
                     const completeSchemas = await listCompleteSchemaFiles();
-                    const idBasedMatch = completeSchemas.find((s) => s.schemaFileId === dbSchema.schemaFileId);
+                    // Match version too: the row is per schema name, so after a new version is imported
+                    // under a new id it can carry the newer version with the older version's schemaFileId.
+                    const idBasedMatch = completeSchemas.find((s) => s.schemaFileId === dbSchema.schemaFileId && s.version === dbSchema.version);
                     if (idBasedMatch) {
                         const content = await BaseFileManager.readFileAsString(idBasedMatch.filePath);
                         schemaFile = JSON.parse(content);
@@ -1917,7 +1921,7 @@ const writeSchemaToDb = fromCallback(({ sendBack, input }) => {
             if (isInternal && schemaName === SEED_PROTOCOL_SCHEMA_NAME) {
                 // For Seed Protocol, load from internal file
                 logger$b(`Loading internal Seed Protocol schema from SDK`);
-                const _mod_9 = await import('./ClientManager-i3nJASkg.js');
+                const _mod_9 = await import('./ClientManager-De-vKHGe.js');
                 const _ns_9 = _mod_9.S;
                 const internalSchema = _ns_9;
                 finalSchema = internalSchema.default;
@@ -2388,8 +2392,8 @@ const createModelInstances = fromCallback(({ sendBack, input }) => {
             return;
         }
         try {
-            const _mod_10 = await import('./index-8O3Uow-Y.js');
-            const _ns_10 = _mod_10.f;
+            const _mod_10 = await import('./errors-Cl8rbtKR.js');
+            const _ns_10 = _mod_10.h;
             const modelMod = _ns_10;
             const { Model } = modelMod;
             // Create instances for all model IDs in parallel
@@ -2477,8 +2481,8 @@ const verifyModelInstancesInCache = fromCallback(({ sendBack, input }) => {
         }
         try {
             const result = await verifyWithRetry$2(async () => {
-                const _mod_11 = await import('./index-8O3Uow-Y.js');
-                const _ns_11 = _mod_11.f;
+                const _mod_11 = await import('./errors-Cl8rbtKR.js');
+                const _ns_11 = _mod_11.h;
                 const modelMod = _ns_11;
                 const { Model } = modelMod;
                 // Check each model ID in the cache
@@ -2536,8 +2540,8 @@ const writePropertiesToDb = fromCallback(({ sendBack, input }) => {
     const _write = async () => {
         const { modelIds } = input;
         try {
-            const _mod_12 = await import('./BasePathResolver-Cm4apKRb.js');
-            const _ns_12 = _mod_12.aZ;
+            const _mod_12 = await import('./BasePathResolver-DxdS0wJ0.js');
+            const _ns_12 = _mod_12.a_;
             const modelSchemaMod = _ns_12;
             const { models: modelsTable, properties: propertiesTable } = modelSchemaMod;
             const drizzleMod = await import('drizzle-orm');
@@ -2726,10 +2730,10 @@ const createPropertyInstances = fromCallback(({ sendBack, input }) => {
             return;
         }
         try {
-            const modProp = await import('./ModelProperty-BS49g01Y.js');
+            const modProp = await import('./ModelProperty-DuuoFXaC.js');
             const ModelProperty = modProp?.ModelProperty ?? modProp?.default;
-            const _mod_13 = await import('./index-8O3Uow-Y.js');
-            const _ns_13 = _mod_13.f;
+            const _mod_13 = await import('./errors-Cl8rbtKR.js');
+            const _ns_13 = _mod_13.h;
             const modModel = _ns_13;
             const Model = modModel?.Model ?? modModel?.default;
             if (!ModelProperty || !Model) {
@@ -2835,7 +2839,7 @@ const verifyPropertyInstancesInCache = fromCallback(({ sendBack, input }) => {
         }
         try {
             const result = await verifyWithRetry(async () => {
-                const mod = await import('./ModelProperty-BS49g01Y.js');
+                const mod = await import('./ModelProperty-DuuoFXaC.js');
                 const ModelProperty = mod?.ModelProperty ?? mod?.default;
                 if (!ModelProperty) {
                     throw new Error('ModelProperty not available from dynamic import');
@@ -2992,6 +2996,13 @@ const schemaMachine = setup({
                 if (event._dbVersion !== undefined) {
                     newContext._dbVersion = event._dbVersion;
                 }
+                // saveNewVersion passes the schema it just wrote: the instance now is that version.
+                const saved = event.savedSchema;
+                if (saved) {
+                    newContext.version = saved.version;
+                    newContext.metadata = saved.metadata;
+                    newContext.migrations = saved.migrations;
+                }
                 return newContext;
             }),
         },
@@ -3065,6 +3076,13 @@ const schemaMachine = setup({
                                 _schemaRecord: ({ event }) => event.schemaRecord,
                                 id: ({ event }) => event.schema.id, // schemaFileId (string)
                                 _dbId: ({ event }) => event.schemaRecord?.id, // Database integer ID
+                                // A schema created in code has these only in the written record; without them
+                                // validation (and so saveNewVersion) failed with "Schema metadata is required".
+                                $schema: ({ context, event }) => context.$schema ?? event.schema.$schema,
+                                version: ({ context, event }) => context.version ?? event.schema.version,
+                                metadata: ({ context, event }) => context.metadata ?? event.schema.metadata,
+                                enums: ({ context, event }) => context.enums ?? event.schema.enums,
+                                migrations: ({ context, event }) => context.migrations ?? event.schema.migrations,
                             }),
                         },
                         writeError: {
@@ -3538,6 +3556,95 @@ async function writeFullSchemaNewVersion(schemaName, schema) {
     logger$1(`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 (isDataType(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 (isDataType(property.dataType, ModelPropertyDataTypes.List)) {
+        if (property.refValueType) {
+            updates.refValueType = property.refValueType;
+            if (property.ref) {
+                updates.ref = 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.ref = refModelName;
+                }
+            }
+        }
+    }
+    // Handle required (validation constraint)
+    if (property.required !== undefined) {
+        updates.required = property.required;
+    }
+    // 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
@@ -3750,8 +3857,8 @@ async function loadSchemaWithRenames(schemaFilePath, modelRenames) {
         updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
     };
     // Use dynamic import to break circular dependency
-    const _mod_14 = await import('./BasePathResolver-Cm4apKRb.js');
-    const _ns_14 = _mod_14.b2;
+    const _mod_14 = await import('./BasePathResolver-DxdS0wJ0.js');
+    const _ns_14 = _mod_14.b3;
     const dbMod = _ns_14;
     const { addSchemaToDb, addModelsToDb } = dbMod;
     // Add schema to database with schemaFileId
@@ -3870,8 +3977,8 @@ async function renameModelProperty(schemaName, modelName, oldPropertyName, newPr
     await BaseFileManager.waitForFileWithContent(newFilePath);
     logger$1(`Renamed property ${oldPropertyName} to ${newPropertyName} in schema ${schemaName} v${newVersion}`);
     // Migrate metadata rows so ItemProperty values follow the new name (prevents duplicate ItemProperties)
-    const _mod_15 = await import('./BasePathResolver-Cm4apKRb.js');
-    const _ns_15 = _mod_15.b2;
+    const _mod_15 = await import('./BasePathResolver-DxdS0wJ0.js');
+    const _ns_15 = _mod_15.b3;
     const { migrateMetadataForPropertyRename } = _ns_15;
     const migratedCount = await migrateMetadataForPropertyRename(modelName, oldPropertyName, newPropertyName, oldProperty.id, { schemaName });
     if (migratedCount > 0) {
@@ -4116,6 +4223,17 @@ async function deletePropertyFromModel(schemaName, modelName, propertyName, opti
     return newFilePath;
 }
 
+var updateSchema = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    convertPropertyToSchemaUpdate: convertPropertyToSchemaUpdate,
+    deleteModelFromSchema: deleteModelFromSchema,
+    deletePropertyFromModel: deletePropertyFromModel,
+    getModelNameFromId: getModelNameFromId,
+    renameModelProperty: renameModelProperty,
+    updateModelProperties: updateModelProperties,
+    writeFullSchemaNewVersion: writeFullSchemaNewVersion
+});
+
 const logger = debug('seedSdk:schema:saveNewVersion');
 const saveDraftLogger = debug('seedSdk:schema:saveDraftToDb');
 // WeakMap to store non-serializable resources per Schema instance
@@ -4349,10 +4467,7 @@ class Schema {
                         });
                         // Save draft to database immediately so changes persist
                         saveDraftLogger(`Name change detected, calling _saveDraftToDb (oldName: "${oldName}", newName: "${newName}")`);
-                        instance._saveDraftToDb(oldName, newName).catch((error) => {
-                            saveDraftLogger(`ERROR: Failed to save draft after name change: ${error instanceof Error ? error.message : String(error)}`);
-                            logger(`Failed to save draft to database: ${error instanceof Error ? error.message : String(error)}`);
-                        });
+                        trackDraftSave(instance._service, instance._saveDraftToDb(oldName, newName), `Schema "${newName}"`);
                     }
                     else {
                         logger(`Schema name unchanged: "${oldName}"`);
@@ -4396,9 +4511,7 @@ class Schema {
                     if (TRACKED_PROPERTIES.includes(prop)) {
                         const trackedPropContext = newInstance._getSnapshotContext();
                         const schemaName = trackedPropContext.metadata?.name || trackedPropContext.schemaName;
-                        newInstance._saveDraftToDb(schemaName, schemaName).catch((error) => {
-                            logger(`Failed to save draft to database: ${error instanceof Error ? error.message : String(error)}`);
-                        });
+                        trackDraftSave(newInstance._service, newInstance._saveDraftToDb(schemaName, schemaName), `Schema "${schemaName}"`);
                     }
                 }
             },
@@ -4794,6 +4907,13 @@ class Schema {
     get validationErrors() {
         return this._getSnapshotContext()._validationErrors || [];
     }
+    /**
+     * The error from the last draft save that an assignment started (e.g. `schema.name = ...`),
+     * such as a ConflictError; undefined once a later one succeeds.
+     */
+    get lastSaveError() {
+        return getDraftSaveError(this._service);
+    }
     get isValid() {
         const errors = this.validationErrors;
         return errors.length === 0;
@@ -4834,36 +4954,63 @@ class Schema {
         });
     }
     /**
-     * Build models object from Model instances (for persistence)
-     * Model instances are the source of truth for model data
+     * Build the file-format `models` object from this schema's Model instances: every model
+     * (those created at runtime too), each property as its file definition ({ id, type, model,
+     * ref, refValueType, required, storage, validation, ... }).
      */
-    _buildModelsFromInstances() {
+    async _buildModelsFromInstances() {
         const context = this._getSnapshotContext();
+        const { convertPropertyToSchemaUpdate } = await Promise.resolve().then(function () { return updateSchema; });
         const models = {};
-        // Get model IDs from service context (reactive state)
-        const modelIds = context._liveQueryModelIds || [];
-        // Iterate through Model instances from static cache
-        for (const modelFileId of modelIds) {
-            const modelInstance = Model.getById(modelFileId);
-            if (!modelInstance)
-                continue;
+        for (const modelInstance of this.models) {
             try {
                 const modelName = modelInstance.modelName;
-                if (!modelName) {
-                    logger(`Model instance with ID ${modelFileId} has no modelName, skipping`);
+                if (!modelName)
                     continue;
+                const properties$1 = {};
+                let propertyContexts = (modelInstance.properties ?? []).map((property) => property.getService().getSnapshot().context);
+                // model.properties can still be empty for a model created at runtime (the browser fills
+                // it from a live query): read the rows, preferring each row's cached instance.
+                const modelDbId = modelInstance.getService().getSnapshot().context._dbId;
+                const db = BaseDb.getAppDb();
+                if (propertyContexts.length === 0 && modelDbId && db) {
+                    const { ModelProperty } = await import('./ModelProperty-DuuoFXaC.js');
+                    const rows = await db.select().from(properties).where(eq(properties.modelId, modelDbId));
+                    propertyContexts = rows.map((row) => {
+                        const cached = row.schemaFileId ? ModelProperty.getById(row.schemaFileId) : undefined;
+                        return cached
+                            ? cached.getService().getSnapshot().context
+                            : {
+                                ...row,
+                                id: row.schemaFileId ?? undefined,
+                                refModelId: row.refModelId ?? undefined,
+                                refValueType: row.refValueType ?? undefined,
+                                storageType: row.storageType ?? undefined,
+                                localStorageDir: row.localStorageDir ?? undefined,
+                                filenameSuffix: row.filenameSuffix ?? undefined,
+                            };
+                    });
                 }
-                // Build model definition from Model instance context
-                // CRITICAL: Read properties from ModelProperty instances, not from Model's properties context
-                // ModelProperty instances are the source of truth for property data
-                const propertiesFromInstances = modelInstance._buildPropertiesFromInstances?.() || modelInstance.properties || {};
+                for (const ctx of propertyContexts) {
+                    if (!ctx.name)
+                        continue;
+                    const { updates } = await convertPropertyToSchemaUpdate(ctx, modelName, ctx.name);
+                    properties$1[ctx.name] = {
+                        ...(ctx.id ? { id: ctx.id } : {}),
+                        ...updates,
+                        ...(ctx.validation ? { validation: ctx.validation } : {}),
+                        ...(ctx.htmlEmbeddedDataUriPolicy ? { htmlEmbeddedDataUriPolicy: ctx.htmlEmbeddedDataUriPolicy } : {}),
+                    };
+                }
+                // No property instances loaded for this model: keep the definitions the schema has.
+                const fromContext = context.models?.[modelName]?.properties;
                 models[modelName] = {
-                    properties: propertiesFromInstances,
+                    ...(modelInstance.id ? { id: modelInstance.id } : {}),
+                    properties: Object.keys(properties$1).length > 0 || !fromContext ? properties$1 : fromContext,
                 };
-                logger(`Built model "${modelName}" from Model instance (ID: ${modelFileId})`);
             }
             catch (error) {
-                logger(`Error building model from instance (ID: ${modelFileId}): ${error instanceof Error ? error.message : String(error)}`);
+                logger(`Error building model from instance: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
         logger(`Built ${Object.keys(models).length} models from Model instances`);
@@ -4904,7 +5051,7 @@ class Schema {
         // Build current schema state from context
         // CRITICAL: Read models from Model instances, not from Schema context
         // Model instances are the source of truth for model data
-        const modelsFromInstances = this._buildModelsFromInstances();
+        const modelsFromInstances = await this._buildModelsFromInstances();
         const currentSchema = {
             id: context.id,
             $schema: context.$schema || 'https://seedprotocol.org/schemas/data-model/v1',
@@ -4977,9 +5124,10 @@ class Schema {
             type: 'clearDraft',
             _dbUpdatedAt: new Date(publishedSchema.metadata.updatedAt).getTime(),
             _dbVersion: publishedSchema.version,
+            savedSchema: publishedSchema,
         });
         // Clear edited flags on all ModelProperty instances and in database
-        const modelPropertyMod = await import('./ModelProperty-BS49g01Y.js');
+        const modelPropertyMod = await import('./ModelProperty-DuuoFXaC.js');
         const { ModelProperty } = modelPropertyMod;
         for (const propertyKey of context._editedProperties) {
             const [modelName, propertyName] = propertyKey.split(':');
@@ -5003,8 +5151,8 @@ class Schema {
                 try {
                     if (db && modelName && propertyName) {
                         // Find this schema's model by name
-                        const _mod_16 = await import('./BasePathResolver-Cm4apKRb.js');
-                        const _ns_16 = _mod_16.b1;
+                        const _mod_16 = await import('./BasePathResolver-DxdS0wJ0.js');
+                        const _ns_16 = _mod_16.b2;
                         const { resolveModelRecord } = _ns_16;
                         const modelRecord = await resolveModelRecord(modelName, { schemaName: thisSchemaName }, db);
                         const modelRecords = modelRecord ? [modelRecord] : [];
@@ -5309,7 +5457,7 @@ class Schema {
             const finalSchemaFileId = existingSchemaRecord?.schemaFileId || schemaFileId;
             // CRITICAL: Read models from Model instances, not from Schema context
             // Model instances are the source of truth for model data
-            const modelsFromInstances = this._buildModelsFromInstances();
+            const modelsFromInstances = await this._buildModelsFromInstances();
             const currentSchema = {
                 $schema: context.$schema || 'https://seedprotocol.org/schemas/data-model/v1',
                 version: context.version || 1,
@@ -5610,14 +5758,28 @@ class Schema {
                 Schema.instanceCacheByName,
             ],
         });
+        // Until its rows are gone, nothing may re-create this schema's models. Its own actor stays live
+        // till then, and its live query reacting to destroyStarted could read a model row the drained
+        // write had just landed and re-create (and re-write) that model after the delete below.
+        if (schemaName)
+            recordSchemaDestroy(schemaName);
+        try {
+            await this._destroyRows(schemaFileId, schemaName, context.metadata?.name);
+        }
+        finally {
+            if (schemaName)
+                finishSchemaDestroy(schemaName);
+        }
+    }
+    async _destroyRows(schemaFileId, schemaName, metadataName) {
         // The rows for this schema's models and properties are deleted below; evict their cached
         // instances too, or a re-import would get them back with dangling _dbIds.
         if (schemaName) {
             const evictedModelNames = Model.evictForSchema(schemaName);
-            const { ModelProperty } = await import('./ModelProperty-BS49g01Y.js');
+            const { ModelProperty } = await import('./ModelProperty-DuuoFXaC.js');
             ModelProperty.evictForModels(evictedModelNames, schemaName);
             // Evicting stops new writes but not ones already running; let those land before deleting their rows
-            const _mod_17 = await import('./index-8O3Uow-Y.js');
+            const _mod_17 = await import('./errors-Cl8rbtKR.js');
             const _ns_17 = _mod_17.e;
             const { waitForInFlightWrites } = _ns_17;
             await waitForInFlightWrites();
@@ -5650,7 +5812,7 @@ class Schema {
                         .map((r) => r.modelId)
                         .filter((id) => id != null)),
                 ];
-                const { detachModelRows } = await import('./detachRowsBeforeDelete-S0q-DJPT.js');
+                const { detachModelRows } = await import('./detachRowsBeforeDelete-YRSZY6dO.js');
                 await detachModelRows(db, modelIds);
                 await db.delete(modelSchemas).where(inArray(modelSchemas.schemaId, schemaIds));
                 for (const modelId of modelIds) {
@@ -5660,6 +5822,22 @@ class Schema {
                     await db.delete(models).where(eq(models.id, modelId));
                 }
                 await db.delete(schemas).where(eq(schemas.schemaFileId, schemaFileId));
+                // Delete the SDK's own copies of this schema's files (all versions) in the working dir.
+                // loadAllSchemasFromDb imports any schema file without a DB row, so leaving them brought
+                // the destroyed schema back on the next Schema.all().
+                // Match on name as well as id: versions imported from complete schema files can each
+                // have their own id, and any version left behind would bring the schema back.
+                const _mod_18 = await import('./ClientManager-De-vKHGe.js');
+                const _ns_18 = _mod_18.K;
+                const { listCompleteSchemaFiles } = _ns_18;
+                const files = await listCompleteSchemaFiles().catch(() => []);
+                const fs = await BaseFileManager.getFs();
+                const names = new Set([schemaName, metadataName].filter(Boolean));
+                for (const file of files) {
+                    if (file.schemaFileId === schemaFileId || names.has(file.name)) {
+                        await fs.promises.unlink(file.filePath).catch(() => { });
+                    }
+                }
             },
         });
     }
@@ -5845,4 +6023,4 @@ var Schema$1 = /*#__PURE__*/Object.freeze({
 });
 
 export { Schema as S, deletePropertyFromModel as a, Schema$1 as b, deleteModelFromSchema as d, renameModelProperty as r, schemaMachine as s, updateModelProperties as u };
-//# sourceMappingURL=Schema-CpMNEnUO.js.map
+//# sourceMappingURL=Schema-Dc5EA8Yb.js.map