@seedprotocol/sdk 0.6.10 → 0.7.1

package/dist/{ModelProperty-D79uV42p.js → ModelProperty-6llK4MTH.js}

@@ -1,29 +1,30 @@
 import { fromCallback, setup, assign, createActor } from 'xstate';
 import 'reflect-metadata';
-import { w as writeProcessMachine, M as Model } from './index-HRHkbVQd.js';
-import { t as getModelIdByFileId, n as normalizeDataType, u as getModelId } from './db-WbrzEf7c.js';
+import { i as isActorStopped, w as writeProcessMachine, c as currentEvictionEpoch, M as Model, b as anyEvictionSince, s as schemaEvictedSince } from './index-Y-yYyRBf.js';
+import { x as getModelIdByFileId, n as normalizeDataType, y as getModelId } from './db-Lw0KVZmc.js';
 import 'pluralize';
-import { a as BaseDb, m as models, p as properties, s as schemas, i as modelSchemas, B as BaseFileManager } from './BasePathResolver-B6CKqoKw.js';
+import { B as BaseDb, j as models, p as properties, s as schemas, g as modelSchemas, a as BaseFileManager } from './BasePathResolver-DRT09oVv.js';
 import { eq, and } from 'drizzle-orm';
 import { modelPropertiesToObject } from './model-DGMe-TTm.js';
 import debug from 'debug';
-import './index-280bL-n4.js';
-import { S as Schema } from './Schema-a8uO-hIZ.js';
-import { n as waitForEntityIdle, o as createReactiveProxy, q as findEntity, u as forceRemoveFromCaches, v as runDestroyLifecycle } from './ClientManager-ChcmUL47.js';
+import './tabEvents-C6NXS6Jl.js';
+import { S as Schema } from './Schema-D-Ud-XYw.js';
+import { j as waitForEntityIdle, k as createReactiveProxy, m as findEntity, n as forceRemoveFromCaches, o as runDestroyLifecycle } from './Item-ZUAmf943.js';
 import { generateId } from './generateId-BopUwD8F.js';
+import './ClientManager-DngaZdw6.js';
+import '@seedprotocol/arweave';
+import '@seedprotocol/eas';
+import '@noble/hashes/sha3';
+import '@noble/hashes/utils';
+import '@seedprotocol/query';
+import 'lodash-es';
 import 'drizzle-orm/casing';
 import '@sinclair/typebox';
-import 'lodash-es';
 import 'drizzle-orm/sqlite-core';
-import '@seedprotocol/arweave';
-import '@seedprotocol/eas';
 import 'nanoid';
 import 'nanoid-dictionary';
-import '@seedprotocol/query';
-import './SchemaValidationService-Y49vqast.js';
+import './SchemaValidationService-IoS7JquP.js';
 import '@sinclair/typebox/value';
-import '@noble/hashes/sha3';
-import '@noble/hashes/utils';
 import 'rxjs';
 
 const logger$3 = debug('seedSdk:modelProperty:actors:saveToSchema');
@@ -34,15 +35,15 @@ 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 _mod_0 = await import('./ClientManager-ChcmUL47.js');
-    const _ns_0 = _mod_0.an;
+    const _mod_0 = await import('./ClientManager-DngaZdw6.js');
+    const _ns_0 = _mod_0.G;
     const schemaHelpersMod = _ns_0;
     const { listLatestSchemaFiles } = schemaHelpersMod;
     const latestSchemas = await listLatestSchemaFiles();
     for (const schema of latestSchemas) {
         try {
-            const _mod_1 = await import('./BasePathResolver-B6CKqoKw.js');
-            const _ns_1 = _mod_1.N;
+            const _mod_1 = await import('./BasePathResolver-DRT09oVv.js');
+            const _ns_1 = _mod_1.O;
             const fileManagerMod = _ns_1;
             const { BaseFileManager } = fileManagerMod;
             const content = await BaseFileManager.readFileAsString(schema.filePath);
@@ -58,10 +59,10 @@ async function getSchemaNameFromModel(modelName) {
     }
     return undefined;
 }
-const saveToSchema = fromCallback(({ sendBack, input: { context } }) => {
+const saveToSchema = fromCallback(({ sendBack, input: { context }, self }) => {
     const _saveToSchema = async () => {
         // Use dynamic import to break circular dependency
-        const validationServiceMod = await import('./SchemaValidationService-Y49vqast.js');
+        const validationServiceMod = await import('./SchemaValidationService-IoS7JquP.js');
         const { SchemaValidationService } = validationServiceMod;
         const validationService = new SchemaValidationService();
         // Validate property structure before saving
@@ -80,18 +81,21 @@ const saveToSchema = fromCallback(({ sendBack, input: { context } }) => {
             throw new Error(`Model not found for modelId: ${context.modelId}`);
         }
         // Persist to database only - schema file is updated only when user calls Schema.saveNewVersion()
-        const _mod_2 = await import('./db-WbrzEf7c.js');
-        const _ns_2 = _mod_2.Q;
+        const _mod_2 = await import('./db-Lw0KVZmc.js');
+        const _ns_2 = _mod_2.Z;
         const dbMod = _ns_2;
         const { savePropertyToDb } = dbMod;
         await savePropertyToDb(context);
         // Mark schema as draft so user knows to save
         const schemaName = context._schemaName ?? (await getSchemaNameFromModel(context.modelName));
         if (schemaName) {
-            const _mod_3 = await import('./Schema-a8uO-hIZ.js');
+            const _mod_3 = await import('./Schema-D-Ud-XYw.js');
             const _ns_3 = _mod_3.b;
             const schemaMod = _ns_3;
             const { Schema } = schemaMod;
+            // Stopped meanwhile (unloaded, or evicted with its schema): don't load the schema again
+            if (isActorStopped(self))
+                return;
             const schema = Schema.create(schemaName, { waitForReady: false });
             schema.getService().send({
                 type: 'markAsDraft',
@@ -112,7 +116,7 @@ const saveToSchema = fromCallback(({ sendBack, input: { context } }) => {
 });
 
 const logger$2 = debug('seedSdk:modelProperty:actors:compareAndMarkDraft');
-const compareAndMarkDraft = fromCallback(({ sendBack, input: { context } }) => {
+const compareAndMarkDraft = fromCallback(({ sendBack, input: { context }, self }) => {
     const _compareAndMarkDraft = async () => {
         // Fill modelName/dataType from _originalValues when missing, then from DB by schemaFileId
         let fullContext = {
@@ -123,8 +127,8 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context } }) => {
         const schemaFileIdForResolve = fullContext._propertyFileId || (typeof fullContext.id === 'string' ? fullContext.id : undefined);
         if (schemaFileIdForResolve && (fullContext.modelName === undefined || fullContext.dataType === undefined)) {
             try {
-                const _mod_4 = await import('./db-WbrzEf7c.js');
-                const _ns_4 = _mod_4.Q;
+                const _mod_4 = await import('./db-Lw0KVZmc.js');
+                const _ns_4 = _mod_4.Z;
                 const dbMod = _ns_4;
                 const { getPropertyModelNameAndDataType, getModelNameByModelId } = dbMod;
                 let fromDb;
@@ -170,8 +174,8 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context } }) => {
             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 _mod_5 = await import('./db-WbrzEf7c.js');
-                    const _ns_5 = _mod_5.Q;
+                    const _mod_5 = await import('./db-Lw0KVZmc.js');
+                    const _ns_5 = _mod_5.Z;
                     const dbMod = _ns_5;
                     const { savePropertyToDb } = dbMod;
                     // Ensure _propertyFileId is set for savePropertyToDb to find the property
@@ -232,8 +236,8 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context } }) => {
             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 _mod_6 = await import('./db-WbrzEf7c.js');
-            const _ns_6 = _mod_6.Q;
+            const _mod_6 = await import('./db-Lw0KVZmc.js');
+            const _ns_6 = _mod_6.Z;
             const dbMod = _ns_6;
             const { savePropertyToDb } = dbMod;
             // Save to database (but not JSON file) - always save to DB when there are changes
@@ -248,10 +252,13 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context } }) => {
             // Mark schema as draft if schema name is available
             if (fullContext._schemaName) {
                 // Get the Schema instance and mark it as draft
-                const _mod_7 = await import('./Schema-a8uO-hIZ.js');
+                const _mod_7 = await import('./Schema-D-Ud-XYw.js');
                 const _ns_7 = _mod_7.b;
                 const schemaMod = _ns_7;
                 const { Schema } = schemaMod;
+                // Stopped meanwhile (unloaded, or evicted with its schema): don't load the schema again
+                if (isActorStopped(self))
+                    return;
                 const schema = Schema.create(fullContext._schemaName, {
                     waitForReady: false,
                 });
@@ -267,7 +274,7 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context } }) => {
             logger$2(`Property ${fullContext.modelName}:${fullContext.name} has no changes`);
             // Clear isEdited flag in database
             try {
-                const _mod_8 = await import('./index-Djd3667v.js');
+                const _mod_8 = await import('./index-5b3JsS55.js');
                 const _ns_8 = _mod_8.s;
                 const seedSchemaMod = _ns_8;
                 const { properties: propertiesTable, models: modelsTable } = seedSchemaMod;
@@ -275,12 +282,15 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context } }) => {
                 const { eq, and } = drizzleMod;
                 const db = BaseDb.getAppDb();
                 if (db && fullContext.modelName && fullContext.name) {
-                    // Find model by name
-                    const modelRecords = await db
-                        .select({ id: modelsTable.id })
-                        .from(modelsTable)
-                        .where(eq(modelsTable.name, fullContext.modelName))
-                        .limit(1);
+                    // Find this property's model (model names are only unique per schema)
+                    const _mod_9 = await import('./db-Lw0KVZmc.js');
+                    const _ns_9 = _mod_9.Y;
+                    const { resolveModelRecord } = _ns_9;
+                    const modelRecord = await resolveModelRecord(fullContext.modelName, {
+                        modelId: typeof fullContext.modelId === 'number' ? fullContext.modelId : undefined,
+                        schemaName: fullContext._schemaName,
+                    }, db);
+                    const modelRecords = modelRecord ? [modelRecord] : [];
                     if (modelRecords.length > 0) {
                         // Find property by name and modelId
                         const propertyRecords = await db
@@ -319,7 +329,7 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context } }) => {
 });
 
 const logger$1 = debug('seedSdk:modelProperty:actors:validateProperty');
-const validateProperty = fromCallback(({ sendBack, input: { context } }) => {
+const validateProperty = fromCallback(({ sendBack, input: { context }, self }) => {
     const _validateProperty = async () => {
         // Use full context for validation: fill modelName/dataType from _originalValues when missing, then
         // from DB by schemaFileId (context.id) so just-created renames don't fail structure validation.
@@ -333,9 +343,9 @@ const validateProperty = fromCallback(({ sendBack, input: { context } }) => {
             // 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 _mod_9 = await import('./db-WbrzEf7c.js');
-                const _ns_9 = _mod_9.Q;
-                const dbMod = _ns_9;
+                const _mod_10 = await import('./db-Lw0KVZmc.js');
+                const _ns_10 = _mod_10.Z;
+                const dbMod = _ns_10;
                 const { getPropertyModelNameAndDataType, getModelNameByModelId } = dbMod;
                 // Try pending write first (property row may not exist yet)
                 if (fullContext.modelName === undefined && schemaFileId) {
@@ -387,12 +397,12 @@ const validateProperty = fromCallback(({ sendBack, input: { context } }) => {
             fullContext = { ...fullContext, dataType: (fullContext.dataType ?? context._originalValues?.dataType) || 'Text' };
         }
         // Use dynamic imports to break circular dependencies
-        const validationServiceMod = await import('./SchemaValidationService-Y49vqast.js');
+        const validationServiceMod = await import('./SchemaValidationService-IoS7JquP.js');
         const { SchemaValidationService } = validationServiceMod;
         const validationService = new SchemaValidationService();
-        const _mod_10 = await import('./Schema-a8uO-hIZ.js');
-        const _ns_10 = _mod_10.b;
-        const schemaMod = _ns_10;
+        const _mod_11 = await import('./Schema-D-Ud-XYw.js');
+        const _ns_11 = _mod_11.b;
+        const schemaMod = _ns_11;
         const { Schema } = schemaMod;
         // Validate property structure
         const structureResult = validationService.validatePropertyStructure(fullContext);
@@ -401,6 +411,9 @@ const validateProperty = fromCallback(({ sendBack, input: { context } }) => {
             return;
         }
         // If we have schema name and model name, validate against schema
+        // Stopped meanwhile (unloaded, or evicted with its schema): don't load the schema again
+        if (isActorStopped(self))
+            return;
         if (fullContext._schemaName && fullContext.modelName) {
             try {
                 const schema = Schema.create(fullContext._schemaName, {
@@ -494,9 +507,6 @@ const modelPropertyMachine = setup({
             const valid = !context._validationErrors || context._validationErrors.length === 0;
             return valid;
         },
-        hasValidationErrors: ({ context }) => {
-            return !!context._validationErrors && context._validationErrors.length > 0;
-        },
     },
     actions: {
         assignValidationErrors: assign(({ context, event }) => {
@@ -595,7 +605,8 @@ const modelPropertyMachine = setup({
             actions: assign(({ context, event }) => ({
                 ...context,
                 _originalValues: event.originalValues,
-                _schemaName: event.schemaName,
+                // Senders don't know the schema name; keep one setSchemaName already stored.
+                _schemaName: event.schemaName ?? context._schemaName,
                 _isEdited: event.isEdited ?? false,
                 _validationErrors: undefined,
             })),
@@ -614,22 +625,15 @@ const modelPropertyMachine = setup({
             })),
         },
         destroyStarted: {
-            actions: assign({ _destroyInProgress: true, _destroyError: null }),
-        },
-        destroyDone: {
-            actions: assign({ _destroyInProgress: false }),
+            actions: assign({ _destroyError: null }),
         },
         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: {
@@ -704,11 +708,9 @@ const modelPropertyMachine = setup({
             },
         },
         saveToSchema: {
-            always: {
-                guard: 'isPropertyValid',
-                target: '.saving',
-            },
-            initial: 'saving',
+            // Gate the save in a transient child. An `always` on this parent targeting `.saving` re-enters
+            // the invoking child on every microstep and never settles (save() ran the process out of memory).
+            initial: 'checking',
             on: {
                 // Apply updateContext but do not re-invoke saveToSchema actor (avoids infinite loop).
                 // Context is updated; in-flight save completes with original context.
@@ -785,6 +787,12 @@ const modelPropertyMachine = setup({
                 },
             },
             states: {
+                checking: {
+                    always: [
+                        { guard: 'isPropertyValid', target: 'saving' },
+                        { target: '#modelProperty.idle' },
+                    ],
+                },
                 saving: {
                     on: {
                         saveToSchemaSuccess: {
@@ -848,6 +856,8 @@ const TPropertyKeys = [
 ];
 class ModelProperty {
     constructor(property) {
+        /** currentEvictionEpoch() at construction: lookups started for this instance don't outlive an eviction. */
+        this._evictionEpoch = currentEvictionEpoch();
         // id is now the schemaFileId (string), _dbId is the database integer ID
         // Preserve _propertyFileId if it exists in the property object (from getPropertySchema)
         // Convert null to undefined for optional fields (TypeBox validation expects undefined, not null)
@@ -867,6 +877,15 @@ class ModelProperty {
         this._initializeOriginalValues(property);
         // Note: Property getters/setters are now handled by the Proxy in create()
     }
+    /**
+     * Send from fire-and-forget async work (DB lookups started in the constructor), which can finish
+     * after the instance was unloaded or evicted with its schema.
+     */
+    _sendIfRunning(event) {
+        if (isActorStopped(this._service))
+            return;
+        this._service.send(event);
+    }
     /**
      * Initialize original values and schema name for tracking changes
      * This is called asynchronously after construction
@@ -878,10 +897,10 @@ class ModelProperty {
         const refModelName = property.refModelName || property.ref;
         if (refModelName && !property.refModelId) {
             // Resolve refModelId asynchronously and update context
-            this._resolveRefModelId(refModelName).then((refModelId) => {
+            this._resolveRefModelId(refModelName, property).then((refModelId) => {
                 if (refModelId) {
                     // Update the context with the resolved refModelId
-                    this._service.send({
+                    this._sendIfRunning({
                         type: 'updateContext',
                         refModelId,
                     });
@@ -949,7 +968,7 @@ class ModelProperty {
             // Initialize with original values, including isEdited flag
             // Load isEdited from database if property exists in DB (async, fire-and-forget)
             this._loadIsEditedFromDb(property, isEdited).then((isEditedFromDb) => {
-                this._service.send({
+                this._sendIfRunning({
                     type: 'initializeOriginalValues',
                     originalValues,
                     schemaName: undefined, // Will be set later if needed
@@ -957,7 +976,7 @@ class ModelProperty {
                 });
             }).catch(() => {
                 // If we can't load from DB, use computed isEdited value
-                this._service.send({
+                this._sendIfRunning({
                     type: 'initializeOriginalValues',
                     originalValues,
                     schemaName: undefined, // Will be set later if needed
@@ -972,7 +991,7 @@ class ModelProperty {
                     originalValues[key] = property[key];
                 }
             });
-            this._service.send({
+            this._sendIfRunning({
                 type: 'initializeOriginalValues',
                 originalValues,
                 schemaName: undefined,
@@ -980,7 +999,7 @@ class ModelProperty {
         });
         // Get schema name from model asynchronously (fire-and-forget)
         if (property.modelName) {
-            this._setSchemaName(property.modelName).catch(() => {
+            this._setSchemaName(property).catch(() => {
                 // If we can't get schema name, that's okay - it will be set later if needed
             });
         }
@@ -1000,12 +1019,12 @@ class ModelProperty {
             if (!db) {
                 return fallbackIsEdited;
             }
-            // Find model by name
-            const modelRecords = await db
-                .select({ id: models.id })
-                .from(models)
-                .where(eq(models.name, property.modelName))
-                .limit(1);
+            // Find this property's model (by modelId when known; model names are only unique per schema)
+            const _mod_12 = await import('./db-Lw0KVZmc.js');
+            const _ns_12 = _mod_12.Y;
+            const { resolveModelRecord } = _ns_12;
+            const modelRecord = await resolveModelRecord(property.modelName, this._ownerModelScope(property), db);
+            const modelRecords = modelRecord ? [modelRecord] : [];
             if (modelRecords.length === 0) {
                 return fallbackIsEdited;
             }
@@ -1029,7 +1048,7 @@ class ModelProperty {
      * @param refModelName - The name of the referenced model
      * @returns The database ID of the referenced model, or undefined if not found
      */
-    async _resolveRefModelId(refModelName) {
+    async _resolveRefModelId(refModelName, property) {
         if (!refModelName) {
             return undefined;
         }
@@ -1038,13 +1057,13 @@ class ModelProperty {
             if (!db) {
                 return undefined;
             }
-            const refModelRecords = await db
-                .select()
-                .from(models)
-                .where(eq(models.name, refModelName))
-                .limit(1);
-            if (refModelRecords.length > 0 && refModelRecords[0].id) {
-                return refModelRecords[0].id;
+            // Resolve the ref within the owning model's schema
+            const _mod_13 = await import('./db-Lw0KVZmc.js');
+            const _ns_13 = _mod_13.Y;
+            const { resolveRefModelRecord } = _ns_13;
+            const refModelRecord = await resolveRefModelRecord(refModelName, property ? this._ownerModelScope(property) : { schemaName: this._getSnapshotContext()._schemaName }, db);
+            if (refModelRecord?.id) {
+                return refModelRecord.id;
             }
         }
         catch (error) {
@@ -1053,6 +1072,15 @@ class ModelProperty {
         }
         return undefined;
     }
+    /** Which model this property belongs to: its models row id and/or schema. */
+    _ownerModelScope(property) {
+        const context = this._getSnapshotContext();
+        const modelId = property.modelId ?? context.modelId;
+        return {
+            modelId: typeof modelId === 'number' ? modelId : undefined,
+            schemaName: context._schemaName,
+        };
+    }
     /**
      * Get schema file values for this property to use as "original" values
      * This allows comparison with database values to detect edits
@@ -1062,7 +1090,42 @@ class ModelProperty {
             return undefined;
         }
         try {
-            const model = await Model.getByNameAsync(property.modelName);
+            const { modelId, schemaName } = this._ownerModelScope(property);
+            // Synchronous cache hits first: callers compare against these values right after construction,
+            // so an extra await here lets every property look "edited" (a draft save each). Only then the
+            // DB (by modelId), and never instantiate a Model while its own properties are initializing.
+            let model = schemaName ? Model.getByName(property.modelName, schemaName) : undefined;
+            if (!model) {
+                try {
+                    model = Model.getByName(property.modelName);
+                }
+                catch {
+                    model = undefined; // ambiguous name; resolve by modelId below
+                }
+            }
+            if (!model && modelId) {
+                const _mod_14 = await import('./db-Lw0KVZmc.js');
+                const _ns_14 = _mod_14.Y;
+                const { resolveModelRecord } = _ns_14;
+                const modelFileId = (await resolveModelRecord(property.modelName, { modelId }))?.schemaFileId;
+                model = modelFileId ? Model.getById(modelFileId) : undefined;
+            }
+            // Evicted (with its schema) or unloaded while the lookups above ran: don't instantiate its model
+            // again from rows that are being deleted.
+            if (!model && isActorStopped(this._service))
+                return undefined;
+            if (!model) {
+                try {
+                    // The epoch from when this instance was built: an eviction of the model's schema since
+                    // then (this instance may already be stopped) must not re-create the model.
+                    model = await Model.getByNameAsync(property.modelName, undefined, {
+                        evictionEpoch: this._evictionEpoch,
+                    });
+                }
+                catch {
+                    model = undefined;
+                }
+            }
             if (!model || !model.properties || model.properties.length === 0) {
                 return undefined;
             }
@@ -1086,7 +1149,7 @@ class ModelProperty {
                 originalValues.ref = schemaFileValue.ref;
                 originalValues.refModelName = schemaFileValue.ref;
                 // Try to get refModelId from database
-                const refModelId = await this._resolveRefModelId(schemaFileValue.ref);
+                const refModelId = await this._resolveRefModelId(schemaFileValue.ref, property);
                 if (refModelId) {
                     originalValues.refModelId = refModelId;
                 }
@@ -1104,11 +1167,19 @@ class ModelProperty {
      * Set the schema name for this property by looking it up from the model
      * Tries database first (more reliable), then falls back to schema files
      */
-    async _setSchemaName(modelName) {
+    async _setSchemaName(property) {
         try {
+            // create() sets the schema name right after construction when its caller knows it. Don't look it
+            // up then: the file fallback below reads and parses every schema file, per property.
+            await Promise.resolve();
+            if (this._getSnapshotContext()._schemaName)
+                return;
             let schemaName;
+            // From the property data: the instance's own modelId field is never assigned (the reactive proxy
+            // serves values from the machine context), so reading this.modelId skipped the DB lookup.
+            const { modelId } = this._ownerModelScope(property);
             // Try to get schema name from database first (more reliable)
-            if (this.modelId) {
+            if (modelId) {
                 try {
                     const db = BaseDb.getAppDb();
                     if (db) {
@@ -1119,7 +1190,7 @@ class ModelProperty {
                             .from(modelSchemas)
                             .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
                             .innerJoin(models, eq(modelSchemas.modelId, models.id))
-                            .where(eq(models.id, this.modelId))
+                            .where(eq(models.id, modelId))
                             .limit(1);
                         if (modelSchemaRecords.length > 0) {
                             schemaName = modelSchemaRecords[0].schemaName;
@@ -1132,11 +1203,11 @@ class ModelProperty {
             }
             // Fall back to schema file lookup if database didn't work
             if (!schemaName) {
-                schemaName = await getSchemaNameFromModel(modelName);
+                schemaName = await getSchemaNameFromModel(property.modelName);
             }
             if (schemaName) {
                 // Update the context with the schema name using dedicated event
-                this._service.send({
+                this._sendIfRunning({
                     type: 'setSchemaName',
                     schemaName,
                 });
@@ -1233,11 +1304,32 @@ class ModelProperty {
             logger(`ModelProperty.create: Generated new id (schemaFileId) "${propertyWithId.id}" for property "${property.name}"`);
         }
         // Create cache key from modelName and name, or use id
-        const cacheKey = propertyWithId.modelName && propertyWithId.name
+        let cacheKey = propertyWithId.modelName && propertyWithId.name
             ? `${propertyWithId.modelName}:${propertyWithId.name}`
             : propertyWithId.id
                 ? `id:${propertyWithId.id}`
                 : propertyWithId.name || 'unnamed';
+        // Model names are only unique per schema: a cached "Post:title" may be another schema's
+        // property. If the ids say it's a different property, key this one by its own id instead.
+        // (Not by file id: the same property is often created first with a generated id, then its real one.)
+        const isOtherProperty = (cachedContext) => (typeof propertyWithId.modelId === 'number' &&
+            typeof cachedContext.modelId === 'number' &&
+            cachedContext.modelId !== propertyWithId.modelId) ||
+            (!!schemaName && !!cachedContext._schemaName && cachedContext._schemaName !== schemaName);
+        const cachedByName = this.instanceCache.get(cacheKey);
+        if (cachedByName && propertyWithId.id && isOtherProperty(cachedByName.instance._getSnapshotContext())) {
+            // Reuse this property's own id-keyed entry if it already has one.
+            cacheKey = `id:${propertyWithId.id}`;
+            for (const [key, { instance }] of this.instanceCache.entries()) {
+                if (!key.startsWith('id:'))
+                    continue;
+                const ctx = instance._getSnapshotContext();
+                if (ctx.modelName === propertyWithId.modelName && ctx.name === propertyWithId.name && !isOtherProperty(ctx)) {
+                    cacheKey = key;
+                    break;
+                }
+            }
+        }
         // Check if instance exists in cache
         if (this.instanceCache.has(cacheKey)) {
             const { instance, refCount } = this.instanceCache.get(cacheKey);
@@ -1299,11 +1391,15 @@ class ModelProperty {
             instance: proxiedInstance,
             refCount: 1,
         });
+        this.indexCachedInstance(cacheKey, proxiedInstance);
         // Trigger write process if property has modelId (or modelName) and id (schemaFileId)
         // Wait for service to be ready (idle state) and have writeProcess spawned
         const propertyFileId = propertyWithId.id; // id is now the schemaFileId (string)
         const hasModelId = propertyWithId.modelId || propertyWithId.modelName;
-        if (hasModelId && propertyFileId) {
+        // A _dbId means the data was loaded from an existing row (createById, getPropertySchema), so
+        // there's nothing to write. Writing it back anyway raced deletes of that row's model (FK error).
+        const isPersisted = typeof propertyWithId._dbId === 'number';
+        if (hasModelId && propertyFileId && !isPersisted) {
             // Wait for writeProcess to be spawned (it's spawned in idle state entry action)
             // Retry a few times if writeProcess isn't available yet
             let retries = 0;
@@ -1311,6 +1407,9 @@ class ModelProperty {
             const checkAndSend = async () => {
                 const service = proxiedInstance.getService();
                 const snapshot = service.getSnapshot();
+                // Unloaded or evicted (e.g. Schema.destroy) before the write started: nothing to write to
+                if (isActorStopped(service))
+                    return;
                 if (snapshot.value === 'idle' && snapshot.context.writeProcess) {
                     const writeProcess = snapshot.context.writeProcess;
                     // Resolve dbModelId - convert from string (modelFileId) to number (database ID) if needed
@@ -1350,14 +1449,17 @@ class ModelProperty {
                         // Don't clear pending write here - it might resolve later
                         return;
                     }
+                    // Resolving the modelId awaited the DB; the instance may have been stopped meanwhile
+                    if (isActorStopped(service))
+                        return;
                     // Track pending write now that we have the resolved modelId
                     this.trackPendingWrite(propertyFileId, resolvedModelId);
                     logger(`Triggering write process for property "${property.name}" (modelId: ${resolvedModelId}, propertyFileId: ${propertyFileId})`);
                     // Check current write state
                     const currentWriteState = writeProcess.getSnapshot();
                     if (currentWriteState.value === 'success') {
-                        // Write already succeeded, clear pending write immediately
-                        this.clearPendingWrite(propertyFileId, 'success');
+                        // Write already succeeded
+                        void this.completePendingWrite(propertyFileId, resolvedModelId);
                     }
                     else {
                         // Set up subscription to catch future state changes
@@ -1365,8 +1467,7 @@ class ModelProperty {
                             if (writeSnapshot.value === 'success') {
                                 writeSubscription.unsubscribe();
                                 logger(`[writeProcess subscription] Write succeeded for property "${property.name}" (propertyFileId: ${propertyFileId})`);
-                                // Clear pending write on success
-                                this.clearPendingWrite(propertyFileId, 'success');
+                                void this.completePendingWrite(propertyFileId, resolvedModelId);
                             }
                             else if (writeSnapshot.value === 'error') {
                                 writeSubscription.unsubscribe();
@@ -1384,6 +1485,7 @@ class ModelProperty {
                         dataType: property.dataType,
                         refModelId: property.refModelId,
                         refValueType: property.refValueType,
+                        required: property.required,
                         storageType: property.storageType,
                         localStorageDir: property.localStorageDir,
                         filenameSuffix: property.filenameSuffix,
@@ -1411,18 +1513,56 @@ class ModelProperty {
             return proxiedInstance;
         return waitForEntityIdle(proxiedInstance, { timeout: readyTimeout }).then(() => proxiedInstance);
     }
+    /** Whether an idIndex entry still points at a cached instance with that id. */
+    static isIndexEntryCurrent(propertyFileId, entry) {
+        if (this.instanceCache.get(entry.cacheKey)?.instance !== entry.instance)
+            return false;
+        try {
+            return entry.instance._getSnapshotContext().id === propertyFileId;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Add a newly cached instance to idIndex, and keep its entry current when its id changes. */
+    static indexCachedInstance(cacheKey, instance) {
+        const index = (id) => {
+            if (!id)
+                return;
+            const existing = this.idIndex.get(id);
+            // Keep the instance cached first, as the old scan in insertion order returned
+            if (existing && existing.instance !== instance && this.isIndexEntryCurrent(id, existing))
+                return;
+            this.idIndex.set(id, { cacheKey, instance });
+        };
+        let indexedId = instance._getSnapshotContext().id;
+        index(indexedId);
+        instance._service.subscribe((snapshot) => {
+            const id = snapshot.context.id;
+            if (id === indexedId)
+                return;
+            indexedId = id;
+            index(id);
+        });
+    }
     /**
      * Get ModelProperty instance by propertyFileId from static cache
      */
     static getById(propertyFileId) {
         if (!propertyFileId)
             return undefined;
-        // Search through cache to find by propertyFileId
+        const indexed = this.idIndex.get(propertyFileId);
+        if (!indexed)
+            return undefined;
+        if (this.isIndexEntryCurrent(propertyFileId, indexed))
+            return indexed.instance;
+        // The indexed instance left the cache or changed id; another cached instance may still have it.
         // Cache key might be "modelName:propertyName" or "id:propertyId"
+        this.idIndex.delete(propertyFileId);
         for (const [cacheKey, { instance }] of this.instanceCache.entries()) {
-            const context = instance._getSnapshotContext();
             // id is now the schemaFileId (string)
-            if (context.id === propertyFileId) {
+            if (instance._getSnapshotContext().id === propertyFileId) {
+                this.idIndex.set(propertyFileId, { cacheKey, instance });
                 return instance;
             }
         }
@@ -1432,7 +1572,7 @@ class ModelProperty {
      * Create or get ModelProperty instance by propertyFileId
      * Queries the database to find the property if not cached
      */
-    static async createById(propertyFileId) {
+    static async createById(propertyFileId, options) {
         if (!propertyFileId) {
             return undefined;
         }
@@ -1446,10 +1586,7 @@ class ModelProperty {
         if (!db) {
             return undefined;
         }
-        await db
-            .select()
-            .from(properties)
-            .limit(100);
+        const evictionEpoch = options?.evictionEpoch ?? currentEvictionEpoch();
         const propertyRecords = await db
             .select()
             .from(properties)
@@ -1481,6 +1618,9 @@ class ModelProperty {
             refModelId: propertyRecord.refModelId || undefined,
             refValueType: propertyRecord.refValueType ? propertyRecord.refValueType : undefined,
             required: propertyRecord.required ?? false,
+            storageType: propertyRecord.storageType ?? undefined,
+            localStorageDir: propertyRecord.localStorageDir ?? undefined,
+            filenameSuffix: propertyRecord.filenameSuffix ?? undefined,
         };
         // Load isEdited from database
         const isEditedFromDb = propertyRecord.isEdited ?? false;
@@ -1496,6 +1636,19 @@ class ModelProperty {
                 propertyData.ref = refModelRecords[0].name;
             }
         }
+        // Its model's schema was evicted while we read the rows (e.g. a model's property lookup in flight
+        // during Schema.destroy or test cleanup): don't bring the property back.
+        if (anyEvictionSince(evictionEpoch)) {
+            const schemaRows = await db
+                .select({ name: schemas.name })
+                .from(modelSchemas)
+                .innerJoin(schemas, eq(schemas.id, modelSchemas.schemaId))
+                .where(eq(modelSchemas.modelId, propertyRecord.modelId));
+            if (schemaRows.length === 0 ||
+                schemaRows.some((row) => schemaEvictedSince(row.name, evictionEpoch))) {
+                return undefined;
+            }
+        }
         // Create ModelProperty instance (sync for createById so we can send updateContext)
         const instance = this.create(propertyData, { waitForReady: false });
         // Set isEdited from database after creation
@@ -1562,6 +1715,20 @@ class ModelProperty {
             timestamp: Date.now(),
         });
     }
+    /**
+     * A property write succeeded: add the property to its model's property ids, then drop the pending
+     * write. In that order, `Model.properties` (property ids + pending writes) never misses it; in Node,
+     * where the Model has no reactive liveQuery, nothing else would add it.
+     */
+    static async completePendingWrite(propertyFileId, modelId) {
+        try {
+            await Model.refreshPropertiesForDbId(modelId);
+        }
+        catch (error) {
+            logger(`Refreshing properties of model ${modelId} after writing "${propertyFileId}" failed: ${error}`);
+        }
+        this.clearPendingWrite(propertyFileId, 'success');
+    }
     /**
      * Clear or update pending write status
      */
@@ -1700,6 +1867,36 @@ class ModelProperty {
         logger('ModelProperty.reload() called - ModelProperty is loaded as part of Model/Schema. Reload the parent Model or Schema instead.');
         // No-op for now, but could be enhanced to reload from DB if needed
     }
+    /**
+     * Force-evict cached ModelProperty instances for the given models, ignoring refCounts, and stop
+     * their services. Used by Schema.destroy() so a re-imported schema gets fresh instances instead of
+     * ones holding a deleted row's _dbId.
+     */
+    static evictForModels(modelNames, schemaName) {
+        if (modelNames.length === 0)
+            return;
+        const names = new Set(modelNames);
+        for (const [cacheKey, { instance }] of this.instanceCache.entries()) {
+            let context;
+            try {
+                context = instance._getSnapshotContext();
+            }
+            catch {
+                continue;
+            }
+            if (!context.modelName || !names.has(context.modelName))
+                continue;
+            if (schemaName && context._schemaName && context._schemaName !== schemaName)
+                continue;
+            this.instanceCache.delete(cacheKey);
+            try {
+                instance._service.stop();
+            }
+            catch {
+                // Service might already be stopped
+            }
+        }
+    }
     unload() {
         // ModelProperty doesn't have liveQuery subscriptions or complex cache management
         // Just stop the service
@@ -1715,13 +1912,24 @@ class ModelProperty {
      */
     async destroy() {
         const context = this._getSnapshotContext();
-        const cacheKey = context.modelName && context.name
-            ? `${context.modelName}:${context.name}`
-            : (context.id ?? '');
-        if (!cacheKey)
+        // Stored under "modelName:name", or "id:<id>" when another schema's same-name property holds that key
+        const cacheKeys = [...ModelProperty.instanceCache.entries()]
+            .filter(([, entry]) => {
+            try {
+                return entry.instance._getSnapshotContext().id === context.id;
+            }
+            catch {
+                return false;
+            }
+        })
+            .map(([key]) => key);
+        if (cacheKeys.length === 0 && context.modelName && context.name) {
+            cacheKeys.push(`${context.modelName}:${context.name}`);
+        }
+        if (cacheKeys.length === 0)
             return;
         forceRemoveFromCaches(this, {
-            getCacheKeys: () => [cacheKey],
+            getCacheKeys: () => cacheKeys,
             caches: [ModelProperty.instanceCache],
         });
         await runDestroyLifecycle(this, {
@@ -1770,6 +1978,15 @@ class ModelProperty {
     }
 }
 ModelProperty.instanceCache = new Map();
+/**
+ * propertyFileId -> where the instance with that id is cached, so getById doesn't scan the cache
+ * (a model's properties are looked up one by one, which made loading one model O(n²)).
+ * Every cached instance's current id has an entry: it's added when the instance is cached and
+ * again whenever its context id changes (a property is often created with a generated id and
+ * then gets its real one). Entries aren't removed when an instance leaves the cache or changes
+ * id; getById checks an entry before using it.
+ */
+ModelProperty.idIndex = new Map();
 // Pending writes tracking
 ModelProperty.pendingWrites = new Map();
 
@@ -1779,4 +1996,4 @@ var ModelProperty$1 = /*#__PURE__*/Object.freeze({
 });
 
 export { ModelProperty };
-//# sourceMappingURL=ModelProperty-D79uV42p.js.map
+//# sourceMappingURL=ModelProperty-6llK4MTH.js.map