@seedprotocol/sdk 0.7.3-next.654.g52217f6 → 0.7.3

package/dist/{index-s15q14rm.js → index-8O3Uow-Y.js}

@@ -1,11 +1,9 @@
 import { fromCallback, fromPromise, setup, assign, createActor } from 'xstate';
-import { B as BaseDb, i as models, p as properties, K as isInternalSchema, f as modelSchemas, s as schemas } from './BasePathResolver-CfSfMW5_.js';
+import { E as BaseDb, s as models, u as properties, $ as generateId, aF as isInternalSchema, aG as writeModelToDb, aH as writePropertyToDb, aI as addSchemaToDb, q as modelSchemas, z as schemas, F as AmbiguousModelError, aJ as renameModelInDb, a as TProperty } from './BasePathResolver-Cm4apKRb.js';
 import { eq, and, isNull, or } from 'drizzle-orm';
-import { j as generateId } from './tabEvents-DguZpCCv.js';
 import debug from 'debug';
-import { G as writeModelToDb, K as writePropertyToDb, O as addSchemaToDb, A as AmbiguousModelError, Q as renameModelInDb, d as TProperty } from './db-D9K_f5cF.js';
-import { k as waitForEntityIdle, V as getInvariantSafePropertyDescriptor, n as findEntity, C as ClientManagerState, I as Item, W as clearDestroySubscriptions, o as forceRemoveFromCaches, X as unloadEntity, q as runDestroyLifecycle } from './Item-C7sUUu2B.js';
-import { k as getClient } from './ClientManager-C-QXqUK9.js';
+import { n as waitForEntityIdle, D as DEFAULT_READY_TIMEOUT_MS, $ as getInvariantSafePropertyDescriptor, q as findEntity, C as ClientManagerState, I as Item, a0 as clearDestroySubscriptions, t as forceRemoveFromCaches, a1 as unloadEntity, u as runDestroyLifecycle } from './Item-DBFchXpC.js';
+import { k as getClient } from './ClientManager-i3nJASkg.js';
 import { modelPropertiesToObject } from './model-DGMe-TTm.js';
 import { toSnakeCase } from 'drizzle-orm/casing';
 import { Type } from '@sinclair/typebox';
@@ -37,7 +35,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await import('./ModelProperty-DJxeOOrc.js');
+        const mod = await import('./ModelProperty-BS49g01Y.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$7('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -103,11 +101,11 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context }, self })
                 if (!modelRecord) {
                     // Model names are only unique per schema: prefer this schema's row, and otherwise only
                     // consider same-name rows that no schema claims yet (never another schema's model).
-                    const _mod_0 = await import('./BasePathResolver-CfSfMW5_.js');
-                    const _ns_0 = _mod_0.R;
+                    const _mod_0 = await import('./BasePathResolver-Cm4apKRb.js');
+                    const _ns_0 = _mod_0.b0;
                     const { modelSchemas } = _ns_0;
-                    const _mod_1 = await import('./BasePathResolver-CfSfMW5_.js');
-                    const _ns_1 = _mod_1.Q;
+                    const _mod_1 = await import('./BasePathResolver-Cm4apKRb.js');
+                    const _ns_1 = _mod_1.a$;
                     const { schemas: schemasTable } = _ns_1;
                     let dbModels = await db
                         .select({
@@ -254,7 +252,7 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context }, self })
         // Step 2: Fallback to Schema context (only if database doesn't have the model)
         // This handles the case where model exists in schema file but not yet in database
         try {
-            const _mod_2 = await import('./Schema-fXtvd-yL.js');
+            const _mod_2 = await import('./Schema-CpMNEnUO.js');
             const _ns_2 = _mod_2.b;
             const schemaMod = _ns_2;
             const { Schema } = schemaMod;
@@ -405,12 +403,12 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context }, self })
                     }
                     // Also check database for models (in case they're persisted but not in Schema context)
                     if (db) {
-                        const _mod_3 = await import('./BasePathResolver-CfSfMW5_.js');
-                        const _ns_3 = _mod_3.R;
+                        const _mod_3 = await import('./BasePathResolver-Cm4apKRb.js');
+                        const _ns_3 = _mod_3.b0;
                         const modelSchemaSchemaMod = _ns_3;
                         const { modelSchemas } = modelSchemaSchemaMod;
-                        const _mod_4 = await import('./BasePathResolver-CfSfMW5_.js');
-                        const _ns_4 = _mod_4.Q;
+                        const _mod_4 = await import('./BasePathResolver-Cm4apKRb.js');
+                        const _ns_4 = _mod_4.a$;
                         const schemaSchemaMod = _ns_4;
                         const { schemas: schemasTable } = schemaSchemaMod;
                         // Query all models for this schema to check for duplicates (case-insensitive)
@@ -505,7 +503,7 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context }, self })
         }
         // Mark schema as draft when a new model is created so saveNewVersion() can persist it
         try {
-            const _mod_5 = await import('./Schema-fXtvd-yL.js');
+            const _mod_5 = await import('./Schema-CpMNEnUO.js');
             const _ns_5 = _mod_5.b;
             const schemaMod = _ns_5;
             const { Schema } = schemaMod;
@@ -553,10 +551,10 @@ const validateModel = fromCallback(({ sendBack, input: { context }, self }) => {
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await import('./SchemaValidationService-CvRS2HSO.js');
+            const validationServiceMod = await import('./SchemaValidationService-DieV4KL-.js');
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const _mod_6 = await import('./Schema-fXtvd-yL.js');
+            const _mod_6 = await import('./Schema-CpMNEnUO.js');
             const _ns_6 = _mod_6.b;
             const schemaMod = _ns_6;
             const { Schema } = schemaMod;
@@ -675,7 +673,7 @@ const createModelProperties = fromCallback(({ sendBack, input, self }) => {
             return;
         }
         logger$5(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await import('./ModelProperty-DJxeOOrc.js');
+        const mod = await import('./ModelProperty-BS49g01Y.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$5('ModelProperty not available from dynamic import');
@@ -700,8 +698,8 @@ const createModelProperties = fromCallback(({ sendBack, input, self }) => {
                 : undefined;
             // Otherwise use provided ID or generate a random one
             // IDs should be generated in the import process before creating properties
-            const _mod_7 = await import('./tabEvents-DguZpCCv.js');
-            const _ns_7 = _mod_7.Z;
+            const _mod_7 = await import('./BasePathResolver-Cm4apKRb.js');
+            const _ns_7 = _mod_7.b4;
             const { generateId } = _ns_7;
             const propertyFileId = propData.id || propertyRecord?.schemaFileId || generateId();
             logger$5(`Creating property "${propName}" with fileId "${propertyFileId}"`);
@@ -718,8 +716,8 @@ const createModelProperties = fromCallback(({ sendBack, input, self }) => {
                     }
                     else if (refModelName) {
                         // Fallback: resolve the ref by name within this model's schema
-                        const _mod_8 = await import('./db-D9K_f5cF.js');
-                        const _ns_8 = _mod_8.Y;
+                        const _mod_8 = await import('./BasePathResolver-Cm4apKRb.js');
+                        const _ns_8 = _mod_8.b1;
                         const { resolveModelRecord } = _ns_8;
                         const refModelRecord = await resolveModelRecord(refModelName, { schemaName }, db);
                         if (refModelRecord?.id) {
@@ -819,7 +817,7 @@ const validateEntity = fromPromise(async ({ input }) => {
     const evictionEpoch = currentEvictionEpoch();
     /** The schema to validate against; throws (validation then skips the schema check) once it was evicted. */
     const schemaForValidation = async (schemaName) => {
-        const _mod_9 = await import('./Schema-fXtvd-yL.js');
+        const _mod_9 = await import('./Schema-CpMNEnUO.js');
         const _ns_9 = _mod_9.b;
         const { Schema } = _ns_9;
         if (schemaEvictedSince(schemaName, evictionEpoch)) {
@@ -837,7 +835,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                 const structureMsg = `[validateEntity] Validating model structure`;
                 logger$4(structureMsg);
                 // Use existing Model validation
-                const validationServiceMod = await import('./SchemaValidationService-CvRS2HSO.js');
+                const validationServiceMod = await import('./SchemaValidationService-DieV4KL-.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
@@ -887,7 +885,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const validationServiceMod = await import('./SchemaValidationService-CvRS2HSO.js');
+                const validationServiceMod = await import('./SchemaValidationService-DieV4KL-.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -927,7 +925,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'schema') {
                 // Schema validation - use existing validation
-                const validationServiceMod = await import('./SchemaValidationService-CvRS2HSO.js');
+                const validationServiceMod = await import('./SchemaValidationService-DieV4KL-.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
@@ -1016,7 +1014,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-DJxeOOrc.js');
+                    const mod = await import('./ModelProperty-BS49g01Y.js');
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -1410,7 +1408,7 @@ const modelMachine = setup({
                                 // Create ModelProperty instances for any new property IDs
                                 if (Array.isArray(newPropertyIds) && newPropertyIds.length > 0) {
                                     // Import and create instances asynchronously (fire-and-forget)
-                                    import('./ModelProperty-DJxeOOrc.js').then(({ ModelProperty }) => {
+                                    import('./ModelProperty-BS49g01Y.js').then(({ ModelProperty }) => {
                                         if (self.getSnapshot().status === 'stopped')
                                             return;
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
@@ -1915,7 +1913,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-DJxeOOrc.js')
+const modelPropertyImportPromise = import('./ModelProperty-BS49g01Y.js')
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -1930,13 +1928,13 @@ function getModelProperty() {
     // and the getter will return empty array, which matches the original behavior
     return ModelPropertyClass;
 }
-// Lazy import for Schema to avoid circular dependency
-const schemaImportPromise = (async () => { const _mod_12 = await import('./Schema-fXtvd-yL.js'); return _mod_12.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();
+// Settles once the properties passed to Model.create exist, or rejects when they can't be created.
+// The model reaches idle before its write, so idle alone doesn't mean they exist yet. Keyed by the
+// actor because callers hold the proxy, not the instance.
+const pendingPropertyCreation = new WeakMap();
 // Define tracked properties for the Proxy
 // These properties will be read from/written to the actor context
 const TRACKED_PROPERTIES = [
@@ -1995,6 +1993,34 @@ class Model {
         });
         // Note: Property getters/setters are now handled by the Proxy in create()
     }
+    /**
+     * Resolves once the model is idle and any properties passed to Model.create exist.
+     * Rejects if it errors, times out, or its properties can't be created.
+     */
+    static async waitUntilReady(instance, timeout) {
+        const startedAt = Date.now();
+        await waitForEntityIdle(instance, { timeout });
+        const propertyCreation = pendingPropertyCreation.get(instance.getService());
+        if (!propertyCreation)
+            return instance;
+        const remaining = Math.max(0, timeout - (Date.now() - startedAt));
+        let timer;
+        try {
+            await Promise.race([
+                propertyCreation,
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => {
+                        const modelName = instance.getService().getSnapshot().context.modelName;
+                        reject(new Error(`Model "${modelName}" did not finish creating its properties within ${timeout}ms`));
+                    }, remaining);
+                }),
+            ]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        return instance;
+    }
     /**
      * 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
@@ -2080,7 +2106,7 @@ class Model {
             throw new Error('Model name is required');
         }
         const waitForReady = options?.waitForReady !== false;
-        const readyTimeout = options?.readyTimeout ?? 5000;
+        const readyTimeout = options?.readyTimeout ?? DEFAULT_READY_TIMEOUT_MS;
         // Extract schema name and instance
         let schemaName;
         let schemaInstance; // Using any to avoid circular dependency with Schema
@@ -2107,7 +2133,7 @@ class Model {
             logger(`Model.create: Found instance in ID cache for "${modelName}" (ID: ${id})`);
             if (!waitForReady)
                 return instance;
-            return waitForEntityIdle(instance, { timeout: readyTimeout }).then(() => instance);
+            return this.waitUntilReady(instance, readyTimeout);
         }
         // Step 2: Check for duplicate names and generate unique name if needed (before checking cache)
         // This allows us to create new models with renamed versions when duplicates exist
@@ -2153,7 +2179,7 @@ class Model {
                     }
                     if (!waitForReady)
                         return instance;
-                    return waitForEntityIdle(instance, { timeout: readyTimeout }).then(() => instance);
+                    return this.waitUntilReady(instance, readyTimeout);
                 }
             }
         }
@@ -2193,7 +2219,7 @@ class Model {
             }
             if (!waitForReady)
                 return instance;
-            return waitForEntityIdle(instance, { timeout: readyTimeout }).then(() => instance);
+            return this.waitUntilReady(instance, readyTimeout);
         }
         // Step 7: Create new instance with id in initial context
         // This ensures loadOrCreateModel sees the ID immediately
@@ -2207,6 +2233,32 @@ class Model {
         if (options?.properties) {
             logger(`[Model.create] Created instance with _pendingPropertyDefinitions in initial context (${Object.keys(options.properties).length} properties) for model "${uniqueModelName}"`);
         }
+        // Called by the write trigger below when the properties will never be created
+        let failPropertyCreation = () => { };
+        if (options?.properties && Object.keys(options.properties).length > 0) {
+            const service = newInstance.getService();
+            const propertyCreation = new Promise((resolve, reject) => {
+                const subscription = service.subscribe({
+                    next: (snapshot) => {
+                        if (snapshot.value === 'idle' && !snapshot.context._pendingPropertyDefinitions) {
+                            subscription.unsubscribe();
+                            resolve();
+                        }
+                        else if (snapshot.value === 'error') {
+                            failPropertyCreation('the model is in an error state');
+                        }
+                    },
+                    complete: () => failPropertyCreation('the model was unloaded'),
+                });
+                failPropertyCreation = (reason) => {
+                    subscription.unsubscribe();
+                    reject(new Error(`Model "${service.getSnapshot().context.modelName}" could not create its properties: ${reason}`));
+                };
+            });
+            // Only waitUntilReady reports this; without waitForReady nobody awaits it
+            propertyCreation.catch(() => { });
+            pendingPropertyCreation.set(service, propertyCreation);
+        }
         // Step 7: Set initial model data if provided
         // Note: description is not supported - JSON files can have it but we ignore it at runtime
         if (options) {
@@ -2430,8 +2482,10 @@ class Model {
                         }, 10000);
                     });
                     // Unloaded or evicted (e.g. Schema.destroy) while it loaded: a stopped model never writes
-                    if (isActorStopped(proxiedInstance._service))
+                    if (isActorStopped(proxiedInstance._service)) {
+                        failPropertyCreation('the model was unloaded');
                         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)) {
@@ -2526,6 +2580,7 @@ class Model {
                                 _dbId: schemaInstance ? schemaInstance._getSnapshotContext()._dbId : 'N/A',
                                 schemaName: schemaName || 'N/A',
                             });
+                            failPropertyCreation(`its schema "${schemaName}" was not found in the database`);
                         }
                         else if (finalSnapshot.context.id) {
                             // Verify schema exists in database before proceeding (additional safety check)
@@ -2563,8 +2618,10 @@ class Model {
                             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))
+                                if (isActorStopped(proxiedInstance._service)) {
+                                    failPropertyCreation('the model was unloaded');
                                     return;
+                                }
                                 const currentSnapshot = proxiedInstance._service.getSnapshot();
                                 if (currentSnapshot.context.writeProcess) {
                                     // Track pending write (only once it really starts: a stopped model leaves none behind)
@@ -2619,6 +2676,7 @@ class Model {
                                                 logger(`Write process failed for model "${finalSnapshot.context.modelName}": ${errorContext.error?.message || 'Unknown error'}`);
                                                 logger(`Write process error details:`, errorContext.error);
                                                 logger(`Validation errors:`, errorContext.validationErrors);
+                                                failPropertyCreation(`writing the model failed: ${errorContext.error?.message || 'Unknown error'}`);
                                             }
                                         });
                                     }
@@ -2639,6 +2697,7 @@ class Model {
                                 }
                                 else {
                                     logger(`ERROR: writeProcess not available after ${maxRetries} retries for model "${finalSnapshot.context.modelName}"`);
+                                    failPropertyCreation('its write process never started');
                                 }
                             };
                             // Start checking immediately, but also allow time for entry action to complete
@@ -2646,20 +2705,23 @@ class Model {
                         }
                         else {
                             logger(`Cannot trigger write process: missing schemaId (${schemaId}) or id (${finalSnapshot.context.id})`);
+                            failPropertyCreation('it has no id');
                         }
                     }
                     else {
                         logger(`Model validation failed or model in error state, skipping write process`);
+                        failPropertyCreation('the model failed validation');
                     }
                 }
                 catch (error) {
                     logger(`Failed to trigger write process: ${error instanceof Error ? error.message : String(error)}`);
+                    failPropertyCreation(error instanceof Error ? error.message : String(error));
                 }
             });
         }
         if (!waitForReady)
             return proxiedInstance;
-        return waitForEntityIdle(proxiedInstance, { timeout: readyTimeout }).then(() => proxiedInstance);
+        return this.waitUntilReady(proxiedInstance, readyTimeout);
     }
     /**
      * Get Model instance by modelFileId (O(1) lookup)
@@ -2842,8 +2904,8 @@ class Model {
             const evictionEpoch = options?.evictionEpoch ?? currentEvictionEpoch();
             try {
                 // Query model by name (throws AmbiguousModelError when several schemas define it)
-                const _mod_10 = await import('./db-D9K_f5cF.js');
-                const _ns_10 = _mod_10.Y;
+                const _mod_10 = await import('./BasePathResolver-Cm4apKRb.js');
+                const _ns_10 = _mod_10.b1;
                 const { resolveModelRecord } = _ns_10;
                 const resolved = await resolveModelRecord(modelName, {}, db);
                 if (!resolved?.schemaFileId) {
@@ -2954,7 +3016,7 @@ class Model {
      * @param options - Find options including lookup parameters and wait configuration
      * @returns Model instance if found, undefined otherwise
      */
-    static async find({ modelFileId, modelName, schemaName, waitForReady = true, readyTimeout = 5000, }) {
+    static async find({ modelFileId, modelName, schemaName, waitForReady = true, readyTimeout = DEFAULT_READY_TIMEOUT_MS, }) {
         return await findEntity({
             getById: (id) => Model.getById(id),
             createById: (id) => Model.createById(id),
@@ -3043,10 +3105,11 @@ class Model {
     /**
      * Get all Model instances, optionally filtered by schema.
      * When DB is available, loads from DB via getModelsData; otherwise returns from cache.
-     * Supports waitForReady to wait for each model to reach idle state before returning.
+     * With waitForReady, waits for each model to be ready (idle, with any properties from Model.create
+     * created) and leaves out models that error or time out.
      */
     static async all(schemaName, options) {
-        const { waitForReady = false, readyTimeout = 5000 } = options ?? {};
+        const { waitForReady = false, readyTimeout = DEFAULT_READY_TIMEOUT_MS } = options ?? {};
         const appDb = BaseDb.getAppDb();
         if (!appDb) {
             const instances = [];
@@ -3130,11 +3193,13 @@ class Model {
             }
         }
         if (waitForReady && instances.length > 0) {
-            await Promise.all(instances.map((m) => waitForEntityIdle(m, {
-                timeout: readyTimeout,
-                throwOnError: false,
+            // Leave out models that errored or didn't get ready in time. Don't re-read their state afterwards:
+            // a ready model can already be validating again, and it still belongs in the result.
+            const ready = await Promise.all(instances.map((m) => this.waitUntilReady(m, readyTimeout).then(() => true, (error) => {
+                logger(`Model.all: leaving out a model that isn't ready: ${error instanceof Error ? error.message : String(error)}`);
+                return false;
             })));
-            return instances.filter((m) => m._getSnapshot?.().value === 'idle');
+            return instances.filter((_, i) => ready[i]);
         }
         return instances;
     }
@@ -3573,6 +3638,8 @@ class Model {
                         .limit(1);
                     if (modelRecords.length > 0) {
                         const modelId = modelRecords[0].id;
+                        const { detachModelRows } = await import('./detachRowsBeforeDelete-S0q-DJPT.js');
+                        await detachModelRows(db, [typeof modelId === 'string' ? parseInt(modelId, 10) : modelId]);
                         await db.delete(modelSchemas).where(eq(modelSchemas.modelId, modelId));
                         await db
                             .delete(properties)
@@ -3581,9 +3648,10 @@ class Model {
                     }
                 }
                 if (schemaName && modelName) {
-                    const Schema = await schemaImportPromise;
-                    if (!Schema)
-                        throw new Error('Schema not loaded');
+                    // Imported here, not at module load: Model and Schema import each other.
+                    const _mod_11 = await import('./Schema-CpMNEnUO.js');
+                    const _ns_11 = _mod_11.b;
+                    const { Schema } = _ns_11;
                     const schema = Schema.create(schemaName, { waitForReady: false });
                     const schemaContext = schema.getService().getSnapshot().context;
                     if (schemaContext.models?.[modelName]) {
@@ -3618,9 +3686,9 @@ class Model {
                             return undefined;
                         }
                         // Model names are only unique per schema: find this model's row by its id (schemaFileId).
-                        const _mod_11 = await import('./db-D9K_f5cF.js');
-                        const _ns_11 = _mod_11.Y;
-                        const { resolveModelRecord } = _ns_11;
+                        const _mod_12 = await import('./BasePathResolver-Cm4apKRb.js');
+                        const _ns_12 = _mod_12.b1;
+                        const { resolveModelRecord } = _ns_12;
                         const modelRecord = await resolveModelRecord(modelName, { modelFileId: context.id, schemaName: context.schemaName }, db);
                         if (!modelRecord?.id) {
                             return undefined;
@@ -3824,4 +3892,4 @@ 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, 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-s15q14rm.js.map
+//# sourceMappingURL=index-8O3Uow-Y.js.map