@seedprotocol/sdk 0.7.7 → 0.7.8-next.1034.g2acd2a2

package/dist/{errors-KM-yq2MD.js → errors-CQagdED2.js}

@@ -1,29 +1,13 @@
 import { fromCallback, fromPromise, setup, assign, createActor } from 'xstate';
-import { B as BaseDb, t as models, v as properties, ai as generateId, aJ as isInternalSchema, aK as writeModelToDb, aL as writePropertyToDb, aM as addSchemaToDb, r as modelSchemas, A as schemas, H as AmbiguousModelError, aN as renameModelInDb, aO as currentNameMatchLevels, a as TProperty } from './index-DpgQMIRq.js';
+import { B as BaseDb, t as models, v as properties, ah as generateId, aJ as isInternalSchema, aK as writeModelToDb, aL as writePropertyToDb, aM as addSchemaToDb, r as modelSchemas, A as schemas, H as AmbiguousModelError, aN as renameModelInDb, aO as currentNameMatchLevels, a as TProperty } from './index-C-NqjjY_.js';
 import { eq, and, isNull, or } from 'drizzle-orm';
 import debug from 'debug';
-import { d as waitForEntityIdle, D as DEFAULT_READY_TIMEOUT_MS, Z as getInvariantSafePropertyDescriptor, n as findEntity, C as ClientManagerState, I as Item, _ as clearDestroySubscriptions, o as forceRemoveFromCaches, $ as unloadEntity, q as runDestroyLifecycle } from './Item-D6j0IvBP.js';
-import { m as getClient } from './ClientManager-2GtDWHq6.js';
+import { m as isActorStopped, $ as ActorKeyedState, d as waitForEntityIdle, D as DEFAULT_READY_TIMEOUT_MS, n as createReactiveProxy, q as findEntity, C as ClientManagerState, I as Item, a0 as clearDestroySubscriptions, t as forceRemoveFromCaches, a1 as unloadEntity, u as runDestroyLifecycle } from './Item-BiMHgg-_.js';
+import { m as getClient } from './ClientManager-DBKvmJov.js';
 import { modelPropertiesToObject } from './model-oHA3YhOd.js';
 import { localNamesInBestMatchTier } from '@seedprotocol/eas';
 import { Type } from '@sinclair/typebox';
 
-/**
- * Common getters and utilities for entity classes
- * These work with any entity that has a getService() method returning an XState actor
- */
-/**
- * Get the current state value from an entity's service
- */
-/**
- * Whether an actor has been stopped (unload, destroy, or Schema eviction). Async work started by an
- * entity (DB lookups, retry timers) must check this before sending, since a stopped actor ignores
- * events and XState warns about every one of them.
- */
-function isActorStopped(actor) {
-    return actor.getSnapshot().status === 'stopped';
-}
-
 const logger$7 = debug('seedSdk:model:actors:loadOrCreateModel');
 /**
  * Create ModelProperty instances for all property IDs to ensure they're cached
@@ -35,7 +19,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await import('./ModelProperty-B52C3CQ2.js');
+        const mod = await import('./ModelProperty-C1Fzcnbm.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$7('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -101,11 +85,11 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context }, self })
                 if (!modelRecord) {
                     // Model names are only unique per schema: prefer this schema's row, and otherwise only
                     // consider same-name rows that no schema claims yet (never another schema's model).
-                    const _mod_0 = await import('./index-DpgQMIRq.js');
-                    const _ns_0 = _mod_0.bg;
+                    const _mod_0 = await import('./index-C-NqjjY_.js');
+                    const _ns_0 = _mod_0.bh;
                     const { modelSchemas } = _ns_0;
-                    const _mod_1 = await import('./index-DpgQMIRq.js');
-                    const _ns_1 = _mod_1.bf;
+                    const _mod_1 = await import('./index-C-NqjjY_.js');
+                    const _ns_1 = _mod_1.bg;
                     const { schemas: schemasTable } = _ns_1;
                     let dbModels = await db
                         .select({
@@ -252,14 +236,14 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context }, self })
         // Step 2: Fallback to Schema context (only if database doesn't have the model)
         // This handles the case where model exists in schema file but not yet in database
         try {
-            const _mod_2 = await import('./Schema-O1QLoXv6.js');
+            const _mod_2 = await import('./Schema-COTbavcm.js');
             const _ns_2 = _mod_2.b;
             const schemaMod = _ns_2;
             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 });
+            const schema = Schema.create(schemaName, { waitForReady: false, hold: false });
             const schemaSnapshot = schema.getService().getSnapshot();
             // Wait for schema to load if it's still loading
             // Check if state is a loading state object (XState v5 nested states)
@@ -403,12 +387,12 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context }, self })
                     }
                     // Also check database for models (in case they're persisted but not in Schema context)
                     if (db) {
-                        const _mod_3 = await import('./index-DpgQMIRq.js');
-                        const _ns_3 = _mod_3.bg;
+                        const _mod_3 = await import('./index-C-NqjjY_.js');
+                        const _ns_3 = _mod_3.bh;
                         const modelSchemaSchemaMod = _ns_3;
                         const { modelSchemas } = modelSchemaSchemaMod;
-                        const _mod_4 = await import('./index-DpgQMIRq.js');
-                        const _ns_4 = _mod_4.bf;
+                        const _mod_4 = await import('./index-C-NqjjY_.js');
+                        const _ns_4 = _mod_4.bg;
                         const schemaSchemaMod = _ns_4;
                         const { schemas: schemasTable } = schemaSchemaMod;
                         // Query all models for this schema to check for duplicates (case-insensitive)
@@ -503,12 +487,12 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context }, self })
         }
         // Mark schema as draft when a new model is created so saveNewVersion() can persist it
         try {
-            const _mod_5 = await import('./Schema-O1QLoXv6.js');
+            const _mod_5 = await import('./Schema-COTbavcm.js');
             const _ns_5 = _mod_5.b;
             const schemaMod = _ns_5;
             const { Schema } = schemaMod;
             if (!isActorStopped(self)) {
-                const schema = Schema.create(schemaName, { waitForReady: false });
+                const schema = Schema.create(schemaName, { waitForReady: false, hold: false });
                 schema.getService().send({ type: 'markAsDraft', propertyKey: 'schema:models' });
             }
         }
@@ -551,10 +535,10 @@ const validateModel = fromCallback(({ sendBack, input: { context }, self }) => {
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await import('./SchemaValidationService-BxCbfDaI.js');
+            const validationServiceMod = await import('./SchemaValidationService-paOfbcwd.js');
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const _mod_6 = await import('./Schema-O1QLoXv6.js');
+            const _mod_6 = await import('./Schema-COTbavcm.js');
             const _ns_6 = _mod_6.b;
             const schemaMod = _ns_6;
             const { Schema } = schemaMod;
@@ -576,9 +560,7 @@ const validateModel = fromCallback(({ sendBack, input: { context }, self }) => {
                 return;
             if (context.schemaName) {
                 try {
-                    const schema = Schema.create(context.schemaName, {
-                        waitForReady: false,
-                    });
+                    const schema = Schema.create(context.schemaName, { waitForReady: false, hold: false });
                     const schemaSnapshot = schema.getService().getSnapshot();
                     const schemaStatus = schemaSnapshot.value;
                     // Only validate against schema if it's loaded (in idle state)
@@ -673,7 +655,7 @@ const createModelProperties = fromCallback(({ sendBack, input, self }) => {
             return;
         }
         logger$5(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await import('./ModelProperty-B52C3CQ2.js');
+        const mod = await import('./ModelProperty-C1Fzcnbm.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$5('ModelProperty not available from dynamic import');
@@ -698,8 +680,8 @@ const createModelProperties = fromCallback(({ sendBack, input, self }) => {
                 : undefined;
             // Otherwise use provided ID or generate a random one
             // IDs should be generated in the import process before creating properties
-            const _mod_7 = await import('./index-DpgQMIRq.js');
-            const _ns_7 = _mod_7.bk;
+            const _mod_7 = await import('./index-C-NqjjY_.js');
+            const _ns_7 = _mod_7.bl;
             const { generateId } = _ns_7;
             const propertyFileId = propData.id || propertyRecord?.schemaFileId || generateId();
             logger$5(`Creating property "${propName}" with fileId "${propertyFileId}"`);
@@ -716,8 +698,8 @@ const createModelProperties = fromCallback(({ sendBack, input, self }) => {
                     }
                     else if (refModelName) {
                         // Fallback: resolve the ref by name within this model's schema
-                        const _mod_8 = await import('./index-DpgQMIRq.js');
-                        const _ns_8 = _mod_8.bh;
+                        const _mod_8 = await import('./index-C-NqjjY_.js');
+                        const _ns_8 = _mod_8.bi;
                         const { resolveModelRecord } = _ns_8;
                         const refModelRecord = await resolveModelRecord(refModelName, { schemaName }, db);
                         if (refModelRecord?.id) {
@@ -887,13 +869,13 @@ const validateEntity = fromPromise(async ({ input }) => {
     const evictionEpoch = currentEvictionEpoch();
     /** The schema to validate against; throws (validation then skips the schema check) once it was evicted. */
     const schemaForValidation = async (schemaName) => {
-        const _mod_9 = await import('./Schema-O1QLoXv6.js');
+        const _mod_9 = await import('./Schema-COTbavcm.js');
         const _ns_9 = _mod_9.b;
         const { Schema } = _ns_9;
         if (schemaEvictedSince(schemaName, evictionEpoch)) {
             throw new Error(`Schema "${schemaName}" was evicted during validation`);
         }
-        return Schema.create(schemaName, { waitForReady: false });
+        return Schema.create(schemaName, { waitForReady: false, hold: false });
     };
     const _validate = async () => {
         try {
@@ -905,7 +887,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                 const structureMsg = `[validateEntity] Validating model structure`;
                 logger$4(structureMsg);
                 // Use existing Model validation
-                const validationServiceMod = await import('./SchemaValidationService-BxCbfDaI.js');
+                const validationServiceMod = await import('./SchemaValidationService-paOfbcwd.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
@@ -955,7 +937,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const validationServiceMod = await import('./SchemaValidationService-BxCbfDaI.js');
+                const validationServiceMod = await import('./SchemaValidationService-paOfbcwd.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -995,7 +977,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'schema') {
                 // Schema validation - use existing validation
-                const validationServiceMod = await import('./SchemaValidationService-BxCbfDaI.js');
+                const validationServiceMod = await import('./SchemaValidationService-paOfbcwd.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
@@ -1083,7 +1065,7 @@ const writeToDatabase = fromCallback(({ sendBack, input }) => {
                 // initial write completes is not overwritten by the stale requestWrite payload.
                 let dataToWrite = input.entityData;
                 try {
-                    const mod = await import('./ModelProperty-B52C3CQ2.js');
+                    const mod = await import('./ModelProperty-C1Fzcnbm.js');
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -1477,7 +1459,7 @@ const modelMachine = setup({
                                 // Create ModelProperty instances for any new property IDs
                                 if (Array.isArray(newPropertyIds) && newPropertyIds.length > 0) {
                                     // Import and create instances asynchronously (fire-and-forget)
-                                    import('./ModelProperty-B52C3CQ2.js').then(({ ModelProperty }) => {
+                                    import('./ModelProperty-C1Fzcnbm.js').then(({ ModelProperty }) => {
                                         if (self.getSnapshot().status === 'stopped')
                                             return;
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
@@ -1828,6 +1810,9 @@ function setupEntityLiveQuery(instance, config) {
                     logger('Instance state not found');
                     return;
                 }
+                // Unloaded or destroyed while setup awaited: subscribing now would leak the query.
+                if (isActorStopped(instance.getService()))
+                    return;
                 // Subscribe to liveQuery updates
                 const subscription = query$.subscribe({
                     next: async (rows) => {
@@ -2011,7 +1996,7 @@ const saveDraftLogger = debug('seedSdk:model:saveDraftToDb');
 // Lazy import cache for ModelProperty to avoid circular dependency
 // Eagerly start loading to minimize delay on first access
 let ModelPropertyClass = null;
-const modelPropertyImportPromise = import('./ModelProperty-B52C3CQ2.js')
+const modelPropertyImportPromise = import('./ModelProperty-C1Fzcnbm.js')
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -2026,9 +2011,8 @@ function getModelProperty() {
     // and the getter will return empty array, which matches the original behavior
     return ModelPropertyClass;
 }
-// WeakMap to store mutable state per Model instance
-// This avoids issues with read-only properties when instances are frozen by Immer
-const modelInstanceState = new WeakMap();
+// Mutable state per Model instance
+const modelInstanceState = new ActorKeyedState();
 // Settles once the properties passed to Model.create exist, or rejects when they can't be created.
 // The model reaches idle before its write, so idle alone doesn't mean they exist yet. Keyed by the
 // actor because callers hold the proxy, not the instance.
@@ -2228,6 +2212,7 @@ class Model {
         }
         const waitForReady = options?.waitForReady !== false;
         const readyTimeout = options?.readyTimeout ?? DEFAULT_READY_TIMEOUT_MS;
+        const holds = options?.hold === false ? 0 : 1;
         // Extract schema name and instance
         let schemaName;
         let schemaInstance; // Using any to avoid circular dependency with Schema
@@ -2245,12 +2230,10 @@ class Model {
         const id = options?.modelFileId || options?.id; // schemaFileId (string) - public ID
         const registerWithSchema = options?.registerWithSchema !== false && schemaInstance !== undefined;
         // Step 1: Check ID-based cache first (if ID provided)
-        if (id && this.instanceCacheById.has(id)) {
-            const { instance, refCount } = this.instanceCacheById.get(id);
-            this.instanceCacheById.set(id, {
-                instance,
-                refCount: refCount + 1,
-            });
+        const cachedById = id ? this.instanceCacheById.get(id) : undefined;
+        if (cachedById) {
+            cachedById.refCount += holds;
+            const { instance } = cachedById;
             logger(`Model.create: Found instance in ID cache for "${modelName}" (ID: ${id})`);
             if (!waitForReady)
                 return instance;
@@ -2284,18 +2267,16 @@ class Model {
         // create('My Model') calls get new instances with incremented names.
         if (id && uniqueModelName === modelName) {
             const legacyKey = `${schemaName}:${modelName}`;
-            if (this.instanceCache.has(legacyKey)) {
-                const { instance, refCount } = this.instanceCache.get(legacyKey);
+            const legacyEntry = this.instanceCache.get(legacyKey);
+            if (legacyEntry) {
+                const { instance } = legacyEntry;
                 const ctx = instance._getSnapshotContext();
                 if (!ctx._idFromSchema && !this.isOtherModelId(ctx.id, id)) {
-                    this.instanceCache.set(legacyKey, {
-                        instance,
-                        refCount: refCount + 1,
-                    });
+                    legacyEntry.refCount += holds;
                     logger(`Model.create: Found instance in legacy cache for "${modelName}"`);
                     const existingId = instance._getSnapshotContext().id;
                     if (existingId) {
-                        this.instanceCacheById.set(existingId, { instance, refCount: refCount + 1 });
+                        this.instanceCacheById.set(existingId, legacyEntry);
                         this.instanceCacheByName.set(legacyKey, existingId);
                     }
                     if (!waitForReady)
@@ -2325,17 +2306,15 @@ class Model {
         // This is a fallback in case an instance was cached with a unique name
         if (this.instanceCache.has(nameKey) &&
             !this.isOtherModelId(this.instanceCache.get(nameKey).instance._getSnapshotContext().id, id)) {
-            const { instance, refCount } = this.instanceCache.get(nameKey);
-            this.instanceCache.set(nameKey, {
-                instance,
-                refCount: refCount + 1,
-            });
+            const legacyEntry = this.instanceCache.get(nameKey);
+            legacyEntry.refCount += holds;
+            const { instance } = legacyEntry;
             logger(`Model.create: Found instance in legacy cache for "${modelName}"`);
             // Migrate to new cache structure
             const context = instance._getSnapshotContext();
             const existingId = context.id; // id is now the schemaFileId (string)
             if (existingId) {
-                this.instanceCacheById.set(existingId, { instance, refCount: refCount + 1 });
+                this.instanceCacheById.set(existingId, legacyEntry);
                 this.instanceCacheByName.set(nameKey, existingId);
             }
             if (!waitForReady)
@@ -2398,168 +2377,88 @@ class Model {
                 });
             }
         }
-        // Wrap instance in Proxy for reactive property access
-        // Create a custom proxy that handles 'name' as an alias for 'modelName'
-        const proxiedInstance = new Proxy(newInstance, {
-            get(target, prop) {
-                // Handle special properties
-                if (prop === '_service') {
-                    return Reflect.get(target, prop);
-                }
-                // Handle 'name' as an alias for 'modelName'
-                if (prop === 'name') {
-                    const context = target._getSnapshotContext();
-                    return context.modelName;
-                }
-                // Handle 'id' property - returns the schemaFileId (string)
-                if (prop === 'id') {
-                    const context = target._getSnapshotContext();
-                    return context.id; // id is now the schemaFileId (string)
-                }
-                // Handle tracked properties
-                if (typeof prop === 'string' && TRACKED_PROPERTIES.includes(prop)) {
-                    const context = target._getSnapshotContext();
-                    return context[prop];
-                }
-                // Handle 'properties' getter - not tracked, but accessible via getter
-                if (typeof prop === 'string' && prop === 'properties') {
-                    // Delegate to the getter method on the instance
-                    return target.properties;
-                }
-                // For methods and other properties, use Reflect
-                return Reflect.get(target, prop);
-            },
-            set(target, prop, value) {
-                // Handle special properties
-                if (prop === '_service') {
-                    return Reflect.set(target, prop, value);
+        // Wrap instance in Proxy for reactive property access. `name` is an alias for `modelName`.
+        const sendUpdate = (target, prop, value) => {
+            if (prop === 'modelName') {
+                // Model name change - need to update Schema and database
+                const context = target._getSnapshotContext();
+                const oldName = context.modelName;
+                const newName = value;
+                if (oldName === newName) {
+                    logger(`Model name unchanged: "${oldName}"`);
+                    return;
                 }
-                // Handle 'name' as an alias for 'modelName'
-                if (prop === 'name') {
-                    prop = 'modelName';
+                logger(`Updating model name from "${oldName}" to "${newName}"`);
+                // Update Model instance cache using new ID-based structure
+                const modelFileId = context.id; // id is now the schemaFileId (string)
+                if (modelFileId) {
+                    Model.updateNameIndex(oldName, newName, context.schemaName, modelFileId);
                 }
-                // Handle tracked properties
-                if (typeof prop === 'string' && TRACKED_PROPERTIES.includes(prop)) {
-                    // Use the sendUpdate logic
-                    if (prop === 'modelName') {
-                        // Model name change - need to update Schema and database
-                        const context = target._getSnapshotContext();
-                        const oldName = context.modelName;
-                        const newName = value;
-                        if (oldName === newName) {
-                            logger(`Model name unchanged: "${oldName}"`);
-                            return true;
-                        }
-                        logger(`Updating model name from "${oldName}" to "${newName}"`);
-                        // Update Model instance cache using new ID-based structure
-                        const modelFileId = context.id; // id is now the schemaFileId (string)
-                        if (modelFileId) {
-                            Model.updateNameIndex(oldName, newName, context.schemaName, modelFileId);
-                        }
-                        else {
-                            // Fallback to legacy cache if no ID (shouldn't happen, but safety)
-                            const oldCacheKey = `${context.schemaName}:${oldName}`;
-                            const newCacheKey = `${context.schemaName}:${newName}`;
-                            if (Model.instanceCache.has(oldCacheKey)) {
-                                const entry = Model.instanceCache.get(oldCacheKey);
-                                Model.instanceCache.delete(oldCacheKey);
-                                Model.instanceCache.set(newCacheKey, entry);
-                            }
-                        }
-                        // Update Model context
-                        target._service.send({
-                            type: 'updateContext',
-                            modelName: newName,
-                        });
-                        // Mark model as draft
-                        target._service.send({
-                            type: 'markAsDraft',
-                            propertyKey: 'modelName',
-                        });
-                        // Save draft to database immediately so changes persist
-                        trackDraftSave(target._service, target._saveDraftToDb(oldName, newName), `Model "${newName}"`);
-                        // NOTE: Schema is not notified of model name changes during edits.
-                        // Schema will read from Model instances when persisting/saving.
-                    }
-                    else if (prop === 'properties') {
-                        // Properties are read-only computed values from ModelProperty instances
-                        // Cannot be set directly - properties are managed via ModelProperty instances
-                        throw new Error('Cannot set model.properties directly. Properties are computed from ModelProperty instances.');
-                    }
-                    else if (prop === 'description') {
-                        // Description is not supported - JSON files can have it but we ignore it at runtime
-                        throw new Error('Cannot set model.description. Description is not supported in runtime Model instances.');
-                    }
-                    else {
-                        // Standard property update
-                        target._service.send({
-                            type: 'updateContext',
-                            [prop]: value,
-                        });
+                else {
+                    // Fallback to legacy cache if no ID (shouldn't happen, but safety)
+                    const oldCacheKey = `${context.schemaName}:${oldName}`;
+                    const newCacheKey = `${context.schemaName}:${newName}`;
+                    if (Model.instanceCache.has(oldCacheKey)) {
+                        const entry = Model.instanceCache.get(oldCacheKey);
+                        Model.instanceCache.delete(oldCacheKey);
+                        Model.instanceCache.set(newCacheKey, entry);
                     }
-                    return true;
                 }
-                // For non-tracked properties, use Reflect
-                return Reflect.set(target, prop, value);
-            },
-            has(target, prop) {
-                // Handle 'name' as an alias for 'modelName'
+                // Update Model context
+                target._service.send({
+                    type: 'updateContext',
+                    modelName: newName,
+                });
+                // Mark model as draft
+                target._service.send({
+                    type: 'markAsDraft',
+                    propertyKey: 'modelName',
+                });
+                // Save draft to database immediately so changes persist
+                trackDraftSave(target._service, target._saveDraftToDb(oldName, newName), `Model "${newName}"`);
+                // NOTE: Schema is not notified of model name changes during edits.
+                // Schema will read from Model instances when persisting/saving.
+            }
+            else {
+                // Standard property update
+                target._service.send({
+                    type: 'updateContext',
+                    [prop]: value,
+                });
+            }
+        };
+        const proxiedInstance = createReactiveProxy({
+            instance: newInstance,
+            service: newInstance._service,
+            trackedProperties: TRACKED_PROPERTIES,
+            getContext: (target) => target._getSnapshotContext(),
+            sendUpdate,
+            resolve: (target, prop) => {
                 if (prop === 'name') {
-                    return true;
-                }
-                // Handle 'id' property
-                if (prop === 'id') {
-                    return true;
-                }
-                // Check tracked properties
-                if (typeof prop === 'string' && TRACKED_PROPERTIES.includes(prop)) {
-                    const context = target._getSnapshotContext();
-                    return prop in context;
+                    return {
+                        get: () => target._getSnapshotContext().modelName,
+                        set: (value) => sendUpdate(target, 'modelName', value),
+                    };
                 }
-                return Reflect.has(target, prop);
+                return undefined;
             },
-            ownKeys(target) {
-                // Include 'name' and 'id' in ownKeys
-                const keys = Reflect.ownKeys(target);
-                const additionalKeys = [];
-                if (!keys.includes('name')) {
-                    additionalKeys.push('name');
+            virtualKeys: () => ['name'],
+            onSet: (_target, prop) => {
+                if (prop === 'properties') {
+                    // Properties are read-only computed values from ModelProperty instances
+                    throw new Error('Cannot set model.properties directly. Properties are computed from ModelProperty instances.');
                 }
-                if (!keys.includes('id')) {
-                    additionalKeys.push('id');
+                if (prop === 'description') {
+                    // Description is not supported - JSON files can have it but we ignore it at runtime
+                    throw new Error('Cannot set model.description. Description is not supported in runtime Model instances.');
                 }
-                return additionalKeys.length > 0 ? [...keys, ...additionalKeys] : keys;
-            },
-            getOwnPropertyDescriptor(target, prop) {
-                // Handle 'name' as an alias for 'modelName'
-                if (prop === 'name') {
-                    return getInvariantSafePropertyDescriptor(target, prop, {
-                        value: target._getSnapshotContext().modelName,
-                    });
-                }
-                // Handle 'id' property - returns the modelFileId
-                if (prop === 'id') {
-                    return getInvariantSafePropertyDescriptor(target, prop, {
-                        value: target._getSnapshotContext().id, // id is now the schemaFileId (string)
-                        writable: false, // id is read-only
-                    });
-                }
-                let invent;
-                if (typeof prop === 'string' && TRACKED_PROPERTIES.includes(prop)) {
-                    const context = target._getSnapshotContext();
-                    if (prop in context) {
-                        invent = { value: context[prop] };
-                    }
-                }
-                return getInvariantSafePropertyDescriptor(target, prop, invent);
             },
         });
         // Step 8: Store in new ID-based cache
-        // resolvedId is guaranteed to be defined at this point (generated if not provided)
-        this.instanceCacheById.set(resolvedId, {
-            instance: proxiedInstance,
-            refCount: 1,
-        });
+        // resolvedId is guaranteed to be defined at this point (generated if not provided).
+        // The ID and legacy caches share one entry: one hold count for the instance.
+        const entry = { instance: proxiedInstance, refCount: holds };
+        this.instanceCacheById.set(resolvedId, entry);
         // Step 9: Store in name-based index (placeholder key when !id; loadOrCreateModel will replace with final name)
         this.instanceCacheByName.set(nameKey, resolvedId);
         // Step 9b: When created with id (schema model) and unique name, also register original name so create(modelName) returns same instance
@@ -2567,10 +2466,7 @@ class Model {
             this.instanceCacheByName.set(originalNameKey, resolvedId);
         }
         // Step 10: Also store in legacy cache (for backward compatibility during migration)
-        this.instanceCache.set(nameKey, {
-            instance: proxiedInstance,
-            refCount: 1,
-        });
+        this.instanceCache.set(nameKey, entry);
         logger(`Model.create: Created new instance for "${uniqueModelName}" (ID: ${id})`);
         // Model instance is now cached and accessible via Model.getById() and Model.getByName()
         // No wrapper or store registration needed
@@ -2851,42 +2747,80 @@ class Model {
         return this.waitUntilReady(proxiedInstance, readyTimeout);
     }
     /**
-     * Get Model instance by modelFileId (O(1) lookup)
+     * Get Model instance by modelFileId (O(1) lookup). Takes a hold on the instance; release it with
+     * `unload()`.
      */
     static getById(modelFileId) {
         const entry = this.instanceCacheById.get(modelFileId);
-        if (entry) {
-            // Increment ref count
-            this.instanceCacheById.set(modelFileId, {
-                instance: entry.instance,
-                refCount: entry.refCount + 1,
-            });
-            return entry.instance;
+        if (!entry)
+            return undefined;
+        entry.refCount += 1;
+        return entry.instance;
+    }
+    /**
+     * @internal For a Schema loading its models: true when this load should take the schema's hold
+     * on the model (pass no `hold` option), false when the schema already holds it (pass
+     * `hold: false`). After a true, call `dropSchemaHold` if the load returns no model.
+     */
+    static takeSchemaHold(modelFileId) {
+        if (!modelFileId || this.schemaHeldModelIds.has(modelFileId))
+            return false;
+        this.schemaHeldModelIds.add(modelFileId);
+        return true;
+    }
+    /** @internal The load `takeSchemaHold` approved found no model: there is no hold to release. */
+    static dropSchemaHold(modelFileId) {
+        this.schemaHeldModelIds.delete(modelFileId);
+    }
+    /** @internal A Schema's last unload: releases its hold on each of its models. */
+    static releaseSchemaHolds(schemaName) {
+        for (const modelFileId of [...this.schemaHeldModelIds]) {
+            const model = this.peek(modelFileId);
+            if (!model) {
+                this.schemaHeldModelIds.delete(modelFileId);
+                continue;
+            }
+            if (model._getSnapshotContext().schemaName !== schemaName)
+                continue;
+            this.schemaHeldModelIds.delete(modelFileId);
+            model.unload();
         }
-        return undefined;
     }
     /**
-     * Get Model instance by name (O(1) lookup via name→ID mapping)
+     * The cached Model with this modelFileId, without taking a hold. For SDK code that reads the
+     * model and doesn't hand it to a caller; callers that keep it use `getById`, `find` or `create`.
+     */
+    static peek(modelFileId) {
+        return this.instanceCacheById.get(modelFileId)?.instance;
+    }
+    /**
+     * Get Model instance by name (O(1) lookup via name→ID mapping). Takes a hold on the instance;
+     * release it with `unload()`.
      *
      * @param modelName - The name of the model
      * @param schemaName - The schema name (optional, will query DB if not provided)
      * @returns The Model instance if found, undefined otherwise
      */
     static getByName(modelName, schemaName) {
+        const model = this.peekByName(modelName, schemaName);
+        return model?.id ? this.getById(model.id) : undefined;
+    }
+    /**
+     * `getByName` without taking a hold. Without `schemaName` it searches every cached schema and
+     * throws AmbiguousModelError when models from several schemas share the name; callers that know
+     * the schema or model id should use Model.resolve() instead.
+     */
+    static peekByName(modelName, schemaName) {
         if (schemaName) {
-            const nameKey = `${schemaName}:${modelName}`;
-            const id = this.instanceCacheByName.get(nameKey);
-            if (!id) {
-                return undefined;
-            }
-            return this.getById(id);
+            const id = this.instanceCacheByName.get(`${schemaName}:${modelName}`);
+            return id ? this.peek(id) : undefined;
         }
-        // If schemaName not provided, search all name keys. Model names are only unique per schema, so
-        // this throws AmbiguousModelError when cached models from several schemas share the name.
-        // Callers that know the schema or model id should use Model.resolve() instead.
         return this._getUniqueCachedModel(modelName, (cachedModelName) => cachedModelName === modelName);
     }
-    /** The one cached Model whose name matches, or AmbiguousModelError if models from several schemas do. */
+    /**
+     * The one cached Model whose name matches (no hold taken), or AmbiguousModelError if models from
+     * several schemas do.
+     */
     static _getUniqueCachedModel(label, matches) {
         const matchesById = new Map(); // modelFileId -> schemaName
         for (const [nameKey, id] of this.instanceCacheByName.entries()) {
@@ -2900,32 +2834,32 @@ class Model {
             throw new AmbiguousModelError(label, [...matchesById.values()]);
         }
         const [matchId] = matchesById.keys();
-        return matchId ? this.getById(matchId) : undefined;
+        return matchId ? this.peek(matchId) : undefined;
     }
     /**
      * Resolve a cached Model from the most specific scope available: modelFileId (Model.id), then
-     * schemaName + modelName, then modelName alone.
+     * schemaName + modelName, then modelName alone. Takes no hold.
      */
     static resolve(modelName, scope = {}) {
         if (scope.modelFileId) {
-            const byId = this.getById(scope.modelFileId);
+            const byId = this.peek(scope.modelFileId);
             if (byId)
                 return byId;
         }
         if (!modelName)
             return undefined;
         if (scope.schemaName) {
-            const bySchema = this.getByName(modelName, scope.schemaName);
+            const bySchema = this.peekByName(modelName, scope.schemaName);
             if (bySchema)
                 return bySchema;
         }
-        return this.getByName(modelName);
+        return this.peekByName(modelName);
     }
     /**
      * Find Model by modelType (an EAS model name, as seeds.type stores it). Matched as ADR 0008
      * matches EAS names: `new_model` finds "New model", and `htmlpage` (an older SDK's name) finds
      * "HTMLPage", unless HTMLPage's nameMatch (ADR 0009) is `exact`. Only the tightest matching tier
-     * counts; matches in several schemas are ambiguous.
+     * counts; matches in several schemas are ambiguous. Takes no hold.
      */
     static findByModelType(modelType) {
         if (!modelType)
@@ -2937,7 +2871,7 @@ class Model {
         return this._getUniqueCachedModel(modelType, (cachedModelName) => best.has(cachedModelName));
     }
     /**
-     * Get all Model instances for a schema from cache only (synchronous).
+     * Get all Model instances for a schema from cache only (synchronous). Takes no holds.
      * Includes models created at runtime via Model.create() that may not yet be in schema context.
      */
     static getCachedInstancesForSchema(schemaName) {
@@ -2946,7 +2880,7 @@ class Model {
         for (const [nameKey, id] of this.instanceCacheByName.entries()) {
             const [cachedSchemaName] = nameKey.split(':');
             if (cachedSchemaName === schemaName && id && !seen.has(id)) {
-                const instance = this.getById(id);
+                const instance = this.peek(id);
                 if (instance) {
                     instances.push(instance);
                     seen.add(id);
@@ -2968,16 +2902,16 @@ class Model {
     }
     /**
      * Async Model.resolve(): exact cache hit by modelFileId or schemaName+modelName, else the DB row for
-     * that scope (instantiating the Model), and only then the name-only fallback.
+     * that scope (instantiating the Model), and only then the name-only fallback. Takes no hold.
      */
     static async resolveAsync(modelName, scope = {}) {
         if (scope.modelFileId) {
-            const byId = this.getById(scope.modelFileId);
+            const byId = this.peek(scope.modelFileId);
             if (byId)
                 return byId;
         }
         if (modelName && scope.schemaName) {
-            const bySchema = this.getByName(modelName, scope.schemaName);
+            const bySchema = this.peekByName(modelName, scope.schemaName);
             if (bySchema)
                 return bySchema;
         }
@@ -3006,7 +2940,7 @@ class Model {
                             return undefined;
                         if (modelDestroyedSince(record.modelFileId, evictionEpoch))
                             return undefined;
-                        return this.create(record.modelName, record.schemaName, { id: record.modelFileId });
+                        return this.create(record.modelName, record.schemaName, { id: record.modelFileId, hold: false });
                     }
                 }
                 catch (error) {
@@ -3014,7 +2948,7 @@ class Model {
                 }
             }
         }
-        return modelName ? this.getByNameAsync(modelName) : undefined;
+        return modelName ? this.getByNameAsync(modelName, undefined, { hold: false }) : undefined;
     }
     /**
      * Get Model instance by name, querying database if not in cache
@@ -3022,11 +2956,11 @@ class Model {
      *
      * @param modelName - The name of the model
      * @param schemaName - Optional schema name (will query DB if not provided)
-     * @returns The Model instance if found, undefined otherwise
+     * @returns The Model instance if found, undefined otherwise. Takes a hold unless `hold: false`.
      */
     static async getByNameAsync(modelName, schemaName, options) {
         // First try cache
-        const cached = this.getByName(modelName, schemaName);
+        const cached = options?.hold === false ? this.peekByName(modelName, schemaName) : this.getByName(modelName, schemaName);
         if (cached) {
             return cached;
         }
@@ -3039,8 +2973,8 @@ class Model {
             const evictionEpoch = options?.evictionEpoch ?? currentEvictionEpoch();
             try {
                 // Query model by name (throws AmbiguousModelError when several schemas define it)
-                const _mod_10 = await import('./index-DpgQMIRq.js');
-                const _ns_10 = _mod_10.bh;
+                const _mod_10 = await import('./index-C-NqjjY_.js');
+                const _ns_10 = _mod_10.bi;
                 const { resolveModelRecord } = _ns_10;
                 const resolved = await resolveModelRecord(modelName, {}, db);
                 if (!resolved?.schemaFileId) {
@@ -3074,6 +3008,7 @@ class Model {
                 // Create model instance (will be cached)
                 return this.create(record.modelName, record.schemaName, {
                     id: record.modelFileId, // id is now the schemaFileId (string)
+                    ...(options?.hold === false && { hold: false }),
                 });
             }
             catch (error) {
@@ -3097,7 +3032,7 @@ class Model {
             return undefined;
         }
         // Step 1: Check cache first (fast path)
-        const cached = this.getById(modelFileId);
+        const cached = options?.hold === false ? this.peek(modelFileId) : this.getById(modelFileId);
         if (cached) {
             logger(`Model.createById: Found instance in cache for ID "${modelFileId}"`);
             return cached;
@@ -3146,6 +3081,7 @@ class Model {
             logger(`Model.createById: Creating model "${modelName}" in schema "${schemaName}" from ID "${modelFileId}"`);
             return this.create(modelName, schemaName, {
                 id: modelFileId, // id is now the schemaFileId (string)
+                ...(options?.hold === false && { hold: false }),
             });
         }
         catch (error) {
@@ -3252,7 +3188,8 @@ class Model {
      * Get all Model instances, optionally filtered by schema.
      * When DB is available, loads from DB via getModelsData; otherwise returns from cache.
      * With waitForReady, waits for each model to be ready (idle, with any properties from Model.create
-     * created) and leaves out models that error or time out.
+     * created) and leaves out models that error or time out. Takes no holds: a caller that keeps a
+     * model uses `Model.find` or `Model.create`.
      */
     static async all(schemaName, options) {
         const { waitForReady = false, readyTimeout = DEFAULT_READY_TIMEOUT_MS } = options ?? {};
@@ -3264,7 +3201,7 @@ class Model {
                 for (const [nameKey, id] of this.instanceCacheByName.entries()) {
                     const [cachedSchemaName] = nameKey.split(':');
                     if (cachedSchemaName === schemaName) {
-                        const instance = this.getById(id);
+                        const instance = this.peek(id);
                         if (instance && !seen.has(id)) {
                             instances.push(instance);
                             seen.add(id);
@@ -3307,7 +3244,7 @@ class Model {
         for (const row of rows) {
             // A model can appear more than once (e.g. duplicate model_schemas links); return it once.
             if (row.schemaFileId && !seen.has(row.schemaFileId)) {
-                const instance = await this.createById(row.schemaFileId);
+                const instance = await this.createById(row.schemaFileId, { hold: false });
                 if (instance && !seen.has(instance.id ?? row.schemaFileId)) {
                     instances.push(instance);
                     seen.add(instance.id ?? row.schemaFileId);
@@ -3319,7 +3256,7 @@ class Model {
             for (const [nameKey, id] of this.instanceCacheByName.entries()) {
                 const [cachedSchemaName] = nameKey.split(':');
                 if (cachedSchemaName === schemaName && id && !seen.has(id)) {
-                    const instance = this.getById(id);
+                    const instance = this.peek(id);
                     if (instance) {
                         instances.push(instance);
                         seen.add(id);
@@ -3699,6 +3636,8 @@ class Model {
             if (context.schemaName !== schemaName)
                 continue;
             const nameKey = `${context.schemaName}:${context.modelName}`;
+            if (context.id)
+                this.schemaHeldModelIds.delete(context.id);
             clearDestroySubscriptions(instance, { instanceState: modelInstanceState });
             forceRemoveFromCaches(instance, {
                 getCacheKeys: () => (context.id ? [context.id, nameKey] : [nameKey]),
@@ -3765,6 +3704,8 @@ class Model {
         // Before the caches are cleared, so a lookup by id already reading the row doesn't re-cache it
         if (modelFileId)
             recordModelDestroy(modelFileId);
+        if (modelFileId)
+            Model.schemaHeldModelIds.delete(modelFileId);
         const cacheKeys = [];
         if (modelFileId)
             cacheKeys.push(modelFileId);
@@ -3792,7 +3733,7 @@ class Model {
                         .limit(1);
                     if (modelRecords.length > 0) {
                         const modelId = modelRecords[0].id;
-                        const { detachModelRows } = await import('./detachRowsBeforeDelete-D1TyEMco.js');
+                        const { detachModelRows } = await import('./detachRowsBeforeDelete-C1iapUFl.js');
                         await detachModelRows(db, [typeof modelId === 'string' ? parseInt(modelId, 10) : modelId]);
                         await db.delete(modelSchemas).where(eq(modelSchemas.modelId, modelId));
                         await db
@@ -3803,10 +3744,10 @@ class Model {
                 }
                 if (schemaName && modelName) {
                     // Imported here, not at module load: Model and Schema import each other.
-                    const _mod_11 = await import('./Schema-O1QLoXv6.js');
+                    const _mod_11 = await import('./Schema-COTbavcm.js');
                     const _ns_11 = _mod_11.b;
                     const { Schema } = _ns_11;
-                    const schema = Schema.create(schemaName, { waitForReady: false });
+                    const schema = Schema.create(schemaName, { waitForReady: false, hold: false });
                     const schemaContext = schema.getService().getSnapshot().context;
                     if (schemaContext.models?.[modelName]) {
                         const updatedModels = { ...schemaContext.models };
@@ -3847,8 +3788,8 @@ class Model {
                             return undefined;
                         }
                         // Model names are only unique per schema: find this model's row by its id (schemaFileId).
-                        const _mod_12 = await import('./index-DpgQMIRq.js');
-                        const _ns_12 = _mod_12.bh;
+                        const _mod_12 = await import('./index-C-NqjjY_.js');
+                        const _ns_12 = _mod_12.bi;
                         const { resolveModelRecord } = _ns_12;
                         const modelRecord = await resolveModelRecord(modelName, { modelFileId: context.id, schemaName: context.schemaName }, db);
                         if (!modelRecord?.id) {
@@ -4048,6 +3989,12 @@ Model.savingModels = new Set();
 Model.cachedClientInitialized = null;
 Model.clientCheckTime = 0;
 Model.CLIENT_CHECK_CACHE_MS = 50; // Cache for 50ms to avoid excessive checks
+/**
+ * Models their schema holds, by modelFileId. A schema's first load of a model takes one hold for
+ * the schema, and the schema's last unload releases it (releaseSchemaHolds), so a user's unload
+ * can't drop a model out of `schema.models` while the schema is loaded.
+ */
+Model.schemaHeldModelIds = new Set();
 
 var Model$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -4107,5 +4054,5 @@ var errors = /*#__PURE__*/Object.freeze({
     UnknownModelError: UnknownModelError
 });
 
-export { ConflictError as C, ItemCreateValidationError as I, Model as M, TModelSchema as T, UnknownModelError as U, TModelValues as a, anyEvictionSince as b, currentEvictionEpoch as c, ItemCreateError as d, setupEntityLiveQuery as e, finishSchemaDestroy as f, getDraftSaveError as g, writeToDatabase$1 as h, isActorStopped as i, Model$1 as j, errors as k, recordSchemaDestroy as r, schemaEvictedSince as s, trackDraftSave as t, writeProcessMachine as w };
-//# sourceMappingURL=errors-KM-yq2MD.js.map
+export { ConflictError as C, ItemCreateValidationError as I, Model as M, TModelSchema as T, UnknownModelError as U, TModelValues as a, anyEvictionSince as b, currentEvictionEpoch as c, ItemCreateError as d, setupEntityLiveQuery as e, finishSchemaDestroy as f, getDraftSaveError as g, writeToDatabase$1 as h, Model$1 as i, errors as j, recordSchemaDestroy as r, schemaEvictedSince as s, trackDraftSave as t, writeProcessMachine as w };
+//# sourceMappingURL=errors-CQagdED2.js.map