@salesforce/lds-worker-api 1.134.3 → 1.134.4

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

@@ -3670,7 +3670,7 @@
             return this.environment.buildStructuredKey(namespace, representationName, idValues);
         }
     }
-    // engine version: 0.138.13-8fa39cd3
+    // engine version: 0.139.1-f7268217
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -3797,7 +3797,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.134.3-d4637e557
+    // version: 1.134.4-b3535d2e7
 
     // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
     function instrumentAdapter$1(createFunction, _metadata) {
@@ -15221,7 +15221,7 @@
         updateReferenceMapWithKnownKey(ast, luvioDocumentNode);
         return luvioDocumentNode;
     }
-    // version: 1.134.3-d4637e557
+    // version: 1.134.4-b3535d2e7
 
     function unwrap(data) {
         // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -16134,7 +16134,7 @@
         const { apiFamily, name } = metadata;
         return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
     }
-    // version: 1.134.3-d4637e557
+    // version: 1.134.4-b3535d2e7
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -16217,7 +16217,7 @@
     ({
         state: FragmentReadResultState.Missing,
     });
-    // engine version: 0.138.13-8fa39cd3
+    // engine version: 0.139.1-f7268217
 
     const { keys: ObjectKeys$3, freeze: ObjectFreeze$3, create: ObjectCreate$3 } = Object;
 
@@ -44434,7 +44434,7 @@
             dropFunction: instrumentation$2.notifyRecordUpdateAvailableDropped,
         });
     });
-    // version: 1.134.3-ea1008c6e
+    // version: 1.134.4-a74ddaa33
 
     var caseSensitiveUserId = '005B0000000GR4OIAW';
 
@@ -45088,10 +45088,8 @@
      * will refresh the snapshot from network, and then run the results from network
      * through L2 ingestion, returning the subsequent revived snapshot.
      */
-    function reviveSnapshot(baseEnvironment, durableStore, 
-    // TODO [W-10165787]: We should only allow Unfulfilled snapshot be passed in
-    unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics = { l2Trips: [] }) {
-        const { recordId, select, seenRecords, state } = unavailableSnapshot;
+    function reviveSnapshot(baseEnvironment, durableStore, unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics = { l2Trips: [] }) {
+        const { recordId, select, missingLinks, seenRecords, state } = unavailableSnapshot;
         // L2 can only revive Unfulfilled snapshots that have a selector since they have the
         // info needed to revive (like missingLinks) and rebuild.  Otherwise return L1 snapshot.
         if (state !== 'Unfulfilled' || select === undefined) {
@@ -45104,6 +45102,7 @@
         // we attempt to read all keys from L2 - so combine recordId with any seenRecords
         const keysToReviveSet = new StoreKeySet().add(recordId);
         keysToReviveSet.merge(seenRecords);
+        keysToReviveSet.merge(missingLinks);
         const keysToRevive = keysToReviveSet.keysAsArray();
         const canonicalKeys = keysToRevive.map((x) => serializeStructuredKey(baseEnvironment.storeGetCanonicalKey(x)));
         const start = Date.now();
@@ -45137,10 +45136,11 @@
             if (snapshot.state === 'Unfulfilled') {
                 // have to check if the new snapshot has any additional seenRecords
                 // and revive again if so
-                const { seenRecords: newSnapshotSeenRecords, recordId: newSnapshotRecordId } = snapshot;
+                const { seenRecords: newSnapshotSeenRecords, missingLinks: newSnapshotMissingLinks, recordId: newSnapshotRecordId, } = snapshot;
                 const newKeysToReviveSet = new StoreKeySet();
                 newKeysToReviveSet.add(newSnapshotRecordId);
                 newKeysToReviveSet.merge(newSnapshotSeenRecords);
+                newKeysToReviveSet.merge(newSnapshotMissingLinks);
                 const newKeys = newKeysToReviveSet.keysAsArray();
                 // in case DS returned additional entries we combine the requested
                 // and returned keys
@@ -60065,7 +60065,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$1,
     });
-    // version: 1.134.3-d4637e557
+    // version: 1.134.4-b3535d2e7
 
     const { create: create$2, keys: keys$2 } = Object;
     const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -60457,35 +60457,38 @@
             }
         }
     }
-    function selectType$H(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$H(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Double': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$H(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$G, getFieldType$11, selectType$H);
+    function buildSelectionForField$H(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$G, getFieldType$11, selectType$H, parentRecordId);
     }
-    function buildSelectionForNode$H(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$H, buildSelectionForField$H);
+    function buildSelectionForNode$H(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$H, buildSelectionForField$H, parentRecordId);
     }
     function select$Q(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$H(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$H(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -60616,35 +60619,38 @@
             }
         }
     }
-    function selectType$G(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$G(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Long': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$G(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$F, getFieldType$10, selectType$G);
+    function buildSelectionForField$G(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$F, getFieldType$10, selectType$G, parentRecordId);
     }
-    function buildSelectionForNode$G(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$G, buildSelectionForField$G);
+    function buildSelectionForNode$G(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$G, buildSelectionForField$G, parentRecordId);
     }
     function select$P(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$G(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$G(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -60775,35 +60781,38 @@
             }
         }
     }
-    function selectType$F(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$F(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Percent': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$F(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$E, getFieldType$$, selectType$F);
+    function buildSelectionForField$F(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$E, getFieldType$$, selectType$F, parentRecordId);
     }
-    function buildSelectionForNode$F(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$F, buildSelectionForField$F);
+    function buildSelectionForNode$F(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$F, buildSelectionForField$F, parentRecordId);
     }
     function select$O(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$F(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$F(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -61016,35 +61025,38 @@
             }
         }
     }
-    function selectType$E(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$E(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Int': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$E(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$D, getFieldType$Z, selectType$E);
+    function buildSelectionForField$E(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$D, getFieldType$Z, selectType$E, parentRecordId);
     }
-    function buildSelectionForNode$E(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$E, buildSelectionForField$E);
+    function buildSelectionForNode$E(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$E, buildSelectionForField$E, parentRecordId);
     }
     function select$N(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$E(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$E(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -61175,31 +61187,33 @@
             }
         }
     }
-    function selectType$D(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$D(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$D(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$C, getFieldType$Y, selectType$D);
+    function buildSelectionForField$D(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$C, getFieldType$Y, selectType$D, parentRecordId);
     }
-    function buildSelectionForNode$D(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$D, buildSelectionForField$D);
+    function buildSelectionForNode$D(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$D, buildSelectionForField$D, parentRecordId);
     }
     function select$M(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$D(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$D(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -61402,35 +61416,38 @@
             }
         }
     }
-    function selectType$C(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$C(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'ID': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$C(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$B, getFieldType$W, selectType$C);
+    function buildSelectionForField$C(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$B, getFieldType$W, selectType$C, parentRecordId);
     }
-    function buildSelectionForNode$C(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$C, buildSelectionForField$C);
+    function buildSelectionForNode$C(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$C, buildSelectionForField$C, parentRecordId);
     }
     function select$L(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$C(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$C(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -61555,35 +61572,38 @@
             }
         }
     }
-    function selectType$B(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$B(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'DateTime': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$B(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$A, getFieldType$V, selectType$B);
+    function buildSelectionForField$B(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$A, getFieldType$V, selectType$B, parentRecordId);
     }
-    function buildSelectionForNode$B(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$B, buildSelectionForField$B);
+    function buildSelectionForNode$B(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$B, buildSelectionForField$B, parentRecordId);
     }
     function select$K(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$B(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$B(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -61714,35 +61734,38 @@
             }
         }
     }
-    function selectType$A(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$A(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Boolean': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$A(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$z, getFieldType$U, selectType$A);
+    function buildSelectionForField$A(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$z, getFieldType$U, selectType$A, parentRecordId);
     }
-    function buildSelectionForNode$A(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$A, buildSelectionForField$A);
+    function buildSelectionForNode$A(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$A, buildSelectionForField$A, parentRecordId);
     }
     function select$J(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$A(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$A(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -61867,35 +61890,38 @@
             }
         }
     }
-    function selectType$z(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$z(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Time': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$z(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$y, getFieldType$T, selectType$z);
+    function buildSelectionForField$z(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$y, getFieldType$T, selectType$z, parentRecordId);
     }
-    function buildSelectionForNode$z(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$z, buildSelectionForField$z);
+    function buildSelectionForNode$z(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$z, buildSelectionForField$z, parentRecordId);
     }
     function select$I(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$z(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$z(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -62026,35 +62052,38 @@
             }
         }
     }
-    function selectType$y(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$y(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Date': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$y(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$x, getFieldType$S, selectType$y);
+    function buildSelectionForField$y(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$x, getFieldType$S, selectType$y, parentRecordId);
     }
-    function buildSelectionForNode$y(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$y, buildSelectionForField$y);
+    function buildSelectionForNode$y(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$y, buildSelectionForField$y, parentRecordId);
     }
     function select$H(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$y(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$y(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -62185,35 +62214,38 @@
             }
         }
     }
-    function selectType$x(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$x(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'TextArea': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$x(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$w, getFieldType$R, selectType$x);
+    function buildSelectionForField$x(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$w, getFieldType$R, selectType$x, parentRecordId);
     }
-    function buildSelectionForNode$x(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$x, buildSelectionForField$x);
+    function buildSelectionForNode$x(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$x, buildSelectionForField$x, parentRecordId);
     }
     function select$G(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$x(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$x(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -62338,35 +62370,38 @@
             }
         }
     }
-    function selectType$w(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$w(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'LongTextArea': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$w(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$v, getFieldType$Q, selectType$w);
+    function buildSelectionForField$w(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$v, getFieldType$Q, selectType$w, parentRecordId);
     }
-    function buildSelectionForNode$w(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$w, buildSelectionForField$w);
+    function buildSelectionForNode$w(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$w, buildSelectionForField$w, parentRecordId);
     }
     function select$F(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$w(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$w(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -62491,35 +62526,38 @@
             }
         }
     }
-    function selectType$v(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$v(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'RichTextArea': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$v(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$u, getFieldType$P, selectType$v);
+    function buildSelectionForField$v(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$u, getFieldType$P, selectType$v, parentRecordId);
     }
-    function buildSelectionForNode$v(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$v, buildSelectionForField$v);
+    function buildSelectionForNode$v(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$v, buildSelectionForField$v, parentRecordId);
     }
     function select$E(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$v(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$v(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -62644,35 +62682,38 @@
             }
         }
     }
-    function selectType$u(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$u(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'PhoneNumber': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$u(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$t, getFieldType$O, selectType$u);
+    function buildSelectionForField$u(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$t, getFieldType$O, selectType$u, parentRecordId);
     }
-    function buildSelectionForNode$u(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$u, buildSelectionForField$u);
+    function buildSelectionForNode$u(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$u, buildSelectionForField$u, parentRecordId);
     }
     function select$D(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$u(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$u(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -62797,35 +62838,38 @@
             }
         }
     }
-    function selectType$t(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$t(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Email': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$t(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$s, getFieldType$N, selectType$t);
+    function buildSelectionForField$t(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$s, getFieldType$N, selectType$t, parentRecordId);
     }
-    function buildSelectionForNode$t(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$t, buildSelectionForField$t);
+    function buildSelectionForNode$t(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$t, buildSelectionForField$t, parentRecordId);
     }
     function select$C(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$t(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$t(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -62950,35 +62994,38 @@
             }
         }
     }
-    function selectType$s(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$s(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Url': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$s(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$r, getFieldType$M, selectType$s);
+    function buildSelectionForField$s(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$r, getFieldType$M, selectType$s, parentRecordId);
     }
-    function buildSelectionForNode$s(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$s, buildSelectionForField$s);
+    function buildSelectionForNode$s(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$s, buildSelectionForField$s, parentRecordId);
     }
     function select$B(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$s(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$s(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -63103,35 +63150,38 @@
             }
         }
     }
-    function selectType$r(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$r(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'EncryptedString': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$r(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$q, getFieldType$L, selectType$r);
+    function buildSelectionForField$r(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$q, getFieldType$L, selectType$r, parentRecordId);
     }
-    function buildSelectionForNode$r(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$r, buildSelectionForField$r);
+    function buildSelectionForNode$r(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$r, buildSelectionForField$r, parentRecordId);
     }
     function select$A(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$r(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$r(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -63256,35 +63306,38 @@
             }
         }
     }
-    function selectType$q(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$q(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Currency': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$q(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$p, getFieldType$K, selectType$q);
+    function buildSelectionForField$q(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$p, getFieldType$K, selectType$q, parentRecordId);
     }
-    function buildSelectionForNode$q(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$q, buildSelectionForField$q);
+    function buildSelectionForNode$q(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$q, buildSelectionForField$q, parentRecordId);
     }
     function select$z(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$q(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$q(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -63415,35 +63468,38 @@
             }
         }
     }
-    function selectType$p(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$p(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Longitude': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$p(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$o, getFieldType$J, selectType$p);
+    function buildSelectionForField$p(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$o, getFieldType$J, selectType$p, parentRecordId);
     }
-    function buildSelectionForNode$p(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$p, buildSelectionForField$p);
+    function buildSelectionForNode$p(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$p, buildSelectionForField$p, parentRecordId);
     }
     function select$y(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$p(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$p(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -63568,35 +63624,38 @@
             }
         }
     }
-    function selectType$o(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$o(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Latitude': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$o(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$n, getFieldType$I, selectType$o);
+    function buildSelectionForField$o(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$n, getFieldType$I, selectType$o, parentRecordId);
     }
-    function buildSelectionForNode$o(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$o, buildSelectionForField$o);
+    function buildSelectionForNode$o(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$o, buildSelectionForField$o, parentRecordId);
     }
     function select$x(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$o(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$o(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -63721,35 +63780,38 @@
             }
         }
     }
-    function selectType$n(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$n(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Picklist': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$n(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$m, getFieldType$H, selectType$n);
+    function buildSelectionForField$n(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$m, getFieldType$H, selectType$n, parentRecordId);
     }
-    function buildSelectionForNode$n(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$n, buildSelectionForField$n);
+    function buildSelectionForNode$n(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$n, buildSelectionForField$n, parentRecordId);
     }
     function select$w(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$n(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$n(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -63880,35 +63942,38 @@
             }
         }
     }
-    function selectType$m(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$m(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'MultiPicklist': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$m(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$l, getFieldType$G, selectType$m);
+    function buildSelectionForField$m(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$l, getFieldType$G, selectType$m, parentRecordId);
     }
-    function buildSelectionForNode$m(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$m, buildSelectionForField$m);
+    function buildSelectionForNode$m(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$m, buildSelectionForField$m, parentRecordId);
     }
     function select$v(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$m(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$m(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -64039,35 +64104,38 @@
             }
         }
     }
-    function selectType$l(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$l(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Base64': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$l(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$k, getFieldType$F, selectType$l);
+    function buildSelectionForField$l(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$k, getFieldType$F, selectType$l, parentRecordId);
     }
-    function buildSelectionForNode$l(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$l, buildSelectionForField$l);
+    function buildSelectionForNode$l(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$l, buildSelectionForField$l, parentRecordId);
     }
     function select$u(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$l(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$l(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -64192,35 +64260,38 @@
             }
         }
     }
-    function selectType$k(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$k(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'JSON': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$k(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$j, getFieldType$E, selectType$k);
+    function buildSelectionForField$k(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$j, getFieldType$E, selectType$k, parentRecordId);
     }
-    function buildSelectionForNode$k(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$k, buildSelectionForField$k);
+    function buildSelectionForNode$k(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$k, buildSelectionForField$k, parentRecordId);
     }
     function select$t(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$k(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$k(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -64313,10 +64384,10 @@
         }
     }
     function select$s(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             const typename = source.data.__typename;
             if (typename === 'RecordRepresentation') {
-                return select$q(field, variables, fragments)(source, reader);
+                return select$q(field, variables, fragments)(source, reader, parentRecordId);
             }
         };
     }
@@ -64942,8 +65013,9 @@
         }
     }
 
-    function selectType$j(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$j(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
@@ -64951,83 +65023,84 @@
             case 'Long':
             case 'ID':
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             // All fields which extend FieldValue, and no other special fields (format etc)
             case 'BooleanValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$J, typename, false, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$J, typename, false, false, parentRecordId);
                 break;
             case 'LongitudeValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$y, typename, false, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$y, typename, false, false, parentRecordId);
                 break;
             case 'UrlValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$B, typename, false, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$B, typename, false, false, parentRecordId);
                 break;
             case 'RichTextAreaValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$E, typename, false, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$E, typename, false, false, parentRecordId);
                 break;
             case 'LongTextAreaValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$F, typename, false, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$F, typename, false, false, parentRecordId);
                 break;
             case 'LatitudeValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$x, typename, false, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$x, typename, false, false, parentRecordId);
                 break;
             case 'PhoneNumberValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$D, typename, false, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$D, typename, false, false, parentRecordId);
                 break;
             case 'TextAreaValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$G, typename, false, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$G, typename, false, false, parentRecordId);
                 break;
             case 'IDValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$L, typename, false, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$L, typename, false, false, parentRecordId);
                 break;
             case 'JSONValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$t, typename, false, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$t, typename, false, false, parentRecordId);
                 break;
             case 'EmailValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$C, typename, false, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$C, typename, false, false, parentRecordId);
                 break;
             case 'Base64Value':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$u, typename, false, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$u, typename, false, false, parentRecordId);
                 break;
             case 'EncryptedStringValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$A, typename, false, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$A, typename, false, false, parentRecordId);
                 break;
             // All field values which support 'label'
             case 'StringValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$M, typename, false, true);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$M, typename, false, true, parentRecordId);
                 break;
             case 'PicklistValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$w, typename, false, true);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$w, typename, false, true, parentRecordId);
                 break;
             case 'MultiPicklistValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$v, typename, false, true);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$v, typename, false, true, parentRecordId);
                 break;
             // All field values that support "format" field.
             case 'IntValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$N, typename, true, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$N, typename, true, false, parentRecordId);
                 break;
             case 'DateValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$H, typename, true, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$H, typename, true, false, parentRecordId);
                 break;
             case 'DoubleValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$Q, typename, true, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$Q, typename, true, false, parentRecordId);
                 break;
             case 'TimeValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$I, typename, true, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$I, typename, true, false, parentRecordId);
                 break;
             case 'DateTimeValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$K, typename, true, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$K, typename, true, false, parentRecordId);
                 break;
             case 'LongValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$P, typename, true, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$P, typename, true, false, parentRecordId);
                 break;
             case 'PercentValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$O, typename, true, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$O, typename, true, false, parentRecordId);
                 break;
             case 'CurrencyValue':
-                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$z, typename, true, false);
+                selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, select$z, typename, true, false, parentRecordId);
                 break;
             case 'PolymorphicParentRelationship':
             case 'RecordRepresentation': {
@@ -65057,7 +65130,7 @@
                         },
                         __link: spanningFieldResult,
                     };
-                    const result = select$q(sel, variables, fragments)(syntheticNormalizedGraphQLRecord, reader);
+                    const result = select$q(sel, variables, fragments)(syntheticNormalizedGraphQLRecord, reader, parentRecordId);
                     if (result) {
                         reader.assignNonScalar(sink, key, result);
                     }
@@ -65073,15 +65146,15 @@
                 break;
             }
             case 'RecordConnection':
-                selectType$h(typename, sel, fieldData, reader, key, sink, variables, fragments); // No need to copy paste this case (lots of pagination code).
+                selectType$h(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId); // No need to copy paste this case (lots of pagination code).
                 break;
         }
         return sink;
     }
-    function selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, selectFunction, __typename, hasFormat, hasLabel) {
+    function selectFieldValue(reader, fieldData, sel, variables, fragments, sink, key, selectFunction, __typename, hasFormat, hasLabel, parentRecordId) {
         const gqlFieldValue = readFieldValueAndConvertToGQL(reader, fieldData, hasFormat, hasLabel, __typename);
         if (gqlFieldValue !== undefined) {
-            const result = selectFunction(sel, variables, fragments)({ data: gqlFieldValue }, reader);
+            const result = selectFunction(sel, variables, fragments)({ data: gqlFieldValue }, reader, parentRecordId);
             reader.assignNonScalar(sink, key, result);
         }
         else {
@@ -65204,35 +65277,38 @@
             }
         }
     }
-    function selectType$i(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$i(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Boolean': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$j(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$h, getFieldType$B, selectType$i);
+    function buildSelectionForField$j(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$h, getFieldType$B, selectType$i, parentRecordId);
     }
-    function buildSelectionForNode$j(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$j, buildSelectionForField$j);
+    function buildSelectionForNode$j(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$j, buildSelectionForField$j, parentRecordId);
     }
     function select$r(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$j(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$j(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -65422,21 +65498,25 @@
             },
         });
     }
-    function selectType$h(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$h(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'ID': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Long': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
@@ -65551,19 +65631,20 @@
         }
         return sink;
     }
-    function buildSelectionForField$i(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$i, getFieldType$C, selectType$j);
+    function buildSelectionForField$i(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$i, getFieldType$C, selectType$j, parentRecordId);
     }
-    function buildSelectionForNode$i(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$i, buildSelectionForField$i);
+    function buildSelectionForNode$i(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$i, buildSelectionForField$i, parentRecordId);
     }
     function select$q(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             source = attachMappedData(source, reader);
+            reader.markSeenId(parentRecordId); // Always mark identifiable types as seen
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$i(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$i(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -66432,13 +66513,15 @@
             }
         }
     }
-    function selectType$g(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$g(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
@@ -66449,18 +66532,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$h(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$g, getFieldType$A, selectType$g);
+    function buildSelectionForField$h(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$g, getFieldType$A, selectType$g, parentRecordId);
     }
-    function buildSelectionForNode$h(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$h, buildSelectionForField$h);
+    function buildSelectionForNode$h(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$h, buildSelectionForField$h, parentRecordId);
     }
     function select$p(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$h(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$h(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -66687,13 +66770,15 @@
             }
         }
     }
-    function selectType$f(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$f(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
@@ -66706,24 +66791,25 @@
                 break;
             }
             case 'Int': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$g(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, true, getFieldData$f, getFieldType$z, selectType$f);
+    function buildSelectionForField$g(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, true, getFieldData$f, getFieldType$z, selectType$f, parentRecordId);
     }
-    function buildSelectionForNode$g(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$g, buildSelectionForField$g);
+    function buildSelectionForNode$g(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$g, buildSelectionForField$g, parentRecordId);
     }
     function select$o(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$g(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$g(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -66901,13 +66987,15 @@
             }
         }
     }
-    function selectType$e(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$e(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
@@ -66918,18 +67006,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$f(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$e, getFieldType$y, selectType$e);
+    function buildSelectionForField$f(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$e, getFieldType$y, selectType$e, parentRecordId);
     }
-    function buildSelectionForNode$f(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$f, buildSelectionForField$f);
+    function buildSelectionForNode$f(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$f, buildSelectionForField$f, parentRecordId);
     }
     function select$n(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$f(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$f(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -67079,13 +67167,15 @@
             }
         }
     }
-    function selectType$d(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$d(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
@@ -67096,18 +67186,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$e(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$d, getFieldType$x, selectType$d);
+    function buildSelectionForField$e(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$d, getFieldType$x, selectType$d, parentRecordId);
     }
-    function buildSelectionForNode$e(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$e, buildSelectionForField$e);
+    function buildSelectionForNode$e(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$e, buildSelectionForField$e, parentRecordId);
     }
     function select$m(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$e(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$e(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -67305,31 +67395,33 @@
             }
         }
     }
-    function selectType$c(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$c(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$d(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$c, getFieldType$w, selectType$c);
+    function buildSelectionForField$d(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$c, getFieldType$w, selectType$c, parentRecordId);
     }
-    function buildSelectionForNode$d(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$d, buildSelectionForField$d);
+    function buildSelectionForNode$d(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$d, buildSelectionForField$d, parentRecordId);
     }
     function select$l(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$d(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$d(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -67462,35 +67554,38 @@
             }
         }
     }
-    function selectType$b(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$b(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Boolean': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$c(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$b, getFieldType$v, selectType$b);
+    function buildSelectionForField$c(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$b, getFieldType$v, selectType$b, parentRecordId);
     }
-    function buildSelectionForNode$c(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$c, buildSelectionForField$c);
+    function buildSelectionForNode$c(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$c, buildSelectionForField$c, parentRecordId);
     }
     function select$k(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$c(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$c(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -67633,13 +67728,15 @@
             }
         }
     }
-    function selectType$a(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$a(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
@@ -67650,18 +67747,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$b(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$a, getFieldType$u, selectType$a);
+    function buildSelectionForField$b(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$a, getFieldType$u, selectType$a, parentRecordId);
     }
-    function buildSelectionForNode$b(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$b, buildSelectionForField$b);
+    function buildSelectionForNode$b(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$b, buildSelectionForField$b, parentRecordId);
     }
     function select$j(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$b(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$b(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -67841,25 +67938,30 @@
             }
         }
     }
-    function selectType$9(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$9(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Boolean': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'DataType': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'FieldExtraTypeInfo': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
@@ -67868,6 +67970,7 @@
                 break;
             }
             case 'Int': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
@@ -67878,18 +67981,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$a(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$9, getFieldType$t, selectType$9);
+    function buildSelectionForField$a(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$9, getFieldType$t, selectType$9, parentRecordId);
     }
-    function buildSelectionForNode$a(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$a, buildSelectionForField$a);
+    function buildSelectionForNode$a(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$a, buildSelectionForField$a, parentRecordId);
     }
     function select$i(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$a(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$a(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -68271,39 +68374,43 @@
             }
         }
     }
-    function selectType$8(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$8(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Boolean': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'ID': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$9(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$8, getFieldType$s, selectType$8);
+    function buildSelectionForField$9(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$8, getFieldType$s, selectType$8, parentRecordId);
     }
-    function buildSelectionForNode$9(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$9, buildSelectionForField$9);
+    function buildSelectionForNode$9(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$9, buildSelectionForField$9, parentRecordId);
     }
     function select$h(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$9(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$9(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -68462,31 +68569,33 @@
             }
         }
     }
-    function selectType$7(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$7(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$8(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$7, getFieldType$r, selectType$7);
+    function buildSelectionForField$8(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$7, getFieldType$r, selectType$7, parentRecordId);
     }
-    function buildSelectionForNode$8(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$8, buildSelectionForField$8);
+    function buildSelectionForNode$8(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$8, buildSelectionForField$8, parentRecordId);
     }
     function select$g(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$8(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$8(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -68620,13 +68729,15 @@
             }
         }
     }
-    function selectType$6(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$6(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
@@ -68635,10 +68746,12 @@
                 break;
             }
             case 'Boolean': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'ID': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
@@ -68661,18 +68774,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$7(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$6, getFieldType$q, selectType$6);
+    function buildSelectionForField$7(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$6, getFieldType$q, selectType$6, parentRecordId);
     }
-    function buildSelectionForNode$7(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$7, buildSelectionForField$7);
+    function buildSelectionForNode$7(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$7, buildSelectionForField$7, parentRecordId);
     }
     function select$f(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$7(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$7(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -69082,35 +69195,38 @@
             }
         }
     }
-    function selectType$5(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$5(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Boolean': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$6(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$5, getFieldType$p, selectType$5);
+    function buildSelectionForField$6(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$5, getFieldType$p, selectType$5, parentRecordId);
     }
-    function buildSelectionForNode$6(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$6, buildSelectionForField$6);
+    function buildSelectionForNode$6(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$6, buildSelectionForField$6, parentRecordId);
     }
     function select$e(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$6(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$6(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -69259,35 +69375,38 @@
             }
         }
     }
-    function selectType$4(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$4(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'ResultOrder': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$5(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$4, getFieldType$o, selectType$4);
+    function buildSelectionForField$5(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$4, getFieldType$o, selectType$4, parentRecordId);
     }
-    function buildSelectionForNode$5(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$5, buildSelectionForField$5);
+    function buildSelectionForNode$5(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$5, buildSelectionForField$5, parentRecordId);
     }
     function select$d(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$5(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$5(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -69425,13 +69544,15 @@
             }
         }
     }
-    function selectType$3(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$3(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
@@ -69446,18 +69567,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$4(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$3, getFieldType$n, selectType$3);
+    function buildSelectionForField$4(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$3, getFieldType$n, selectType$3, parentRecordId);
     }
-    function buildSelectionForNode$4(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$4, buildSelectionForField$4);
+    function buildSelectionForNode$4(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$4, buildSelectionForField$4, parentRecordId);
     }
     function select$c(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$4(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$4(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -69695,13 +69816,15 @@
             }
         }
     }
-    function selectType$2(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$2(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
@@ -69720,18 +69843,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$3(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$2, getFieldType$m, selectType$2);
+    function buildSelectionForField$3(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$2, getFieldType$m, selectType$2, parentRecordId);
     }
-    function buildSelectionForNode$3(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$3, buildSelectionForField$3);
+    function buildSelectionForNode$3(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$3, buildSelectionForField$3, parentRecordId);
     }
     function select$b(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$3(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$3(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -69967,39 +70090,43 @@
             }
         }
     }
-    function selectType$1(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType$1(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'Long': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
             case 'DateTime': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
         }
         return sink;
     }
-    function buildSelectionForField$2(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$1, getFieldType$l, selectType$1);
+    function buildSelectionForField$2(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData$1, getFieldType$l, selectType$1, parentRecordId);
     }
-    function buildSelectionForNode$2(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$2, buildSelectionForField$2);
+    function buildSelectionForNode$2(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$2, buildSelectionForField$2, parentRecordId);
     }
     function select$a(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$2(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$2(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -70152,13 +70279,15 @@
             }
         }
     }
-    function selectType(typename, sel, fieldData, reader, key, sink, variables, fragments) {
+    function selectType(typename, sel, fieldData, reader, key, sink, variables, fragments, parentRecordId) {
         if (fieldData === null) {
+            reader.markSeenId(parentRecordId);
             reader.assignScalar(key, sink, fieldData);
             return sink;
         }
         switch (typename) {
             case 'String': {
+                reader.markSeenId(parentRecordId);
                 reader.assignScalar(key, sink, fieldData);
                 break;
             }
@@ -70173,18 +70302,18 @@
         }
         return sink;
     }
-    function buildSelectionForField$1(source, reader, sel, variables, fragments) {
-        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData, getFieldType$k, selectType);
+    function buildSelectionForField$1(source, reader, sel, variables, fragments, parentRecordId) {
+        return buildSelectionForField(source, reader, sel, variables, fragments, false, getFieldData, getFieldType$k, selectType, parentRecordId);
     }
-    function buildSelectionForNode$1(source, reader, parentNode, selectionNode, variables, fragments) {
-        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$1, buildSelectionForField$1);
+    function buildSelectionForNode$1(source, reader, parentNode, selectionNode, variables, fragments, parentRecordId) {
+        return buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable$1, buildSelectionForField$1, parentRecordId);
     }
     function select$9(field, variables, fragments) {
-        return (source, reader) => {
+        return (source, reader, parentRecordId) => {
             var _a;
             const sink = {};
             (_a = field.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.forEach((sel) => {
-                const builtSelection = buildSelectionForNode$1(source, reader, field, sel, variables, fragments);
+                const builtSelection = buildSelectionForNode$1(source, reader, field, sel, variables, fragments, parentRecordId);
                 if (builtSelection !== undefined) {
                     if (sel.kind === "InlineFragment" || sel.kind === "FragmentSpread") {
                         Object.keys(builtSelection).forEach((key, value) => {
@@ -72820,7 +72949,7 @@
         const typenameMatchesCondition = typename !== undefined && !isUntypedInlineFragment && typename === fragmentNode.typeCondition.name.value;
         return isUntypedInlineFragment || matchesTypeCondition || doesImplementInterface || typenameMatchesCondition;
     }
-    function buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable, buildSelectionForField) {
+    function buildSelectionForNode(source, reader, parentNode, selectionNode, variables, fragments, isFragmentApplicable, buildSelectionForField, parentRecordId) {
         const sink = {};
         if (selectionNode.directives) {
             const selectionWithDirectives = applyDirectivesForSelection(selectionNode, variables);
@@ -72834,7 +72963,7 @@
                 // Get selections out of the inline fragment
                 selectionNode.selectionSet.selections.forEach(fragmentSelection => {
                     // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode(source, reader, parentNode, fragmentSelection, variables, fragments, isFragmentApplicable, buildSelectionForField));
+                    Object.assign(sink, buildSelectionForNode(source, reader, parentNode, fragmentSelection, variables, fragments, isFragmentApplicable, buildSelectionForField, parentRecordId));
                 });
             }
         }
@@ -72843,16 +72972,16 @@
             if (namedFragment && isFragmentApplicable(namedFragment, source.data.__typename)) {
                 namedFragment.selectionSet.selections.forEach(fragmentSelection => {
                     // Call into field handling with selections
-                    Object.assign(sink, buildSelectionForNode(source, reader, parentNode, fragmentSelection, variables, fragments, isFragmentApplicable, buildSelectionForField));
+                    Object.assign(sink, buildSelectionForNode(source, reader, parentNode, fragmentSelection, variables, fragments, isFragmentApplicable, buildSelectionForField, parentRecordId));
                 });
             }
         }
         if (selectionNode.kind === "Field") {
-            Object.assign(sink, buildSelectionForField(source, reader, selectionNode, variables, fragments));
+            Object.assign(sink, buildSelectionForField(source, reader, selectionNode, variables, fragments, parentRecordId));
         }
         return sink;
     }
-    function buildSelectionForField(source, reader, sel, variables, fragments, isCursorConnectionType, getFieldData, getFieldType, selectType) {
+    function buildSelectionForField(source, reader, sel, variables, fragments, isCursorConnectionType, getFieldData, getFieldType, selectType, parentRecordId) {
         const sink = {};
         const fieldData = getFieldData(source, sel, variables);
         const requestedFieldName = sel.alias ? sel.alias.value : sel.name.value;
@@ -72877,15 +73006,16 @@
         }
         else if (fieldType.isArray) {
             const arraySink = [];
+            reader.markSeenId(parentRecordId); // Always mark the parent of an array as seen.
             for (let i = 0, len = fieldData.length; i < len; i += 1) {
                 reader.enterPath(i);
-                selectType(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments);
+                selectType(fieldType.typename, sel, fieldData[i], reader, i, arraySink, variables, fragments, parentRecordId);
                 reader.exitPath();
             }
             reader.assignNonScalar(sink, requestedFieldName, arraySink);
         }
         else {
-            selectType(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments);
+            selectType(fieldType.typename, sel, fieldData, reader, requestedFieldName, sink, variables, fragments, parentRecordId);
         }
         reader.exitPath();
         return sink;
@@ -72901,13 +73031,12 @@
             },
             variables: {}
         });
-        reader.markSeenId(fieldData.__ref);
         if (resolvedLink.data !== undefined) {
             if (isCursorConnection) {
                 selectTypeLinkWithPagination(resolvedLink, sel, fieldData, reader, key, sink, variables, fragments, selectFn);
             }
             else {
-                const result = selectFn(sel, variables, fragments)(resolvedLink.data, reader);
+                const result = selectFn(sel, variables, fragments)(resolvedLink.data, reader, resolvedLink.recordId);
                 reader.assignNonScalar(sink, key, result);
             }
         }
@@ -72938,6 +73067,7 @@
     function selectTypeLinkWithPagination(resolvedLink, sel, fieldData, reader, key, sink, variables, fragments, selectFn) {
         var _a, _b, _c, _d, _e;
         const source = resolvedLink.data.data;
+        const parentRecordId = resolvedLink.recordId;
         const totalEdges = source.edges !== undefined ? source.edges.length : 0;
         const metadata = reader.resolveMetadata(source, PAGINATION_VERSION);
         const firstArg = (_a = sel.arguments) === null || _a === void 0 ? void 0 : _a.find(argument => { return argument.name.value === 'first'; });
@@ -73006,7 +73136,8 @@
                 edges: ObjectFreeze(trimmedEdges),
             }
         };
-        const result = selectFn(sel, variables, fragments)(paginatedData, reader);
+        reader.markSeenId(parentRecordId);
+        const result = selectFn(sel, variables, fragments)(paginatedData, reader, parentRecordId);
         const pageInfo = createPageInfo(result === null || result === void 0 ? void 0 : result.edges, startOffset, endOffset, maxOffset, metadata);
         if (pageInfo !== undefined) {
             const selectedPageInfo = selectPageInfo((_e = sel.selectionSet) === null || _e === void 0 ? void 0 : _e.selections, fragments, pageInfo);
@@ -73073,8 +73204,9 @@
                 for (let i = 0, len = definitions.length; i < len; i += 1) {
                     const def = definitions[i];
                     if (def.kind === 'OperationDefinition') {
+                        const parentRecordId = keyBuilderFromType();
                         const snapshot = builder.read({
-                            recordId: keyBuilderFromType(),
+                            recordId: parentRecordId,
                             node: {
                                 kind: 'Fragment',
                                 private: [],
@@ -73086,7 +73218,7 @@
                         if (snapshot.data === undefined) {
                             return {};
                         }
-                        const data = select$9(def, variables, fragments)(snapshot.data, builder);
+                        const data = select$9(def, variables, fragments)(snapshot.data, builder, parentRecordId);
                         sink = {
                             ...sink,
                             ...data,
@@ -74373,7 +74505,7 @@
         configuration: { ...configurationForGraphQLAdapters },
         instrument,
     });
-    // version: 1.134.3-ea1008c6e
+    // version: 1.134.4-a74ddaa33
 
     // On core the unstable adapters are re-exported with different names,
 
@@ -76502,7 +76634,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.134.3-ea1008c6e
+    // version: 1.134.4-a74ddaa33
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -77211,4 +77343,4 @@
     Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
-// version: 1.134.3-d4637e557
+// version: 1.134.4-b3535d2e7