@seedprotocol/sdk 0.7.7 → 0.7.8-next.1066.gac32194

package/dist/{Schema-O1QLoXv6.js → Schema-D-TczaIj.js}

@@ -1,13 +1,13 @@
 import { fromCallback, setup, assign, createActor } from 'xstate';
-import { au as SEED_PROTOCOL_SCHEMA_NAME, B as BaseDb, A as schemas, aM as addSchemaToDb, i as isDataType, M as ModelPropertyDataTypes, ai as generateId, N as addModelsToDb, t as models, r as modelSchemas, v as properties, h as BaseFileManager, aP as loadModelsFromDbForSchema, aQ as mergeDbModelsIntoSchemaModels, aJ as isInternalSchema, aR as clearNameMatchLevels } from './index-DpgQMIRq.js';
-import { g as getRefValueType, J as createRowsWrittenSignal, K as createModelsFromJson, q as listCompleteSchemaFiles, L as getLatestSchemaVersion, l as loadSchemaFromFile, M as jsonPropertiesToSchemaProperties, u as loadAllSchemasFromDb, m as getClient } from './ClientManager-2GtDWHq6.js';
+import { aw as SEED_PROTOCOL_SCHEMA_NAME, F as BaseDb, A as schemas, aO as addSchemaToDb, i as isDataType, M as ModelPropertyDataTypes, ai as generateId, O as addModelsToDb, s as models, q as modelSchemas, v as properties, N as BaseFileManager, aR as loadModelsFromDbForSchema, aS as mergeDbModelsIntoSchemaModels, aL as isInternalSchema, aT as clearNameMatchLevels } from './index-CI0NFf4B.js';
+import { h as getRefValueType, T as createRowsWrittenSignal, U as createModelsFromJson, F as listCompleteSchemaFiles, V as getLatestSchemaVersion, l as loadSchemaFromFile, W as jsonPropertiesToSchemaProperties, G as loadAllSchemasFromDb, z as getClient } from './ClientManager-Dcju5x4k.js';
 import { eq, desc, and } from 'drizzle-orm';
 import debug from 'debug';
-import { c as currentEvictionEpoch, w as writeProcessMachine, t as trackDraftSave, M as Model, g as getDraftSaveError, C as ConflictError, r as recordSchemaDestroy, f as finishSchemaDestroy, e as setupEntityLiveQuery } from './errors-KM-yq2MD.js';
+import { c as currentEvictionEpoch, w as writeProcessMachine, M as Model, g as getDraftSaveError, C as ConflictError, r as recordSchemaDestroy, f as finishSchemaDestroy, e as setupEntityLiveQuery, t as trackDraftSave } from './errors-BGk_IJO5.js';
 import 'pluralize';
 import '@seedprotocol/eas';
-import { SchemaValidationService } from './SchemaValidationService-BxCbfDaI.js';
-import { D as DEFAULT_READY_TIMEOUT_MS, d as waitForEntityIdle, m as createReactiveProxy, n as findEntity, C as ClientManagerState, _ as clearDestroySubscriptions, o as forceRemoveFromCaches, $ as unloadEntity, q as runDestroyLifecycle } from './Item-D6j0IvBP.js';
+import { SchemaValidationService } from './SchemaValidationService-NYTtSCxd.js';
+import { ak as ActorKeyedState, Q as DEFAULT_READY_TIMEOUT_MS, C as waitForEntityIdle, R as createReactiveProxy, T as findEntity, X as ClientManagerState, al as clearDestroySubscriptions, U as forceRemoveFromCaches, am as unloadEntity, V as runDestroyLifecycle } from './Item-DZfNz7xl.js';
 
 const logger$d = debug('seedSdk:schema:actors:loadOrCreateSchema');
 /**
@@ -51,8 +51,8 @@ const createModelInstances$2 = async (modelIds, evictionEpoch) => {
         return;
     }
     try {
-        const _mod_0 = await import('./errors-KM-yq2MD.js');
-        const _ns_0 = _mod_0.j;
+        const _mod_0 = await import('./errors-BGk_IJO5.js');
+        const _ns_0 = _mod_0.i;
         const modelMod = _ns_0;
         const { Model } = modelMod;
         // Create instances for all model IDs in parallel
@@ -60,7 +60,10 @@ const createModelInstances$2 = async (modelIds, evictionEpoch) => {
         const createPromises = modelIds.map(async (modelFileId) => {
             try {
                 // Not if the schema was evicted (Schema.destroy, test cleanup) since this load started
-                const model = await Model.createById(modelFileId, { evictionEpoch });
+                const schemaHold = Model.takeSchemaHold(modelFileId);
+                const model = await Model.createById(modelFileId, { evictionEpoch, ...(!schemaHold && { hold: false }) });
+                if (!model && schemaHold)
+                    Model.dropSchemaHold(modelFileId);
                 if (model) {
                     logger$d(`Created/cached Model instance for modelFileId "${modelFileId}"`);
                 }
@@ -168,8 +171,8 @@ const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
             // For Seed Protocol, always load from internal file, never create new
             logger$d(`Loading internal Seed Protocol schema from SDK`);
             try {
-                const _mod_1 = await import('./ClientManager-2GtDWHq6.js');
-                const _ns_1 = _mod_1.S;
+                const _mod_1 = await import('./ClientManager-Dcju5x4k.js');
+                const _ns_1 = _mod_1.Y;
                 const internalSchema = _ns_1;
                 const schemaFile = internalSchema.default;
                 // Check if it exists in database, if not, add it
@@ -667,8 +670,8 @@ const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
                     // Ensure models are populated (fallback for seed-protocol if missing)
                     if ((!mergedModels || Object.keys(mergedModels).length === 0) && schemaName === 'Seed Protocol') {
                         try {
-                            const _mod_2 = await import('./ClientManager-2GtDWHq6.js');
-                            const _ns_2 = _mod_2.S;
+                            const _mod_2 = await import('./ClientManager-Dcju5x4k.js');
+                            const _ns_2 = _mod_2.Y;
                             const internalSchema = _ns_2;
                             const internalSchemaFile = internalSchema.default;
                             mergedModels = { ...(internalSchemaFile.models || {}) };
@@ -832,8 +835,8 @@ const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
                     // Ensure models are populated (fallback for seed-protocol if missing)
                     if ((!mergedModels || Object.keys(mergedModels).length === 0) && schemaName === 'Seed Protocol') {
                         try {
-                            const _mod_3 = await import('./ClientManager-2GtDWHq6.js');
-                            const _ns_3 = _mod_3.S;
+                            const _mod_3 = await import('./ClientManager-Dcju5x4k.js');
+                            const _ns_3 = _mod_3.Y;
                             const internalSchema = _ns_3;
                             const internalSchemaFile = internalSchema.default;
                             mergedModels = { ...(internalSchemaFile.models || {}) };
@@ -887,8 +890,8 @@ const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
                         // Ensure models are populated (fallback for seed-protocol if missing)
                         if ((!mergedModels || Object.keys(mergedModels).length === 0) && schemaName === 'Seed Protocol') {
                             try {
-                                const _mod_4 = await import('./ClientManager-2GtDWHq6.js');
-                                const _ns_4 = _mod_4.S;
+                                const _mod_4 = await import('./ClientManager-Dcju5x4k.js');
+                                const _ns_4 = _mod_4.Y;
                                 const internalSchema = _ns_4;
                                 const internalSchemaFile = internalSchema.default;
                                 mergedModels = { ...(internalSchemaFile.models || {}) };
@@ -937,8 +940,8 @@ const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
                 // If schemaData is missing, try to load from internal schema file for seed-protocol
                 if (!dbSchema.schemaData && schemaName === 'Seed Protocol') {
                     try {
-                        const _mod_5 = await import('./ClientManager-2GtDWHq6.js');
-                        const _ns_5 = _mod_5.S;
+                        const _mod_5 = await import('./ClientManager-Dcju5x4k.js');
+                        const _ns_5 = _mod_5.Y;
                         const internalSchema = _ns_5;
                         const schemaFile = internalSchema.default;
                         logger$d(`Found seed-protocol schema in internal file (schemaData missing, using internal schema)`);
@@ -1048,8 +1051,8 @@ const loadOrCreateSchema = fromCallback(({ sendBack, input: { context } }) => {
             // Ensure models are populated (fallback for seed-protocol if missing)
             if ((!mergedModels || Object.keys(mergedModels).length === 0) && schemaName === 'Seed Protocol') {
                 try {
-                    const _mod_6 = await import('./ClientManager-2GtDWHq6.js');
-                    const _ns_6 = _mod_6.S;
+                    const _mod_6 = await import('./ClientManager-Dcju5x4k.js');
+                    const _ns_6 = _mod_6.Y;
                     const internalSchema = _ns_6;
                     const internalSchemaFile = internalSchema.default;
                     mergedModels = { ...(internalSchemaFile.models || {}) };
@@ -1375,8 +1378,8 @@ const createModelInstances$1 = async (modelIds, evictionEpoch) => {
         return;
     }
     try {
-        const _mod_7 = await import('./errors-KM-yq2MD.js');
-        const _ns_7 = _mod_7.j;
+        const _mod_7 = await import('./errors-BGk_IJO5.js');
+        const _ns_7 = _mod_7.i;
         const mod = _ns_7;
         const Model = mod?.Model ?? mod?.default;
         if (!Model) {
@@ -1386,7 +1389,10 @@ const createModelInstances$1 = async (modelIds, evictionEpoch) => {
         const createPromises = modelIds.map(async (modelFileId) => {
             try {
                 // Not if the schema was evicted (Schema.destroy, test cleanup) since this check started
-                const model = await Model.createById(modelFileId, { evictionEpoch });
+                const schemaHold = Model.takeSchemaHold(modelFileId);
+                const model = await Model.createById(modelFileId, { evictionEpoch, ...(!schemaHold && { hold: false }) });
+                if (!model && schemaHold)
+                    Model.dropSchemaHold(modelFileId);
                 if (model) {
                     logger$c(`Created/cached Model instance for modelFileId "${modelFileId}"`);
                 }
@@ -1424,8 +1430,8 @@ const checkExistingSchema = fromCallback(({ sendBack, input: { context } }) => {
         if (isInternal && schemaName === SEED_PROTOCOL_SCHEMA_NAME) {
             // For Seed Protocol, check if it exists in database
             try {
-                const _mod_8 = await import('./ClientManager-2GtDWHq6.js');
-                const _ns_8 = _mod_8.S;
+                const _mod_8 = await import('./ClientManager-Dcju5x4k.js');
+                const _ns_8 = _mod_8.Y;
                 const internalSchema = _ns_8;
                 const schemaFile = internalSchema.default;
                 if (db && schemaFile.id) {
@@ -1760,8 +1766,8 @@ const writeSchemaToDb = fromCallback(({ sendBack, input }) => {
             if (isInternal && schemaName === SEED_PROTOCOL_SCHEMA_NAME) {
                 // For Seed Protocol, load from internal file
                 logger$b(`Loading internal Seed Protocol schema from SDK`);
-                const _mod_9 = await import('./ClientManager-2GtDWHq6.js');
-                const _ns_9 = _mod_9.S;
+                const _mod_9 = await import('./ClientManager-Dcju5x4k.js');
+                const _ns_9 = _mod_9.Y;
                 const internalSchema = _ns_9;
                 finalSchema = internalSchema.default;
                 const db = BaseDb.getAppDb();
@@ -2233,8 +2239,8 @@ const createModelInstances = fromCallback(({ sendBack, input }) => {
             return;
         }
         try {
-            const _mod_10 = await import('./errors-KM-yq2MD.js');
-            const _ns_10 = _mod_10.j;
+            const _mod_10 = await import('./errors-BGk_IJO5.js');
+            const _ns_10 = _mod_10.i;
             const modelMod = _ns_10;
             const { Model } = modelMod;
             // Create instances for all model IDs in parallel
@@ -2242,7 +2248,10 @@ const createModelInstances = fromCallback(({ sendBack, input }) => {
             const createPromises = modelIds.map(async (modelFileId) => {
                 try {
                     // Not if the schema was evicted (Schema.destroy, test cleanup) since this started
-                    const model = await Model.createById(modelFileId, { evictionEpoch });
+                    const schemaHold = Model.takeSchemaHold(modelFileId);
+                    const model = await Model.createById(modelFileId, { evictionEpoch, ...(!schemaHold && { hold: false }) });
+                    if (!model && schemaHold)
+                        Model.dropSchemaHold(modelFileId);
                     if (model) {
                         logger$7(`Created/cached Model instance for modelFileId "${modelFileId}"`);
                         return true;
@@ -2322,8 +2331,8 @@ const verifyModelInstancesInCache = fromCallback(({ sendBack, input }) => {
         }
         try {
             const result = await verifyWithRetry$2(async () => {
-                const _mod_11 = await import('./errors-KM-yq2MD.js');
-                const _ns_11 = _mod_11.j;
+                const _mod_11 = await import('./errors-BGk_IJO5.js');
+                const _ns_11 = _mod_11.i;
                 const modelMod = _ns_11;
                 const { Model } = modelMod;
                 // Check each model ID in the cache
@@ -2331,7 +2340,7 @@ const verifyModelInstancesInCache = fromCallback(({ sendBack, input }) => {
                 const missingIds = [];
                 for (const modelFileId of modelIds) {
                     // Try to get instance from cache
-                    const instance = Model.getById(modelFileId);
+                    const instance = Model.peek(modelFileId);
                     if (instance) {
                         verifiedInstances.push(modelFileId);
                     }
@@ -2381,8 +2390,8 @@ const writePropertiesToDb = fromCallback(({ sendBack, input }) => {
     const _write = async () => {
         const { modelIds } = input;
         try {
-            const _mod_12 = await import('./index-DpgQMIRq.js');
-            const _ns_12 = _mod_12.bd;
+            const _mod_12 = await import('./index-CI0NFf4B.js');
+            const _ns_12 = _mod_12.bh;
             const modelSchemaMod = _ns_12;
             const { models: modelsTable, properties: propertiesTable } = modelSchemaMod;
             const drizzleMod = await import('drizzle-orm');
@@ -2571,10 +2580,10 @@ const createPropertyInstances = fromCallback(({ sendBack, input }) => {
             return;
         }
         try {
-            const modProp = await import('./ModelProperty-B52C3CQ2.js');
+            const modProp = await import('./ModelProperty-sMGL-_LK.js');
             const ModelProperty = modProp?.ModelProperty ?? modProp?.default;
-            const _mod_13 = await import('./errors-KM-yq2MD.js');
-            const _ns_13 = _mod_13.j;
+            const _mod_13 = await import('./errors-BGk_IJO5.js');
+            const _ns_13 = _mod_13.i;
             const modModel = _ns_13;
             const Model = modModel?.Model ?? modModel?.default;
             if (!ModelProperty || !Model) {
@@ -2587,7 +2596,7 @@ const createPropertyInstances = fromCallback(({ sendBack, input }) => {
             let successCount = 0;
             // For each model, check if properties are loaded
             for (const modelFileId of modelIds) {
-                const model = Model.getById(modelFileId);
+                const model = Model.peek(modelFileId);
                 if (model && model.properties) {
                     // Count properties that match our property IDs
                     for (const prop of model.properties) {
@@ -2680,7 +2689,7 @@ const verifyPropertyInstancesInCache = fromCallback(({ sendBack, input }) => {
         }
         try {
             const result = await verifyWithRetry(async () => {
-                const mod = await import('./ModelProperty-B52C3CQ2.js');
+                const mod = await import('./ModelProperty-sMGL-_LK.js');
                 const ModelProperty = mod?.ModelProperty ?? mod?.default;
                 if (!ModelProperty) {
                     throw new Error('ModelProperty not available from dynamic import');
@@ -3700,8 +3709,8 @@ async function loadSchemaWithRenames(schemaFilePath, modelRenames) {
         updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
     };
     // Use dynamic import to break circular dependency
-    const _mod_14 = await import('./index-DpgQMIRq.js');
-    const _ns_14 = _mod_14.bi;
+    const _mod_14 = await import('./index-CI0NFf4B.js');
+    const _ns_14 = _mod_14.bm;
     const dbMod = _ns_14;
     const { addSchemaToDb, addModelsToDb } = dbMod;
     // Add schema to database with schemaFileId
@@ -3824,8 +3833,8 @@ async function renameModelProperty(schemaName, modelName, oldPropertyName, newPr
     await BaseFileManager.waitForFileWithContent(newFilePath);
     logger$1(`Renamed property ${oldPropertyName} to ${newPropertyName} in schema ${schemaName} v${newVersion}`);
     // Migrate metadata rows so ItemProperty values follow the new name (prevents duplicate ItemProperties)
-    const _mod_15 = await import('./index-DpgQMIRq.js');
-    const _ns_15 = _mod_15.bi;
+    const _mod_15 = await import('./index-CI0NFf4B.js');
+    const _ns_15 = _mod_15.bm;
     const { migrateMetadataForPropertyRename } = _ns_15;
     const migratedCount = await migrateMetadataForPropertyRename(modelName, oldPropertyName, newPropertyName, oldProperty.id, { schemaName });
     if (migratedCount > 0) {
@@ -4083,9 +4092,8 @@ var updateSchema = /*#__PURE__*/Object.freeze({
 
 const logger = debug('seedSdk:schema:saveNewVersion');
 const saveDraftLogger = debug('seedSdk:schema:saveDraftToDb');
-// WeakMap to store non-serializable resources per Schema instance
-// Only stores resources that cannot be serialized (subscriptions, timers, etc.)
-const schemaInstanceState = new WeakMap();
+// Non-serializable resources per Schema instance (subscriptions, timers, etc.)
+const schemaInstanceState = new ActorKeyedState();
 // Cache client initialization state globally to avoid repeated checks
 let cachedClientInitialized = null;
 let clientCheckTime = 0;
@@ -4142,18 +4150,18 @@ class Schema {
         }
         const waitForReady = options?.waitForReady !== false;
         const readyTimeout = options?.readyTimeout ?? DEFAULT_READY_TIMEOUT_MS;
+        const holds = options?.hold === false ? 0 : 1;
         // First, check if we have an instance cached by name
-        if (this.instanceCacheByName.has(schemaName)) {
-            const { instance, refCount } = this.instanceCacheByName.get(schemaName);
-            this.instanceCacheByName.set(schemaName, {
-                instance,
-                refCount: refCount + 1,
-            });
+        const cached = this.instanceCacheByName.get(schemaName);
+        if (cached) {
+            cached.refCount += holds;
+            const { instance } = cached;
             if (!waitForReady)
                 return instance;
             return waitForEntityIdle(instance, { timeout: readyTimeout }).then(() => instance);
         }
-        // Deduplicate concurrent creates for same schema (prevents many parallel checkExistingSchema loads)
+        // Deduplicate concurrent creates for same schema (prevents many parallel checkExistingSchema loads).
+        // The name cache is set before a pending load is recorded, so a hold was already taken above.
         if (waitForReady) {
             const pending = this.pendingSchemaByName.get(schemaName);
             if (pending) {
@@ -4366,7 +4374,7 @@ class Schema {
         // Cache by name initially (will be moved to id-based cache once schemaFileId is available)
         this.instanceCacheByName.set(schemaName, {
             instance: proxiedInstance,
-            refCount: 1,
+            refCount: holds,
         });
         const schema = proxiedInstance;
         if (!waitForReady)
@@ -4392,14 +4400,11 @@ class Schema {
             return;
         }
         // If we have an instance cached by name, also add it to id-based cache
-        // Keep it in both caches for efficient lookups
+        // Keep it in both caches for efficient lookups, as one entry: one hold count for both keys
         if (this.instanceCacheByName.has(schemaName)) {
             const cacheEntry = this.instanceCacheByName.get(schemaName);
             // Add to ID cache (don't remove from name cache)
-            this.instanceCacheById.set(schemaFileId, {
-                instance: cacheEntry.instance,
-                refCount: cacheEntry.refCount, // Use same refCount
-            });
+            this.instanceCacheById.set(schemaFileId, cacheEntry);
             logger(`Added schema cache entry to id "${schemaFileId}" (kept in name cache: "${schemaName}")`);
         }
     }
@@ -4408,15 +4413,19 @@ class Schema {
      * Returns null if not found in cache
      */
     static getById(schemaFileId) {
-        if (this.instanceCacheById.has(schemaFileId)) {
-            const { instance, refCount } = this.instanceCacheById.get(schemaFileId);
-            this.instanceCacheById.set(schemaFileId, {
-                instance,
-                refCount: refCount + 1,
-            });
-            return instance;
-        }
-        return null;
+        const entry = this.instanceCacheById.get(schemaFileId);
+        if (!entry)
+            return null;
+        entry.refCount += 1;
+        return entry.instance;
+    }
+    /**
+     * The cached schema with this file id or name, without taking a hold. For SDK code that reads
+     * the schema and doesn't hand it to a caller; callers that keep it use `create` or `find`.
+     */
+    static peek(schemaFileIdOrName) {
+        return (this.instanceCacheById.get(schemaFileIdOrName)?.instance ??
+            this.instanceCacheByName.get(schemaFileIdOrName)?.instance);
     }
     /**
      * Clear all cached Schema instances.
@@ -4452,14 +4461,16 @@ class Schema {
      * Create or get schema instance by schemaFileId
      * Queries the database to find the schema name if not cached
      * @param schemaFileId - The schema file ID
-     * @returns Schema instance
+     * @returns Schema instance, with a hold taken (unless `hold: false`)
      */
-    static async createById(schemaFileId) {
+    static async createById(schemaFileId, 
+    /** @internal `hold: false` as for `create` */
+    options) {
         if (!schemaFileId) {
             throw new Error('Schema file ID is required');
         }
         // First, check if we have an instance cached by ID
-        const cachedInstance = this.getById(schemaFileId);
+        const cachedInstance = options?.hold === false ? this.peek(schemaFileId) : this.getById(schemaFileId);
         if (cachedInstance) {
             return cachedInstance;
         }
@@ -4483,7 +4494,7 @@ class Schema {
             throw new Error(`Schema with ID "${schemaFileId}" has no name in database`);
         }
         // Create schema using the name (this will load from database/file)
-        return this.create(schemaName);
+        return this.create(schemaName, options?.hold === false ? { hold: false } : undefined);
     }
     /**
      * Find schema instance by schemaFileId
@@ -4512,6 +4523,7 @@ class Schema {
      * Get instantiated Schema objects for all schemas (from database and files)
      * By default, returns only the latest version of each schema and excludes the internal Seed Protocol schema.
      * Uses loadAllSchemasFromDb() as the single source of truth, which intelligently merges database and file data.
+     * Takes no holds on the instances it returns: a caller that keeps one uses `Schema.create` or `Schema.find`.
      *
      * @param options - Configuration options
      * @param options.includeAllVersions - If true, returns all versions of each schema. Default: false
@@ -4570,9 +4582,10 @@ class Schema {
                 }
                 processedSchemaNames.add(schemaName);
                 // Try to use schemaFileId to ensure we load the correct version
-                // First check if we have a cached instance by schemaFileId
+                // First check if we have a cached instance by schemaFileId. Schema.all takes no holds: it
+                // lists schemas (useSchemas caches the list and never unloads it).
                 if (schemaFileId) {
-                    const cachedById = this.getById(schemaFileId);
+                    const cachedById = this.peek(schemaFileId);
                     if (cachedById) {
                         // Verify the cached instance has the correct version
                         const cachedContext = cachedById.getService().getSnapshot().context;
@@ -4597,16 +4610,16 @@ class Schema {
                 // But to ensure we get the correct version, we'll use createById if we have the schemaFileId
                 if (schemaFileId) {
                     try {
-                        const instance = await this.createById(schemaFileId);
+                        const instance = await this.createById(schemaFileId, { hold: false });
                         schemaInstances.push(instance);
                     }
                     catch {
                         // Fallback to creating by name if createById fails
-                        schemaInstances.push(this.create(schemaName, { waitForReady: false }));
+                        schemaInstances.push(this.create(schemaName, { waitForReady: false, hold: false }));
                     }
                 }
                 else {
-                    schemaInstances.push(this.create(schemaName, { waitForReady: false }));
+                    schemaInstances.push(this.create(schemaName, { waitForReady: false, hold: false }));
                 }
             }
             if (waitForReady && schemaInstances.length > 0) {
@@ -4651,7 +4664,7 @@ class Schema {
             // Create Schema instances for each unique schema name
             const schemaInstances = [];
             for (const schemaName of uniqueSchemaNames) {
-                schemaInstances.push(this.create(schemaName, { waitForReady: false }));
+                schemaInstances.push(this.create(schemaName, { waitForReady: false, hold: false }));
             }
             if (waitForReady && schemaInstances.length > 0) {
                 await Promise.all(schemaInstances.map((s) => waitForEntityIdle(s, {
@@ -4712,7 +4725,7 @@ class Schema {
         const seen = new Set();
         const modelInstances = [];
         for (const modelFileId of allModelIds) {
-            const model = Model.getById(modelFileId);
+            const model = Model.peek(modelFileId);
             if (model && modelFileId && !seen.has(modelFileId)) {
                 modelInstances.push(model);
                 seen.add(modelFileId);
@@ -4821,7 +4834,7 @@ class Schema {
                 const modelDbId = modelInstance.getService().getSnapshot().context._dbId;
                 const db = BaseDb.getAppDb();
                 if (propertyContexts.length === 0 && modelDbId && db) {
-                    const { ModelProperty } = await import('./ModelProperty-B52C3CQ2.js');
+                    const { ModelProperty } = await import('./ModelProperty-sMGL-_LK.js');
                     const rows = await db.select().from(properties).where(eq(properties.modelId, modelDbId));
                     propertyContexts = rows.map((row) => {
                         const cached = row.schemaFileId ? ModelProperty.getById(row.schemaFileId) : undefined;
@@ -4987,7 +5000,7 @@ class Schema {
             savedSchema: publishedSchema,
         });
         // Clear edited flags on all ModelProperty instances and in database
-        const modelPropertyMod = await import('./ModelProperty-B52C3CQ2.js');
+        const modelPropertyMod = await import('./ModelProperty-sMGL-_LK.js');
         const { ModelProperty } = modelPropertyMod;
         for (const propertyKey of context._editedProperties) {
             const [modelName, propertyName] = propertyKey.split(':');
@@ -5010,8 +5023,8 @@ class Schema {
                 try {
                     if (db && modelName && propertyName) {
                         // Find this schema's model by name
-                        const _mod_16 = await import('./index-DpgQMIRq.js');
-                        const _ns_16 = _mod_16.bh;
+                        const _mod_16 = await import('./index-CI0NFf4B.js');
+                        const _ns_16 = _mod_16.bl;
                         const { resolveModelRecord } = _ns_16;
                         const modelRecord = await resolveModelRecord(modelName, { schemaName: thisSchemaName }, db);
                         const modelRecords = modelRecord ? [modelRecord] : [];
@@ -5577,6 +5590,8 @@ class Schema {
                 onUnload: () => {
                     // Clean up WeakMap entry
                     schemaInstanceState.delete(this);
+                    if (context.schemaName)
+                        Model.releaseSchemaHolds(context.schemaName);
                 },
             });
         }
@@ -5640,10 +5655,10 @@ class Schema {
         // instances too, or a re-import would get them back with dangling _dbIds.
         if (schemaName) {
             const evictedModelNames = Model.evictForSchema(schemaName);
-            const { ModelProperty } = await import('./ModelProperty-B52C3CQ2.js');
+            const { ModelProperty } = await import('./ModelProperty-sMGL-_LK.js');
             ModelProperty.evictForModels(evictedModelNames, schemaName);
             // Evicting stops new writes but not ones already running; let those land before deleting their rows
-            const _mod_17 = await import('./errors-KM-yq2MD.js');
+            const _mod_17 = await import('./errors-BGk_IJO5.js');
             const _ns_17 = _mod_17.h;
             const { waitForInFlightWrites } = _ns_17;
             await waitForInFlightWrites();
@@ -5676,7 +5691,7 @@ class Schema {
                         .map((r) => r.modelId)
                         .filter((id) => id != null)),
                 ];
-                const { detachModelRows } = await import('./detachRowsBeforeDelete-D1TyEMco.js');
+                const { detachModelRows } = await import('./detachRowsBeforeDelete-CLbBbpX4.js');
                 await detachModelRows(db, modelIds);
                 await db.delete(modelSchemas).where(inArray(modelSchemas.schemaId, schemaIds));
                 for (const modelId of modelIds) {
@@ -5691,8 +5706,8 @@ class Schema {
                 // the destroyed schema back on the next Schema.all().
                 // Match on name as well as id: versions imported from complete schema files can each
                 // have their own id, and any version left behind would bring the schema back.
-                const _mod_18 = await import('./ClientManager-2GtDWHq6.js');
-                const _ns_18 = _mod_18.N;
+                const _mod_18 = await import('./ClientManager-Dcju5x4k.js');
+                const _ns_18 = _mod_18.X;
                 const { listCompleteSchemaFiles } = _ns_18;
                 const files = await listCompleteSchemaFiles().catch(() => []);
                 const fs = await BaseFileManager.getFs();
@@ -5810,7 +5825,7 @@ class Schema {
                 // One at a time: an eviction of this schema part way through stops the rest
                 const evictionEpoch = currentEvictionEpoch();
                 for (const id of ids) {
-                    await Model.createById(id, { evictionEpoch });
+                    await Model.createById(id, { evictionEpoch, hold: false });
                 }
             },
             queryInitialData: async (schemaId) => {
@@ -5887,4 +5902,4 @@ var Schema$1 = /*#__PURE__*/Object.freeze({
 });
 
 export { Schema as S, deletePropertyFromModel as a, Schema$1 as b, deleteModelFromSchema as d, renameModelProperty as r, schemaMachine as s, updateModelProperties as u };
-//# sourceMappingURL=Schema-O1QLoXv6.js.map
+//# sourceMappingURL=Schema-D-TczaIj.js.map