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

package/dist/{ModelProperty-DJxeOOrc.js → ModelProperty-BS49g01Y.js}

@@ -1,29 +1,27 @@
 import { fromCallback, setup, assign, createActor } from 'xstate';
-import 'reflect-metadata';
-import { i as isActorStopped, w as writeProcessMachine, c as currentEvictionEpoch, M as Model, b as anyEvictionSince, s as schemaEvictedSince } from './index-s15q14rm.js';
-import { x as getModelIdByFileId, n as normalizeDataType, y as getModelId } from './db-D9K_f5cF.js';
+import { i as isActorStopped, w as writeProcessMachine, c as currentEvictionEpoch, M as Model, b as anyEvictionSince, s as schemaEvictedSince } from './index-8O3Uow-Y.js';
+import { E as BaseDb, s as models, u as properties, z as schemas, q as modelSchemas, ai as getModelIdByFileId, n as normalizeDataType, $ as generateId, M as ModelPropertyDataTypes, J as BaseFileManager, aj as getModelId, ak as setCachedPropertyRefresher } from './BasePathResolver-Cm4apKRb.js';
 import 'pluralize';
-import { B as BaseDb, i as models, p as properties, s as schemas, f as modelSchemas, t as BaseFileManager } from './BasePathResolver-CfSfMW5_.js';
-import { eq, and } from 'drizzle-orm';
+import { eq, and, inArray } from 'drizzle-orm';
 import { modelPropertiesToObject } from './model-DGMe-TTm.js';
 import debug from 'debug';
-import { j as generateId } from './tabEvents-DguZpCCv.js';
-import { S as Schema } from './Schema-fXtvd-yL.js';
-import { k as waitForEntityIdle, m as createReactiveProxy, n as findEntity, o as forceRemoveFromCaches, q as runDestroyLifecycle } from './Item-C7sUUu2B.js';
-import './ClientManager-C-QXqUK9.js';
+import { S as Schema } from './Schema-CpMNEnUO.js';
+import { D as DEFAULT_READY_TIMEOUT_MS, n as waitForEntityIdle, o as createReactiveProxy, q as findEntity, t as forceRemoveFromCaches, u as runDestroyLifecycle } from './Item-DBFchXpC.js';
+import './ClientManager-i3nJASkg.js';
+import 'lodash-es';
+import './tabEvents-9s2WCYw-.js';
 import '@seedprotocol/arweave';
 import '@seedprotocol/eas';
 import '@noble/hashes/sha3';
 import '@noble/hashes/utils';
 import '@seedprotocol/query';
-import 'lodash-es';
 import 'drizzle-orm/casing';
 import '@sinclair/typebox';
 import 'drizzle-orm/sqlite-core';
 import 'nanoid';
 import 'nanoid-dictionary';
 import '@noble/hashes/sha256';
-import './SchemaValidationService-CvRS2HSO.js';
+import './SchemaValidationService-DieV4KL-.js';
 import '@sinclair/typebox/value';
 import 'rxjs';
 
@@ -35,15 +33,15 @@ 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('./ClientManager-C-QXqUK9.js');
-    const _ns_0 = _mod_0.I;
+    const _mod_0 = await import('./ClientManager-i3nJASkg.js');
+    const _ns_0 = _mod_0.K;
     const schemaHelpersMod = _ns_0;
     const { listLatestSchemaFiles } = schemaHelpersMod;
     const latestSchemas = await listLatestSchemaFiles();
     for (const schema of latestSchemas) {
         try {
-            const _mod_1 = await import('./BasePathResolver-CfSfMW5_.js');
-            const _ns_1 = _mod_1.O;
+            const _mod_1 = await import('./BasePathResolver-Cm4apKRb.js');
+            const _ns_1 = _mod_1.a_;
             const fileManagerMod = _ns_1;
             const { BaseFileManager } = fileManagerMod;
             const content = await BaseFileManager.readFileAsString(schema.filePath);
@@ -62,7 +60,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-CvRS2HSO.js');
+        const validationServiceMod = await import('./SchemaValidationService-DieV4KL-.js');
         const { SchemaValidationService } = validationServiceMod;
         const validationService = new SchemaValidationService();
         // Validate property structure before saving
@@ -81,15 +79,15 @@ 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('./db-D9K_f5cF.js');
-        const _ns_2 = _mod_2.Z;
+        const _mod_2 = await import('./BasePathResolver-Cm4apKRb.js');
+        const _ns_2 = _mod_2.b2;
         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-fXtvd-yL.js');
+            const _mod_3 = await import('./Schema-CpMNEnUO.js');
             const _ns_3 = _mod_3.b;
             const schemaMod = _ns_3;
             const { Schema } = schemaMod;
@@ -127,8 +125,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('./db-D9K_f5cF.js');
-                const _ns_4 = _mod_4.Z;
+                const _mod_4 = await import('./BasePathResolver-Cm4apKRb.js');
+                const _ns_4 = _mod_4.b2;
                 const dbMod = _ns_4;
                 const { getPropertyModelNameAndDataType, getModelNameByModelId } = dbMod;
                 let fromDb;
@@ -174,8 +172,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('./db-D9K_f5cF.js');
-                    const _ns_5 = _mod_5.Z;
+                    const _mod_5 = await import('./BasePathResolver-Cm4apKRb.js');
+                    const _ns_5 = _mod_5.b2;
                     const dbMod = _ns_5;
                     const { savePropertyToDb } = dbMod;
                     // Ensure _propertyFileId is set for savePropertyToDb to find the property
@@ -236,8 +234,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('./db-D9K_f5cF.js');
-            const _ns_6 = _mod_6.Z;
+            const _mod_6 = await import('./BasePathResolver-Cm4apKRb.js');
+            const _ns_6 = _mod_6.b2;
             const dbMod = _ns_6;
             const { savePropertyToDb } = dbMod;
             // Save to database (but not JSON file) - always save to DB when there are changes
@@ -252,7 +250,7 @@ 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-fXtvd-yL.js');
+                const _mod_7 = await import('./Schema-CpMNEnUO.js');
                 const _ns_7 = _mod_7.b;
                 const schemaMod = _ns_7;
                 const { Schema } = schemaMod;
@@ -274,7 +272,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-DglvthOk.js');
+                const _mod_8 = await import('./index-AVFTVp1m.js');
                 const _ns_8 = _mod_8.s;
                 const seedSchemaMod = _ns_8;
                 const { properties: propertiesTable, models: modelsTable } = seedSchemaMod;
@@ -283,8 +281,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('./db-D9K_f5cF.js');
-                    const _ns_9 = _mod_9.Y;
+                    const _mod_9 = await import('./BasePathResolver-Cm4apKRb.js');
+                    const _ns_9 = _mod_9.b1;
                     const { resolveModelRecord } = _ns_9;
                     const modelRecord = await resolveModelRecord(fullContext.modelName, {
                         modelId: typeof fullContext.modelId === 'number' ? fullContext.modelId : undefined,
@@ -343,8 +341,8 @@ const validateProperty = fromCallback(({ sendBack, input: { context }, self }) =
             // Brief wait so trackPendingWrite from ModelProperty.create() has time to run (it's in setTimeout(0))
             await new Promise((r) => setTimeout(r, 60));
             try {
-                const _mod_10 = await import('./db-D9K_f5cF.js');
-                const _ns_10 = _mod_10.Z;
+                const _mod_10 = await import('./BasePathResolver-Cm4apKRb.js');
+                const _ns_10 = _mod_10.b2;
                 const dbMod = _ns_10;
                 const { getPropertyModelNameAndDataType, getModelNameByModelId } = dbMod;
                 // Try pending write first (property row may not exist yet)
@@ -397,10 +395,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-CvRS2HSO.js');
+        const validationServiceMod = await import('./SchemaValidationService-DieV4KL-.js');
         const { SchemaValidationService } = validationServiceMod;
         const validationService = new SchemaValidationService();
-        const _mod_11 = await import('./Schema-fXtvd-yL.js');
+        const _mod_11 = await import('./Schema-CpMNEnUO.js');
         const _ns_11 = _mod_11.b;
         const schemaMod = _ns_11;
         const { Schema } = schemaMod;
@@ -624,6 +622,16 @@ const modelPropertyMachine = setup({
                 _schemaName: event.schemaName,
             })),
         },
+        // The property's row and schema file already have these values (e.g. after a schema update reloaded
+        // them), so unlike updateContext it isn't an edit: no validation, draft marking or saveToSchema.
+        syncedFromStorage: {
+            actions: assign(({ context, event }) => ({
+                ...event.values,
+                _originalValues: context._originalValues
+                    ? { ...context._originalValues, ...event.values }
+                    : context._originalValues,
+            })),
+        },
         destroyStarted: {
             actions: assign({ _destroyError: null }),
         },
@@ -1020,8 +1028,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('./db-D9K_f5cF.js');
-            const _ns_12 = _mod_12.Y;
+            const _mod_12 = await import('./BasePathResolver-Cm4apKRb.js');
+            const _ns_12 = _mod_12.b1;
             const { resolveModelRecord } = _ns_12;
             const modelRecord = await resolveModelRecord(property.modelName, this._ownerModelScope(property), db);
             const modelRecords = modelRecord ? [modelRecord] : [];
@@ -1058,8 +1066,8 @@ class ModelProperty {
                 return undefined;
             }
             // Resolve the ref within the owning model's schema
-            const _mod_13 = await import('./db-D9K_f5cF.js');
-            const _ns_13 = _mod_13.Y;
+            const _mod_13 = await import('./BasePathResolver-Cm4apKRb.js');
+            const _ns_13 = _mod_13.b1;
             const { resolveRefModelRecord } = _ns_13;
             const refModelRecord = await resolveRefModelRecord(refModelName, property ? this._ownerModelScope(property) : { schemaName: this._getSnapshotContext()._schemaName }, db);
             if (refModelRecord?.id) {
@@ -1104,8 +1112,8 @@ class ModelProperty {
                 }
             }
             if (!model && modelId) {
-                const _mod_14 = await import('./db-D9K_f5cF.js');
-                const _ns_14 = _mod_14.Y;
+                const _mod_14 = await import('./BasePathResolver-Cm4apKRb.js');
+                const _ns_14 = _mod_14.b1;
                 const { resolveModelRecord } = _ns_14;
                 const modelFileId = (await resolveModelRecord(property.modelName, { modelId }))?.schemaFileId;
                 model = modelFileId ? Model.getById(modelFileId) : undefined;
@@ -1267,7 +1275,7 @@ class ModelProperty {
             throw new Error('Property is required');
         }
         const waitForReady = options?.waitForReady !== false;
-        const readyTimeout = options?.readyTimeout ?? 5000;
+        const readyTimeout = options?.readyTimeout ?? DEFAULT_READY_TIMEOUT_MS;
         const schemaName = options?.schemaName;
         // Handle 'type' field from JSON schema format - convert to 'dataType'
         // Normalize to PascalCase so lowercase values from JSON (e.g. 'text') work
@@ -1399,7 +1407,16 @@ class ModelProperty {
         // A _dbId means the data was loaded from an existing row (createById, getPropertySchema), so
         // there's nothing to write. Writing it back anyway raced deletes of that row's model (FK error).
         const isPersisted = typeof propertyWithId._dbId === 'number';
+        // Settles when the row write finishes; create() waits for it when waitForReady is on, so a
+        // failed write rejects create() instead of resolving with nothing in the DB.
+        let writeDone = Promise.resolve();
         if (hasModelId && propertyFileId && !isPersisted) {
+            let resolveWrite;
+            let rejectWrite;
+            writeDone = new Promise((resolve, reject) => {
+                resolveWrite = resolve;
+                rejectWrite = reject;
+            });
             // 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;
@@ -1408,8 +1425,10 @@ class ModelProperty {
                 const service = proxiedInstance.getService();
                 const snapshot = service.getSnapshot();
                 // Unloaded or evicted (e.g. Schema.destroy) before the write started: nothing to write to
-                if (isActorStopped(service))
+                if (isActorStopped(service)) {
+                    resolveWrite();
                     return;
+                }
                 if (snapshot.value === 'idle' && snapshot.context.writeProcess) {
                     const writeProcess = snapshot.context.writeProcess;
                     // Resolve dbModelId - convert from string (modelFileId) to number (database ID) if needed
@@ -1447,11 +1466,14 @@ class ModelProperty {
                         logger(`ERROR: Cannot write property "${property.name}" - no modelId available`);
                         console.error(`[ModelProperty.create] ERROR: Cannot write property "${property.name}" - no modelId available. modelId: ${propertyWithId.modelId}, modelName: ${propertyWithId.modelName}`);
                         // Don't clear pending write here - it might resolve later
+                        rejectWrite(new Error(`Cannot write property "${property.name}": model ${propertyWithId.modelName ?? propertyWithId.modelId} has no database row`));
                         return;
                     }
                     // Resolving the modelId awaited the DB; the instance may have been stopped meanwhile
-                    if (isActorStopped(service))
+                    if (isActorStopped(service)) {
+                        resolveWrite();
                         return;
+                    }
                     // Track pending write now that we have the resolved modelId
                     this.trackPendingWrite(propertyFileId, resolvedModelId);
                     logger(`Triggering write process for property "${property.name}" (modelId: ${resolvedModelId}, propertyFileId: ${propertyFileId})`);
@@ -1460,6 +1482,7 @@ class ModelProperty {
                     if (currentWriteState.value === 'success') {
                         // Write already succeeded
                         void this.completePendingWrite(propertyFileId, resolvedModelId);
+                        resolveWrite();
                     }
                     else {
                         // Set up subscription to catch future state changes
@@ -1468,6 +1491,7 @@ class ModelProperty {
                                 writeSubscription.unsubscribe();
                                 logger(`[writeProcess subscription] Write succeeded for property "${property.name}" (propertyFileId: ${propertyFileId})`);
                                 void this.completePendingWrite(propertyFileId, resolvedModelId);
+                                resolveWrite();
                             }
                             else if (writeSnapshot.value === 'error') {
                                 writeSubscription.unsubscribe();
@@ -1476,6 +1500,7 @@ class ModelProperty {
                                 logger(`Write process error details:`, errorContext.error);
                                 // Mark pending write as error
                                 this.clearPendingWrite(propertyFileId, 'error');
+                                rejectWrite(new Error(`Failed to write property "${property.name}": ${errorContext.error?.message || 'Unknown error'}`));
                             }
                         });
                     }
@@ -1504,14 +1529,25 @@ class ModelProperty {
                     console.error(`[ModelProperty.create] ERROR: writeProcess not available after ${maxRetries} retries for property "${property.name}" (propertyFileId: ${propertyFileId})`);
                     // Mark as error if we couldn't even start the write process
                     this.clearPendingWrite(propertyFileId, 'error');
+                    rejectWrite(new Error(`Failed to write property "${property.name}": its write process never started`));
                 }
             };
             // Start checking after a short delay to allow state machine to initialize
             setTimeout(checkAndSend, 0);
         }
-        if (!waitForReady)
+        if (!waitForReady) {
+            // Nobody awaits the write; failures are already logged above.
+            writeDone.catch(() => { });
             return proxiedInstance;
-        return waitForEntityIdle(proxiedInstance, { timeout: readyTimeout }).then(() => proxiedInstance);
+        }
+        let timer;
+        const writeWithin = Promise.race([
+            writeDone,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`Property "${property.name}" was not written within ${readyTimeout}ms`)), readyTimeout);
+            }),
+        ]).finally(() => clearTimeout(timer));
+        return Promise.all([waitForEntityIdle(proxiedInstance, { timeout: readyTimeout }), writeWithin]).then(() => proxiedInstance);
     }
     /** Whether an idIndex entry still points at a cached instance with that id. */
     static isIndexEntryCurrent(propertyFileId, entry) {
@@ -1660,13 +1696,93 @@ class ModelProperty {
         }
         return instance;
     }
+    /**
+     * Give cached instances of these properties the values their rows now have (e.g. after a schema
+     * update reloaded them: renamed, dataType or storage changed). Nothing else updates them: createById
+     * and the Model's property refresh return a cached instance as is. A renamed instance's
+     * "modelName:oldName" cache entry is re-keyed so creating the property by its new name finds it.
+     * Instances with unsaved edits are left alone, as addModelsToDb leaves edited rows alone.
+     */
+    static async refreshFromDb(propertyFileIds) {
+        const ids = new Set(propertyFileIds.filter(Boolean));
+        if (ids.size === 0)
+            return;
+        const db = BaseDb.getAppDb();
+        if (!db)
+            return;
+        const rows = await db
+            .select({
+            schemaFileId: properties.schemaFileId,
+            name: properties.name,
+            dataType: properties.dataType,
+            refModelId: properties.refModelId,
+            refModelName: models.name,
+            refValueType: properties.refValueType,
+            required: properties.required,
+            storageType: properties.storageType,
+            localStorageDir: properties.localStorageDir,
+            filenameSuffix: properties.filenameSuffix,
+        })
+            .from(properties)
+            .leftJoin(models, eq(models.id, properties.refModelId))
+            .where(inArray(properties.schemaFileId, [...ids]));
+        for (const row of rows) {
+            const propertyFileId = row.schemaFileId;
+            if (!propertyFileId || !row.name)
+                continue;
+            const dataType = row.dataType;
+            const rowValues = {
+                name: row.name,
+                dataType,
+                refValueType: row.refValueType ?? undefined,
+                required: row.required ?? false,
+                storageType: row.storageType ?? undefined,
+                localStorageDir: row.localStorageDir ?? undefined,
+                filenameSuffix: row.filenameSuffix ?? undefined,
+            };
+            if (row.refModelId) {
+                rowValues.refModelId = row.refModelId;
+                if (row.refModelName) {
+                    rowValues.ref = row.refModelName;
+                    rowValues.refModelName = row.refModelName;
+                }
+            }
+            else if (dataType !== ModelPropertyDataTypes.Relation && dataType !== ModelPropertyDataTypes.List) {
+                // No longer a reference. (A Relation/List row without refModelId may just not have its
+                // referenced model's row yet, so keep the instance's ref then.)
+                rowValues.refModelId = undefined;
+                rowValues.ref = undefined;
+                rowValues.refModelName = undefined;
+            }
+            for (const [cacheKey, entry] of [...this.instanceCache.entries()]) {
+                const { instance } = entry;
+                if (isActorStopped(instance._service))
+                    continue;
+                const context = instance._getSnapshotContext();
+                if (context.id !== propertyFileId || context._isEdited)
+                    continue;
+                const changed = Object.fromEntries(Object.entries(rowValues).filter(([key, value]) => context[key] !== value));
+                if (Object.keys(changed).length === 0)
+                    continue;
+                instance._service.send({ type: 'syncedFromStorage', values: changed });
+                const newCacheKey = changed.name && context.modelName ? `${context.modelName}:${changed.name}` : undefined;
+                if (newCacheKey && cacheKey === `${context.modelName}:${context.name}` && !this.instanceCache.has(newCacheKey)) {
+                    this.instanceCache.delete(cacheKey);
+                    this.instanceCache.set(newCacheKey, entry);
+                    if (this.idIndex.get(propertyFileId)?.instance === instance) {
+                        this.idIndex.set(propertyFileId, { cacheKey: newCacheKey, instance });
+                    }
+                }
+            }
+        }
+    }
     /**
      * Find ModelProperty instance by propertyFileId
      * Waits for the property to be fully loaded (idle state) by default
      * @param options - Find options including propertyFileId and wait configuration
      * @returns ModelProperty instance if found, undefined otherwise
      */
-    static async find({ propertyFileId, waitForReady = true, readyTimeout = 5000, }) {
+    static async find({ propertyFileId, waitForReady = true, readyTimeout = DEFAULT_READY_TIMEOUT_MS, }) {
         if (!propertyFileId) {
             return undefined;
         }
@@ -1683,7 +1799,7 @@ class ModelProperty {
      * Loads property rows from DB for the given modelFileId, creates instances via createById, optionally waits for idle.
      */
     static async all(modelFileId, options) {
-        const { waitForReady = false, readyTimeout = 5000 } = options ?? {};
+        const { waitForReady = false, readyTimeout = DEFAULT_READY_TIMEOUT_MS } = options ?? {};
         if (!modelFileId) {
             return [];
         }
@@ -1955,6 +2071,8 @@ class ModelProperty {
                         .where(and(eq(schemas.name, schemaName), eq(models.name, modelName), eq(properties.name, propertyName)))
                         .limit(1);
                     if (propertyRecords.length > 0 && propertyRecords[0].propertyId != null) {
+                        const { detachPropertyRows } = await import('./detachRowsBeforeDelete-S0q-DJPT.js');
+                        await detachPropertyRows(db, [propertyRecords[0].propertyId]);
                         await db
                             .delete(properties)
                             .where(eq(properties.id, propertyRecords[0].propertyId));
@@ -1989,6 +2107,7 @@ ModelProperty.instanceCache = new Map();
 ModelProperty.idIndex = new Map();
 // Pending writes tracking
 ModelProperty.pendingWrites = new Map();
+setCachedPropertyRefresher((propertyFileIds) => ModelProperty.refreshFromDb(propertyFileIds));
 
 var ModelProperty$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -1996,4 +2115,4 @@ var ModelProperty$1 = /*#__PURE__*/Object.freeze({
 });
 
 export { ModelProperty };
-//# sourceMappingURL=ModelProperty-DJxeOOrc.js.map
+//# sourceMappingURL=ModelProperty-BS49g01Y.js.map