@salesforce/lds-worker-api 1.460.0 → 1.462.0

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

@@ -4282,7 +4282,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.460.0-f7dc7797dd
+    // version: 1.462.0-50d9a13ba4
 
     // 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.460.0-f7dc7797dd
+    // version: 1.462.0-50d9a13ba4
 
     function isSupportedEntity(_objectApiName) {
         return true;
@@ -32553,7 +32553,7 @@
         throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
         throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
     });
-    // version: 1.460.0-3e24f1bbff
+    // version: 1.462.0-2919385b97
 
     var draftQueueMaxRetryAttemptsGate = {
         isOpen: function (e) {
@@ -44185,24 +44185,6 @@
         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;
@@ -44221,15 +44203,6 @@
         },
     };
 
-    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;
@@ -45949,7 +45922,7 @@
         },
     };
 
-    var reviveOnlyRequestedFields = {
+    var isProduct2SerializedSideEffectKillSwitch = {
         isOpen: function (e) {
             return e.fallback;
         },
@@ -81470,6 +81443,35 @@
         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 {
@@ -81590,9 +81592,9 @@
             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;
             }
@@ -81673,8 +81675,15 @@
                     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);
                 }
@@ -92746,211 +92755,6 @@
         }
     }
 
-    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 {
         /**
          *
@@ -93443,16 +93247,7 @@
     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({
@@ -94105,6 +93900,38 @@
     }
 
     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;
@@ -94183,7 +94010,7 @@
             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
@@ -94680,6 +94507,58 @@
             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 = {
@@ -94714,6 +94593,7 @@
         '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
@@ -94878,14 +94758,181 @@
     }
 
     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',
         },
@@ -94896,7 +94943,7 @@
             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);
@@ -94909,7 +94956,7 @@
             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,
@@ -94926,16 +94973,17 @@
             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);
@@ -94946,13 +94994,13 @@
             }
             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,
@@ -94969,11 +95017,12 @@
             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);
@@ -94984,13 +95033,13 @@
             }
             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,
@@ -95001,13 +95050,115 @@
         }
     }
     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];
         }
-        return field;
     }
+    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];
+        }
+    }
+    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') {
@@ -95029,29 +95180,265 @@
         }
         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 [];
     }
@@ -97419,7 +97806,7 @@
             },
         };
     }
-    // version: 1.460.0-f7dc7797dd
+    // version: 1.462.0-50d9a13ba4
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -97445,7 +97832,7 @@
             },
         };
     }
-    // version: 1.460.0-f7dc7797dd
+    // version: 1.462.0-50d9a13ba4
 
     function findExecutableOperation$1(input) {
       const operations = input.query.definitions.filter(
@@ -99834,9 +100221,6 @@
 
     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() };
@@ -100023,12 +100407,6 @@
             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,
@@ -100036,7 +100414,12 @@
                 // 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);
@@ -100154,7 +100537,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$2,
     });
-    // version: 1.460.0-f7dc7797dd
+    // version: 1.462.0-50d9a13ba4
 
     const { create: create$2, keys: keys$2 } = Object;
     const { stringify, parse } = JSON;
@@ -107706,7 +108089,7 @@
             cb(graphql_v1_import, graphql_imperative$1, graphql_imperative_legacy_v1_import, graphql_state_manager, useOneStoreGraphQL);
         }
     }
-    // version: 1.460.0-3e24f1bbff
+    // version: 1.462.0-2919385b97
 
     function createFragmentMap(documentNode) {
         const fragments = {};
@@ -136949,7 +137332,7 @@
         configuration: { ...configurationForGraphQLAdapters$1 },
         instrument: instrument$1,
     });
-    // version: 1.460.0-3e24f1bbff
+    // version: 1.462.0-2919385b97
 
     // On core the unstable adapters are re-exported with different names,
     // we want to match them here.
@@ -137101,7 +137484,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.460.0-3e24f1bbff
+    // version: 1.462.0-2919385b97
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -137900,7 +138283,7 @@
     function register(r) {
         callbacks$1.forEach((callback) => callback(r));
     }
-    // version: 1.460.0-f7dc7797dd
+    // version: 1.462.0-50d9a13ba4
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -139210,4 +139593,4 @@
     exports.subscribeToAdapter = subscribeToAdapter;
 
 }));
-// version: 1.460.0-f7dc7797dd
+// version: 1.462.0-50d9a13ba4