@seedprotocol/sdk 0.6.10 → 0.7.0

package/dist/cjs/{ModelProperty-D9FGaGuE.js → ModelProperty-BEsIHAjk.js}

@@ -2,11 +2,11 @@
 
 var xstate = require('xstate');
 require('reflect-metadata');
-var main_cjs = require('./index-CSNtEnbF.js');
+var main_cjs = require('./index-C66AfYDG.js');
 require('pluralize');
 var drizzleOrm = require('drizzle-orm');
 var debug = require('debug');
-var Schema = require('./Schema-BiJIPLEL.js');
+var Schema = require('./Schema-qEp5mH1N.js');
 require('immer');
 require('drizzle-orm/sqlite-core');
 require('@seedprotocol/arweave');
@@ -32,7 +32,7 @@ require('js-yaml');
 require('child_process');
 require('@seedprotocol/arweave/node');
 require('@seedprotocol/eas/node');
-require('./SchemaValidationService-DtYs_CNY.js');
+require('./SchemaValidationService-CWEnZmOH.js');
 require('@sinclair/typebox/value');
 
 const logger$3 = debug('seedSdk:modelProperty:actors:saveToSchema');
@@ -43,12 +43,12 @@ 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 schemaHelpersMod = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.schema$1; });
+    const schemaHelpersMod = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.schema$1; });
     const { listLatestSchemaFiles } = schemaHelpersMod;
     const latestSchemas = await listLatestSchemaFiles();
     for (const schema of latestSchemas) {
         try {
-            const fileManagerMod = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.BaseFileManager$1; });
+            const fileManagerMod = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.BaseFileManager$1; });
             const { BaseFileManager } = fileManagerMod;
             const content = await BaseFileManager.readFileAsString(schema.filePath);
             const schemaFile = JSON.parse(content);
@@ -66,7 +66,7 @@ async function getSchemaNameFromModel(modelName) {
 const saveToSchema = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const _saveToSchema = async () => {
         // Use dynamic import to break circular dependency
-        const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DtYs_CNY.js'); });
+        const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-CWEnZmOH.js'); });
         const { SchemaValidationService } = validationServiceMod;
         const validationService = new SchemaValidationService();
         // Validate property structure before saving
@@ -85,13 +85,13 @@ const saveToSchema = xstate.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 dbMod = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.db; });
+        const dbMod = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.db; });
         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 schemaMod = await Promise.resolve().then(function () { return require('./Schema-BiJIPLEL.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-qEp5mH1N.js'); });
             const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             schema.getService().send({
@@ -124,7 +124,7 @@ const compareAndMarkDraft = xstate.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 dbMod = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.db; });
+                const dbMod = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.db; });
                 const { getPropertyModelNameAndDataType, getModelNameByModelId } = dbMod;
                 let fromDb;
                 for (let attempt = 0; attempt < 6; attempt++) {
@@ -169,7 +169,7 @@ const compareAndMarkDraft = xstate.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 dbMod = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.db; });
+                    const dbMod = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.db; });
                     const { savePropertyToDb } = dbMod;
                     // Ensure _propertyFileId is set for savePropertyToDb to find the property
                     const contextWithFileId = {
@@ -229,7 +229,7 @@ const compareAndMarkDraft = xstate.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 dbMod = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.db; });
+            const dbMod = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.db; });
             const { savePropertyToDb } = dbMod;
             // Save to database (but not JSON file) - always save to DB when there are changes
             try {
@@ -243,7 +243,7 @@ const compareAndMarkDraft = xstate.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 schemaMod = await Promise.resolve().then(function () { return require('./Schema-BiJIPLEL.js'); });
+                const schemaMod = await Promise.resolve().then(function () { return require('./Schema-qEp5mH1N.js'); });
                 const { Schema } = schemaMod;
                 const schema = Schema.create(fullContext._schemaName, {
                     waitForReady: false,
@@ -260,18 +260,19 @@ const compareAndMarkDraft = xstate.fromCallback(({ sendBack, input: { context }
             logger$2(`Property ${fullContext.modelName}:${fullContext.name} has no changes`);
             // Clear isEdited flag in database
             try {
-                const seedSchemaMod = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.schema; });
+                const seedSchemaMod = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.schema; });
                 const { properties: propertiesTable, models: modelsTable } = seedSchemaMod;
                 const drizzleMod = await import('drizzle-orm');
                 const { eq, and } = drizzleMod;
                 const db = main_cjs.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 { resolveModelRecord } = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.resolveModelRecord$1; });
+                    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
@@ -324,7 +325,7 @@ const validateProperty = xstate.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 dbMod = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.db; });
+                const dbMod = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.db; });
                 const { getPropertyModelNameAndDataType, getModelNameByModelId } = dbMod;
                 // Try pending write first (property row may not exist yet)
                 if (fullContext.modelName === undefined && schemaFileId) {
@@ -376,10 +377,10 @@ const validateProperty = xstate.fromCallback(({ sendBack, input: { context } })
             fullContext = { ...fullContext, dataType: (fullContext.dataType ?? context._originalValues?.dataType) || 'Text' };
         }
         // Use dynamic imports to break circular dependencies
-        const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DtYs_CNY.js'); });
+        const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-CWEnZmOH.js'); });
         const { SchemaValidationService } = validationServiceMod;
         const validationService = new SchemaValidationService();
-        const schemaMod = await Promise.resolve().then(function () { return require('./Schema-BiJIPLEL.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./Schema-qEp5mH1N.js'); });
         const { Schema } = schemaMod;
         // Validate property structure
         const structureResult = validationService.validatePropertyStructure(fullContext);
@@ -481,9 +482,6 @@ const modelPropertyMachine = xstate.setup({
             const valid = !context._validationErrors || context._validationErrors.length === 0;
             return valid;
         },
-        hasValidationErrors: ({ context }) => {
-            return !!context._validationErrors && context._validationErrors.length > 0;
-        },
     },
     actions: {
         assignValidationErrors: xstate.assign(({ context, event }) => {
@@ -582,7 +580,8 @@ const modelPropertyMachine = xstate.setup({
             actions: xstate.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,
             })),
@@ -601,22 +600,15 @@ const modelPropertyMachine = xstate.setup({
             })),
         },
         destroyStarted: {
-            actions: xstate.assign({ _destroyInProgress: true, _destroyError: null }),
-        },
-        destroyDone: {
-            actions: xstate.assign({ _destroyInProgress: false }),
+            actions: xstate.assign({ _destroyError: null }),
         },
         destroyError: {
             actions: xstate.assign(({ event }) => ({
-                _destroyInProgress: false,
                 _destroyError: event.error instanceof Error
                     ? { message: event.error.message, name: event.error.name }
                     : { message: String(event.error) },
             })),
         },
-        clearDestroyError: {
-            actions: xstate.assign({ _destroyError: null }),
-        },
     },
     states: {
         idle: {
@@ -691,11 +683,9 @@ const modelPropertyMachine = xstate.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.
@@ -772,6 +762,12 @@ const modelPropertyMachine = xstate.setup({
                 },
             },
             states: {
+                checking: {
+                    always: [
+                        { guard: 'isPropertyValid', target: 'saving' },
+                        { target: '#modelProperty.idle' },
+                    ],
+                },
                 saving: {
                     on: {
                         saveToSchemaSuccess: {
@@ -854,6 +850,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 (main_cjs.isActorStopped(this._service))
+            return;
+        this._service.send(event);
+    }
     /**
      * Initialize original values and schema name for tracking changes
      * This is called asynchronously after construction
@@ -865,10 +870,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,
                     });
@@ -936,7 +941,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
@@ -944,7 +949,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
@@ -959,7 +964,7 @@ class ModelProperty {
                     originalValues[key] = property[key];
                 }
             });
-            this._service.send({
+            this._sendIfRunning({
                 type: 'initializeOriginalValues',
                 originalValues,
                 schemaName: undefined,
@@ -967,7 +972,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
             });
         }
@@ -987,12 +992,10 @@ class ModelProperty {
             if (!db) {
                 return fallbackIsEdited;
             }
-            // Find model by name
-            const modelRecords = await db
-                .select({ id: main_cjs.models.id })
-                .from(main_cjs.models)
-                .where(drizzleOrm.eq(main_cjs.models.name, property.modelName))
-                .limit(1);
+            // Find this property's model (by modelId when known; model names are only unique per schema)
+            const { resolveModelRecord } = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.resolveModelRecord$1; });
+            const modelRecord = await resolveModelRecord(property.modelName, this._ownerModelScope(property), db);
+            const modelRecords = modelRecord ? [modelRecord] : [];
             if (modelRecords.length === 0) {
                 return fallbackIsEdited;
             }
@@ -1016,7 +1019,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;
         }
@@ -1025,13 +1028,11 @@ class ModelProperty {
             if (!db) {
                 return undefined;
             }
-            const refModelRecords = await db
-                .select()
-                .from(main_cjs.models)
-                .where(drizzleOrm.eq(main_cjs.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 { resolveRefModelRecord } = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.resolveModelRecord$1; });
+            const refModelRecord = await resolveRefModelRecord(refModelName, property ? this._ownerModelScope(property) : { schemaName: this._getSnapshotContext()._schemaName }, db);
+            if (refModelRecord?.id) {
+                return refModelRecord.id;
             }
         }
         catch (error) {
@@ -1040,6 +1041,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
@@ -1049,7 +1059,32 @@ class ModelProperty {
             return undefined;
         }
         try {
-            const model = await main_cjs.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 ? main_cjs.Model.getByName(property.modelName, schemaName) : undefined;
+            if (!model) {
+                try {
+                    model = main_cjs.Model.getByName(property.modelName);
+                }
+                catch {
+                    model = undefined; // ambiguous name; resolve by modelId below
+                }
+            }
+            if (!model && modelId) {
+                const { resolveModelRecord } = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.resolveModelRecord$1; });
+                const modelFileId = (await resolveModelRecord(property.modelName, { modelId }))?.schemaFileId;
+                model = modelFileId ? main_cjs.Model.getById(modelFileId) : undefined;
+            }
+            if (!model) {
+                try {
+                    model = await main_cjs.Model.getByNameAsync(property.modelName);
+                }
+                catch {
+                    model = undefined;
+                }
+            }
             if (!model || !model.properties || model.properties.length === 0) {
                 return undefined;
             }
@@ -1073,7 +1108,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;
                 }
@@ -1091,11 +1126,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 = main_cjs.BaseDb.getAppDb();
                     if (db) {
@@ -1106,7 +1149,7 @@ class ModelProperty {
                             .from(main_cjs.modelSchemas)
                             .innerJoin(main_cjs.schemas, drizzleOrm.eq(main_cjs.modelSchemas.schemaId, main_cjs.schemas.id))
                             .innerJoin(main_cjs.models, drizzleOrm.eq(main_cjs.modelSchemas.modelId, main_cjs.models.id))
-                            .where(drizzleOrm.eq(main_cjs.models.id, this.modelId))
+                            .where(drizzleOrm.eq(main_cjs.models.id, modelId))
                             .limit(1);
                         if (modelSchemaRecords.length > 0) {
                             schemaName = modelSchemaRecords[0].schemaName;
@@ -1119,11 +1162,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,
                 });
@@ -1220,11 +1263,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);
@@ -1286,11 +1350,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;
@@ -1298,6 +1366,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 (main_cjs.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
@@ -1337,14 +1408,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 (main_cjs.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
@@ -1352,8 +1426,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();
@@ -1371,6 +1444,7 @@ class ModelProperty {
                         dataType: property.dataType,
                         refModelId: property.refModelId,
                         refValueType: property.refValueType,
+                        required: property.required,
                         storageType: property.storageType,
                         localStorageDir: property.localStorageDir,
                         filenameSuffix: property.filenameSuffix,
@@ -1398,18 +1472,56 @@ class ModelProperty {
             return proxiedInstance;
         return main_cjs.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;
             }
         }
@@ -1468,6 +1580,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;
@@ -1549,6 +1664,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 main_cjs.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
      */
@@ -1687,6 +1816,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
@@ -1702,13 +1861,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;
         main_cjs.forceRemoveFromCaches(this, {
-            getCacheKeys: () => [cacheKey],
+            getCacheKeys: () => cacheKeys,
             caches: [ModelProperty.instanceCache],
         });
         await main_cjs.runDestroyLifecycle(this, {
@@ -1757,6 +1927,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();
 
@@ -1766,4 +1945,4 @@ var ModelProperty$1 = /*#__PURE__*/Object.freeze({
 });
 
 exports.ModelProperty = ModelProperty;
-//# sourceMappingURL=ModelProperty-D9FGaGuE.js.map
+//# sourceMappingURL=ModelProperty-BEsIHAjk.js.map