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

package/dist/{Item-D6j0IvBP.js → Item-BiMHgg-_.js}

@@ -1,13 +1,13 @@
 import { waitFor, fromCallback, setup, assign, stateIn, createActor, isMachineSnapshot } from 'xstate';
-import { B as BaseDb, F as versions, m as metadata, C as seeds, G as resolveStorageNameToSchemaName, a$ as toSchemaPropertyName, i as isDataType, A as schemas, t as models, r as modelSchemas, aZ as getOwnedAddressesFromDb, a2 as ZERO_BYTES32, aF as normalizeAddressList, aj as normalizeHexAddress, aC as getAddressesForItemsFilter, a6 as INTERNAL_PROPERTY_NAMES, b0 as easSchemaDefinitionForProperty, h as BaseFileManager, b1 as getStorageTransactionIdForSeedUid, b2 as convertTxIdToImage, ae as normalizePublisher, n as normalizeDataType, b3 as getMetadataPropertyNamesForQuery, aB as ensureImageLocal, at as ImageSize, b4 as downloadTransactionIdWithDedupe, b5 as resolveMetadataRecord, v as properties, M as ModelPropertyDataTypes, ai as generateId, a9 as INTERNAL_DATA_TYPES, s as modelUids, aa as listRelationEasPropertyName, ab as easPropertyNameForPublish, L as resolveItemModelFileId, b6 as getPropertyIdForSchemaFileId, K as getPropertyIdForModelAndName, ak as toMetadataPropertyName, b7 as getDataTypeFromString, b8 as getMimeType, X as INTERNAL_STORAGE_MODEL_FILE_IDS, $ as getItemStorageSubdir, a0 as getItemStorageLocalFileName, g as normalizePropertyRecordSchema, b9 as listRelationStoragePropertyName, ba as PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP, Q as getCorrectId, I as eventEmitter, bb as getAlternatePropertyNameForInstanceLookup, a7 as isStorageSeedRef } from './index-DpgQMIRq.js';
+import { B as BaseDb, F as versions, m as metadata, C as seeds, G as resolveStorageNameToSchemaName, a$ as toSchemaPropertyName, i as isDataType, A as schemas, t as models, r as modelSchemas, aZ as getOwnedAddressesFromDb, a2 as ZERO_BYTES32, aF as normalizeAddressList, ai as normalizeHexAddress, aC as getAddressesForItemsFilter, a6 as INTERNAL_PROPERTY_NAMES, b0 as easSchemaDefinitionForProperty, h as BaseFileManager, b1 as getStorageTransactionIdForSeedUid, b2 as convertTxIdToImage, ac as normalizePublisher, n as normalizeDataType, b3 as getMetadataPropertyNamesForQuery, aB as ensureImageLocal, at as ImageSize, b4 as downloadTransactionIdWithDedupe, b5 as resolveMetadataRecord, v as properties, M as ModelPropertyDataTypes, ah as generateId, a9 as INTERNAL_DATA_TYPES, s as modelUids, aa as listRelationEasPropertyName, ab as easPropertyNameForPublish, L as resolveItemModelFileId, b6 as getPropertyIdForSchemaFileId, K as getPropertyIdForModelAndName, aj as toMetadataPropertyName, b7 as getDataTypeFromString, b8 as getMimeType, X as INTERNAL_STORAGE_MODEL_FILE_IDS, $ as getItemStorageSubdir, a0 as getItemStorageLocalFileName, g as normalizePropertyRecordSchema, b9 as listRelationStoragePropertyName, ba as PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP, Q as getCorrectId, I as eventEmitter, bb as toItemPropertyKey, bc as getAlternatePropertyNameForInstanceLookup, a7 as isStorageSeedRef } from './index-C-NqjjY_.js';
 import { or, isNull, eq, max, count, and, getTableColumns, sql, desc, inArray, gt, isNotNull } from 'drizzle-orm';
 import pluralize from 'pluralize';
 import debug from 'debug';
 import { BehaviorSubject } from 'rxjs';
 import { startCase, upperFirst, camelCase, orderBy } from 'lodash-es';
 import { isValidEasAttestationUid, easName, isPlaceholderUid, BaseQueryClient, BaseEasClient, GET_SCHEMAS, getEasSchemaUidForSchemaDefinition, getSchemaUidForModelFromCache, setSchemaUidForModel, cachedSchemaLookup, getEasSchemaUidForExactDefinition } from '@seedprotocol/eas';
+import { c as createSessionObjectUrl, f as notifyFileSaved, g as withTabLock, r as revokeSessionObjectUrl, h as isSessionObjectUrl } from './tabEvents-UH-wNsZC.js';
 import { fetchArweaveRawTextAcrossGateways } from '@seedprotocol/arweave';
-import { d as notifyFileSaved, f as withTabLock } from './tabEvents-DksXwk3X.js';
 import { modelPropertiesToObject } from './model-oHA3YhOd.js';
 
 /**
@@ -144,6 +144,29 @@ var publishConfig = /*#__PURE__*/Object.freeze({
     setUploadExecutor: setUploadExecutor
 });
 
+/**
+ * Common getters and utilities for entity classes
+ * These work with any entity that has a getService() method returning an XState actor
+ */
+/**
+ * Get the current state value from an entity's service
+ */
+/**
+ * Whether two references are the same entity: an instance and its reactive proxy are different
+ * objects that share one actor.
+ */
+function sameEntity(a, b) {
+    return a === b || a.getService() === b.getService();
+}
+/**
+ * Whether an actor has been stopped (unload, destroy, or Schema eviction). Async work started by an
+ * entity (DB lookups, retry timers) must check this before sending, since a stopped actor ignores
+ * events and XState warns about every one of them.
+ */
+function isActorStopped(actor) {
+    return actor.getSnapshot().status === 'stopped';
+}
+
 /**
  * Proxy [[GetOwnProperty]] that stays compatible with the target.
  * Never overrides an own descriptor, never invents on a non-extensible target,
@@ -180,7 +203,7 @@ function getInvariantSafePropertyDescriptor(target, prop, invent) {
  * The Proxy implementation preserves all methods via Reflect.get, so this is safe.
  */
 function createReactiveProxy(config) {
-    const { instance, trackedProperties, getContext, sendUpdate } = config;
+    const { instance, trackedProperties, getContext, sendUpdate, resolve, virtualKeys, onSet } = 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
@@ -198,6 +221,9 @@ function createReactiveProxy(config) {
                 const context = getContext(instance);
                 return context[prop];
             }
+            const virtual = typeof prop === 'string' ? resolve?.(instance, prop) : undefined;
+            if (virtual)
+                return virtual.get();
             // For methods and non-tracked properties, use Reflect
             return Reflect.get(target, prop);
         },
@@ -211,10 +237,15 @@ function createReactiveProxy(config) {
                 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);
+            if (typeof prop === 'string') {
+                const virtual = resolve?.(instance, prop);
+                if (virtual) {
+                    if (!virtual.set)
+                        throw new TypeError(`Cannot set ${prop}: it is read-only.`);
+                    virtual.set(value);
+                    return true;
+                }
+                onSet?.(instance, prop, value);
             }
             return Reflect.set(target, prop, value);
         },
@@ -224,14 +255,19 @@ function createReactiveProxy(config) {
                 const context = getContext(instance);
                 return prop in context;
             }
+            if (typeof prop === 'string' && resolve?.(instance, prop))
+                return true;
             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);
+            // 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. Resolved names do, when
+            // the target is extensible (a non-extensible one, e.g. frozen by Immer, can't report them).
+            const keys = Reflect.ownKeys(target);
+            if (!virtualKeys || !Object.isExtensible(target))
+                return keys;
+            const extra = virtualKeys(instance).filter((key) => !keys.includes(key));
+            return extra.length > 0 ? [...keys, ...extra] : keys;
         },
         getOwnPropertyDescriptor(target, prop) {
             let invent;
@@ -241,6 +277,11 @@ function createReactiveProxy(config) {
                     invent = { value: context[prop] };
                 }
             }
+            else if (typeof prop === 'string') {
+                const virtual = resolve?.(instance, prop);
+                if (virtual)
+                    invent = { value: virtual.get(), writable: !!virtual.set };
+            }
             return getInvariantSafePropertyDescriptor(target, prop, invent);
         }
     });
@@ -580,8 +621,8 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
         const itemPropertyMod = await Promise.resolve().then(function () { return ItemProperty$1; });
         const { ItemProperty } = itemPropertyMod;
         const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
-        const _mod_0 = await import('./errors-KM-yq2MD.js');
-        const _ns_0 = _mod_0.j;
+        const _mod_0 = await import('./errors-CQagdED2.js');
+        const _ns_0 = _mod_0.i;
         const { Model } = _ns_0;
         // Resolve Model and build property schemas (use getByNameAsync for models not yet in cache)
         let propertySchemas = {};
@@ -598,10 +639,10 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             const schemaNameToTry = schemaName ?? model?.schemaName;
             if (schemaNameToTry) {
                 try {
-                    const _mod_1 = await import('./Schema-O1QLoXv6.js');
+                    const _mod_1 = await import('./Schema-COTbavcm.js');
                     const _ns_1 = _mod_1.b;
                     const { Schema } = _ns_1;
-                    const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false });
+                    const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false, hold: false });
                     const schemaContext = schemaInstance.getService().getSnapshot().context;
                     if (schemaContext.models?.[modelName]?.properties) {
                         propertySchemas = schemaContext.models[modelName].properties;
@@ -614,7 +655,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             }
             if (Object.keys(propertySchemas).length === 0) {
                 try {
-                    const _mod_2 = await import('./ClientManager-2GtDWHq6.js');
+                    const _mod_2 = await import('./ClientManager-DBKvmJov.js');
                     const _ns_2 = _mod_2.N;
                     const { loadAllSchemasFromDb } = _ns_2;
                     const allSchemas = await loadAllSchemasFromDb();
@@ -635,11 +676,11 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             }
             if (Object.keys(propertySchemas).length === 0) {
                 try {
-                    const _mod_3 = await import('./ClientManager-2GtDWHq6.js');
+                    const _mod_3 = await import('./ClientManager-DBKvmJov.js');
                     const _ns_3 = _mod_3.N;
                     const { listCompleteSchemaFiles } = _ns_3;
-                    const _mod_4 = await import('./index-DpgQMIRq.js');
-                    const _ns_4 = _mod_4.be;
+                    const _mod_4 = await import('./index-C-NqjjY_.js');
+                    const _ns_4 = _mod_4.bf;
                     const { BaseFileManager } = _ns_4;
                     const schemaFiles = await listCompleteSchemaFiles();
                     for (const { filePath } of schemaFiles) {
@@ -659,7 +700,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
-                const schemaMod = await import('./index-BAao3_Po.js');
+                const schemaMod = await import('./index-DM3zrNtX.js');
                 const { ModelPropertyDataTypes } = schemaMod;
                 const KNOWN_MODEL_FALLBACKS = {
                     Post: {
@@ -676,7 +717,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             }
         }
         // Fallbacks above may return schema-file shape ({ type, model, items }); normalize to dataType/ref/refValueType.
-        const { normalizePropertyRecordSchema } = await import('./property-BDBvImLs.js');
+        const { normalizePropertyRecordSchema } = await import('./property-DaUy4XMe.js');
         propertySchemas = Object.fromEntries(Object.entries(propertySchemas).map(([name, def]) => [name, normalizePropertyRecordSchema(def)]));
         // Collapse rows that map to the same instance key (e.g. authorIdentityIds + authors -> authors).
         // ItemProperty.create cache does not sync propertyValue on hit; processing order would otherwise
@@ -709,7 +750,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-BAao3_Po.js');
+                    const schemaMod = await import('./index-DM3zrNtX.js');
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -739,7 +780,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                         : metaRow.refResolvedDisplayValue ?? undefined,
                     localStorageDir: metaRow.localStorageDir ?? undefined,
                 };
-                const property = ItemProperty.create(createProps, { waitForReady: false });
+                const property = ItemProperty.create(createProps, { waitForReady: false, hold: false });
                 if (property) {
                     propertyInstances.set(propertyName, property);
                     logger$9(`Created/cached ItemProperty instance for propertyName "${propertyName}" with propertyRecordSchema: ${!!createProps.propertyRecordSchema}`);
@@ -769,7 +810,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                     schemaUid: undefined,
                     propertyRecordSchema: propSchema,
                 };
-                const property = ItemProperty.create(createProps, { waitForReady: false });
+                const property = ItemProperty.create(createProps, { waitForReady: false, hold: false });
                 if (property) {
                     propertyInstances.set(propertyName, property);
                     logger$9(`Created placeholder ItemProperty for model property "${propertyName}" (no metadata)`);
@@ -1026,7 +1067,7 @@ const itemMachineSingle = setup({
         },
         updateProperties: {
             actions: assign({
-                propertiesUpdatedAt: Date.now(),
+                propertiesUpdatedAt: () => Date.now(),
             }),
         },
         updateValue: {
@@ -1070,9 +1111,11 @@ const itemMachineSingle = setup({
         },
         updateContext: {
             actions: assign(({ context, event }) => {
+                // Every key the event carries: one sent before loading sets it (revokedAt, versionsCount,
+                // createdAt) must not be dropped because the context doesn't have it yet.
                 const updates = {};
                 for (const key in event) {
-                    if (key !== 'type' && key in context) {
+                    if (key !== 'type') {
                         updates[key] = event[key];
                     }
                 }
@@ -1715,8 +1758,8 @@ const getItemsData = async ({ modelName, modelFileId, schemaName, deleted, inclu
         conditions.push(eq(seeds.type, easName(modelName)));
     }
     if (!modelFileId && schemaName && modelName) {
-        const _mod_5 = await import('./index-DpgQMIRq.js');
-        const _ns_5 = _mod_5.bh;
+        const _mod_5 = await import('./index-C-NqjjY_.js');
+        const _ns_5 = _mod_5.bi;
         const { resolveModelRecord } = _ns_5;
         modelFileId = (await resolveModelRecord(modelName, { schemaName }))?.schemaFileId ?? undefined;
         if (!modelFileId)
@@ -2001,7 +2044,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
     const { isRelation, propertyValue, propertyName, propertyRecordSchema, populatedFromDb, } = context;
     const _resolveRelatedValue = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-BAao3_Po.js');
+        const schemaMod = await import('./index-DM3zrNtX.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
@@ -2436,8 +2479,8 @@ async function readHtmlBodyFromChildStorageArweave(seedLocalId) {
         /* offline / bad tx id */
     }
     try {
-        const _mod_6 = await import('./index-DpgQMIRq.js');
-        const _ns_6 = _mod_6.bj;
+        const _mod_6 = await import('./index-C-NqjjY_.js');
+        const _ns_6 = _mod_6.bk;
         const { downloadTransactionIdWithDedupe } = _ns_6;
         await downloadTransactionIdWithDedupe(txId);
         const retryFp = BaseFileManager.getFilesPath('html', `${seedLocalId}.html`);
@@ -2497,7 +2540,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-BAao3_Po.js');
+        const schemaMod = await import('./index-DM3zrNtX.js');
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -2598,7 +2641,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
                     localStorageDir = `/${dir}`;
                     if (filePath) {
                         const file = await BaseFileManager.readFile(filePath);
-                        refResolvedDisplayValue = URL.createObjectURL(file);
+                        refResolvedDisplayValue = createSessionObjectUrl(file);
                         renderValue = refResolvedDisplayValue;
                         // Do not persist blob URL - it is session-scoped
                     }
@@ -2779,12 +2822,12 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
             const modelNameForNew = context.modelName;
             if (modelNameForNew) {
                 try {
-                    const _mod_7 = await import('./errors-KM-yq2MD.js');
-                    const _ns_7 = _mod_7.j;
+                    const _mod_7 = await import('./errors-CQagdED2.js');
+                    const _ns_7 = _mod_7.i;
                     const { Model } = _ns_7;
                     const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
-                    const _mod_8 = await import('./index-DpgQMIRq.js');
-                    const _ns_8 = _mod_8.bh;
+                    const _mod_8 = await import('./index-C-NqjjY_.js');
+                    const _ns_8 = _mod_8.bi;
                     const { resolveItemModelFileId } = _ns_8;
                     const normalizedModelName = upperFirst(camelCase(modelNameForNew));
                     const itemModelFileId = await resolveItemModelFileId({
@@ -2837,8 +2880,8 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
         // It ends up in the context below, and later lookups by name (Model.getByName) can't match it.
         const modelName = context.modelName || (metadataRecord.modelType ? upperFirst(camelCase(metadataRecord.modelType)) : undefined);
         // Model names are only unique per schema: pin lookups to the item's own model row.
-        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 { resolveItemModelFileId, resolveModelRecord } = _ns_9;
         const modelFileId = await resolveItemModelFileId({
             modelFileId: context.modelFileId,
@@ -2882,7 +2925,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                             required: propRecord.required ?? undefined,
                         };
                         // Validation rules (enum, pattern, ...) aren't in the properties table
-                        const { resolvePropertyValidationRules } = await import('./propertyValidationRules-BlfLn4rP.js');
+                        const { resolvePropertyValidationRules } = await import('./propertyValidationRules-DbbWvBzj.js');
                         const validation = await resolvePropertyValidationRules(normalizedModelName, propertyName, {
                             modelFileId: modelRecord?.schemaFileId ?? modelFileId,
                         });
@@ -2900,8 +2943,8 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
         // Fix 1: Fallback to in-memory Model when DB doesn't have model/properties yet (e.g. runtime-created model)
         if (!propertyRecordSchema && modelName) {
             try {
-                const _mod_10 = await import('./errors-KM-yq2MD.js');
-                const _ns_10 = _mod_10.j;
+                const _mod_10 = await import('./errors-CQagdED2.js');
+                const _ns_10 = _mod_10.i;
                 const { Model } = _ns_10;
                 const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
                 const normalizedModelName = upperFirst(camelCase(modelName));
@@ -3039,7 +3082,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                 const filePath = await resolveMatchingFilePath(dir, metadataRecord.refResolvedValue);
                 if (filePath) {
                     const file = await BaseFileManager.readFile(filePath);
-                    const freshBlobUrl = URL.createObjectURL(file);
+                    const freshBlobUrl = createSessionObjectUrl(file);
                     renderValue = freshBlobUrl;
                     refResolvedDisplayValue = freshBlobUrl;
                 }
@@ -3389,9 +3432,9 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
             return false;
         }
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-BAao3_Po.js');
+        const schemaMod = await import('./index-DM3zrNtX.js');
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await import('./SchemaValidationService-BxCbfDaI.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-paOfbcwd.js');
         const propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -3704,7 +3747,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await import('./SchemaValidationService-BxCbfDaI.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-paOfbcwd.js');
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, normalizeDataType(propertyRecordSchema.dataType), propertyRecordSchema.validation, propertyRecordSchema.refValueType
             ? normalizeDataType(String(propertyRecordSchema.refValueType))
@@ -4898,6 +4941,8 @@ const propertyMachine = setup({
                 actions: assign({
                     isSaving: false,
                     _saveValidationErrors: undefined,
+                    // Only a refused or failed save restores it; kept after success, it pinned the old value.
+                    _valueBeforeSave: undefined,
                 }),
             },
         },
@@ -4919,11 +4964,11 @@ const getPropertyData = async ({ propertyName, seedLocalId, seedUid, modelName,
     let names = [...getMetadataPropertyNamesForQuery(propertyName)];
     if (modelName) {
         try {
-            const _mod_11 = await import('./errors-KM-yq2MD.js');
-            const _ns_11 = _mod_11.j;
+            const _mod_11 = await import('./errors-CQagdED2.js');
+            const _ns_11 = _mod_11.i;
             const { Model } = _ns_11;
-            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 { resolveItemModelFileId } = _ns_12;
             // Model names are only unique per schema: use the seed's own model when it is recorded.
             const modelFileId = await resolveItemModelFileId({ seedLocalId, seedUid });
@@ -4979,26 +5024,30 @@ var getPropertyData$1 = /*#__PURE__*/Object.freeze({
 function unloadEntity(instance, config) {
     // Get cache keys for this instance
     const cacheKeys = config.getCacheKeys(instance);
-    // Remove from all caches (decrement refCount, delete if 0)
-    let stillReferenced = false;
+    // Release one hold per entry. An entry stored under several keys (a name and an id) is one
+    // instance's count: decrement it once, and when it reaches 0 delete every key that holds it.
+    const found = [];
     for (const cache of config.caches) {
         for (const key of cacheKeys) {
             const entry = cache.get(key);
-            if (entry) {
-                entry.refCount -= 1;
-                if (entry.refCount <= 0) {
-                    cache.delete(key);
-                    // Also remove from secondary caches if provided
-                    if (config.secondaryCaches) {
-                        for (const secondaryCache of config.secondaryCaches) {
-                            secondaryCache.delete(key);
-                        }
-                    }
-                }
-                else {
-                    cache.set(key, entry);
-                    stillReferenced = true;
-                }
+            if (entry)
+                found.push({ cache, key, entry });
+        }
+    }
+    const entries = new Set(found.map(({ entry }) => entry));
+    for (const entry of entries)
+        entry.refCount -= 1;
+    let stillReferenced = false;
+    for (const { cache, key, entry } of found) {
+        if (entry.refCount > 0) {
+            stillReferenced = true;
+            continue;
+        }
+        cache.delete(key);
+        // Also remove from secondary caches if provided
+        if (config.secondaryCaches) {
+            for (const secondaryCache of config.secondaryCaches) {
+                secondaryCache.delete(key);
             }
         }
     }
@@ -5041,20 +5090,50 @@ function unloadEntity(instance, config) {
     }
 }
 
+/**
+ * Per-instance state for an entity (liveQuery subscriptions and the like), keyed by the entity's
+ * actor. An entity's raw instance and its reactive proxy are different objects that share one
+ * actor. State set from the constructor (`this` = raw instance) must be found again from methods
+ * called on the proxy (`this` = proxy), so a WeakMap keyed by the instance misses there.
+ *
+ * `getService()` must return the actor before the first `set`.
+ */
+class ActorKeyedState {
+    constructor() {
+        this.states = new WeakMap();
+    }
+    get(instance) {
+        return this.states.get(instance.getService());
+    }
+    set(instance, state) {
+        this.states.set(instance.getService(), state);
+        return this;
+    }
+    delete(instance) {
+        return this.states.delete(instance.getService());
+    }
+    has(instance) {
+        return this.states.has(instance.getService());
+    }
+}
+
 /**
  * Shared helpers for entity destroy operations.
  * Used by Schema, Model, ModelProperty, Item, and ItemProperty destroy() methods.
  */
 /**
- * Unsubscribe liveQuery and any extra subscription (e.g. Item/ItemProperty _subscription).
- * Swallows errors so one failure doesn't block the rest.
+ * Unsubscribe the entity's liveQueries and any extra subscription (e.g. Item/ItemProperty
+ * _subscription). Swallows errors so one failure doesn't block the rest.
  */
 function clearDestroySubscriptions(instance, config) {
     const instanceState = config.instanceState.get(instance);
-    if (instanceState?.liveQuerySubscription) {
+    for (const key of ['liveQuerySubscription', 'schemaLiveQuerySubscription']) {
+        const subscription = instanceState?.[key];
+        if (!subscription)
+            continue;
         try {
-            instanceState.liveQuerySubscription.unsubscribe();
-            instanceState.liveQuerySubscription = null;
+            subscription.unsubscribe();
+            instanceState[key] = null;
         }
         catch {
             // Ignore errors during cleanup
@@ -5123,7 +5202,7 @@ const HTML_PROP_SEED_UID_RE = /^0x[a-fA-F0-9]{64}$/;
  */
 const resolvePropertyRecordSchemaFromSchemaData = async (modelName, propertyName, modelType, schemaName) => {
     try {
-        const _mod_13 = await import('./ClientManager-2GtDWHq6.js');
+        const _mod_13 = await import('./ClientManager-DBKvmJov.js');
         const _ns_13 = _mod_13.N;
         const { loadAllSchemasFromDb } = _ns_13;
         const allSchemas = await loadAllSchemasFromDb();
@@ -5177,29 +5256,29 @@ hints = {}) => {
         return undefined;
     }
     try {
-        const _mod_14 = await import('./errors-KM-yq2MD.js');
-        const _ns_14 = _mod_14.j;
+        const _mod_14 = await import('./errors-CQagdED2.js');
+        const _ns_14 = _mod_14.i;
         const { Model } = _ns_14;
         const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
-        const _mod_15 = await import('./index-DpgQMIRq.js');
-        const _ns_15 = _mod_15.bh;
+        const _mod_15 = await import('./index-C-NqjjY_.js');
+        const _ns_15 = _mod_15.bi;
         const { resolveItemModelFileId } = _ns_15;
         const modelFileId = await resolveItemModelFileId(hints);
         let model = modelFileId
             ? await Model.resolveAsync(modelName || modelTypeToModelName(modelType ?? ''), { modelFileId })
             : undefined;
         if (!model?.properties?.length && modelName) {
-            model = Model.getByName(modelName);
+            model = Model.peekByName(modelName);
         }
         if (!model?.properties?.length && modelType) {
             model = Model.findByModelType(modelType);
         }
         // Fallback: load from DB when not in cache (fixes external app persistence when Model not yet loaded)
         if (!model?.properties?.length && modelName) {
-            model = await Model.getByNameAsync(modelName);
+            model = await Model.getByNameAsync(modelName, undefined, { hold: false });
         }
         if (!model?.properties?.length && modelType) {
-            model = await Model.getByNameAsync(modelTypeToModelName(modelType));
+            model = await Model.getByNameAsync(modelTypeToModelName(modelType), undefined, { hold: false });
         }
         if (!model?.properties?.length) {
             // Fallback: resolve from schema JSON when Model not in cache/DB (e.g. PermaPress sync failed but schema in DB)
@@ -5244,9 +5323,43 @@ const TRACKED_PROPERTIES$1 = [
     'localId',
     'uid',
 ];
-// WeakMap to store mutable state per ItemProperty instance
-// This avoids issues with read-only properties when instances are frozen by Immer
-const itemPropertyInstanceState = new WeakMap();
+// SDK-minted blob URLs a property's context has held, by actor (the raw instance and its proxy share
+// one). An entry no context field references any more is revoked; the rest are revoked on unload.
+const heldObjectUrls = new WeakMap();
+const trackHeldObjectUrls = (context, held) => {
+    const referenced = new Set([
+        context.refResolvedDisplayValue,
+        context.renderValue,
+        context.propertyValue,
+        // Restored if the pending save is refused.
+        context._valueBeforeSave?.renderValue,
+        context._valueBeforeSave?.propertyValue,
+    ].filter(isSessionObjectUrl));
+    for (const url of held) {
+        if (!referenced.has(url)) {
+            held.delete(url);
+            revokeSessionObjectUrl(url);
+        }
+    }
+    for (const url of referenced)
+        held.add(url);
+};
+const revokeHeldObjectUrls = (service) => {
+    const held = heldObjectUrls.get(service);
+    if (!held)
+        return;
+    for (const url of held)
+        revokeSessionObjectUrl(url);
+    held.clear();
+};
+// Mutable state per ItemProperty instance
+const itemPropertyInstanceState = new ActorKeyedState();
+/**
+ * Each cached instance's entry in `ItemProperty.instanceCache`, keyed by its actor. Every key the
+ * instance is cached under shares this one entry, so `retain` and the constructor's re-keying find
+ * it without scanning the cache.
+ */
+const cacheEntries = new WeakMap();
 /** Thrown by ItemProperty.save() when the value failed validation (enum, pattern, minLength, maxLength). */
 class ItemPropertySaveValidationError extends Error {
     constructor(message, validationErrors) {
@@ -5336,25 +5449,34 @@ class ItemProperty {
         this._service = createActor(propertyMachine, {
             input: serviceInput,
         });
+        // Synchronous and reading the latest snapshot: the async subscriber below can run on stale ones.
+        const held = new Set();
+        heldObjectUrls.set(this._service, held);
+        this._service.subscribe(() => trackHeldObjectUrls(this._service.getSnapshot().context, held));
         this._subscription = this._service.subscribe(async (snapshot) => {
             if (!snapshot || !snapshot.context) {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await import('./index-BAao3_Po.js');
+            const schemaMod = await import('./index-DM3zrNtX.js');
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
             if (context.seedLocalId && context.propertyName) {
                 const cacheKey = ItemProperty.cacheKey(context.seedLocalId, context.propertyName);
-                if (!ItemProperty.instanceCache.has(cacheKey)) {
-                    ItemProperty.instanceCache.set(cacheKey, {
-                        instance: this,
-                        refCount: 1,
-                    });
+                // The context's ids or name can change after create (a seed uid arrives, a List of relation
+                // moves to its storage name): add the new key to this instance's entry. Never a new entry
+                // or count, and nothing once the instance was unloaded (this runs after an await).
+                const entry = cacheEntries.get(this._service);
+                if (entry &&
+                    !ItemProperty.instanceCache.has(cacheKey) &&
+                    this._service.getSnapshot().status === 'active') {
+                    ItemProperty.instanceCache.set(cacheKey, entry);
                 }
             }
             let renderValue;
+            // Set when this pass minted the display URL; stored with it so the next pass reuses it.
+            let mintedDisplayValue;
             const isImage = propertyRecordSchema &&
                 isDataType(propertyRecordSchema.dataType, ModelPropertyDataTypes.Image);
             const isFile = propertyRecordSchema &&
@@ -5384,7 +5506,7 @@ class ItemProperty {
             if (isImage && !context.refResolvedValue && (isFileValue || isBlobValue)) {
                 const fileOrBlob = pv;
                 const fileName = fileOrBlob instanceof File ? fileOrBlob.name : 'image';
-                const blobUrl = URL.createObjectURL(fileOrBlob);
+                const blobUrl = createSessionObjectUrl(fileOrBlob);
                 this._service.send({
                     type: 'updateContext',
                     refResolvedValue: fileName,
@@ -5414,15 +5536,17 @@ class ItemProperty {
                             renderValue = context.refResolvedDisplayValue;
                         }
                         if (!context.refResolvedDisplayValue) {
-                            renderValue = await BaseFileManager.getContentUrlFromPath(filePath);
+                            renderValue = mintedDisplayValue = await BaseFileManager.getContentUrlFromPath(filePath);
                         }
                     }
                     if (exists && isFile) {
                         // A File's value is its content URL (a blob URL in browsers, file:// in Node), as saveFile
                         // and hydrateFromDb set it. Reading the text here made the value change from the URL to
                         // the file's contents a moment after every save or load.
-                        renderValue =
-                            context.refResolvedDisplayValue ?? (await BaseFileManager.getContentUrlFromPath(filePath));
+                        renderValue = context.refResolvedDisplayValue;
+                        if (!renderValue) {
+                            renderValue = mintedDisplayValue = await BaseFileManager.getContentUrlFromPath(filePath);
+                        }
                     }
                     if (!exists) {
                         // Keep filename for display when File object is present but not yet saved to disk
@@ -5466,16 +5590,25 @@ class ItemProperty {
                 transformedPropertyName = this._alias;
             }
             if (skipTransform && !this._alias) ;
+            // The context moved on while this pass awaited; the pass for the newer snapshot decides.
+            // Sending here put back values (and revoked URLs) that the newer pass had replaced.
+            if (this._service.getSnapshot().context !== context) {
+                if (mintedDisplayValue)
+                    revokeSessionObjectUrl(mintedDisplayValue);
+                return;
+            }
             // Update context with renderValue instead of BehaviorSubject
             // The reactive proxy will handle reactivity
             const currentRenderValue = context.renderValue || context.propertyValue;
             if (currentRenderValue === renderValue) {
                 return;
             }
-            // Update context with new renderValue
+            // Update context with new renderValue. A minted URL goes into refResolvedDisplayValue too:
+            // sent as renderValue alone, the next pass minted another, and so on about 60 times a second.
             this._service.send({
                 type: 'updateContext',
                 renderValue,
+                ...(mintedDisplayValue ? { refResolvedDisplayValue: mintedDisplayValue } : {}),
             });
         });
         this._service.start();
@@ -5518,6 +5651,8 @@ class ItemProperty {
                 // File and Image display values are session URLs minted from the file on disk; the column holds
                 // nothing useful for them (older versions stored blob: URLs that die on reload). Keep the minted
                 // one unless the row now points at a different file, then clear it so the next render mints anew.
+                // A kept URL is also the renderValue: the row's propertyValue (the storage seed id) showed for a
+                // moment on every write to the metadata table, then the subscriber put the URL back.
                 const displayValueFromRow = (row) => {
                     const { context } = this._service.getSnapshot();
                     const isSessionUrlType = normalizedDataType === 'Image' ||
@@ -5528,8 +5663,9 @@ class ItemProperty {
                     if (!isSessionUrlType) {
                         return { refResolvedDisplayValue: row.refResolvedDisplayValue || undefined };
                     }
-                    if ((row.refResolvedValue || undefined) === context.refResolvedValue)
-                        return {};
+                    if ((row.refResolvedValue || undefined) === context.refResolvedValue) {
+                        return context.refResolvedDisplayValue ? { renderValue: context.refResolvedDisplayValue } : {};
+                    }
                     return { refResolvedDisplayValue: undefined };
                 };
                 const drizzleMod = await import('drizzle-orm');
@@ -5655,6 +5791,9 @@ class ItemProperty {
                         logger('[ItemProperty._setupLiveQuerySubscription] Instance state not found');
                         return;
                     }
+                    // Unloaded or destroyed while setup awaited: subscribing now would leak the query.
+                    if (isActorStopped(this._service))
+                        return;
                     // Subscribe to liveQuery updates
                     const subscription = metadata$.subscribe({
                         next: async (metadataRows) => {
@@ -5752,8 +5891,8 @@ class ItemProperty {
             const ctx = this._service.getSnapshot().context;
             let modelFileId;
             try {
-                const _mod_16 = await import('./index-DpgQMIRq.js');
-                const _ns_16 = _mod_16.bh;
+                const _mod_16 = await import('./index-C-NqjjY_.js');
+                const _ns_16 = _mod_16.bi;
                 const { resolveItemModelFileId } = _ns_16;
                 modelFileId = await resolveItemModelFileId({
                     modelFileId: ctx.modelFileId,
@@ -5794,6 +5933,9 @@ class ItemProperty {
                     logger('[ItemProperty._setupPropertySchemaLiveQuery] Instance state not found');
                     return;
                 }
+                // Unloaded or destroyed while setup awaited: subscribing now would leak the query.
+                if (isActorStopped(this._service))
+                    return;
                 const subscription = schema$.subscribe({
                     next: (rows) => {
                         if (rows.length === 0)
@@ -5868,6 +6010,7 @@ class ItemProperty {
     static create(props, options) {
         const waitForReady = options?.waitForReady !== false;
         const readyTimeout = options?.readyTimeout ?? DEFAULT_READY_TIMEOUT_MS;
+        const holds = options?.hold === false ? 0 : 1;
         const { propertyName, seedLocalId, seedUid } = props;
         if (!propertyName || (!seedLocalId && !seedUid)) {
             if (!waitForReady)
@@ -5884,9 +6027,10 @@ class ItemProperty {
                 ? keyByUid
                 : null;
         if (lookupKey) {
-            const { instance, refCount } = this.instanceCache.get(lookupKey);
-            const entry = { instance, refCount: refCount + 1 };
-            this.instanceCache.set(lookupKey, entry);
+            // One entry under both keys: one hold count for the instance
+            const entry = this.instanceCache.get(lookupKey);
+            entry.refCount += holds;
+            const { instance } = entry;
             const otherKey = lookupKey === keyByLocal ? keyByUid : keyByLocal;
             if (otherKey)
                 this.instanceCache.set(otherKey, entry);
@@ -5960,21 +6104,9 @@ class ItemProperty {
             if (!this.instanceCache.has(cacheKey)) {
                 const newInstance = new ItemProperty(props);
                 // Wrap instance in Proxy for reactive property access
-                const proxiedInstance = createReactiveProxy({
-                    instance: newInstance,
-                    service: newInstance._service,
-                    trackedProperties: TRACKED_PROPERTIES$1,
-                    getContext: (instance) => {
-                        return instance._getSnapshotContext();
-                    },
-                    sendUpdate: (instance, prop, value) => {
-                        instance._service.send({
-                            type: 'updateContext',
-                            [prop]: value,
-                        });
-                    },
-                });
-                const entry = { instance: proxiedInstance, refCount: 1 };
+                const proxiedInstance = ItemProperty.wrapInProxy(newInstance);
+                const entry = { instance: proxiedInstance, refCount: holds };
+                cacheEntries.set(newInstance._service, entry);
                 this.instanceCache.set(cacheKey, entry);
                 if (keyByUid && keyByUid !== cacheKey)
                     this.instanceCache.set(keyByUid, entry);
@@ -5987,21 +6119,9 @@ class ItemProperty {
             if (!this.instanceCache.has(cacheKey)) {
                 const newInstance = new ItemProperty(props);
                 // Wrap instance in Proxy for reactive property access
-                const proxiedInstance = createReactiveProxy({
-                    instance: newInstance,
-                    service: newInstance._service,
-                    trackedProperties: TRACKED_PROPERTIES$1,
-                    getContext: (instance) => {
-                        return instance._getSnapshotContext();
-                    },
-                    sendUpdate: (instance, prop, value) => {
-                        instance._service.send({
-                            type: 'updateContext',
-                            [prop]: value,
-                        });
-                    },
-                });
-                const entry = { instance: proxiedInstance, refCount: 1 };
+                const proxiedInstance = ItemProperty.wrapInProxy(newInstance);
+                const entry = { instance: proxiedInstance, refCount: holds };
+                cacheEntries.set(newInstance._service, entry);
                 this.instanceCache.set(cacheKey, entry);
                 if (keyByLocal && keyByLocal !== cacheKey)
                     this.instanceCache.set(keyByLocal, entry);
@@ -6012,24 +6132,31 @@ class ItemProperty {
         }
         const newInstance = new ItemProperty(props);
         // Wrap instance in Proxy for reactive property access
-        const result = createReactiveProxy({
-            instance: newInstance,
-            service: newInstance._service,
-            trackedProperties: TRACKED_PROPERTIES$1,
-            getContext: (instance) => {
-                return instance._getSnapshotContext();
-            },
-            sendUpdate: (instance, prop, value) => {
-                instance._service.send({
-                    type: 'updateContext',
-                    [prop]: value,
-                });
-            },
-        });
+        const result = ItemProperty.wrapInProxy(newInstance);
         if (!waitForReady)
             return result;
         return waitForEntityIdle(result, { timeout: readyTimeout }).then(() => result);
     }
+    /**
+     * Wraps a new instance in its reactive proxy: tracked names read from and write to the actor's
+     * context, and assigning `value` also sends it to the actor before the setter runs.
+     */
+    static wrapInProxy(instance) {
+        const sendUpdate = (target, prop, value) => {
+            target._service.send({ type: 'updateContext', [prop]: value });
+        };
+        return createReactiveProxy({
+            instance,
+            service: instance._service,
+            trackedProperties: TRACKED_PROPERTIES$1,
+            getContext: (target) => target._getSnapshotContext(),
+            sendUpdate,
+            onSet: (target, prop, value) => {
+                if (prop === 'value')
+                    sendUpdate(target, prop, value);
+            },
+        });
+    }
     /**
      * The cached ItemProperty when it can be read right now (idle, not saving), the state
      * `ItemProperty.find()` waits for. Otherwise undefined. Unlike `find`, it takes no cache hold, so
@@ -6053,21 +6180,20 @@ class ItemProperty {
         }
         return undefined;
     }
-    static async find({ propertyName, seedLocalId, seedUid, modelName: modelNameOption, waitForReady = true, readyTimeout = DEFAULT_READY_TIMEOUT_MS, }) {
+    /** Takes a hold on the instance it returns: release it with `unload()`. */
+    static async find({ propertyName, seedLocalId, seedUid, modelName: modelNameOption, waitForReady = true, readyTimeout = DEFAULT_READY_TIMEOUT_MS, hold, }) {
         if ((!seedLocalId && !seedUid) || !propertyName) {
             return undefined;
         }
         const cacheKeyId = seedUid || seedLocalId;
         const cacheKey = ItemProperty.cacheKey(cacheKeyId, propertyName);
         let foundProperty;
-        // Check cache first
-        if (this.instanceCache.has(cacheKey)) {
-            const { instance, refCount } = this.instanceCache.get(cacheKey);
-            this.instanceCache.set(cacheKey, {
-                instance,
-                refCount: refCount + 1,
-            });
-            foundProperty = instance;
+        // Check cache first. Mutate the entry: it may also be stored under the item's other id.
+        const cachedEntry = this.instanceCache.get(cacheKey);
+        if (cachedEntry) {
+            if (hold !== false)
+                cachedEntry.refCount += 1;
+            foundProperty = cachedEntry.instance;
         }
         else {
             // Query database
@@ -6092,7 +6218,7 @@ class ItemProperty {
                 seedUid: propertyData.seedUid ?? seedUid,
                 propertyId: propertyData.propertyId,
             });
-            foundProperty = ItemProperty.create({ ...propertyData, modelName, propertyRecordSchema }, { waitForReady: false });
+            foundProperty = ItemProperty.create({ ...propertyData, modelName, propertyRecordSchema }, { waitForReady: false, hold });
         }
         if (!foundProperty) {
             return undefined;
@@ -6105,9 +6231,10 @@ class ItemProperty {
     /**
      * Get all ItemProperty instances for an item.
      * Loads property data via getItemProperties, creates instances via create, optionally waits for idle.
+     * Takes a hold on each instance, as `create` does.
      */
     static async all(params, options) {
-        const { waitForReady = false, readyTimeout = DEFAULT_READY_TIMEOUT_MS } = options ?? {};
+        const { waitForReady = false, readyTimeout = DEFAULT_READY_TIMEOUT_MS, hold } = options ?? {};
         const { seedLocalId, seedUid } = params;
         if (!seedLocalId && !seedUid) {
             return [];
@@ -6115,8 +6242,8 @@ class ItemProperty {
         const propertiesData = await getItemProperties({ seedLocalId, seedUid });
         const instances = [];
         const seenNormalized = new Set();
-        const _mod_17 = await import('./index-DpgQMIRq.js');
-        const _ns_17 = _mod_17.bh;
+        const _mod_17 = await import('./index-C-NqjjY_.js');
+        const _ns_17 = _mod_17.bi;
         const { resolveItemModelFileId } = _ns_17;
         const itemModelFileId = await resolveItemModelFileId({ seedLocalId, seedUid });
         for (const data of propertiesData) {
@@ -6133,8 +6260,8 @@ class ItemProperty {
             }
             else if (baseName) {
                 try {
-                    const _mod_18 = await import('./errors-KM-yq2MD.js');
-                    const _ns_18 = _mod_18.j;
+                    const _mod_18 = await import('./errors-CQagdED2.js');
+                    const _ns_18 = _mod_18.i;
                     const { Model } = _ns_18;
                     const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
                     const model = await Model.resolveAsync(modelName, { modelFileId });
@@ -6150,8 +6277,8 @@ class ItemProperty {
             }
             if (modelName && propertyName) {
                 try {
-                    const _mod_19 = await import('./errors-KM-yq2MD.js');
-                    const _ns_19 = _mod_19.j;
+                    const _mod_19 = await import('./errors-CQagdED2.js');
+                    const _ns_19 = _mod_19.i;
                     const { Model } = _ns_19;
                     const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
                     const model = await Model.resolveAsync(modelName, { modelFileId });
@@ -6180,7 +6307,7 @@ class ItemProperty {
                 modelFileId,
                 propertyRecordSchema,
             };
-            const instance = this.create(createProps, { waitForReady: false });
+            const instance = this.create(createProps, { waitForReady: false, hold });
             if (instance) {
                 instances.push(instance);
             }
@@ -6192,18 +6319,44 @@ class ItemProperty {
         }
         return instances;
     }
+    /**
+     * @internal Takes one more hold on a cached, running instance, released with `unload()`. False
+     * (and no hold) when the instance isn't cached or was stopped.
+     */
+    static retain(instance) {
+        const service = instance.getService();
+        const entry = cacheEntries.get(service);
+        if (!entry || service.getSnapshot().status !== 'active')
+            return false;
+        entry.refCount += 1;
+        return true;
+    }
     static cacheKey(seedLocalIdOrUid, propertyName) {
         const { uid, localId } = getCorrectId(seedLocalIdOrUid);
         return `Item_${uid || localId}_${propertyName}`;
     }
-    /** Clears instance cache for an item (for test isolation when run in group). */
+    /**
+     * Drops an item's properties from the instance cache, under every key they're cached by. A dropped
+     * instance someone still holds keeps running but is detached: it doesn't re-key itself into the
+     * cache when its context changes, so the next lookup creates a fresh instance.
+     */
     static clearInstanceCacheForItem(seedLocalIdOrUid) {
         const { uid, localId } = getCorrectId(seedLocalIdOrUid);
         const prefix = `Item_${uid || localId}_`;
-        for (const key of Array.from(this.instanceCache.keys())) {
+        const dropped = new Set();
+        for (const [key, entry] of this.instanceCache) {
             if (key.startsWith(prefix))
+                dropped.add(entry);
+        }
+        for (const [key, entry] of Array.from(this.instanceCache)) {
+            if (dropped.has(entry))
                 this.instanceCache.delete(key);
         }
+        for (const entry of dropped) {
+            const service = entry.instance.getService();
+            if (cacheEntries.get(service) === entry)
+                cacheEntries.delete(service);
+        }
     }
     getService() {
         return this._service;
@@ -6406,22 +6559,21 @@ class ItemProperty {
         //   })
         // })
     }
+    /**
+     * Every cache key holding this instance: its item's local id and seed uid, and the name it had
+     * before a rename (List of relation). They share one entry.
+     */
+    _cacheKeys() {
+        const keys = [];
+        for (const [key, entry] of ItemProperty.instanceCache) {
+            if (entry.instance.getService() === this._service)
+                keys.push(key);
+        }
+        return keys;
+    }
     unload() {
         try {
-            const context = this._getSnapshotContext();
-            const cacheKey = ItemProperty.cacheKey(context.seedUid || context.seedLocalId || '', context.propertyName || '');
-            const cacheKeys = [];
-            if (cacheKey && cacheKey !== 'Item__') {
-                cacheKeys.push(cacheKey);
-            }
-            // Renamed after construction (List of relation): also drop the entry cached under the old name.
-            const publicName = this.propertyName;
-            if (publicName && publicName !== context.propertyName) {
-                const aliasKey = ItemProperty.cacheKey(context.seedUid || context.seedLocalId || '', publicName);
-                if (aliasKey && aliasKey !== 'Item__' && ItemProperty.instanceCache.get(aliasKey)?.instance === this) {
-                    cacheKeys.push(aliasKey);
-                }
-            }
+            const cacheKeys = this._cacheKeys();
             unloadEntity(this, {
                 getCacheKeys: () => cacheKeys,
                 caches: [ItemProperty.instanceCache],
@@ -6430,6 +6582,7 @@ class ItemProperty {
                 onUnload: (instance) => {
                     // Clean up additional subscriptions
                     instance._subscription?.unsubscribe();
+                    revokeHeldObjectUrls(instance._service);
                     const state = itemPropertyInstanceState.get(instance);
                     if (state?.schemaLiveQuerySubscription) {
                         state.schemaLiveQuerySubscription.unsubscribe();
@@ -6450,6 +6603,7 @@ class ItemProperty {
                 instanceState.schemaLiveQuerySubscription = null;
             }
             this._subscription?.unsubscribe();
+            revokeHeldObjectUrls(this._service);
             try {
                 this._service.stop();
             }
@@ -6470,8 +6624,7 @@ class ItemProperty {
             seedLocalId: context.seedLocalId ?? undefined,
             seedUid: context.seedUid ?? undefined,
         });
-        const cacheKey = ItemProperty.cacheKey(context.seedUid || context.seedLocalId || '', context.propertyName || '');
-        const cacheKeys = cacheKey && cacheKey !== 'Item__' ? [cacheKey] : [];
+        const cacheKeys = this._cacheKeys();
         clearDestroySubscriptions(this, {
             instanceState: itemPropertyInstanceState,
             onUnload: (instance) => instance._subscription?.unsubscribe(),
@@ -6490,7 +6643,7 @@ class ItemProperty {
                 if (!propertyName || (!seedLocalId && !seedUid))
                     return;
                 if (db) {
-                    const _mod_20 = await import('./index-BbFwftAv.js');
+                    const _mod_20 = await import('./index-3_hGVu7v.js');
                     const _ns_20 = _mod_20.s;
                     const seedSchemaMod = _ns_20;
                     const { metadata } = seedSchemaMod;
@@ -6511,7 +6664,7 @@ class ItemProperty {
                 }
                 const itemMod = await Promise.resolve().then(function () { return Item$1; });
                 const { Item } = itemMod;
-                const item = Item.getById((seedLocalId || seedUid));
+                const item = Item.peek(seedLocalId || seedUid);
                 if (item) {
                     item.getService().send({ type: 'removePropertyInstance', propertyName });
                 }
@@ -6535,8 +6688,8 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
     }
     const seedType = easName(modelName);
     // Dynamic import to break circular dependency
-    const _mod_21 = await import('./errors-KM-yq2MD.js');
-    const _ns_21 = _mod_21.j;
+    const _mod_21 = await import('./errors-CQagdED2.js');
+    const _ns_21 = _mod_21.i;
     const modelMod = _ns_21;
     const { Model } = modelMod;
     const model = await Model.resolveAsync(modelName, { modelFileId });
@@ -6549,7 +6702,7 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
     catch (error) {
         // The rows are separate inserts (no transaction): remove what was written so a failure leaves
         // no half-made draft.
-        const { discardNewDraft } = await import('./discardNewDraft-hiVaUVjV.js');
+        const { discardNewDraft } = await import('./discardNewDraft-D4nrwp3T.js');
         await discardNewDraft(newSeedId).catch(() => undefined);
         throw error;
     }
@@ -6731,8 +6884,8 @@ const getModel = () => {
         // the fragile `import(...).then(n => n.X)` chunk-namespace pattern.
         if (!modelImportPromise) {
             modelImportPromise = (async () => {
-                const _mod_22 = await import('./errors-KM-yq2MD.js');
-                const _ns_22 = _mod_22.j;
+                const _mod_22 = await import('./errors-CQagdED2.js');
+                const _ns_22 = _mod_22.i;
                 const mod = _ns_22;
                 ModelClass = mod.Model;
                 return mod;
@@ -6788,9 +6941,8 @@ const TRACKED_PROPERTIES = [
     'publisher',
     'revokedAt',
 ];
-// WeakMap to store mutable state per Item instance
-// This avoids issues with read-only properties when instances are frozen by Immer
-const itemInstanceState = new WeakMap();
+// Mutable state per Item instance
+const itemInstanceState = new ActorKeyedState();
 /**
  * Seed uids an item has moved away from (a republish gives the item a new seed uid) whose seed row
  * may still hold them: the new uid is set on the item before its DB write lands, and until then the
@@ -6800,11 +6952,55 @@ const itemInstanceState = new WeakMap();
  */
 const supersededSeedUids = new WeakMap();
 /**
- * Each Item's reactive proxy, keyed by the raw instance. The class's arrow-function methods see the
- * raw instance as `this`, where tracked properties such as `seedUid` are getter-only; anything they
- * hand the item to that assigns tracked properties (the publish executor) must get the proxy.
+ * The ItemProperty instances an item holds, keyed by the item's actor, then by each property's
+ * actor. An item takes one hold on each instance in its `propertyInstances` map while it is there
+ * and releases it when the instance leaves the map or the item's actor stops. The SDK code that puts
+ * instances in the map looks them up with `hold: false`, so these are their only item-owned holds.
+ */
+const propertyHolds = new WeakMap();
+function syncPropertyHolds(itemService, propertyInstances) {
+    let held = propertyHolds.get(itemService);
+    if (!held) {
+        held = new Map();
+        propertyHolds.set(itemService, held);
+    }
+    const current = new Set();
+    for (const property of propertyInstances?.values() ?? []) {
+        const propertyService = property.getService();
+        current.add(propertyService);
+        if (!held.has(propertyService) && ItemProperty.retain(property))
+            held.set(propertyService, property);
+    }
+    for (const [propertyService, property] of held) {
+        if (current.has(propertyService))
+            continue;
+        held.delete(propertyService);
+        property.unload();
+    }
+}
+function releasePropertyHolds(itemService) {
+    const held = propertyHolds.get(itemService);
+    if (!held)
+        return;
+    propertyHolds.delete(itemService);
+    for (const property of held.values()) {
+        try {
+            property.unload();
+        }
+        catch {
+            // Already stopped
+        }
+    }
+}
+/**
+ * Each Item's reactive proxy, keyed by its actor. The class's arrow-function methods see the raw
+ * instance as `this`, where tracked properties such as `seedUid` are getter-only and model
+ * properties (`item.title`) don't exist; anything they hand the item to (the publish executor)
+ * must get the proxy.
  */
 const reactiveProxies = new WeakMap();
+/** The latest seed uid write per item, keyed by its actor (see `_persistSeedUid`). */
+const pendingSeedUidWrites = new WeakMap();
 class Item {
     constructor(initialValues) {
         this._propertiesSubject = new BehaviorSubject({});
@@ -6900,20 +7096,20 @@ class Item {
                     }
                 });
                 // The executor assigns item.seedUid, which only the proxy accepts.
-                const item = reactiveProxies.get(this) ?? this;
+                const item = reactiveProxies.get(this._service) ?? this;
                 this._service.send({ type: 'startPublish', item, options });
             });
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const _mod_23 = await import('./getPublishUploads-Cex-NBe6.js');
+            const _mod_23 = await import('./getPublishUploads-7nW1kMZV.js');
             const _ns_23 = _mod_23.o;
             const getPublishUploadsMod = _ns_23;
             const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this, [], undefined, options);
         };
         this.getPublishPayload = async (uploadedTransactions, options) => {
-            const _mod_24 = await import('./getPublishPayload-oH8wJhnH.js');
+            const _mod_24 = await import('./getPublishPayload-Bmeqtq4l.js');
             const _ns_24 = _mod_24.g;
             const getPublishPayloadMod = _ns_24;
             const { getPublishPayload } = getPublishPayloadMod;
@@ -6971,58 +7167,28 @@ class Item {
                 context.propertyInstances.size === 0) {
                 return;
             }
-            const state = itemInstanceState.get(this);
             const propertiesObj = {};
             for (const [key, propertyInstance] of context.propertyInstances) {
                 if (typeof key !== 'string' || INTERNAL_PROPERTY_NAMES.includes(key)) {
                     propertiesObj[key.toString()] = propertyInstance;
                     continue;
                 }
-                let transformedKey = key;
-                if (propertyInstance.alias) {
-                    transformedKey = propertyInstance.alias;
-                }
-                if (!propertyInstance.alias && key.endsWith('Ids')) {
-                    transformedKey = key.slice(0, -3); // Remove 'Ids'
-                    transformedKey = pluralize(transformedKey);
-                }
-                if (!propertyInstance.alias &&
-                    key.endsWith('Id') &&
-                    !PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP.has(key)) {
-                    transformedKey = key.slice(0, -2); // Remove 'Id'
-                }
-                propertiesObj[transformedKey] = propertyInstance;
-            }
-            // Define accessors for any property instances we don't have yet (e.g. from loadOrCreateItem)
-            const definedSet = state?.definedPropertyNames;
-            if (definedSet) {
-                for (const key of context.propertyInstances.keys()) {
-                    if (typeof key !== 'string' || INTERNAL_PROPERTY_NAMES.includes(key)) {
-                        continue;
-                    }
-                    if (!definedSet.has(key)) {
-                        this._definePropertyAccessor(key);
-                    }
-                }
-                // Html/Image/File/Relation store as e.g. htmlId; ensure schema name (html) has accessor when htmlId exists
-                for (const key of context.propertyInstances.keys()) {
-                    if (typeof key !== 'string' || INTERNAL_PROPERTY_NAMES.includes(key))
-                        continue;
-                    const schemaBaseName = toSchemaPropertyName(key);
-                    if (schemaBaseName &&
-                        (schemaKeys.includes(schemaBaseName) || schemaKeys.length === 0) &&
-                        !definedSet.has(schemaBaseName)) {
-                        this._definePropertyAccessor(schemaBaseName);
-                    }
-                }
+                propertiesObj[toItemPropertyKey(key, propertyInstance.alias)] = propertyInstance;
             }
             this._propertiesSubject.next(propertiesObj);
         });
+        // Hold the properties in the map; release them all when the actor stops (last unload, destroy,
+        // eviction or error), whichever teardown path stops it.
+        const itemService = this._service;
+        itemService.subscribe({
+            next: (snapshot) => syncPropertyHolds(itemService, snapshot.context?.propertyInstances),
+            complete: () => releasePropertyHolds(itemService),
+            error: () => releasePropertyHolds(itemService),
+        });
         this._service.start();
         // Initialize instance state in WeakMap
         itemInstanceState.set(this, {
             liveQuerySubscription: null,
-            definedPropertyNames: new Set(),
         });
         // Set up liveQuery subscription for cross-instance updates
         this._setupLiveQuerySubscription();
@@ -7123,7 +7289,7 @@ class Item {
     static collectInstanceCacheKeysForInstance(instance) {
         const keys = [];
         for (const [k, v] of this.instanceCache) {
-            if (v.instance === instance)
+            if (sameEntity(v.instance, instance))
                 keys.push(k);
         }
         return keys;
@@ -7143,6 +7309,95 @@ class Item {
             throw new Error('Item.registerItemInInstanceCache: missing seedLocalId and seedUid');
         }
     }
+    /**
+     * Wraps a new instance in its reactive proxy: tracked names read from and write to the actor's
+     * context, and the model's property names (`item.title`, or `item.html` for `htmlId`) read and
+     * write their ItemProperty's value.
+     */
+    static wrapInProxy(instance) {
+        const proxy = createReactiveProxy({
+            instance,
+            service: instance._service,
+            trackedProperties: TRACKED_PROPERTIES,
+            getContext: (target) => target._getSnapshotContext(),
+            sendUpdate: (target, prop, value) => {
+                if (prop === 'publisher')
+                    throw new Error('Cannot set item.publisher: publisher is read-only.');
+                Item.sendTrackedPropertyUpdate(target, prop, value);
+                if (prop === 'seedUid' && typeof value === 'string' && value.length > 0) {
+                    target._persistSeedUid(value);
+                }
+            },
+            resolve: (target, prop) => {
+                const property = target._findPropertyInstance(prop);
+                if (!property)
+                    return undefined;
+                return {
+                    get: () => property.value,
+                    set: (value) => {
+                        property.value = value;
+                    },
+                };
+            },
+            virtualKeys: (target) => target._propertyInstanceNames(),
+            onSet: (_target, prop) => {
+                if (prop === 'properties') {
+                    // Properties are read-only computed values from propertyInstances, managed via ItemProperty instances
+                    throw new Error('Cannot set item.properties directly. Properties are computed from ItemProperty instances.');
+                }
+            },
+        });
+        reactiveProxies.set(instance._service, proxy);
+        return proxy;
+    }
+    /**
+     * The ItemProperty a model property name reads and writes on the item: by its name, or by its
+     * storage name (`html` finds `htmlId` and the other way round). Internal names don't resolve.
+     */
+    _findPropertyInstance(propertyName) {
+        if (INTERNAL_PROPERTY_NAMES.includes(propertyName))
+            return undefined;
+        const instances = this._service.getSnapshot().context.propertyInstances;
+        if (!instances || instances.size === 0)
+            return undefined;
+        const direct = instances.get(propertyName);
+        if (direct)
+            return direct;
+        const altKey = getAlternatePropertyNameForInstanceLookup(propertyName);
+        return altKey ? instances.get(altKey) : undefined;
+    }
+    /** Every name `_findPropertyInstance` resolves: the stored names and their schema names. */
+    _propertyInstanceNames() {
+        const instances = this._service.getSnapshot().context.propertyInstances;
+        if (!instances)
+            return [];
+        const names = new Set();
+        for (const key of instances.keys()) {
+            if (typeof key !== 'string' || INTERNAL_PROPERTY_NAMES.includes(key))
+                continue;
+            names.add(key);
+            const schemaName = toSchemaPropertyName(key);
+            if (schemaName && !INTERNAL_PROPERTY_NAMES.includes(schemaName))
+                names.add(schemaName);
+        }
+        return [...names];
+    }
+    /**
+     * Writes an assigned seed uid to the item's seed row, so later loads and getPublishPayload see it.
+     * Writes run one after another per item, so the last assignment is the one that stays.
+     */
+    _persistSeedUid(seedUid) {
+        const seedLocalId = this._getSnapshotContext().seedLocalId;
+        if (!seedLocalId)
+            return;
+        const previous = pendingSeedUidWrites.get(this._service) ?? Promise.resolve();
+        const write = previous
+            .then(() => updateSeedUid({ seedLocalId, seedUid }))
+            .catch((err) => {
+            itemLogger('updateSeedUid failed:', err);
+        });
+        pendingSeedUidWrites.set(this._service, write);
+    }
     /**
      * Sets a tracked context property from the proxy. Setting `seedUid` to a different uid means a
      * new seed attestation (publishing again after unpublish): the revocation belonged to the old
@@ -7206,6 +7461,13 @@ class Item {
         }
         return (ctx.propertyInstances?.size ?? 0) > 0;
     }
+    /**
+     * The cached Item for a seedLocalId or seedUid, in any state, without taking a hold. For SDK code
+     * that reads or messages the item and doesn't hand it to a caller.
+     */
+    static peek(id) {
+        return id ? this.findItemInstanceCacheEntryById(id)?.instance : undefined;
+    }
     /**
      * The cached Item for a seedLocalId or seedUid when it can be read right now: idle and hydrated,
      * so at least what `Item.find()` would wait for. Otherwise undefined. Unlike `getById`, it takes
@@ -7345,82 +7607,7 @@ class Item {
                 const { latestVersionUid, ...propsWithoutVersionUid } = props;
                 const propsWithModel = { ...propsWithoutVersionUid };
                 const newInstance = new Item(propsWithModel);
-                // Wrap instance in Proxy for reactive property access
-                const proxiedInstance = new Proxy(newInstance, {
-                    get(target, prop) {
-                        // Handle special properties
-                        if (prop === '_service') {
-                            return Reflect.get(target, prop);
-                        }
-                        // Handle tracked properties
-                        if (typeof prop === 'string' && TRACKED_PROPERTIES.includes(prop)) {
-                            const context = target._getSnapshotContext();
-                            return context[prop];
-                        }
-                        // Handle 'properties' getter - not tracked, but accessible via getter
-                        if (typeof prop === 'string' && prop === 'properties') {
-                            // Delegate to the getter method on the instance
-                            return target.properties;
-                        }
-                        // For methods and other 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 (typeof prop === 'string' && prop === 'publisher') {
-                            throw new Error('Cannot set item.publisher: publisher is read-only.');
-                        }
-                        // Handle tracked properties
-                        if (typeof prop === 'string' && TRACKED_PROPERTIES.includes(prop)) {
-                            // Standard property update
-                            Item.sendTrackedPropertyUpdate(target, prop, value);
-                            // Auto-persist seedUid to DB when assigned so future loads and getPublishPayload see it
-                            if (prop === 'seedUid' && typeof value === 'string' && value.length > 0) {
-                                const seedLocalId = target._getSnapshotContext().seedLocalId;
-                                if (seedLocalId) {
-                                    void updateSeedUid({ seedLocalId, seedUid: value }).catch((err) => {
-                                        itemLogger('updateSeedUid failed:', err);
-                                    });
-                                }
-                            }
-                            return true;
-                        }
-                        // Handle 'properties' - read-only computed property
-                        if (typeof prop === 'string' && prop === 'properties') {
-                            // Properties are read-only computed values from propertyInstances
-                            // Cannot be set directly - properties are managed via ItemProperty instances
-                            throw new Error('Cannot set item.properties directly. Properties are computed from ItemProperty instances.');
-                        }
-                        // For non-tracked properties, use Reflect
-                        return Reflect.set(target, prop, value);
-                    },
-                    has(target, prop) {
-                        // Check tracked properties
-                        if (typeof prop === 'string' && TRACKED_PROPERTIES.includes(prop)) {
-                            const context = target._getSnapshotContext();
-                            return prop in context;
-                        }
-                        return Reflect.has(target, prop);
-                    },
-                    ownKeys(target) {
-                        // Return keys from target
-                        return Reflect.ownKeys(target);
-                    },
-                    getOwnPropertyDescriptor(target, prop) {
-                        let invent;
-                        if (typeof prop === 'string' && TRACKED_PROPERTIES.includes(prop)) {
-                            const context = target._getSnapshotContext();
-                            if (prop in context) {
-                                invent = { value: context[prop] };
-                            }
-                        }
-                        return getInvariantSafePropertyDescriptor(target, prop, invent);
-                    },
-                });
-                reactiveProxies.set(newInstance, proxiedInstance);
+                const proxiedInstance = Item.wrapInProxy(newInstance);
                 this.registerItemInInstanceCache(proxiedInstance);
                 if (!waitForReady)
                     return proxiedInstance;
@@ -7453,8 +7640,8 @@ class Item {
         const db = BaseDb.getAppDb();
         if (db && props.modelName) {
             // Model names are only unique per schema: resolve the exact models row from the most specific scope.
-            const _mod_25 = await import('./index-DpgQMIRq.js');
-            const _ns_25 = _mod_25.bh;
+            const _mod_25 = await import('./index-C-NqjjY_.js');
+            const _ns_25 = _mod_25.bi;
             const { resolveModelRecord } = _ns_25;
             const modelRecord = await resolveModelRecord(props.modelName, {
                 modelFileId: props.modelFileId ?? modelInstance?.id,
@@ -7462,8 +7649,8 @@ class Item {
             });
             const modelRecords = modelRecord ? [modelRecord] : [];
             if (!modelRecord) {
-                const _mod_26 = await import('./errors-KM-yq2MD.js');
-                const _ns_26 = _mod_26.k;
+                const _mod_26 = await import('./errors-CQagdED2.js');
+                const _ns_26 = _mod_26.j;
                 const { UnknownModelError } = _ns_26;
                 throw new UnknownModelError(props.modelName, schemaName ?? modelInstance?.schemaName);
             }
@@ -7473,11 +7660,11 @@ class Item {
             // Scope the constructor's Model lookup to this model's schema (as getItemData does on reload),
             // so a same-named model cached from another schema can't supply the property set.
             if (modelRecord && !props.schemaName) {
-                const _mod_27 = await import('./index-DpgQMIRq.js');
-                const _ns_27 = _mod_27.bg;
+                const _mod_27 = await import('./index-C-NqjjY_.js');
+                const _ns_27 = _mod_27.bh;
                 const { modelSchemas } = _ns_27;
-                const _mod_28 = await import('./index-DpgQMIRq.js');
-                const _ns_28 = _mod_28.bf;
+                const _mod_28 = await import('./index-C-NqjjY_.js');
+                const _ns_28 = _mod_28.bg;
                 const { schemas: schemasTable } = _ns_28;
                 const schemaRows = await db
                     .select({ schemaName: schemasTable.name })
@@ -7551,95 +7738,7 @@ class Item {
         const { latestVersionUid, ...propsWithoutVersionUid } = props;
         const propsWithModel = { ...propsWithoutVersionUid };
         const newInstance = new Item(propsWithModel);
-        // Wrap instance in Proxy for reactive property access
-        const proxiedInstance = new Proxy(newInstance, {
-            get(target, prop) {
-                // Handle special properties
-                if (prop === '_service') {
-                    return Reflect.get(target, prop);
-                }
-                // Handle tracked properties
-                if (typeof prop === 'string' && TRACKED_PROPERTIES.includes(prop)) {
-                    // Special handling for properties - compute from propertyInstances Map
-                    if (prop === 'properties') {
-                        const snapshot = target._service.getSnapshot();
-                        const context = snapshot.context;
-                        const propertyInstances = context.propertyInstances;
-                        if (!propertyInstances || propertyInstances.size === 0) {
-                            return [];
-                        }
-                        // Get model schema keys for filtering
-                        const modelSchemaKeys = target._getModelSchemaKeys();
-                        // Convert Map to array, filtering by model schema
-                        const properties = [];
-                        for (const [key, propertyInstance] of propertyInstances) {
-                            // Skip internal properties
-                            if (INTERNAL_PROPERTY_NAMES.includes(key)) {
-                                continue;
-                            }
-                            // Include if it's a model property
-                            const isModelProp = target._isModelProperty(key, modelSchemaKeys);
-                            if (isModelProp) {
-                                properties.push(propertyInstance);
-                            }
-                        }
-                        // CRITICAL: Always create a new array reference so React detects changes
-                        return [...properties];
-                    }
-                    const context = target._getSnapshotContext();
-                    return context[prop];
-                }
-                // For methods and other 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 (typeof prop === 'string' && prop === 'publisher') {
-                    throw new Error('Cannot set item.publisher: publisher is read-only.');
-                }
-                // Handle tracked properties
-                if (typeof prop === 'string' && TRACKED_PROPERTIES.includes(prop)) {
-                    if (prop === 'properties') {
-                        // Properties are read-only computed values from propertyInstances
-                        // Cannot be set directly - properties are managed via ItemProperty instances
-                        throw new Error('Cannot set item.properties directly. Properties are computed from ItemProperty instances.');
-                    }
-                    else {
-                        // Standard property update
-                        Item.sendTrackedPropertyUpdate(target, prop, value);
-                    }
-                    return true;
-                }
-                // For non-tracked properties, use Reflect
-                return Reflect.set(target, prop, value);
-            },
-            has(target, prop) {
-                // Check tracked properties
-                if (typeof prop === 'string' && TRACKED_PROPERTIES.includes(prop)) {
-                    const context = target._getSnapshotContext();
-                    return prop in context;
-                }
-                return Reflect.has(target, prop);
-            },
-            ownKeys(target) {
-                // Return keys from target
-                return Reflect.ownKeys(target);
-            },
-            getOwnPropertyDescriptor(target, prop) {
-                let invent;
-                if (typeof prop === 'string' && TRACKED_PROPERTIES.includes(prop)) {
-                    const context = target._getSnapshotContext();
-                    if (prop in context) {
-                        invent = { value: context[prop] };
-                    }
-                }
-                return getInvariantSafePropertyDescriptor(target, prop, invent);
-            },
-        });
-        reactiveProxies.set(newInstance, proxiedInstance);
+        const proxiedInstance = Item.wrapInProxy(newInstance);
         this.registerItemInInstanceCache(proxiedInstance);
         // Storage values must be saved before returning, so wait for readiness even when not requested.
         if (!waitForReady && pipelineValues.length === 0)
@@ -7664,7 +7763,7 @@ class Item {
             /* best-effort cache cleanup */
         }
         try {
-            const { discardNewDraft } = await import('./discardNewDraft-hiVaUVjV.js');
+            const { discardNewDraft } = await import('./discardNewDraft-D4nrwp3T.js');
             await discardNewDraft(seedLocalId);
         }
         catch (error) {
@@ -7680,8 +7779,8 @@ class Item {
         for (const [propertyName, value] of pipelineValues) {
             const property = await this.waitForPropertyInstance(item, propertyName, timeout);
             if (!property) {
-                const _mod_29 = await import('./errors-KM-yq2MD.js');
-                const _ns_29 = _mod_29.k;
+                const _mod_29 = await import('./errors-CQagdED2.js');
+                const _ns_29 = _mod_29.j;
                 const { ItemCreateError } = _ns_29;
                 throw new ItemCreateError(`Item.create: property ${item.modelName}.${propertyName} did not load for item ${item.seedLocalId}; value was not saved`, { code: 'property_not_loaded', modelName: item.modelName, property: propertyName, seedLocalId: item.seedLocalId });
             }
@@ -7692,15 +7791,15 @@ class Item {
             }
             catch (error) {
                 if (error instanceof ItemPropertySaveValidationError) {
-                    const _mod_30 = await import('./errors-KM-yq2MD.js');
-                    const _ns_30 = _mod_30.k;
+                    const _mod_30 = await import('./errors-CQagdED2.js');
+                    const _ns_30 = _mod_30.j;
                     const { ItemCreateValidationError } = _ns_30;
                     const created = new ItemCreateValidationError(item.modelName, error.validationErrors.map((e) => ({ property: propertyName, code: e.code, message: e.message })));
                     created.cause = error;
                     throw created;
                 }
-                const _mod_31 = await import('./errors-KM-yq2MD.js');
-                const _ns_31 = _mod_31.k;
+                const _mod_31 = await import('./errors-CQagdED2.js');
+                const _ns_31 = _mod_31.j;
                 const { ItemCreateError } = _ns_31;
                 throw new ItemCreateError(`Item.create: failed to save ${item.modelName}.${propertyName} for item ${item.seedLocalId}: ` +
                     (error instanceof Error ? error.message : String(error)), { code: 'save_failed', modelName: item.modelName, property: propertyName, seedLocalId: item.seedLocalId, cause: error });
@@ -7841,11 +7940,12 @@ class Item {
         const { waitForReady = false, readyTimeout = DEFAULT_READY_TIMEOUT_MS, includeEas = false, addressFilter, modelFileId, schemaName, } = options ?? {};
         const itemsData = await getItemsData({ modelName, modelFileId, schemaName, deleted, includeEas, addressFilter });
         const itemInstances = [];
+        // Built without waiting; with waitForReady the items are then awaited together, below.
         for (const itemData of itemsData) {
             itemInstances.push(await Item.create({
                 ...itemData,
                 modelName,
-            }));
+            }, { waitForReady: false }));
         }
         if (waitForReady && itemInstances.length > 0) {
             await Promise.all(itemInstances.map((item) => this.waitForItemInstanceReadyForRead(item, readyTimeout)));
@@ -7862,7 +7962,7 @@ class Item {
         if (!appDb || Item.instanceCache.size === 0) {
             return;
         }
-        const _mod_32 = await import('./index-BbFwftAv.js');
+        const _mod_32 = await import('./index-3_hGVu7v.js');
         const _ns_32 = _mod_32.s;
         const { metadata } = _ns_32;
         const { eq, and } = await import('drizzle-orm');
@@ -7938,6 +8038,7 @@ class Item {
                             seedLocalId,
                             seedUid,
                             modelName: itemModelName,
+                            hold: false,
                         });
                         if (property) {
                             sendToItemMachine({
@@ -7976,8 +8077,10 @@ class Item {
         if (this._storageTransactionId) {
             props.storageTransactionId = this._storageTransactionId;
         }
+        // The item's own hold is taken when the instance enters its map (syncPropertyHolds)
         const propertyInstance = ItemProperty.create(props, {
             waitForReady: false,
+            hold: false,
         });
         if (!propertyInstance || !props.propertyName) {
             return;
@@ -7987,49 +8090,14 @@ class Item {
             propertyName: props.propertyName,
             propertyInstance,
         });
-        this._definePropertyAccessor(props.propertyName);
-    }
-    /**
-     * Defines a property accessor on this Item that delegates get/set to the
-     * ItemProperty in context.propertyInstances at access time (so the correct
-     * instance is used after loadOrCreateItemSuccess merges DB-backed instances).
-     */
-    _definePropertyAccessor(propertyName) {
-        let state = itemInstanceState.get(this);
-        if (!state) {
-            state = { liveQuerySubscription: null, definedPropertyNames: new Set() };
-            itemInstanceState.set(this, state);
-        }
-        if (state.definedPropertyNames.has(propertyName)) {
-            return;
-        }
-        const altKey = getAlternatePropertyNameForInstanceLookup(propertyName);
-        Object.defineProperty(this, propertyName, {
-            get: () => {
-                const instances = this._service.getSnapshot().context.propertyInstances;
-                const inst = instances?.get(propertyName) ?? (altKey ? instances?.get(altKey) : undefined);
-                const val = inst?.value;
-                return val;
-            },
-            set: (value) => {
-                const instances = this._service.getSnapshot().context.propertyInstances;
-                const inst = instances?.get(propertyName) ?? (altKey ? instances?.get(altKey) : undefined);
-                if (inst) {
-                    inst.value = value;
-                }
-            },
-            enumerable: true,
-            configurable: true,
-        });
-        state.definedPropertyNames.add(propertyName);
     }
     /** Throws ItemCreateValidationError for unknown keys and values that break their property's rules. */
     static async assertValidCreateValues(props, propertyNames, dataTypeByPropertyName, skipKeys) {
-        const _mod_33 = await import('./errors-KM-yq2MD.js');
-        const _ns_33 = _mod_33.k;
+        const _mod_33 = await import('./errors-CQagdED2.js');
+        const _ns_33 = _mod_33.j;
         const { ItemCreateValidationError } = _ns_33;
-        const { getPropertySchema } = await import('./property-BDBvImLs.js');
-        const { SchemaValidationService } = await import('./SchemaValidationService-BxCbfDaI.js');
+        const { getPropertySchema } = await import('./property-DaUy4XMe.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-paOfbcwd.js');
         const validationService = new SchemaValidationService();
         const modelName = props.modelName;
         const known = new Set(propertyNames);
@@ -8066,7 +8134,7 @@ class Item {
                     // Not JSON: validated as given, and rejected as a non-array
                 }
             }
-            const { resolvePropertyValidationRules } = await import('./propertyValidationRules-BlfLn4rP.js');
+            const { resolvePropertyValidationRules } = await import('./propertyValidationRules-DbbWvBzj.js');
             const rules = propertySchema?.validation ??
                 (await resolvePropertyValidationRules(modelName, key, {
                     modelFileId: props.modelFileId,
@@ -8254,17 +8322,7 @@ class Item {
             // Prefer propertyInstance.propertyName if available (most reliable)
             // Otherwise use the Map key
             const propertyName = propertyInstance.propertyName || key;
-            // Apply transformations if needed
-            let transformedKey = propertyName;
-            if (propertyInstance.alias) {
-                transformedKey = propertyInstance.alias;
-            }
-            else if (propertyName.endsWith('Ids')) {
-                transformedKey = pluralize(propertyName.slice(0, -3));
-            }
-            else if (propertyName.endsWith('Id')) {
-                transformedKey = propertyName.slice(0, -2);
-            }
+            const transformedKey = toItemPropertyKey(propertyName, propertyInstance.alias);
             if (!schemaKeys.includes(transformedKey)) {
                 schemaKeys.push(transformedKey);
             }
@@ -8295,19 +8353,9 @@ class Item {
         if (!propertyInstance) {
             return false;
         }
-        // Apply same transformation as _getSchemaKeysFromPropertyInstances
+        // Same key as _getSchemaKeysFromPropertyInstances
         const propertyName = propertyInstance.propertyName || key;
-        let transformedKey = propertyName;
-        if (propertyInstance.alias) {
-            transformedKey = propertyInstance.alias;
-        }
-        else if (propertyName.endsWith('Ids')) {
-            transformedKey = pluralize(propertyName.slice(0, -3));
-        }
-        else if (propertyName.endsWith('Id')) {
-            transformedKey = propertyName.slice(0, -2);
-        }
-        return modelSchemaKeys.includes(transformedKey);
+        return modelSchemaKeys.includes(toItemPropertyKey(propertyName, propertyInstance.alias));
     }
     /**
      * Returns only properties that are defined in the Model's schema
@@ -8397,7 +8445,7 @@ class Item {
                 itemActor.send(event);
             };
             try {
-                const _mod_34 = await import('./index-BbFwftAv.js');
+                const _mod_34 = await import('./index-3_hGVu7v.js');
                 const _ns_34 = _mod_34.s;
                 const seedSchemaMod = _ns_34;
                 const { seeds, metadata } = seedSchemaMod;
@@ -8463,6 +8511,7 @@ class Item {
                                         seedLocalId: watchedSeedLocalId,
                                         seedUid: this._getSnapshotContext().seedUid ?? seedUid,
                                         modelName: itemModelName,
+                                        hold: false,
                                     });
                                     if (property) {
                                         logger(`[Item._setupLiveQuerySubscription] Created/cached ItemProperty instance for propertyName "${metaRow.propertyName}"`);
@@ -8506,6 +8555,9 @@ class Item {
                         logger('[Item._setupLiveQuerySubscription] Instance state not found');
                         return;
                     }
+                    // Unloaded or destroyed while setup awaited: subscribing now would leak the query.
+                    if (isActorStopped(this._service))
+                        return;
                     // Subscribe to seeds updates
                     const seedsSubscription = seeds$.subscribe({
                         next: async (seedRows) => {
@@ -8616,6 +8668,7 @@ class Item {
                                                 seedLocalId: watchedSeedLocalId,
                                                 seedUid: this._getSnapshotContext().seedUid ?? seedUid,
                                                 modelName: itemModelName,
+                                                hold: false,
                                             });
                                             if (property) {
                                                 sendToItemMachine({
@@ -8767,5 +8820,5 @@ var Item$1 = /*#__PURE__*/Object.freeze({
     Item: Item
 });
 
-export { unloadEntity as $, getPublishExecutor as A, getRevokeExecutor as B, ClientManagerState as C, DEFAULT_READY_TIMEOUT_MS as D, getUploadExecutor as E, getVersionData$1 as F, isLocalUnsealedDraft as G, isSeedRowOwned as H, Item as I, localUnsealedDraftSql as J, ownedPublisherSql as K, ownedSeedsSql as L, METADATA_LATEST_FIRST_ORDER_SQL as M, pickLatestMetadataRowPerProperty as N, OwnershipError as O, PUBLISH_NOT_CONFIGURED_MESSAGE as P, placeholderUidSql as Q, propertyMachine as R, publisherInAddressListSql as S, publisherIsInOwnedSet as T, setAdditionalSyncAddresses as U, setGetPublisherForNewSeeds as V, setPublishExecutor as W, setRevokeExecutor as X, setUploadExecutor as Y, getInvariantSafePropertyDescriptor as Z, clearDestroySubscriptions as _, ItemProperty as a, ClientManagerEvents as a0, withLockedItemStorageRow as a1, getItemStorageFilePath as a2, writeItemStorageFile as a3, resolvePublisherFromSeedRow as a4, getPropertyData$1 as a5, Item$1 as a6, ItemPropertySaveValidationError as b, assertItemOwned as c, waitForEntityIdle as d, compareMetadataRowsLatestFirst as e, getEasSchemaUidForModel as f, getItemData as g, getLatestPublishedVersionRow as h, isItemOwned as i, chunkValues as j, getGetAdditionalSyncAddresses as k, isVersionRevoked as l, createReactiveProxy as m, findEntity as n, forceRemoveFromCaches as o, parseListPropertyValueFromStorage as p, runDestroyLifecycle as q, rowsPerInsert as r, selectInBatches as s, isPublishedMetadataRow as t, MachineIds as u, createNewItem as v, writeInBatches as w, getEasSchemaForItemProperty as x, getGetPublisherForNewSeeds as y, getMetadataLatest as z };
-//# sourceMappingURL=Item-D6j0IvBP.js.map
+export { ActorKeyedState as $, getGetPublisherForNewSeeds as A, getMetadataLatest as B, ClientManagerState as C, DEFAULT_READY_TIMEOUT_MS as D, getPublishExecutor as E, getRevokeExecutor as F, getUploadExecutor as G, getVersionData$1 as H, Item as I, isLocalUnsealedDraft as J, isSeedRowOwned as K, localUnsealedDraftSql as L, METADATA_LATEST_FIRST_ORDER_SQL as M, ownedPublisherSql as N, OwnershipError as O, PUBLISH_NOT_CONFIGURED_MESSAGE as P, ownedSeedsSql as Q, pickLatestMetadataRowPerProperty as R, placeholderUidSql as S, propertyMachine as T, publisherInAddressListSql as U, publisherIsInOwnedSet as V, setAdditionalSyncAddresses as W, setGetPublisherForNewSeeds as X, setPublishExecutor as Y, setRevokeExecutor as Z, setUploadExecutor as _, ItemProperty as a, clearDestroySubscriptions as a0, unloadEntity as a1, ClientManagerEvents as a2, withLockedItemStorageRow as a3, getItemStorageFilePath as a4, writeItemStorageFile as a5, resolvePublisherFromSeedRow as a6, getPropertyData$1 as a7, Item$1 as a8, ItemPropertySaveValidationError as b, assertItemOwned as c, waitForEntityIdle as d, compareMetadataRowsLatestFirst as e, getEasSchemaUidForModel as f, getItemData as g, getLatestPublishedVersionRow as h, isItemOwned as i, chunkValues as j, getGetAdditionalSyncAddresses as k, isVersionRevoked as l, isActorStopped as m, createReactiveProxy as n, sameEntity as o, parseListPropertyValueFromStorage as p, findEntity as q, rowsPerInsert as r, selectInBatches as s, forceRemoveFromCaches as t, runDestroyLifecycle as u, isPublishedMetadataRow as v, writeInBatches as w, MachineIds as x, createNewItem as y, getEasSchemaForItemProperty as z };
+//# sourceMappingURL=Item-BiMHgg-_.js.map