@salesforce/lds-worker-api 1.467.0 → 1.468.0

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

@@ -4282,7 +4282,7 @@
         }
         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) {
@@ -5326,7 +5326,7 @@
         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;
@@ -32571,7 +32571,7 @@
         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) {
@@ -32652,6 +32652,15 @@
         },
     };
 
+    var sideEffectRefreshKillSwitch = {
+        isOpen: function (e) {
+            return e.fallback;
+        },
+        hasError: function () {
+            return !0;
+        },
+    };
+
     var caseSensitiveUserId = '005B0000000GR4OIAW';
 
     /**
@@ -48707,6 +48716,48 @@
                 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
@@ -48716,32 +48767,18 @@
                 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) {
@@ -48780,15 +48817,12 @@
             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 || {};
@@ -48807,6 +48841,18 @@
             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) => {
@@ -50409,27 +50455,17 @@
                 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) {
@@ -50568,6 +50604,27 @@
             }
             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);
@@ -50672,6 +50729,8 @@
         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);
@@ -51113,27 +51172,12 @@
         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) {
@@ -51143,6 +51187,7 @@
                 __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
@@ -51157,21 +51202,6 @@
             }))
                 .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.
          */
@@ -51186,40 +51216,58 @@
             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).
@@ -51257,29 +51305,17 @@
             }
         }
         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])));
         }
@@ -83821,6 +83857,12 @@
             // 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);
@@ -83835,6 +83877,8 @@
             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) {
@@ -83945,7 +83989,40 @@
                 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) => {
@@ -84608,10 +84685,35 @@
             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
@@ -84681,6 +84783,10 @@
             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) {
@@ -93617,21 +93723,10 @@
      *
      * 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'));
             }
@@ -93658,7 +93753,7 @@
             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'));
             }
@@ -93671,7 +93766,7 @@
             });
         }
         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');
             }
@@ -93877,7 +93972,7 @@
         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) {
@@ -93892,14 +93987,10 @@
     }
     /**
      * 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);
@@ -98827,7 +98918,10 @@
           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);
@@ -99769,7 +99863,10 @@
           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);
@@ -99791,6 +99888,79 @@
         }
       };
     }
+    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;
     }
@@ -99819,18 +99989,18 @@
             }
             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 }];
                 }
@@ -99857,38 +100027,35 @@
         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);
@@ -99896,53 +100063,9 @@
       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
@@ -101006,7 +101129,7 @@
             },
         };
     }
-    // version: 1.467.0-4f065d2a2a
+    // version: 1.468.0-9ef0fbdaee
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -101032,7 +101155,7 @@
             },
         };
     }
-    // version: 1.467.0-4f065d2a2a
+    // version: 1.468.0-9ef0fbdaee
 
     function findExecutableOperation$1(input) {
       const operations = input.query.definitions.filter(
@@ -101895,6 +102018,53 @@
         }
       };
     }
+    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(
@@ -101947,7 +102117,7 @@
         });
       }
     }
-    function buildServiceDescriptor$6() {
+    function buildServiceDescriptor$5() {
       return {
         type: "defaultImperativeBindings",
         version: "1.0",
@@ -101967,70 +102137,13 @@
         });
       }
     }
-    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) => {
@@ -102332,7 +102445,7 @@
         };
       }
     }
-    function buildServiceDescriptor$7() {
+    function buildServiceDescriptor$6() {
       return {
         type: "graphQLMutationBindings",
         version: "1.0",
@@ -103480,13 +103593,13 @@
             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.
@@ -103651,12 +103764,19 @@
                 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,
@@ -103677,27 +103797,19 @@
             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
@@ -103712,7 +103824,9 @@
                     },
                 ]);
             }
-            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);
@@ -103790,8 +103904,6 @@
             environment: lazyEnvironment,
             draftManager: lazyDraftManager,
             draftQueue: lazyRoutingDraftQueue ?? lazyDraftQueue,
-            serialDraftQueue: lazyDraftQueue,
-            binaryDraftQueue: lazyBinaryDraftQueue,
             createPrimingSession: (config) => {
                 return primingSessionFactory({
                     store: lazyDurableStore,
@@ -103817,7 +103929,7 @@
         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;
@@ -111367,7 +111479,7 @@
             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 = {};
@@ -140596,7 +140708,7 @@
         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.
@@ -140748,7 +140860,7 @@
         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,
@@ -141600,7 +141712,7 @@
     function register(r) {
         callbacks$1.forEach((callback) => callback(r));
     }
-    // version: 1.467.0-4f065d2a2a
+    // version: 1.468.0-9ef0fbdaee
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -142911,4 +143023,4 @@
     exports.subscribeToAdapter = subscribeToAdapter;
 
 }));
-// version: 1.467.0-4f065d2a2a
+// version: 1.468.0-9ef0fbdaee