@seedprotocol/sdk 0.7.7 → 0.7.8-next.1034.g2acd2a2

package/dist/{ModelProperty-B52C3CQ2.js → ModelProperty-C1Fzcnbm.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-KM-yq2MD.js';
-import { B as BaseDb, t as models, v as properties, A as schemas, r as modelSchemas, ao as getModelIdByFileId, n as normalizeDataType, ai as generateId, M as ModelPropertyDataTypes, h as BaseFileManager, ap as getModelId, aq as setCachedPropertyRefresher } from './index-DpgQMIRq.js';
+import { w as writeProcessMachine, c as currentEvictionEpoch, M as Model, b as anyEvictionSince, s as schemaEvictedSince } from './errors-CQagdED2.js';
+import { B as BaseDb, t as models, v as properties, A as schemas, r as modelSchemas, ao as getModelIdByFileId, n as normalizeDataType, ah as generateId, M as ModelPropertyDataTypes, h as BaseFileManager, ap as getModelId, aq as setCachedPropertyRefresher } from './index-C-NqjjY_.js';
 import 'pluralize';
 import '@seedprotocol/eas';
 import { eq, and, inArray } from 'drizzle-orm';
 import { modelPropertiesToObject } from './model-oHA3YhOd.js';
+import { m as isActorStopped, D as DEFAULT_READY_TIMEOUT_MS, d as waitForEntityIdle, n as createReactiveProxy, o as sameEntity, q as findEntity, t as forceRemoveFromCaches, u as runDestroyLifecycle } from './Item-BiMHgg-_.js';
 import debug from 'debug';
-import { S as Schema } from './Schema-O1QLoXv6.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-D6j0IvBP.js';
-import './ClientManager-2GtDWHq6.js';
+import { S as Schema } from './Schema-COTbavcm.js';
+import './ClientManager-DBKvmJov.js';
 import 'lodash-es';
-import './tabEvents-DksXwk3X.js';
+import './tabEvents-UH-wNsZC.js';
 import '@seedprotocol/arweave';
 import '@noble/hashes/sha3';
 import '@noble/hashes/utils';
@@ -20,9 +20,9 @@ import 'drizzle-orm/sqlite-core';
 import 'nanoid';
 import 'nanoid-dictionary';
 import '@noble/hashes/sha256';
-import './SchemaValidationService-BxCbfDaI.js';
-import '@sinclair/typebox/value';
 import 'rxjs';
+import './SchemaValidationService-paOfbcwd.js';
+import '@sinclair/typebox/value';
 
 const logger$3 = debug('seedSdk:modelProperty:actors:saveToSchema');
 /**
@@ -32,15 +32,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-2GtDWHq6.js');
+    const _mod_0 = await import('./ClientManager-DBKvmJov.js');
     const _ns_0 = _mod_0.N;
     const schemaHelpersMod = _ns_0;
     const { listLatestSchemaFiles } = schemaHelpersMod;
     const latestSchemas = await listLatestSchemaFiles();
     for (const schema of latestSchemas) {
         try {
-            const _mod_1 = await import('./index-DpgQMIRq.js');
-            const _ns_1 = _mod_1.be;
+            const _mod_1 = await import('./index-C-NqjjY_.js');
+            const _ns_1 = _mod_1.bf;
             const fileManagerMod = _ns_1;
             const { BaseFileManager } = fileManagerMod;
             const content = await BaseFileManager.readFileAsString(schema.filePath);
@@ -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-BxCbfDaI.js');
+        const validationServiceMod = await import('./SchemaValidationService-paOfbcwd.js');
         const { SchemaValidationService } = validationServiceMod;
         const validationService = new SchemaValidationService();
         // Validate property structure before saving
@@ -78,22 +78,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('./index-DpgQMIRq.js');
-        const _ns_2 = _mod_2.bi;
+        const _mod_2 = await import('./index-C-NqjjY_.js');
+        const _ns_2 = _mod_2.bj;
         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-O1QLoXv6.js');
+            const _mod_3 = await import('./Schema-COTbavcm.js');
             const _ns_3 = _mod_3.b;
             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 = Schema.create(schemaName, { waitForReady: false });
+            const schema = Schema.create(schemaName, { waitForReady: false, hold: false });
             schema.getService().send({
                 type: 'markAsDraft',
                 propertyKey: `${context.modelName}:${context.name}`,
@@ -124,8 +124,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('./index-DpgQMIRq.js');
-                const _ns_4 = _mod_4.bi;
+                const _mod_4 = await import('./index-C-NqjjY_.js');
+                const _ns_4 = _mod_4.bj;
                 const dbMod = _ns_4;
                 const { getPropertyModelNameAndDataType, getModelNameByModelId } = dbMod;
                 let fromDb;
@@ -171,8 +171,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('./index-DpgQMIRq.js');
-                    const _ns_5 = _mod_5.bi;
+                    const _mod_5 = await import('./index-C-NqjjY_.js');
+                    const _ns_5 = _mod_5.bj;
                     const dbMod = _ns_5;
                     const { savePropertyToDb } = dbMod;
                     // Ensure _propertyFileId is set for savePropertyToDb to find the property
@@ -233,8 +233,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('./index-DpgQMIRq.js');
-            const _ns_6 = _mod_6.bi;
+            const _mod_6 = await import('./index-C-NqjjY_.js');
+            const _ns_6 = _mod_6.bj;
             const dbMod = _ns_6;
             const { savePropertyToDb } = dbMod;
             // Save to database (but not JSON file) - always save to DB when there are changes
@@ -249,16 +249,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-O1QLoXv6.js');
+                const _mod_7 = await import('./Schema-COTbavcm.js');
                 const _ns_7 = _mod_7.b;
                 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 = Schema.create(fullContext._schemaName, {
-                    waitForReady: false,
-                });
+                const schema = Schema.create(fullContext._schemaName, { waitForReady: false, hold: false });
                 // Send event to Schema machine to mark as draft
                 schema.getService().send({
                     type: 'markAsDraft',
@@ -271,7 +269,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-BbFwftAv.js');
+                const _mod_8 = await import('./index-3_hGVu7v.js');
                 const _ns_8 = _mod_8.s;
                 const seedSchemaMod = _ns_8;
                 const { properties: propertiesTable } = seedSchemaMod;
@@ -280,8 +278,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('./index-DpgQMIRq.js');
-                    const _ns_9 = _mod_9.bh;
+                    const _mod_9 = await import('./index-C-NqjjY_.js');
+                    const _ns_9 = _mod_9.bi;
                     const { resolveModelRecord } = _ns_9;
                     const modelRecord = await resolveModelRecord(fullContext.modelName, {
                         modelId: typeof fullContext.modelId === 'number' ? fullContext.modelId : undefined,
@@ -340,8 +338,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('./index-DpgQMIRq.js');
-                const _ns_10 = _mod_10.bi;
+                const _mod_10 = await import('./index-C-NqjjY_.js');
+                const _ns_10 = _mod_10.bj;
                 const dbMod = _ns_10;
                 const { getPropertyModelNameAndDataType, getModelNameByModelId } = dbMod;
                 // Try pending write first (property row may not exist yet)
@@ -394,10 +392,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-BxCbfDaI.js');
+        const validationServiceMod = await import('./SchemaValidationService-paOfbcwd.js');
         const { SchemaValidationService } = validationServiceMod;
         const validationService = new SchemaValidationService();
-        const _mod_11 = await import('./Schema-O1QLoXv6.js');
+        const _mod_11 = await import('./Schema-COTbavcm.js');
         const _ns_11 = _mod_11.b;
         const schemaMod = _ns_11;
         const { Schema } = schemaMod;
@@ -413,9 +411,7 @@ const validateProperty = fromCallback(({ sendBack, input: { context }, self }) =
             return;
         if (fullContext._schemaName && fullContext.modelName) {
             try {
-                const schema = Schema.create(fullContext._schemaName, {
-                    waitForReady: false,
-                });
+                const schema = Schema.create(fullContext._schemaName, { waitForReady: false, hold: false });
                 const schemaSnapshot = schema.getService().getSnapshot();
                 const schemaStatus = schemaSnapshot.value;
                 // Only validate against schema if it's loaded (in idle state)
@@ -1027,8 +1023,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('./index-DpgQMIRq.js');
-            const _ns_12 = _mod_12.bh;
+            const _mod_12 = await import('./index-C-NqjjY_.js');
+            const _ns_12 = _mod_12.bi;
             const { resolveModelRecord } = _ns_12;
             const modelRecord = await resolveModelRecord(property.modelName, this._ownerModelScope(property), db);
             const modelRecords = modelRecord ? [modelRecord] : [];
@@ -1065,8 +1061,8 @@ class ModelProperty {
                 return undefined;
             }
             // Resolve the ref within the owning model's schema
-            const _mod_13 = await import('./index-DpgQMIRq.js');
-            const _ns_13 = _mod_13.bh;
+            const _mod_13 = await import('./index-C-NqjjY_.js');
+            const _ns_13 = _mod_13.bi;
             const { resolveRefModelRecord } = _ns_13;
             const refModelRecord = await resolveRefModelRecord(refModelName, property ? this._ownerModelScope(property) : { schemaName: this._getSnapshotContext()._schemaName }, db);
             if (refModelRecord?.id) {
@@ -1101,21 +1097,21 @@ class ModelProperty {
             // Synchronous cache hits first: callers compare against these values right after construction,
             // so an extra await here lets every property look "edited" (a draft save each). Only then the
             // DB (by modelId), and never instantiate a Model while its own properties are initializing.
-            let model = schemaName ? Model.getByName(property.modelName, schemaName) : undefined;
+            let model = schemaName ? Model.peekByName(property.modelName, schemaName) : undefined;
             if (!model) {
                 try {
-                    model = Model.getByName(property.modelName);
+                    model = Model.peekByName(property.modelName);
                 }
                 catch {
                     model = undefined; // ambiguous name; resolve by modelId below
                 }
             }
             if (!model && modelId) {
-                const _mod_14 = await import('./index-DpgQMIRq.js');
-                const _ns_14 = _mod_14.bh;
+                const _mod_14 = await import('./index-C-NqjjY_.js');
+                const _ns_14 = _mod_14.bi;
                 const { resolveModelRecord } = _ns_14;
                 const modelFileId = (await resolveModelRecord(property.modelName, { modelId }))?.schemaFileId;
-                model = modelFileId ? Model.getById(modelFileId) : undefined;
+                model = modelFileId ? Model.peek(modelFileId) : undefined;
             }
             // Evicted (with its schema) or unloaded while the lookups above ran: don't instantiate its model
             // again from rows that are being deleted.
@@ -1127,6 +1123,7 @@ class ModelProperty {
                     // then (this instance may already be stopped) must not re-create the model.
                     model = await Model.getByNameAsync(property.modelName, undefined, {
                         evictionEpoch: this._evictionEpoch,
+                        hold: false,
                     });
                 }
                 catch {
@@ -1559,7 +1556,8 @@ class ModelProperty {
     }
     /** Whether an idIndex entry still points at a cached instance with that id. */
     static isIndexEntryCurrent(propertyFileId, entry) {
-        if (this.instanceCache.get(entry.cacheKey)?.instance !== entry.instance)
+        const cached = this.instanceCache.get(entry.cacheKey)?.instance;
+        if (!cached || !sameEntity(cached, entry.instance))
             return false;
         try {
             return entry.instance._getSnapshotContext().id === propertyFileId;
@@ -1575,7 +1573,7 @@ class ModelProperty {
                 return;
             const existing = this.idIndex.get(id);
             // Keep the instance cached first, as the old scan in insertion order returned
-            if (existing && existing.instance !== instance && this.isIndexEntryCurrent(id, existing))
+            if (existing && !sameEntity(existing.instance, instance) && this.isIndexEntryCurrent(id, existing))
                 return;
             this.idIndex.set(id, { cacheKey, instance });
         };
@@ -1791,7 +1789,8 @@ class ModelProperty {
                 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) {
+                    const indexed = this.idIndex.get(propertyFileId)?.instance;
+                    if (indexed && sameEntity(indexed, instance)) {
                         this.idIndex.set(propertyFileId, { cacheKey: newCacheKey, instance });
                     }
                 }
@@ -2108,7 +2107,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-D1TyEMco.js');
+                        const { detachPropertyRows } = await import('./detachRowsBeforeDelete-C1iapUFl.js');
                         await detachPropertyRows(db, [propertyRecords[0].propertyId]);
                         await db
                             .delete(properties)
@@ -2116,7 +2115,7 @@ class ModelProperty {
                     }
                 }
                 if (schemaName) {
-                    const schema = Schema.create(schemaName, { waitForReady: false });
+                    const schema = Schema.create(schemaName, { waitForReady: false, hold: false });
                     const snapshot = schema.getService().getSnapshot();
                     const schemaContext = snapshot.context;
                     if (schemaContext.models?.[modelName]?.properties?.[propertyName]) {
@@ -2157,4 +2156,4 @@ var ModelProperty$1 = /*#__PURE__*/Object.freeze({
 });
 
 export { ModelProperty };
-//# sourceMappingURL=ModelProperty-B52C3CQ2.js.map
+//# sourceMappingURL=ModelProperty-C1Fzcnbm.js.map