@seedprotocol/sdk 0.7.9 → 0.7.10-next.1353.g74aeeed

package/dist/{ModelProperty-BlaEgb_U.js → ModelProperty-D2vJozmW.js}

@@ -1,14 +1,14 @@
 import { fromCallback, setup, assign, createActor, waitFor } from 'xstate';
-import { M as Model, F as saveDefinition } from './errors-DLSoqSHG.js';
-import { r as resolveModelRecord, n as normalizeDataType, m as generateId, a2 as definitionOnlyFields, a3 as persistDefinitionFields, a4 as getPropertyDefinition, a5 as propertyDefinitionFromRow, M as ModelPropertyDataTypes, a6 as setCachedPropertyRefresher } from './tabEvents-CaVmngqr.js';
+import { M as Model, F as saveDefinition } from './errors-CnT0fSMK.js';
+import { r as resolveModelRecord, n as normalizeDataType, m as generateId, a2 as definitionOnlyFields, a3 as persistDefinitionFields, a4 as getPropertyDefinition, a5 as propertyDefinitionFromRow, M as ModelPropertyDataTypes, a6 as addCachedPropertyRefresher } from './tabEvents-DT5ez6io.js';
 import 'pluralize';
 import '@seedprotocol/eas';
-import { B as BaseDb, d as models, l as properties, t as schemas, j as modelSchemas, w as BaseFileManager } from './BaseFileManager-BAlySv8w.js';
-import { aj as isActorStopped, T as applyContextUpdate, U as isInternalUpdate, ak as differsFromOriginals, V as evictionLog, a7 as modelPropertiesToObject, Z as DEFAULT_READY_TIMEOUT_MS, _ as waitForEntityReady, $ as createReactiveProxy, al as onEntityTeardown, a0 as runEntityLoad, W as holdChild, a2 as entityStatus, a1 as evictEntities, a3 as releaseEntity, a4 as destroyEntity, a5 as EntityCache } from './Item-Bf4kWKpH.js';
+import { B as BaseDb, d as models, l as properties, t as schemas, j as modelSchemas, w as BaseFileManager } from './BaseFileManager-DLou1TZS.js';
+import { ak as isActorStopped, T as applyContextUpdate, U as isInternalUpdate, al as differsFromOriginals, V as evictionLog, a8 as modelPropertiesToObject, Z as DEFAULT_READY_TIMEOUT_MS, _ as createReactiveProxy, am as onEntityTeardown, $ as runEntityLoad, a0 as waitForEntityReady, W as holdChild, X as isEntityTornDown, a2 as EntityUnloadedError, a3 as entityStatus, a1 as evictEntities, a4 as releaseEntity, a5 as destroyEntity, a6 as EntityCache } from './Item-oPnmIehk.js';
 import debug from 'debug';
 import '@seedprotocol/arweave';
 import { eq, and, inArray } from 'drizzle-orm';
-import { S as Schema } from './Schema-J_1f6p0c.js';
+import { S as Schema } from './Schema-BMXRF4j9.js';
 import '@sinclair/typebox';
 import 'lodash-es';
 import '@noble/hashes/sha3';
@@ -19,7 +19,7 @@ import 'nanoid';
 import 'nanoid-dictionary';
 import '@noble/hashes/sha256';
 import 'rxjs';
-import './SchemaValidationService-CnmKyzR-.js';
+import './SchemaValidationService-CieGrj5c.js';
 import '@sinclair/typebox/value';
 
 const logger$3 = debug('seedSdk:modelProperty:actors:saveToSchema');
@@ -30,14 +30,14 @@ const logger$3 = debug('seedSdk:modelProperty:actors:saveToSchema');
  */
 async function getSchemaNameFromModel(modelName) {
     // Get the latest schema files and find which one contains this model
-    const _mod_0 = await import('./errors-DLSoqSHG.js');
+    const _mod_0 = await import('./errors-CnT0fSMK.js');
     const _ns_0 = _mod_0.a5;
     const schemaHelpersMod = _ns_0;
     const { listLatestSchemaFiles } = schemaHelpersMod;
     const latestSchemas = await listLatestSchemaFiles();
     for (const schema of latestSchemas) {
         try {
-            const _mod_1 = await import('./BaseFileManager-BAlySv8w.js');
+            const _mod_1 = await import('./BaseFileManager-DLou1TZS.js');
             const _ns_1 = _mod_1.A;
             const fileManagerMod = _ns_1;
             const { BaseFileManager } = fileManagerMod;
@@ -57,7 +57,7 @@ async function getSchemaNameFromModel(modelName) {
 const saveToSchema = fromCallback(({ sendBack, input: { context }, self }) => {
     const _saveToSchema = async () => {
         // Use dynamic import to break circular dependency
-        const validationServiceMod = await import('./SchemaValidationService-CnmKyzR-.js');
+        const validationServiceMod = await import('./SchemaValidationService-CieGrj5c.js');
         const { SchemaValidationService } = validationServiceMod;
         const validationService = new SchemaValidationService();
         // Validate property structure before saving
@@ -76,22 +76,22 @@ const saveToSchema = fromCallback(({ sendBack, input: { context }, self }) => {
             throw new Error(`Model not found for modelId: ${context.modelId}`);
         }
         // Persist to database only - schema file is updated only when user calls Schema.saveNewVersion()
-        const _mod_2 = await import('./tabEvents-CaVmngqr.js');
-        const _ns_2 = _mod_2.bh;
+        const _mod_2 = await import('./tabEvents-DT5ez6io.js');
+        const _ns_2 = _mod_2.bk;
         const dbMod = _ns_2;
         const { savePropertyToDb } = dbMod;
         await savePropertyToDb(context);
         // Mark schema as draft so user knows to save
         const schemaName = context._schemaName ?? (await getSchemaNameFromModel(context.modelName));
         if (schemaName) {
-            const _mod_3 = await import('./Schema-J_1f6p0c.js');
+            const _mod_3 = await import('./Schema-BMXRF4j9.js');
             const _ns_3 = _mod_3.a;
             const schemaMod = _ns_3;
             const { Schema } = schemaMod;
             // Stopped meanwhile (unloaded, or evicted with its schema): don't load the schema again
             if (isActorStopped(self))
                 return;
-            const schema = await Schema.find({ schemaName, waitForReady: false, hold: false });
+            const schema = await Schema.find({ schemaName, waitForReady: false });
             schema?.getService().send({
                 type: 'markAsDraft',
                 propertyKey: `${context.modelName}:${context.name}`,
@@ -122,8 +122,8 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context }, self }
         const schemaFileIdForResolve = fullContext._propertyFileId || (typeof fullContext.id === 'string' ? fullContext.id : undefined);
         if (schemaFileIdForResolve && (fullContext.modelName === undefined || fullContext.dataType === undefined)) {
             try {
-                const _mod_4 = await import('./tabEvents-CaVmngqr.js');
-                const _ns_4 = _mod_4.be;
+                const _mod_4 = await import('./tabEvents-DT5ez6io.js');
+                const _ns_4 = _mod_4.bh;
                 const { resolveModelRecord, resolvePropertyModelRecord } = _ns_4;
                 const fromDb = await resolvePropertyModelRecord(schemaFileIdForResolve);
                 if (fromDb) {
@@ -161,8 +161,8 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context }, self }
             if (fullContext.modelName && fullContext.name && schemaFileId) {
                 logger$2(`[compareAndMarkDraft] _originalValues not set, but saving to database anyway for property ${context.modelName}:${context.name} (schemaFileId: ${schemaFileId})`);
                 try {
-                    const _mod_5 = await import('./tabEvents-CaVmngqr.js');
-                    const _ns_5 = _mod_5.bh;
+                    const _mod_5 = await import('./tabEvents-DT5ez6io.js');
+                    const _ns_5 = _mod_5.bk;
                     const dbMod = _ns_5;
                     const { savePropertyToDb } = dbMod;
                     // Ensure _propertyFileId is set for savePropertyToDb to find the property
@@ -223,8 +223,8 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context }, self }
             logger$2(`Property ${fullContext.modelName}:${fullContext.name} has changes, marking as edited`);
             logger$2(`[compareAndMarkDraft] Context when saving: id=${fullContext.id}, _propertyFileId=${fullContext._propertyFileId}, name=${fullContext.name}, _originalValues.name=${fullContext._originalValues?.name}`);
             // Use dynamic import to break circular dependency
-            const _mod_6 = await import('./tabEvents-CaVmngqr.js');
-            const _ns_6 = _mod_6.bh;
+            const _mod_6 = await import('./tabEvents-DT5ez6io.js');
+            const _ns_6 = _mod_6.bk;
             const dbMod = _ns_6;
             const { savePropertyToDb } = dbMod;
             // Save to database (but not JSON file) - always save to DB when there are changes
@@ -239,14 +239,14 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context }, self }
             // Mark schema as draft if schema name is available
             if (fullContext._schemaName) {
                 // Get the Schema instance and mark it as draft
-                const _mod_7 = await import('./Schema-J_1f6p0c.js');
+                const _mod_7 = await import('./Schema-BMXRF4j9.js');
                 const _ns_7 = _mod_7.a;
                 const schemaMod = _ns_7;
                 const { Schema } = schemaMod;
                 // Stopped meanwhile (unloaded, or evicted with its schema): don't load the schema again
                 if (isActorStopped(self))
                     return;
-                const schema = await Schema.find({ schemaName: fullContext._schemaName, waitForReady: false, hold: false });
+                const schema = await Schema.find({ schemaName: fullContext._schemaName, waitForReady: false });
                 // Send event to Schema machine to mark as draft
                 schema?.getService().send({
                     type: 'markAsDraft',
@@ -259,7 +259,7 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context }, self }
             logger$2(`Property ${fullContext.modelName}:${fullContext.name} has no changes`);
             // Clear isEdited flag in database
             try {
-                const _mod_8 = await import('./index-D0V-mjCV.js');
+                const _mod_8 = await import('./index-BjWk0x4-.js');
                 const _ns_8 = _mod_8.s;
                 const seedSchemaMod = _ns_8;
                 const { properties: propertiesTable } = seedSchemaMod;
@@ -268,8 +268,8 @@ const compareAndMarkDraft = fromCallback(({ sendBack, input: { context }, self }
                 const db = BaseDb.getAppDb();
                 if (db && fullContext.modelName && fullContext.name) {
                     // Find this property's model (model names are only unique per schema)
-                    const _mod_9 = await import('./tabEvents-CaVmngqr.js');
-                    const _ns_9 = _mod_9.be;
+                    const _mod_9 = await import('./tabEvents-DT5ez6io.js');
+                    const _ns_9 = _mod_9.bh;
                     const { resolveModelRecord } = _ns_9;
                     const modelRecord = await resolveModelRecord(fullContext.modelName, {
                         modelId: typeof fullContext.modelId === 'number' ? fullContext.modelId : undefined,
@@ -326,8 +326,8 @@ const validateProperty = fromCallback(({ sendBack, input: { context }, self }) =
         const schemaFileId = typeof context.id === 'string' ? context.id : undefined;
         if (schemaFileId && (fullContext.modelName === undefined || fullContext.dataType === undefined)) {
             try {
-                const _mod_10 = await import('./tabEvents-CaVmngqr.js');
-                const _ns_10 = _mod_10.be;
+                const _mod_10 = await import('./tabEvents-DT5ez6io.js');
+                const _ns_10 = _mod_10.bh;
                 const { resolveModelRecord, resolvePropertyModelRecord } = _ns_10;
                 // Try pending write first (property row may not exist yet)
                 if (fullContext.modelName === undefined && schemaFileId) {
@@ -360,10 +360,10 @@ const validateProperty = fromCallback(({ sendBack, input: { context }, self }) =
             fullContext = { ...fullContext, dataType: (fullContext.dataType ?? context._originalValues?.dataType) || 'Text' };
         }
         // Use dynamic imports to break circular dependencies
-        const validationServiceMod = await import('./SchemaValidationService-CnmKyzR-.js');
+        const validationServiceMod = await import('./SchemaValidationService-CieGrj5c.js');
         const { SchemaValidationService } = validationServiceMod;
         const validationService = new SchemaValidationService();
-        const _mod_11 = await import('./Schema-J_1f6p0c.js');
+        const _mod_11 = await import('./Schema-BMXRF4j9.js');
         const _ns_11 = _mod_11.a;
         const schemaMod = _ns_11;
         const { Schema } = schemaMod;
@@ -379,7 +379,7 @@ const validateProperty = fromCallback(({ sendBack, input: { context }, self }) =
             return;
         if (fullContext._schemaName && fullContext.modelName) {
             try {
-                const schema = await Schema.find({ schemaName: fullContext._schemaName, waitForReady: false, hold: false });
+                const schema = await Schema.find({ schemaName: fullContext._schemaName, waitForReady: false });
                 if (!schema)
                     throw new Error(`No schema named "${fullContext._schemaName}"`);
                 const schemaSnapshot = schema.getService().getSnapshot();
@@ -870,8 +870,8 @@ class ModelProperty {
                 return fallbackIsEdited;
             }
             // Find this property's model (by modelId when known; model names are only unique per schema)
-            const _mod_12 = await import('./tabEvents-CaVmngqr.js');
-            const _ns_12 = _mod_12.be;
+            const _mod_12 = await import('./tabEvents-DT5ez6io.js');
+            const _ns_12 = _mod_12.bh;
             const { resolveModelRecord } = _ns_12;
             const modelRecord = await resolveModelRecord(property.modelName, this._ownerModelScope(property), db);
             const modelRecords = modelRecord ? [modelRecord] : [];
@@ -908,8 +908,8 @@ class ModelProperty {
                 return undefined;
             }
             // Resolve the ref within the owning model's schema
-            const _mod_13 = await import('./tabEvents-CaVmngqr.js');
-            const _ns_13 = _mod_13.be;
+            const _mod_13 = await import('./tabEvents-DT5ez6io.js');
+            const _ns_13 = _mod_13.bh;
             const { resolveRefModelRecord } = _ns_13;
             const refModelRecord = await resolveRefModelRecord(refModelName, property ? this._ownerModelScope(property) : { schemaName: this._getSnapshotContext()._schemaName }, db);
             if (refModelRecord?.id) {
@@ -954,8 +954,8 @@ class ModelProperty {
                 }
             }
             if (!model && modelId) {
-                const _mod_14 = await import('./tabEvents-CaVmngqr.js');
-                const _ns_14 = _mod_14.be;
+                const _mod_14 = await import('./tabEvents-DT5ez6io.js');
+                const _ns_14 = _mod_14.bh;
                 const { resolveModelRecord } = _ns_14;
                 const modelFileId = (await resolveModelRecord(property.modelName, { modelId }))?.schemaFileId;
                 model = modelFileId ? Model.peek(modelFileId) : undefined;
@@ -968,10 +968,7 @@ class ModelProperty {
                 try {
                     // An eviction of the model's schema since this instance was built (it may already be
                     // stopped) must not re-create the model.
-                    model = await Model.getByNameAsync(property.modelName, undefined, {
-                        since: this._since,
-                        hold: false,
-                    });
+                    model = await Model.getByNameAsync(property.modelName, undefined, { since: this._since });
                 }
                 catch {
                     model = undefined;
@@ -1122,7 +1119,7 @@ class ModelProperty {
         const waitForReady = options?.waitForReady !== false;
         const readyTimeout = options?.readyTimeout ?? DEFAULT_READY_TIMEOUT_MS;
         const schemaName = options?.schemaName;
-        const hold = options?.hold !== false;
+        const hold = options?.hold === true;
         // An id the caller passed (not one generated below): the cache may have that property
         const givenId = typeof property.id === 'string' ? property.id : (property._propertyFileId ?? undefined);
         // Handle 'type' field from JSON schema format - convert to 'dataType'
@@ -1207,7 +1204,7 @@ class ModelProperty {
                 this.cache.holdInstance(instance);
             if (!waitForReady)
                 return instance;
-            return waitForEntityReady(instance, { timeout: readyTimeout }).then(() => instance);
+            return ModelProperty.readyOrRelease(instance, readyTimeout, hold);
         }
         const newInstance = new this(propertyWithId);
         // Set schema name before async operations so the model lookup is scoped to the right schema
@@ -1227,6 +1224,7 @@ class ModelProperty {
                 return context;
             },
             sendUpdate: (instance, prop, value) => {
+                instance._assertLoaded(`set ${prop} on`);
                 const currentContext = instance._getSnapshotContext();
                 if (currentContext[prop] === value)
                     return; // No-op, avoid triggering machine
@@ -1273,7 +1271,19 @@ class ModelProperty {
         });
         if (!waitForReady)
             return proxiedInstance;
-        return waitForEntityReady(proxiedInstance, { timeout: readyTimeout }).then(() => proxiedInstance);
+        return ModelProperty.readyOrRelease(proxiedInstance, readyTimeout, hold);
+    }
+    /** The property once ready; a call that took a hold gives it back when it isn't ready in time. */
+    static async readyOrRelease(property, timeout, held) {
+        try {
+            await waitForEntityReady(property, { timeout });
+        }
+        catch (error) {
+            if (held)
+                property.unload();
+            throw error;
+        }
+        return property;
     }
     /**
      * Writes the row of a property ModelProperty.create made, under the model row its modelId (row id
@@ -1360,20 +1370,28 @@ class ModelProperty {
         if (owner)
             holdChild(owner, instance, this.cache);
     }
-    /** The cached ModelProperty with this propertyFileId, without taking a hold. */
-    static getById(propertyFileId) {
-        return this.cache.peek(propertyFileId);
+    /** The cached ModelProperty with this propertyFileId. Takes no hold unless `hold: true`. */
+    static getById(propertyFileId, options) {
+        return options?.hold ? this.cache.hold(propertyFileId) : this.cache.peek(propertyFileId);
+    }
+    /**
+     * Takes one more hold on a cached, running instance, released with `unload()`. False (and no
+     * hold) when the instance isn't cached or was stopped.
+     */
+    static retain(instance) {
+        return instance.getService().getSnapshot().status === 'active' && this.cache.holdInstance(instance);
     }
     /**
      * Create or get ModelProperty instance by propertyFileId
-     * Queries the database to find the property if not cached
+     * Queries the database to find the property if not cached. Takes no hold unless `hold: true`
+     * (its model holds it either way).
      */
     static async createById(propertyFileId, options) {
         if (!propertyFileId) {
             return undefined;
         }
         // Cached (an app may have created it before its model's load got here): its model holds it too
-        const cachedInstance = this.getById(propertyFileId);
+        const cachedInstance = this.getById(propertyFileId, options);
         if (cachedInstance) {
             this.holdForModel(cachedInstance);
             return cachedInstance;
@@ -1431,7 +1449,7 @@ class ModelProperty {
             }
         }
         // Create ModelProperty instance (sync for createById so we can send updateContext)
-        const instance = this.create(propertyData, { waitForReady: false, hold: false });
+        const instance = this.create(propertyData, { waitForReady: false, hold: options?.hold });
         // Loaded for its model (Model's property list), not held by a caller
         this.holdForModel(instance);
         // Set isEdited from database after creation
@@ -1517,25 +1535,27 @@ class ModelProperty {
     }
     /**
      * Find ModelProperty instance by propertyFileId
-     * Waits for the property to be fully loaded (idle state) by default
+     * Waits for the property to be fully loaded (idle state) by default. Takes no hold unless
+     * `hold: true`; a call that throws keeps none.
      * @param options - Find options including propertyFileId and wait configuration
      * @returns ModelProperty instance if found, undefined otherwise
      */
-    static async find({ propertyFileId, waitForReady = true, readyTimeout = DEFAULT_READY_TIMEOUT_MS, }) {
+    static async find({ propertyFileId, waitForReady = true, readyTimeout = DEFAULT_READY_TIMEOUT_MS, hold = false, }) {
         if (!propertyFileId) {
             return undefined;
         }
-        const property = ModelProperty.getById(propertyFileId) ?? (await ModelProperty.createById(propertyFileId));
+        const property = await ModelProperty.createById(propertyFileId, { hold });
         if (property && waitForReady)
-            await waitForEntityReady(property, { timeout: readyTimeout });
+            await ModelProperty.readyOrRelease(property, readyTimeout, hold);
         return property;
     }
     /**
      * Get all ModelProperty instances for a model.
      * Loads property rows from DB for the given modelFileId, creates instances via createById, optionally waits for idle.
+     * Takes no holds unless `hold: true`.
      */
     static async all(modelFileId, options) {
-        const { waitForReady = false, readyTimeout = DEFAULT_READY_TIMEOUT_MS } = options ?? {};
+        const { waitForReady = false, readyTimeout = DEFAULT_READY_TIMEOUT_MS, hold = false } = options ?? {};
         if (!modelFileId) {
             return [];
         }
@@ -1552,6 +1572,10 @@ class ModelProperty {
         if (waitForReady && instances.length > 0) {
             await Promise.all(instances.map((property) => waitForEntityReady(property, { timeout: readyTimeout })));
         }
+        // Once nothing can throw, so a failed call keeps no holds
+        if (hold)
+            for (const property of instances)
+                this.cache.holdInstance(property);
         return instances;
     }
     /**
@@ -1613,6 +1637,14 @@ class ModelProperty {
     static getPendingModelId(propertyFileId) {
         return this.pendingWrites.get(propertyFileId)?.modelId;
     }
+    /** Throws EntityUnloadedError, naming the property, when this instance was destroyed or evicted. */
+    _assertLoaded(action) {
+        if (!isEntityTornDown(this))
+            return;
+        const { modelName, name, id } = this._getSnapshotContext();
+        throw new EntityUnloadedError(`Cannot ${action} property ${modelName ?? '?'}.${name ?? '?'} (${id ?? 'no id'}): this ModelProperty instance ` +
+            'was destroyed or evicted. Look the property up again (ModelProperty.find).');
+    }
     getService() {
         return this._service;
     }
@@ -1671,6 +1703,7 @@ class ModelProperty {
         return { isValid: errors.length === 0, errors };
     }
     save() {
+        this._assertLoaded('save');
         const snapshot = this._service.getSnapshot();
         const isAlreadySaving = typeof snapshot.value === 'object' && snapshot.value !== null && 'saveToSchema' in snapshot.value;
         if (isAlreadySaving) {
@@ -1730,8 +1763,8 @@ class ModelProperty {
         });
     }
     /**
-     * Releases this caller's hold. The instance is shared: it keeps running while other callers hold
-     * it, or while its model holds it. An instance nobody else holds is stopped and leaves the cache.
+     * Releases this caller's hold, if it took one. The property stays cached (see
+     * `ModelProperty.cache`); only `destroy`, eviction or client stop stop it.
      */
     unload() {
         releaseEntity(this, ModelProperty.cache);
@@ -1754,7 +1787,7 @@ class ModelProperty {
                     .where(eq(properties.schemaFileId, propertyFileId))
                     .limit(1);
                 if (row) {
-                    const { detachPropertyRows } = await import('./detachRowsBeforeDelete-sEaUwlOU.js');
+                    const { detachPropertyRows } = await import('./detachRowsBeforeDelete-BZr_0iZU.js');
                     await detachPropertyRows(db, [row.id]);
                     await db.delete(properties).where(eq(properties.id, row.id));
                 }
@@ -1765,7 +1798,7 @@ class ModelProperty {
             const schemaName = context._schemaName ?? (db ? await this._resolveSchemaNameForDestroy(db, context) : undefined);
             if (!schemaName)
                 return;
-            const schema = await Schema.find({ schemaName, waitForReady: false, hold: false });
+            const schema = await Schema.find({ schemaName, waitForReady: false });
             const schemaContext = schema?.getService().getSnapshot().context;
             if (schema && schemaContext?.models?.[modelName]?.properties?.[propertyName]) {
                 const updatedModels = { ...schemaContext.models };
@@ -1779,13 +1812,13 @@ class ModelProperty {
     }
 }
 /**
- * Cached under its id (schemaFileId) and `modelName:name` (ADR 0014). Its model holds it (see
- * holdForModel), so app holders' unloads don't stop a model's property.
+ * Cached under its id (schemaFileId) and `modelName:name` (ADR 0014). Stays cached with no holds
+ * until it is destroyed or evicted (`unloadUnheld: false`), as Schema and Model do.
  */
-ModelProperty.cache = new EntityCache();
+ModelProperty.cache = new EntityCache({ unloadUnheld: false });
 // Pending writes tracking
 ModelProperty.pendingWrites = new Map();
-setCachedPropertyRefresher((propertyFileIds) => ModelProperty.refreshFromDb(propertyFileIds));
+addCachedPropertyRefresher((propertyFileIds) => ModelProperty.refreshFromDb(propertyFileIds));
 
 var ModelProperty$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -1793,4 +1826,4 @@ var ModelProperty$1 = /*#__PURE__*/Object.freeze({
 });
 
 export { ModelProperty };
-//# sourceMappingURL=ModelProperty-BlaEgb_U.js.map
+//# sourceMappingURL=ModelProperty-D2vJozmW.js.map