@seedprotocol/sdk 0.7.9-next.1189.g5e63267 → 0.7.9

package/dist/{ModelProperty-DDD47KVm.js → ModelProperty-BlaEgb_U.js}

@@ -1,28 +1,25 @@
-import { fromCallback, setup, assign, createActor } from 'xstate';
-import { w as writeProcessMachine, c as currentEvictionEpoch, M as Model, b as anyEvictionSince, s as schemaEvictedSince } from './errors-CS3nDpUU.js';
-import { L as BaseDb, p as models, E as properties, J as schemas, z as modelSchemas, ai as getModelIdByFileId, n as normalizeDataType, a5 as generateId, M as ModelPropertyDataTypes, Q as BaseFileManager, aj as getModelId, ak as setCachedPropertyRefresher } from './index-rOTW-2QZ.js';
+import { fromCallback, setup, assign, createActor, waitFor } from 'xstate';
+import { M as Model, F as saveDefinition } from './errors-DLSoqSHG.js';
+import { r as resolveModelRecord, n as normalizeDataType, m as generateId, a2 as definitionOnlyFields, a3 as persistDefinitionFields, a4 as getPropertyDefinition, a5 as propertyDefinitionFromRow, M as ModelPropertyDataTypes, a6 as setCachedPropertyRefresher } from './tabEvents-CaVmngqr.js';
 import 'pluralize';
 import '@seedprotocol/eas';
-import { eq, and, inArray } from 'drizzle-orm';
-import { modelPropertiesToObject } from './model-oHA3YhOd.js';
-import { P as isActorStopped, Q as DEFAULT_READY_TIMEOUT_MS, F as waitForEntityIdle, R as createReactiveProxy, S as sameEntity, T as findEntity, U as forceRemoveFromCaches, V as runDestroyLifecycle } from './Item-CG5IhPtL.js';
+import { B as BaseDb, d as models, l as properties, t as schemas, j as modelSchemas, w as BaseFileManager } from './BaseFileManager-BAlySv8w.js';
+import { aj as isActorStopped, T as applyContextUpdate, U as isInternalUpdate, ak as differsFromOriginals, V as evictionLog, a7 as modelPropertiesToObject, Z as DEFAULT_READY_TIMEOUT_MS, _ as waitForEntityReady, $ as createReactiveProxy, al as onEntityTeardown, a0 as runEntityLoad, W as holdChild, a2 as entityStatus, a1 as evictEntities, a3 as releaseEntity, a4 as destroyEntity, a5 as EntityCache } from './Item-Bf4kWKpH.js';
 import debug from 'debug';
-import { S as Schema } from './Schema-BS8oR7QV.js';
-import './ClientManager-DqL0q_eu.js';
-import 'lodash-es';
-import './changeFeed-M8sGbOrW.js';
-import './eventBus-7vxTCc3a.js';
 import '@seedprotocol/arweave';
+import { eq, and, inArray } from 'drizzle-orm';
+import { S as Schema } from './Schema-J_1f6p0c.js';
+import '@sinclair/typebox';
+import 'lodash-es';
 import '@noble/hashes/sha3';
 import '@noble/hashes/utils';
 import '@seedprotocol/query';
-import '@sinclair/typebox';
 import 'drizzle-orm/sqlite-core';
 import 'nanoid';
 import 'nanoid-dictionary';
 import '@noble/hashes/sha256';
 import 'rxjs';
-import './SchemaValidationService-CZzKNL04.js';
+import './SchemaValidationService-CnmKyzR-.js';
 import '@sinclair/typebox/value';
 
 const logger$3 = debug('seedSdk:modelProperty:actors:saveToSchema');
@@ -33,15 +30,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-DqL0q_eu.js');
-    const _ns_0 = _mod_0.S;
+    const _mod_0 = await import('./errors-DLSoqSHG.js');
+    const _ns_0 = _mod_0.a5;
     const schemaHelpersMod = _ns_0;
     const { listLatestSchemaFiles } = schemaHelpersMod;
     const latestSchemas = await listLatestSchemaFiles();
     for (const schema of latestSchemas) {
         try {
-            const _mod_1 = await import('./index-rOTW-2QZ.js');
-            const _ns_1 = _mod_1.bb;
+            const _mod_1 = await import('./BaseFileManager-BAlySv8w.js');
+            const _ns_1 = _mod_1.A;
             const fileManagerMod = _ns_1;
             const { BaseFileManager } = fileManagerMod;
             const content = await BaseFileManager.readFileAsString(schema.filePath);
@@ -60,7 +57,7 @@ async function getSchemaNameFromModel(modelName) {
 const saveToSchema = fromCallback(({ sendBack, input: { context }, self }) => {
     const _saveToSchema = async () => {
         // Use dynamic import to break circular dependency
-        const validationServiceMod = await import('./SchemaValidationService-CZzKNL04.js');
+        const validationServiceMod = await import('./SchemaValidationService-CnmKyzR-.js');
         const { SchemaValidationService } = validationServiceMod;
         const validationService = new SchemaValidationService();
         // Validate property structure before saving
@@ -79,23 +76,23 @@ const saveToSchema = fromCallback(({ sendBack, input: { context }, self }) => {
             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('./index-rOTW-2QZ.js');
-        const _ns_2 = _mod_2.bf;
+        const _mod_2 = await import('./tabEvents-CaVmngqr.js');
+        const _ns_2 = _mod_2.bh;
         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-BS8oR7QV.js');
+            const _mod_3 = await import('./Schema-J_1f6p0c.js');
             const _ns_3 = _mod_3.a;
             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, hold: false });
-            schema.getService().send({
+            const schema = await Schema.find({ schemaName, waitForReady: false, hold: false });
+            schema?.getService().send({
                 type: 'markAsDraft',
                 propertyKey: `${context.modelName}:${context.name}`,
             });
@@ -125,22 +122,14 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context }, self }
         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('./index-rOTW-2QZ.js');
-                const _ns_4 = _mod_4.bf;
-                const dbMod = _ns_4;
-                const { getPropertyModelNameAndDataType, getModelNameByModelId } = dbMod;
-                let fromDb;
-                for (let attempt = 0; attempt < 6; attempt++) {
-                    fromDb = await getPropertyModelNameAndDataType(schemaFileIdForResolve);
-                    if (fromDb)
-                        break;
-                    if (attempt < 5)
-                        await new Promise((r) => setTimeout(r, 40));
-                }
+                const _mod_4 = await import('./tabEvents-CaVmngqr.js');
+                const _ns_4 = _mod_4.be;
+                const { resolveModelRecord, resolvePropertyModelRecord } = _ns_4;
+                const fromDb = await resolvePropertyModelRecord(schemaFileIdForResolve);
                 if (fromDb) {
                     fullContext = {
                         ...fullContext,
-                        modelName: fullContext.modelName ?? fromDb.modelName,
+                        modelName: fullContext.modelName ?? fromDb.name,
                         dataType: fullContext.dataType ?? fromDb.dataType,
                     };
                 }
@@ -149,7 +138,7 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context }, self }
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     const pendingModelId = ModelProperty?.getPendingModelId?.(schemaFileIdForResolve);
                     if (pendingModelId != null) {
-                        const modelName = await getModelNameByModelId(pendingModelId);
+                        const modelName = (await resolveModelRecord(undefined, { modelId: pendingModelId }))?.name;
                         if (modelName) {
                             fullContext = { ...fullContext, modelName };
                         }
@@ -172,8 +161,8 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context }, self }
             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('./index-rOTW-2QZ.js');
-                    const _ns_5 = _mod_5.bf;
+                    const _mod_5 = await import('./tabEvents-CaVmngqr.js');
+                    const _ns_5 = _mod_5.bh;
                     const dbMod = _ns_5;
                     const { savePropertyToDb } = dbMod;
                     // Ensure _propertyFileId is set for savePropertyToDb to find the property
@@ -234,8 +223,8 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context }, self }
             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('./index-rOTW-2QZ.js');
-            const _ns_6 = _mod_6.bf;
+            const _mod_6 = await import('./tabEvents-CaVmngqr.js');
+            const _ns_6 = _mod_6.bh;
             const dbMod = _ns_6;
             const { savePropertyToDb } = dbMod;
             // Save to database (but not JSON file) - always save to DB when there are changes
@@ -250,16 +239,16 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context }, self }
             // 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-BS8oR7QV.js');
+                const _mod_7 = await import('./Schema-J_1f6p0c.js');
                 const _ns_7 = _mod_7.a;
                 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, hold: false });
+                const schema = await Schema.find({ schemaName: fullContext._schemaName, waitForReady: false, hold: false });
                 // Send event to Schema machine to mark as draft
-                schema.getService().send({
+                schema?.getService().send({
                     type: 'markAsDraft',
                     propertyKey: `${fullContext.modelName}:${fullContext.name}`,
                 });
@@ -270,7 +259,7 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context }, self }
             logger$2(`Property ${fullContext.modelName}:${fullContext.name} has no changes`);
             // Clear isEdited flag in database
             try {
-                const _mod_8 = await import('./index-DxHpPNfn.js');
+                const _mod_8 = await import('./index-D0V-mjCV.js');
                 const _ns_8 = _mod_8.s;
                 const seedSchemaMod = _ns_8;
                 const { properties: propertiesTable } = seedSchemaMod;
@@ -279,7 +268,7 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context }, self }
                 const db = BaseDb.getAppDb();
                 if (db && fullContext.modelName && fullContext.name) {
                     // Find this property's model (model names are only unique per schema)
-                    const _mod_9 = await import('./index-rOTW-2QZ.js');
+                    const _mod_9 = await import('./tabEvents-CaVmngqr.js');
                     const _ns_9 = _mod_9.be;
                     const { resolveModelRecord } = _ns_9;
                     const modelRecord = await resolveModelRecord(fullContext.modelName, {
@@ -336,53 +325,31 @@ const validateProperty = fromCallback(({ sendBack, input: { context }, self }) =
         };
         const schemaFileId = typeof context.id === 'string' ? context.id : undefined;
         if (schemaFileId && (fullContext.modelName === undefined || fullContext.dataType === undefined)) {
-            // Brief wait so trackPendingWrite from ModelProperty.create() has time to run (it's in setTimeout(0))
-            await new Promise((r) => setTimeout(r, 60));
             try {
-                const _mod_10 = await import('./index-rOTW-2QZ.js');
-                const _ns_10 = _mod_10.bf;
-                const dbMod = _ns_10;
-                const { getPropertyModelNameAndDataType, getModelNameByModelId } = dbMod;
+                const _mod_10 = await import('./tabEvents-CaVmngqr.js');
+                const _ns_10 = _mod_10.be;
+                const { resolveModelRecord, resolvePropertyModelRecord } = _ns_10;
                 // Try pending write first (property row may not exist yet)
                 if (fullContext.modelName === undefined && schemaFileId) {
                     const mod = await Promise.resolve().then(function () { return ModelProperty$1; });
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     const pendingModelId = ModelProperty?.getPendingModelId?.(schemaFileId);
                     if (pendingModelId != null) {
-                        const modelName = await getModelNameByModelId(pendingModelId);
+                        const modelName = (await resolveModelRecord(undefined, { modelId: pendingModelId }))?.name;
                         if (modelName) {
                             fullContext = { ...fullContext, modelName };
                         }
                     }
                 }
-                // Then DB property lookup with retry (catches row after initial write)
-                let fromDb;
-                for (let attempt = 0; attempt < 6; attempt++) {
-                    fromDb = await getPropertyModelNameAndDataType(schemaFileId);
-                    if (fromDb)
-                        break;
-                    if (attempt < 5)
-                        await new Promise((r) => setTimeout(r, 40));
-                }
+                // Then the property's row, once its write has run
+                const fromDb = await resolvePropertyModelRecord(schemaFileId);
                 if (fromDb) {
                     fullContext = {
                         ...fullContext,
-                        modelName: fullContext.modelName ?? fromDb.modelName,
+                        modelName: fullContext.modelName ?? fromDb.name,
                         dataType: fullContext.dataType ?? fromDb.dataType,
                     };
                 }
-                // If still no modelName, try pending write again (may have been set during retries)
-                if (fullContext.modelName === undefined && schemaFileId) {
-                    const mod = await Promise.resolve().then(function () { return ModelProperty$1; });
-                    const ModelProperty = mod?.ModelProperty ?? mod?.default;
-                    const pendingModelId = ModelProperty?.getPendingModelId?.(schemaFileId);
-                    if (pendingModelId != null) {
-                        const modelName = await getModelNameByModelId(pendingModelId);
-                        if (modelName) {
-                            fullContext = { ...fullContext, modelName };
-                        }
-                    }
-                }
             }
             catch {
                 // ignore
@@ -393,10 +360,10 @@ const validateProperty = fromCallback(({ sendBack, input: { context }, self }) =
             fullContext = { ...fullContext, dataType: (fullContext.dataType ?? context._originalValues?.dataType) || 'Text' };
         }
         // Use dynamic imports to break circular dependencies
-        const validationServiceMod = await import('./SchemaValidationService-CZzKNL04.js');
+        const validationServiceMod = await import('./SchemaValidationService-CnmKyzR-.js');
         const { SchemaValidationService } = validationServiceMod;
         const validationService = new SchemaValidationService();
-        const _mod_11 = await import('./Schema-BS8oR7QV.js');
+        const _mod_11 = await import('./Schema-J_1f6p0c.js');
         const _ns_11 = _mod_11.a;
         const schemaMod = _ns_11;
         const { Schema } = schemaMod;
@@ -412,7 +379,9 @@ const validateProperty = fromCallback(({ sendBack, input: { context }, self }) =
             return;
         if (fullContext._schemaName && fullContext.modelName) {
             try {
-                const schema = Schema.create(fullContext._schemaName, { waitForReady: false, hold: false });
+                const schema = await Schema.find({ schemaName: fullContext._schemaName, waitForReady: false, hold: false });
+                if (!schema)
+                    throw new Error(`No schema named "${fullContext._schemaName}"`);
                 const schemaSnapshot = schema.getService().getSnapshot();
                 const schemaStatus = schemaSnapshot.value;
                 // Only validate against schema if it's loaded (in idle state)
@@ -494,7 +463,6 @@ const modelPropertyMachine = setup({
         saveToSchema,
         compareAndMarkDraft,
         validateProperty,
-        writeProcessMachine,
     },
     guards: {
         isPropertyValid: ({ context }) => {
@@ -503,6 +471,29 @@ const modelPropertyMachine = setup({
         },
     },
     actions: {
+        applyUpdate: assign(({ context, event }) => {
+            const next = applyContextUpdate(context, event);
+            // TypeBox validation expects undefined, not null, for the optional ref fields
+            for (const field of ['refValueType', 'refModelId', 'ref', 'refModelName']) {
+                if (next[field] === null)
+                    next[field] = undefined;
+            }
+            if (isInternalUpdate(event))
+                return next;
+            // Validation and the row write need these even when a just-created property is renamed
+            // before its creator's full context arrives
+            const originals = context._originalValues;
+            if (next.modelName === undefined && originals?.modelName !== undefined)
+                next.modelName = originals.modelName;
+            if (next.dataType === undefined && originals?.dataType !== undefined)
+                next.dataType = originals.dataType;
+            const edited = differsFromOriginals(originals, next, event);
+            return {
+                ...next,
+                ...(edited !== undefined && { _isEdited: edited }),
+                _validationErrors: undefined,
+            };
+        }),
         assignValidationErrors: assign(({ context, event }) => {
             if (event.type === 'validationError') {
                 return {
@@ -521,66 +512,11 @@ const modelPropertyMachine = setup({
         return context;
     },
     on: {
-        updateContext: {
-            actions: assign(({ context, event }) => {
-                const newContext = Object.assign({}, context);
-                // Check if this is only updating internal fields
-                const onlyInternalFields = Object.keys(event).every((key) => {
-                    return key === 'type' || key.startsWith('_');
-                });
-                // Update the context with new values
-                for (let i = 0; i < Object.keys(event).length; i++) {
-                    const key = Object.keys(event)[i];
-                    if (key === 'type') {
-                        continue;
-                    }
-                    let value = event[key];
-                    // Convert null to undefined for optional fields (TypeBox validation expects undefined, not null)
-                    // This is especially important for refValueType, refModelId, etc.
-                    if (value === null && (key === 'refValueType' || key === 'refModelId' || key === 'ref' || key === 'refModelName')) {
-                        value = undefined;
-                    }
-                    newContext[key] = value;
-                }
-                // Preserve modelName and dataType from context or _originalValues so validation and savePropertyToDb
-                // never run with missing required/needed fields (e.g. when a just-created property is renamed before
-                // the full context is available from the creator).
-                if (newContext.modelName === undefined && context._originalValues?.modelName !== undefined) {
-                    newContext.modelName = context._originalValues.modelName;
-                }
-                if (newContext.dataType === undefined && context._originalValues?.dataType !== undefined) {
-                    newContext.dataType = context._originalValues.dataType;
-                }
-                // Compare with original values and set _isEdited flag (only for non-internal updates)
-                if (!onlyInternalFields && context._originalValues) {
-                    const hasChanges = Object.keys(event).some((key) => {
-                        if (key === 'type' || key.startsWith('_'))
-                            return false;
-                        return newContext[key] !== context._originalValues?.[key];
-                    });
-                    newContext._isEdited = hasChanges;
-                }
-                // Clear validation errors on context update (will be re-validated if needed)
-                newContext._validationErrors = undefined;
-                // Convert null to undefined for optional fields (TypeBox validation expects undefined, not null)
-                // This is especially important for refValueType, refModelId, etc.
-                const optionalFields = ['refValueType', 'refModelId', 'ref', 'refModelName'];
-                for (const field of optionalFields) {
-                    if (newContext[field] === null) {
-                        newContext[field] = undefined;
-                    }
-                }
-                return newContext;
-            }),
-            // Only trigger validation and compareAndMarkDraft if we're updating non-internal fields
-            guard: ({ event }) => {
-                const shouldTransition = !Object.keys(event).every((key) => {
-                    return key === 'type' || key.startsWith('_');
-                });
-                return shouldTransition;
-            },
-            target: '.validating',
-        },
+        updateContext: [
+            // A public change revalidates (then compareAndMarkDraft); an internal one is only applied
+            { guard: ({ event }) => !isInternalUpdate(event), actions: 'applyUpdate', target: '.validating' },
+            { actions: 'applyUpdate' },
+        ],
         validateProperty: {
             target: '.validating',
         },
@@ -646,34 +582,7 @@ const modelPropertyMachine = setup({
                 validateProperty: {
                     target: 'validating',
                 },
-                requestWrite: {
-                    actions: ({ context, event }) => {
-                        if (context.writeProcess) {
-                            context.writeProcess.send({
-                                type: 'startWrite',
-                                data: event.data,
-                            });
-                        }
-                    },
-                },
             },
-            entry: assign({
-                writeProcess: ({ spawn, context }) => {
-                    // Spawn writeProcess if we have id (schemaFileId)
-                    // New properties will have id generated
-                    const entityId = context.id;
-                    if (!context.writeProcess && entityId) {
-                        return spawn(writeProcessMachine, {
-                            input: {
-                                entityType: 'modelProperty',
-                                entityId: String(entityId),
-                                entityData: context,
-                            },
-                        });
-                    }
-                    return context.writeProcess;
-                },
-            }),
         },
         validating: {
             on: {
@@ -718,72 +627,8 @@ const modelPropertyMachine = setup({
             on: {
                 // Apply updateContext but do not re-invoke saveToSchema actor (avoids infinite loop).
                 // Context is updated; in-flight save completes with original context.
-                updateContext: [
-                    {
-                        guard: ({ context, event }) => {
-                            const onlyInternal = Object.keys(event).every((k) => k === 'type' || k.startsWith('_'));
-                            return !onlyInternal && event.name !== undefined && event.name !== context.name;
-                        },
-                        actions: assign(({ context, event }) => {
-                            const newContext = Object.assign({}, context);
-                            const onlyInternalFields = Object.keys(event).every((key) => key === 'type' || key.startsWith('_'));
-                            for (const key of Object.keys(event)) {
-                                if (key === 'type')
-                                    continue;
-                                let value = event[key];
-                                if (value === null && ['refValueType', 'refModelId', 'ref', 'refModelName'].includes(key))
-                                    value = undefined;
-                                newContext[key] = value;
-                            }
-                            if (newContext.modelName === undefined && context._originalValues?.modelName !== undefined) {
-                                newContext.modelName = context._originalValues.modelName;
-                            }
-                            if (newContext.dataType === undefined && context._originalValues?.dataType !== undefined) {
-                                newContext.dataType = context._originalValues.dataType;
-                            }
-                            if (!onlyInternalFields && context._originalValues) {
-                                const hasChanges = Object.keys(event).some((key) => {
-                                    if (key === 'type' || key.startsWith('_'))
-                                        return false;
-                                    return newContext[key] !== context._originalValues?.[key];
-                                });
-                                newContext._isEdited = hasChanges;
-                            }
-                            newContext._validationErrors = undefined;
-                            return newContext;
-                        }),
-                    },
-                    {
-                        actions: assign(({ context, event }) => {
-                            const newContext = Object.assign({}, context);
-                            const onlyInternalFields = Object.keys(event).every((key) => key === 'type' || key.startsWith('_'));
-                            for (const key of Object.keys(event)) {
-                                if (key === 'type')
-                                    continue;
-                                let value = event[key];
-                                if (value === null && ['refValueType', 'refModelId', 'ref', 'refModelName'].includes(key))
-                                    value = undefined;
-                                newContext[key] = value;
-                            }
-                            if (newContext.modelName === undefined && context._originalValues?.modelName !== undefined) {
-                                newContext.modelName = context._originalValues.modelName;
-                            }
-                            if (newContext.dataType === undefined && context._originalValues?.dataType !== undefined) {
-                                newContext.dataType = context._originalValues.dataType;
-                            }
-                            if (!onlyInternalFields && context._originalValues) {
-                                const hasChanges = Object.keys(event).some((key) => {
-                                    if (key === 'type' || key.startsWith('_'))
-                                        return false;
-                                    return newContext[key] !== context._originalValues?.[key];
-                                });
-                                newContext._isEdited = hasChanges;
-                            }
-                            newContext._validationErrors = undefined;
-                            return newContext;
-                        }),
-                    },
-                ],
+                // Applied without re-invoking saveToSchema (that looped); the save in flight keeps its context
+                updateContext: { actions: 'applyUpdate' },
                 // validationError: Uses root handler for assignment, but needs state-specific transition
                 validationError: {
                     target: 'idle',
@@ -843,6 +688,8 @@ const getModelPropertiesData = async (modelFileId) => {
 };
 
 const logger = debug('seedSdk:modelProperty:ModelProperty');
+/** Property objects createById built from a row: their rules are already stored, nothing to persist. */
+const definitionsReadFromRow = new WeakSet();
 // Define the property keys from TProperty
 const TPropertyKeys = [
     'id',
@@ -860,8 +707,8 @@ const TPropertyKeys = [
 ];
 class ModelProperty {
     constructor(property) {
-        /** currentEvictionEpoch() at construction: lookups started for this instance don't outlive an eviction. */
-        this._evictionEpoch = currentEvictionEpoch();
+        /** evictionLog.now() at construction: lookups started for this instance don't outlive an eviction. */
+        this._since = evictionLog.now();
         // 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)
@@ -878,7 +725,7 @@ class ModelProperty {
         });
         this._service.start();
         // Initialize original values from the input property
-        this._initializeOriginalValues(property);
+        this._originalValuesLoaded = this._initializeOriginalValues(property);
         // Note: Property getters/setters are now handled by the Proxy in create()
     }
     /**
@@ -913,9 +760,15 @@ class ModelProperty {
                 // Ignore errors - model might not exist yet
             });
         }
+        // Get schema name from model asynchronously (fire-and-forget)
+        if (property.modelName) {
+            this._setSchemaName(property).catch(() => {
+                // If we can't get schema name, that's okay - it will be set later if needed
+            });
+        }
         // Get schema file values to use as "original" values
         // This allows us to detect if the property was edited (DB value differs from schema file)
-        this._getSchemaFileValues(property).then((schemaFileValues) => {
+        return this._getSchemaFileValues(property).then((schemaFileValues) => {
             // Use schema file values as original (not the current property values)
             // This way, if current values differ from schema file, _isEdited will be true
             const originalValues = schemaFileValues || {};
@@ -969,9 +822,8 @@ class ModelProperty {
                 // For runtime-created properties, set isEdited = true initially
                 isEdited = true;
             }
-            // 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) => {
+            // Initialize with original values, including isEdited flag (from the row when there is one)
+            return this._loadIsEditedFromDb(property, isEdited).then((isEditedFromDb) => {
                 this._sendIfRunning({
                     type: 'initializeOriginalValues',
                     originalValues,
@@ -1001,12 +853,6 @@ class ModelProperty {
                 schemaName: undefined,
             });
         });
-        // Get schema name from model asynchronously (fire-and-forget)
-        if (property.modelName) {
-            this._setSchemaName(property).catch(() => {
-                // If we can't get schema name, that's okay - it will be set later if needed
-            });
-        }
     }
     /**
      * Load isEdited flag from database if property exists in DB
@@ -1024,7 +870,7 @@ class ModelProperty {
                 return fallbackIsEdited;
             }
             // Find this property's model (by modelId when known; model names are only unique per schema)
-            const _mod_12 = await import('./index-rOTW-2QZ.js');
+            const _mod_12 = await import('./tabEvents-CaVmngqr.js');
             const _ns_12 = _mod_12.be;
             const { resolveModelRecord } = _ns_12;
             const modelRecord = await resolveModelRecord(property.modelName, this._ownerModelScope(property), db);
@@ -1062,7 +908,7 @@ class ModelProperty {
                 return undefined;
             }
             // Resolve the ref within the owning model's schema
-            const _mod_13 = await import('./index-rOTW-2QZ.js');
+            const _mod_13 = await import('./tabEvents-CaVmngqr.js');
             const _ns_13 = _mod_13.be;
             const { resolveRefModelRecord } = _ns_13;
             const refModelRecord = await resolveRefModelRecord(refModelName, property ? this._ownerModelScope(property) : { schemaName: this._getSnapshotContext()._schemaName }, db);
@@ -1108,7 +954,7 @@ class ModelProperty {
                 }
             }
             if (!model && modelId) {
-                const _mod_14 = await import('./index-rOTW-2QZ.js');
+                const _mod_14 = await import('./tabEvents-CaVmngqr.js');
                 const _ns_14 = _mod_14.be;
                 const { resolveModelRecord } = _ns_14;
                 const modelFileId = (await resolveModelRecord(property.modelName, { modelId }))?.schemaFileId;
@@ -1120,10 +966,10 @@ class ModelProperty {
                 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.
+                    // An eviction of the model's schema since this instance was built (it may already be
+                    // stopped) must not re-create the model.
                     model = await Model.getByNameAsync(property.modelName, undefined, {
-                        evictionEpoch: this._evictionEpoch,
+                        since: this._since,
                         hold: false,
                     });
                 }
@@ -1244,7 +1090,9 @@ class ModelProperty {
             if (modelId == null)
                 return undefined;
             // Resolve modelFileId (string) to database ID (number) if needed - modelSchemas.modelId expects number
-            const modelIdNum = typeof modelId === 'string' ? await getModelIdByFileId(modelId) : modelId;
+            const modelIdNum = typeof modelId === 'string' ? (await resolveModelRecord(undefined, { modelFileId: modelId }, db))?.id : modelId;
+            if (modelIdNum == null)
+                return undefined;
             const modelSchemaRecords = await db
                 .select({ schemaName: schemas.name })
                 .from(modelSchemas)
@@ -1274,6 +1122,9 @@ class ModelProperty {
         const waitForReady = options?.waitForReady !== false;
         const readyTimeout = options?.readyTimeout ?? DEFAULT_READY_TIMEOUT_MS;
         const schemaName = options?.schemaName;
+        const hold = options?.hold !== false;
+        // An id the caller passed (not one generated below): the cache may have that property
+        const givenId = typeof property.id === 'string' ? property.id : (property._propertyFileId ?? undefined);
         // Handle 'type' field from JSON schema format - convert to 'dataType'
         // Normalize to PascalCase so lowercase values from JSON (e.g. 'text') work
         const propertyWithId = { ...property };
@@ -1308,37 +1159,19 @@ class ModelProperty {
             propertyWithId.id = generateId();
             logger(`ModelProperty.create: Generated new id (schemaFileId) "${propertyWithId.id}" for property "${property.name}"`);
         }
-        // Create cache key from modelName and name, or use id
-        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.)
+        // By id, else by `modelName:name`. Model names are only unique per schema: a property cached
+        // under that name may be another schema's. (Not only by id: the same property is often created
+        // first with a generated id, then with its real one.)
+        const nameKey = propertyWithId.modelName && propertyWithId.name ? `${propertyWithId.modelName}:${propertyWithId.name}` : undefined;
         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 cachedEntry = this.instanceCache.get(cacheKey);
-            const { instance, refCount } = cachedEntry;
+        const cachedByName = this.cache.peek(nameKey);
+        const nameTakenByOther = !!cachedByName && isOtherProperty(cachedByName._getSnapshotContext());
+        const cached = this.cache.peek(givenId) ?? (nameTakenByOther ? undefined : cachedByName);
+        if (cached) {
+            const instance = cached;
             const cachedContext = instance._getSnapshotContext();
             // Update cached instance if new property data has fields that the cached instance doesn't have
             // This handles cases where the property was created without ref initially, but now we have ref from schema
@@ -1352,30 +1185,32 @@ class ModelProperty {
             if (propertyWithId.refModelId && !cachedContext.refModelId) {
                 needsUpdate.refModelId = propertyWithId.refModelId;
             }
-            // Rules defined in code exist only on the instance: an instance cached from the DB row first
-            // (which has no column for them) must still take them.
+            // Rules defined in code: an instance cached from a row that doesn't have them takes them,
+            // and so does the row's definition.
             if (propertyWithId.validation && !cachedContext.validation) {
                 needsUpdate.validation = propertyWithId.validation;
             }
             if (propertyWithId.htmlEmbeddedDataUriPolicy && !cachedContext.htmlEmbeddedDataUriPolicy) {
                 needsUpdate.htmlEmbeddedDataUriPolicy = propertyWithId.htmlEmbeddedDataUriPolicy;
             }
+            const codeDefined = definitionOnlyFields(propertyWithId);
+            if (Object.keys(codeDefined).length > 0 && typeof propertyWithId.id === 'string') {
+                void persistDefinitionFields({ schemaFileId: propertyWithId.id }, codeDefined).catch((error) => logger(`Could not store the definition of property "${property.name}": ${error}`));
+            }
             if (Object.keys(needsUpdate).length > 0) {
                 instance._service.send({
                     type: 'updateContext',
                     ...needsUpdate,
                 });
             }
-            this.instanceCache.set(cacheKey, {
-                ...cachedEntry,
-                refCount: refCount + 1,
-            });
+            if (hold)
+                this.cache.holdInstance(instance);
             if (!waitForReady)
                 return instance;
-            return waitForEntityIdle(instance, { timeout: readyTimeout }).then(() => instance);
+            return waitForEntityReady(instance, { timeout: readyTimeout }).then(() => instance);
         }
         const newInstance = new this(propertyWithId);
-        // Set schema name before async operations so getModelId can resolve the correct model
+        // Set schema name before async operations so the model lookup is scoped to the right schema
         if (schemaName) {
             newInstance._service.send({
                 type: 'setSchemaName',
@@ -1401,13 +1236,20 @@ class ModelProperty {
                 });
             },
         });
-        this.instanceCache.set(cacheKey, {
-            instance: proxiedInstance,
-            refCount: 1,
+        this.cache.add(proxiedInstance, [propertyWithId.id, nameTakenByOther ? undefined : nameKey], { hold });
+        // A property is often created with a generated id and gets its real one later: key it by that too
+        let keyedId = propertyWithId.id;
+        const idWatch = newInstance._service.subscribe((snapshot) => {
+            const id = snapshot.context.id;
+            if (!id || id === keyedId)
+                return;
+            if (keyedId)
+                this.cache.removeKey(proxiedInstance, keyedId);
+            keyedId = id;
+            this.cache.addKey(proxiedInstance, id);
         });
-        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
+        onEntityTeardown(proxiedInstance, () => idWatch.unsubscribe());
+        // A property with a model (modelId or modelName) and an id (schemaFileId) writes its row
         const propertyFileId = propertyWithId.id; // id is now the schemaFileId (string)
         const hasModelId = propertyWithId.modelId || propertyWithId.modelName;
         // A _dbId means the data was loaded from an existing row (createById, getPropertySchema), so
@@ -1416,212 +1258,111 @@ class ModelProperty {
         // Settles when the row write finishes; create() waits for it when waitForReady is on, so a
         // failed write rejects create() instead of resolving with nothing in the DB.
         let writeDone = Promise.resolve();
+        const codeDefined = definitionOnlyFields(propertyWithId);
+        if (isPersisted && Object.keys(codeDefined).length > 0 && !definitionsReadFromRow.has(property)) {
+            // The row exists (a schema file's, or an earlier run's); rules defined in code go into its
+            // definition now rather than at the next saveNewVersion.
+            writeDone = persistDefinitionFields({ id: propertyWithId._dbId }, codeDefined).catch((error) => logger(`Could not store the definition of property "${property.name}": ${error}`));
+        }
         if (hasModelId && propertyFileId && !isPersisted) {
-            let resolveWrite;
-            let rejectWrite;
-            writeDone = new Promise((resolve, reject) => {
-                resolveWrite = resolve;
-                rejectWrite = reject;
-            });
-            // 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;
-            const maxRetries = 10;
-            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)) {
-                    resolveWrite();
-                    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
-                    let resolvedModelId = undefined;
-                    if (propertyWithId.modelId) {
-                        if (typeof propertyWithId.modelId === 'number') {
-                            resolvedModelId = propertyWithId.modelId;
-                        }
-                        else if (typeof propertyWithId.modelId === 'string') {
-                            // modelId is a string (modelFileId), need to convert to database ID
-                            try {
-                                resolvedModelId = await getModelIdByFileId(propertyWithId.modelId);
-                                logger(`Converted modelFileId "${propertyWithId.modelId}" to database modelId: ${resolvedModelId}`);
-                            }
-                            catch (error) {
-                                logger(`Failed to convert modelFileId "${propertyWithId.modelId}" to database ID: ${error}`);
-                                console.error(`[ModelProperty.create] Failed to convert modelFileId: ${error}`);
-                            }
-                        }
-                    }
-                    // If we still don't have a modelId, try to resolve it from modelName
-                    if (!resolvedModelId && propertyWithId.modelName) {
-                        try {
-                            // Get schemaName from context if available
-                            const schemaName = snapshot.context._schemaName;
-                            resolvedModelId = await getModelId(propertyWithId.modelName, schemaName);
-                            logger(`Resolved modelId for model "${propertyWithId.modelName}": ${resolvedModelId}`);
-                        }
-                        catch (error) {
-                            logger(`Failed to resolve modelId for model "${propertyWithId.modelName}": ${error}`);
-                            console.error(`[ModelProperty.create] Failed to resolve modelId: ${error}`);
-                        }
-                    }
-                    if (!resolvedModelId) {
-                        logger(`ERROR: Cannot write property "${property.name}" - no modelId available`);
-                        console.error(`[ModelProperty.create] ERROR: Cannot write property "${property.name}" - no modelId available. modelId: ${propertyWithId.modelId}, modelName: ${propertyWithId.modelName}`);
-                        // Don't clear pending write here - it might resolve later
-                        rejectWrite(new Error(`Cannot write property "${property.name}": model ${propertyWithId.modelName ?? propertyWithId.modelId} has no database row`));
-                        return;
-                    }
-                    // Resolving the modelId awaited the DB; the instance may have been stopped meanwhile
-                    if (isActorStopped(service)) {
-                        resolveWrite();
-                        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
-                        void this.completePendingWrite(propertyFileId, resolvedModelId);
-                        resolveWrite();
-                    }
-                    else {
-                        // Set up subscription to catch future state changes
-                        const writeSubscription = writeProcess.subscribe((writeSnapshot) => {
-                            if (writeSnapshot.value === 'success') {
-                                writeSubscription.unsubscribe();
-                                logger(`[writeProcess subscription] Write succeeded for property "${property.name}" (propertyFileId: ${propertyFileId})`);
-                                void this.completePendingWrite(propertyFileId, resolvedModelId);
-                                resolveWrite();
-                            }
-                            else if (writeSnapshot.value === 'error') {
-                                writeSubscription.unsubscribe();
-                                const errorContext = writeSnapshot.context;
-                                logger(`Write process failed for property "${property.name}" (propertyFileId: ${propertyFileId}): ${errorContext.error?.message || 'Unknown error'}`);
-                                logger(`Write process error details:`, errorContext.error);
-                                // Mark pending write as error
-                                this.clearPendingWrite(propertyFileId, 'error');
-                                rejectWrite(new Error(`Failed to write property "${property.name}": ${errorContext.error?.message || 'Unknown error'}`));
-                            }
-                        });
-                    }
-                    const propertyData = {
-                        modelId: resolvedModelId,
-                        name: property.name,
-                        dataType: property.dataType,
-                        refModelId: property.refModelId,
-                        refValueType: property.refValueType,
-                        required: property.required,
-                        storageType: property.storageType,
-                        localStorageDir: property.localStorageDir,
-                        filenameSuffix: property.filenameSuffix,
-                    };
-                    service.send({
-                        type: 'requestWrite',
-                        data: propertyData,
-                    });
-                }
-                else if (retries < maxRetries) {
-                    retries++;
-                    setTimeout(checkAndSend, 50); // Retry after 50ms
-                }
-                else {
-                    logger(`ERROR: writeProcess not available after ${maxRetries} retries for property "${property.name}" (propertyFileId: ${propertyFileId})`);
-                    console.error(`[ModelProperty.create] ERROR: writeProcess not available after ${maxRetries} retries for property "${property.name}" (propertyFileId: ${propertyFileId})`);
-                    // Mark as error if we couldn't even start the write process
-                    this.clearPendingWrite(propertyFileId, 'error');
-                    rejectWrite(new Error(`Failed to write property "${property.name}": its write process never started`));
-                }
-            };
-            // Start checking after a short delay to allow state machine to initialize
-            setTimeout(checkAndSend, 0);
+            writeDone = this.persistNewProperty(proxiedInstance, propertyWithId, propertyFileId);
         }
-        if (!waitForReady) {
-            // Nobody awaits the write; failures are already logged above.
-            writeDone.catch(() => { });
+        // Ready once its row is written (when it had none) and its original values are known
+        void runEntityLoad(proxiedInstance, async () => {
+            await Promise.all([writeDone, newInstance._originalValuesLoaded.catch(() => { })]);
+        });
+        if (!waitForReady)
             return proxiedInstance;
-        }
-        let timer;
-        const writeWithin = Promise.race([
-            writeDone,
-            new Promise((_, reject) => {
-                timer = setTimeout(() => reject(new Error(`Property "${property.name}" was not written within ${readyTimeout}ms`)), readyTimeout);
-            }),
-        ]).finally(() => clearTimeout(timer));
-        return Promise.all([waitForEntityIdle(proxiedInstance, { timeout: readyTimeout }), writeWithin]).then(() => proxiedInstance);
+        return waitForEntityReady(proxiedInstance, { timeout: readyTimeout }).then(() => proxiedInstance);
     }
-    /** Whether an idIndex entry still points at a cached instance with that id. */
-    static isIndexEntryCurrent(propertyFileId, entry) {
-        const cached = this.instanceCache.get(entry.cacheKey)?.instance;
-        if (!cached || !sameEntity(cached, entry.instance))
-            return false;
+    /**
+     * Writes the row of a property ModelProperty.create made, under the model row its modelId (row id
+     * or file id) or modelName names. Resolves without writing once the instance is stopped; rejects
+     * when the model has no row or the write fails.
+     */
+    static async persistNewProperty(instance, property, propertyFileId) {
+        const service = instance.getService();
+        const findModelId = async () => {
+            if (typeof property.modelId === 'number')
+                return property.modelId;
+            if (typeof property.modelId === 'string') {
+                const row = await resolveModelRecord(undefined, { modelFileId: property.modelId });
+                if (row?.id)
+                    return row.id;
+            }
+            if (!property.modelName)
+                return undefined;
+            // With a schema name only that schema's model counts (no name-only fallback)
+            const row = await resolveModelRecord(property.modelName, {
+                modelFileId: property.modelName,
+                schemaName: service.getSnapshot().context._schemaName,
+                strict: true,
+            });
+            return row?.id;
+        };
+        const modelId = await findModelId().catch((error) => {
+            logger(`Could not resolve the model of property "${property.name}": ${error}`);
+            return undefined;
+        });
+        if (!modelId) {
+            throw new Error(`Cannot write property "${property.name}": model ${property.modelName ?? property.modelId} has no database row`);
+        }
+        // Unloaded or evicted (e.g. Schema.destroy) before the write started: nothing to write to
+        if (isActorStopped(service))
+            return;
+        this.trackPendingWrite(propertyFileId, modelId);
         try {
-            return entry.instance._getSnapshotContext().id === propertyFileId;
+            await saveDefinition({
+                type: 'property',
+                propertyFileId,
+                data: () => {
+                    // A rename made since create is written, not the name create got
+                    const context = service.getSnapshot().context;
+                    return {
+                        modelId,
+                        name: context.name ?? property.name,
+                        dataType: context.dataType ?? property.dataType,
+                        refModelId: context.refModelId ?? property.refModelId,
+                        refModelName: context.refModelName ?? property.refModelName,
+                        refValueType: context.refValueType ?? property.refValueType,
+                        required: context.required ?? property.required,
+                        storageType: context.storageType ?? property.storageType,
+                        localStorageDir: context.localStorageDir ?? property.localStorageDir,
+                        filenameSuffix: context.filenameSuffix ?? property.filenameSuffix,
+                        // Stored in the row's definition column with the rest
+                        ...definitionOnlyFields(property),
+                    };
+                },
+            });
         }
-        catch {
-            return false;
+        catch (error) {
+            this.clearPendingWrite(propertyFileId, 'error');
+            throw new Error(`Failed to write property "${property.name}": ${error instanceof Error ? error.message : String(error)}`);
         }
-    }
-    /** 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 && !sameEntity(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);
-        });
+        void this.completePendingWrite(propertyFileId, modelId);
     }
     /**
-     * Turns the caller's hold from the create call just made into model ownership: the instance stays
-     * cached and running for its model, and app holders' unload calls don't stop it.
+     * Make the property's model hold it: the instance stays cached and running for its model, and app
+     * holders' unload calls don't stop it. Teardown of the model releases it. Without a cached model
+     * (it was unloaded meanwhile) nothing holds it.
      * @internal Used by the model's property loading.
      */
-    static adoptForModel(instance) {
-        for (const [key, entry] of this.instanceCache) {
-            if (entry.instance._service !== instance._service)
-                continue;
-            this.instanceCache.set(key, { ...entry, refCount: Math.max(0, entry.refCount - 1), modelOwned: true });
-        }
+    static holdForModel(instance, model) {
+        const context = instance._getSnapshotContext();
+        const owner = model ??
+            Model.cache.instances((candidate) => {
+                const modelContext = candidate.getService().getSnapshot().context;
+                if (typeof context.modelId === 'number')
+                    return modelContext._dbId === context.modelId;
+                return (modelContext.modelName === context.modelName &&
+                    (!context._schemaName || modelContext.schemaName === context._schemaName));
+            })[0];
+        if (owner)
+            holdChild(owner, instance, this.cache);
     }
-    /**
-     * Get ModelProperty instance by propertyFileId from static cache
-     */
+    /** The cached ModelProperty with this propertyFileId, without taking a hold. */
     static getById(propertyFileId) {
-        if (!propertyFileId)
-            return undefined;
-        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()) {
-            // id is now the schemaFileId (string)
-            if (instance._getSnapshotContext().id === propertyFileId) {
-                this.idIndex.set(propertyFileId, { cacheKey, instance });
-                return instance;
-            }
-        }
-        return undefined;
+        return this.cache.peek(propertyFileId);
     }
     /**
      * Create or get ModelProperty instance by propertyFileId
@@ -1631,9 +1372,10 @@ class ModelProperty {
         if (!propertyFileId) {
             return undefined;
         }
-        // First, check if we have an instance cached
+        // Cached (an app may have created it before its model's load got here): its model holds it too
         const cachedInstance = this.getById(propertyFileId);
         if (cachedInstance) {
+            this.holdForModel(cachedInstance);
             return cachedInstance;
         }
         // Query database to get property data from ID
@@ -1641,7 +1383,7 @@ class ModelProperty {
         if (!db) {
             return undefined;
         }
-        const evictionEpoch = options?.evictionEpoch ?? currentEvictionEpoch();
+        const since = options?.since ?? evictionLog.now();
         const propertyRecords = await db
             .select()
             .from(properties)
@@ -1661,53 +1403,37 @@ class ModelProperty {
             return undefined;
         }
         const modelName = modelRecords[0].name;
-        // Build property data
-        // id is now the schemaFileId (string), _dbId is the database integer ID
+        // id is the schemaFileId (string), _dbId the row id
+        const definition = await getPropertyDefinition(propertyRecord.id, db);
+        if (!definition)
+            return undefined;
         const propertyData = {
-            id: propertyFileId, // schemaFileId (string) - public ID
-            _dbId: propertyRecord.id ?? undefined, // Database integer ID - internal only
-            name: propertyRecord.name,
-            dataType: propertyRecord.dataType,
-            modelId: propertyRecord.modelId,
+            ...definition,
+            id: propertyFileId,
             modelName,
-            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,
+            required: definition.required ?? false,
         };
+        definitionsReadFromRow.add(propertyData);
         // Load isEdited from database
         const isEditedFromDb = propertyRecord.isEdited ?? false;
-        // Get ref model name if applicable
-        if (propertyRecord.refModelId) {
-            const refModelRecords = await db
-                .select({ name: models.name })
-                .from(models)
-                .where(eq(models.id, propertyRecord.refModelId))
-                .limit(1);
-            if (refModelRecords.length > 0) {
-                propertyData.refModelName = refModelRecords[0].name;
-                propertyData.ref = refModelRecords[0].name;
-            }
-        }
         // 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 })
+        if (evictionLog.now() !== since) {
+            const owners = await db
+                .select({ schemaName: schemas.name, modelFileId: models.schemaFileId })
                 .from(modelSchemas)
                 .innerJoin(schemas, eq(schemas.id, modelSchemas.schemaId))
+                .innerJoin(models, eq(models.id, modelSchemas.modelId))
                 .where(eq(modelSchemas.modelId, propertyRecord.modelId));
-            if (schemaRows.length === 0 ||
-                schemaRows.some((row) => schemaEvictedSince(row.name, evictionEpoch))) {
+            if (owners.length === 0 ||
+                owners.some((row) => evictionLog.evictedSince([`schema:${row.schemaName}`, `model:${row.modelFileId}`], since))) {
                 return undefined;
             }
         }
         // Create ModelProperty instance (sync for createById so we can send updateContext)
-        const instance = this.create(propertyData, { waitForReady: false });
-        // Loaded for its model (Model's property list, the model machine), not held by a caller.
-        this.adoptForModel(instance);
+        const instance = this.create(propertyData, { waitForReady: false, hold: false });
+        // Loaded for its model (Model's property list), not held by a caller
+        this.holdForModel(instance);
         // Set isEdited from database after creation
         if (isEditedFromDb) {
             instance._service.send({
@@ -1732,37 +1458,29 @@ class ModelProperty {
         if (!db)
             return;
         const rows = await db
-            .select({
-            schemaFileId: properties.schemaFileId,
-            name: properties.name,
-            dataType: properties.dataType,
-            refModelId: properties.refModelId,
-            refModelName: models.name,
-            refValueType: properties.refValueType,
-            required: properties.required,
-            storageType: properties.storageType,
-            localStorageDir: properties.localStorageDir,
-            filenameSuffix: properties.filenameSuffix,
-        })
+            .select({ property: properties, refModelName: models.name })
             .from(properties)
             .leftJoin(models, eq(models.id, properties.refModelId))
             .where(inArray(properties.schemaFileId, [...ids]));
         for (const row of rows) {
-            const propertyFileId = row.schemaFileId;
-            if (!propertyFileId || !row.name)
+            const propertyFileId = row.property.schemaFileId;
+            if (!propertyFileId || !row.property.name)
                 continue;
-            const dataType = row.dataType;
+            const definition = propertyDefinitionFromRow(row.property, row.refModelName);
+            const dataType = definition.dataType;
             const rowValues = {
-                name: row.name,
+                name: definition.name,
                 dataType,
-                refValueType: row.refValueType ?? undefined,
-                required: row.required ?? false,
-                storageType: row.storageType ?? undefined,
-                localStorageDir: row.localStorageDir ?? undefined,
-                filenameSuffix: row.filenameSuffix ?? undefined,
+                refValueType: definition.refValueType,
+                required: definition.required ?? false,
+                storageType: definition.storageType,
+                localStorageDir: definition.localStorageDir,
+                filenameSuffix: definition.filenameSuffix,
+                // Only when the row has them: rules code just set may not be stored yet
+                ...definitionOnlyFields(definition),
             };
-            if (row.refModelId) {
-                rowValues.refModelId = row.refModelId;
+            if (definition.refModelId) {
+                rowValues.refModelId = definition.refModelId;
                 if (row.refModelName) {
                     rowValues.ref = row.refModelName;
                     rowValues.refModelName = row.refModelName;
@@ -1775,24 +1493,23 @@ class ModelProperty {
                 rowValues.ref = undefined;
                 rowValues.refModelName = undefined;
             }
-            for (const [cacheKey, entry] of [...this.instanceCache.entries()]) {
-                const { instance } = entry;
+            for (const instance of this.cache.instances()) {
                 if (isActorStopped(instance._service))
                     continue;
                 const context = instance._getSnapshotContext();
                 if (context.id !== propertyFileId || context._isEdited)
                     continue;
-                const changed = Object.fromEntries(Object.entries(rowValues).filter(([key, value]) => context[key] !== value));
+                const changed = Object.fromEntries(Object.entries(rowValues).filter(([key, value]) => typeof value === 'object' && value !== null
+                    ? JSON.stringify(context[key]) !== JSON.stringify(value)
+                    : context[key] !== value));
                 if (Object.keys(changed).length === 0)
                     continue;
                 instance._service.send({ type: 'syncedFromStorage', values: changed });
-                const newCacheKey = changed.name && context.modelName ? `${context.modelName}:${changed.name}` : undefined;
-                if (newCacheKey && cacheKey === `${context.modelName}:${context.name}` && !this.instanceCache.has(newCacheKey)) {
-                    this.instanceCache.delete(cacheKey);
-                    this.instanceCache.set(newCacheKey, entry);
-                    const indexed = this.idIndex.get(propertyFileId)?.instance;
-                    if (indexed && sameEntity(indexed, instance)) {
-                        this.idIndex.set(propertyFileId, { cacheKey: newCacheKey, instance });
+                // Renamed: creating the property by its new name finds it
+                if (changed.name && context.modelName) {
+                    const ownNameKey = this.cache.keysOf(instance).includes(`${context.modelName}:${context.name}`);
+                    if (ownNameKey && !this.cache.peek(`${context.modelName}:${changed.name}`)) {
+                        this.cache.setKeys(instance, [propertyFileId, `${context.modelName}:${changed.name}`]);
                     }
                 }
             }
@@ -1808,13 +1525,10 @@ class ModelProperty {
         if (!propertyFileId) {
             return undefined;
         }
-        return await findEntity({
-            getById: (id) => ModelProperty.getById(id),
-            createById: (id) => ModelProperty.createById(id),
-        }, { id: propertyFileId }, {
-            waitForReady,
-            readyTimeout,
-        });
+        const property = ModelProperty.getById(propertyFileId) ?? (await ModelProperty.createById(propertyFileId));
+        if (property && waitForReady)
+            await waitForEntityReady(property, { timeout: readyTimeout });
+        return property;
     }
     /**
      * Get all ModelProperty instances for a model.
@@ -1836,9 +1550,7 @@ class ModelProperty {
             }
         }
         if (waitForReady && instances.length > 0) {
-            await Promise.all(instances.map((p) => waitForEntityIdle(p, {
-                timeout: readyTimeout,
-            })));
+            await Promise.all(instances.map((property) => waitForEntityReady(property, { timeout: readyTimeout })));
         }
         return instances;
     }
@@ -1917,8 +1629,13 @@ class ModelProperty {
         }
         return `${workingDir}/${this.localStorageDir}/${this.name}${this.filenameSuffix || ''}`;
     }
+    /** Resolves once `status` is `ready`; rejects when the load failed or `timeout` ms pass. */
+    waitForReady(options) {
+        return waitForEntityReady(this, options);
+    }
+    /** `loading` until its row is written (when it had none) and its original values are known. */
     get status() {
-        return this._getSnapshot().value;
+        return entityStatus(this);
     }
     get isEdited() {
         const context = this._getSnapshotContext();
@@ -1947,35 +1664,11 @@ class ModelProperty {
      * @returns Validation result
      */
     async validate() {
-        return new Promise((resolve) => {
-            let resolved = false;
-            const subscription = this._service.subscribe((snapshot) => {
-                const state = snapshot.value;
-                // Wait for validation to complete (idle state after validating)
-                if (state === 'idle' && !resolved) {
-                    resolved = true;
-                    subscription.unsubscribe();
-                    const errors = snapshot.context._validationErrors || [];
-                    resolve({
-                        isValid: errors.length === 0,
-                        errors,
-                    });
-                }
-            });
-            this._service.send({ type: 'validateProperty' });
-            // Timeout fallback
-            setTimeout(() => {
-                if (!resolved) {
-                    resolved = true;
-                    subscription.unsubscribe();
-                    const errors = this._getSnapshotContext()._validationErrors || [];
-                    resolve({
-                        isValid: errors.length === 0,
-                        errors,
-                    });
-                }
-            }, 5000);
-        });
+        this._service.send({ type: 'validateProperty' });
+        // Settles back in idle; after 5 s, the errors so far
+        await waitFor(this._service, (snapshot) => snapshot.value === 'idle', { timeout: 5000 }).catch(() => { });
+        const errors = this._getSnapshotContext()._validationErrors || [];
+        return { isValid: errors.length === 0, errors };
     }
     save() {
         const snapshot = this._service.getSnapshot();
@@ -2014,139 +1707,82 @@ class ModelProperty {
         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;
-            }
+        evictEntities(this.cache, (property) => {
+            const context = property._getSnapshotContext();
             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
+                return false;
+            return !schemaName || !context._schemaName || context._schemaName === schemaName;
+        });
+    }
+    /**
+     * Force-evict one model's cached properties (Model.destroy): by its row id when the property has
+     * one, else by model and schema name.
+     */
+    static evictForModel(model) {
+        evictEntities(this.cache, (property) => {
+            const context = property._getSnapshotContext();
+            if (typeof context.modelId === 'number' && typeof model.modelId === 'number') {
+                return context.modelId === model.modelId;
             }
-        }
+            if (!model.modelName || context.modelName !== model.modelName)
+                return false;
+            return !model.schemaName || !context._schemaName || context._schemaName === model.schemaName;
+        });
     }
     /**
      * Releases this caller's hold. The instance is shared: it keeps running while other callers hold
-     * it, or while its model owns it (a model's properties are stopped when the model is evicted).
-     * An instance nobody else holds is stopped and leaves the cache.
+     * it, or while its model holds it. An instance nobody else holds is stopped and leaves the cache.
      */
     unload() {
-        const entries = [...ModelProperty.instanceCache.entries()].filter(([, entry]) => entry.instance._service === this._service);
-        if (entries.length > 0) {
-            const [, first] = entries[0];
-            const refCount = Math.max(0, first.refCount - 1);
-            if (refCount > 0 || first.modelOwned) {
-                for (const [key, entry] of entries)
-                    ModelProperty.instanceCache.set(key, { ...entry, refCount });
-                return;
-            }
-            for (const [key] of entries)
-                ModelProperty.instanceCache.delete(key);
-        }
-        try {
-            this._service.stop();
-        }
-        catch {
-            // Service might already be stopped
-        }
+        releaseEntity(this, ModelProperty.cache);
     }
     /**
-     * Destroy the model property: remove from caches, delete from database, update Schema context, stop service.
+     * Destroy the model property: delete its row, remove it from its Schema's context, and stop it
+     * whoever holds it.
      */
     async destroy() {
         const context = this._getSnapshotContext();
-        // 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;
+        await destroyEntity(this, ModelProperty.cache, async () => {
+            const db = BaseDb.getAppDb();
+            const modelName = context.modelName;
+            const propertyName = context.name;
+            const propertyFileId = context.id ?? context._propertyFileId;
+            if (db && propertyFileId) {
+                const [row] = await db
+                    .select({ id: properties.id })
+                    .from(properties)
+                    .where(eq(properties.schemaFileId, propertyFileId))
+                    .limit(1);
+                if (row) {
+                    const { detachPropertyRows } = await import('./detachRowsBeforeDelete-sEaUwlOU.js');
+                    await detachPropertyRows(db, [row.id]);
+                    await db.delete(properties).where(eq(properties.id, row.id));
+                }
             }
-            catch {
-                return false;
+            if (!modelName || !propertyName)
+                return;
+            // Resolve schema name from DB when _schemaName is missing (e.g. destroy ran before _setSchemaName finished)
+            const schemaName = context._schemaName ?? (db ? await this._resolveSchemaNameForDestroy(db, context) : undefined);
+            if (!schemaName)
+                return;
+            const schema = await Schema.find({ schemaName, waitForReady: false, hold: false });
+            const schemaContext = schema?.getService().getSnapshot().context;
+            if (schema && schemaContext?.models?.[modelName]?.properties?.[propertyName]) {
+                const updatedModels = { ...schemaContext.models };
+                const updatedProperties = { ...updatedModels[modelName].properties };
+                delete updatedProperties[propertyName];
+                updatedModels[modelName] = { ...updatedModels[modelName], properties: updatedProperties };
+                schema.getService().send({ type: 'updateContext', models: updatedModels });
+                schema.getService().send({ type: 'markAsDraft', propertyKey: `property:${modelName}:${propertyName}` });
             }
-        })
-            .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: () => cacheKeys,
-            caches: [ModelProperty.instanceCache],
-        });
-        await runDestroyLifecycle(this, {
-            getService: (instance) => instance._service,
-            doDestroy: async () => {
-                const db = BaseDb.getAppDb();
-                let schemaName = context._schemaName;
-                const modelName = context.modelName;
-                const propertyName = context.name;
-                if (!modelName || !propertyName)
-                    return;
-                // Resolve schema name from DB when _schemaName is missing (e.g. destroy ran before _setSchemaName finished)
-                if (!schemaName && db) {
-                    schemaName = await this._resolveSchemaNameForDestroy(db, context);
-                }
-                if (db && schemaName) {
-                    const propertyRecords = await db
-                        .select({ propertyId: properties.id })
-                        .from(properties)
-                        .innerJoin(models, eq(properties.modelId, models.id))
-                        .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
-                        .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
-                        .where(and(eq(schemas.name, schemaName), eq(models.name, modelName), eq(properties.name, propertyName)))
-                        .limit(1);
-                    if (propertyRecords.length > 0 && propertyRecords[0].propertyId != null) {
-                        const { detachPropertyRows } = await import('./detachRowsBeforeDelete-Di1enVUF.js');
-                        await detachPropertyRows(db, [propertyRecords[0].propertyId]);
-                        await db
-                            .delete(properties)
-                            .where(eq(properties.id, propertyRecords[0].propertyId));
-                    }
-                }
-                if (schemaName) {
-                    const schema = Schema.create(schemaName, { waitForReady: false, hold: false });
-                    const snapshot = schema.getService().getSnapshot();
-                    const schemaContext = snapshot.context;
-                    if (schemaContext.models?.[modelName]?.properties?.[propertyName]) {
-                        const updatedModels = { ...schemaContext.models };
-                        const updatedProperties = { ...updatedModels[modelName].properties };
-                        delete updatedProperties[propertyName];
-                        updatedModels[modelName] = { ...updatedModels[modelName], properties: updatedProperties };
-                        schema.getService().send({ type: 'updateContext', models: updatedModels });
-                        schema.getService().send({ type: 'markAsDraft', propertyKey: `property:${modelName}:${propertyName}` });
-                    }
-                }
-            },
         });
     }
 }
 /**
- * `refCount` counts app holders (ModelProperty.create callers that haven't unloaded). `modelOwned`
- * marks an instance its model created or loaded: the model keeps it until the model is evicted,
- * so it isn't stopped when the app's holders unload it.
- */
-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.
+ * Cached under its id (schemaFileId) and `modelName:name` (ADR 0014). Its model holds it (see
+ * holdForModel), so app holders' unloads don't stop a model's property.
  */
-ModelProperty.idIndex = new Map();
+ModelProperty.cache = new EntityCache();
 // Pending writes tracking
 ModelProperty.pendingWrites = new Map();
 setCachedPropertyRefresher((propertyFileIds) => ModelProperty.refreshFromDb(propertyFileIds));
@@ -2157,4 +1793,4 @@ var ModelProperty$1 = /*#__PURE__*/Object.freeze({
 });
 
 export { ModelProperty };
-//# sourceMappingURL=ModelProperty-DDD47KVm.js.map
+//# sourceMappingURL=ModelProperty-BlaEgb_U.js.map