@salesforce/lds-worker-api 1.461.0 → 1.463.0

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

@@ -4276,7 +4276,7 @@ function withDefaultLuvio(callback) {
     }
     callbacks.push(callback);
 }
-// version: 1.461.0-37b1c9d1cb
+// version: 1.463.0-ea9ecd17fc
 
 // 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.461.0-37b1c9d1cb
+// version: 1.463.0-ea9ecd17fc
 
 function isSupportedEntity(_objectApiName) {
     return true;
@@ -32547,7 +32547,7 @@ withDefaultLuvio((luvio) => {
     throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
     throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
 });
-// version: 1.461.0-55ae54e753
+// version: 1.463.0-8515018faf
 
 var draftQueueMaxRetryAttemptsGate = {
     isOpen: function (e) {
@@ -44179,24 +44179,6 @@ function formattingOptions(pattern) {
     return pattern;
 }
 
-var ldsPrimingGraphqlBatch = {
-    isOpen: function (e) {
-        return e.fallback;
-    },
-    hasError: function () {
-        return !0;
-    },
-};
-
-var lmrPrimingUseSoql = {
-    isOpen: function (e) {
-        return e.fallback;
-    },
-    hasError: function () {
-        return !0;
-    },
-};
-
 var aggressiveTrimCountKillSwitchGate = {
     isOpen: function (e) {
         return e.fallback;
@@ -44215,15 +44197,6 @@ var graphqlL2AdapterGate = {
     },
 };
 
-var useOneStore = {
-    isOpen: function (e) {
-        return e.fallback;
-    },
-    hasError: function () {
-        return !0;
-    },
-};
-
 const { create: create$7, freeze: freeze$4, keys: keys$8, entries: entries$5 } = Object;
 const { hasOwnProperty: hasOwnProperty$3 } = Object.prototype;
 const { isArray: isArray$7 } = Array;
@@ -44768,9 +44741,18 @@ function validateDiscriminatedOneOf$1(data, discriminator, path, document, visit
   if (data === null || typeof data !== "object" || Array.isArray(data)) {
     return invalidSchemaResponseWithError$1(incorrectTypeError$1("object", typeof data, path));
   }
-  const { propertyName, mapping } = discriminator;
+  const { propertyName, mapping, defaultMapping } = discriminator;
   const discriminatorValue = data[propertyName];
   if (discriminatorValue === void 0) {
+    if (defaultMapping !== void 0) {
+      return validateJsonSchemaInternal$1(
+        data,
+        { $ref: defaultMapping },
+        path,
+        document,
+        visited
+      );
+    }
     return invalidSchemaResponseWithError$1(
       new MissingRequiredPropertyError$1(
         `Object at path '${path}' is missing required discriminator property '${propertyName}'.`
@@ -44782,7 +44764,7 @@ function validateDiscriminatedOneOf$1(data, discriminator, path, document, visit
       incorrectTypeError$1("string", typeof discriminatorValue, `${path}.${propertyName}`)
     );
   }
-  const targetRef = mapping[discriminatorValue];
+  const targetRef = mapping[discriminatorValue] ?? defaultMapping;
   if (targetRef === void 0) {
     return invalidSchemaResponseWithError$1(
       new JsonSchemaViolationError$1(
@@ -45943,7 +45925,7 @@ var productConsumedSideEffects = {
     },
 };
 
-var reviveOnlyRequestedFields = {
+var isProduct2SerializedSideEffectKillSwitch = {
     isOpen: function (e) {
         return e.fallback;
     },
@@ -81464,6 +81446,35 @@ async function getAdapterData(adapter, config) {
     return snapshot.data;
 }
 
+/**
+ * A read-through cache over `DurableRecordStore.getRecord` scoped to a single draft-action
+ * dispatch. Multiple side-effect hooks fire for one action (e.g. the van-stock and
+ * IsProduct2Serialized ProductConsumed hooks) and are awaited one at a time, so they otherwise
+ * each re-read the same draft record — and the IsProduct2Serialized chain re-reads the same
+ * related ProductItem / Product2 — from the durable store. Sharing one reader across the
+ * action's hooks collapses those repeated reads to a single durable call per key.
+ *
+ * The cache stores the in-flight promise (not the resolved value) so concurrent reads of the
+ * same key share one durable call, and it caches `undefined` results so a miss is not re-fetched.
+ * A reader must not outlive one action dispatch: durable state changes between actions, so a
+ * longer-lived cache would return stale records.
+ */
+class MemoizingRecordReader {
+    constructor(durableRecordStore) {
+        this.durableRecordStore = durableRecordStore;
+        this.cache = new Map();
+    }
+    getRecord(key) {
+        const cached = this.cache.get(key);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const promise = this.durableRecordStore.getRecord(key);
+        this.cache.set(key, promise);
+        return promise;
+    }
+}
+
 const LDS_ACTION_HANDLER_ID = 'LDS_ACTION_HANDLER';
 const LDS_ACTION_METADATA_API_NAME = 'LDS_ACTION_METADATA_API_NAME';
 class UiApiActionHandler extends AbstractResourceRequestActionHandler {
@@ -81584,9 +81595,9 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
         return super.getRedirectMappings(action);
     }
     async handleActionCompleted(completedAction, queueOperations) {
-        if (completedAction.response.status === 204 && completedAction.data.method === 'post') {
-            // if we get a 204 it means the record creation was successful but we don't have the record to ingest
-            // remove the synthesized draft and do not try to ingest the response
+        const { method } = completedAction.data;
+        if (completedAction.response.status === 204 && (method === 'post' || method === 'patch')) {
+            await this.recordService.removeSideEffectsForAction(completedAction);
             await this.evictKey(completedAction.tag);
             return;
         }
@@ -81667,8 +81678,15 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
                 break;
             }
         }
+        // One reader shared across every hook for this action so repeated reads of the same
+        // record (the draft record, and any related records the hooks resolve) collapse to a
+        // single durable call. Scoped to this dispatch only — durable state changes between
+        // actions, so it must not be reused across them. Built only when hooks will run.
+        const recordReader = hookTriggers.length > 0
+            ? new MemoizingRecordReader(this.durableRecordStore)
+            : undefined;
         for (const trigger of hookTriggers) {
-            const hookEffects = await trigger.then(action.id, action.timestamp, action.targetId, action.data.body?.fields ?? {});
+            const hookEffects = await trigger.then(action.id, action.timestamp, action.targetId, action.data.body?.fields ?? {}, recordReader);
             for (const hookEffect of hookEffects) {
                 effects.push(hookEffect);
             }
@@ -92740,211 +92758,6 @@ class NetworkRecordLoader {
     }
 }
 
-const apiPath$1 = basePath + '/graphql';
-const requiredPrefix = `required_`;
-const requiredFieldMap = {
-    ApiName: 'ApiName',
-    Id: 'Id',
-    LastModifiedById: 'LastModifiedById { value }',
-    LastModifiedDate: 'LastModifiedDate { value }',
-    RecordTypeId: 'RecordTypeId(fallback: true) { value }',
-    SystemModstamp: 'SystemModstamp { value }',
-    WeakEtag: 'WeakEtag',
-};
-class RecordLoaderGraphQL extends NetworkRecordLoader {
-    makeRequest(batch, observabilityContext) {
-        const query = this.generateGraphQLQuery(batch.type, batch.fields);
-        return {
-            request: {
-                method: 'POST',
-                path: apiPath$1,
-                body: JSON.stringify({
-                    query,
-                    variables: {
-                        ids: batch.ids,
-                        first: batch.ids.length,
-                    },
-                }),
-                headers: {},
-                queryParams: {},
-                priority: 'background',
-                observabilityContext: observabilityContext !== undefined ? observabilityContext : {},
-            },
-            context: undefined,
-        };
-    }
-    generateFetchResults(repResult, batchInput, _context) {
-        const { data, errors } = repResult;
-        if (errors !== undefined && errors.length > 0) {
-            // right now if there are any errors in the batch we throw out the entire batch
-            // for now this is ok all errors will originate on the same node so there shouldn't be a mix of errors and data
-            return [
-                {
-                    missingIds: batchInput.ids,
-                    ok: false,
-                    error: 'request-error',
-                    messages: errors.map((x) => x.message),
-                },
-            ];
-        }
-        // this shouldn't really happen if there's no errors
-        if (!data || !data.uiapi) {
-            return [
-                {
-                    ok: false,
-                    error: 'unknown',
-                    messages: ['unexpected response retrieved from graphql endpoint'],
-                    missingIds: batchInput.ids,
-                },
-            ];
-        }
-        const objectInfo = batchInput.objectInfo;
-        const seenRecords = new Set(batchInput.ids);
-        const records = data.uiapi.query[batchInput.type].edges.map((edge) => {
-            const record = this.generateDurableRecordRepresentation(edge.node, objectInfo);
-            seenRecords.delete(record.id);
-            return record;
-        });
-        return [
-            {
-                ok: true,
-                records,
-                missingIds: Array.from(seenRecords),
-            },
-        ];
-    }
-    generateGraphQLQuery(type, fields) {
-        const fieldList = Object.keys(requiredFieldMap)
-            .map((field) => {
-            return `${requiredPrefix}${field}: ${requiredFieldMap[field]}`;
-        })
-            .join('\n');
-        return /* GraphQL */ `
-        fragment requiredRecordFields on Record {
-            ${fieldList}
-        }
-        query prime${type}($ids: [ID], $first: Int){
-            uiapi {
-                query {
-                    ${type} (where: {Id: {in: $ids}} first: $first) {
-                        edges {
-                            node {
-                            ...requiredRecordFields
-                            ${fields
-            .filter((x) => x !== 'Id' && x !== 'RecordTypeId')
-            .map((field) => `${field} { value displayValue }`)}
-                            }
-                        }
-                    }
-                }
-            }
-        }
-      `;
-    }
-    generateDurableRecordRepresentation(node, objectInfo) {
-        const standardRecordFields = new Set(Object.keys(requiredFieldMap).map((x) => `${requiredPrefix}${x}`));
-        const id = node[`${requiredPrefix}Id`];
-        const recordTypeId = node[`${requiredPrefix}RecordTypeId`].value;
-        const requestedFields = Object.keys(node).filter((field) => !standardRecordFields.has(field));
-        const fields = requestedFields.reduce((acc, field) => {
-            const fieldNode = node[field];
-            if (fieldNode.displayValue === undefined) {
-                fieldNode.displayValue = null;
-            }
-            acc[field] = node[field];
-            return acc;
-        }, {});
-        fields['Id'] = { value: id, displayValue: null };
-        if (objectInfo.fields['RecordTypeId'] !== undefined) {
-            fields['RecordTypeId'] = { value: recordTypeId, displayValue: null };
-        }
-        let recordTypeInfo = null;
-        if (recordTypeId !== null &&
-            objectInfo.recordTypeInfos &&
-            objectInfo.recordTypeInfos[recordTypeId]) {
-            const appliedRecordTypeInfo = objectInfo.recordTypeInfos[recordTypeId];
-            // ui-api only applies the record type if its not the default type, otherwise it sets it to null
-            if (appliedRecordTypeInfo.defaultRecordTypeMapping === false) {
-                recordTypeInfo = appliedRecordTypeInfo;
-            }
-        }
-        return {
-            apiName: node[`${requiredPrefix}ApiName`],
-            childRelationships: {},
-            eTag: '',
-            id,
-            lastModifiedById: node[`${requiredPrefix}LastModifiedById`] &&
-                node[`${requiredPrefix}LastModifiedById`].value
-                ? node[`${requiredPrefix}LastModifiedById`].value
-                : null,
-            lastModifiedDate: node[`${requiredPrefix}LastModifiedDate`] &&
-                node[`${requiredPrefix}LastModifiedDate`].value
-                ? node[`${requiredPrefix}LastModifiedDate`].value
-                : null,
-            recordTypeId,
-            recordTypeInfo: recordTypeInfo,
-            systemModstamp: node[`${requiredPrefix}SystemModstamp`] &&
-                node[`${requiredPrefix}SystemModstamp`].value
-                ? node[`${requiredPrefix}SystemModstamp`].value
-                : null,
-            weakEtag: node[`${requiredPrefix}WeakEtag`],
-            fields,
-            links: {},
-        };
-    }
-}
-
-const DEFAULT_GQL_QUERY_BATCH_SIZE = 100;
-const apiPath = basePath + '/graphql/batch';
-class RecordLoaderGraphQLBatch extends RecordLoaderGraphQL {
-    makeRequest(batch, observabilityContext) {
-        const query = this.generateGraphQLQuery(batch.type, batch.fields);
-        const chunks = chunk(batch.ids, DEFAULT_GQL_QUERY_BATCH_SIZE);
-        const batches = chunks.map((chunk) => {
-            return {
-                query,
-                variables: {
-                    ids: chunk,
-                    first: chunk.length,
-                },
-            };
-        });
-        return {
-            request: {
-                method: 'POST',
-                path: apiPath,
-                body: JSON.stringify({
-                    batchQuery: batches,
-                }),
-                headers: {},
-                queryParams: {},
-                priority: 'background',
-                observabilityContext: observabilityContext !== undefined ? observabilityContext : {},
-            },
-            context: chunks,
-        };
-    }
-    generateFetchResults(body, batchInput, context) {
-        const { results } = body;
-        const fetchResults = context.flatMap((chunk, index) => {
-            const result = results[index];
-            if (!result || result.statusCode !== 200) {
-                return {
-                    ok: false,
-                    error: 'request-error',
-                    messages: ['unexpected response from graphql batch endpoint'],
-                    missingIds: chunk,
-                };
-            }
-            return super.generateFetchResults(result.result, {
-                ...batchInput,
-                ids: chunk,
-            }, undefined);
-        });
-        return fetchResults;
-    }
-}
-
 class SoqlRecordConverter {
     /**
      *
@@ -93437,16 +93250,7 @@ class LdsPrimingRecordRefresher {
 function primingSessionFactory(config) {
     const { store, objectInfoService, getLuvio } = config;
     const networkAdapter = new NimbusPrimingNetworkAdapter();
-    let recordLoader;
-    if (lmrPrimingUseSoql.isOpen({ fallback: false })) {
-        recordLoader = new RecordLoaderSOQLComposite(networkAdapter);
-    }
-    else if (ldsPrimingGraphqlBatch.isOpen({ fallback: false })) {
-        recordLoader = new RecordLoaderGraphQLBatch(networkAdapter);
-    }
-    else {
-        recordLoader = new RecordLoaderGraphQL(networkAdapter);
-    }
+    const recordLoader = new RecordLoaderSOQLComposite(networkAdapter);
     const primingStore = new SqlitePrimingStore(getLuvio, store);
     const recordIngestor = new RecordIngestor(primingStore, getLuvio);
     const session = new PrimingSession({
@@ -94099,6 +93903,38 @@ function buildCachedSnapshotCachePolicy$e(context, storeLookup) {
 }
 
 const SIDE_EFFECT_SEGMENT = 'RECORD_SIDE_EFFECTS';
+// Base-record effects rebuild (or remove) the entire record for a key, so they must be
+// applied before any field-level effect on that same key — otherwise a field effect that
+// runs first is discarded when the base record is (re)built. keyToEffectMap ordering is not
+// stable: it is re-materialized from the durable store on reload / onChanged replay, where
+// entry order is not guaranteed. So two field-set effects on the same key from different
+// actions (e.g. two queued edits of one field) can come back in either order; applied out of
+// order the OLDER value wins and the newer edit is lost. Effects must therefore be applied in
+// action chronology (by timestamp), with base-record ops ordered ahead of field ops only as
+// the tie-breaker within one action — create/field effects on a draft-created record share a
+// key AND a timestamp, so timestamp alone can't order those.
+const BASE_RECORD_EFFECT_TYPES = new Set(['record-create', 'record-update', 'record-delete']);
+function orderEffectsForApply(effects) {
+    // Nothing to reorder for a single effect; return the original array to avoid allocating on
+    // the hot read-out path.
+    if (effects.length <= 1) {
+        return effects;
+    }
+    // Primary key: timestamp (action chronology). Secondary key: base-record ops before field
+    // ops, which only matters within one action's shared timestamp. Array.prototype.sort is
+    // stable (ES2019), so effects that tie on both keys keep their existing relative order.
+    return [...effects].sort((a, b) => {
+        if (a.timestamp !== b.timestamp) {
+            return a.timestamp - b.timestamp;
+        }
+        const aIsBase = BASE_RECORD_EFFECT_TYPES.has(a.type);
+        const bIsBase = BASE_RECORD_EFFECT_TYPES.has(b.type);
+        if (aIsBase === bIsBase) {
+            return 0;
+        }
+        return aIsBase ? -1 : 1;
+    });
+}
 class SideEffectStore {
     constructor(durableStore) {
         this.durableStore = durableStore;
@@ -94177,7 +94013,7 @@ class SideEffectStore {
         if (effects === undefined) {
             return [];
         }
-        return effects;
+        return orderEffectsForApply(effects);
     }
     getEffectsByTag(tag) {
         // This scan is still O(N) over every effect regardless of the incremental-map
@@ -94674,6 +94510,58 @@ class RecordFieldIncrementHandler {
         return record;
     }
 }
+class RecordFieldSetHandler {
+    constructor() {
+        this.logger = typeof __nimbus !== 'undefined' &&
+            __nimbus.plugins !== undefined &&
+            __nimbus.plugins.JSLoggerPlugin !== undefined
+            ? __nimbus.plugins.JSLoggerPlugin
+            : undefined;
+    }
+    apply(record, effect) {
+        if (record === undefined) {
+            if (this.logger) {
+                this.logger.logWarning('RecordFieldSetHandler - cannot apply set side effect to non existing record');
+            }
+            return undefined;
+        }
+        // fieldName is an unconstrained string that has round-tripped through the durable
+        // store, so a value like `__proto__` would hit the prototype setter on the plain
+        // `fields`/`serverValues` objects below rather than creating an own field (prototype
+        // pollution). Reject dangerous keys before any dynamic read/write and skip the effect.
+        if (isUnsafeFieldName(effect.fieldName)) {
+            if (this.logger) {
+                this.logger.logError(`RecordFieldSetHandler - unsafe field name ${effect.fieldName}, skip applying side effect`);
+            }
+            return record;
+        }
+        applyDraftNode(record, effect);
+        record.drafts.edited = true;
+        // capture the server value so it can be restored when the draft syncs.
+        // unlike the increment handler, the field may not yet exist on the record
+        // (e.g. IsProduct2Serialized is not part of the draft-created record), in
+        // which case we record `null` to indicate we never had the field.
+        if (record.drafts.created === false) {
+            const serverValue = record.drafts.serverValues[effect.fieldName];
+            if (serverValue === undefined) {
+                const existingField = record.fields[effect.fieldName];
+                record.drafts.serverValues[effect.fieldName] =
+                    existingField === undefined ? null : existingField;
+            }
+        }
+        record.fields[effect.fieldName] = {
+            value: effect.value,
+            displayValue: null,
+        };
+        return record;
+    }
+}
+// Field names that would target the prototype chain rather than an own property when used
+// to index a plain object, enabling prototype pollution on the record's field containers.
+const UNSAFE_FIELD_NAMES = new Set(['__proto__', 'constructor', 'prototype']);
+function isUnsafeFieldName(fieldName) {
+    return UNSAFE_FIELD_NAMES.has(fieldName);
+}
 function applyDraftNode(record, effect) {
     if (record.drafts === undefined) {
         record.drafts = {
@@ -94708,6 +94596,7 @@ const handlerMap = {
     'record-update': new UpdateRecordEffectHandler(),
     'record-delete': new DeleteRecordEffectHandler(),
     'record-field-increment': new RecordFieldIncrementHandler(),
+    'record-field-set': new RecordFieldSetHandler(),
 };
 /**
  * Removes any existing effects on a record and re-applies the given ordered list and returns the record
@@ -94872,14 +94761,181 @@ function isStoreRecordError(storeRecord) {
 }
 
 const instrumentation$4 = getInstrumentation();
+const ProductItem$2 = {
+    Fields: {
+        PRODUCT2_ID: 'Product2Id',
+        IS_PRODUCT2_SERIALIZED: 'IsProduct2Serialized',
+    },
+};
+const Product2 = {
+    Fields: {
+        IS_SERIALIZED: 'IsSerialized',
+    },
+};
+var CounterResult;
+(function (CounterResult) {
+    // A side effect was created.
+    CounterResult["Created"] = "Created";
+    // The hook exited early.
+    CounterResult["Exited"] = "Exited";
+    // An unexpected error occurred.
+    CounterResult["Error"] = "Error";
+})(CounterResult || (CounterResult = {}));
+function incrementCounter(name, result) {
+    instrumentation$4.incrementCounter('SFSSideEffect', 1, result === CounterResult.Error, {
+        Name: name,
+        Result: result,
+    });
+}
+/**
+ * Reads a string-valued field off a draft-create `fields` map (the raw create body, where
+ * values are the primitives themselves rather than `{ value }` wrappers). Returns `undefined`
+ * when the field is absent or not a string.
+ */
+function getStringDraftField(fields, fieldName) {
+    const field = fields[fieldName];
+    if (field === undefined || typeof field !== 'string') {
+        return undefined;
+    }
+    return field;
+}
+/**
+ * Reads a string-valued field off a durable record's `fields` map (where each value is a
+ * `{ value }` wrapper). Returns `undefined` when the field is absent, null, or not a string.
+ */
+function getStringRecordField(fields, fieldName) {
+    const field = fields[fieldName];
+    if (field === undefined || field.value === undefined || typeof field.value !== 'string') {
+        return undefined;
+    }
+    return field.value;
+}
+/**
+ * Resolves the reference id that points at a related record for a draft edit.
+ *
+ * On a `patch` the body only carries the fields being changed, so the link field may be
+ * absent, present with a new id, or present but explicitly `null` (the link is being cleared).
+ * These three cases are distinguished via `hasOwnProperty` because they demand different
+ * behavior — falling back to the original durable-store id on an explicit `null` would resolve
+ * `IsProduct2Serialized` from a relationship the record no longer has:
+ *
+ *   - present + string -> `resolved` with the reassigned id.
+ *   - present + null   -> `cleared`.
+ *   - absent           -> fall back to the original record; `resolved` when it carries a usable
+ *                         string, otherwise `unresolved`.
+ */
+function resolveReferenceIdForUpdate(patchFields, originalFields, fieldName) {
+    if (Object.prototype.hasOwnProperty.call(patchFields, fieldName)) {
+        const patchValue = patchFields[fieldName];
+        if (patchValue === null) {
+            return { kind: 'cleared' };
+        }
+        const patchId = getStringDraftField(patchFields, fieldName);
+        if (patchId !== undefined) {
+            return { kind: 'resolved', id: patchId, source: 'patch' };
+        }
+        // Present but neither a string nor null (unexpected shape): treat as an absent link
+        // and fall through to the original record rather than guessing.
+    }
+    const originalId = getStringRecordField(originalFields, fieldName);
+    if (originalId !== undefined) {
+        return { kind: 'resolved', id: originalId, source: 'original' };
+    }
+    return { kind: 'unresolved' };
+}
+/**
+ * Resolves the server-derived `IsProduct2Serialized` boolean for a draft-created record by
+ * following the related `ProductItem`:
+ *
+ *   1. If the cached `ProductItem` already carries `IsProduct2Serialized`, use it directly
+ *      (it mirrors the linked product's serialization, and avoids a second durable read).
+ *   2. Otherwise fall back to the linked `Product2`:
+ *      `ProductItem.Product2Id` -> `Product2.IsSerialized`.
+ *
+ * All lookups go through the given `RecordReader` (the durable store, or a per-action memoizer
+ * that dedups reads). Returns `undefined` when a link in the chain is missing so the caller can
+ * exit without an effect and leave the field synthesized (null). Callers pass their own
+ * `counterName` so instrumentation is attributed to the owning hook.
+ */
+async function resolveIsProduct2SerializedFromProductItem(recordReader, productItemId, counterName) {
+    const productItemRecord = await recordReader.getRecord(buildRecordRepKeyFromId$1(productItemId));
+    if (productItemRecord === undefined) {
+        incrementCounter(counterName, CounterResult.Exited);
+        return undefined;
+    }
+    // Prefer IsProduct2Serialized straight off the ProductItem when it is cached there;
+    // it saves a second durable read. Fall back to the linked Product2 otherwise.
+    const fromProductItem = getIsProduct2SerializedFromRecordFields(productItemRecord.fields);
+    if (fromProductItem !== undefined) {
+        incrementCounter(counterName, CounterResult.Created);
+        return fromProductItem;
+    }
+    const product2Id = getProduct2IdFromRecordFields(productItemRecord.fields);
+    if (product2Id === undefined) {
+        incrementCounter(counterName, CounterResult.Exited);
+        return undefined;
+    }
+    return resolveIsSerializedFromProduct2Id(recordReader, product2Id, counterName);
+}
+/**
+ * Resolves the `Product2.IsSerialized` boolean for a given `Product2Id` by reading the linked
+ * `Product2` record through the given `RecordReader`. Used directly by the `ProductItem` hooks
+ * (which carry `Product2Id` themselves) and as the fallback tail of
+ * `resolveIsProduct2SerializedFromProductItem`.
+ *
+ * Returns `undefined` when the `Product2` record is missing so the caller can exit without an
+ * effect and leave the field synthesized (null). Callers pass their own `counterName` so
+ * instrumentation is attributed to the owning hook.
+ */
+async function resolveIsSerializedFromProduct2Id(recordReader, product2Id, counterName) {
+    const product2Record = await recordReader.getRecord(buildRecordRepKeyFromId$1(product2Id));
+    if (product2Record === undefined) {
+        incrementCounter(counterName, CounterResult.Exited);
+        return undefined;
+    }
+    const isSerialized = getIsSerializedFromRecordFields(product2Record.fields);
+    if (isSerialized === undefined) {
+        incrementCounter(counterName, CounterResult.Error);
+        // Keep the message a stable literal and append the variable parts as key=value
+        // pairs, so the log line stays low-cardinality and greppable in Splunk (the raw
+        // record id is a discrete field rather than baked into the message text).
+        instrumentation$4.error(`SFS - Product2 IsSerialized not found: hook=${counterName}, product2Id=${product2Id}`);
+        return undefined;
+    }
+    incrementCounter(counterName, CounterResult.Created);
+    return isSerialized;
+}
+function getProduct2IdFromRecordFields(fields) {
+    const field = fields[ProductItem$2.Fields.PRODUCT2_ID];
+    if (field === undefined || field.value === undefined || typeof field.value !== 'string') {
+        return undefined;
+    }
+    return field.value;
+}
+function getIsProduct2SerializedFromRecordFields(fields) {
+    const field = fields[ProductItem$2.Fields.IS_PRODUCT2_SERIALIZED];
+    if (field === undefined || field.value === undefined || typeof field.value !== 'boolean') {
+        return undefined;
+    }
+    return field.value;
+}
+function getIsSerializedFromRecordFields(fields) {
+    const field = fields[Product2.Fields.IS_SERIALIZED];
+    if (field === undefined || field.value === undefined || typeof field.value !== 'boolean') {
+        return undefined;
+    }
+    return field.value;
+}
+
 const ProductConsumed = {
     API_NAME: 'ProductConsumed',
     Fields: {
         PRODUCT_ITEM_ID: 'ProductItemId',
         QUANTITY_CONSUMED: 'QuantityConsumed',
+        IS_PRODUCT2_SERIALIZED: 'IsProduct2Serialized',
     },
 };
-const ProductItem = {
+const ProductItem$1 = {
     Fields: {
         QUANTITY_ON_HAND: 'QuantityOnHand',
     },
@@ -94890,7 +94946,7 @@ class ProductConsumedCreatedHook {
         this.apiName = ProductConsumed.API_NAME;
     }
     async then(draftActionId, draftActionTimestamp, _draftRecordId, fields) {
-        const productItemId = getProductItemId(fields);
+        const productItemId = getStringDraftField(fields, ProductConsumed.Fields.PRODUCT_ITEM_ID);
         const quantityConsumed = getQuantityConsumed(fields);
         if (productItemId === undefined) {
             incrementCounter(ProductConsumedCreatedHook.COUNTER_NAME, CounterResult.Exited);
@@ -94903,7 +94959,7 @@ class ProductConsumedCreatedHook {
         incrementCounter(ProductConsumedCreatedHook.COUNTER_NAME, CounterResult.Created);
         const effect = {
             type: 'record-field-increment',
-            fieldName: ProductItem.Fields.QUANTITY_ON_HAND,
+            fieldName: ProductItem$1.Fields.QUANTITY_ON_HAND,
             value: -quantityConsumed,
             key: buildRecordRepKeyFromId$1(productItemId),
             tag: draftActionId,
@@ -94920,16 +94976,17 @@ class ProductConsumedUpdatedHook {
         this.on = 'patch';
         this.apiName = ProductConsumed.API_NAME;
     }
-    async then(draftActionId, draftActionTimestamp, draftRecordId, fields) {
+    async then(draftActionId, draftActionTimestamp, draftRecordId, fields, reader) {
         const quantityConsumed = getQuantityConsumed(fields);
         if (quantityConsumed === undefined) {
             incrementCounter(ProductConsumedUpdatedHook.COUNTER_NAME, CounterResult.Exited);
             return [];
         }
-        const originalRecord = await this.durableRecordStore.getRecord(buildRecordRepKeyFromId$1(draftRecordId));
+        const recordReader = reader ?? this.durableRecordStore;
+        const originalRecord = await recordReader.getRecord(buildRecordRepKeyFromId$1(draftRecordId));
         if (originalRecord === undefined) {
             incrementCounter(ProductConsumedUpdatedHook.COUNTER_NAME, CounterResult.Error);
-            instrumentation$4.error(`SFS - ProductConsumedUpdatedHook - Original record ${draftRecordId} not found`);
+            instrumentation$4.error(`SFS - ProductConsumedUpdatedHook original record not found: draftRecordId=${draftRecordId}`);
             return [];
         }
         const originalProductItemId = getProductItemIdFromRecordFields(originalRecord.fields);
@@ -94940,13 +94997,13 @@ class ProductConsumedUpdatedHook {
         }
         if (originalQuantityConsumed === undefined) {
             incrementCounter(ProductConsumedUpdatedHook.COUNTER_NAME, CounterResult.Error);
-            instrumentation$4.error(`SFS - ProductConsumedUpdatedHook - Original record ${draftRecordId} QuantityConsumed not found`);
+            instrumentation$4.error(`SFS - ProductConsumedUpdatedHook original record QuantityConsumed not found: draftRecordId=${draftRecordId}`);
             return [];
         }
         incrementCounter(ProductConsumedUpdatedHook.COUNTER_NAME, CounterResult.Created);
         const effect = {
             type: 'record-field-increment',
-            fieldName: ProductItem.Fields.QUANTITY_ON_HAND,
+            fieldName: ProductItem$1.Fields.QUANTITY_ON_HAND,
             value: originalQuantityConsumed - quantityConsumed,
             key: buildRecordRepKeyFromId$1(originalProductItemId),
             tag: draftActionId,
@@ -94963,11 +95020,12 @@ class ProductConsumedDeletedHook {
         this.on = 'delete';
         this.apiName = ProductConsumed.API_NAME;
     }
-    async then(draftActionId, draftActionTimestamp, draftRecordId) {
-        const originalRecord = await this.durableRecordStore.getRecord(buildRecordRepKeyFromId$1(draftRecordId));
+    async then(draftActionId, draftActionTimestamp, draftRecordId, _fields, reader) {
+        const recordReader = reader ?? this.durableRecordStore;
+        const originalRecord = await recordReader.getRecord(buildRecordRepKeyFromId$1(draftRecordId));
         if (originalRecord === undefined) {
             incrementCounter(ProductConsumedDeletedHook.COUNTER_NAME, CounterResult.Error);
-            instrumentation$4.error(`SFS - ProductConsumedDeletedHook - Original record ${draftRecordId} not found`);
+            instrumentation$4.error(`SFS - ProductConsumedDeletedHook original record not found: draftRecordId=${draftRecordId}`);
             return [];
         }
         const productItemId = getProductItemIdFromRecordFields(originalRecord.fields);
@@ -94978,13 +95036,13 @@ class ProductConsumedDeletedHook {
         }
         if (quantityConsumed === undefined) {
             incrementCounter(ProductConsumedDeletedHook.COUNTER_NAME, CounterResult.Error);
-            instrumentation$4.error(`SFS - ProductConsumedDeletedHook - Original record ${draftRecordId} QuantityConsumed not found`);
+            instrumentation$4.error(`SFS - ProductConsumedDeletedHook original record QuantityConsumed not found: draftRecordId=${draftRecordId}`);
             return [];
         }
         incrementCounter(ProductConsumedDeletedHook.COUNTER_NAME, CounterResult.Created);
         const effect = {
             type: 'record-field-increment',
-            fieldName: ProductItem.Fields.QUANTITY_ON_HAND,
+            fieldName: ProductItem$1.Fields.QUANTITY_ON_HAND,
             value: quantityConsumed,
             key: buildRecordRepKeyFromId$1(productItemId),
             tag: draftActionId,
@@ -94995,13 +95053,115 @@ class ProductConsumedDeletedHook {
     }
 }
 ProductConsumedDeletedHook.COUNTER_NAME = 'ProductConsumedDeletedHook';
-function getProductItemId(fields) {
-    const field = fields[ProductConsumed.Fields.PRODUCT_ITEM_ID];
-    if (field === undefined || typeof field !== 'string') {
-        return undefined;
+/**
+ * Replicates the server-derived `IsProduct2Serialized` boolean on a draft-created
+ * `ProductConsumed` record.
+ *
+ * `Product2Id` is not createable on `ProductConsumed`, so the draft only carries the
+ * `ProductItemId`. The value is resolved through the related `ProductItem` record (see
+ * `resolveIsProduct2SerializedFromProductItem`): the ProductItem's own
+ * `IsProduct2Serialized` when cached, otherwise `ProductItem.Product2Id` ->
+ * `Product2.IsSerialized`. When the chain cannot be resolved the hook exits without an
+ * effect and the field is left as synthesized (null).
+ */
+class ProductConsumedIsSerializedCreatedHook {
+    constructor(durableRecordStore) {
+        this.durableRecordStore = durableRecordStore;
+        this.on = 'post';
+        this.apiName = ProductConsumed.API_NAME;
+    }
+    async then(draftActionId, draftActionTimestamp, draftRecordId, fields, reader) {
+        const productItemId = getStringDraftField(fields, ProductConsumed.Fields.PRODUCT_ITEM_ID);
+        if (productItemId === undefined) {
+            incrementCounter(ProductConsumedIsSerializedCreatedHook.COUNTER_NAME, CounterResult.Exited);
+            return [];
+        }
+        const isSerialized = await resolveIsProduct2SerializedFromProductItem(reader ?? this.durableRecordStore, productItemId, ProductConsumedIsSerializedCreatedHook.COUNTER_NAME);
+        if (isSerialized === undefined) {
+            return [];
+        }
+        const effect = {
+            type: 'record-field-set',
+            fieldName: ProductConsumed.Fields.IS_PRODUCT2_SERIALIZED,
+            value: isSerialized,
+            key: buildRecordRepKeyFromId$1(draftRecordId),
+            tag: draftActionId,
+            uniqueId: `${draftActionId}-IsProduct2Serialized`,
+            timestamp: draftActionTimestamp,
+        };
+        return [effect];
+    }
+}
+ProductConsumedIsSerializedCreatedHook.COUNTER_NAME = 'ProductConsumedIsSerializedCreatedHook';
+/**
+ * Replicates the server-derived `IsProduct2Serialized` boolean on a draft-edited
+ * `ProductConsumed` record.
+ *
+ * A `patch` body only carries changed fields, so the related `ProductItemId` may be absent.
+ * The id is resolved by preferring the patch body (the link is being reassigned) and falling
+ * back to the original record in the durable store, then the value is resolved through that
+ * `ProductItem` exactly as on create (see `resolveIsProduct2SerializedFromProductItem`).
+ *
+ * When the patch explicitly clears `ProductItemId` (sets it to `null`) the record no longer
+ * derives from any `ProductItem`, so `IsProduct2Serialized` is cleared (set to `null`) rather
+ * than resolved from the now-stale original link. Likewise, when the patch reassigns
+ * `ProductItemId` to a new id whose chain isn't cached, the stored value reflects the old link
+ * and is stale, so it is cleared. When the link is unchanged and its chain cannot be resolved,
+ * the stored value is still correct so the hook exits without an effect and leaves it unchanged.
+ */
+class ProductConsumedIsSerializedUpdatedHook {
+    constructor(durableRecordStore) {
+        this.durableRecordStore = durableRecordStore;
+        this.on = 'patch';
+        this.apiName = ProductConsumed.API_NAME;
+    }
+    async then(draftActionId, draftActionTimestamp, draftRecordId, fields, reader) {
+        const recordReader = reader ?? this.durableRecordStore;
+        const originalRecord = await recordReader.getRecord(buildRecordRepKeyFromId$1(draftRecordId));
+        if (originalRecord === undefined) {
+            incrementCounter(ProductConsumedIsSerializedUpdatedHook.COUNTER_NAME, CounterResult.Error);
+            instrumentation$4.error(`SFS - ProductConsumedIsSerializedUpdatedHook original record not found: draftRecordId=${draftRecordId}`);
+            return [];
+        }
+        const reference = resolveReferenceIdForUpdate(fields, originalRecord.fields, ProductConsumed.Fields.PRODUCT_ITEM_ID);
+        if (reference.kind === 'unresolved') {
+            incrementCounter(ProductConsumedIsSerializedUpdatedHook.COUNTER_NAME, CounterResult.Exited);
+            return [];
+        }
+        let isSerialized;
+        if (reference.kind === 'cleared') {
+            // The link was explicitly cleared: the record derives from no ProductItem, so clear
+            // IsProduct2Serialized rather than resolving it from the stale original link.
+            incrementCounter(ProductConsumedIsSerializedUpdatedHook.COUNTER_NAME, CounterResult.Created);
+            isSerialized = null;
+        }
+        else {
+            isSerialized = await resolveIsProduct2SerializedFromProductItem(recordReader, reference.id, ProductConsumedIsSerializedUpdatedHook.COUNTER_NAME);
+            if (isSerialized === undefined && reference.source === 'patch') {
+                // The link was reassigned to a new ProductItem whose chain isn't cached yet, so
+                // the stored IsProduct2Serialized still reflects the OLD link and is now stale.
+                // Clear it rather than leaving the stale value alongside the new relationship;
+                // the server recomputes the real value on sync.
+                incrementCounter(ProductConsumedIsSerializedUpdatedHook.COUNTER_NAME, CounterResult.Created);
+                isSerialized = null;
+            }
+        }
+        if (isSerialized === undefined) {
+            return [];
+        }
+        const effect = {
+            type: 'record-field-set',
+            fieldName: ProductConsumed.Fields.IS_PRODUCT2_SERIALIZED,
+            value: isSerialized,
+            key: buildRecordRepKeyFromId$1(draftRecordId),
+            tag: draftActionId,
+            uniqueId: `${draftActionId}-IsProduct2Serialized`,
+            timestamp: draftActionTimestamp,
+        };
+        return [effect];
     }
-    return field;
 }
+ProductConsumedIsSerializedUpdatedHook.COUNTER_NAME = 'ProductConsumedIsSerializedUpdatedHook';
 function getProductItemIdFromRecordFields(fields) {
     const field = fields[ProductConsumed.Fields.PRODUCT_ITEM_ID];
     if (field === undefined || field.value === undefined || typeof field.value !== 'string') {
@@ -95023,29 +95183,265 @@ function getQuantityConsumedFromRecordFields(fields) {
     }
     return field.value;
 }
-var CounterResult;
-(function (CounterResult) {
-    // A side effect was created.
-    CounterResult["Created"] = "Created";
-    // The hook exited early.
-    CounterResult["Exited"] = "Exited";
-    // An unexpected error occurred.
-    CounterResult["Error"] = "Error";
-})(CounterResult || (CounterResult = {}));
-function incrementCounter(name, result) {
-    instrumentation$4.incrementCounter('SFSSideEffect', 1, result === CounterResult.Error, {
-        Name: name,
-        Result: result,
-    });
+
+const ProductTransfer = {
+    API_NAME: 'ProductTransfer',
+    Fields: {
+        SOURCE_PRODUCT_ITEM_ID: 'SourceProductItemId',
+        IS_PRODUCT2_SERIALIZED: 'IsProduct2Serialized',
+    },
+};
+/**
+ * Replicates the server-derived `IsProduct2Serialized` boolean on a draft-created
+ * `ProductTransfer` record.
+ *
+ * The value is resolved through the related `SourceProductItem` record (a `ProductItem`),
+ * mirroring the `ProductConsumed` hook: the ProductItem's own `IsProduct2Serialized` when
+ * cached, otherwise `ProductItem.Product2Id` -> `Product2.IsSerialized` (see
+ * `resolveIsProduct2SerializedFromProductItem`). When the chain cannot be resolved the hook
+ * exits without an effect and the field is left as synthesized (null).
+ */
+class ProductTransferIsSerializedCreatedHook {
+    constructor(durableRecordStore) {
+        this.durableRecordStore = durableRecordStore;
+        this.on = 'post';
+        this.apiName = ProductTransfer.API_NAME;
+    }
+    async then(draftActionId, draftActionTimestamp, draftRecordId, fields, reader) {
+        const sourceProductItemId = getStringDraftField(fields, ProductTransfer.Fields.SOURCE_PRODUCT_ITEM_ID);
+        if (sourceProductItemId === undefined) {
+            incrementCounter(ProductTransferIsSerializedCreatedHook.COUNTER_NAME, CounterResult.Exited);
+            return [];
+        }
+        const isSerialized = await resolveIsProduct2SerializedFromProductItem(reader ?? this.durableRecordStore, sourceProductItemId, ProductTransferIsSerializedCreatedHook.COUNTER_NAME);
+        if (isSerialized === undefined) {
+            return [];
+        }
+        const effect = {
+            type: 'record-field-set',
+            fieldName: ProductTransfer.Fields.IS_PRODUCT2_SERIALIZED,
+            value: isSerialized,
+            key: buildRecordRepKeyFromId$1(draftRecordId),
+            tag: draftActionId,
+            uniqueId: `${draftActionId}-IsProduct2Serialized`,
+            timestamp: draftActionTimestamp,
+        };
+        return [effect];
+    }
+}
+ProductTransferIsSerializedCreatedHook.COUNTER_NAME = 'ProductTransferIsSerializedCreatedHook';
+/**
+ * Replicates the server-derived `IsProduct2Serialized` boolean on a draft-edited
+ * `ProductTransfer` record.
+ *
+ * ProductTransfer can only be edited (not created) on mobile, so this is the hook that fires
+ * in practice. A `patch` body only carries changed fields, so the related `SourceProductItemId`
+ * may be absent; the id is resolved by preferring the patch body (the link is being reassigned)
+ * and falling back to the original record in the durable store, then the value is resolved
+ * through that `ProductItem` exactly as on create (see
+ * `resolveIsProduct2SerializedFromProductItem`).
+ *
+ * When the patch explicitly clears `SourceProductItemId` (sets it to `null`) the record no
+ * longer derives from any `ProductItem`, so `IsProduct2Serialized` is cleared (set to `null`)
+ * rather than resolved from the now-stale original link. Likewise, when the patch reassigns
+ * `SourceProductItemId` to a new id whose chain isn't cached, the stored value reflects the old
+ * link and is stale, so it is cleared. When the link is unchanged and its chain cannot be
+ * resolved, the stored value is still correct so the hook exits without an effect and leaves it
+ * unchanged.
+ */
+class ProductTransferIsSerializedUpdatedHook {
+    constructor(durableRecordStore) {
+        this.durableRecordStore = durableRecordStore;
+        this.on = 'patch';
+        this.apiName = ProductTransfer.API_NAME;
+    }
+    async then(draftActionId, draftActionTimestamp, draftRecordId, fields, reader) {
+        const recordReader = reader ?? this.durableRecordStore;
+        const originalRecord = await recordReader.getRecord(buildRecordRepKeyFromId$1(draftRecordId));
+        if (originalRecord === undefined) {
+            incrementCounter(ProductTransferIsSerializedUpdatedHook.COUNTER_NAME, CounterResult.Error);
+            instrumentation$4.error(`SFS - ProductTransferIsSerializedUpdatedHook original record not found: draftRecordId=${draftRecordId}`);
+            return [];
+        }
+        const reference = resolveReferenceIdForUpdate(fields, originalRecord.fields, ProductTransfer.Fields.SOURCE_PRODUCT_ITEM_ID);
+        if (reference.kind === 'unresolved') {
+            incrementCounter(ProductTransferIsSerializedUpdatedHook.COUNTER_NAME, CounterResult.Exited);
+            return [];
+        }
+        let isSerialized;
+        if (reference.kind === 'cleared') {
+            // The link was explicitly cleared: the record derives from no ProductItem, so clear
+            // IsProduct2Serialized rather than resolving it from the stale original link.
+            incrementCounter(ProductTransferIsSerializedUpdatedHook.COUNTER_NAME, CounterResult.Created);
+            isSerialized = null;
+        }
+        else {
+            isSerialized = await resolveIsProduct2SerializedFromProductItem(recordReader, reference.id, ProductTransferIsSerializedUpdatedHook.COUNTER_NAME);
+            if (isSerialized === undefined && reference.source === 'patch') {
+                // The link was reassigned to a new ProductItem whose chain isn't cached yet, so
+                // the stored IsProduct2Serialized still reflects the OLD link and is now stale.
+                // Clear it rather than leaving the stale value alongside the new relationship;
+                // the server recomputes the real value on sync.
+                incrementCounter(ProductTransferIsSerializedUpdatedHook.COUNTER_NAME, CounterResult.Created);
+                isSerialized = null;
+            }
+        }
+        if (isSerialized === undefined) {
+            return [];
+        }
+        const effect = {
+            type: 'record-field-set',
+            fieldName: ProductTransfer.Fields.IS_PRODUCT2_SERIALIZED,
+            value: isSerialized,
+            key: buildRecordRepKeyFromId$1(draftRecordId),
+            tag: draftActionId,
+            uniqueId: `${draftActionId}-IsProduct2Serialized`,
+            timestamp: draftActionTimestamp,
+        };
+        return [effect];
+    }
 }
+ProductTransferIsSerializedUpdatedHook.COUNTER_NAME = 'ProductTransferIsSerializedUpdatedHook';
+
+const ProductItem = {
+    API_NAME: 'ProductItem',
+    Fields: {
+        PRODUCT2_ID: 'Product2Id',
+        IS_PRODUCT2_SERIALIZED: 'IsProduct2Serialized',
+    },
+};
+/**
+ * Replicates the server-derived `IsProduct2Serialized` boolean on a draft-created
+ * `ProductItem` record.
+ *
+ * Unlike `ProductConsumed`/`ProductTransfer` — which reach the product through a related
+ * `ProductItem` — a `ProductItem` carries `Product2Id` directly, so the value is resolved as
+ * `Product2Id` -> `Product2.IsSerialized` (see `resolveIsSerializedFromProduct2Id`). When the
+ * chain cannot be resolved the hook exits without an effect and the field is left as
+ * synthesized (null).
+ */
+class ProductItemIsSerializedCreatedHook {
+    constructor(durableRecordStore) {
+        this.durableRecordStore = durableRecordStore;
+        this.on = 'post';
+        this.apiName = ProductItem.API_NAME;
+    }
+    async then(draftActionId, draftActionTimestamp, draftRecordId, fields, reader) {
+        const product2Id = getStringDraftField(fields, ProductItem.Fields.PRODUCT2_ID);
+        if (product2Id === undefined) {
+            incrementCounter(ProductItemIsSerializedCreatedHook.COUNTER_NAME, CounterResult.Exited);
+            return [];
+        }
+        const isSerialized = await resolveIsSerializedFromProduct2Id(reader ?? this.durableRecordStore, product2Id, ProductItemIsSerializedCreatedHook.COUNTER_NAME);
+        if (isSerialized === undefined) {
+            return [];
+        }
+        const effect = {
+            type: 'record-field-set',
+            fieldName: ProductItem.Fields.IS_PRODUCT2_SERIALIZED,
+            value: isSerialized,
+            key: buildRecordRepKeyFromId$1(draftRecordId),
+            tag: draftActionId,
+            uniqueId: `${draftActionId}-IsProduct2Serialized`,
+            timestamp: draftActionTimestamp,
+        };
+        return [effect];
+    }
+}
+ProductItemIsSerializedCreatedHook.COUNTER_NAME = 'ProductItemIsSerializedCreatedHook';
+/**
+ * Replicates the server-derived `IsProduct2Serialized` boolean on a draft-edited
+ * `ProductItem` record.
+ *
+ * A `patch` body only carries changed fields, so `Product2Id` may be absent; it is resolved by
+ * preferring the patch body (the product is being reassigned) and falling back to the original
+ * record in the durable store, then resolved as `Product2Id` -> `Product2.IsSerialized` (see
+ * `resolveIsSerializedFromProduct2Id`).
+ *
+ * When the patch explicitly clears `Product2Id` (sets it to `null`) the record no longer
+ * derives from any `Product2`, so `IsProduct2Serialized` is cleared (set to `null`) rather than
+ * resolved from the now-stale original link. Likewise, when the patch reassigns `Product2Id` to
+ * a new id whose `Product2` isn't cached, the stored value reflects the old link and is stale,
+ * so it is cleared. When the link is unchanged and its `Product2` cannot be resolved, the stored
+ * value is still correct so the hook exits without an effect and leaves it unchanged.
+ */
+class ProductItemIsSerializedUpdatedHook {
+    constructor(durableRecordStore) {
+        this.durableRecordStore = durableRecordStore;
+        this.on = 'patch';
+        this.apiName = ProductItem.API_NAME;
+    }
+    async then(draftActionId, draftActionTimestamp, draftRecordId, fields, reader) {
+        const recordReader = reader ?? this.durableRecordStore;
+        const originalRecord = await recordReader.getRecord(buildRecordRepKeyFromId$1(draftRecordId));
+        if (originalRecord === undefined) {
+            incrementCounter(ProductItemIsSerializedUpdatedHook.COUNTER_NAME, CounterResult.Error);
+            instrumentation$4.error(`SFS - ProductItemIsSerializedUpdatedHook original record not found: draftRecordId=${draftRecordId}`);
+            return [];
+        }
+        const reference = resolveReferenceIdForUpdate(fields, originalRecord.fields, ProductItem.Fields.PRODUCT2_ID);
+        if (reference.kind === 'unresolved') {
+            incrementCounter(ProductItemIsSerializedUpdatedHook.COUNTER_NAME, CounterResult.Exited);
+            return [];
+        }
+        let isSerialized;
+        if (reference.kind === 'cleared') {
+            // The link was explicitly cleared: the record derives from no Product2, so clear
+            // IsProduct2Serialized rather than resolving it from the stale original link.
+            incrementCounter(ProductItemIsSerializedUpdatedHook.COUNTER_NAME, CounterResult.Created);
+            isSerialized = null;
+        }
+        else {
+            isSerialized = await resolveIsSerializedFromProduct2Id(recordReader, reference.id, ProductItemIsSerializedUpdatedHook.COUNTER_NAME);
+            if (isSerialized === undefined && reference.source === 'patch') {
+                // The link was reassigned to a new Product2 that isn't cached yet, so the stored
+                // IsProduct2Serialized still reflects the OLD link and is now stale. Clear it
+                // rather than leaving the stale value alongside the new relationship; the server
+                // recomputes the real value on sync.
+                incrementCounter(ProductItemIsSerializedUpdatedHook.COUNTER_NAME, CounterResult.Created);
+                isSerialized = null;
+            }
+        }
+        if (isSerialized === undefined) {
+            return [];
+        }
+        const effect = {
+            type: 'record-field-set',
+            fieldName: ProductItem.Fields.IS_PRODUCT2_SERIALIZED,
+            value: isSerialized,
+            key: buildRecordRepKeyFromId$1(draftRecordId),
+            tag: draftActionId,
+            uniqueId: `${draftActionId}-IsProduct2Serialized`,
+            timestamp: draftActionTimestamp,
+        };
+        return [effect];
+    }
+}
+ProductItemIsSerializedUpdatedHook.COUNTER_NAME = 'ProductItemIsSerializedUpdatedHook';
 
 function createSfsSideEffectHooks(durableRecordStore) {
     if (productConsumedSideEffects.isOpen({ fallback: false })) {
-        return [
+        const hooks = [
             new ProductConsumedCreatedHook(),
             new ProductConsumedUpdatedHook(durableRecordStore),
             new ProductConsumedDeletedHook(durableRecordStore),
         ];
+        // The IsProduct2Serialized side effects (ProductConsumed, ProductTransfer and
+        // ProductItem) ship on by default and can be disabled independently of the van stock
+        // hooks above via a shared kill switch: the gate is closed (fallback false) by default,
+        // which keeps the effects enabled, and opening the gate turns them off.
+        //
+        // Each object gets both a create (post) and edit (patch) hook so the field is
+        // synthesized on either draft action, keeping the behavior uniform across the objects.
+        if (!isProduct2SerializedSideEffectKillSwitch.isOpen({ fallback: false })) {
+            hooks.push(new ProductConsumedIsSerializedCreatedHook(durableRecordStore));
+            hooks.push(new ProductConsumedIsSerializedUpdatedHook(durableRecordStore));
+            hooks.push(new ProductTransferIsSerializedCreatedHook(durableRecordStore));
+            hooks.push(new ProductTransferIsSerializedUpdatedHook(durableRecordStore));
+            hooks.push(new ProductItemIsSerializedCreatedHook(durableRecordStore));
+            hooks.push(new ProductItemIsSerializedUpdatedHook(durableRecordStore));
+        }
+        return hooks;
     }
     return [];
 }
@@ -95369,6 +95765,15 @@ function buildServiceDescriptor$m() {
   };
 }
 
+function applyOperationRequestOptions$1(init, operationType) {
+  if (operationType === void 0) {
+    return init;
+  }
+  return {
+    ...init,
+    onestore: { ...init?.onestore, retrySafe: operationType === "query" }
+  };
+}
 class AuraNetworkCommand extends NetworkCommand$1 {
   constructor(services) {
     super(services);
@@ -95387,6 +95792,18 @@ class AuraNetworkCommand extends NetworkCommand$1 {
       "Fetch parameters must be specified when using HTTP transport on an Aura adapter"
     );
   }
+  /**
+   * 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. On the HTTP fallback path (`fetch`) it derives the
+   * request's `onestore.retrySafe` — reads (`query`) are retry-safe, writes
+   * (`mutation`) are not. Mirrors `FetchNetworkCommand.operationType`, which
+   * this class does not inherit (it extends `NetworkCommand` directly).
+   */
+  get operationType() {
+    return void 0;
+  }
   coerceAuraErrors(auraErrors) {
     return new UserVisibleError(getFetchResponseFromAuraError(auraErrors[0]));
   }
@@ -95488,9 +95905,11 @@ class AuraNetworkCommand extends NetworkCommand$1 {
         this.coerceAuraErrors
       );
     } else if (this.shouldUseFetch()) {
-      const params = this.fetchParams;
+      const [input, init] = this.fetchParams;
+      const initWithOptions = applyOperationRequestOptions$1(init, this.operationType);
       try {
-        return this.convertFetchResponseToData(this.services.fetch(...params));
+        const fetchCall = initWithOptions === void 0 ? this.services.fetch(input) : this.services.fetch(input, initWithOptions);
+        return this.convertFetchResponseToData(fetchCall);
       } catch (reason) {
         return resolvedPromiseLike$2(err$1(toError(reason)));
       }
@@ -96237,6 +96656,15 @@ class NetworkCommand extends BaseCommand {
   async afterRequestHooks(_options) {
   }
 }
+function applyOperationRequestOptions(init, operationType) {
+  if (operationType === void 0) {
+    return init;
+  }
+  return {
+    ...init,
+    onestore: { ...init?.onestore, retrySafe: operationType === "query" }
+  };
+}
 function isAbortableCommand(command) {
   return !!command && typeof command === "object" && "isAbortableCommand" in command && command.isAbortableCommand === true;
 }
@@ -96309,7 +96737,8 @@ const _FetchNetworkCommand = class _FetchNetworkCommand extends NetworkCommand {
    * `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.
+   * `fetch`, which folds it into the context seed and derives
+   * `onestore.retrySafe` from it.
    */
   get operationType() {
     return void 0;
@@ -96318,8 +96747,9 @@ const _FetchNetworkCommand = class _FetchNetworkCommand extends NetworkCommand {
     try {
       const [input, init] = this.fetchParams;
       const operationType = this.operationType;
+      const initWithOptions = applyOperationRequestOptions(init, operationType);
       const seed = operationType === void 0 ? contextSeed : { operationType, ...contextSeed };
-      const initWithSeed = seed === void 0 ? init : { ...init, __contextSeed: seed };
+      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) {
@@ -97413,7 +97843,7 @@ function buildServiceDescriptor$b(luvio) {
         },
     };
 }
-// version: 1.461.0-37b1c9d1cb
+// version: 1.463.0-ea9ecd17fc
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -97439,7 +97869,7 @@ function buildServiceDescriptor$a(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.461.0-37b1c9d1cb
+// version: 1.463.0-ea9ecd17fc
 
 function findExecutableOperation$1(input) {
   const operations = input.query.definitions.filter(
@@ -98020,9 +98450,18 @@ function validateDiscriminatedOneOf(data, discriminator, path, document, visited
   if (data === null || typeof data !== "object" || Array.isArray(data)) {
     return invalidSchemaResponseWithError(incorrectTypeError("object", typeof data, path));
   }
-  const { propertyName, mapping } = discriminator;
+  const { propertyName, mapping, defaultMapping } = discriminator;
   const discriminatorValue = data[propertyName];
   if (discriminatorValue === void 0) {
+    if (defaultMapping !== void 0) {
+      return validateJsonSchemaInternal(
+        data,
+        { $ref: defaultMapping },
+        path,
+        document,
+        visited
+      );
+    }
     return invalidSchemaResponseWithError(
       new MissingRequiredPropertyError(
         `Object at path '${path}' is missing required discriminator property '${propertyName}'.`
@@ -98034,7 +98473,7 @@ function validateDiscriminatedOneOf(data, discriminator, path, document, visited
       incorrectTypeError("string", typeof discriminatorValue, `${path}.${propertyName}`)
     );
   }
-  const targetRef = mapping[discriminatorValue];
+  const targetRef = mapping[discriminatorValue] ?? defaultMapping;
   if (targetRef === void 0) {
     return invalidSchemaResponseWithError(
       new JsonSchemaViolationError(
@@ -99828,9 +100267,6 @@ class NimbusSqliteOneStoreCache {
 
 const PURGE_CACHE_DAYS = 30;
 function initializeOneStore(sqliteStore, luvio) {
-    if (!useOneStore.isOpen({ fallback: true })) {
-        return;
-    }
     // Initialize performance.now() fallback if not available
     if (typeof globalThis.performance === 'undefined') {
         globalThis.performance = { now: () => Date.now() };
@@ -100017,12 +100453,6 @@ function getRuntime({ primeUser = false } = {}) {
         lazyInternalLuvio = internalLuvio;
         lazyObjectInfoService = new ObjectInfoService(getObjectInfo, getObjectInfos, getObjectInfoDirectory, lazyDurableStore);
         const baseEnv = new Environment(store, lazyNetworkAdapter);
-        const shouldFilterFieldsOnRevive = (key) => {
-            if (reviveOnlyRequestedFields.isOpen({ fallback: true })) {
-                return isStoreKeyRecordId(key);
-            }
-            return false;
-        };
         const gqlEnv = makeEnvironmentGraphqlAware(baseEnv);
         const durableEnv = makeDurable(gqlEnv, {
             durableStore: lazyDurableStore,
@@ -100030,7 +100460,12 @@ function getRuntime({ primeUser = false } = {}) {
             // disable luvio deep freeze in headless environments
             disableDeepFreeze: typeof window === 'undefined',
             shouldFlush,
-            shouldFilterFieldsOnRevive,
+            // Disabling field filtering on revive for now (previously gated behind
+            // the lmr.reviveOnlyRequestedFields gate). The code path is retained
+            // below should we need to re-enable this behavior in the future:
+            shouldFilterFieldsOnRevive: (_key) => {
+                return false;
+            },
         });
         // draft queue
         lazyDraftQueue = buildLdsDraftQueue(lazyDurableStore);
@@ -100148,7 +100583,7 @@ register$1({
     id: '@salesforce/lds-network-adapter',
     instrument: instrument$2,
 });
-// version: 1.461.0-37b1c9d1cb
+// version: 1.463.0-ea9ecd17fc
 
 const { create: create$2, keys: keys$2 } = Object;
 const { stringify, parse } = JSON;
@@ -107700,7 +108135,7 @@ function registerCallback(cb) {
         cb(graphql_v1_import, graphql_imperative$1, graphql_imperative_legacy_v1_import, graphql_state_manager, useOneStoreGraphQL);
     }
 }
-// version: 1.461.0-55ae54e753
+// version: 1.463.0-8515018faf
 
 function createFragmentMap(documentNode) {
     const fragments = {};
@@ -136943,7 +137378,7 @@ register$1({
     configuration: { ...configurationForGraphQLAdapters$1 },
     instrument: instrument$1,
 });
-// version: 1.461.0-55ae54e753
+// version: 1.463.0-8515018faf
 
 // On core the unstable adapters are re-exported with different names,
 // we want to match them here.
@@ -137095,7 +137530,7 @@ withDefaultLuvio((luvio) => {
     unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
     graphQLImperative = ldsAdapter;
 });
-// version: 1.461.0-55ae54e753
+// version: 1.463.0-8515018faf
 
 var gqlApi = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -137418,19 +137853,7 @@ function invokeDmlAdapter(adapter, configObject, onResponse, nativeAdapterReques
 function invokeAdapterWithDraftToReplace(adapterId, config, draftIdToReplace, onResponse, nativeAdapterRequestContext) {
     invokeAdapterWithDraftToMerge(adapterId, config, draftIdToReplace, onResponse, nativeAdapterRequestContext);
 }
-/**
- * Executes the specified adapter with the given @param adapterId and @param config. Then
- * it merges the draft with the given id with the draft generated by
- * the mutating adapter. Will call onResult callback once with data or error.
- *
- * This function returns an error if the given adapterId cannot be found, or if the
- * adapterId is not a mutating adapter if a draft isn't created, or
- * if it fails to parse the given config string.
- *
- * If the @param adapterId is deleteRecod, the invocation of it will generate a delele draft.
- * The newly generated delete draft will replace the draft specified by @param targetDraftId
- */
-function invokeAdapterWithDraftToMerge(adapterId, config, targetDraftId, onResponse, nativeAdapterRequestContext) {
+function invokeAdapterWithDraftToMergeAndMetadata(adapterId, config, targetDraftId, metadata, onResponse, nativeAdapterRequestContext) {
     const adapter = getDMLAdapterFromName(adapterId);
     if (adapter === undefined) {
         // Check if the adapter is non-mutating adapter and create proper error message.
@@ -137446,10 +137869,12 @@ function invokeAdapterWithDraftToMerge(adapterId, config, targetDraftId, onRespo
     // deleteRecord adapter call will generate a delete draft and
     // the newly generate draft will replace the target draft
     if (adapterId === 'deleteRecord') {
-        invokeAdapterWithDraftToMergeDeleteRecord(adapter, config, targetDraftId, onResponse, nativeAdapterRequestContext);
+        invokeAdapterWithDraftToMergeDeleteRecord(adapter, config, targetDraftId, metadata, onResponse, nativeAdapterRequestContext);
         return;
     }
-    draftManager.getQueue().then((draftInfo) => {
+    draftManager
+        .getQueue()
+        .then((draftInfo) => {
         const draftIds = draftInfo.items.map((draft) => draft.id);
         if (draftIds.includes(targetDraftId) === false) {
             onResponse({
@@ -137466,14 +137891,32 @@ function invokeAdapterWithDraftToMerge(adapterId, config, targetDraftId, onRespo
                 const draftId = draftIds[draftIds.length - 1];
                 draftManager
                     .mergeActions(targetDraftId, draftId)
-                    .then(() => {
+                    .then(async () => {
                     if (responseValue.data === undefined ||
                         responseValue.data.drafts === undefined) {
                         onResponse(responseValue);
                         return;
                     }
                     const newResponse = removeDraftNodeActionId(draftId, responseValue);
-                    onResponse(newResponse);
+                    if (metadata !== undefined) {
+                        const mergedState = await draftManager.getQueue();
+                        const mergedItem = mergedState.items.find((item) => item.id === targetDraftId);
+                        const mergedMetadata = mergedItem?.metadata ?? {};
+                        draftManager
+                            .setMetadata(targetDraftId, {
+                            ...mergedMetadata,
+                            ...metadata,
+                        })
+                            .then(() => {
+                            onResponse(newResponse);
+                        })
+                            .catch((error) => {
+                            onResponse(convertErrorIntoNativeFetchError(error, 'Unable to set metadata on draft'));
+                        });
+                    }
+                    else {
+                        onResponse(newResponse);
+                    }
                 })
                     .catch((error) => {
                     onResponse(convertErrorIntoNativeFetchError(error, `Unknown error merging draft`));
@@ -137485,8 +137928,26 @@ function invokeAdapterWithDraftToMerge(adapterId, config, targetDraftId, onRespo
                 onResponse(response);
             }
         }, nativeAdapterRequestContext);
+    })
+        .catch((error) => {
+        onResponse(convertErrorIntoNativeFetchError(error, 'Unable to get draft queue'));
     });
 }
+/**
+ * Executes the specified adapter with the given @param adapterId and @param config. Then
+ * it merges the draft with the given id with the draft generated by
+ * the mutating adapter. Will call onResult callback once with data or error.
+ *
+ * This function returns an error if the given adapterId cannot be found, or if the
+ * adapterId is not a mutating adapter if a draft isn't created, or
+ * if it fails to parse the given config string.
+ *
+ * If the @param adapterId is deleteRecod, the invocation of it will generate a delele draft.
+ * The newly generated delete draft will replace the draft specified by @param targetDraftId
+ */
+function invokeAdapterWithDraftToMerge(adapterId, config, targetDraftId, onResponse, nativeAdapterRequestContext) {
+    invokeAdapterWithDraftToMergeAndMetadata(adapterId, config, targetDraftId, undefined, onResponse, nativeAdapterRequestContext);
+}
 /**
  * Executes the specified adapter with the given adapterId and config. Then
  * it sets the given metadata on the draft created by the mutating adapter.  Will call
@@ -137622,18 +138083,20 @@ This is a special case version of the invokeAdapterWithDraftToMerge function
 which should only be used for the deleteRecord wire adapter, since it does not
 contain record data in the result and has to do special querying of the draft queue
 */
-function invokeAdapterWithDraftToMergeDeleteRecord(adapter, config, draftIdToReplace, onResponse, nativeAdapterRequestContext) {
+function invokeAdapterWithDraftToMergeDeleteRecord(adapter, config, draftIdToReplace, metadata, onResponse, nativeAdapterRequestContext) {
     const targetedRecordId = parse(config);
     let priorDraftIds;
-    draftManager.getQueue().then((draftState) => {
-        priorDraftIds = draftState.items.map((item) => {
-            return item.id;
-        });
+    draftManager
+        .getQueue()
+        .then((draftState) => {
+        priorDraftIds = draftState.items.map((item) => item.id);
         invokeDmlAdapter(adapter, parse(config), (responseValue) => {
             if (responseValue.error === undefined &&
                 responseValue.errors === undefined &&
                 responseValue.data === undefined) {
-                draftManager.getQueue().then((newState) => {
+                draftManager
+                    .getQueue()
+                    .then((newState) => {
                     const draftIdsToFilter = priorDraftIds ? priorDraftIds : [];
                     const newDrafts = newState.items;
                     const addedDrafts = newDrafts.filter((item) => {
@@ -137650,13 +138113,35 @@ function invokeAdapterWithDraftToMergeDeleteRecord(adapter, config, draftIdToRep
                     else {
                         draftManager
                             .replaceAction(draftIdToReplace, addedDrafts[0].id)
-                            .then(() => {
-                            onResponse(responseValue);
+                            .then((replacedDraft) => {
+                            if (metadata !== undefined) {
+                                // Spread the metadata returned by replaceAction
+                                // (not the pre-replace snapshot) so that keys the
+                                // replacement clears — notably retryCount — stay
+                                // cleared instead of being reintroduced here.
+                                draftManager
+                                    .setMetadata(draftIdToReplace, {
+                                    ...replacedDraft.metadata,
+                                    ...metadata,
+                                })
+                                    .then(() => {
+                                    onResponse(responseValue);
+                                })
+                                    .catch((error) => {
+                                    onResponse(convertErrorIntoNativeFetchError(error, 'Unable to set metadata on draft'));
+                                });
+                            }
+                            else {
+                                onResponse(responseValue);
+                            }
                         })
                             .catch((error) => {
                             onResponse(convertErrorIntoNativeFetchError(error, 'Unknown error replacing action'));
                         });
                     }
+                })
+                    .catch((error) => {
+                    onResponse(convertErrorIntoNativeFetchError(error, 'Unable to get draft queue'));
                 });
             }
             else {
@@ -137665,6 +138150,9 @@ function invokeAdapterWithDraftToMergeDeleteRecord(adapter, config, draftIdToRep
                 onResponse(response);
             }
         }, nativeAdapterRequestContext);
+    })
+        .catch((error) => {
+        onResponse(convertErrorIntoNativeFetchError(error, 'Unable to get draft queue'));
     });
 }
 function removeDraftNodeActionId(targetDraftId, responseValue) {
@@ -137894,7 +138382,7 @@ const callbacks$1 = [];
 function register(r) {
     callbacks$1.forEach((callback) => callback(r));
 }
-// version: 1.461.0-37b1c9d1cb
+// version: 1.463.0-ea9ecd17fc
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -139182,5 +139670,5 @@ class OneStoreAdapterModule {
 const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
-export { createPrimingSession, draftManager, draftQueue, evictCacheRecordsByIds, evictExpiredCacheEntries, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, importLuvioAdapterModule, importOneStoreAdapterModule, invokeAdapter, invokeAdapterWithDraftToMerge, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, stopEviction, subscribeToAdapter };
-// version: 1.461.0-37b1c9d1cb
+export { createPrimingSession, draftManager, draftQueue, evictCacheRecordsByIds, evictExpiredCacheEntries, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, importLuvioAdapterModule, importOneStoreAdapterModule, invokeAdapter, invokeAdapterWithDraftToMerge, invokeAdapterWithDraftToMergeAndMetadata, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, stopEviction, subscribeToAdapter };
+// version: 1.463.0-ea9ecd17fc