@seedprotocol/sdk 0.7.5-next.850.g9ab585b → 0.7.5

package/dist/{ModelProperty-Bw6N8OMK.js → ModelProperty-Dto5C0om.js}

@@ -1,16 +1,16 @@
 import { fromCallback, setup, assign, createActor } from 'xstate';
-import { i as isActorStopped, w as writeProcessMachine, c as currentEvictionEpoch, M as Model, b as anyEvictionSince, s as schemaEvictedSince } from './errors-CWKup8tw.js';
-import { E as BaseDb, s as models, u as properties, z as schemas, q as modelSchemas, an as getModelIdByFileId, n as normalizeDataType, aj as generateId, M as ModelPropertyDataTypes, K as BaseFileManager, ao as getModelId, ap as setCachedPropertyRefresher } from './BasePathResolver-CsZHPrk9.js';
+import { i as isActorStopped, w as writeProcessMachine, c as currentEvictionEpoch, M as Model, b as anyEvictionSince, s as schemaEvictedSince } from './errors-CIrbsN_i.js';
+import { B as BaseDb, t as models, v as properties, A as schemas, r as modelSchemas, ap as getModelIdByFileId, n as normalizeDataType, al as generateId, M as ModelPropertyDataTypes, h as BaseFileManager, aq as getModelId, ar as setCachedPropertyRefresher } from './BasePathResolver-CBTXCMFL.js';
 import 'pluralize';
 import '@seedprotocol/eas';
 import { eq, and, inArray } from 'drizzle-orm';
 import { modelPropertiesToObject } from './model-oHA3YhOd.js';
 import debug from 'debug';
-import { S as Schema } from './Schema-VLenyJDy.js';
-import { D as DEFAULT_READY_TIMEOUT_MS, l as waitForEntityIdle, m as createReactiveProxy, n as findEntity, o as forceRemoveFromCaches, q as runDestroyLifecycle } from './Item-TMrVEPeX.js';
-import './ClientManager-DETTj0_z.js';
+import { S as Schema } from './Schema-8DxGcORY.js';
+import { D as DEFAULT_READY_TIMEOUT_MS, d as waitForEntityIdle, m as createReactiveProxy, n as findEntity, o as forceRemoveFromCaches, q as runDestroyLifecycle } from './Item-DTJPMjFk.js';
+import './ClientManager-DRf4uuei.js';
 import 'lodash-es';
-import './tabEvents-BEAmMncP.js';
+import './tabEvents-BGBYV65P.js';
 import '@seedprotocol/arweave';
 import '@noble/hashes/sha3';
 import '@noble/hashes/utils';
@@ -20,7 +20,7 @@ import 'drizzle-orm/sqlite-core';
 import 'nanoid';
 import 'nanoid-dictionary';
 import '@noble/hashes/sha256';
-import './SchemaValidationService-CLGadxgf.js';
+import './SchemaValidationService-CE92y1TT.js';
 import '@sinclair/typebox/value';
 import 'rxjs';
 
@@ -32,14 +32,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('./ClientManager-DETTj0_z.js');
-    const _ns_0 = _mod_0.L;
+    const _mod_0 = await import('./ClientManager-DRf4uuei.js');
+    const _ns_0 = _mod_0.M;
     const schemaHelpersMod = _ns_0;
     const { listLatestSchemaFiles } = schemaHelpersMod;
     const latestSchemas = await listLatestSchemaFiles();
     for (const schema of latestSchemas) {
         try {
-            const _mod_1 = await import('./BasePathResolver-CsZHPrk9.js');
+            const _mod_1 = await import('./BasePathResolver-CBTXCMFL.js');
             const _ns_1 = _mod_1.bc;
             const fileManagerMod = _ns_1;
             const { BaseFileManager } = fileManagerMod;
@@ -59,7 +59,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-CLGadxgf.js');
+        const validationServiceMod = await import('./SchemaValidationService-CE92y1TT.js');
         const { SchemaValidationService } = validationServiceMod;
         const validationService = new SchemaValidationService();
         // Validate property structure before saving
@@ -78,7 +78,7 @@ 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('./BasePathResolver-CsZHPrk9.js');
+        const _mod_2 = await import('./BasePathResolver-CBTXCMFL.js');
         const _ns_2 = _mod_2.bg;
         const dbMod = _ns_2;
         const { savePropertyToDb } = dbMod;
@@ -86,7 +86,7 @@ const saveToSchema = fromCallback(({ sendBack, input: { context }, self }) => {
         // 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-VLenyJDy.js');
+            const _mod_3 = await import('./Schema-8DxGcORY.js');
             const _ns_3 = _mod_3.b;
             const schemaMod = _ns_3;
             const { Schema } = schemaMod;
@@ -124,7 +124,7 @@ 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('./BasePathResolver-CsZHPrk9.js');
+                const _mod_4 = await import('./BasePathResolver-CBTXCMFL.js');
                 const _ns_4 = _mod_4.bg;
                 const dbMod = _ns_4;
                 const { getPropertyModelNameAndDataType, getModelNameByModelId } = dbMod;
@@ -171,7 +171,7 @@ 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('./BasePathResolver-CsZHPrk9.js');
+                    const _mod_5 = await import('./BasePathResolver-CBTXCMFL.js');
                     const _ns_5 = _mod_5.bg;
                     const dbMod = _ns_5;
                     const { savePropertyToDb } = dbMod;
@@ -233,7 +233,7 @@ 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('./BasePathResolver-CsZHPrk9.js');
+            const _mod_6 = await import('./BasePathResolver-CBTXCMFL.js');
             const _ns_6 = _mod_6.bg;
             const dbMod = _ns_6;
             const { savePropertyToDb } = dbMod;
@@ -249,7 +249,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-VLenyJDy.js');
+                const _mod_7 = await import('./Schema-8DxGcORY.js');
                 const _ns_7 = _mod_7.b;
                 const schemaMod = _ns_7;
                 const { Schema } = schemaMod;
@@ -271,7 +271,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-CURf9L4d.js');
+                const _mod_8 = await import('./index-DWK-LOUY.js');
                 const _ns_8 = _mod_8.s;
                 const seedSchemaMod = _ns_8;
                 const { properties: propertiesTable, models: modelsTable } = seedSchemaMod;
@@ -280,7 +280,7 @@ 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('./BasePathResolver-CsZHPrk9.js');
+                    const _mod_9 = await import('./BasePathResolver-CBTXCMFL.js');
                     const _ns_9 = _mod_9.bf;
                     const { resolveModelRecord } = _ns_9;
                     const modelRecord = await resolveModelRecord(fullContext.modelName, {
@@ -340,7 +340,7 @@ 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('./BasePathResolver-CsZHPrk9.js');
+                const _mod_10 = await import('./BasePathResolver-CBTXCMFL.js');
                 const _ns_10 = _mod_10.bg;
                 const dbMod = _ns_10;
                 const { getPropertyModelNameAndDataType, getModelNameByModelId } = dbMod;
@@ -394,10 +394,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-CLGadxgf.js');
+        const validationServiceMod = await import('./SchemaValidationService-CE92y1TT.js');
         const { SchemaValidationService } = validationServiceMod;
         const validationService = new SchemaValidationService();
-        const _mod_11 = await import('./Schema-VLenyJDy.js');
+        const _mod_11 = await import('./Schema-8DxGcORY.js');
         const _ns_11 = _mod_11.b;
         const schemaMod = _ns_11;
         const { Schema } = schemaMod;
@@ -1027,7 +1027,7 @@ 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('./BasePathResolver-CsZHPrk9.js');
+            const _mod_12 = await import('./BasePathResolver-CBTXCMFL.js');
             const _ns_12 = _mod_12.bf;
             const { resolveModelRecord } = _ns_12;
             const modelRecord = await resolveModelRecord(property.modelName, this._ownerModelScope(property), db);
@@ -1065,7 +1065,7 @@ class ModelProperty {
                 return undefined;
             }
             // Resolve the ref within the owning model's schema
-            const _mod_13 = await import('./BasePathResolver-CsZHPrk9.js');
+            const _mod_13 = await import('./BasePathResolver-CBTXCMFL.js');
             const _ns_13 = _mod_13.bf;
             const { resolveRefModelRecord } = _ns_13;
             const refModelRecord = await resolveRefModelRecord(refModelName, property ? this._ownerModelScope(property) : { schemaName: this._getSnapshotContext()._schemaName }, db);
@@ -1111,7 +1111,7 @@ class ModelProperty {
                 }
             }
             if (!model && modelId) {
-                const _mod_14 = await import('./BasePathResolver-CsZHPrk9.js');
+                const _mod_14 = await import('./BasePathResolver-CBTXCMFL.js');
                 const _ns_14 = _mod_14.bf;
                 const { resolveModelRecord } = _ns_14;
                 const modelFileId = (await resolveModelRecord(property.modelName, { modelId }))?.schemaFileId;
@@ -1339,7 +1339,8 @@ class ModelProperty {
         }
         // Check if instance exists in cache
         if (this.instanceCache.has(cacheKey)) {
-            const { instance, refCount } = this.instanceCache.get(cacheKey);
+            const cachedEntry = this.instanceCache.get(cacheKey);
+            const { instance, refCount } = cachedEntry;
             const cachedContext = instance._getSnapshotContext();
             // Update cached instance if new property data has fields that the cached instance doesn't have
             // This handles cases where the property was created without ref initially, but now we have ref from schema
@@ -1368,7 +1369,7 @@ class ModelProperty {
                 });
             }
             this.instanceCache.set(cacheKey, {
-                instance,
+                ...cachedEntry,
                 refCount: refCount + 1,
             });
             if (!waitForReady)
@@ -1588,6 +1589,18 @@ class ModelProperty {
             index(id);
         });
     }
+    /**
+     * Turns the caller's hold from the create call just made into model ownership: the instance stays
+     * cached and running for its model, and app holders' unload calls don't stop it.
+     * @internal Used by the model's property loading.
+     */
+    static adoptForModel(instance) {
+        for (const [key, entry] of this.instanceCache) {
+            if (entry.instance._service !== instance._service)
+                continue;
+            this.instanceCache.set(key, { ...entry, refCount: Math.max(0, entry.refCount - 1), modelOwned: true });
+        }
+    }
     /**
      * Get ModelProperty instance by propertyFileId from static cache
      */
@@ -1694,6 +1707,8 @@ class ModelProperty {
         }
         // Create ModelProperty instance (sync for createById so we can send updateContext)
         const instance = this.create(propertyData, { waitForReady: false });
+        // Loaded for its model (Model's property list, the model machine), not held by a caller.
+        this.adoptForModel(instance);
         // Set isEdited from database after creation
         if (isEditedFromDb) {
             instance._service.send({
@@ -2020,9 +2035,24 @@ class ModelProperty {
             }
         }
     }
+    /**
+     * Releases this caller's hold. The instance is shared: it keeps running while other callers hold
+     * it, or while its model owns it (a model's properties are stopped when the model is evicted).
+     * An instance nobody else holds is stopped and leaves the cache.
+     */
     unload() {
-        // ModelProperty doesn't have liveQuery subscriptions or complex cache management
-        // Just stop the service
+        const entries = [...ModelProperty.instanceCache.entries()].filter(([, entry]) => entry.instance._service === this._service);
+        if (entries.length > 0) {
+            const [, first] = entries[0];
+            const refCount = Math.max(0, first.refCount - 1);
+            if (refCount > 0 || first.modelOwned) {
+                for (const [key, entry] of entries)
+                    ModelProperty.instanceCache.set(key, { ...entry, refCount });
+                return;
+            }
+            for (const [key] of entries)
+                ModelProperty.instanceCache.delete(key);
+        }
         try {
             this._service.stop();
         }
@@ -2078,7 +2108,7 @@ 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-D1gTseFW.js');
+                        const { detachPropertyRows } = await import('./detachRowsBeforeDelete-BVetHtn2.js');
                         await detachPropertyRows(db, [propertyRecords[0].propertyId]);
                         await db
                             .delete(properties)
@@ -2102,6 +2132,11 @@ class ModelProperty {
         });
     }
 }
+/**
+ * `refCount` counts app holders (ModelProperty.create callers that haven't unloaded). `modelOwned`
+ * marks an instance its model created or loaded: the model keeps it until the model is evicted,
+ * so it isn't stopped when the app's holders unload it.
+ */
 ModelProperty.instanceCache = new Map();
 /**
  * propertyFileId -> where the instance with that id is cached, so getById doesn't scan the cache
@@ -2122,4 +2157,4 @@ var ModelProperty$1 = /*#__PURE__*/Object.freeze({
 });
 
 export { ModelProperty };
-//# sourceMappingURL=ModelProperty-Bw6N8OMK.js.map
+//# sourceMappingURL=ModelProperty-Dto5C0om.js.map