@seedprotocol/sdk 0.6.2 → 0.6.4

package/dist/{index-C1pktvdj.js → index-DjwIC6U3.js}

@@ -5,10 +5,10 @@ import { n as normalizeDataType, t as toSnakeCase, o as MachineIds, v as getStor
 import debug from 'debug';
 import { customAlphabet } from 'nanoid';
 import { alphanumeric } from 'nanoid-dictionary';
-import { w as writeModelToDb, m as writePropertyToDb, k as addSchemaToDb, n as normalizePublisher, o as getOwnedAddressesFromDb, j as normalizeAddressList, b as normalizeHexAddress, h as getAddressesForItemsFilter, a as getAllAddressesFromDb, e as escapeSqliteString, g as getPropertyIdForModelAndName, i as normalizeAddressConfig, l as loadModelsFromDbForSchema, p as getWatchedAddressesFromDb, r as renameModelInDb } from './db-BwVuO1tO.js';
+import { w as writeModelToDb, m as writePropertyToDb, k as addSchemaToDb, n as normalizePublisher, o as getOwnedAddressesFromDb, j as normalizeAddressList, b as normalizeHexAddress, h as getAddressesForItemsFilter, a as getAllAddressesFromDb, e as escapeSqliteString, g as getPropertyIdForModelAndName, i as normalizeAddressConfig, l as loadModelsFromDbForSchema, p as getWatchedAddressesFromDb, r as renameModelInDb } from './db-DVsy4QZe.js';
 import pluralize from 'pluralize';
 import { BaseQueryClient, BaseEasClient, GET_SCHEMAS, getSchemaUidForModelFromCache, setSchemaUidForModel, GET_PROPERTIES, pickLatestPropertyAttestationsByRefAndSchema, isValidEasAttestationUid, isPlaceholderUid, getEasSchemaUidForSchemaDefinition, GET_FILES_METADATA, GET_SCHEMA_BY_NAME } from '@seedprotocol/eas';
-import { ZERO_BYTES32, INTERNAL_PROPERTY_NAMES, INTERNAL_DATA_TYPES, ImageSize, PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP, isInternalSchema, INTERNAL_SCHEMA_IDS, SEED_PROTOCOL_SCHEMA_NAME, CLIENT_NOT_INITIALIZED } from './constants-DMHTYMgJ.js';
+import { ZERO_BYTES32, INTERNAL_PROPERTY_NAMES, INTERNAL_DATA_TYPES, ImageSize, PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP, isInternalSchema, INTERNAL_SCHEMA_IDS, SEED_PROTOCOL_SCHEMA_NAME, CLIENT_NOT_INITIALIZED } from './constants-Bre6dTJR.js';
 import { BehaviorSubject } from 'rxjs';
 import { startCase, throttle, upperFirst, camelCase, orderBy } from 'lodash-es';
 import { toSnakeCase as toSnakeCase$1 } from 'drizzle-orm/casing';
@@ -283,7 +283,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await import('./ModelProperty-DMjKVphl.js');
+        const mod = await import('./ModelProperty-BiDQu5rE.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$s('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -467,7 +467,7 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
         // 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_0 = await import('./Schema-cK2z7wet.js');
+            const _mod_0 = await import('./Schema-qciDB7Nu.js');
             const _ns_0 = _mod_0.b;
             const schemaMod = _ns_0;
             const { Schema } = schemaMod;
@@ -541,7 +541,7 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
         let finalModelName = modelName;
         if (db) {
             // Check if this is an internal schema (Seed Protocol)
-            const constantsMod = await import('./constants-DMHTYMgJ.js');
+            const constantsMod = await import('./constants-Bre6dTJR.js');
             const { isInternalSchema } = constantsMod;
             const isInternal = isInternalSchema(schemaName);
             // Only skip duplicate check if:
@@ -717,7 +717,7 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
         }
         // Mark schema as draft when a new model is created so saveNewVersion() can persist it
         try {
-            const _mod_3 = await import('./Schema-cK2z7wet.js');
+            const _mod_3 = await import('./Schema-qciDB7Nu.js');
             const _ns_3 = _mod_3.b;
             const schemaMod = _ns_3;
             const { Schema } = schemaMod;
@@ -763,10 +763,10 @@ const validateModel = fromCallback(({ sendBack, input: { context } }) => {
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await import('./SchemaValidationService-B3pQ_q-9.js');
+            const validationServiceMod = await import('./SchemaValidationService-BaOkRjsU.js');
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const _mod_4 = await import('./Schema-cK2z7wet.js');
+            const _mod_4 = await import('./Schema-qciDB7Nu.js');
             const _ns_4 = _mod_4.b;
             const schemaMod = _ns_4;
             const { Schema } = schemaMod;
@@ -878,7 +878,7 @@ const createModelProperties = fromCallback(({ sendBack, input }) => {
             return;
         }
         logger$q(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await import('./ModelProperty-DMjKVphl.js');
+        const mod = await import('./ModelProperty-BiDQu5rE.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$q('ModelProperty not available from dynamic import');
@@ -981,7 +981,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                 const structureMsg = `[validateEntity] Validating model structure`;
                 logger$p(structureMsg);
                 // Use existing Model validation
-                const validationServiceMod = await import('./SchemaValidationService-B3pQ_q-9.js');
+                const validationServiceMod = await import('./SchemaValidationService-BaOkRjsU.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
@@ -999,7 +999,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                     if (entityInput.entityData.schemaName) {
                         try {
                             logger$p(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
-                            const _mod_5 = await import('./Schema-cK2z7wet.js');
+                            const _mod_5 = await import('./Schema-qciDB7Nu.js');
                             const _ns_5 = _mod_5.b;
                             const schemaMod = _ns_5;
                             const { Schema } = schemaMod;
@@ -1037,7 +1037,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const validationServiceMod = await import('./SchemaValidationService-B3pQ_q-9.js');
+                const validationServiceMod = await import('./SchemaValidationService-BaOkRjsU.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -1052,7 +1052,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                     // If schema name and model name provided, validate against schema
                     if (entityInput.entityData._schemaName && entityInput.entityData.modelName) {
                         try {
-                            const _mod_6 = await import('./Schema-cK2z7wet.js');
+                            const _mod_6 = await import('./Schema-qciDB7Nu.js');
                             const _ns_6 = _mod_6.b;
                             const schemaMod = _ns_6;
                             const { Schema } = schemaMod;
@@ -1083,7 +1083,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'schema') {
                 // Schema validation - use existing validation
-                const validationServiceMod = await import('./SchemaValidationService-B3pQ_q-9.js');
+                const validationServiceMod = await import('./SchemaValidationService-BaOkRjsU.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
@@ -1156,7 +1156,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-DMjKVphl.js');
+                    const mod = await import('./ModelProperty-BiDQu5rE.js');
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -1536,7 +1536,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-DMjKVphl.js').then(({ ModelProperty }) => {
+                                    import('./ModelProperty-BiDQu5rE.js').then(({ ModelProperty }) => {
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
                                             try {
                                                 const property = await ModelProperty.createById(propertyFileId);
@@ -1831,6 +1831,111 @@ const modelMachine = setup({
     },
 });
 
+/**
+ * Proxy [[GetOwnProperty]] that stays compatible with the target.
+ * Never overrides an own descriptor, never invents on a non-extensible target,
+ * and never promotes a prototype accessor to an own descriptor.
+ */
+function getInvariantSafePropertyDescriptor(target, prop, invent) {
+    const own = Reflect.getOwnPropertyDescriptor(target, prop);
+    if (own)
+        return own;
+    if (!invent)
+        return undefined;
+    if (!Object.isExtensible(target))
+        return undefined;
+    return {
+        enumerable: true,
+        configurable: true,
+        value: invent.value,
+        writable: invent.writable ?? true,
+    };
+}
+/**
+ * Creates a reactive Proxy that intercepts property access and assignment
+ * to read from and write to an actor service's context.
+ *
+ * This enables automatic React re-renders when properties change, as the
+ * React hooks subscribe to the actor service which gets updated when properties
+ * are set via the proxy.
+ *
+ * @param config Configuration object
+ * @returns A proxied instance that behaves like the original but with reactive properties
+ *
+ * @note TypeScript's Proxy type doesn't automatically preserve method signatures,
+ * so we use Proxied<T> to ensure all methods and properties are recognized.
+ * The Proxy implementation preserves all methods via Reflect.get, so this is safe.
+ */
+function createReactiveProxy(config) {
+    const { instance, trackedProperties, getContext, sendUpdate } = config;
+    // Convert readonly array to regular array for includes() checks
+    const trackedPropsSet = new Set(trackedProperties);
+    // Create the proxy - TypeScript needs explicit type assertion to preserve all methods
+    // The Proxy preserves all methods via Reflect.get, so we assert it maintains type T
+    // Using 'as unknown as T' forces TypeScript to recognize all methods and properties
+    const proxy = new Proxy(instance, {
+        get(target, prop) {
+            // Handle special properties that should not be proxied
+            // These need direct access to the underlying instance
+            if (prop === '_service') {
+                return Reflect.get(target, prop);
+            }
+            // If it's a tracked property, read from actor context
+            if (typeof prop === 'string' && trackedPropsSet.has(prop)) {
+                const context = getContext(instance);
+                return context[prop];
+            }
+            // For methods and non-tracked properties, use Reflect
+            return Reflect.get(target, prop);
+        },
+        set(target, prop, value) {
+            // Handle special properties
+            if (prop === '_service') {
+                return Reflect.set(target, prop, value);
+            }
+            // If it's a tracked property, send update to actor
+            if (typeof prop === 'string' && trackedPropsSet.has(prop)) {
+                sendUpdate(instance, prop, value);
+                return true; // Indicate success
+            }
+            // For non-tracked properties, use Reflect. Also trigger sendUpdate for virtual
+            // 'value' so the callback runs when .value is assigned (e.g. ItemProperty).
+            if (typeof prop === 'string' && prop === 'value') {
+                sendUpdate(instance, prop, value);
+            }
+            return Reflect.set(target, prop, value);
+        },
+        has(target, prop) {
+            // Check if property exists in context or on target
+            if (typeof prop === 'string' && trackedPropsSet.has(prop)) {
+                const context = getContext(instance);
+                return prop in context;
+            }
+            return Reflect.has(target, prop);
+        },
+        ownKeys(target) {
+            // Only return keys that actually exist on the target object
+            // This is required when the target is non-extensible (e.g., frozen by Immer)
+            // Tracked properties are virtual (read from context), so we don't include them here
+            // They're accessible via the get trap, but don't appear in ownKeys
+            return Reflect.ownKeys(target);
+        },
+        getOwnPropertyDescriptor(target, prop) {
+            let invent;
+            if (typeof prop === 'string' && trackedPropsSet.has(prop)) {
+                const context = getContext(instance);
+                if (prop in context) {
+                    invent = { value: context[prop] };
+                }
+            }
+            return getInvariantSafePropertyDescriptor(target, prop, invent);
+        }
+    });
+    // Force TypeScript to recognize all methods and properties are preserved
+    // The Proxy implementation preserves all methods via Reflect.get, so this is safe
+    return proxy;
+}
+
 debug('seedSdk:item:service:actors:waitForDb');
 const waitForDb$1 = fromCallback(({ sendBack }) => {
     const _waitForDb = new Promise((resolve) => {
@@ -2434,7 +2539,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             const schemaNameToTry = model$1?.schemaName;
             if (schemaNameToTry) {
                 try {
-                    const _mod_7 = await import('./Schema-cK2z7wet.js');
+                    const _mod_7 = await import('./Schema-qciDB7Nu.js');
                     const _ns_7 = _mod_7.b;
                     const { Schema } = _ns_7;
                     const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false });
@@ -2487,7 +2592,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
-                const schemaMod = await import('./index-DAwvrNga.js');
+                const schemaMod = await import('./index-C41UZTmQ.js');
                 const { ModelPropertyDataTypes } = schemaMod;
                 const KNOWN_MODEL_FALLBACKS = {
                     Post: {
@@ -2534,7 +2639,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 // Infer propertyRecordSchema from metadata when schema is missing (enables persistence)
                 let propSchema = propertySchemas[propertyName];
                 if (!propSchema && isRefTypeFromMeta) {
-                    const schemaMod = await import('./index-DAwvrNga.js');
+                    const schemaMod = await import('./index-C41UZTmQ.js');
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -2791,9 +2896,9 @@ const runPublish = fromCallback(({ sendBack, input: { context } }) => {
                 sendBack({ type: 'publishError', error: new Error(`Item not found for seedLocalId: ${seedLocalId}`) });
                 return;
             }
-            const getPublishUploadsMod = await import('./getPublishUploads-gWv4tDyT.js');
+            const getPublishUploadsMod = await import('./getPublishUploads-CMgzBCzZ.js');
             const { getPublishUploads } = getPublishUploadsMod;
-            const getPublishPayloadMod = await import('./getPublishPayload-DmOu0I29.js');
+            const getPublishPayloadMod = await import('./getPublishPayload-CuRGEZa5.js');
             const { getPublishPayload } = getPublishPayloadMod;
             const uploads = await getPublishUploads(item);
             let uploadedTransactions = [];
@@ -3765,7 +3870,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
     const { isRelation, propertyValue, propertyName, seedUid, propertyRecordSchema, populatedFromDb, schemaUid, } = context;
     const _resolveRelatedValue = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-DAwvrNga.js');
+        const schemaMod = await import('./index-C41UZTmQ.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
@@ -4769,7 +4874,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
     // to use dynamically imported ModelPropertyDataTypes
     const _hydrateFromDb = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-DAwvrNga.js');
+        const schemaMod = await import('./index-C41UZTmQ.js');
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -5132,7 +5237,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                         };
                         // Merge with schema from file/DB to get validation rules (enum, pattern, etc.) - properties table doesn't store these
                         try {
-                            const { getPropertySchema } = await import('./property-eMrSbAWU.js');
+                            const { getPropertySchema } = await import('./property-Bs3a4Dna.js');
                             let schemaFromFile = await getPropertySchema(normalizedModelName, propertyName);
                             if (!schemaFromFile?.validation) {
                                 // Fallback: get validation from schemaData in database (Schema context may not be loaded yet)
@@ -5601,9 +5706,9 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _analyzeInput = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-DAwvrNga.js');
+        const schemaMod = await import('./index-C41UZTmQ.js');
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await import('./SchemaValidationService-B3pQ_q-9.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-BaOkRjsU.js');
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -5801,7 +5906,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await import('./SchemaValidationService-B3pQ_q-9.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-BaOkRjsU.js');
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, normalizeDataType(propertyRecordSchema.dataType), propertyRecordSchema.validation, propertyRecordSchema.refValueType
             ? normalizeDataType(String(propertyRecordSchema.refValueType))
@@ -6394,7 +6499,7 @@ const saveRelation = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _saveRelation = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-DAwvrNga.js');
+        const schemaMod = await import('./index-C41UZTmQ.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
@@ -7143,95 +7248,6 @@ async function runDestroyLifecycle(instance, config) {
     }
 }
 
-/**
- * Creates a reactive Proxy that intercepts property access and assignment
- * to read from and write to an actor service's context.
- *
- * This enables automatic React re-renders when properties change, as the
- * React hooks subscribe to the actor service which gets updated when properties
- * are set via the proxy.
- *
- * @param config Configuration object
- * @returns A proxied instance that behaves like the original but with reactive properties
- *
- * @note TypeScript's Proxy type doesn't automatically preserve method signatures,
- * so we use Proxied<T> to ensure all methods and properties are recognized.
- * The Proxy implementation preserves all methods via Reflect.get, so this is safe.
- */
-function createReactiveProxy(config) {
-    const { instance, trackedProperties, getContext, sendUpdate } = config;
-    // Convert readonly array to regular array for includes() checks
-    const trackedPropsSet = new Set(trackedProperties);
-    // Create the proxy - TypeScript needs explicit type assertion to preserve all methods
-    // The Proxy preserves all methods via Reflect.get, so we assert it maintains type T
-    // Using 'as unknown as T' forces TypeScript to recognize all methods and properties
-    const proxy = new Proxy(instance, {
-        get(target, prop) {
-            // Handle special properties that should not be proxied
-            // These need direct access to the underlying instance
-            if (prop === '_service') {
-                return Reflect.get(target, prop);
-            }
-            // If it's a tracked property, read from actor context
-            if (typeof prop === 'string' && trackedPropsSet.has(prop)) {
-                const context = getContext(instance);
-                return context[prop];
-            }
-            // For methods and non-tracked properties, use Reflect
-            return Reflect.get(target, prop);
-        },
-        set(target, prop, value) {
-            // Handle special properties
-            if (prop === '_service') {
-                return Reflect.set(target, prop, value);
-            }
-            // If it's a tracked property, send update to actor
-            if (typeof prop === 'string' && trackedPropsSet.has(prop)) {
-                sendUpdate(instance, prop, value);
-                return true; // Indicate success
-            }
-            // For non-tracked properties, use Reflect. Also trigger sendUpdate for virtual
-            // 'value' so the callback runs when .value is assigned (e.g. ItemProperty).
-            if (typeof prop === 'string' && prop === 'value') {
-                sendUpdate(instance, prop, value);
-            }
-            return Reflect.set(target, prop, value);
-        },
-        has(target, prop) {
-            // Check if property exists in context or on target
-            if (typeof prop === 'string' && trackedPropsSet.has(prop)) {
-                const context = getContext(instance);
-                return prop in context;
-            }
-            return Reflect.has(target, prop);
-        },
-        ownKeys(target) {
-            // Only return keys that actually exist on the target object
-            // This is required when the target is non-extensible (e.g., frozen by Immer)
-            // Tracked properties are virtual (read from context), so we don't include them here
-            // They're accessible via the get trap, but don't appear in ownKeys
-            return Reflect.ownKeys(target);
-        },
-        getOwnPropertyDescriptor(target, prop) {
-            if (typeof prop === 'string' && trackedPropsSet.has(prop)) {
-                const context = getContext(instance);
-                if (prop in context) {
-                    return {
-                        enumerable: true,
-                        configurable: true,
-                        value: context[prop],
-                        writable: true,
-                    };
-                }
-            }
-            return Reflect.getOwnPropertyDescriptor(target, prop);
-        }
-    });
-    // Force TypeScript to recognize all methods and properties are preserved
-    // The Proxy implementation preserves all methods via Reflect.get, so this is safe
-    return proxy;
-}
-
 /** Parent Html property `propertyValue` after publish (66-char seed uid). */
 const HTML_PROP_SEED_UID_RE = /^0x[a-fA-F0-9]{64}$/;
 // Start loading Model at module load time (non-blocking)
@@ -7438,7 +7454,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await import('./index-DAwvrNga.js');
+            const schemaMod = await import('./index-C41UZTmQ.js');
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -8751,12 +8767,12 @@ class Item {
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const getPublishUploadsMod = await import('./getPublishUploads-gWv4tDyT.js');
+            const getPublishUploadsMod = await import('./getPublishUploads-CMgzBCzZ.js');
             const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this, [], undefined, options);
         };
         this.getPublishPayload = async (uploadedTransactions, options) => {
-            const getPublishPayloadMod = await import('./getPublishPayload-DmOu0I29.js');
+            const getPublishPayloadMod = await import('./getPublishPayload-CuRGEZa5.js');
             const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions, options);
         };
@@ -8875,6 +8891,7 @@ class Item {
             'latestVersionUid',
             'publishedVersionUid',
             'publishedVersionLocalId',
+            'revokedAt',
         ];
         const keysFromInitial = Object.keys(initialValues).filter((key) => !metadataKeys.includes(key));
         const schemaNameForModel = initialValues.schemaName;
@@ -9180,19 +9197,14 @@ class Item {
                         return Reflect.ownKeys(target);
                     },
                     getOwnPropertyDescriptor(target, prop) {
-                        // Handle tracked properties
+                        let invent;
                         if (typeof prop === 'string' && TRACKED_PROPERTIES$1.includes(prop)) {
                             const context = target._getSnapshotContext();
                             if (prop in context) {
-                                return {
-                                    enumerable: true,
-                                    configurable: true,
-                                    value: context[prop],
-                                    writable: true,
-                                };
+                                invent = { value: context[prop] };
                             }
                         }
-                        return Reflect.getOwnPropertyDescriptor(target, prop);
+                        return getInvariantSafePropertyDescriptor(target, prop, invent);
                     },
                 });
                 this.registerItemInInstanceCache(proxiedInstance);
@@ -9364,19 +9376,14 @@ class Item {
                 return Reflect.ownKeys(target);
             },
             getOwnPropertyDescriptor(target, prop) {
-                // Handle tracked properties
+                let invent;
                 if (typeof prop === 'string' && TRACKED_PROPERTIES$1.includes(prop)) {
                     const context = target._getSnapshotContext();
                     if (prop in context) {
-                        return {
-                            enumerable: true,
-                            configurable: true,
-                            value: context[prop],
-                            writable: true,
-                        };
+                        invent = { value: context[prop] };
                     }
                 }
-                return Reflect.getOwnPropertyDescriptor(target, prop);
+                return getInvariantSafePropertyDescriptor(target, prop, invent);
             },
         });
         this.registerItemInInstanceCache(proxiedInstance);
@@ -9690,6 +9697,7 @@ class Item {
                 }
             },
             enumerable: true,
+            configurable: true,
         });
         state.definedPropertyNames.add(propertyName);
     }
@@ -10429,7 +10437,7 @@ const runEasSync = fromPromise(async ({ input, }) => {
         requestPayload: input.requestPayload,
         persistedSnapshot: input.runningSnapshot,
     });
-    const { runSyncFromEas } = await import('./syncDbWithEas-c9Xe17zq.js');
+    const { runSyncFromEas } = await import('./syncDbWithEas-DRpLRxwb.js');
     try {
         await runSyncFromEas(toRunSyncArg(input.options));
         await finalizeEasSyncProcessRow(rowId, {
@@ -12443,7 +12451,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         }
     }
     // Check if this is an internal SDK schema (should not create files in app directory)
-    const constantsMod = await import('./constants-DMHTYMgJ.js');
+    const constantsMod = await import('./constants-Bre6dTJR.js');
     const { isInternalSchema, INTERNAL_SCHEMA_IDS } = constantsMod;
     const isInternal = isInternalSchema(schemaFile.metadata.name, schemaFile.id);
     if (isInternal) {
@@ -12546,7 +12554,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
             updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
         };
         // Use dynamic import to break circular dependency
-        const _mod_20 = await import('./db-BwVuO1tO.js');
+        const _mod_20 = await import('./db-DVsy4QZe.js');
         const _ns_20 = _mod_20.q;
         const dbMod = _ns_20;
         const { addSchemaToDb, addModelsToDb } = dbMod;
@@ -12775,7 +12783,7 @@ async function applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, prope
         createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
         updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
     };
-    const _mod_23 = await import('./db-BwVuO1tO.js');
+    const _mod_23 = await import('./db-DVsy4QZe.js');
     const _ns_23 = _mod_23.q;
     const dbMod = _ns_23;
     const { addSchemaToDb, addModelsToDb } = dbMod;
@@ -14911,7 +14919,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-DMjKVphl.js')
+const modelPropertyImportPromise = import('./ModelProperty-BiDQu5rE.js')
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -14928,7 +14936,7 @@ function getModelProperty() {
 }
 // Lazy import cache for Schema to avoid circular dependency
 let SchemaClass = null;
-const schemaImportPromise = (async () => { const _mod_28 = await import('./Schema-cK2z7wet.js'); return _mod_28.b; })()
+const schemaImportPromise = (async () => { const _mod_28 = await import('./Schema-qciDB7Nu.js'); return _mod_28.b; })()
     .then(module => {
     SchemaClass = module.Schema;
     return SchemaClass;
@@ -15386,37 +15394,25 @@ class Model {
             getOwnPropertyDescriptor(target, prop) {
                 // Handle 'name' as an alias for 'modelName'
                 if (prop === 'name') {
-                    const context = target._getSnapshotContext();
-                    return {
-                        enumerable: true,
-                        configurable: true,
-                        value: context.modelName,
-                        writable: true,
-                    };
+                    return getInvariantSafePropertyDescriptor(target, prop, {
+                        value: target._getSnapshotContext().modelName,
+                    });
                 }
                 // Handle 'id' property - returns the modelFileId
                 if (prop === 'id') {
-                    const context = target._getSnapshotContext();
-                    return {
-                        enumerable: true,
-                        configurable: true,
-                        value: context.id, // id is now the schemaFileId (string)
+                    return getInvariantSafePropertyDescriptor(target, prop, {
+                        value: target._getSnapshotContext().id, // id is now the schemaFileId (string)
                         writable: false, // id is read-only
-                    };
+                    });
                 }
-                // Handle tracked properties
+                let invent;
                 if (typeof prop === 'string' && TRACKED_PROPERTIES.includes(prop)) {
                     const context = target._getSnapshotContext();
                     if (prop in context) {
-                        return {
-                            enumerable: true,
-                            configurable: true,
-                            value: context[prop],
-                            writable: true,
-                        };
+                        invent = { value: context[prop] };
                     }
                 }
-                return Reflect.getOwnPropertyDescriptor(target, prop);
+                return getInvariantSafePropertyDescriptor(target, prop, invent);
             },
         });
         // Step 8: Store in new ID-based cache
@@ -16669,4 +16665,4 @@ const TModelValues = Type.Record(Type.String(), Type.Any());
 const TModelSchema = Type.Record(Type.String(), TProperty);
 
 export { ownedPublisherSql as $, compareMetadataRowsLatestFirst as A, ADDRESSES_PERSISTED_EVENT as B, ClientManager as C, claimUnpublishedDrafts as D, createLocalQueryDataSource as E, createNewItem as F, createSchema as G, easSyncActor as H, Item as I, getClient as J, getGetPublisherForNewSeeds as K, LOCAL_COPIES_REMOVED_EVENT as L, Model as M, getMetadataLatest as N, getPublishedSeedRecord as O, getRevokeExecutor as P, getSchemaNameFromId as Q, getUploadExecutor as R, getVersionData$1 as S, TModelSchema as T, isItemOwned as U, isLocalUnsealedDraft as V, isSeedQueryLocalSourceRegistered as W, isSeedRowOwned as X, listCompleteSchemaFiles as Y, loadAllSchemasFromDb as Z, mergeEasSyncRequestIntents as _, TModelValues as a, parseAddressesPersistedPayload as a0, propertyMachine as a1, publisherInAddressListSql as a2, publisherIsInOwnedSet as a3, readSchema as a4, registerSeedQueryLocalSource as a5, requestEasSyncFromAddressChange as a6, requestEasSyncFromEventBus as a7, requestEasSyncFromModelsInit as a8, sendEasSyncClientRequest as a9, setAdditionalSyncAddresses as aa, setGetPublisherForNewSeeds as ab, setRevokeExecutor as ac, setUploadExecutor as ad, startEasSyncActor as ae, unregisterSeedQueryLocalSource as af, createModelsFromJson as ag, getLatestSchemaVersion as ah, createModelFromJson as ai, ConflictError as aj, unloadEntity as ak, clearDestroySubscriptions as al, setupEntityLiveQuery as am, generateId$1 as an, model as ao, getPropertyData$1 as ap, Item$1 as aq, schema as ar, SEEDPROTOCOL_Seed_Protocol_v1 as as, Model$1 as at, getItemData as b, getEasSchemaUidForModel as c, getLatestPublishedVersionRow as d, getEasSchemaForItemProperty as e, eventEmitter as f, getContentHash as g, generateId as h, getGetAdditionalSyncAddresses as i, ItemProperty as j, getRefValueType as k, importJsonSchema as l, modelPropertiesToObject as m, loadSchemaFromFile as n, readJsonImportFile as o, parseListPropertyValueFromStorage as p, syncSchemaFromSource as q, resolveStorageNameToSchemaName as r, scheduleBulkFilesDownloadFromEasSync as s, transformImportToSchemaFile as t, waitForEntityIdle as u, createReactiveProxy as v, writeProcessMachine as w, findEntity as x, forceRemoveFromCaches as y, runDestroyLifecycle as z };
-//# sourceMappingURL=index-C1pktvdj.js.map
+//# sourceMappingURL=index-DjwIC6U3.js.map