@seedprotocol/sdk 0.7.9 → 0.7.10-next.1353.g74aeeed

package/dist/{Item-Bf4kWKpH.js → Item-oPnmIehk.js}

@@ -1,10 +1,10 @@
-import { a_ as PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP, n as normalizeDataType, v as INTERNAL_DATA_TYPES, af as MachineIds, O as resolveItemModelFileId, l as resolveModelRecordByNameOrType, A as AmbiguousModelError, m as generateId, a$ as TAB_ID, aM as onTabMessage, ax as whenLeaderTab, ap as isLeaderTab, aL as postTabMessage, j as findSeedRow, b0 as getModelSchemaName, K as selectInBatches, aX as getOwnedAddressesFromDb, Z as ZERO_BYTES32, ar as normalizeAddressList, J as normalizeHexAddress, am as getAddressesForItemsFilter, a0 as INTERNAL_PROPERTY_NAMES, a7 as convertTxIdToImage, i as isDataType, R as getExtensionForMimeType, b1 as normalizeMimeType, aA as sniffMimeType, Y as getItemStorageSubdir, ad as ImageSize, b2 as findFileInDir, b3 as getStorageSubdirForDataType, g as normalizePropertyRecordSchema, h as eventEmitter, b4 as timingMarks, a4 as getPropertyDefinition, aT as tryWithTabLock, b5 as withTabLock, M as ModelPropertyDataTypes, aC as createSessionObjectUrl, U as INTERNAL_STORAGE_MODEL_FILE_IDS, b6 as revokeSessionObjectUrl, aw as whenDbReady, b7 as timed, av as watchEntityRows, a5 as propertyDefinitionFromRow, b8 as isSessionObjectUrl, x as normalizePublisher, _ as getItemStorageLocalFileName, b9 as timingNow, ba as timingSince, bb as timingLogger, bc as timedDb } from './tabEvents-CaVmngqr.js';
+import { b0 as PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP, n as normalizeDataType, v as INTERNAL_DATA_TYPES, af as MachineIds, O as resolveItemModelFileId, l as resolveModelRecordByNameOrType, A as AmbiguousModelError, m as generateId, b1 as TAB_ID, aN as onTabMessage, ax as whenLeaderTab, ap as isLeaderTab, aM as postTabMessage, j as findSeedRow, b2 as getModelSchemaName, K as selectInBatches, aY as getOwnedAddressesFromDb, Z as ZERO_BYTES32, ar as normalizeAddressList, J as normalizeHexAddress, am as getAddressesForItemsFilter, a0 as INTERNAL_PROPERTY_NAMES, a7 as convertTxIdToImage, i as isDataType, R as getExtensionForMimeType, b3 as normalizeMimeType, aA as sniffMimeType, Y as getItemStorageSubdir, ad as ImageSize, b4 as findFileInDir, b5 as getStorageSubdirForDataType, g as normalizePropertyRecordSchema, h as eventEmitter, b6 as timingMarks, a4 as getPropertyDefinition, aU as tryWithTabLock, b7 as withTabLock, M as ModelPropertyDataTypes, aC as createSessionObjectUrl, U as INTERNAL_STORAGE_MODEL_FILE_IDS, b8 as revokeSessionObjectUrl, b9 as getPropertyDefinitionsByFileId, aw as whenDbReady, ba as timed, av as watchEntityRows, a5 as propertyDefinitionFromRow, bb as isSessionObjectUrl, a6 as addCachedPropertyRefresher, x as normalizePublisher, _ as getItemStorageLocalFileName, bc as timingNow, bd as timingSince, be as timingLogger, bf as timedDb } from './tabEvents-DT5ez6io.js';
 import { fromCallback, setup, assign, and as and$1, stateIn, createActor, waitFor, isMachineSnapshot } from 'xstate';
 import debug from 'debug';
 import pluralize from 'pluralize';
 import { easName, isValidEasAttestationUid, isPlaceholderUid, getEasSchemaUidForSchemaDefinition, getSchemaUidForModelFromCache, setSchemaUidForModel, cachedSchemaLookup, getEasModelSchemasForNames, getEasSchemaUidForExactDefinition } from '@seedprotocol/eas';
 import { sql, inArray, or, eq, and, isNull, getTableColumns, asc, lt, isNotNull, max, count, gt, desc, ne } from 'drizzle-orm';
-import { m as metadata, l as properties, B as BaseDb, d as models, p as pendingWrites, x as isSqliteBusyError, v as versions, s as seeds, w as BaseFileManager, b as modelUids, r as publishProcesses, e as arweaveL1FinalizeJobs, h as htmlEmbeddedImageCoPublish } from './BaseFileManager-BAlySv8w.js';
+import { m as metadata, l as properties, B as BaseDb, d as models, p as pendingWrites, x as isSqliteBusyError, v as versions, s as seeds, w as BaseFileManager, b as modelUids, r as publishProcesses, e as arweaveL1FinalizeJobs, h as htmlEmbeddedImageCoPublish } from './BaseFileManager-DLou1TZS.js';
 import { BehaviorSubject } from 'rxjs';
 import { orderBy } from 'lodash-es';
 import { normalizeRelationPropertyValue, resolveSeedIdsFromRefString, BaseArweaveClient } from '@seedprotocol/arweave';
@@ -496,7 +496,7 @@ const runPublish = fromCallback(({ sendBack, input: { context, item: itemFromEve
             // item.publish() sends its own instance; look it up only if startPublish came without one.
             const loaded = itemFromEvent
                 ? undefined
-                : (await (await Promise.resolve().then(function () { return Item$1; })).Item.find({ seedLocalId }));
+                : (await (await Promise.resolve().then(function () { return Item$1; })).Item.find({ seedLocalId, hold: true }));
             const item = itemFromEvent ?? loaded;
             if (!item) {
                 sendBack({ type: 'publishError', error: new Error(`Item not found: ${seedLocalId}`) });
@@ -1078,6 +1078,9 @@ function outboxOpResult(op) {
 // --- Draining ---------------------------------------------------------------------------------
 let started = false;
 let paused = false;
+/** Set by stopOutbox (client.stop) until the next startOutbox. */
+let stopped = false;
+let stopTabMessages;
 let draining;
 let drainAgain = false;
 let retryTimer;
@@ -1091,7 +1094,8 @@ function startOutbox() {
     if (started)
         return;
     started = true;
-    onTabMessage((message) => {
+    stopped = false;
+    stopTabMessages = onTabMessage((message) => {
         if (message.type === 'outbox-nudge' && isLeaderTab())
             scheduleDrain();
         if (message.type === 'outbox-settled')
@@ -1101,7 +1105,7 @@ function startOutbox() {
 }
 /** Drains soon in this tab (if it leads); calls made while a drain runs make it run once more. */
 function scheduleDrain() {
-    if (!isLeaderTab())
+    if (stopped || !isLeaderTab())
         return;
     if (draining) {
         drainAgain = true;
@@ -1112,7 +1116,7 @@ function scheduleDrain() {
             do {
                 drainAgain = false;
                 await drainOutbox();
-            } while (drainAgain && !paused);
+            } while (drainAgain && !paused && !stopped);
         }
         catch (error) {
             logger$8('drain failed', error);
@@ -1455,6 +1459,24 @@ async function getOutboxOps(opIds) {
         return [];
     return BaseDb.getAppDb().select().from(pendingWrites).where(inArray(pendingWrites.opId, opIds));
 }
+/**
+ * Stops draining in this tab (client.stop): no new drain starts, retries are dropped, and this
+ * resolves once a drain that was running has finished. Ops stay pending in the database; the next
+ * startOutbox (any write after init) resumes them, as after a reload.
+ */
+async function stopOutbox() {
+    started = false;
+    stopped = true;
+    stopTabMessages?.();
+    stopTabMessages = undefined;
+    if (retryTimer !== undefined) {
+        clearTimeout(retryTimer);
+        retryTimer = undefined;
+    }
+    notBefore.clear();
+    while (draining)
+        await draining;
+}
 
 /** A storage op's row fields, from either op shape. */
 function storageValueRowOf(value) {
@@ -2213,8 +2235,8 @@ const getItemsData = async ({ modelName, modelFileId, schemaName, deleted, inclu
         conditions.push(eq(seeds.type, easName(modelName)));
     }
     if (!modelFileId && schemaName && modelName) {
-        const _mod_0 = await import('./tabEvents-CaVmngqr.js');
-        const _ns_0 = _mod_0.be;
+        const _mod_0 = await import('./tabEvents-DT5ez6io.js');
+        const _ns_0 = _mod_0.bh;
         const { resolveModelRecord } = _ns_0;
         modelFileId = (await resolveModelRecord(modelName, { schemaName }))?.schemaFileId ?? undefined;
         if (!modelFileId)
@@ -2469,7 +2491,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-BVBmz_cc.js');
+        const schemaMod = await import('./index-DXRhFg1N.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
@@ -2983,7 +3005,7 @@ async function resolveStorageRef(kind, row) {
     }
     if (kind === 'html') {
         if (!out.refResolvedValue && out.propertyValue) {
-            const { resolveHtmlStorageSeedLocalId } = await import('./readHtmlBodyForStorageSeed-D6KPtWoR.js');
+            const { resolveHtmlStorageSeedLocalId } = await import('./readHtmlBodyForStorageSeed-B7HgPmq6.js');
             const localId = await resolveHtmlStorageSeedLocalId(out.propertyValue);
             if (localId)
                 out.refResolvedValue = `${localId}.html`;
@@ -3032,7 +3054,7 @@ async function resolveStorageDisplay(kind, row, options = {}) {
             }
         }
         if (!renderValue && options.fetch && ref.propertyValue) {
-            const { readHtmlBodyForStorageSeedPropertyValue } = await import('./readHtmlBodyForStorageSeed-D6KPtWoR.js');
+            const { readHtmlBodyForStorageSeedPropertyValue } = await import('./readHtmlBodyForStorageSeed-B7HgPmq6.js');
             renderValue = await readHtmlBodyForStorageSeedPropertyValue(ref.propertyValue);
         }
         return { ref, filePath, renderValue };
@@ -3044,15 +3066,15 @@ async function resolveStorageDisplay(kind, row, options = {}) {
         : BaseFileManager.pathExists(BaseFileManager.getFilesPath(dir, name)).then((exists) => exists ? BaseFileManager.getFilesPath(dir, name) : undefined);
     // ensureImageLocal also makes the smallest size variant when the original is already there
     if (kind === 'image' && options.fetch) {
-        const _mod_1 = await import('./tabEvents-CaVmngqr.js');
-        const _ns_1 = _mod_1.bl;
+        const _mod_1 = await import('./tabEvents-DT5ez6io.js');
+        const _ns_1 = _mod_1.bo;
         const { ensureImageLocal } = _ns_1;
         await ensureImageLocal({ transactionId: name, fileName: name, widths: [ImageSize.EXTRA_SMALL] });
     }
     let filePath = await find();
     if (!filePath && kind === 'file' && options.fetch) {
-        const _mod_2 = await import('./tabEvents-CaVmngqr.js');
-        const _ns_2 = _mod_2.bj;
+        const _mod_2 = await import('./tabEvents-DT5ez6io.js');
+        const _ns_2 = _mod_2.bm;
         const { downloadTransactionIdWithDedupe } = _ns_2;
         await downloadTransactionIdWithDedupe(name);
         filePath = await find();
@@ -3086,7 +3108,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
     }
     const _hydrateFromDb = async () => {
         const normalizedDataType = normalizeDataType(propertyRecordSchema?.dataType);
-        const row = await currentPropertyRow({ seedLocalId, seedUid }, {
+        const read = () => currentPropertyRow({ seedLocalId, seedUid }, {
             propertyId: context.propertyId,
             propertyName,
             modelName,
@@ -3094,10 +3116,15 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
             dataType: normalizedDataType,
             refValueType: normalizeDataType(propertyRecordSchema?.refValueType),
         });
+        let row = await read();
         if (!row)
             return;
         const { getPropertyConflict } = await Promise.resolve().then(function () { return conflicts; });
         const conflict = await getPropertyConflict(row.seedLocalId ?? seedLocalId, propertyName);
+        // Sync records a conflict and moves its draft to newest in one transaction: a row read before
+        // the conflict may be the synced one
+        if (conflict)
+            row = (await read()) ?? row;
         // Only with a definition: without one, a row's refSeedType alone doesn't decide the display here
         const kind = propertyRecordSchema ? storedValueKind(propertyRecordSchema) : undefined;
         let { refResolvedValue, localStorageDir } = row;
@@ -3480,12 +3507,12 @@ async function keepLocalDraftsOverSyncedRows(synced) {
         const now = Date.now();
         const remoteAt = remote.attestationCreatedAt ?? 0;
         const createdAt = Math.max(draft.createdAt ?? 0, remoteAt + 1);
-        // Written after the conflict: the change feed has no trigger on pending_writes, so this write
+        // Written with the conflict: the change feed has no trigger on pending_writes, so this write
         // is what makes a loaded property re-read and pick the conflict up (ADR 0020).
-        const keepDraftNewest = async (recordedConflict) => {
+        const keepDraftNewest = async (on, recordedConflict) => {
             if (createdAt === draft.createdAt && !recordedConflict)
                 return;
-            await db.update(metadata).set({ createdAt }).where(eq(metadata.localId, draft.localId));
+            await on.update(metadata).set({ createdAt }).where(eq(metadata.localId, draft.localId));
         };
         // The attested value the draft replaced: the newest attested row that sync didn't just write
         const base = candidates
@@ -3495,7 +3522,7 @@ async function keepLocalDraftsOverSyncedRows(synced) {
         const remoteValue = remote.propertyValue ?? null;
         const localValue = draft.propertyValue ?? null;
         if (remoteValue === localValue || remoteValue === baseValue) {
-            await keepDraftNewest(false);
+            await keepDraftNewest(db, false);
             continue;
         }
         const opId = generateId();
@@ -3508,19 +3535,23 @@ async function keepLocalDraftsOverSyncedRows(synced) {
             remoteUid: remote.uid,
             opId,
         };
-        await db.insert(pendingWrites).values({
-            opId,
-            seedLocalId: draft.seedLocalId,
-            propertyName: draft.propertyName,
-            kind: 'set',
-            value: JSON.stringify({ newValue: localValue }),
-            baseRowId: draft.localId,
-            createdAt: now,
-            status: 'applied',
-            appliedAt: now,
-            conflict: JSON.stringify(conflict),
+        // One transaction: a reader that sees the conflict also sees the draft as the newest row, or it
+        // could show the synced value beside the conflict
+        await BaseDb.transaction(async (tx) => {
+            await tx.insert(pendingWrites).values({
+                opId,
+                seedLocalId: draft.seedLocalId,
+                propertyName: draft.propertyName,
+                kind: 'set',
+                value: JSON.stringify({ newValue: localValue }),
+                baseRowId: draft.localId,
+                createdAt: now,
+                status: 'applied',
+                appliedAt: now,
+                conflict: JSON.stringify(conflict),
+            });
+            await keepDraftNewest(tx, true);
         });
-        await keepDraftNewest(true);
         eventEmitter.emit('itemProperty.conflict', conflict);
     }
 }
@@ -3535,194 +3566,6 @@ var conflicts = /*#__PURE__*/Object.freeze({
     recordPropertyEdit: recordPropertyEdit
 });
 
-/**
- * The cache behind an entity class (ADR 0014). `peek` takes no hold; `hold`, `add({ hold: true })`
- * and `holdInstance` take one each, and `release` gives one back. Entries are found by key or by
- * actor, so a raw instance and its proxy find the same entry.
- */
-class EntityCache {
-    constructor() {
-        this.byKey = new Map();
-        this.byActor = new WeakMap();
-    }
-    /** Cache `instance` under `keys` (empty and duplicate keys are skipped). Returns its entry. */
-    add(instance, keys, options) {
-        const existing = this.entryOf(instance);
-        if (existing) {
-            if (options.hold)
-                existing.refCount += 1;
-            for (const key of keys)
-                if (key)
-                    this.addKey(instance, key);
-            return existing;
-        }
-        const entry = {
-            instance,
-            refCount: options.hold ? 1 : 0,
-            keys: new Set(),
-        };
-        this.byActor.set(instance.getService(), entry);
-        for (const key of keys)
-            if (key)
-                this.addKey(instance, key);
-        return entry;
-    }
-    /** The cached instance under `key`, without taking a hold. */
-    peek(key) {
-        return key ? this.byKey.get(key)?.instance : undefined;
-    }
-    /** The cached instance under `key`, taking a hold the caller releases with `release`. */
-    hold(key) {
-        const entry = key ? this.byKey.get(key) : undefined;
-        if (!entry)
-            return undefined;
-        entry.refCount += 1;
-        return entry.instance;
-    }
-    /** Take a hold on a cached instance. False when it isn't cached (unloaded, evicted). */
-    holdInstance(instance) {
-        const entry = this.entryOf(instance);
-        if (!entry)
-            return false;
-        entry.refCount += 1;
-        return true;
-    }
-    /**
-     * Give back one hold. True when the instance should be torn down: its last hold went, or it
-     * isn't cached at all (evicted while the caller held it).
-     */
-    release(instance) {
-        const entry = this.entryOf(instance);
-        if (!entry)
-            return true;
-        entry.refCount -= 1;
-        return entry.refCount <= 0;
-    }
-    entryOf(instance) {
-        return this.byActor.get(instance.getService());
-    }
-    has(instance) {
-        return this.entryOf(instance) !== undefined;
-    }
-    /**
-     * Store the instance under one more key. A key held by another instance moves to this one:
-     * the newest instance for a name or uid wins.
-     */
-    addKey(instance, key) {
-        const entry = this.entryOf(instance);
-        if (!entry || !key)
-            return;
-        const previous = this.byKey.get(key);
-        if (previous === entry)
-            return;
-        previous?.keys.delete(key);
-        this.byKey.set(key, entry);
-        entry.keys.add(key);
-    }
-    removeKey(instance, key) {
-        const entry = this.entryOf(instance);
-        if (!entry || !entry.keys.has(key))
-            return;
-        entry.keys.delete(key);
-        if (this.byKey.get(key) === entry)
-            this.byKey.delete(key);
-    }
-    /** Replace every key of the instance (a rename, an id that changed). */
-    setKeys(instance, keys) {
-        const entry = this.entryOf(instance);
-        if (!entry)
-            return;
-        const next = new Set(keys.filter((key) => !!key));
-        for (const key of [...entry.keys])
-            if (!next.has(key))
-                this.removeKey(instance, key);
-        for (const key of next)
-            this.addKey(instance, key);
-    }
-    keysOf(instance) {
-        return [...(this.entryOf(instance)?.keys ?? [])];
-    }
-    /** Drop the instance under all its keys. Teardown (entityLifecycle) also releases its children. */
-    remove(instance) {
-        const entry = this.entryOf(instance);
-        if (!entry)
-            return undefined;
-        for (const key of entry.keys) {
-            if (this.byKey.get(key) === entry)
-                this.byKey.delete(key);
-        }
-        entry.keys.clear();
-        this.byActor.delete(instance.getService());
-        return entry;
-    }
-    /** Every cached instance once, optionally filtered. */
-    instances(filter) {
-        const seen = new Set();
-        const result = [];
-        for (const entry of this.byKey.values()) {
-            if (seen.has(entry))
-                continue;
-            seen.add(entry);
-            if (!filter || filter(entry.instance))
-                result.push(entry.instance);
-        }
-        return result;
-    }
-    get size() {
-        return this.instances().length;
-    }
-}
-/**
- * Evictions and destroys, by scope (`schema:<name>`, `model:<id>`). Work that reads a row and then
- * creates an instance from it (a lookup by id) can't be cancelled by stopping actors: capture
- * `evictionLog.now()` before the read, and skip creating when `evictedSince(scopes, then)`. A scope
- * also counts as evicted while its destroy runs, since its rows still exist until the delete commits.
- */
-const evictionLog = {
-    generation: 0,
-    last: new Map(),
-    running: new Map(),
-    now() {
-        return this.generation;
-    },
-    /** Record an eviction of these scopes. Call the returned function once a destroy's rows are gone. */
-    evict(scopes) {
-        this.generation += 1;
-        for (const scope of scopes) {
-            this.last.set(scope, this.generation);
-            this.running.set(scope, (this.running.get(scope) ?? 0) + 1);
-        }
-        let finished = false;
-        return () => {
-            if (finished)
-                return;
-            finished = true;
-            // Work that read a row during the destroy and checks after it must still see the eviction
-            this.generation += 1;
-            for (const scope of scopes) {
-                this.last.set(scope, this.generation);
-                const remaining = (this.running.get(scope) ?? 1) - 1;
-                if (remaining > 0)
-                    this.running.set(scope, remaining);
-                else
-                    this.running.delete(scope);
-            }
-        };
-    },
-    /** True when a scope is being destroyed, or was evicted after `since`. */
-    evictedSince(scopes, since) {
-        for (const scope of scopes) {
-            if (!scope)
-                continue;
-            if (this.running.has(scope))
-                return true;
-            if (this.generation !== since && (this.last.get(scope) ?? 0) > since)
-                return true;
-        }
-        return false;
-    },
-};
-
 /**
  * Default timeout for create/find/all with waitForReady. Loads that touch OPFS and the DB can take
  * several seconds on slow devices and CI runners; a load that is really stuck still errors.
@@ -3813,6 +3656,17 @@ async function waitForEntityReady(instance, options = {}) {
         throw cause instanceof Error ? cause : new EntityLoadError('Entity failed to load', { cause });
     }
 }
+/**
+ * A write or publish on an instance that was unloaded (no hold kept it past the grace period,
+ * or it was destroyed, evicted or dropped by another tab). Look it up again, and hold it while
+ * using it.
+ */
+class EntityUnloadedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'EntityUnloadedError';
+    }
+}
 /** Run `dispose` when the entity is torn down (unsubscribe a watch, revoke an object URL). */
 function onEntityTeardown(instance, dispose) {
     const lifecycle = lifecycleOf(instance);
@@ -3844,9 +3698,10 @@ function teardownEntity(instance, cache) {
         lifecycle.error = new EntityLoadError('Entity was unloaded before it finished loading');
         lifecycle.settle();
     }
+    // At once: the parent already waited out its grace period, or was destroyed or evicted
     for (const release of lifecycle.children.values()) {
         try {
-            release();
+            release({ immediate: true });
         }
         catch {
             // A child that fails to release must not keep the rest held
@@ -3871,9 +3726,12 @@ function teardownEntity(instance, cache) {
         // Already stopped
     }
 }
-/** Give back one hold; tear the entity down when it was the last. */
-function releaseEntity(instance, cache) {
-    if (cache.release(instance))
+/**
+ * Give back one hold. With the last one the entity is torn down after the grace period (at once
+ * with `immediate`, or when the grace period is 0); a hold taken meanwhile keeps it.
+ */
+function releaseEntity(instance, cache, options) {
+    if (cache.release(instance, options))
         teardownEntity(instance, cache);
 }
 /**
@@ -3886,6 +3744,14 @@ function evictEntities(cache, filter) {
         teardownEntity(instance, cache);
     return evicted;
 }
+/**
+ * Stop and drop every cached entity of every class, whoever holds it (client.stop()). Reaches the
+ * caches through EntityCache.all, so callers needn't import the entity classes.
+ */
+function evictAllEntities() {
+    for (const cache of EntityCache.all)
+        evictEntities(cache, () => true);
+}
 /**
  * Delete an entity's rows. By default it leaves the cache first, so no lookup returns it meanwhile;
  * with `leaveCache: 'after'` it stays cached until the rows are gone, so a lookup that read a row
@@ -3923,7 +3789,7 @@ function holdChild(parent, child, childCache) {
         return true;
     if (!childCache.holdInstance(child))
         return false;
-    lifecycle.children.set(key, () => releaseEntity(child, childCache));
+    lifecycle.children.set(key, (options) => releaseEntity(child, childCache, options));
     return true;
 }
 function releaseChildHold(parent, child) {
@@ -3940,6 +3806,270 @@ function heldChildActors(parent) {
     return [...lifecycleOf(parent).children.keys()];
 }
 
+/** Default for `SeedConfig.entityCache.unloadGraceMs`. */
+const DEFAULT_UNLOAD_GRACE_MS = 60000;
+let defaultUnloadGraceMs = DEFAULT_UNLOAD_GRACE_MS;
+let configuredUnloadGraceMs;
+/** How long an instance no one holds stays cached before it is torn down. 0: no grace period. */
+function entityUnloadGraceMs() {
+    return configuredUnloadGraceMs ?? defaultUnloadGraceMs;
+}
+/** `client.init` sets the configured value; `undefined` (client stop, or none given) uses the default. */
+function setEntityUnloadGraceMs(ms) {
+    configuredUnloadGraceMs = ms === undefined ? undefined : Math.max(0, ms);
+}
+/**
+ * The cache behind an entity class (ADR 0014). `peek` takes no hold; `hold`, `add({ hold: true })`
+ * and `holdInstance` take one each, and `release` gives one back. Entries are found by key or by
+ * actor, so a raw instance and its proxy find the same entry.
+ *
+ * An entry with no holds (its last one released, or added or looked up without one) is torn down
+ * after the grace period (`entityUnloadGraceMs`) unless a hold is taken first, which keeps the same
+ * instance. With a grace period of 0, the last release tears it down at once and an entry that
+ * never had a hold stays cached until it is evicted. Removing an entry (teardown, destroy,
+ * eviction) cancels its timer.
+ *
+ * A cache made with `unloadUnheld: false` (the definition classes: Schema, Model, ModelProperty)
+ * never tears an entry down for having no holds: it stays cached until it is destroyed, evicted or
+ * the client stops. Holds are still counted there, and releasing the last one does nothing, except
+ * an `immediate` release: its owner was destroyed or evicted (a Schema's models, a Model's
+ * properties), and a child no one else holds goes with it.
+ */
+class EntityCache {
+    constructor(options = {}) {
+        this.byKey = new Map();
+        this.byActor = new WeakMap();
+        this.unloadUnheld = options.unloadUnheld !== false;
+        EntityCache.all.add(this);
+    }
+    /** Cache `instance` under `keys` (empty and duplicate keys are skipped). Returns its entry. */
+    add(instance, keys, options) {
+        const existing = this.entryOf(instance);
+        if (existing) {
+            if (options.hold)
+                this.addHold(existing);
+            for (const key of keys)
+                if (key)
+                    this.addKey(instance, key);
+            return existing;
+        }
+        const entry = {
+            instance,
+            refCount: options.hold ? 1 : 0,
+            keys: new Set(),
+        };
+        this.byActor.set(instance.getService(), entry);
+        for (const key of keys)
+            if (key)
+                this.addKey(instance, key);
+        if (!options.hold)
+            this.keepUnheld(instance);
+        return entry;
+    }
+    /** The cached instance under `key`, without taking a hold. */
+    peek(key) {
+        return key ? this.byKey.get(key)?.instance : undefined;
+    }
+    /** The cached instance under `key`, taking a hold the caller releases with `release`. */
+    hold(key) {
+        const entry = key ? this.byKey.get(key) : undefined;
+        if (!entry)
+            return undefined;
+        this.addHold(entry);
+        return entry.instance;
+    }
+    /** Take a hold on a cached instance. False when it isn't cached (unloaded, evicted). */
+    holdInstance(instance) {
+        const entry = this.entryOf(instance);
+        if (!entry)
+            return false;
+        this.addHold(entry);
+        return true;
+    }
+    /**
+     * Give back one hold. True when the instance should be torn down now: its last hold went and
+     * there is no grace period (or `immediate`), or it isn't cached at all (evicted while the caller
+     * held it). After the last hold with a grace period, the teardown is scheduled instead. An
+     * instance with no holds (a caller that never held it) is left as it is, and so is an instance of
+     * a cache made with `unloadUnheld: false` unless the release is `immediate`.
+     */
+    release(instance, options = {}) {
+        const entry = this.entryOf(instance);
+        if (!entry)
+            return true;
+        if (entry.refCount <= 0)
+            return false;
+        entry.refCount -= 1;
+        if (entry.refCount > 0)
+            return false;
+        if (options.immediate)
+            return true;
+        if (!this.unloadUnheld)
+            return false;
+        if (entityUnloadGraceMs() === 0)
+            return true;
+        this.scheduleUnload(entry);
+        return false;
+    }
+    /**
+     * An instance a caller looked up without a hold: when no one holds it, restart its grace period,
+     * so it stays cached that long after its last use. Does nothing without a grace period.
+     */
+    keepUnheld(instance) {
+        const entry = this.entryOf(instance);
+        if (entry && entry.refCount <= 0 && this.unloadUnheld && entityUnloadGraceMs() > 0)
+            this.scheduleUnload(entry);
+    }
+    addHold(entry) {
+        entry.refCount += 1;
+        this.cancelUnload(entry);
+    }
+    scheduleUnload(entry) {
+        this.cancelUnload(entry);
+        const teardown = () => {
+            this.cancelUnload(entry);
+            if (this.byActor.get(entry.instance.getService()) === entry && entry.refCount <= 0) {
+                teardownEntity(entry.instance, this);
+            }
+        };
+        const timer = setTimeout(teardown, entityUnloadGraceMs());
+        timer.unref?.();
+        entry.unloadTimer = timer;
+    }
+    cancelUnload(entry) {
+        if (entry.unloadTimer === undefined)
+            return;
+        clearTimeout(entry.unloadTimer);
+        entry.unloadTimer = undefined;
+    }
+    entryOf(instance) {
+        return this.byActor.get(instance.getService());
+    }
+    has(instance) {
+        return this.entryOf(instance) !== undefined;
+    }
+    /**
+     * Store the instance under one more key. A key held by another instance moves to this one:
+     * the newest instance for a name or uid wins.
+     */
+    addKey(instance, key) {
+        const entry = this.entryOf(instance);
+        if (!entry || !key)
+            return;
+        const previous = this.byKey.get(key);
+        if (previous === entry)
+            return;
+        previous?.keys.delete(key);
+        this.byKey.set(key, entry);
+        entry.keys.add(key);
+    }
+    removeKey(instance, key) {
+        const entry = this.entryOf(instance);
+        if (!entry || !entry.keys.has(key))
+            return;
+        entry.keys.delete(key);
+        if (this.byKey.get(key) === entry)
+            this.byKey.delete(key);
+    }
+    /** Replace every key of the instance (a rename, an id that changed). */
+    setKeys(instance, keys) {
+        const entry = this.entryOf(instance);
+        if (!entry)
+            return;
+        const next = new Set(keys.filter((key) => !!key));
+        for (const key of [...entry.keys])
+            if (!next.has(key))
+                this.removeKey(instance, key);
+        for (const key of next)
+            this.addKey(instance, key);
+    }
+    keysOf(instance) {
+        return [...(this.entryOf(instance)?.keys ?? [])];
+    }
+    /** Drop the instance under all its keys. Teardown (entityLifecycle) also releases its children. */
+    remove(instance) {
+        const entry = this.entryOf(instance);
+        if (!entry)
+            return undefined;
+        this.cancelUnload(entry);
+        for (const key of entry.keys) {
+            if (this.byKey.get(key) === entry)
+                this.byKey.delete(key);
+        }
+        entry.keys.clear();
+        this.byActor.delete(instance.getService());
+        return entry;
+    }
+    /** Every cached instance once, optionally filtered. */
+    instances(filter) {
+        const seen = new Set();
+        const result = [];
+        for (const entry of this.byKey.values()) {
+            if (seen.has(entry))
+                continue;
+            seen.add(entry);
+            if (!filter || filter(entry.instance))
+                result.push(entry.instance);
+        }
+        return result;
+    }
+    get size() {
+        return this.instances().length;
+    }
+}
+/** Every cache made, one per entity class; client.stop() evicts them all (evictAllEntities). */
+EntityCache.all = new Set();
+/**
+ * Evictions and destroys, by scope (`schema:<name>`, `model:<id>`). Work that reads a row and then
+ * creates an instance from it (a lookup by id) can't be cancelled by stopping actors: capture
+ * `evictionLog.now()` before the read, and skip creating when `evictedSince(scopes, then)`. A scope
+ * also counts as evicted while its destroy runs, since its rows still exist until the delete commits.
+ */
+const evictionLog = {
+    generation: 0,
+    last: new Map(),
+    running: new Map(),
+    now() {
+        return this.generation;
+    },
+    /** Record an eviction of these scopes. Call the returned function once a destroy's rows are gone. */
+    evict(scopes) {
+        this.generation += 1;
+        for (const scope of scopes) {
+            this.last.set(scope, this.generation);
+            this.running.set(scope, (this.running.get(scope) ?? 0) + 1);
+        }
+        let finished = false;
+        return () => {
+            if (finished)
+                return;
+            finished = true;
+            // Work that read a row during the destroy and checks after it must still see the eviction
+            this.generation += 1;
+            for (const scope of scopes) {
+                this.last.set(scope, this.generation);
+                const remaining = (this.running.get(scope) ?? 1) - 1;
+                if (remaining > 0)
+                    this.running.set(scope, remaining);
+                else
+                    this.running.delete(scope);
+            }
+        };
+    },
+    /** True when a scope is being destroyed, or was evicted after `since`. */
+    evictedSince(scopes, since) {
+        for (const scope of scopes) {
+            if (!scope)
+                continue;
+            if (this.running.has(scope))
+                return true;
+            if (this.generation !== since && (this.last.get(scope) ?? 0) > since)
+                return true;
+        }
+        return false;
+    },
+};
+
 const logger$4 = debug('seedSdk:itemProperty:loadProperty');
 /**
  * Load a property's value and definition: its current row (with a pending outbox value over it,
@@ -3970,15 +4100,14 @@ async function loadProperty(context) {
     });
     timing.mark('metadata');
     if (!metadataRecord) {
-        // Metadata not found - this is a new property, will be created elsewhere.
-        // Still resolve propertyRecordSchema from Model so getSegmentedItemProperties and
-        // getPublishPayload can route and attest the property (e.g. title, description).
+        // No row yet: its first assignment writes one. The definition still comes from the model,
+        // since the setter checks and routes values by it (planPropertyWrite).
         let propertyRecordSchema = undefined;
         const modelNameForNew = context.modelName;
         if (modelNameForNew) {
             try {
-                const _mod_3 = await import('./tabEvents-CaVmngqr.js');
-                const _ns_3 = _mod_3.be;
+                const _mod_3 = await import('./tabEvents-DT5ez6io.js');
+                const _ns_3 = _mod_3.bh;
                 const { resolveItemModelFileId, modelNameForType } = _ns_3;
                 const itemModelFileId = await resolveItemModelFileId({
                     modelFileId: context.modelFileId,
@@ -4017,8 +4146,8 @@ async function loadProperty(context) {
     // Load propertyRecordSchema from database to make ItemProperty independent from Model
     let propertyRecordSchema = undefined;
     // Model names are only unique per schema: pin lookups to the item's own model row.
-    const _mod_4 = await import('./tabEvents-CaVmngqr.js');
-    const _ns_4 = _mod_4.be;
+    const _mod_4 = await import('./tabEvents-DT5ez6io.js');
+    const _ns_4 = _mod_4.bh;
     const { resolveItemModelFileId, modelNameForType } = _ns_4;
     const modelFileId = await resolveItemModelFileId({
         modelFileId: context.modelFileId,
@@ -4122,11 +4251,11 @@ async function loadPropertyDefinition(db, { propertyId, modelName, modelFileId,
     }
     if (!modelName)
         return undefined;
-    const { loadModelPropertyRecordSchemas } = await import('./modelPropertyRecordSchemas-C7UgA5TH.js');
+    const { loadModelPropertyRecordSchemas } = await import('./modelPropertyRecordSchemas-DEe-lYhn.js');
     const definition = (await loadModelPropertyRecordSchemas(modelName, modelFileId, db)).get(propertyName);
     if (definition)
         return definition;
-    const _mod_5 = await import('./errors-DLSoqSHG.js');
+    const _mod_5 = await import('./errors-CnT0fSMK.js');
     const _ns_5 = _mod_5.a4;
     const { Model } = _ns_5;
     const { modelPropertiesToObject } = await Promise.resolve().then(function () { return model; });
@@ -4232,13 +4361,17 @@ let validationLoading;
 function whenValidationLoaded() {
     if (validationService)
         return Promise.resolve();
-    validationLoading ?? (validationLoading = import('./SchemaValidationService-CnmKyzR-.js')
-        .then(({ SchemaValidationService }) => {
-        validationService = new SchemaValidationService();
-    })
-        .finally(() => {
-        validationLoading = undefined;
-    }));
+    // async/await, not import().then: rollup's dynamic-import rewrite (rollup.config.mjs) only
+    // neutralizes the minified chunk-export read (`.then(n => n._)`) in this form
+    validationLoading ?? (validationLoading = (async () => {
+        try {
+            const { SchemaValidationService } = await import('./SchemaValidationService-CieGrj5c.js');
+            validationService = new SchemaValidationService();
+        }
+        finally {
+            validationLoading = undefined;
+        }
+    })());
     return validationLoading;
 }
 const isValidationLoaded = () => validationService !== undefined;
@@ -4467,17 +4600,17 @@ hints = {}) => {
     }
     try {
         if (hints.propertyId != null) {
-            const _mod_6 = await import('./tabEvents-CaVmngqr.js');
-            const _ns_6 = _mod_6.bf;
+            const _mod_6 = await import('./tabEvents-DT5ez6io.js');
+            const _ns_6 = _mod_6.bi;
             const { getPropertyDefinition } = _ns_6;
             const definition = await getPropertyDefinition(hints.propertyId);
             if (definition)
                 return definition;
         }
-        const _mod_7 = await import('./tabEvents-CaVmngqr.js');
-        const _ns_7 = _mod_7.be;
+        const _mod_7 = await import('./tabEvents-DT5ez6io.js');
+        const _ns_7 = _mod_7.bh;
         const { resolveItemModelFileId } = _ns_7;
-        const { getModelPropertyDefinitions, resolvePropertyKey } = await import('./property-BxUYznH0.js');
+        const { getModelPropertyDefinitions, resolvePropertyKey } = await import('./property-iNW1N3vm.js');
         const modelFileId = (await resolveItemModelFileId(hints)) ?? undefined;
         const name = modelName || ((await modelTypeToModelName(modelType)) ?? '');
         // An ambiguous bare name reads nothing here; the in-memory model below may still know it
@@ -4485,7 +4618,7 @@ hints = {}) => {
         const key = resolvePropertyKey(definitions, propertyName);
         if (key)
             return definitions[key];
-        const _mod_8 = await import('./errors-DLSoqSHG.js');
+        const _mod_8 = await import('./errors-CnT0fSMK.js');
         const _ns_8 = _mod_8.a4;
         const { Model } = _ns_8;
         const { modelPropertiesToObject } = await Promise.resolve().then(function () { return model; });
@@ -4506,8 +4639,8 @@ hints = {}) => {
 const modelTypeToModelName = async (modelType) => {
     if (!modelType)
         return undefined;
-    const _mod_9 = await import('./tabEvents-CaVmngqr.js');
-    const _ns_9 = _mod_9.be;
+    const _mod_9 = await import('./tabEvents-DT5ez6io.js');
+    const _ns_9 = _mod_9.bh;
     const { modelNameForType } = _ns_9;
     return modelNameForType(modelType).catch(() => undefined);
 };
@@ -4670,7 +4803,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await import('./index-BVBmz_cc.js');
+            const schemaMod = await import('./index-DXRhFg1N.js');
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -4883,7 +5016,7 @@ class ItemProperty {
                 // The change feed reports writes by stored name: watch every name this property's rows have
                 const propertyNames = [...property.names];
                 if (propertyId != null) {
-                    const _mod_10 = await import('./index-D0V-mjCV.js');
+                    const _mod_10 = await import('./index-BjWk0x4-.js');
                     const _ns_10 = _mod_10.s;
                     const { metadata } = _ns_10;
                     const { eq: eqOp } = await import('drizzle-orm');
@@ -4923,12 +5056,17 @@ class ItemProperty {
                 // A pending edit settles the conflict when it applies, so an overlaid row shows none.
                 // `assignSeq` marks a read begun before an assignment in this tab: it may predate that op,
                 // which the context already shows, so the feed drops it.
+                // Sync records a conflict and moves its draft to newest in one transaction, so a row read
+                // before the conflict may be the synced one: read the row again once a conflict shows.
                 const readRow = async () => {
                     const assignSeq = this._assignSeq;
-                    const row = await currentPropertyRow({ seedLocalId, seedUid }, { match: property, propertyName }, { overlay: true, db });
+                    const read = () => currentPropertyRow({ seedLocalId, seedUid }, { match: property, propertyName }, { overlay: true, db });
+                    let row = await read();
                     if (!row)
                         return row;
                     const conflict = row.overlaid ? null : await getPropertyConflict(row.seedLocalId ?? seedLocalId, propertyName);
+                    if (conflict)
+                        row = (await read()) ?? row;
                     return { ...row, conflict, assignSeq };
                 };
                 // In the browser the feed watch below reads the row at once, so only Node (no change feed)
@@ -5057,6 +5195,33 @@ class ItemProperty {
             });
         }
     }
+    /** Takes a property definition read from its row, as the constructor takes the initial one. */
+    _applyDefinition(propertyRecordSchema) {
+        this._service.send({ type: 'updateContext', propertyRecordSchema });
+        this._dataType = normalizeDataType(propertyRecordSchema.dataType);
+        const isList = isDataType(propertyRecordSchema.dataType, ModelPropertyDataTypes.List);
+        this._isList = isList;
+        this._isRelation = isList
+            ? !!propertyRecordSchema.ref
+            : isDataType(propertyRecordSchema.dataType, ModelPropertyDataTypes.Relation);
+    }
+    /**
+     * Gives cached instances of these properties their rows' current definitions, after a schema
+     * change wrote the rows (refreshCachedProperties). An instance keeps the definition it loaded
+     * with otherwise: Node has no live query, and the browser's arrives some time after the write.
+     */
+    static async refreshDefinitions(propertyFileIds) {
+        const instances = this.cache.instances().filter((instance) => !isActorStopped(instance._service));
+        if (instances.length === 0)
+            return;
+        const definitions = await getPropertyDefinitionsByFileId(propertyFileIds);
+        for (const instance of instances) {
+            const fileId = instance._getSnapshotContext().propertyRecordSchema?.id;
+            const definition = fileId ? definitions.get(fileId) : undefined;
+            if (definition)
+                instance._applyDefinition(definition);
+        }
+    }
     /**
      * Set up liveQuery subscription to watch for property schema changes in the properties table.
      * When ModelProperty dataType (or other schema fields) changes in the database, ItemProperty
@@ -5077,8 +5242,8 @@ class ItemProperty {
             const ctx = this._service.getSnapshot().context;
             let modelFileId;
             try {
-                const _mod_11 = await import('./tabEvents-CaVmngqr.js');
-                const _ns_11 = _mod_11.be;
+                const _mod_11 = await import('./tabEvents-DT5ez6io.js');
+                const _ns_11 = _mod_11.bh;
                 const { resolveItemModelFileId } = _ns_11;
                 modelFileId = await resolveItemModelFileId({
                     modelFileId: ctx.modelFileId,
@@ -5131,29 +5296,7 @@ class ItemProperty {
                         const required = row.required;
                         const propertyRecordSchema = propertyDefinitionFromRow({ ...row, required: required == null ? null : !!required }, refModelName);
                         logger(`[ItemProperty._setupPropertySchemaLiveQuery] Schema updated for ${propertyName}: dataType=${row.dataType}`);
-                        this._service.send({
-                            type: 'updateContext',
-                            propertyRecordSchema,
-                        });
-                        // Update instance fields to match new schema (mirror constructor logic)
-                        this._dataType = normalizeDataType(propertyRecordSchema.dataType);
-                        if (isDataType(propertyRecordSchema.dataType, ModelPropertyDataTypes.Relation)) {
-                            ;
-                            this._isRelation = true;
-                        }
-                        else {
-                            ;
-                            this._isRelation = false;
-                        }
-                        if (isDataType(propertyRecordSchema.dataType, ModelPropertyDataTypes.List)) {
-                            ;
-                            this._isList = true;
-                            this._isRelation = !!(propertyRecordSchema.ref);
-                        }
-                        else {
-                            ;
-                            this._isList = false;
-                        }
+                        this._applyDefinition(propertyRecordSchema);
                     },
                     error: (error) => {
                         logger(`[ItemProperty._setupPropertySchemaLiveQuery] LiveQuery error: ${error}`);
@@ -5205,6 +5348,8 @@ class ItemProperty {
         if (cached) {
             if (holds)
                 this.cache.holdInstance(cached);
+            else
+                this.cache.keepUnheld(cached);
             for (const key of [keyByLocal, keyByUid])
                 this.cache.addKey(cached, key);
             this.syncFromRow(cached, props);
@@ -5337,8 +5482,11 @@ class ItemProperty {
         }
         return undefined;
     }
-    /** 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, }) {
+    /**
+     * The property's instance, loaded from its row when it isn't cached. Takes no hold unless
+     * `hold: true` (release it with `unload()`).
+     */
+    static async find({ propertyName, seedLocalId, seedUid, modelName: modelNameOption, waitForReady = true, readyTimeout = DEFAULT_READY_TIMEOUT_MS, hold = false, }) {
         if ((!seedLocalId && !seedUid) || !propertyName) {
             return undefined;
         }
@@ -5355,8 +5503,10 @@ class ItemProperty {
                 return undefined;
             for (const key of [keyByLocal, keyByUid])
                 this.cache.addKey(cached, key);
-            if (hold !== false)
+            if (hold)
                 this.cache.holdInstance(cached);
+            else
+                this.cache.keepUnheld(cached);
             return cached;
         };
         foundProperty = fromCache();
@@ -5400,10 +5550,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.
+     * Takes no holds unless `hold: true`, as `find`.
      */
     static async all(params, options) {
-        const { waitForReady = false, readyTimeout = DEFAULT_READY_TIMEOUT_MS, hold } = options ?? {};
+        const { waitForReady = false, readyTimeout = DEFAULT_READY_TIMEOUT_MS, hold = false } = options ?? {};
         const { seedLocalId, seedUid } = params;
         if (!seedLocalId && !seedUid) {
             return [];
@@ -5411,8 +5561,8 @@ class ItemProperty {
         const propertiesData = await getItemProperties({ seedLocalId, seedUid });
         const instances = [];
         const seenNormalized = new Set();
-        const _mod_12 = await import('./tabEvents-CaVmngqr.js');
-        const _ns_12 = _mod_12.be;
+        const _mod_12 = await import('./tabEvents-DT5ez6io.js');
+        const _ns_12 = _mod_12.bh;
         const { resolveItemModelFileId } = _ns_12;
         const itemModelFileId = await resolveItemModelFileId({ seedLocalId, seedUid });
         // One lookup per model type, not per property
@@ -5433,7 +5583,7 @@ class ItemProperty {
             // (`textId` → `text`, `authorIdentityIds` → `authors`)
             const definitionsKey = JSON.stringify([modelName, modelFileId ?? null]);
             if (modelName && !definitionsByModel.has(definitionsKey)) {
-                const { getModelPropertyDefinitions } = await import('./property-BxUYznH0.js');
+                const { getModelPropertyDefinitions } = await import('./property-iNW1N3vm.js');
                 definitionsByModel.set(definitionsKey, 
                 // No model row: the stored name decides
                 getModelPropertyDefinitions(modelName, { modelFileId }).then(Object.fromEntries, () => ({})));
@@ -5607,7 +5757,7 @@ class ItemProperty {
         const { seedLocalId, propertyName } = this._getSnapshotContext();
         if (!seedLocalId || !propertyName)
             return;
-        const { appendOutboxOpAndWait, markPropertyConflictsResolved, startItemOutbox, throwItemWriteError } = await import('./index-CYGWPoOx.js');
+        const { appendOutboxOpAndWait, markPropertyConflictsResolved, startItemOutbox, throwItemWriteError } = await import('./index-CZMWKXLM.js');
         if (choice === 'remote') {
             startItemOutbox();
             await appendOutboxOpAndWait({
@@ -5654,6 +5804,7 @@ class ItemProperty {
      * any tab, else its stored row.
      */
     setValue(value) {
+        this._assertLoaded('set');
         // An empty Image, File or Html value has nothing to store: it clears the property
         if ((value == null || (typeof value === 'string' && value.trim() === '')) && this._holdsStorageSeed(this._getSnapshotContext())) {
             this._assign(null, { retract: false });
@@ -5754,8 +5905,8 @@ class ItemProperty {
         context = this._getSnapshotContext();
         if (!context.seedLocalId) {
             // An item known only by its seed uid: its local seed, if it has one
-            const _mod_13 = await import('./tabEvents-CaVmngqr.js');
-            const _ns_13 = _mod_13.bd;
+            const _mod_13 = await import('./tabEvents-DT5ez6io.js');
+            const _ns_13 = _mod_13.bg;
             const { findSeedRow } = _ns_13;
             const seedLocalId = context.seedUid ? (await findSeedRow({ uid: context.seedUid }))?.localId : undefined;
             if (!seedLocalId)
@@ -5794,7 +5945,7 @@ class ItemProperty {
     /** Waits for an appended op to settle, then shows its row, or the current value if it failed. */
     async _followWrite(write, appended, plan) {
         try {
-            const { getOutboxOps, outboxOpResult, startItemOutbox, waitForOutboxOp } = await import('./index-CYGWPoOx.js');
+            const { getOutboxOps, outboxOpResult, startItemOutbox, waitForOutboxOp } = await import('./index-CZMWKXLM.js');
             startItemOutbox();
             const opId = await appended;
             await waitForOutboxOp(opId);
@@ -5853,7 +6004,7 @@ class ItemProperty {
             this._service.send({ type: 'updateContext', ...outcome.applied, isSaving: false });
             return;
         }
-        const { throwItemWriteError } = await import('./index-CYGWPoOx.js');
+        const { throwItemWriteError } = await import('./index-CZMWKXLM.js');
         let error = outcome.error;
         try {
             throwItemWriteError(outcome.error);
@@ -5919,6 +6070,7 @@ class ItemProperty {
      * ItemPropertySaveValidationError when the value broke a rule and was not written.
      */
     async save() {
+        this._assertLoaded('save');
         const ctx = this._getSnapshotContext();
         const label = `save ${ctx?.modelName ?? '?'}.${ctx?.propertyName ?? '?'}`;
         const { assertItemOwned } = await Promise.resolve().then(function () { return ownership; });
@@ -5949,6 +6101,14 @@ 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.
      */
+    /** Throws EntityUnloadedError, naming the property and its item, when this instance was unloaded. */
+    _assertLoaded(action) {
+        if (!isEntityTornDown(this))
+            return;
+        const { seedLocalId, seedUid, modelName, propertyName } = this._getSnapshotContext();
+        throw new EntityUnloadedError(`Cannot ${action} ${modelName ?? '?'}.${propertyName ?? '?'} of item ${seedLocalId ?? seedUid ?? '(no id)'}: ` +
+            'this ItemProperty instance was unloaded. Look the item or property up again, and hold it while you use it.');
+    }
     /** Releases this caller's hold; the last one stops the property and drops it from the cache. */
     unload() {
         releaseEntity(this, ItemProperty.cache);
@@ -5979,7 +6139,7 @@ class ItemProperty {
         if (db && seedLocalId) {
             // Through the outbox (ADR 0019): after the property's pending edits, which would
             // otherwise write its rows back
-            const { appendOutboxOpAndWait, startItemOutbox, throwItemWriteError } = await import('./index-CYGWPoOx.js');
+            const { appendOutboxOpAndWait, startItemOutbox, throwItemWriteError } = await import('./index-CZMWKXLM.js');
             startItemOutbox();
             await appendOutboxOpAndWait({
                 seedLocalId,
@@ -5989,7 +6149,7 @@ class ItemProperty {
             }).catch(throwItemWriteError);
         }
         else if (db) {
-            const _mod_14 = await import('./index-D0V-mjCV.js');
+            const _mod_14 = await import('./index-BjWk0x4-.js');
             const _ns_14 = _mod_14.s;
             const seedSchemaMod = _ns_14;
             const { metadata } = seedSchemaMod;
@@ -6018,6 +6178,7 @@ class ItemProperty {
 }
 /** Cached as `Item_<id>_<propertyName>` under its item's local id and seed uid. */
 ItemProperty.cache = new EntityCache();
+addCachedPropertyRefresher((propertyFileIds) => ItemProperty.refreshDefinitions(propertyFileIds));
 
 var ItemProperty$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -6221,7 +6382,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await import('./SchemaValidationService-CnmKyzR-.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-CieGrj5c.js');
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, normalizeDataType(propertyRecordSchema.dataType), propertyRecordSchema.validation, propertyRecordSchema.refValueType
             ? normalizeDataType(String(propertyRecordSchema.refValueType))
@@ -6315,7 +6476,7 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
     }
     const seedType = easName(modelName);
     // Dynamic import to break circular dependency
-    const _mod_15 = await import('./errors-DLSoqSHG.js');
+    const _mod_15 = await import('./errors-CnT0fSMK.js');
     const _ns_15 = _mod_15.a4;
     const modelMod = _ns_15;
     const { Model } = modelMod;
@@ -6373,7 +6534,7 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
             }
             rows.push({ propertyName, propertyValue, propertyRecordSchema, schemaUid: schemaUids.get(propertyName) });
         }
-        const { appendOutboxOpAndWait, startItemOutbox } = await import('./index-CYGWPoOx.js');
+        const { appendOutboxOpAndWait, startItemOutbox } = await import('./index-CZMWKXLM.js');
         startItemOutbox();
         const fields = await timed(`${label} seed fields`, () => resolveNewSeedFields(seedType));
         const applied = await timed(`${label} outbox apply`, () => appendOutboxOpAndWait({
@@ -6392,7 +6553,7 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
     }
     catch (error) {
         // Staged values of a create that never got appended (once appended, the op's discard does it)
-        const _mod_16 = await import('./errors-DLSoqSHG.js');
+        const _mod_16 = await import('./errors-CnT0fSMK.js');
         const _ns_16 = _mod_16.a7;
         const { deleteFiles } = _ns_16;
         await deleteFiles(stagedPaths);
@@ -6468,14 +6629,14 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
         };
         // The model's property definitions from their rows; a model created in this session whose
         // rows aren't written yet gives its in-memory ones
-        const { getModelPropertyDefinitions } = await import('./property-BxUYznH0.js');
+        const { getModelPropertyDefinitions } = await import('./property-iNW1N3vm.js');
         let propertySchemas = Object.fromEntries(await getModelPropertyDefinitions(modelName, modelScope).catch((err) => {
             logger(`No property definitions for ${modelName}: ${err}`);
             return [];
         }));
         if (Object.keys(propertySchemas).length === 0) {
             const { modelPropertiesToObject } = await Promise.resolve().then(function () { return model; });
-            const _mod_17 = await import('./errors-DLSoqSHG.js');
+            const _mod_17 = await import('./errors-CnT0fSMK.js');
             const _ns_17 = _mod_17.a4;
             const { Model } = _ns_17;
             const model$1 = Model.resolve(modelName, modelScope);
@@ -6503,7 +6664,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-BVBmz_cc.js');
+                    const schemaMod = await import('./index-DXRhFg1N.js');
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -6886,7 +7047,7 @@ const getModel = () => {
         // the fragile `import(...).then(n => n.X)` chunk-namespace pattern.
         if (!modelImportPromise) {
             modelImportPromise = (async () => {
-                const _mod_18 = await import('./errors-DLSoqSHG.js');
+                const _mod_18 = await import('./errors-CnT0fSMK.js');
                 const _ns_18 = _mod_18.a4;
                 const mod = _ns_18;
                 ModelClass = mod.Model;
@@ -7002,6 +7163,7 @@ class Item {
             });
         };
         this.unpublish = async () => {
+            this._assertLoaded('unpublish');
             const { assertItemOwned } = await Promise.resolve().then(function () { return ownership; });
             const { getRevokeExecutor } = await Promise.resolve().then(function () { return publishConfig; });
             await assertItemOwned(this);
@@ -7045,6 +7207,7 @@ class Item {
          * if it failed. Throws OwnershipError if none of the client's addresses own the item.
          */
         this.publish = async (options) => {
+            this._assertLoaded('publish');
             const { assertItemOwned } = await Promise.resolve().then(function () { return ownership; });
             const { getPublishExecutor, PUBLISH_NOT_CONFIGURED_MESSAGE } = await Promise.resolve().then(function () { return publishConfig; });
             await assertItemOwned(this);
@@ -7085,14 +7248,14 @@ class Item {
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const _mod_19 = await import('./getPublishUploads-sS6JfPgz.js');
-            const _ns_19 = _mod_19.n;
+            const _mod_19 = await import('./getPublishUploads-DivYpgNw.js');
+            const _ns_19 = _mod_19.q;
             const getPublishUploadsMod = _ns_19;
             const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this, options);
         };
         this.getPublishPayload = async (uploadedTransactions, options) => {
-            const _mod_20 = await import('./getPublishPayload-BnIwpwz1.js');
+            const _mod_20 = await import('./getPublishPayload-DKuEaq96.js');
             const _ns_20 = _mod_20.c;
             const getPublishPayloadMod = _ns_20;
             const { getPublishPayload } = getPublishPayloadMod;
@@ -7241,13 +7404,13 @@ class Item {
      * Cache a new item under its ids and keep its keys in step with them (a seed uid arrives on
      * publish, moves on republish), then start its load.
      */
-    static cacheAndLoad(instance) {
+    static cacheAndLoad(instance, hold = true) {
         const keys = () => {
             const { seedLocalId, seedUid } = instance._getSnapshotContext();
             return [seedLocalId, seedUid];
         };
         let current = keys().join('\u0000');
-        this.cache.add(instance, keys(), { hold: true });
+        this.cache.add(instance, keys(), { hold });
         const idWatch = instance._service.subscribe(() => {
             const next = keys();
             if (next.join('\u0000') === current || isEntityTornDown(instance))
@@ -7286,6 +7449,7 @@ class Item {
             sendUpdate: (target, prop, value) => {
                 if (prop === 'publisher')
                     throw new Error('Cannot set item.publisher: publisher is read-only.');
+                target._assertLoaded(`set ${prop} on`);
                 Item.sendTrackedPropertyUpdate(target, prop, value);
                 if (prop === 'seedUid' && typeof value === 'string' && value.length > 0) {
                     target._persistSeedUid(value);
@@ -7298,6 +7462,7 @@ class Item {
                 return {
                     get: () => property.value,
                     set: (value) => {
+                        target._assertLoaded(`set ${prop} on`);
                         property.value = value;
                     },
                 };
@@ -7313,6 +7478,15 @@ class Item {
         reactiveProxies.set(instance._service, proxy);
         return proxy;
     }
+    /** Throws EntityUnloadedError, naming the item, when this instance was unloaded. */
+    _assertLoaded(action) {
+        if (!isEntityTornDown(this))
+            return;
+        const { seedLocalId, seedUid, modelName } = this._getSnapshotContext();
+        throw new EntityUnloadedError(`Cannot ${action} ${modelName ?? 'item'} ${seedLocalId ?? seedUid ?? '(no id)'}: this Item instance was ` +
+            'unloaded. Look the item up again (Item.find), and hold it while you use it ' +
+            '(Item.find({ hold: true }) or Item.retain, then unload()).');
+    }
     /**
      * 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.
@@ -7407,11 +7581,12 @@ class Item {
     static async create(props, options) {
         const waitForReady = options?.waitForReady !== false;
         const readyTimeout = options?.readyTimeout ?? DEFAULT_READY_TIMEOUT_MS;
+        const hold = options?.hold !== false;
         if (!props.modelName && props.type) {
             // The model the seed's type names (its easName, at the model's nameMatch level): `blog_post`
             // finds "Blog Post". No match leaves the type, which then fails as an unknown model.
-            const _mod_21 = await import('./tabEvents-CaVmngqr.js');
-            const _ns_21 = _mod_21.be;
+            const _mod_21 = await import('./tabEvents-DT5ez6io.js');
+            const _ns_21 = _mod_21.bh;
             const { resolveModelRecordByNameOrType } = _ns_21;
             const model = await resolveModelRecordByNameOrType(props.type, {
                 modelFileId: props.modelFileId,
@@ -7423,7 +7598,10 @@ class Item {
             // Local id first, so list rows (local + uid) resolve the same instance as early draft loads
             const cached = this.cache.peek(props.seedLocalId) ?? this.cache.peek(props.seedUid);
             if (cached) {
-                this.cache.holdInstance(cached);
+                if (hold)
+                    this.cache.holdInstance(cached);
+                else
+                    this.cache.keepUnheld(cached);
                 const propertyInstances = cached.getService().getSnapshot().context.propertyInstances;
                 for (const [propertyName, propertyValue] of Object.entries(props)) {
                     propertyInstances?.get(propertyName)?.getService().send({ type: 'updateContext', propertyValue });
@@ -7434,7 +7612,8 @@ class Item {
                     await waitForEntityReady(cached, { timeout: readyTimeout });
                 }
                 catch (err) {
-                    cached.unload();
+                    if (hold)
+                        cached.unload();
                     throw err;
                 }
                 return cached;
@@ -7443,14 +7622,15 @@ class Item {
             // Exclude latestVersionUid from props as it has incompatible types (string vs VersionsType)
             const { latestVersionUid: _latestVersionUid, ...propsWithoutVersionUid } = props;
             const proxiedInstance = Item.wrapInProxy(new Item({ ...propsWithoutVersionUid }));
-            this.cacheAndLoad(proxiedInstance);
+            this.cacheAndLoad(proxiedInstance, hold);
             if (!waitForReady)
                 return proxiedInstance;
             try {
                 await waitForEntityReady(proxiedInstance, { timeout: readyTimeout });
             }
             catch (err) {
-                proxiedInstance.unload();
+                if (hold)
+                    proxiedInstance.unload();
                 throw err;
             }
             return proxiedInstance;
@@ -7469,8 +7649,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_22 = await import('./tabEvents-CaVmngqr.js');
-            const _ns_22 = _mod_22.be;
+            const _mod_22 = await import('./tabEvents-DT5ez6io.js');
+            const _ns_22 = _mod_22.bh;
             const { resolveModelRecord } = _ns_22;
             const modelRecord = await resolveModelRecord(props.modelName, {
                 modelFileId: props.modelFileId ?? modelInstance?.id,
@@ -7478,7 +7658,7 @@ class Item {
             });
             const modelRecords = modelRecord ? [modelRecord] : [];
             if (!modelRecord) {
-                const _mod_23 = await import('./errors-DLSoqSHG.js');
+                const _mod_23 = await import('./errors-CnT0fSMK.js');
                 const _ns_23 = _mod_23.a8;
                 const { UnknownModelError } = _ns_23;
                 throw new UnknownModelError(props.modelName, schemaName ?? modelInstance?.schemaName);
@@ -7489,8 +7669,8 @@ 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_24 = await import('./tabEvents-CaVmngqr.js');
-                const _ns_24 = _mod_24.be;
+                const _mod_24 = await import('./tabEvents-DT5ez6io.js');
+                const _ns_24 = _mod_24.bh;
                 const { getModelSchemaName } = _ns_24;
                 const modelSchemaName = await getModelSchemaName(modelRecord.id, db);
                 if (modelSchemaName) {
@@ -7560,10 +7740,16 @@ class Item {
         const propsWithModel = { ...propsWithoutVersionUid };
         const newInstance = new Item(propsWithModel);
         const proxiedInstance = Item.wrapInProxy(newInstance);
+        // Held while create saves its values; `hold: false` gives the hold back as it returns
         this.cacheAndLoad(proxiedInstance);
+        const created = () => {
+            if (!hold)
+                this.cache.release(proxiedInstance);
+            return proxiedInstance;
+        };
         // Storage values must be saved before returning, so wait for readiness even when not requested.
         if (!waitForReady && pipelineValues.length === 0)
-            return proxiedInstance;
+            return created();
         try {
             await waitForEntityReady(proxiedInstance, { timeout: readyTimeout });
             await this.savePipelineValues(proxiedInstance, pipelineValues, readyTimeout);
@@ -7573,7 +7759,7 @@ class Item {
             await this.discardCreatedItem(proxiedInstance, seedLocalId);
             throw err;
         }
-        return proxiedInstance;
+        return created();
     }
     /**
      * Stops a just-created item and deletes what create wrote: a `discard` outbox op (ADR 0019),
@@ -7588,7 +7774,7 @@ class Item {
             /* best-effort cache cleanup */
         }
         try {
-            const { appendOutboxOpAndWait, deleteFiles, startItemOutbox } = await import('./index-CYGWPoOx.js');
+            const { appendOutboxOpAndWait, deleteFiles, startItemOutbox } = await import('./index-CZMWKXLM.js');
             startItemOutbox();
             const applied = await appendOutboxOpAndWait({
                 seedLocalId,
@@ -7611,7 +7797,7 @@ class Item {
         for (const [propertyName, value] of pipelineValues) {
             const property = await this.waitForPropertyInstance(item, propertyName, timeout);
             if (!property) {
-                const _mod_25 = await import('./errors-DLSoqSHG.js');
+                const _mod_25 = await import('./errors-CnT0fSMK.js');
                 const _ns_25 = _mod_25.a8;
                 const { ItemCreateError } = _ns_25;
                 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 });
@@ -7623,14 +7809,14 @@ class Item {
             }
             catch (error) {
                 if (error instanceof ItemPropertySaveValidationError) {
-                    const _mod_26 = await import('./errors-DLSoqSHG.js');
+                    const _mod_26 = await import('./errors-CnT0fSMK.js');
                     const _ns_26 = _mod_26.a8;
                     const { ItemCreateValidationError } = _ns_26;
                     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_27 = await import('./errors-DLSoqSHG.js');
+                const _mod_27 = await import('./errors-CnT0fSMK.js');
                 const _ns_27 = _mod_27.a8;
                 const { ItemCreateError } = _ns_27;
                 throw new ItemCreateError(`Item.create: failed to save ${item.modelName}.${propertyName} for item ${item.seedLocalId}: ` +
@@ -7715,7 +7901,15 @@ class Item {
             modelName,
         }));
     }
-    static async find({ modelName, seedLocalId, seedUid, waitForReady = true, readyTimeout = DEFAULT_READY_TIMEOUT_MS, }) {
+    /**
+     * The Item for a seedLocalId or seedUid, loaded from its rows when it isn't cached. Takes no
+     * cache hold: an item no one holds stays cached for the grace period
+     * (`SeedConfig.entityCache.unloadGraceMs`) after this lookup, then unloads. A caller that keeps
+     * the item longer passes `hold: true` and releases it with `unload()`, or holds it with
+     * `Item.retain` (React hooks do). Returns undefined, keeping no hold, when there is no such item
+     * or it isn't ready in `readyTimeout`.
+     */
+    static async find({ modelName, seedLocalId, seedUid, waitForReady = true, readyTimeout = DEFAULT_READY_TIMEOUT_MS, hold = false, }) {
         if (!seedLocalId && !seedUid) {
             return undefined;
         }
@@ -7725,11 +7919,22 @@ class Item {
             return undefined;
         }
         let cached = false;
+        let held;
         try {
             return await timedDb(`find ${modelName ?? '?'} ${id}`, async () => {
-                const held = Item.getById(id) ?? undefined;
-                cached = held !== undefined;
-                const item = held ?? (await Item.createById(id, modelName, seedLocalId ? 'localId' : undefined));
+                const fromCache = hold ? (Item.getById(id) ?? undefined) : Item.peek(id);
+                if (fromCache && !hold)
+                    Item.cache.keepUnheld(fromCache);
+                cached = fromCache !== undefined;
+                let item = fromCache;
+                if (!item) {
+                    item = await Item.createById(id, modelName, seedLocalId ? 'localId' : undefined);
+                    // createById holds what it returns; without one the item waits out the grace period
+                    if (item && !hold)
+                        Item.cache.release(item);
+                }
+                if (hold)
+                    held = item;
                 if (item && waitForReady)
                     await waitForEntityReady(item, { timeout: readyTimeout });
                 return item;
@@ -7737,26 +7942,46 @@ class Item {
         }
         catch (error) {
             timingLogger(`find ${modelName ?? '?'} ${id} returned undefined: ${error}`);
+            held?.unload();
             return undefined;
         }
     }
+    /**
+     * 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 item = instance;
+        return item.getService().getSnapshot().status === 'active' && this.cache.holdInstance(item);
+    }
+    /**
+     * The items of a model (every model when `modelName` is omitted), newest first. Takes no cache
+     * holds, as `find`: an item no one holds unloads after the grace period. With `hold: true` each
+     * item comes with a hold the caller releases with `unload()`; when the call then throws (aborted,
+     * an item not ready in `readyTimeout`), it keeps none of the holds it took.
+     */
     static async all(modelName, deleted, options) {
-        const { waitForReady = false, readyTimeout = DEFAULT_READY_TIMEOUT_MS, includeEas = false, addressFilter, modelFileId, schemaName, signal, } = options ?? {};
+        const { hold = false, waitForReady = false, readyTimeout = DEFAULT_READY_TIMEOUT_MS, includeEas = false, addressFilter, modelFileId, schemaName, signal, } = options ?? {};
         signal?.throwIfAborted();
         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) {
+        try {
+            // Built without waiting; with waitForReady the items are then awaited together, below.
+            for (const itemData of itemsData) {
+                signal?.throwIfAborted();
+                itemInstances.push(await Item.create({ ...itemData, modelName }, { waitForReady: false, hold }));
+            }
+            if (waitForReady && itemInstances.length > 0) {
+                await Promise.all(itemInstances.map((item) => waitForEntityReady(item, { timeout: readyTimeout })));
+            }
             signal?.throwIfAborted();
-            itemInstances.push(await Item.create({
-                ...itemData,
-                modelName,
-            }, { waitForReady: false }));
         }
-        if (waitForReady && itemInstances.length > 0) {
-            await Promise.all(itemInstances.map((item) => waitForEntityReady(item, { timeout: readyTimeout })));
+        catch (error) {
+            if (hold)
+                for (const item of itemInstances)
+                    item.unload();
+            throw error;
         }
-        signal?.throwIfAborted();
         return orderBy(itemInstances, ['createdAt'], ['desc']);
     }
     /**
@@ -7769,7 +7994,7 @@ class Item {
         if (!appDb || Item.cache.size === 0) {
             return;
         }
-        const _mod_28 = await import('./index-D0V-mjCV.js');
+        const _mod_28 = await import('./index-BjWk0x4-.js');
         const _ns_28 = _mod_28.s;
         const { metadata } = _ns_28;
         const { eq, and } = await import('drizzle-orm');
@@ -7881,11 +8106,11 @@ class Item {
     }
     /** Throws ItemCreateValidationError for unknown keys and values that break their property's rules. */
     static async assertValidCreateValues(props, propertyNames, dataTypeByPropertyName, skipKeys) {
-        const _mod_29 = await import('./errors-DLSoqSHG.js');
+        const _mod_29 = await import('./errors-CnT0fSMK.js');
         const _ns_29 = _mod_29.a8;
         const { ItemCreateValidationError } = _ns_29;
-        const { getModelPropertyDefinitions, resolvePropertyKey } = await import('./property-BxUYznH0.js');
-        const { SchemaValidationService } = await import('./SchemaValidationService-CnmKyzR-.js');
+        const { getModelPropertyDefinitions, resolvePropertyKey } = await import('./property-iNW1N3vm.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-CieGrj5c.js');
         const validationService = new SchemaValidationService();
         const modelName = props.modelName;
         const known = new Set(propertyNames);
@@ -8239,7 +8464,7 @@ class Item {
                 itemActor.send(event);
             };
             try {
-                const _mod_30 = await import('./index-D0V-mjCV.js');
+                const _mod_30 = await import('./index-BjWk0x4-.js');
                 const _ns_30 = _mod_30.s;
                 const seedSchemaMod = _ns_30;
                 const { seeds, metadata } = seedSchemaMod;
@@ -8253,8 +8478,8 @@ class Item {
                     return;
                 }
                 // Query initial seed and version data
-                const _mod_31 = await import('./tabEvents-CaVmngqr.js');
-                const _ns_31 = _mod_31.bd;
+                const _mod_31 = await import('./tabEvents-DT5ez6io.js');
+                const _ns_31 = _mod_31.bg;
                 const { findSeedRow } = _ns_31;
                 const seed = await findSeedRow({ localId: seedLocalId, uid: seedUid }, db);
                 if (!seed) {
@@ -8554,7 +8779,7 @@ class Item {
                 return;
             }
             // Through the outbox (ADR 0019): after the item's pending edits, not before them
-            const { appendOutboxOpAndWait, startItemOutbox, throwItemWriteError } = await import('./index-CYGWPoOx.js');
+            const { appendOutboxOpAndWait, startItemOutbox, throwItemWriteError } = await import('./index-CZMWKXLM.js');
             startItemOutbox();
             await appendOutboxOpAndWait({
                 seedLocalId: context.seedLocalId,
@@ -8581,5 +8806,5 @@ var Item$1 = /*#__PURE__*/Object.freeze({
     Item: Item
 });
 
-export { createReactiveProxy as $, getCorrectId as A, isItemOwned as B, ClearNotSupportedError as C, isPublishedSeedRef as D, propertyKeyFromStoredName as E, currentPropertyRows as F, metadataPropertyGroupKeys as G, compareMetadataRowsLatestFirst as H, Item as I, readMetadataPropertiesById as J, isPublishedMetadataRow as K, getLatestPublishedVersionRow as L, isVersionRevoked as M, readModelMetadataProperties as N, OUTBOX_DEFER_MS as O, metadataPropertyNameForms as P, currentPropertyRow as Q, getLatestVersionRow as R, parseListPropertyValueFromStorage as S, applyContextUpdate as T, isInternalUpdate as U, evictionLog as V, holdChild as W, isEntityTornDown as X, sameEntity as Y, DEFAULT_READY_TIMEOUT_MS as Z, waitForEntityReady as _, appendOutboxOpAndWait as a, findSetConflict as a$, runEntityLoad as a0, evictEntities as a1, entityStatus as a2, releaseEntity as a3, destroyEntity as a4, EntityCache as a5, getGetAdditionalSyncAddresses as a6, modelPropertiesToObject as a7, listRelationEasPropertyName as a8, easPropertyNameForPublish as a9, getVersionData as aA, isLocalUnsealedDraft as aB, isSeedRowOwned as aC, localUnsealedDraftSql as aD, ownedPublisherSql as aE, ownedSeedsSql as aF, pickLatestMetadataRowPerProperty as aG, placeholderUidSql as aH, propertyMachine as aI, publisherInAddressListSql as aJ, publisherIsInOwnedSet as aK, setAdditionalSyncAddresses as aL, setGetPublisherForNewSeeds as aM, setPublishExecutor as aN, setRevokeExecutor as aO, setUploadExecutor as aP, getSeedPublisher as aQ, deleteStagedFile as aR, storageFileName as aS, STORAGE_SUBDIR as aT, resolveNewSeedFields as aU, lookupPropertySchemaUid as aV, stageStorageContent as aW, requireStagedFile as aX, createSeed as aY, createMetadata as aZ, storageValueRowOf as a_, metadataStorageName as aa, resolveMetadataPropertyId as ab, storageSeedTransactionId as ac, storageUploadPath as ad, matchMetadataProperty as ae, metadataRowsOfProperty as af, METADATA_LATEST_FIRST_ORDER_SQL as ag, getEasSchemaUidForModel as ah, isStorageSeedRef as ai, isActorStopped as aj, differsFromOriginals as ak, onEntityTeardown as al, getStorageTransactionIdForSeedUid as am, latestVersionOrder as an, otherVersionRowsWithUid as ao, mergeVersionRowInto as ap, findMetadataPropertyByName as aq, resolvePublisherFromSeedRow as ar, PUBLISH_NOT_CONFIGURED_MESSAGE as as, createNewItem as at, getArweaveUrlForTransaction as au, getGetPublisherForNewSeeds as av, getMetadataLatest as aw, getPublishExecutor as ax, getRevokeExecutor as ay, getUploadExecutor as az, waitForPendingOutboxOps as b, recordPropertyEdit as b0, currentPropertyRow$1 as b1, resolve as b2, conflicts as b3, propertySchemaUid as b4, Item$1 as b5, OUTBOX_MAX_ATTEMPTS as c, OUTBOX_PRUNE_AFTER_MS as d, OUTBOX_PRUNE_FAILED_AFTER_MS as e, OUTBOX_RETRY_DELAYS_MS as f, getOutboxOps as g, OutboxOpDeferredError as h, OutboxOpFailedError as i, OutboxOpRejectedError as j, appendOutboxOp as k, drainOutbox as l, markPropertyConflictsResolved as m, getItemConflicts as n, outboxOpResult as o, getPendingSetValue as p, getPropertyConflict as q, outboxOpValue as r, pruneOutbox as s, registerOutboxApplier as t, startOutbox as u, ItemProperty as v, waitForOutboxOp as w, ItemPropertySaveValidationError as x, OwnershipError as y, assertItemOwned as z };
-//# sourceMappingURL=Item-Bf4kWKpH.js.map
+export { runEntityLoad as $, getCorrectId as A, isItemOwned as B, ClearNotSupportedError as C, isPublishedSeedRef as D, propertyKeyFromStoredName as E, currentPropertyRows as F, metadataPropertyGroupKeys as G, compareMetadataRowsLatestFirst as H, Item as I, readMetadataPropertiesById as J, isPublishedMetadataRow as K, getLatestPublishedVersionRow as L, isVersionRevoked as M, readModelMetadataProperties as N, OUTBOX_DEFER_MS as O, metadataPropertyNameForms as P, currentPropertyRow as Q, getLatestVersionRow as R, parseListPropertyValueFromStorage as S, applyContextUpdate as T, isInternalUpdate as U, evictionLog as V, holdChild as W, isEntityTornDown as X, sameEntity as Y, DEFAULT_READY_TIMEOUT_MS as Z, createReactiveProxy as _, appendOutboxOpAndWait as a, createSeed as a$, waitForEntityReady as a0, evictEntities as a1, EntityUnloadedError as a2, entityStatus as a3, releaseEntity as a4, destroyEntity as a5, EntityCache as a6, getGetAdditionalSyncAddresses as a7, modelPropertiesToObject as a8, listRelationEasPropertyName as a9, getPublishExecutor as aA, getRevokeExecutor as aB, getUploadExecutor as aC, getVersionData as aD, isLocalUnsealedDraft as aE, isSeedRowOwned as aF, localUnsealedDraftSql as aG, ownedPublisherSql as aH, ownedSeedsSql as aI, pickLatestMetadataRowPerProperty as aJ, placeholderUidSql as aK, propertyMachine as aL, publisherInAddressListSql as aM, publisherIsInOwnedSet as aN, setAdditionalSyncAddresses as aO, setGetPublisherForNewSeeds as aP, setPublishExecutor as aQ, setRevokeExecutor as aR, setUploadExecutor as aS, getSeedPublisher as aT, deleteStagedFile as aU, storageFileName as aV, STORAGE_SUBDIR as aW, resolveNewSeedFields as aX, lookupPropertySchemaUid as aY, stageStorageContent as aZ, requireStagedFile as a_, easPropertyNameForPublish as aa, metadataStorageName as ab, resolveMetadataPropertyId as ac, storageSeedTransactionId as ad, storageUploadPath as ae, matchMetadataProperty as af, metadataRowsOfProperty as ag, METADATA_LATEST_FIRST_ORDER_SQL as ah, getEasSchemaUidForModel as ai, isStorageSeedRef as aj, isActorStopped as ak, differsFromOriginals as al, onEntityTeardown as am, getStorageTransactionIdForSeedUid as an, latestVersionOrder as ao, otherVersionRowsWithUid as ap, mergeVersionRowInto as aq, findMetadataPropertyByName as ar, storedValueKind as as, resolveStorageDisplay as at, resolvePublisherFromSeedRow as au, PUBLISH_NOT_CONFIGURED_MESSAGE as av, createNewItem as aw, getArweaveUrlForTransaction as ax, getGetPublisherForNewSeeds as ay, getMetadataLatest as az, waitForPendingOutboxOps as b, createMetadata as b0, storageValueRowOf as b1, findSetConflict as b2, recordPropertyEdit as b3, setEntityUnloadGraceMs as b4, stopOutbox as b5, evictAllEntities as b6, currentPropertyRow$1 as b7, resolve as b8, conflicts as b9, propertySchemaUid as ba, Item$1 as bb, OUTBOX_MAX_ATTEMPTS as c, OUTBOX_PRUNE_AFTER_MS as d, OUTBOX_PRUNE_FAILED_AFTER_MS as e, OUTBOX_RETRY_DELAYS_MS as f, getOutboxOps as g, OutboxOpDeferredError as h, OutboxOpFailedError as i, OutboxOpRejectedError as j, appendOutboxOp as k, drainOutbox as l, markPropertyConflictsResolved as m, getItemConflicts as n, outboxOpResult as o, getPendingSetValue as p, getPropertyConflict as q, outboxOpValue as r, pruneOutbox as s, registerOutboxApplier as t, startOutbox as u, ItemProperty as v, waitForOutboxOp as w, ItemPropertySaveValidationError as x, OwnershipError as y, assertItemOwned as z };
+//# sourceMappingURL=Item-oPnmIehk.js.map