@salesforce/lds-runtime-mobile 1.460.0 → 1.462.0

package/sfdc/main.js

@@ -43,17 +43,14 @@ import shortTimeFormat from '@salesforce/i18n/dateTime.shortTimeFormat';
 import shortDateTimeFormat from '@salesforce/i18n/dateTime.shortDateTimeFormat';
 import { getDateTimeFormat, getDateTimeISO8601Parser, getNumberFormat } from 'lightning/i18nService';
 import formattingOptions from 'lightning/i18nCldrOptions';
-import ldsPrimingGraphqlBatch from '@salesforce/gate/lds.primingGraphqlBatch';
-import lmrPrimingUseSoql from '@salesforce/gate/lmr.primingUseSoql';
 import aggressiveTrimCountKillSwitchGate from '@salesforce/gate/lmr.disableAggresiveTrimCountChange';
 import graphqlL2AdapterGate from '@salesforce/gate/lmr.graphqlL2Adapter';
-import useOneStore from '@salesforce/gate/lmr.useOneStore';
 import { setServices } from 'force/luvioServiceProvisioner1';
 import 'force/luvioTypeNormalization1';
 import { Kind as Kind$2, visit as visit$2, print as print$1, resolveAndValidateGraphQLConfig, toGraphQLErrorResponse } from 'force/luvioOnestoreGraphqlParser';
 import draftQueueSideEffectMapGate from '@salesforce/gate/lmr.draft-queue-sideeffect-map';
 import productConsumedSideEffects from '@salesforce/gate/com.salesforce.fieldservice.vanStockLDSBypass256';
-import reviveOnlyRequestedFields from '@salesforce/gate/lmr.reviveOnlyRequestedFields';
+import isProduct2SerializedSideEffectKillSwitch from '@salesforce/gate/com.salesforce.fieldservice.productConsumedSideEffectsKillSwitch';
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -43595,6 +43592,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 {
@@ -43715,9 +43741,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;
         }
@@ -43798,8 +43824,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);
             }
@@ -55004,211 +55037,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 {
     /**
      *
@@ -55701,16 +55529,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({
@@ -56384,6 +56203,38 @@ function buildCachedSnapshotCachePolicy(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;
@@ -56462,7 +56313,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
@@ -56959,6 +56810,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 = {
@@ -56993,6 +56896,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
@@ -57157,14 +57061,181 @@ function isStoreRecordError(storeRecord) {
 }
 
 const instrumentation = getInstrumentation(O11Y_NAMESPACE_LDS_MOBILE);
+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.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(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(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.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',
     },
@@ -57175,7 +57246,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);
@@ -57188,7 +57259,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(productItemId),
             tag: draftActionId,
@@ -57205,16 +57276,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(draftRecordId));
+        const recordReader = reader ?? this.durableRecordStore;
+        const originalRecord = await recordReader.getRecord(buildRecordRepKeyFromId(draftRecordId));
         if (originalRecord === undefined) {
             incrementCounter(ProductConsumedUpdatedHook.COUNTER_NAME, CounterResult.Error);
-            instrumentation.error(`SFS - ProductConsumedUpdatedHook - Original record ${draftRecordId} not found`);
+            instrumentation.error(`SFS - ProductConsumedUpdatedHook original record not found: draftRecordId=${draftRecordId}`);
             return [];
         }
         const originalProductItemId = getProductItemIdFromRecordFields(originalRecord.fields);
@@ -57225,13 +57297,13 @@ class ProductConsumedUpdatedHook {
         }
         if (originalQuantityConsumed === undefined) {
             incrementCounter(ProductConsumedUpdatedHook.COUNTER_NAME, CounterResult.Error);
-            instrumentation.error(`SFS - ProductConsumedUpdatedHook - Original record ${draftRecordId} QuantityConsumed not found`);
+            instrumentation.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(originalProductItemId),
             tag: draftActionId,
@@ -57248,11 +57320,12 @@ class ProductConsumedDeletedHook {
         this.on = 'delete';
         this.apiName = ProductConsumed.API_NAME;
     }
-    async then(draftActionId, draftActionTimestamp, draftRecordId) {
-        const originalRecord = await this.durableRecordStore.getRecord(buildRecordRepKeyFromId(draftRecordId));
+    async then(draftActionId, draftActionTimestamp, draftRecordId, _fields, reader) {
+        const recordReader = reader ?? this.durableRecordStore;
+        const originalRecord = await recordReader.getRecord(buildRecordRepKeyFromId(draftRecordId));
         if (originalRecord === undefined) {
             incrementCounter(ProductConsumedDeletedHook.COUNTER_NAME, CounterResult.Error);
-            instrumentation.error(`SFS - ProductConsumedDeletedHook - Original record ${draftRecordId} not found`);
+            instrumentation.error(`SFS - ProductConsumedDeletedHook original record not found: draftRecordId=${draftRecordId}`);
             return [];
         }
         const productItemId = getProductItemIdFromRecordFields(originalRecord.fields);
@@ -57263,13 +57336,13 @@ class ProductConsumedDeletedHook {
         }
         if (quantityConsumed === undefined) {
             incrementCounter(ProductConsumedDeletedHook.COUNTER_NAME, CounterResult.Error);
-            instrumentation.error(`SFS - ProductConsumedDeletedHook - Original record ${draftRecordId} QuantityConsumed not found`);
+            instrumentation.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(productItemId),
             tag: draftActionId,
@@ -57280,13 +57353,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(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(draftRecordId));
+        if (originalRecord === undefined) {
+            incrementCounter(ProductConsumedIsSerializedUpdatedHook.COUNTER_NAME, CounterResult.Error);
+            instrumentation.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(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') {
@@ -57308,29 +57483,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.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(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(draftRecordId));
+        if (originalRecord === undefined) {
+            incrementCounter(ProductTransferIsSerializedUpdatedHook.COUNTER_NAME, CounterResult.Error);
+            instrumentation.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(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(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(draftRecordId));
+        if (originalRecord === undefined) {
+            incrementCounter(ProductItemIsSerializedUpdatedHook.COUNTER_NAME, CounterResult.Error);
+            instrumentation.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(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 [];
 }
@@ -59715,7 +60126,7 @@ function buildServiceDescriptor$b(luvio) {
         },
     };
 }
-// version: 1.460.0-f7dc7797dd
+// version: 1.462.0-50d9a13ba4
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -59741,7 +60152,7 @@ function buildServiceDescriptor$a(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.460.0-f7dc7797dd
+// version: 1.462.0-50d9a13ba4
 
 function findExecutableOperation(input) {
   const operations = input.query.definitions.filter(
@@ -62130,9 +62541,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() };
@@ -62319,12 +62727,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,
@@ -62332,7 +62734,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);
@@ -62453,4 +62860,4 @@ register({
 });
 
 export { O11Y_NAMESPACE_LDS_MOBILE, getRuntime, ingest$1o as ingestDenormalizedRecordRepresentation, initializeOneStore, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.460.0-f7dc7797dd
+// version: 1.462.0-50d9a13ba4