@seedprotocol/sdk 0.7.5 → 0.7.6-next.957.g6bb7768

package/dist/{errors-CIrbsN_i.js → errors-3tc6XkCB.js}

@@ -1,9 +1,9 @@
 import { fromCallback, fromPromise, setup, assign, createActor } from 'xstate';
-import { B as BaseDb, t as models, v as properties, al as generateId, aK as isInternalSchema, aL as writeModelToDb, aM as writePropertyToDb, aN as addSchemaToDb, r as modelSchemas, A as schemas, H as AmbiguousModelError, aO as renameModelInDb, aP as currentNameMatchLevels, a as TProperty } from './BasePathResolver-CBTXCMFL.js';
+import { B as BaseDb, t as models, v as properties, ai as generateId, aJ as isInternalSchema, aK as writeModelToDb, aL as writePropertyToDb, aM as addSchemaToDb, r as modelSchemas, A as schemas, H as AmbiguousModelError, aN as renameModelInDb, aO as currentNameMatchLevels, a as TProperty } from './index-CrvIcVFJ.js';
 import { eq, and, isNull, or } from 'drizzle-orm';
 import debug from 'debug';
-import { d as waitForEntityIdle, D as DEFAULT_READY_TIMEOUT_MS, Z as getInvariantSafePropertyDescriptor, n as findEntity, C as ClientManagerState, I as Item, _ as clearDestroySubscriptions, o as forceRemoveFromCaches, $ as unloadEntity, q as runDestroyLifecycle } from './Item-DTJPMjFk.js';
-import { m as getClient } from './ClientManager-DRf4uuei.js';
+import { d as waitForEntityIdle, D as DEFAULT_READY_TIMEOUT_MS, Z as getInvariantSafePropertyDescriptor, n as findEntity, C as ClientManagerState, I as Item, _ as clearDestroySubscriptions, o as forceRemoveFromCaches, $ as unloadEntity, q as runDestroyLifecycle } from './Item-B1MH0tXx.js';
+import { m as getClient } from './ClientManager-D6YA20jP.js';
 import { modelPropertiesToObject } from './model-oHA3YhOd.js';
 import { localNamesInBestMatchTier } from '@seedprotocol/eas';
 import { Type } from '@sinclair/typebox';
@@ -35,7 +35,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await import('./ModelProperty-Dto5C0om.js');
+        const mod = await import('./ModelProperty-Dw6dHdu_.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$7('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -101,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-CBTXCMFL.js');
-                    const _ns_0 = _mod_0.be;
+                    const _mod_0 = await import('./index-CrvIcVFJ.js');
+                    const _ns_0 = _mod_0.bg;
                     const { modelSchemas } = _ns_0;
-                    const _mod_1 = await import('./BasePathResolver-CBTXCMFL.js');
-                    const _ns_1 = _mod_1.bd;
+                    const _mod_1 = await import('./index-CrvIcVFJ.js');
+                    const _ns_1 = _mod_1.bf;
                     const { schemas: schemasTable } = _ns_1;
                     let dbModels = await db
                         .select({
@@ -252,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-8DxGcORY.js');
+            const _mod_2 = await import('./Schema-DppObO6h.js');
             const _ns_2 = _mod_2.b;
             const schemaMod = _ns_2;
             const { Schema } = schemaMod;
@@ -403,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-CBTXCMFL.js');
-                        const _ns_3 = _mod_3.be;
+                        const _mod_3 = await import('./index-CrvIcVFJ.js');
+                        const _ns_3 = _mod_3.bg;
                         const modelSchemaSchemaMod = _ns_3;
                         const { modelSchemas } = modelSchemaSchemaMod;
-                        const _mod_4 = await import('./BasePathResolver-CBTXCMFL.js');
-                        const _ns_4 = _mod_4.bd;
+                        const _mod_4 = await import('./index-CrvIcVFJ.js');
+                        const _ns_4 = _mod_4.bf;
                         const schemaSchemaMod = _ns_4;
                         const { schemas: schemasTable } = schemaSchemaMod;
                         // Query all models for this schema to check for duplicates (case-insensitive)
@@ -503,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-8DxGcORY.js');
+            const _mod_5 = await import('./Schema-DppObO6h.js');
             const _ns_5 = _mod_5.b;
             const schemaMod = _ns_5;
             const { Schema } = schemaMod;
@@ -551,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-CE92y1TT.js');
+            const validationServiceMod = await import('./SchemaValidationService-DXQ-D531.js');
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const _mod_6 = await import('./Schema-8DxGcORY.js');
+            const _mod_6 = await import('./Schema-DppObO6h.js');
             const _ns_6 = _mod_6.b;
             const schemaMod = _ns_6;
             const { Schema } = schemaMod;
@@ -673,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-Dto5C0om.js');
+        const mod = await import('./ModelProperty-Dw6dHdu_.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$5('ModelProperty not available from dynamic import');
@@ -698,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('./BasePathResolver-CBTXCMFL.js');
-            const _ns_7 = _mod_7.bi;
+            const _mod_7 = await import('./index-CrvIcVFJ.js');
+            const _ns_7 = _mod_7.bk;
             const { generateId } = _ns_7;
             const propertyFileId = propData.id || propertyRecord?.schemaFileId || generateId();
             logger$5(`Creating property "${propName}" with fileId "${propertyFileId}"`);
@@ -716,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('./BasePathResolver-CBTXCMFL.js');
-                        const _ns_8 = _mod_8.bf;
+                        const _mod_8 = await import('./index-CrvIcVFJ.js');
+                        const _ns_8 = _mod_8.bh;
                         const { resolveModelRecord } = _ns_8;
                         const refModelRecord = await resolveModelRecord(refModelName, { schemaName }, db);
                         if (refModelRecord?.id) {
@@ -887,7 +887,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-8DxGcORY.js');
+        const _mod_9 = await import('./Schema-DppObO6h.js');
         const _ns_9 = _mod_9.b;
         const { Schema } = _ns_9;
         if (schemaEvictedSince(schemaName, evictionEpoch)) {
@@ -905,7 +905,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                 const structureMsg = `[validateEntity] Validating model structure`;
                 logger$4(structureMsg);
                 // Use existing Model validation
-                const validationServiceMod = await import('./SchemaValidationService-CE92y1TT.js');
+                const validationServiceMod = await import('./SchemaValidationService-DXQ-D531.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
@@ -955,7 +955,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const validationServiceMod = await import('./SchemaValidationService-CE92y1TT.js');
+                const validationServiceMod = await import('./SchemaValidationService-DXQ-D531.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -995,7 +995,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'schema') {
                 // Schema validation - use existing validation
-                const validationServiceMod = await import('./SchemaValidationService-CE92y1TT.js');
+                const validationServiceMod = await import('./SchemaValidationService-DXQ-D531.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
@@ -1084,7 +1084,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-Dto5C0om.js');
+                    const mod = await import('./ModelProperty-Dw6dHdu_.js');
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -1478,7 +1478,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-Dto5C0om.js').then(({ ModelProperty }) => {
+                                    import('./ModelProperty-Dw6dHdu_.js').then(({ ModelProperty }) => {
                                         if (self.getSnapshot().status === 'stopped')
                                             return;
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
@@ -1844,7 +1844,15 @@ function setupEntityLiveQuery(instance, config) {
                         if (isActorStopped(instance.getService()))
                             return;
                         if (config.createChildInstances && ids.length > 0) {
-                            await config.createChildInstances(ids);
+                            // Nothing awaits this handler, so a child that fails to load (its row deleted while it
+                            // loads, say) would be an unhandled rejection. Skip this result; a later one tries again.
+                            try {
+                                await config.createChildInstances(ids);
+                            }
+                            catch (error) {
+                                logger(`createChildInstances failed: ${error}`);
+                                return;
+                            }
                         }
                         // Update context with new IDs
                         if (isActorStopped(instance.getService()))
@@ -2004,7 +2012,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-Dto5C0om.js')
+const modelPropertyImportPromise = import('./ModelProperty-Dw6dHdu_.js')
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -2112,6 +2120,30 @@ class Model {
         }
         return instance;
     }
+    /**
+     * Gives an idle, valid model the row someone else wrote for its id, the way its own write would
+     * (writeSuccess with the row's id, which goes on to create its properties from their rows).
+     * Returns false when there is no such row, so the model writes it.
+     */
+    static async adoptPersistedRow(instance) {
+        const snapshot = instance.getService().getSnapshot();
+        if (snapshot.value !== 'idle' || snapshot.context._validationErrors?.length || !snapshot.context.id) {
+            return false;
+        }
+        const db = BaseDb.getAppDb();
+        if (!db)
+            return false;
+        const [row] = await db
+            .select({ id: models.id })
+            .from(models)
+            .where(eq(models.schemaFileId, snapshot.context.id))
+            .limit(1);
+        if (!row || isActorStopped(instance.getService()))
+            return false;
+        logger(`Model "${snapshot.context.modelName}" adopts model row ${row.id} written by its schema import`);
+        instance.getService().send({ type: 'writeSuccess', output: { _dbId: row.id } });
+        return true;
+    }
     /**
      * 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
@@ -2571,11 +2603,18 @@ class Model {
                             }
                         });
                     });
+                    // The caller writes this model's rows; wait for that so two writers don't write them at once
+                    if (options?.persistedBy) {
+                        await options.persistedBy.catch(() => { });
+                    }
                     // Unloaded or evicted (e.g. Schema.destroy) while it loaded: a stopped model never writes
                     if (isActorStopped(proxiedInstance._service)) {
                         failPropertyCreation('the model was unloaded');
                         return;
                     }
+                    if (options?.persistedBy && (await Model.adoptPersistedRow(proxiedInstance))) {
+                        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)) {
@@ -3002,8 +3041,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('./BasePathResolver-CBTXCMFL.js');
-                const _ns_10 = _mod_10.bf;
+                const _mod_10 = await import('./index-CrvIcVFJ.js');
+                const _ns_10 = _mod_10.bh;
                 const { resolveModelRecord } = _ns_10;
                 const resolved = await resolveModelRecord(modelName, {}, db);
                 if (!resolved?.schemaFileId) {
@@ -3756,7 +3795,7 @@ class Model {
                         .limit(1);
                     if (modelRecords.length > 0) {
                         const modelId = modelRecords[0].id;
-                        const { detachModelRows } = await import('./detachRowsBeforeDelete-BVetHtn2.js');
+                        const { detachModelRows } = await import('./detachRowsBeforeDelete-CtmIFpgV.js');
                         await detachModelRows(db, [typeof modelId === 'string' ? parseInt(modelId, 10) : modelId]);
                         await db.delete(modelSchemas).where(eq(modelSchemas.modelId, modelId));
                         await db
@@ -3767,7 +3806,7 @@ class Model {
                 }
                 if (schemaName && modelName) {
                     // Imported here, not at module load: Model and Schema import each other.
-                    const _mod_11 = await import('./Schema-8DxGcORY.js');
+                    const _mod_11 = await import('./Schema-DppObO6h.js');
                     const _ns_11 = _mod_11.b;
                     const { Schema } = _ns_11;
                     const schema = Schema.create(schemaName, { waitForReady: false });
@@ -3811,13 +3850,19 @@ class Model {
                             return undefined;
                         }
                         // Model names are only unique per schema: find this model's row by its id (schemaFileId).
-                        const _mod_12 = await import('./BasePathResolver-CBTXCMFL.js');
-                        const _ns_12 = _mod_12.bf;
+                        const _mod_12 = await import('./index-CrvIcVFJ.js');
+                        const _ns_12 = _mod_12.bh;
                         const { resolveModelRecord } = _ns_12;
                         const modelRecord = await resolveModelRecord(modelName, { modelFileId: context.id, schemaName: context.schemaName }, db);
                         if (!modelRecord?.id) {
                             return undefined;
                         }
+                        // Until this model's own row is written, the lookup falls back to the name and can find a
+                        // same-named model in another schema. Taking that row would load its properties into this
+                        // model; wait for the row with this model's id instead (the caller retries).
+                        if (context.id && modelRecord.schemaFileId !== context.id) {
+                            return undefined;
+                        }
                         dbId = modelRecord.id;
                         // Update context with _dbId (unless the model was stopped while the lookup ran)
                         if (isActorStopped(model._service))
@@ -4049,4 +4094,4 @@ var errors = /*#__PURE__*/Object.freeze({
 });
 
 export { ConflictError as C, ItemCreateValidationError as I, Model as M, TModelSchema as T, UnknownModelError as U, TModelValues as a, anyEvictionSince as b, currentEvictionEpoch as c, setupEntityLiveQuery as d, writeToDatabase$1 as e, finishSchemaDestroy as f, getDraftSaveError as g, Model$1 as h, isActorStopped as i, errors as j, recordSchemaDestroy as r, schemaEvictedSince as s, trackDraftSave as t, writeProcessMachine as w };
-//# sourceMappingURL=errors-CIrbsN_i.js.map
+//# sourceMappingURL=errors-3tc6XkCB.js.map