@seedprotocol/sdk 0.6.10 → 0.7.1

package/dist/{index-HRHkbVQd.js → index-Y-yYyRBf.js}

@@ -1,15 +1,32 @@
 import { fromCallback, fromPromise, setup, assign, createActor } from 'xstate';
-import { a as BaseDb, m as models, p as properties, J as isInternalSchema, i as modelSchemas, s as schemas } from './BasePathResolver-B6CKqoKw.js';
-import { eq, or } from 'drizzle-orm';
-import './index-280bL-n4.js';
+import { B as BaseDb, j as models, p as properties, K as isInternalSchema, g as modelSchemas, s as schemas } from './BasePathResolver-DRT09oVv.js';
+import { eq, and, isNull, or } from 'drizzle-orm';
+import './tabEvents-C6NXS6Jl.js';
 import debug from 'debug';
 import { generateId } from './generateId-BopUwD8F.js';
-import { y as writeModelToDb, z as writePropertyToDb, A as addSchemaToDb, C as renameModelInDb, d as TProperty } from './db-WbrzEf7c.js';
-import { n as waitForEntityIdle, af as getInvariantSafePropertyDescriptor, q as findEntity, H as getClient, y as ClientManagerState, I as Item, ag as unloadEntity, ah as clearDestroySubscriptions, u as forceRemoveFromCaches, v as runDestroyLifecycle } from './ClientManager-ChcmUL47.js';
+import { G as writeModelToDb, K as writePropertyToDb, O as addSchemaToDb, A as AmbiguousModelError, Q as renameModelInDb, d as TProperty } from './db-Lw0KVZmc.js';
+import { j as waitForEntityIdle, T as getInvariantSafePropertyDescriptor, m as findEntity, C as ClientManagerState, I as Item, U as clearDestroySubscriptions, n as forceRemoveFromCaches, V as unloadEntity, o as runDestroyLifecycle } from './Item-ZUAmf943.js';
+import { h as getClient } from './ClientManager-DngaZdw6.js';
 import { modelPropertiesToObject } from './model-DGMe-TTm.js';
 import { toSnakeCase } from 'drizzle-orm/casing';
 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
@@ -21,7 +38,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await import('./ModelProperty-D79uV42p.js');
+        const mod = await import('./ModelProperty-6llK4MTH.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$7('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -52,7 +69,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         // Don't throw - this is best-effort to pre-populate cache
     }
 };
-const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
+const loadOrCreateModel = fromCallback(({ sendBack, input: { context }, self }) => {
     const _loadOrCreateModel = async () => {
         const { modelName, schemaName, id, _idFromSchema } = context; // id is now the schemaFileId (string)
         if (!modelName || !schemaName) {
@@ -85,11 +102,40 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
                 // But if we have a schemaFileId and the model found by name has a different schemaFileId,
                 // don't use it - we're creating a new model from a schema file with a specific ID
                 if (!modelRecord) {
-                    const dbModels = await db
-                        .select()
+                    // 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('./BasePathResolver-DRT09oVv.js');
+                    const _ns_0 = _mod_0.R;
+                    const { modelSchemas } = _ns_0;
+                    const _mod_1 = await import('./BasePathResolver-DRT09oVv.js');
+                    const _ns_1 = _mod_1.Q;
+                    const { schemas: schemasTable } = _ns_1;
+                    let dbModels = await db
+                        .select({
+                        id: models.id,
+                        name: models.name,
+                        schemaFileId: models.schemaFileId,
+                        isEdited: models.isEdited,
+                    })
                         .from(models)
-                        .where(eq(models.name, modelName))
+                        .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
+                        .innerJoin(schemasTable, eq(modelSchemas.schemaId, schemasTable.id))
+                        .where(and(eq(models.name, modelName), eq(schemasTable.name, schemaName)))
                         .limit(1);
+                    if (dbModels.length === 0) {
+                        dbModels = await db
+                            .select({
+                            id: models.id,
+                            name: models.name,
+                            schemaFileId: models.schemaFileId,
+                            isEdited: models.isEdited,
+                        })
+                            .from(models)
+                            .leftJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
+                            // Stubs only: an unlinked row with a schemaFileId is a deleted schema's leftover, not ours
+                            .where(and(eq(models.name, modelName), isNull(modelSchemas.id), isNull(models.schemaFileId)))
+                            .limit(1);
+                    }
                     if (dbModels.length > 0) {
                         const foundModel = dbModels[0];
                         const dbSchemaFileId = foundModel.schemaFileId;
@@ -98,7 +144,9 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
                         // This handles the case where Model.create was called with a generated ID, but the model
                         // already exists in the database with a different ID. By updating the current instance's
                         // schemaFileId to match the database, both will point to the same cached instance.
-                        if (dbSchemaFileId) {
+                        // Skip for schema models (_idFromSchema): their id is authoritative, and a same-name row
+                        // with a different id belongs to another schema (e.g. two schemas that each define "Post").
+                        if (dbSchemaFileId && !(_idFromSchema && schemaFileId && schemaFileId !== dbSchemaFileId)) {
                             try {
                                 const modelMod = await Promise.resolve().then(function () { return Model$1; });
                                 const { Model } = modelMod;
@@ -164,7 +212,9 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
                         .map((record) => record.schemaFileId)
                         .filter((id) => id !== null && id !== undefined);
                     if (propertyFileIds.length > 0) {
-                        await createPropertyInstances(propertyFileIds);
+                        // Not for a model stopped meanwhile (unloaded, or evicted with its schema)
+                        if (!isActorStopped(self))
+                            await createPropertyInstances(propertyFileIds);
                     }
                     // Generate schemaFileId if not set
                     if (!schemaFileId) {
@@ -205,10 +255,13 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
         // 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_0 = await import('./Schema-a8uO-hIZ.js');
-            const _ns_0 = _mod_0.b;
-            const schemaMod = _ns_0;
+            const _mod_2 = await import('./Schema-D-Ud-XYw.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 schemaSnapshot = schema.getService().getSnapshot();
             // Wait for schema to load if it's still loading
@@ -353,13 +406,13 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
                     }
                     // Also check database for models (in case they're persisted but not in Schema context)
                     if (db) {
-                        const _mod_1 = await import('./BasePathResolver-B6CKqoKw.js');
-                        const _ns_1 = _mod_1.Q;
-                        const modelSchemaSchemaMod = _ns_1;
+                        const _mod_3 = await import('./BasePathResolver-DRT09oVv.js');
+                        const _ns_3 = _mod_3.R;
+                        const modelSchemaSchemaMod = _ns_3;
                         const { modelSchemas } = modelSchemaSchemaMod;
-                        const _mod_2 = await import('./BasePathResolver-B6CKqoKw.js');
-                        const _ns_2 = _mod_2.O;
-                        const schemaSchemaMod = _ns_2;
+                        const _mod_4 = await import('./BasePathResolver-DRT09oVv.js');
+                        const _ns_4 = _mod_4.Q;
+                        const schemaSchemaMod = _ns_4;
                         const { schemas: schemasTable } = schemaSchemaMod;
                         // Query all models for this schema to check for duplicates (case-insensitive)
                         logger$7(`Checking database for duplicate model names in schema "${schemaName}"`);
@@ -453,12 +506,14 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
         }
         // Mark schema as draft when a new model is created so saveNewVersion() can persist it
         try {
-            const _mod_3 = await import('./Schema-a8uO-hIZ.js');
-            const _ns_3 = _mod_3.b;
-            const schemaMod = _ns_3;
+            const _mod_5 = await import('./Schema-D-Ud-XYw.js');
+            const _ns_5 = _mod_5.b;
+            const schemaMod = _ns_5;
             const { Schema } = schemaMod;
-            const schema = Schema.create(schemaName, { waitForReady: false });
-            schema.getService().send({ type: 'markAsDraft', propertyKey: 'schema:models' });
+            if (!isActorStopped(self)) {
+                const schema = Schema.create(schemaName, { waitForReady: false });
+                schema.getService().send({ type: 'markAsDraft', propertyKey: 'schema:models' });
+            }
         }
         catch (err) {
             logger$7(`Failed to mark schema as draft after creating model: ${err}`);
@@ -479,7 +534,7 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
 const logger$6 = debug('seedSdk:model:actors:validateModel');
 // Validation timeout in milliseconds (10 seconds)
 const VALIDATION_TIMEOUT_MS = 10000;
-const validateModel = fromCallback(({ sendBack, input: { context } }) => {
+const validateModel = fromCallback(({ sendBack, input: { context }, self }) => {
     let hasResponded = false;
     // Timeout handler to ensure we always respond
     const timeoutId = setTimeout(() => {
@@ -499,12 +554,12 @@ const validateModel = fromCallback(({ sendBack, input: { context } }) => {
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await import('./SchemaValidationService-Y49vqast.js');
+            const validationServiceMod = await import('./SchemaValidationService-IoS7JquP.js');
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const _mod_4 = await import('./Schema-a8uO-hIZ.js');
-            const _ns_4 = _mod_4.b;
-            const schemaMod = _ns_4;
+            const _mod_6 = await import('./Schema-D-Ud-XYw.js');
+            const _ns_6 = _mod_6.b;
+            const schemaMod = _ns_6;
             const { Schema } = schemaMod;
             // Validate model structure
             const structureResult = validationService.validateModelStructure(context);
@@ -519,6 +574,9 @@ const validateModel = fromCallback(({ sendBack, input: { context } }) => {
             // If we have schema name, validate against schema
             // CRITICAL: Use validateModelAgainstSchema which doesn't require the model to be in schema context
             // This allows validation BEFORE registration, preventing update loops
+            // Stopped meanwhile (unloaded, or evicted with its schema): don't load the schema again
+            if (isActorStopped(self))
+                return;
             if (context.schemaName) {
                 try {
                     const schema = Schema.create(context.schemaName, {
@@ -601,10 +659,14 @@ const validateModel = fromCallback(({ sendBack, input: { context } }) => {
 });
 
 const logger$5 = debug('seedSdk:model:actors:createModelProperties');
-const createModelProperties = fromCallback(({ sendBack, input }) => {
+const createModelProperties = fromCallback(({ sendBack, input, self }) => {
+    // The model was stopped (unloaded, or evicted with its schema by Schema.destroy / test cleanup) while
+    // this ran: stopping it stops this actor too, but can't cancel the awaits below. A stopped model
+    // creates no properties (they'd be cached for a model that's gone, and write rows under it).
+    const stopped = () => isActorStopped(self);
     const _createProperties = async () => {
         const { context, propertyDefinitions } = input;
-        const { id, _dbId, modelName } = context;
+        const { id, _dbId, modelName, schemaName } = context;
         if (!id || !_dbId || !modelName) {
             throw new Error('Model ID, file ID, and name are required to create properties');
         }
@@ -614,7 +676,7 @@ const createModelProperties = fromCallback(({ sendBack, input }) => {
             return;
         }
         logger$5(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await import('./ModelProperty-D79uV42p.js');
+        const mod = await import('./ModelProperty-6llK4MTH.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$5('ModelProperty not available from dynamic import');
@@ -622,13 +684,25 @@ const createModelProperties = fromCallback(({ sendBack, input }) => {
             return;
         }
         const drizzleMod = await import('drizzle-orm');
-        const { eq } = drizzleMod;
+        const { and, eq } = drizzleMod;
         const db = BaseDb.getAppDb();
         for (const [propName, propData] of Object.entries(propertyDefinitions)) {
-            // Use provided ID or generate a random one
+            // The model's own write (writeModelToDb) normally stored this property already, under
+            // propData.id or an id it generated. Reuse that row so the instance gets the same id
+            // and doesn't write the property a second time.
+            const propertyRecord = db
+                ? (await db
+                    .select()
+                    .from(properties)
+                    .where(propData.id
+                    ? eq(properties.schemaFileId, propData.id)
+                    : and(eq(properties.modelId, _dbId), eq(properties.name, propName)))
+                    .limit(1))[0]
+                : undefined;
+            // Otherwise use provided ID or generate a random one
             // IDs should be generated in the import process before creating properties
             const { generateId } = await import('./generateId-BopUwD8F.js');
-            const propertyFileId = propData.id || generateId();
+            const propertyFileId = propData.id || propertyRecord?.schemaFileId || generateId();
             logger$5(`Creating property "${propName}" with fileId "${propertyFileId}"`);
             // Query database to get refModelId if the property has ref/refModelName
             // The property should already be in DB from addModelsToDb
@@ -637,24 +711,18 @@ const createModelProperties = fromCallback(({ sendBack, input }) => {
                 try {
                     const refModelName = propData.refModelName || propData.ref;
                     // First try to get refModelId from the property record in the database
-                    const propertyRecords = await db
-                        .select()
-                        .from(properties)
-                        .where(eq(properties.schemaFileId, propertyFileId))
-                        .limit(1);
-                    if (propertyRecords.length > 0 && propertyRecords[0].refModelId) {
-                        refModelId = propertyRecords[0].refModelId;
+                    if (propertyRecord?.refModelId) {
+                        refModelId = propertyRecord.refModelId;
                         logger$5(`Found refModelId ${refModelId} from database for property "${propName}"`);
                     }
                     else if (refModelName) {
-                        // Fallback: query models table directly by name
-                        const refModelRecords = await db
-                            .select()
-                            .from(models)
-                            .where(eq(models.name, refModelName))
-                            .limit(1);
-                        if (refModelRecords.length > 0 && refModelRecords[0].id) {
-                            refModelId = refModelRecords[0].id;
+                        // Fallback: resolve the ref by name within this model's schema
+                        const _mod_7 = await import('./db-Lw0KVZmc.js');
+                        const _ns_7 = _mod_7.Y;
+                        const { resolveModelRecord } = _ns_7;
+                        const refModelRecord = await resolveModelRecord(refModelName, { schemaName }, db);
+                        if (refModelRecord?.id) {
+                            refModelId = refModelRecord.id;
                             logger$5(`Resolved refModelId ${refModelId} from model name "${refModelName}" for property "${propName}"`);
                         }
                     }
@@ -664,6 +732,10 @@ const createModelProperties = fromCallback(({ sendBack, input }) => {
                     // Continue without refModelId - it will be resolved later in _initializeOriginalValues
                 }
             }
+            if (stopped()) {
+                logger$5(`Model "${modelName}" was stopped while creating its properties; not creating the rest`);
+                return;
+            }
             // Create ModelProperty instance
             // This will load from DB if it exists, or create new instance
             // The property should already be in DB from writeModelToDb
@@ -678,12 +750,14 @@ const createModelProperties = fromCallback(({ sendBack, input }) => {
                 refModelName: propData.refModelName,
                 refModelId,
                 refValueType: propData.refValueType,
-                storageType: propData.storageType,
-                localStorageDir: propData.localStorageDir,
-                filenameSuffix: propData.filenameSuffix,
+                // Definitions built from DB rows may lack storage settings; the row has them.
+                storageType: propData.storageType ?? propertyRecord?.storageType ?? undefined,
+                localStorageDir: propData.localStorageDir ?? propertyRecord?.localStorageDir ?? undefined,
+                filenameSuffix: propData.filenameSuffix ?? propertyRecord?.filenameSuffix ?? undefined,
                 required: propData.required,
                 _propertyFileId: propertyFileId, // Store schemaFileId for getById() lookups
-            }); // Use 'as any' because _propertyFileId is not in TProperty type
+                _dbId: propertyRecord?.schemaFileId === propertyFileId ? propertyRecord.id : undefined, // Already persisted: skip the write
+            }, { schemaName }); // Use 'as any' because _propertyFileId is not in TProperty type
         }
         logger$5(`Successfully created all properties for model "${modelName}"`);
         sendBack({ type: 'createModelPropertiesSuccess' });
@@ -700,6 +774,37 @@ const createModelProperties = fromCallback(({ sendBack, input }) => {
     };
 });
 
+/**
+ * Eviction epochs: lets work that was started before a schema's Model/ModelProperty instances were
+ * evicted (Schema.destroy, test cleanup) tell, when it finishes, that it must not put instances for
+ * that schema back in the caches. Stopping the evicted actors can't cancel such work (a DB lookup
+ * that ends in Model.create, a model's property creation), and finishing it after the eviction would
+ * rebuild instances from rows that are about to be deleted, which then write themselves again.
+ *
+ * Capture `currentEvictionEpoch()` when the work starts; before creating or caching an instance, skip
+ * it when `schemaEvictedSince(schemaName, epoch)`. Work started after an eviction is unaffected.
+ */
+let epoch = 0;
+const lastEvictionBySchema = new Map();
+function currentEvictionEpoch() {
+    return epoch;
+}
+/** Called by Model.evictForSchema. */
+function recordSchemaEviction(schemaName) {
+    epoch += 1;
+    lastEvictionBySchema.set(schemaName, epoch);
+}
+/** True when the schema's instances were evicted after `since` (an epoch from currentEvictionEpoch). */
+function schemaEvictedSince(schemaName, since) {
+    if (epoch === since || !schemaName)
+        return false;
+    return (lastEvictionBySchema.get(schemaName) ?? 0) > since;
+}
+/** True when any schema was evicted after `since` (cheap check before looking up which schemas apply). */
+function anyEvictionSince(since) {
+    return epoch !== since;
+}
+
 const logger$4 = debug('seedSdk:write:validateEntity');
 // XState v5 type inference bug: fromPromise types are inverted
 // We use type assertion to work around this
@@ -707,6 +812,20 @@ const validateEntity = fromPromise(async ({ input }) => {
     // Type assertion to fix XState v5 type inference bug
     // Convert through unknown to avoid type overlap error
     const entityInput = input;
+    // Validation awaits imports before looking up the schema; the entity can be evicted with its
+    // schema meanwhile (Schema.destroy, test cleanup). Schema.create would then load the evicted
+    // schema again, and its load re-creates the schema's models from rows being deleted.
+    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_8 = await import('./Schema-D-Ud-XYw.js');
+        const _ns_8 = _mod_8.b;
+        const { Schema } = _ns_8;
+        if (schemaEvictedSince(schemaName, evictionEpoch)) {
+            throw new Error(`Schema "${schemaName}" was evicted during validation`);
+        }
+        return Schema.create(schemaName, { waitForReady: false });
+    };
     const _validate = async () => {
         try {
             const msg = `[validateEntity] Starting validation for ${entityInput.entityType}`;
@@ -717,7 +836,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                 const structureMsg = `[validateEntity] Validating model structure`;
                 logger$4(structureMsg);
                 // Use existing Model validation
-                const validationServiceMod = await import('./SchemaValidationService-Y49vqast.js');
+                const validationServiceMod = await import('./SchemaValidationService-IoS7JquP.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
@@ -735,13 +854,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                     if (entityInput.entityData.schemaName) {
                         try {
                             logger$4(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
-                            const _mod_5 = await import('./Schema-a8uO-hIZ.js');
-                            const _ns_5 = _mod_5.b;
-                            const schemaMod = _ns_5;
-                            const { Schema } = schemaMod;
-                            const schema = Schema.create(entityInput.entityData.schemaName, {
-                                waitForReady: false,
-                            });
+                            const schema = await schemaForValidation(entityInput.entityData.schemaName);
                             const schemaSnapshot = schema.getService().getSnapshot();
                             const schemaStatus = schemaSnapshot.value;
                             logger$4(`[validateEntity] Schema status: ${schemaStatus}`);
@@ -773,7 +886,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const validationServiceMod = await import('./SchemaValidationService-Y49vqast.js');
+                const validationServiceMod = await import('./SchemaValidationService-IoS7JquP.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -788,13 +901,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                     // If schema name and model name provided, validate against schema
                     if (entityInput.entityData._schemaName && entityInput.entityData.modelName) {
                         try {
-                            const _mod_6 = await import('./Schema-a8uO-hIZ.js');
-                            const _ns_6 = _mod_6.b;
-                            const schemaMod = _ns_6;
-                            const { Schema } = schemaMod;
-                            const schema = Schema.create(entityInput.entityData._schemaName, {
-                                waitForReady: false,
-                            });
+                            const schema = await schemaForValidation(entityInput.entityData._schemaName);
                             const schemaSnapshot = schema.getService().getSnapshot();
                             const schemaStatus = schemaSnapshot.value;
                             if (schemaStatus === 'idle') {
@@ -819,7 +926,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'schema') {
                 // Schema validation - use existing validation
-                const validationServiceMod = await import('./SchemaValidationService-Y49vqast.js');
+                const validationServiceMod = await import('./SchemaValidationService-IoS7JquP.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
@@ -849,6 +956,22 @@ const validateEntity = fromPromise(async ({ input }) => {
 });
 
 const logger$3 = debug('seedSdk:write:writeToDatabase');
+// Writes that have started. Stopping a write process's actor can't cancel one, so code that deletes rows
+// under live instances (Schema.destroy, test cleanup) waits for these after evicting the instances.
+const inFlightWrites = new Set();
+/**
+ * Resolves once every database write started so far has finished (or after timeoutMs). Evict/stop the
+ * instances first so no new writes start while waiting.
+ */
+const waitForInFlightWrites = async (timeoutMs = 5000) => {
+    const deadline = Date.now() + timeoutMs;
+    while (inFlightWrites.size > 0 && Date.now() < deadline) {
+        await Promise.race([
+            Promise.allSettled([...inFlightWrites]),
+            new Promise((resolve) => setTimeout(resolve, deadline - Date.now())),
+        ]);
+    }
+};
 const writeToDatabase = fromCallback(({ sendBack, input }) => {
     const _write = async () => {
         try {
@@ -892,7 +1015,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-D79uV42p.js');
+                    const mod = await import('./ModelProperty-6llK4MTH.js');
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -909,6 +1032,7 @@ const writeToDatabase = fromCallback(({ sendBack, input }) => {
                                 storageType: ctx.storageType ?? input.entityData.storageType,
                                 localStorageDir: ctx.localStorageDir ?? input.entityData.localStorageDir,
                                 filenameSuffix: ctx.filenameSuffix ?? input.entityData.filenameSuffix,
+                                required: ctx.required ?? input.entityData.required,
                             };
                         }
                     }
@@ -941,18 +1065,26 @@ const writeToDatabase = fromCallback(({ sendBack, input }) => {
             });
         }
     };
-    _write().catch((error) => {
+    const write = _write().catch((error) => {
         logger$3('Error in writeToDatabase promise:', error);
         sendBack({
             type: 'writeError',
             error: error instanceof Error ? error : new Error(String(error)),
         });
     });
+    inFlightWrites.add(write);
+    write.finally(() => inFlightWrites.delete(write));
     return () => {
         // Cleanup function (optional)
     };
 });
 
+var writeToDatabase$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    waitForInFlightWrites: waitForInFlightWrites,
+    writeToDatabase: writeToDatabase
+});
+
 const logger$2 = debug('seedSdk:write:writeProcessMachine');
 const writeProcessMachine = setup({
     types: {
@@ -1131,7 +1263,10 @@ const writeProcessMachine = setup({
                             retryCount: ({ context }) => context.retryCount + 1,
                         }),
                         ({ context, event }) => {
-                            logger$2(`[writing] Write error for ${context.entityType} "${context.entityId}":`, event.error);
+                            const errorMsg = `[writing] Write error for ${context.entityType} "${context.entityId}": ${event.error}`;
+                            logger$2(errorMsg);
+                            // Nothing else reports a failed persist to the caller, so always log to console
+                            console.error(errorMsg, event.error);
                         },
                     ],
                 },
@@ -1189,9 +1324,6 @@ const modelMachine = setup({
         isModelValid: ({ context }) => {
             return !context._validationErrors || context._validationErrors.length === 0;
         },
-        hasValidationErrors: ({ context }) => {
-            return !!context._validationErrors && context._validationErrors.length > 0;
-        },
     },
     actions: {
         assignValidationErrors: assign(({ context, event }) => {
@@ -1266,16 +1398,23 @@ const modelMachine = setup({
                     ({ context, event, self }) => {
                         if (event._liveQueryPropertyIds !== undefined) {
                             const newPropertyIds = event._liveQueryPropertyIds;
+                            // The model can be evicted with its schema (Schema.destroy, test cleanup) before the
+                            // timer and import below run: then create nothing, and drop lookups an eviction overtakes.
+                            const evictionEpoch = currentEvictionEpoch();
                             // Use setTimeout to check after assign has been applied
                             setTimeout(() => {
-                                self.getSnapshot();
+                                const snapshot = self.getSnapshot();
+                                if (snapshot.status === 'stopped')
+                                    return;
                                 // 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-D79uV42p.js').then(({ ModelProperty }) => {
+                                    import('./ModelProperty-6llK4MTH.js').then(({ ModelProperty }) => {
+                                        if (self.getSnapshot().status === 'stopped')
+                                            return;
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
                                             try {
-                                                const property = await ModelProperty.createById(propertyFileId);
+                                                const property = await ModelProperty.createById(propertyFileId, { evictionEpoch });
                                                 if (property) {
                                                     logger$1(`[modelMachine] Created/cached ModelProperty instance for propertyFileId "${propertyFileId}" after _liveQueryPropertyIds update`);
                                                 }
@@ -1349,22 +1488,15 @@ const modelMachine = setup({
             })),
         },
         destroyStarted: {
-            actions: assign({ _destroyInProgress: true, _destroyError: null }),
-        },
-        destroyDone: {
-            actions: assign({ _destroyInProgress: false }),
+            actions: assign({ _destroyError: null }),
         },
         destroyError: {
             actions: assign(({ event }) => ({
-                _destroyInProgress: false,
                 _destroyError: event.error instanceof Error
                     ? { message: event.error.message, name: event.error.name }
                     : { message: String(event.error) },
             })),
         },
-        clearDestroyError: {
-            actions: assign({ _destroyError: null }),
-        },
     },
     states: {
         loading: {
@@ -1497,10 +1629,9 @@ const modelMachine = setup({
                     },
                 ],
             },
-            always: {
-                guard: 'hasValidationErrors',
-                target: 'validating',
-            },
+            // No `always: hasValidationErrors -> validating` here: validation is re-run when the context changes
+            // (updateContext) or on request (validateModel). Re-entering while errors exist would loop forever on a
+            // model that is still invalid.
         },
         validating: {
             on: {
@@ -1550,6 +1681,8 @@ const modelMachine = setup({
                             // Trigger property refresh after properties are created
                             // This ensures _liveQueryPropertyIds is updated in Node.js where liveQuery isn't available
                             setTimeout(() => {
+                                if (self.getSnapshot().status === 'stopped')
+                                    return;
                                 self.send({ type: 'refreshProperties' });
                             }, 100); // Small delay to ensure properties are written to DB
                         },
@@ -1604,11 +1737,16 @@ function setupEntityLiveQuery(instance, config) {
                 const initialIds = config.extractEntityIds(initialRows);
                 if (initialIds.length > 0) {
                     logger(`Initial query returned ${initialIds.length} entities`);
-                    // Create child instances if provided
+                    // Create child instances if provided (not for a stopped entity: an unloaded or evicted
+                    // parent must not re-cache its children)
+                    if (isActorStopped(instance.getService()))
+                        return;
                     if (config.createChildInstances) {
                         await config.createChildInstances(initialIds);
                     }
-                    // Update context with initial IDs
+                    // Update context with initial IDs (the queries above can outlive the instance)
+                    if (isActorStopped(instance.getService()))
+                        return;
                     config.updateContext(instance, initialIds);
                 }
             }
@@ -1633,11 +1771,15 @@ function setupEntityLiveQuery(instance, config) {
                         }
                         logger(`Query returned ${rows.length} rows`);
                         const ids = config.extractEntityIds(rows);
-                        // Create child instances if provided (before updating context)
+                        // Create child instances if provided (before updating context; not for a stopped entity)
+                        if (isActorStopped(instance.getService()))
+                            return;
                         if (config.createChildInstances && ids.length > 0) {
                             await config.createChildInstances(ids);
                         }
                         // Update context with new IDs
+                        if (isActorStopped(instance.getService()))
+                            return;
                         config.updateContext(instance, ids);
                     },
                     error: (error) => {
@@ -1656,9 +1798,31 @@ function setupEntityLiveQuery(instance, config) {
             setupState.subscriptionSetUp = false; // Reset on error so we can retry
         }
     };
-    // Set up liveQuery subscription as soon as we have entity ID
-    const setupSubscription = instance.getService().subscribe(async (snapshot) => {
-        // Check if entity is ready
+    // The entity's DB row can be written after the entity goes idle (e.g. a schema import writes its
+    // models' rows after the Model instances loaded from the schema file). Nothing changes the
+    // entity's snapshot then, so an idle entity's id is also retried on a timer until found or the
+    // actor stops. Only while idle and not writing (canRetryEntityId): a busy entity's own snapshots
+    // drive the lookup, and finding its row mid-write handed a Model its _dbId before its write (and
+    // its properties' rows) had finished.
+    let retryIndex = 0;
+    let retryTimer;
+    const scheduleRetry = () => {
+        if (retryTimer !== undefined || retryIndex >= ENTITY_ID_RETRY_DELAYS_MS.length)
+            return;
+        retryTimer = setTimeout(() => {
+            retryTimer = undefined;
+            // Busy: its next snapshot retries
+            if (instance.getService().getSnapshot().value !== 'idle')
+                return;
+            if (config.canRetryEntityId && !config.canRetryEntityId(instance))
+                return;
+            retryIndex++;
+            void trySetup();
+        }, ENTITY_ID_RETRY_DELAYS_MS[retryIndex]);
+    };
+    const trySetup = async () => {
+        if (setupState.subscriptionSetUp || isActorStopped(instance.getService()))
+            return;
         if (config.isReady && !config.isReady(instance)) {
             if (config.waitForReady) {
                 await config.waitForReady(instance);
@@ -1667,35 +1831,42 @@ function setupEntityLiveQuery(instance, config) {
                 return; // Not ready yet, will retry on next snapshot
             }
         }
-        // Get entity ID
-        const entityId = await config.getEntityId(instance);
+        let entityId;
+        try {
+            entityId = await config.getEntityId(instance);
+        }
+        catch (error) {
+            logger(`Error getting entity ID: ${error}`);
+        }
         if (!entityId) {
-            return; // Need entity ID to proceed
+            scheduleRetry();
+            return;
         }
         // Once we have entity ID, set up the liveQuery subscription (only once)
         if (!setupState.subscriptionSetUp) {
             await setupLiveQuery(entityId);
-            if (setupState.subscriptionSetUp) {
-                setupSubscription.unsubscribe();
-            }
         }
-    });
-    // Also check current state immediately in case entity ID is already available
-    instance.getService().getSnapshot();
-    if (config.isReady && !config.isReady(instance)) {
-        // Not ready yet, will be handled by subscription
-        return;
-    }
-    config.getEntityId(instance).then((entityId) => {
-        if (entityId && !setupState.subscriptionSetUp) {
-            setupLiveQuery(entityId).catch((error) => {
-                logger(`Error in immediate setup: ${error}`);
-            });
+        if (setupState.subscriptionSetUp) {
+            setupSubscription.unsubscribe();
+            if (retryTimer !== undefined)
+                clearTimeout(retryTimer);
         }
-    }).catch((error) => {
-        logger(`Error getting entity ID: ${error}`);
+    };
+    // Set up liveQuery subscription as soon as we have entity ID
+    const setupSubscription = instance.getService().subscribe({
+        next: () => {
+            void trySetup();
+        },
+        complete: () => {
+            if (retryTimer !== undefined)
+                clearTimeout(retryTimer);
+        },
     });
+    // Also check current state immediately in case entity ID is already available
+    void trySetup();
 }
+/** Backoff for retrying an entity's id when its DB row isn't there yet (~60s in total). */
+const ENTITY_ID_RETRY_DELAYS_MS = [50, 100, 200, 400, 800, 1600, ...Array(28).fill(2000)];
 
 /**
  * Returns model rows (id, name, schemaFileId, isEdited) for building Model instances.
@@ -1743,7 +1914,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-D79uV42p.js')
+const modelPropertyImportPromise = import('./ModelProperty-6llK4MTH.js')
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -1758,17 +1929,10 @@ function getModelProperty() {
     // and the getter will return empty array, which matches the original behavior
     return ModelPropertyClass;
 }
-// Lazy import cache for Schema to avoid circular dependency
-let SchemaClass = null;
-const schemaImportPromise = (async () => { const _mod_7 = await import('./Schema-a8uO-hIZ.js'); return _mod_7.b; })()
-    .then(module => {
-    SchemaClass = module.Schema;
-    return SchemaClass;
-})
-    .catch(() => {
-    // If import fails, SchemaClass remains null
-    return null;
-});
+// Lazy import for Schema to avoid circular dependency
+const schemaImportPromise = (async () => { const _mod_11 = await import('./Schema-D-Ud-XYw.js'); return _mod_11.b; })()
+    .then(module => module.Schema)
+    .catch(() => null);
 // 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();
@@ -1830,6 +1994,14 @@ class Model {
         });
         // Note: Property getters/setters are now handled by the Proxy in create()
     }
+    /**
+     * True when a name-cached instance belongs to a different model than the requested modelFileId.
+     * A schema re-imported under the same name can give its models new ids while the previous
+     * instances are still cached by name; Model.create must not hand those back for the new id.
+     */
+    static isOtherModelId(cachedId, requestedId) {
+        return !!requestedId && !!cachedId && cachedId !== requestedId;
+    }
     /**
      * Find a unique model name by checking for duplicates (case-insensitive) in the cache
      * If duplicates are found, appends an incrementing number to make it unique
@@ -1888,36 +2060,6 @@ class Model {
                 }
             }
         }
-        // Also check schema context models (case-insensitive)
-        // This ensures runtime-created models are renamed if they conflict with schema-defined models
-        try {
-            // Use lazy-loaded Schema class to avoid circular dependency
-            if (SchemaClass) {
-                const schema = SchemaClass.create(schemaName);
-                const schemaContext = schema.getService().getSnapshot().context;
-                if (schemaContext.models) {
-                    for (const schemaModelName of Object.keys(schemaContext.models)) {
-                        const lowerSchemaModelName = schemaModelName.toLowerCase();
-                        // If it matches the base name (case-insensitive), check if it has a number suffix
-                        if (lowerSchemaModelName === lowerModelName) {
-                            existingNumbers.add(0); // Base name exists in schema
-                        }
-                        else if (lowerSchemaModelName.startsWith(lowerModelName + ' ')) {
-                            // Check if it's the base name followed by a space and a number
-                            const suffix = lowerSchemaModelName.slice(lowerModelName.length + 1);
-                            const number = parseInt(suffix, 10);
-                            if (!isNaN(number) && suffix === number.toString()) {
-                                existingNumbers.add(number);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // If schema check fails, continue with cache-only check
-            // This is a best-effort check and shouldn't block model creation
-        }
         // If no duplicates found (no base name match and no numbered variants), return original name
         if (existingNumbers.size === 0) {
             return modelName;
@@ -1997,7 +2139,7 @@ class Model {
             if (this.instanceCache.has(legacyKey)) {
                 const { instance, refCount } = this.instanceCache.get(legacyKey);
                 const ctx = instance._getSnapshotContext();
-                if (!ctx._idFromSchema) {
+                if (!ctx._idFromSchema && !this.isOtherModelId(ctx.id, id)) {
                     this.instanceCache.set(legacyKey, {
                         instance,
                         refCount: refCount + 1,
@@ -2033,7 +2175,8 @@ class Model {
             : `${schemaName}:__pending__${resolvedId}`;
         // Step 6: Check legacy cache with unique name (backward compatibility during migration)
         // This is a fallback in case an instance was cached with a unique name
-        if (this.instanceCache.has(nameKey)) {
+        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,
@@ -2285,6 +2428,9 @@ class Model {
                             resolve();
                         }, 10000);
                     });
+                    // Unloaded or evicted (e.g. Schema.destroy) while it loaded: a stopped model never writes
+                    if (isActorStopped(proxiedInstance._service))
+                        return;
                     // Only write if validation passed (model is in idle state, not error)
                     const finalSnapshot = proxiedInstance._service.getSnapshot();
                     if (finalSnapshot.value === 'idle' && (!finalSnapshot.context._validationErrors || finalSnapshot.context._validationErrors.length === 0)) {
@@ -2408,15 +2554,20 @@ class Model {
                                 }
                                 logger(`WARNING: Could not verify schema exists in database: ${error}. Proceeding anyway.`);
                             }
-                            // Track pending write
-                            Model.trackPendingWrite(finalSnapshot.context.id, schemaId); // id is now the schemaFileId (string)
+                            const pendingModelFileId = finalSnapshot.context.id;
+                            const pendingSchemaId = schemaId;
                             // 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 () => {
+                                // Unloaded or evicted (e.g. Schema.destroy) before the write started: nothing to write to
+                                if (isActorStopped(proxiedInstance._service))
+                                    return;
                                 const currentSnapshot = proxiedInstance._service.getSnapshot();
                                 if (currentSnapshot.context.writeProcess) {
+                                    // Track pending write (only once it really starts: a stopped model leaves none behind)
+                                    Model.trackPendingWrite(pendingModelFileId, pendingSchemaId); // id is now the schemaFileId (string)
                                     logger(`Triggering write process for model "${finalSnapshot.context.modelName}" (schemaId: ${schemaId})`);
                                     // Use pending property definitions if available, otherwise convert from ModelProperty instances
                                     let propertiesObject = {};
@@ -2540,14 +2691,45 @@ class Model {
             }
             return this.getById(id);
         }
-        // If schemaName not provided, try to find in cache by searching all name keys
+        // 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. */
+    static _getUniqueCachedModel(label, matches) {
+        const matchesById = new Map(); // modelFileId -> schemaName
         for (const [nameKey, id] of this.instanceCacheByName.entries()) {
-            const [, cachedModelName] = nameKey.split(':');
-            if (cachedModelName === modelName) {
-                return this.getById(id);
+            const separator = nameKey.lastIndexOf(':');
+            const cachedModelName = nameKey.slice(separator + 1);
+            if (id && cachedModelName && matches(cachedModelName) && this.instanceCacheById.has(id)) {
+                matchesById.set(id, nameKey.slice(0, separator));
             }
         }
-        return undefined;
+        if (matchesById.size > 1) {
+            throw new AmbiguousModelError(label, [...matchesById.values()]);
+        }
+        const [matchId] = matchesById.keys();
+        return matchId ? this.getById(matchId) : undefined;
+    }
+    /**
+     * Resolve a cached Model from the most specific scope available: modelFileId (Model.id), then
+     * schemaName + modelName, then modelName alone.
+     */
+    static resolve(modelName, scope = {}) {
+        if (scope.modelFileId) {
+            const byId = this.getById(scope.modelFileId);
+            if (byId)
+                return byId;
+        }
+        if (!modelName)
+            return undefined;
+        if (scope.schemaName) {
+            const bySchema = this.getByName(modelName, scope.schemaName);
+            if (bySchema)
+                return bySchema;
+        }
+        return this.getByName(modelName);
     }
     /**
      * Find Model by modelType (snake_case from DB/metadata).
@@ -2556,14 +2738,7 @@ class Model {
     static findByModelType(modelType) {
         if (!modelType)
             return undefined;
-        for (const [nameKey, id] of this.instanceCacheByName.entries()) {
-            const parts = nameKey.split(':', 2);
-            const cachedModelName = parts[1];
-            if (cachedModelName && toSnakeCase(cachedModelName) === modelType) {
-                return this.getById(id);
-            }
-        }
-        return undefined;
+        return this._getUniqueCachedModel(modelType, (cachedModelName) => toSnakeCase(cachedModelName) === modelType);
     }
     /**
      * Get all Model instances for a schema from cache only (synchronous).
@@ -2595,6 +2770,54 @@ class Model {
         }
         return instances;
     }
+    /**
+     * 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.
+     */
+    static async resolveAsync(modelName, scope = {}) {
+        if (scope.modelFileId) {
+            const byId = this.getById(scope.modelFileId);
+            if (byId)
+                return byId;
+        }
+        if (modelName && scope.schemaName) {
+            const bySchema = this.getByName(modelName, scope.schemaName);
+            if (bySchema)
+                return bySchema;
+        }
+        if (scope.modelFileId || scope.schemaName) {
+            const db = BaseDb.getAppDb();
+            if (db) {
+                const evictionEpoch = currentEvictionEpoch();
+                try {
+                    const rows = await db
+                        .select({
+                        modelFileId: models.schemaFileId,
+                        modelName: models.name,
+                        schemaName: schemas.name,
+                    })
+                        .from(models)
+                        .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
+                        .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
+                        .where(scope.modelFileId
+                        ? eq(models.schemaFileId, scope.modelFileId)
+                        : and(eq(models.name, modelName ?? ''), eq(schemas.name, scope.schemaName)))
+                        .limit(1);
+                    const record = rows[0];
+                    if (record?.modelName && record.schemaName && record.modelFileId) {
+                        // Its schema was evicted while we read the row: don't bring the model back.
+                        if (schemaEvictedSince(record.schemaName, evictionEpoch))
+                            return undefined;
+                        return this.create(record.modelName, record.schemaName, { id: record.modelFileId });
+                    }
+                }
+                catch (error) {
+                    logger(`Model.resolveAsync: scoped lookup failed for "${modelName}": ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        return modelName ? this.getByNameAsync(modelName) : undefined;
+    }
     /**
      * Get Model instance by name, querying database if not in cache
      * This is an async version that can query the database when schemaName is not provided
@@ -2603,7 +2826,7 @@ class Model {
      * @param schemaName - Optional schema name (will query DB if not provided)
      * @returns The Model instance if found, undefined otherwise
      */
-    static async getByNameAsync(modelName, schemaName) {
+    static async getByNameAsync(modelName, schemaName, options) {
         // First try cache
         const cached = this.getByName(modelName, schemaName);
         if (cached) {
@@ -2615,8 +2838,16 @@ class Model {
             if (!db) {
                 return undefined;
             }
+            const evictionEpoch = options?.evictionEpoch ?? currentEvictionEpoch();
             try {
-                // Query model by name
+                // Query model by name (throws AmbiguousModelError when several schemas define it)
+                const _mod_9 = await import('./db-Lw0KVZmc.js');
+                const _ns_9 = _mod_9.Y;
+                const { resolveModelRecord } = _ns_9;
+                const resolved = await resolveModelRecord(modelName, {}, db);
+                if (!resolved?.schemaFileId) {
+                    return undefined;
+                }
                 const modelRecords = await db
                     .select({
                     modelFileId: models.schemaFileId,
@@ -2626,7 +2857,7 @@ class Model {
                     .from(models)
                     .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
                     .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
-                    .where(eq(models.name, modelName))
+                    .where(eq(models.id, resolved.id))
                     .limit(1);
                 if (modelRecords.length === 0) {
                     return undefined;
@@ -2635,12 +2866,18 @@ class Model {
                 if (!record.modelName || !record.schemaName || !record.modelFileId) {
                     return undefined;
                 }
+                // Its schema was evicted while we read the row: don't bring the model back.
+                if (schemaEvictedSince(record.schemaName, evictionEpoch)) {
+                    return undefined;
+                }
                 // Create model instance (will be cached)
                 return this.create(record.modelName, record.schemaName, {
                     id: record.modelFileId, // id is now the schemaFileId (string)
                 });
             }
             catch (error) {
+                if (error instanceof AmbiguousModelError)
+                    throw error;
                 logger(`Model.getByNameAsync: Error looking up model by name "${modelName}": ${error instanceof Error ? error.message : String(error)}`);
                 return undefined;
             }
@@ -2654,7 +2891,7 @@ class Model {
      * @param modelFileId - The model file ID to look up
      * @returns The Model instance if found, undefined otherwise
      */
-    static async createById(modelFileId) {
+    static async createById(modelFileId, options) {
         if (!modelFileId) {
             return undefined;
         }
@@ -2670,6 +2907,7 @@ class Model {
             logger(`Model.createById: Database not available for ID "${modelFileId}"`);
             return undefined;
         }
+        const evictionEpoch = options?.evictionEpoch ?? currentEvictionEpoch();
         try {
             // Query model by schemaFileId and join to get schema name
             const modelRecords = await db
@@ -2692,6 +2930,12 @@ class Model {
                 logger(`Model.createById: Missing modelName or schemaName for ID "${modelFileId}"`);
                 return undefined;
             }
+            // Its schema was evicted while we read the row (e.g. a Schema live query in flight during
+            // Schema.destroy or test cleanup): don't bring the model back.
+            if (schemaEvictedSince(schemaName, evictionEpoch)) {
+                logger(`Model.createById: schema "${schemaName}" was evicted during the lookup of "${modelFileId}"`);
+                return undefined;
+            }
             // Step 3: Create model using existing create method (which will handle caching)
             logger(`Model.createById: Creating model "${modelName}" in schema "${schemaName}" from ID "${modelFileId}"`);
             return this.create(modelName, schemaName, {
@@ -2746,6 +2990,7 @@ class Model {
             logger(`Model.createBySchemaId: Database not available for schema "${schemaIdentifier}"`);
             return [];
         }
+        const evictionEpoch = currentEvictionEpoch();
         try {
             // Query all models for this schema - support both schemaFileId and schema name
             const modelRecords = await db
@@ -2768,6 +3013,10 @@ class Model {
                 if (!record.modelName || !record.schemaName || !record.modelFileId) {
                     continue;
                 }
+                // Its schema was evicted while we read the rows: don't bring its models back.
+                if (schemaEvictedSince(record.schemaName, evictionEpoch)) {
+                    continue;
+                }
                 // Check cache first
                 const cached = this.getById(record.modelFileId);
                 if (cached) {
@@ -2846,9 +3095,10 @@ class Model {
         const instances = [];
         const seen = new Set();
         for (const row of rows) {
-            if (row.schemaFileId) {
+            // 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);
-                if (instance) {
+                if (instance && !seen.has(instance.id ?? row.schemaFileId)) {
                     instances.push(instance);
                     seen.add(instance.id ?? row.schemaFileId);
                 }
@@ -3206,6 +3456,52 @@ class Model {
             }, 10000);
         });
     }
+    /**
+     * Force-evict every cached Model belonging to a schema, ignoring refCounts, and stop their services.
+     * Used by Schema.destroy(): once the DB rows are gone, cached instances would keep a dangling _dbId
+     * and be handed back by Model.create/Model.all after the schema is re-imported.
+     * @returns names of the evicted models (so callers can evict their ModelProperty instances)
+     */
+    static evictForSchema(schemaName) {
+        // Work already running for this schema's models must not re-cache them when it finishes.
+        recordSchemaEviction(schemaName);
+        const instances = new Set();
+        for (const { instance } of this.instanceCacheById.values())
+            instances.add(instance);
+        for (const { instance } of this.instanceCache.values())
+            instances.add(instance);
+        const evictedNames = [];
+        for (const instance of instances) {
+            let context;
+            try {
+                context = instance._getSnapshotContext();
+            }
+            catch {
+                continue;
+            }
+            if (context.schemaName !== schemaName)
+                continue;
+            const nameKey = `${context.schemaName}:${context.modelName}`;
+            clearDestroySubscriptions(instance, { instanceState: modelInstanceState });
+            forceRemoveFromCaches(instance, {
+                getCacheKeys: () => (context.id ? [context.id, nameKey] : [nameKey]),
+                caches: [
+                    Model.instanceCacheById,
+                    Model.instanceCacheByName,
+                    Model.instanceCache,
+                ],
+            });
+            try {
+                instance._service.stop();
+            }
+            catch {
+                // Service might already be stopped
+            }
+            if (context.modelName)
+                evictedNames.push(context.modelName);
+        }
+        return evictedNames;
+    }
     /**
      * Unload the model instance and clean up resources
      */
@@ -3320,16 +3616,18 @@ class Model {
                         if (!db) {
                             return undefined;
                         }
-                        const modelRecords = await db
-                            .select()
-                            .from(models)
-                            .where(eq(models.name, modelName))
-                            .limit(1);
-                        if (modelRecords.length === 0 || !modelRecords[0].id) {
+                        // Model names are only unique per schema: find this model's row by its id (schemaFileId).
+                        const _mod_10 = await import('./db-Lw0KVZmc.js');
+                        const _ns_10 = _mod_10.Y;
+                        const { resolveModelRecord } = _ns_10;
+                        const modelRecord = await resolveModelRecord(modelName, { modelFileId: context.id, schemaName: context.schemaName }, db);
+                        if (!modelRecord?.id) {
                             return undefined;
                         }
-                        dbId = modelRecords[0].id;
-                        // Update context with _dbId
+                        dbId = modelRecord.id;
+                        // Update context with _dbId (unless the model was stopped while the lookup ran)
+                        if (isActorStopped(model._service))
+                            return undefined;
                         model._service.send({
                             type: 'updateContext',
                             _dbId: dbId,
@@ -3389,6 +3687,12 @@ class Model {
                     schemaFileId: row.schemaFileId,
                 }));
             },
+            // The model writes from its writeProcess child while itself idle; wait for that write to end.
+            canRetryEntityId: (model) => {
+                const writeProcess = model._getSnapshotContext().writeProcess;
+                const writeState = writeProcess?.getSnapshot().value;
+                return writeState !== 'validating' && writeState !== 'writing';
+            },
             instanceState: modelInstanceState,
             loggerName: 'seedSdk:model:liveQuery',
         });
@@ -3412,6 +3716,9 @@ class Model {
                 .select({ schemaFileId: properties.schemaFileId })
                 .from(properties)
                 .where(eq(properties.modelId, dbId)); // Use _dbId (database integer ID)
+            // Stopped while querying: don't re-cache ModelProperty instances for an evicted/unloaded model
+            if (isActorStopped(this._service))
+                return;
             const propertyIds = propertyRows
                 .map((row) => row.schemaFileId)
                 .filter((id) => id !== null && id !== undefined);
@@ -3446,7 +3753,10 @@ class Model {
                     logger(`[Model._refreshPropertiesFromDb] Error importing ModelProperty or creating instances: ${error}`);
                 }
             }
-            // Update context with refreshed property IDs AFTER creating instances
+            // Update context with refreshed property IDs AFTER creating instances (the awaits above can
+            // outlive the instance)
+            if (isActorStopped(this._service))
+                return;
             this._service.send({
                 type: 'updateContext',
                 _liveQueryPropertyIds: propertyIds,
@@ -3463,6 +3773,30 @@ class Model {
     async refreshProperties() {
         await this._refreshPropertiesFromDb();
     }
+    /**
+     * Refresh the property ids of every cached Model whose DB row is `dbId`. Called when a property
+     * write for that model finishes: until then `properties` includes it as a pending write, and in Node
+     * (no reactive liveQuery) nothing else adds it to `_liveQueryPropertyIds`.
+     */
+    static async refreshPropertiesForDbId(dbId) {
+        const instances = new Set();
+        for (const { instance } of this.instanceCacheById.values())
+            instances.add(instance);
+        for (const { instance } of this.instanceCache.values())
+            instances.add(instance);
+        for (const instance of instances) {
+            let context;
+            try {
+                context = instance._getSnapshotContext();
+            }
+            catch {
+                continue;
+            }
+            if (context._dbId !== dbId)
+                continue;
+            await instance._refreshPropertiesFromDb();
+        }
+    }
 }
 // Primary cache: ID-based (never changes on rename)
 Model.instanceCacheById = new Map();
@@ -3488,5 +3822,5 @@ var Model$1 = /*#__PURE__*/Object.freeze({
 const TModelValues = Type.Record(Type.String(), Type.Any());
 const TModelSchema = Type.Record(Type.String(), TProperty);
 
-export { ConflictError as C, Model as M, TModelSchema as T, TModelValues as a, Model$1 as b, setupEntityLiveQuery as s, writeProcessMachine as w };
-//# sourceMappingURL=index-HRHkbVQd.js.map
+export { ConflictError as C, Model as M, TModelSchema as T, TModelValues as a, anyEvictionSince as b, currentEvictionEpoch as c, setupEntityLiveQuery as d, writeToDatabase$1 as e, Model$1 as f, isActorStopped as i, schemaEvictedSince as s, writeProcessMachine as w };
+//# sourceMappingURL=index-Y-yYyRBf.js.map