@salesforce/lds-worker-api 1.467.0 → 1.468.0

package/dist/standalone/es/lds-worker-api.js

@@ -4276,7 +4276,7 @@ function withDefaultLuvio(callback) {
     }
     callbacks.push(callback);
 }
-// version: 1.467.0-4f065d2a2a
+// version: 1.468.0-9ef0fbdaee
 
 // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
 function instrumentAdapter$1(createFunction, _metadata) {
@@ -5320,7 +5320,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     const { apiFamily, name } = metadata;
     return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
 }
-// version: 1.467.0-4f065d2a2a
+// version: 1.468.0-9ef0fbdaee
 
 function isSupportedEntity(_objectApiName) {
     return true;
@@ -32565,7 +32565,7 @@ withDefaultLuvio((luvio) => {
     throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
     throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
 });
-// version: 1.467.0-049a8b6027
+// version: 1.468.0-c060a9b9c6
 
 var draftQueueMaxRetryAttemptsGate = {
     isOpen: function (e) {
@@ -32646,6 +32646,15 @@ var allowUpdatesForNonCachedRecords = {
     },
 };
 
+var sideEffectRefreshKillSwitch = {
+    isOpen: function (e) {
+        return e.fallback;
+    },
+    hasError: function () {
+        return !0;
+    },
+};
+
 var caseSensitiveUserId = '005B0000000GR4OIAW';
 
 /**
@@ -48701,6 +48710,48 @@ class DurableDraftQueue {
             await this.startQueue();
         }
     }
+    /**
+     * Builds the set of actions deleted by removing `action`, validating
+     * before any store mutation. Same-tag actions are ordered newest-first so
+     * the clicked create is handled last and each intermediate side-effect
+     * replay reflects a valid undo prefix.
+     */
+    resolveActionsToRemove(action, queue, isUploading) {
+        const shouldDeleteRelated = this.getHandler(action.handler).shouldDeleteActionByTagOnRemoval(action);
+        const removedActions = shouldDeleteRelated
+            ? queue.filter((a) => a.tag === action.tag).reverse()
+            : [action];
+        const uploading = removedActions.find((a) => isUploading(a.id));
+        if (uploading !== undefined) {
+            // eslint-disable-next-line @salesforce/lds/no-error-in-production
+            throw new Error(`Cannot remove an uploading draft action with ID ${uploading.id}`);
+        }
+        return {
+            shouldDeleteRelated,
+            removed: removedActions.map((a) => ({
+                action: a,
+                handler: this.getHandler(a.handler),
+            })),
+        };
+    }
+    /**
+     * Runs every removed action's handler cleanup before emitting any
+     * ActionDeleted event, so listeners observe the final side-effect state.
+     */
+    async notifyActionsRemoved(removed, queue) {
+        const removedIds = new Set(removed.map(({ action }) => action.id));
+        const remaining = queue.filter((a) => !removedIds.has(a.id));
+        for (const { action, handler } of removed) {
+            await handler.handleActionRemoved(action, remaining);
+        }
+        for (const { action } of removed) {
+            await this.notifyChangedListeners({
+                type: DraftQueueEventType.ActionDeleted,
+                action,
+                draftCount: this.draftStore.getCount(),
+            });
+        }
+    }
     async removeDraftAction(actionId) {
         const queue = await this.getQueueActions();
         //Get the store key for the removed action
@@ -48710,32 +48761,18 @@ class DurableDraftQueue {
             throw new Error(`No removable action with id ${actionId}`);
         }
         const action = actions[0];
-        if (action.id === this.uploadingActionId) {
-            // eslint-disable-next-line @salesforce/lds/no-error-in-production
-            throw new Error(`Cannot remove an uploading draft action with ID ${actionId}`);
-        }
-        const handler = this.getHandler(action.handler);
-        const shouldDeleteRelated = handler.shouldDeleteActionByTagOnRemoval(action);
+        const { shouldDeleteRelated, removed } = this.resolveActionsToRemove(action, queue, (id) => id === this.uploadingActionId);
         if (shouldDeleteRelated) {
             await this.draftStore.deleteByTag(action.tag);
-            queue.forEach((queuedAction) => {
-                if (queuedAction.tag === action.tag) {
-                    this.uploadStartTimes.delete(queuedAction.id);
-                    this.actionQueueWaitEmittedIds.delete(queuedAction.id);
-                }
-            });
         }
         else {
             await this.draftStore.deleteDraft(action.id);
-            this.uploadStartTimes.delete(action.id);
-            this.actionQueueWaitEmittedIds.delete(action.id);
         }
-        await handler.handleActionRemoved(action, queue.filter((x) => x.id !== actionId));
-        await this.notifyChangedListeners({
-            type: DraftQueueEventType.ActionDeleted,
-            action,
-            draftCount: this.draftStore.getCount(),
+        removed.forEach(({ action: a }) => {
+            this.uploadStartTimes.delete(a.id);
+            this.actionQueueWaitEmittedIds.delete(a.id);
         });
+        await this.notifyActionsRemoved(removed, queue);
         if (this.userState === DraftQueueState.Started &&
             this.state !== DraftQueueState.Started &&
             this.replacingAction === undefined) {
@@ -48774,15 +48811,12 @@ class DurableDraftQueue {
         return this.replaceOrMergeActions(targetActionId, sourceActionId, true);
     }
     async retryAction(actionId) {
-        this.stopQueueManually(true);
-        const actions = await this.getQueueActions();
-        const target = actions[0];
-        if (!target || target.id !== actionId) {
-            throw Error(`Action ${actionId} not found at the head of the draft queue`);
-        }
+        // Validate before stopping so a rejected retry leaves the queue state untouched.
+        const target = await this.getRetryTarget(actionId);
         if (!isDraftError(target)) {
             throw Error(`Action ${actionId} is not in Error state`);
         }
+        this.stopQueueManually(true);
         // A manual retry is a fresh start: clear the persisted upload retry-attempt
         // count so the action doesn't immediately re-cap after a single failure.
         const { [DRAFT_ACTION_RETRY_COUNT_METADATA_KEY]: _retryCount, ...metadataWithoutRetryCount } = target.metadata || {};
@@ -48801,6 +48835,18 @@ class DurableDraftQueue {
         await this.startQueueSafe();
         return pendingAction;
     }
+    /**
+     * The action `retryAction` may retry. Only the head: an errored head is what blocks a
+     * strictly ordered queue.
+     */
+    async getRetryTarget(actionId) {
+        const actions = await this.getQueueActions();
+        const target = actions[0];
+        if (!target || target.id !== actionId) {
+            throw Error(`Action ${actionId} not found at the head of the draft queue`);
+        }
+        return target;
+    }
     async setMetadata(actionId, metadata) {
         const keys$1 = keys$4(metadata);
         const compatibleKeys = keys$1.filter((key) => {
@@ -50403,27 +50449,17 @@ class PerformanceDraftQueue extends DurableDraftQueue {
             throw new Error(`No removable action with id ${actionId}`);
         }
         const action = actions[0];
-        if (this.uploadingActionIds.has(action.id)) {
-            // eslint-disable-next-line @salesforce/lds/no-error-in-production
-            throw new Error(`Cannot remove an uploading draft action with ID ${actionId}`);
-        }
+        const { shouldDeleteRelated, removed } = this.resolveActionsToRemove(action, queue, (id) => this.uploadingActionIds.has(id));
         // A removed action must not leave a dangling backoff timer that would
         // later fire and re-drive the scheduler for an id that no longer exists.
-        this.clearActionRetry(action.id);
-        const handler = this.getHandler(action.handler);
-        const shouldDeleteRelated = handler.shouldDeleteActionByTagOnRemoval(action);
+        removed.forEach(({ action: a }) => this.clearActionRetry(a.id));
         if (shouldDeleteRelated) {
             await this.draftStore.deleteByTag(action.tag);
         }
         else {
             await this.draftStore.deleteDraft(action.id);
         }
-        await handler.handleActionRemoved(action, queue.filter((x) => x.id !== actionId));
-        await this.notifyChangedListeners({
-            type: DraftQueueEventType.ActionDeleted,
-            action,
-            draftCount: this.draftStore.getCount(),
-        });
+        await this.notifyActionsRemoved(removed, queue);
         if (this.userState === DraftQueueState.Started &&
             this.state !== DraftQueueState.Started &&
             this.replacingAction === undefined) {
@@ -50562,6 +50598,27 @@ class PerformanceDraftQueue extends DurableDraftQueue {
         }
         return super.startQueue();
     }
+    /**
+     * The head of the shared store may belong to the other queue, so targets are resolved
+     * against the actions this queue owns. With strict ordering only the owned head can be
+     * retried (it is what blocks dispatch); without it an errored action blocks nothing, so
+     * any errored action this queue owns can be retried.
+     */
+    async getRetryTarget(actionId) {
+        const owned = await this.getOwnedQueueActions();
+        if (this.strictOrdering) {
+            const head = owned[0];
+            if (!head || head.id !== actionId) {
+                throw Error(`Action ${actionId} not found at the head of the draft queue`);
+            }
+            return head;
+        }
+        const target = owned.find((action) => action.id === actionId);
+        if (target === undefined) {
+            throw Error(`Action ${actionId} not found in the draft queue`);
+        }
+        return target;
+    }
     async retryAllErrors() {
         const actions = await this.getOwnedQueueActions();
         const errored = actions.filter((a) => a.status === DraftActionStatus.Error);
@@ -50666,6 +50723,8 @@ class RoutingDraftQueue {
     removeHandler(id) {
         return this.primary.removeHandler(id);
     }
+    // Removes only the action itself. Removing a binary action through RoutingDraftManager also
+    // removes the serial actions that depend on it; this façade does not.
     async removeDraftAction(actionId) {
         const owner = await this.routeByActionId(actionId);
         return owner.removeDraftAction(actionId);
@@ -51107,27 +51166,12 @@ function isResourceRequestAction$1(action) {
     return (dataAsAny !== undefined && dataAsAny.method !== undefined && dataAsAny.body !== undefined);
 }
 
-function hasGetOwnedQueueActions(queue) {
-    return typeof queue.getOwnedQueueActions === 'function';
-}
-function hasGetCreatedDraftIds(queue) {
-    return typeof queue.getCreatedDraftIds === 'function';
-}
-function hasGetOwnedActionsReferencing(queue) {
-    return typeof queue.getOwnedActionsReferencing === 'function';
-}
-function hasRetryAllErrors(queue) {
-    return typeof queue.retryAllErrors === 'function';
-}
 /**
  * Gate-ON DraftManager: the concurrent-binary upload variant, instantiated only when the
  * `concurrentBinaryQueue` feature flag is on. It wraps a strict-ordering serial draft queue
  * plus a parallel binary queue over one shared store, stamps each draft's routing `lane`, and
- * drives the binary-queue lifecycle/read methods the native Pending Images UI consumes.
- *
- * The base `DraftManager` (gate-OFF) keeps every one of these methods as an inert stub so the
- * native bridge surface is identical regardless of the flag; this subclass supplies the real
- * behavior. Current (non-SCE) users never instantiate this class — they run the unchanged base.
+ * routes lifecycle, remove, and retry calls to the queue that owns each action. Current
+ * (non-SCE) users never instantiate this class — they run the unchanged base.
  */
 class RoutingDraftManager extends DraftManager {
     constructor(draftQueue, binaryQueue, laneLabels) {
@@ -51137,6 +51181,7 @@ class RoutingDraftManager extends DraftManager {
             __nimbus.plugins.JSLoggerPlugin !== undefined
             ? __nimbus.plugins.JSLoggerPlugin
             : undefined;
+        this.serialQueue = draftQueue;
         this.binaryQueue = binaryQueue;
         this.laneLabels = laneLabels;
         // Surface binary-queue change events through the same listener pipeline as the serial
@@ -51151,21 +51196,6 @@ class RoutingDraftManager extends DraftManager {
         }))
             .then(toQueueState(this.draftQueue));
     }
-    /**
-     * Get the current state of each of the DraftActions in the binary DraftQueue
-     * (ContentDocument/Version/Link uploads).
-     */
-    getBinaryQueue() {
-        const queue = this.binaryQueue;
-        const getActions = hasGetOwnedQueueActions(queue)
-            ? queue.getOwnedQueueActions()
-            : queue.getQueueActions();
-        return getActions
-            .then((queueActions) => {
-            return queueActions.map(this.buildDraftQueueItem);
-        })
-            .then(toQueueState(queue));
-    }
     /**
      * Starts both the serial and binary draft queues and begins processing their items.
      */
@@ -51180,40 +51210,58 @@ class RoutingDraftManager extends DraftManager {
         return Promise.all([this.draftQueue.stopQueue(), this.binaryQueue.stopQueue()]).then(() => undefined);
     }
     /**
-     * Starts the binary draft queue (for ContentDocument/Version/Link uploads). Separate from
-     * startQueue() so the binary queue can be paused/resumed independently from the regular
-     * draft queue and from stopQueueWhileRunning() interruptions.
+     * Pauses both queues while `action` runs. Nests each queue's own stopQueueWhileRunning so
+     * each restarts afterwards only if it was user-started before.
      */
-    startBinaryQueue() {
-        return this.binaryQueue.startQueue();
-    }
-    /** Stops the binary draft queue; pairs with startBinaryQueue(). */
-    stopBinaryQueue() {
-        return this.binaryQueue.stopQueue();
+    stopQueueWhileRunning(action) {
+        return this.draftQueue.stopQueueWhileRunning(() => this.binaryQueue.stopQueueWhileRunning(action));
     }
     async retryAllErrors() {
-        if (hasRetryAllErrors(this.draftQueue)) {
-            await this.draftQueue.retryAllErrors();
-        }
-        if (hasRetryAllErrors(this.binaryQueue)) {
-            await this.binaryQueue.retryAllErrors();
-        }
+        await this.serialQueue.retryAllErrors();
+        await this.binaryQueue.retryAllErrors();
     }
     /**
      * Routes the remove to the queue that owns the action. The serial queue reads the shared
      * store, so it sees binary-owned actions too, but has no handler registered for them and
      * would throw.
+     *
+     * A binary remove pauses the serial queue so a dependent can't start uploading between the
+     * uploading check and its removal. Only the serial queue: stopping the binary queue would
+     * clear every binary action's retry backoff. The serial queue's own removeDraftAction
+     * restarts it, so the pause covers the first dependent only.
      */
     removeDraftAction(actionId) {
         return this.binaryActionsById()
             .then((binaryById) => {
             const binaryAction = binaryById.get(actionId);
             return binaryAction !== undefined
-                ? this.removeBinaryActionAndDependents(binaryAction)
+                ? this.serialQueue.stopQueueWhileRunning(() => this.removeBinaryActionAndDependents(binaryAction))
                 : this.draftQueue.removeDraftAction(actionId);
         })
             .then(() => this.getQueue());
     }
+    /**
+     * Routes to the queue that owns the action, for the same reason as removeDraftAction.
+     * Native sets metadata on every image upload right after enqueueing it, so a serial-only
+     * setMetadata fails the upload call and native never links the image to its record.
+     */
+    async setMetadata(actionId, metadata) {
+        const binaryById = await this.binaryActionsById();
+        if (!binaryById.has(actionId)) {
+            return super.setMetadata(actionId, metadata);
+        }
+        const updated = await this.binaryQueue.setMetadata(actionId, metadata);
+        return this.buildDraftQueueItem(this.stampLane(updated, true));
+    }
+    /** Routes to the queue that owns the action, for the same reason as removeDraftAction. */
+    async retryAction(actionId) {
+        const binaryById = await this.binaryActionsById();
+        if (!binaryById.has(actionId)) {
+            return super.retryAction(actionId);
+        }
+        const retried = await this.binaryQueue.retryAction(actionId);
+        return this.buildDraftQueueItem(this.stampLane(retried, true));
+    }
     /**
      * Removes a binary action plus the serial actions that reference a draft id it creates
      * (e.g. the ContentDocumentLink native enqueues to link an uploaded image to a record).
@@ -51251,29 +51299,17 @@ class RoutingDraftManager extends DraftManager {
         }
     }
     serialActionsDependingOn(action) {
-        const binary = this.binaryQueue;
-        const serial = this.draftQueue;
-        if (!hasGetCreatedDraftIds(binary) || !hasGetOwnedActionsReferencing(serial)) {
-            return Promise.resolve([]);
-        }
-        const draftIds = binary.getCreatedDraftIds(action);
+        const draftIds = this.binaryQueue.getCreatedDraftIds(action);
         return draftIds.length === 0
             ? Promise.resolve([])
-            : serial.getOwnedActionsReferencing(draftIds);
+            : this.serialQueue.getOwnedActionsReferencing(draftIds);
     }
     /**
      * Binary-lane actions keyed by id, carrying the lane's transient `Uploading` status.
      * `getQueue` uses it to stamp the `concurrentBinary` lane and source the correct status.
-     * An empty map means "treat every action as serial" — returned both when the binary queue
-     * can't report ownership and (harmlessly) when it is simply empty; the caller doesn't need
-     * to tell those apart.
      */
     binaryActionsById() {
-        const binary = this.binaryQueue;
-        if (!hasGetOwnedQueueActions(binary)) {
-            return Promise.resolve(new Map());
-        }
-        return binary
+        return this.binaryQueue
             .getOwnedQueueActions()
             .then((actions) => new Map(actions.map((action) => [action.id, action])));
     }
@@ -83815,6 +83851,12 @@ function batchLog(line) {
         // debug-only
     }
 }
+// Ingestion timestamp that makes the uploaded record stale for the next read. Ingested at
+// epoch+1 the record is expired under any ttl: the record ttl, a record ttl override, the
+// default ttl override or a host metadata ttl. (Not 0, which falsy checks treat as missing.)
+// Expiring it with luvio.storeExpirePossibleStaleRecords or a 0 ttl does not work when a ttl
+// override is set, since the override replaces the ttl.
+const STALE_INGESTION_TIMESTAMP = 1;
 class UiApiActionHandler extends AbstractResourceRequestActionHandler {
     constructor(getLuvio, networkAdapter, draftQueue, getRecordAdapter, objectInfoService, isDraftId, recordService, sideEffectService, durableRecordStore) {
         super(draftQueue, networkAdapter, getLuvio, recordService);
@@ -83829,6 +83871,8 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
         this.durableRecordStore = durableRecordStore;
         this.handlerId = LDS_ACTION_HANDLER_ID;
         this.sideEffectHooks = [];
+        // side effect field values of the create actions being completed, by action id
+        this.injectedFieldsByActionId = new Map();
         recordService.registerRecordHandler(this);
     }
     setSideEffectHooks(hooks) {
@@ -83939,7 +83983,40 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
             await this.evictKey(completedAction.tag);
             return;
         }
-        return super.handleActionCompleted(completedAction, queueOperations);
+        if (method !== 'post') {
+            return super.handleActionCompleted(completedAction, queueOperations);
+        }
+        // super removes the action's side effects before it ingests the response, so what the
+        // create's side effects set has to be captured first
+        const injectedFields = this.getFieldsToInject(completedAction);
+        if (injectedFields !== undefined) {
+            this.injectedFieldsByActionId.set(completedAction.id, injectedFields);
+        }
+        try {
+            await super.handleActionCompleted(completedAction, queueOperations);
+        }
+        finally {
+            this.injectedFieldsByActionId.delete(completedAction.id);
+        }
+    }
+    // The create response only has the fields that were requested, so a field that only a side
+    // effect sets (e.g. ProductConsumed.IsProduct2Serialized) is missing from the cached
+    // server record once the draft's effects are gone. Returns the values of those fields.
+    // Only called for a POST: handleActionCompleted hands every other method straight to super.
+    getFieldsToInject(completedAction) {
+        if (sideEffectRefreshKillSwitch.isOpen({ fallback: false })) {
+            return undefined;
+        }
+        const fields = {};
+        this.recordService.getEffectsForAction(completedAction).forEach((effect) => {
+            if (effect.type === 'record-field-set' && effect.key === completedAction.tag) {
+                fields[effect.fieldName] = { value: effect.value, displayValue: null };
+            }
+        });
+        if (keys$3(fields).length === 0) {
+            return undefined;
+        }
+        return fields;
     }
     async fetchReferenceRecord(referenceFields) {
         const promises = referenceFields.map(async (referenceFieldInfo) => {
@@ -84602,10 +84679,35 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
         getTypeCacheKeys$1u$1(cacheKeys, this.getLuvio(), record);
         return cacheKeys;
     }
-    synchronousIngest(response) {
+    synchronousIngest(response, action) {
         const luvio = this.getLuvio();
+        const injected = this.injectedFieldsByActionId.get(action.id);
+        if (injected === undefined) {
+            const key = keyBuilderFromType$g(luvio, response);
+            luvio.storeIngest(key, ingest$1o$1, response);
+            return;
+        }
+        // never replace what the server sent
+        const fields = { ...response.fields };
+        let injectedAny = false;
+        keys$3(injected).forEach((fieldName) => {
+            if (fields[fieldName] === undefined) {
+                fields[fieldName] = injected[fieldName];
+                injectedAny = true;
+            }
+        });
         const key = keyBuilderFromType$g(luvio, response);
-        luvio.storeIngest(key, ingest$1o$1, response);
+        luvio.storeIngest(key, ingest$1o$1, { ...response, fields });
+        if (injectedAny) {
+            // after ingestRecord, which publishes the metadata with a fresh ttl
+            luvio.publishStoreMetadata(key, {
+                ttl: TTL$k,
+                representationName: 'RecordRepresentation',
+                namespace: 'UiApi',
+                version: VERSION$1v$1,
+                ingestionTimestamp: STALE_INGESTION_TIMESTAMP,
+            });
+        }
     }
     mergeRequestBody(targetBody, sourceBody) {
         // IMPORTANT: spread operator isn't deep clone so we have to individually
@@ -84675,6 +84777,10 @@ class UiApiDraftRecordService {
         await this.sideEffectStore.removeEffects(operations);
         return new Set(operations.map((o) => o.key));
     }
+    // returns the side effects queued for the given action, oldest first
+    getEffectsForAction(action) {
+        return this.sideEffectStore.getEffectsByTag(action.id);
+    }
     // reads a set of records out of the durable store, re-applies current side
     // effects and persists the changed record
     async reapplyRecordSideEffects(recordKeys, lifecycle) {
@@ -93611,21 +93717,10 @@ function makeNetworkAdapterChunkRecordFields(networkAdapter, instrumentationSink
  *
  * This instance is leveraged in the LMR webview which proxies DraftQueue requests
  * to a concrete implementation running in jscore.
- *
- * The Nimbus plugin name targeted by this proxy can be parameterized via the
- * constructor (defaults to 'LdsDraftQueue'); pass 'LdsPerformanceDraftQueue' to
- * target the primer's Performance Upload draft queue.
  */
 class NimbusDraftQueue {
-    constructor(pluginName = 'LdsDraftQueue') {
-        this.pluginName = pluginName;
-    }
-    get callProxyMethod() {
-        const plugin = __nimbus.plugins[this.pluginName];
-        return plugin && plugin.callProxyMethod;
-    }
     enqueue(handlerId, data, observabilityContext) {
-        const callProxyMethod = this.callProxyMethod;
+        const callProxyMethod = __nimbus.plugins.LdsDraftQueue.callProxyMethod;
         if (callProxyMethod === undefined) {
             return Promise.reject(new Error('callProxyMethod not defined on the nimbus plugin'));
         }
@@ -93652,7 +93747,7 @@ class NimbusDraftQueue {
         return Promise.reject(new Error('Cannot call processNextAction from the NimbusDraftQueue'));
     }
     getQueueActions() {
-        const callProxyMethod = this.callProxyMethod;
+        const callProxyMethod = __nimbus.plugins.LdsDraftQueue.callProxyMethod;
         if (callProxyMethod === undefined) {
             return Promise.reject(new Error('callProxyMethod not defined on the nimbus plugin'));
         }
@@ -93665,7 +93760,7 @@ class NimbusDraftQueue {
         });
     }
     getDataForAction(action) {
-        const callProxyMethod = this.callProxyMethod;
+        const callProxyMethod = __nimbus.plugins.LdsDraftQueue.callProxyMethod;
         if (callProxyMethod === undefined) {
             return Promise.reject('callProxyMethod not defined on the nimbus plugin');
         }
@@ -93871,7 +93966,7 @@ function buildLdsDraftQueue(durableStore, draftStore, options) {
     if (typeof __nimbus !== 'undefined' &&
         __nimbus.plugins !== undefined &&
         __nimbus.plugins.LdsDraftQueue !== undefined) {
-        return new NimbusDraftQueue('LdsDraftQueue');
+        return new NimbusDraftQueue();
     }
     // Legacy gate-OFF path: no shared store / options → today's plain queue.
     if (draftStore === undefined && options === undefined) {
@@ -93886,14 +93981,10 @@ function buildLdsDraftQueue(durableStore, draftStore, options) {
 }
 /**
  * Builds the Performance Upload draft queue (ContentDocument/Version/Link
- * multipart uploads, concurrency > 1). Only constructed on the gate-ON path.
+ * multipart uploads, concurrency > 1). Only constructed on the gate-ON path, in the
+ * worker realm.
  */
 function buildLdsPerformanceDraftQueue(durableStore, draftStore, options) {
-    if (typeof __nimbus !== 'undefined' &&
-        __nimbus.plugins !== undefined &&
-        __nimbus.plugins.LdsPerformanceDraftQueue !== undefined) {
-        return new NimbusDraftQueue('LdsPerformanceDraftQueue');
-    }
     const store = draftStore ?? new DurableDraftStore(durableStore);
     const draftQueue = new PerformanceDraftQueue(store, options);
     return instrumentDraftQueue(draftQueue);
@@ -98821,7 +98912,10 @@ let NetworkCommand$1 = class NetworkCommand extends BaseCommand {
       if (isSubscribableResult(newResult)) {
         const value = newResult.isOk() ? ok$1(newResult.value.data) : err$1(newResult.error.failure);
         this.subscriptions.forEach((cb) => {
-          cb(value);
+          try {
+            cb(value);
+          } catch {
+          }
         });
       }
       return ok$1(void 0);
@@ -99763,7 +99857,10 @@ class NetworkCommand extends BaseCommand {
       if (isSubscribableResult(newResult)) {
         const value = newResult.isOk() ? ok$1(newResult.value.data) : err$1(newResult.error.failure);
         this.subscriptions.forEach((cb) => {
-          cb(value);
+          try {
+            cb(value);
+          } catch {
+          }
         });
       }
       return ok$1(void 0);
@@ -99785,6 +99882,79 @@ function applyOperationRequestOptions$1(init, operationType, requestOptions) {
     }
   };
 }
+function fetchFromNetwork(getRequest, hooks, contextSeed) {
+  try {
+    const {
+      services,
+      params: [input, init],
+      operationType,
+      requestOptions
+    } = getRequest();
+    const initWithOptions = applyOperationRequestOptions$1(init, operationType, requestOptions);
+    const seed = operationType === void 0 ? contextSeed : { operationType, ...contextSeed };
+    const initWithSeed = seed === void 0 ? initWithOptions : { ...initWithOptions, __contextSeed: seed };
+    const fetchCall = initWithSeed === void 0 ? services.fetch(input) : services.fetch(input, initWithSeed);
+    return convertFetchResponseToData(fetchCall, hooks);
+  } catch (reason) {
+    return resolvedPromiseLike$2(err$1(toError(reason)));
+  }
+}
+function convertFetchResponseToData(response, hooks) {
+  return response.then(
+    (response2) => {
+      if (response2.ok) {
+        let resultPromise;
+        if (hooks.isSemanticNullResponse(response2)) {
+          resultPromise = Promise.resolve(ok$1(null));
+        } else if (hooks.isProtocolNoBodyStatus(response2.status) && !hooks.isSemanticNullResponse(response2)) {
+          resultPromise = Promise.resolve(
+            err$1(
+              toError(
+                `Unexpected ${response2.status} response: no-content status was not declared in the API specification. Declare this response in your OAS without a content property.`
+              )
+            )
+          );
+        } else {
+          resultPromise = response2.json().then(
+            (json) => ok$1(json),
+            (reason) => err$1(toError(reason))
+          );
+        }
+        return resultPromise.finally(() => {
+          try {
+            hooks.afterRequestHooks({ statusCode: response2.status });
+          } catch {
+          }
+        });
+      } else {
+        return hooks.coerceError(response2).then((coercedError) => {
+          return err$1(coercedError);
+        }).finally(() => {
+          try {
+            hooks.afterRequestHooks({ statusCode: response2.status });
+          } catch {
+          }
+        });
+      }
+    },
+    (reason) => err$1(toError(reason))
+  );
+}
+function completeRefresh(result, getSubscriptions, options = {}) {
+  const { previousResult } = options;
+  if (!options.suppressEqualSuccesses || result.isErr() || !previousResult || previousResult.isErr() || !deepEquals$1(previousResult.value, result.value)) {
+    const subscriptions = getSubscriptions();
+    const callbacks = options.skipRemovedSubscriptions ? [...subscriptions] : subscriptions;
+    callbacks.forEach((callback) => {
+      if (options.skipRemovedSubscriptions && !getSubscriptions().includes(callback)) return;
+      try {
+        callback(result);
+      } catch {
+      }
+    });
+  }
+  return options.reportFailure && result.isErr() ? result : ok$1(void 0);
+}
 function isAbortableCommand(command) {
   return !!command && typeof command === "object" && "isAbortableCommand" in command && command.isAbortableCommand === true;
 }
@@ -99813,18 +99983,18 @@ function createAbortableDecorator(command, options) {
         }
         if (prop === "fetchParams") {
           const originalFetchParams = Reflect.get(target, prop, receiver);
-          const isInternal = Reflect.get(target, "isInternalExecution", receiver) === true;
+          const suppressAbortSignal = Reflect.get(target, "isInternalExecution", receiver) === true;
           if (typeof originalFetchParams === "function") {
             return function(...args) {
               const originalReturnValue = originalFetchParams.apply(this, args);
-              if (!isInternal) {
+              if (!suppressAbortSignal) {
                 const [url, init = {}] = originalReturnValue;
                 return [url, { signal, ...init }];
               }
               return originalReturnValue;
             };
           } else {
-            if (!isInternal && originalFetchParams && Array.isArray(originalFetchParams)) {
+            if (!suppressAbortSignal && originalFetchParams && Array.isArray(originalFetchParams)) {
               const [url, init = {}] = originalFetchParams;
               return [url, { signal, ...init }];
             }
@@ -99851,38 +100021,35 @@ const _FetchNetworkCommand = class _FetchNetworkCommand extends NetworkCommand {
     this.services = services;
     this.additionalNullResponses = [];
   }
-  /**
-   * The command's operation type. Generated command subclasses override this
-   * getter with their concrete operation (see the generator's
-   * `generateOperationType`); the base returns `undefined` for commands that
-   * don't declare one (e.g. hand-written commands). Transport-layer
-   * interceptors use it to tell a read (`query`) apart from a write — see
-   * `fetch`, which folds it into the context seed and derives
-   * `onestore.retrySafe` from it.
-   */
   get operationType() {
     return void 0;
   }
-  /** Declared `onestore` options (`handleServerError`, `compression`); generated overrides (`generateRequestOptionsGetter`). */
   get requestOptions() {
     return void 0;
   }
   fetch(contextSeed) {
-    try {
-      const [input, init] = this.fetchParams;
-      const operationType = this.operationType;
-      const initWithOptions = applyOperationRequestOptions$1(
-        init,
-        operationType,
-        this.requestOptions
-      );
-      const seed = operationType === void 0 ? contextSeed : { operationType, ...contextSeed };
-      const initWithSeed = seed === void 0 ? initWithOptions : { ...initWithOptions, __contextSeed: seed };
-      const fetchCall = initWithSeed === void 0 ? this.services.fetch(input) : this.services.fetch(input, initWithSeed);
-      return this.convertFetchResponseToData(fetchCall);
-    } catch (reason) {
-      return resolvedPromiseLike$2(err$1(toError(reason)));
-    }
+    return fetchFromNetwork(
+      () => ({
+        services: this.services,
+        params: this.fetchParams,
+        operationType: this.operationType,
+        requestOptions: this.requestOptions
+      }),
+      {
+        isSemanticNullResponse: (response) => this.isSemanticNullResponse(response),
+        isProtocolNoBodyStatus: (status) => this.isProtocolNoBodyStatus(status),
+        coerceError: (response) => this.coerceError(response),
+        afterRequestHooks: (options) => this.afterRequestHooks(options)
+      },
+      contextSeed
+    );
+  }
+  refresh() {
+    return this.execute().then((newResult) => {
+      if (!isSubscribableResult(newResult)) return ok$1(void 0);
+      const result = newResult.isOk() ? ok$1(newResult.value.data) : err$1(newResult.error.failure);
+      return completeRefresh(result, () => this.subscriptions);
+    });
   }
   isSemanticNullResponse(response) {
     return this.additionalNullResponses.includes(response.status);
@@ -99890,53 +100057,9 @@ const _FetchNetworkCommand = class _FetchNetworkCommand extends NetworkCommand {
   isProtocolNoBodyStatus(status) {
     return status === 204 || status === 205;
   }
-  isUndeclaredNoBodyResponse(response) {
-    return this.isProtocolNoBodyStatus(response.status) && !this.isSemanticNullResponse(response);
-  }
   async coerceError(errorResponse) {
     return toError(errorResponse.statusText);
   }
-  convertFetchResponseToData(response) {
-    return response.then(
-      (response2) => {
-        if (response2.ok) {
-          let resultPromise;
-          if (this.isSemanticNullResponse(response2)) {
-            resultPromise = Promise.resolve(ok$1(null));
-          } else if (this.isUndeclaredNoBodyResponse(response2)) {
-            resultPromise = Promise.resolve(
-              err$1(
-                toError(
-                  `Unexpected ${response2.status} response: no-content status was not declared in the API specification. Declare this response in your OAS without a content property.`
-                )
-              )
-            );
-          } else {
-            resultPromise = response2.json().then(
-              (json) => ok$1(json),
-              (reason) => err$1(toError(reason))
-            );
-          }
-          return resultPromise.finally(() => {
-            try {
-              this.afterRequestHooks({ statusCode: response2.status });
-            } catch {
-            }
-          });
-        } else {
-          return this.coerceError(response2).then((coercedError) => {
-            return err$1(coercedError);
-          }).finally(() => {
-            try {
-              this.afterRequestHooks({ statusCode: response2.status });
-            } catch {
-            }
-          });
-        }
-      },
-      (reason) => err$1(toError(reason))
-    );
-  }
 };
 _FetchNetworkCommand.availableDecorators = {
   abortable: createAbortableDecorator
@@ -101000,7 +101123,7 @@ function buildServiceDescriptor$b(luvio) {
         },
     };
 }
-// version: 1.467.0-4f065d2a2a
+// version: 1.468.0-9ef0fbdaee
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -101026,7 +101149,7 @@ function buildServiceDescriptor$a(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.467.0-4f065d2a2a
+// version: 1.468.0-9ef0fbdaee
 
 function findExecutableOperation$1(input) {
   const operations = input.query.definitions.filter(
@@ -101889,6 +102012,53 @@ function buildBaseImperativeInvoker(getCommand, transformResult) {
     }
   };
 }
+function assertSubscribable(result, report) {
+  if (!isSubscribableResult(result)) {
+    report("Non-subscribable result encountered - please use correct operation type");
+    throw new Error("Internal error in Lightning Data Service adapter occurred");
+  }
+}
+function toQueryUpdate(result) {
+  return result.isOk() ? { data: result.value, error: void 0 } : { data: void 0, error: unwrapUserlandError(result.error) };
+}
+class SubscribableImperativeBindingsService {
+  bind(getCommand, exposeRefresh = false) {
+    return buildBaseImperativeInvoker(
+      getCommand,
+      (result) => this.transformResult(result, exposeRefresh)
+    );
+  }
+  transformResult(result, exposeRefresh = false) {
+    assertSubscribable(result, (message) => console.error(message));
+    if (result.isErr()) throwUnwrappedUserlandError(result.error.failure);
+    deepFreeze(result.value.data);
+    const api = {
+      data: result.value.data,
+      subscribe: (callback) => result.value.subscribe((update) => {
+        const { data, error } = toQueryUpdate(update);
+        return callback({ data, error });
+      })
+    };
+    if (exposeRefresh) {
+      return {
+        ...api,
+        refresh: () => result.value.refresh().then((refreshed) => {
+          if (refreshed.isOk()) return void 0;
+          throw refreshed.error;
+        })
+      };
+    }
+    return api;
+  }
+}
+function buildServiceDescriptor$7() {
+  return {
+    type: "subscribableImperativeBindings",
+    version: "1.0",
+    service: new SubscribableImperativeBindingsService()
+  };
+}
+
 const supportedCachePolicyTypes = ["no-cache", "only-if-cached"];
 function requestContextIsSupportedCachePolicy(requestContext) {
   return typeof requestContext === "object" && requestContext !== null && "cachePolicy" in requestContext && typeof requestContext.cachePolicy === "object" && requestContext.cachePolicy !== null && "type" in requestContext.cachePolicy && typeof requestContext.cachePolicy.type === "string" && supportedCachePolicyTypes.includes(
@@ -101941,7 +102111,7 @@ class DefaultImperativeBindingsService {
     });
   }
 }
-function buildServiceDescriptor$6() {
+function buildServiceDescriptor$5() {
   return {
     type: "defaultImperativeBindings",
     version: "1.0",
@@ -101961,70 +102131,13 @@ class QueryImperativeBindingsService {
     });
   }
 }
-function buildServiceDescriptor$5() {
+function buildServiceDescriptor$4() {
   return {
     type: "queryImperativeBindings",
     version: "1.0",
     service: new QueryImperativeBindingsService()
   };
 }
-class SubscribableImperativeBindingsService {
-  bind(getCommand, exposeRefresh = false) {
-    return buildBaseImperativeInvoker(
-      getCommand,
-      (result) => this.transformResult(result, exposeRefresh)
-    );
-  }
-  transformResult(result, exposeRefresh = false) {
-    if (!isSubscribableResult(result)) {
-      console.error(
-        "Non-subscribable result encountered - please use correct operation type"
-      );
-      throw new Error("Internal error in Lightning Data Service adapter occurred");
-    }
-    if (result.isOk()) {
-      deepFreeze(result.value.data);
-      const api = {
-        data: result.value.data,
-        subscribe: (cb) => {
-          return result.value.subscribe((result2) => {
-            if (result2.isErr()) {
-              return cb({
-                data: void 0,
-                error: unwrapUserlandError(result2.error)
-              });
-            }
-            return cb({ data: result2.value, error: void 0 });
-          });
-        }
-      };
-      if (exposeRefresh) {
-        return {
-          ...api,
-          refresh: () => {
-            return result.value.refresh().then((res) => {
-              if (res.isOk()) {
-                return void 0;
-              }
-              throw res.error;
-            });
-          }
-        };
-      } else {
-        return api;
-      }
-    } else {
-      throwUnwrappedUserlandError(result.error.failure);
-    }
-  }
-}
-function buildServiceDescriptor$4() {
-  return {
-    type: "subscribableImperativeBindings",
-    version: "1.0",
-    service: new SubscribableImperativeBindingsService()
-  };
-}
 class LegacyImperativeBindingsService {
   bind(getCommand) {
     const invoke = async (config, requestContext, callback) => {
@@ -102326,7 +102439,7 @@ class GraphQLMutationBindingsService {
     };
   }
 }
-function buildServiceDescriptor$7() {
+function buildServiceDescriptor$6() {
   return {
     type: "graphQLMutationBindings",
     version: "1.0",
@@ -103474,13 +103587,13 @@ function initializeOneStore(sqliteStore, luvio) {
         featureFlagsServiceDescriptor,
         buildServiceDescriptor$b(luvio),
         luvioUiapiRecordsServiceDescriptor,
-        buildServiceDescriptor$6(),
         buildServiceDescriptor$5(),
         buildServiceDescriptor$4(),
+        buildServiceDescriptor$7(),
         buildServiceDescriptor$3(),
         buildServiceDescriptor$2$1(),
         buildServiceDescriptor$1$2(),
-        buildServiceDescriptor$7(),
+        buildServiceDescriptor$6(),
         buildServiceDescriptor$1$1(),
         buildServiceDescriptor$2(),
         // TODO [W-18753648]: See note above.
@@ -103645,12 +103758,19 @@ function getRuntime({ primeUser = false } = {}) {
             logInfo(`Serial draft queue created with batching=${useQueueBatching}, strictOrdering=true`);
             lazyDraftQueue = buildLdsDraftQueue(lazyDurableStore, sharedDraftStore, {
                 // No peer queues when there's no binary lane (batching-only).
-                getPeerQueues: () => (useConcurrentBinaryQueue ? [lazyBinaryDraftQueue] : []),
+                getPeerQueues: () => lazyBinaryDraftQueue !== undefined ? [lazyBinaryDraftQueue] : [],
                 concurrency: 1,
                 strictOrdering: true,
                 queueBatching: useQueueBatching,
             });
-            if (useConcurrentBinaryQueue) {
+            // The binary lane lives only in the worker realm. In the WebView realm the serial
+            // queue is a Nimbus proxy to the worker's routing façade, which already routes
+            // binary uploads to the worker's binary lane; a local binary queue there would
+            // take uploads the worker never sees. Only worker-realm queues expose
+            // isHandlerRegistered.
+            if (useConcurrentBinaryQueue &&
+                typeof lazyDraftQueue.isHandlerRegistered ===
+                    'function') {
                 lazyBinaryDraftQueue = buildLdsPerformanceDraftQueue(lazyDurableStore, sharedDraftStore, {
                     getPeerQueues: () => [lazyDraftQueue],
                     concurrency: 4,
@@ -103671,27 +103791,19 @@ function getRuntime({ primeUser = false } = {}) {
         const updateRecordQuickActionHandler = new UpdateRecordQuickActionExecutionRepresentationHandler(() => lazyLuvio, draftService, lazyDraftQueue, lazyNetworkAdapter, isGenerated, lazySideEffectService);
         // Route the CD composite to the concurrent binary queue when gate-ON so
         // multipart uploads run in parallel and don't block other DML.
-        const contentDocumentTargetQueue = useConcurrentBinaryQueue
-            ? lazyBinaryDraftQueue
-            : lazyDraftQueue;
-        logInfo(`ContentDocumentVersion handler routed to ${useConcurrentBinaryQueue ? 'concurrent draft queue' : 'serial draft queue'}`);
+        const contentDocumentTargetQueue = lazyBinaryDraftQueue ?? lazyDraftQueue;
+        logInfo(`ContentDocumentVersion handler routed to ${lazyBinaryDraftQueue !== undefined ? 'concurrent draft queue' : 'serial draft queue'}`);
         const contentDocumentCompositeActionHandler = new ContentDocumentCompositeRepresentationActionHandler(() => lazyLuvio, userId, draftService, lazyObjectInfoService, contentDocumentTargetQueue, lazyNetworkAdapter, isGenerated, NimbusBinaryStore, lazySideEffectService);
         lazyDraftQueue.addHandler(uiApiRecordHandler);
         lazyDraftQueue.addHandler(quickActionHandler);
         lazyDraftQueue.addHandler(updateRecordQuickActionHandler);
         contentDocumentTargetQueue.addHandler(contentDocumentCompositeActionHandler);
-        // Build the routing façade only with the flag on AND over concrete, handler-owning
-        // queues. Only the worker-realm queues expose isHandlerRegistered; the WebView realm's
-        // Nimbus proxies lack it. Feature-detect that method rather than sniffing the realm via
-        // `window`: it tests the exact invariant the DurableDraftQueue casts below rely on, and
-        // stays correct in non-browser (e.g. jest) realms where `window` is an unreliable realm
-        // signal. The flag must stay the first term — it short-circuits the queue accesses, and
-        // the gate-OFF path never builds lazyBinaryDraftQueue (it is undefined there).
-        const shouldBuildRoutingQueue = useConcurrentBinaryQueue &&
-            typeof lazyDraftQueue.isHandlerRegistered ===
-                'function' &&
-            typeof lazyBinaryDraftQueue
-                .isHandlerRegistered === 'function';
+        // Build the routing façade and manager only when the binary lane exists: flag on and
+        // in the worker realm, over concrete, handler-owning queues (see where it is built).
+        // Feature-detecting isHandlerRegistered rather than sniffing the realm via `window` tests
+        // the exact invariant the queue casts below rely on, and stays correct in non-browser
+        // (e.g. jest) realms where `window` is an unreliable realm signal.
+        const shouldBuildRoutingQueue = lazyBinaryDraftQueue !== undefined;
         if (shouldBuildRoutingQueue) {
             // Serial is the primary/fallback lane, so the bridged `draftQueue` routes enqueue
             // by handler ownership in the worker. Lane labels are stamped onto each action
@@ -103706,7 +103818,9 @@ function getRuntime({ primeUser = false } = {}) {
                 },
             ]);
         }
-        lazyDraftManager = useConcurrentBinaryQueue
+        // The WebView realm's (unused) manager falls back to the base DraftManager: native only
+        // drives the worker-realm manager, and RoutingDraftManager needs the concrete queues.
+        lazyDraftManager = shouldBuildRoutingQueue
             ? new RoutingDraftManager(lazyDraftQueue, lazyBinaryDraftQueue, DRAFT_QUEUE_LANE)
             : new DraftManager(lazyDraftQueue);
         const objectInfoCachingEnvironment = enableObjectInfoCaching(durableEnv, lazyObjectInfoService.ensureObjectInfoCached);
@@ -103784,8 +103898,6 @@ function getRuntime({ primeUser = false } = {}) {
         environment: lazyEnvironment,
         draftManager: lazyDraftManager,
         draftQueue: lazyRoutingDraftQueue ?? lazyDraftQueue,
-        serialDraftQueue: lazyDraftQueue,
-        binaryDraftQueue: lazyBinaryDraftQueue,
         createPrimingSession: (config) => {
             return primingSessionFactory({
                 store: lazyDurableStore,
@@ -103811,7 +103923,7 @@ register$1({
     id: '@salesforce/lds-network-adapter',
     instrument: instrument$2,
 });
-// version: 1.467.0-4f065d2a2a
+// version: 1.468.0-9ef0fbdaee
 
 const { create: create$2, keys: keys$2 } = Object;
 const { stringify, parse } = JSON;
@@ -111361,7 +111473,7 @@ function registerCallback(cb) {
         cb(graphql_v1_import, graphql_imperative$1, graphql_imperative_legacy_v1_import, graphql_state_manager);
     }
 }
-// version: 1.467.0-049a8b6027
+// version: 1.468.0-c060a9b9c6
 
 function createFragmentMap(documentNode) {
     const fragments = {};
@@ -140590,7 +140702,7 @@ register$1({
     configuration: { ...configurationForGraphQLAdapters$1 },
     instrument: instrument$1,
 });
-// version: 1.467.0-049a8b6027
+// version: 1.468.0-c060a9b9c6
 
 // On core the unstable adapters are re-exported with different names,
 // we want to match them here.
@@ -140742,7 +140854,7 @@ withDefaultLuvio((luvio) => {
     unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
     graphQLImperative = ldsAdapter;
 });
-// version: 1.467.0-049a8b6027
+// version: 1.468.0-c060a9b9c6
 
 var gqlApi = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -141594,7 +141706,7 @@ const callbacks$1 = [];
 function register(r) {
     callbacks$1.forEach((callback) => callback(r));
 }
-// version: 1.467.0-4f065d2a2a
+// version: 1.468.0-9ef0fbdaee
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -142883,4 +142995,4 @@ const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
 export { createPrimingSession, draftManager, draftQueue, evictCacheRecordsByIds, evictExpiredCacheEntries, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, importLuvioAdapterModule, importOneStoreAdapterModule, invokeAdapter, invokeAdapterWithDraftToMerge, invokeAdapterWithDraftToMergeAndMetadata, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, stopEviction, subscribeToAdapter };
-// version: 1.467.0-4f065d2a2a
+// version: 1.468.0-9ef0fbdaee