@isograph/react 0.4.3 → 0.5.1

package/dist/core/makeNetworkRequest.mjs

@@ -0,0 +1,195 @@
+import { wrapPromise, wrapResolvedValue } from "./PromiseWrapper.mjs";
+import { ROOT_ID } from "./IsographEnvironment.mjs";
+import { logMessage } from "./logging.mjs";
+import { getOrCreateCachedStartUpdate } from "./startUpdate.mjs";
+import { getOrCreateCachedComponent } from "./componentCache.mjs";
+import { DEFAULT_SHOULD_FETCH_VALUE, check } from "./check.mjs";
+import { readButDoNotEvaluate } from "./read.mjs";
+import { callSubscriptions } from "./subscribe.mjs";
+import { addNetworkResponseStoreLayer, addOptimisticNetworkResponseStoreLayer, revertOptimisticStoreLayerAndMaybeReplace } from "./optimisticProxy.mjs";
+import { normalizeData } from "./cache.mjs";
+import { garbageCollectEnvironment, retainQuery, unretainQuery } from "./garbageCollection.mjs";
+
+//#region src/core/makeNetworkRequest.ts
+let networkRequestId = 0;
+function maybeMakeNetworkRequest(environment, artifact, variables, readerWithRefetchQueries, fetchOptions) {
+	switch (fetchOptions?.shouldFetch ?? DEFAULT_SHOULD_FETCH_VALUE) {
+		case "Yes": return makeNetworkRequest(environment, artifact, variables, readerWithRefetchQueries, fetchOptions);
+		case "No": return retainQueryWithoutMakingNetworkRequest(environment, artifact, variables);
+		case "IfNecessary":
+			if (artifact.networkRequestInfo.normalizationAst.kind === "NormalizationAstLoader") throw new Error("Using lazy loaded normalizationAst with shouldFetch: \"IfNecessary\" is not supported as it will lead to a network waterfall.");
+			if (check(environment, artifact.networkRequestInfo.normalizationAst.selections, variables, {
+				__link: ROOT_ID,
+				__typename: artifact.concreteType
+			}).kind === "EnoughData") return retainQueryWithoutMakingNetworkRequest(environment, artifact, variables);
+			else return makeNetworkRequest(environment, artifact, variables, readerWithRefetchQueries, fetchOptions);
+	}
+}
+function retainQueryWithoutMakingNetworkRequest(environment, artifact, variables) {
+	let status = {
+		kind: "UndisposedComplete",
+		retainedQuery: fetchNormalizationAstAndRetainArtifact(environment, artifact, variables)
+	};
+	return [wrapResolvedValue(void 0), () => {
+		if (status.kind !== "Disposed") status = unretainAndGarbageCollect(environment, status);
+	}];
+}
+function makeNetworkRequest(environment, artifact, variables, readerWithRefetchQueries, fetchOptions) {
+	const myNetworkRequestId = networkRequestId + "";
+	networkRequestId++;
+	let status = {
+		kind: "UndisposedIncomplete",
+		retainedQuery: fetchNormalizationAstAndRetainArtifact(environment, artifact, variables),
+		optimistic: fetchOptions?.optimisticNetworkResponse != null ? makeOptimisticUpdate(environment, artifact, variables, fetchOptions?.optimisticNetworkResponse) : null
+	};
+	logMessage(environment, () => ({
+		kind: "MakeNetworkRequest",
+		artifact,
+		variables,
+		networkRequestId: myNetworkRequestId
+	}));
+	return [wrapPromise(Promise.all([
+		environment.networkFunction(artifact.networkRequestInfo.operation, variables),
+		status.retainedQuery.normalizationAst.promise,
+		readerWithRefetchQueries?.promise
+	]).then(([networkResponse, normalizationAst, readerWithRefetchQueries$1]) => {
+		logMessage(environment, () => ({
+			kind: "ReceivedNetworkResponse",
+			networkResponse,
+			networkRequestId: myNetworkRequestId
+		}));
+		if (networkResponse.errors != null) {
+			try {
+				fetchOptions?.onError?.();
+			} catch {}
+			throw new Error("Network response had errors", { cause: networkResponse });
+		}
+		const root = {
+			__link: ROOT_ID,
+			__typename: artifact.concreteType
+		};
+		if (status.kind === "UndisposedIncomplete") if (status.optimistic != null) status = revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(environment, status, (storeLayer) => normalizeData(environment, storeLayer, normalizationAst.selections, networkResponse.data ?? {}, variables, root, /* @__PURE__ */ new Map()));
+		else {
+			const encounteredIds = /* @__PURE__ */ new Map();
+			environment.store = addNetworkResponseStoreLayer(environment.store);
+			normalizeData(environment, environment.store, normalizationAst.selections, networkResponse.data ?? {}, variables, root, encounteredIds);
+			logMessage(environment, () => ({
+				kind: "AfterNormalization",
+				store: environment.store,
+				encounteredIds
+			}));
+			callSubscriptions(environment, encounteredIds);
+			status = {
+				kind: "UndisposedComplete",
+				retainedQuery: status.retainedQuery
+			};
+		}
+		const onComplete = fetchOptions?.onComplete;
+		if (onComplete != null) {
+			let data = readDataForOnComplete(artifact, environment, root, variables, readerWithRefetchQueries$1);
+			try {
+				onComplete(data);
+			} catch {}
+		}
+	}).catch((e) => {
+		logMessage(environment, () => ({
+			kind: "ReceivedNetworkError",
+			networkRequestId: myNetworkRequestId,
+			error: e
+		}));
+		try {
+			fetchOptions?.onError?.();
+		} catch {}
+		if (status.kind === "UndisposedIncomplete") status = revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(environment, status, null);
+		throw e;
+	})), () => {
+		if (status.kind === "UndisposedIncomplete") status = revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(environment, status, null);
+		if (status.kind !== "Disposed") status = unretainAndGarbageCollect(environment, status);
+	}];
+}
+function readDataForOnComplete(artifact, environment, root, variables, readerWithRefetchQueries) {
+	if (artifact.kind === "Entrypoint") {
+		const fakeNetworkRequest = wrapResolvedValue(void 0);
+		const fakeNetworkRequestOptions = {
+			suspendIfInFlight: false,
+			throwOnNetworkError: false
+		};
+		const resolvedReaderWithRefetchQueries = readerWithRefetchQueries;
+		const fragment = {
+			kind: "FragmentReference",
+			readerWithRefetchQueries: wrapResolvedValue(resolvedReaderWithRefetchQueries),
+			fieldName: resolvedReaderWithRefetchQueries.readerArtifact.fieldName,
+			readerArtifactKind: resolvedReaderWithRefetchQueries.readerArtifact.kind,
+			root,
+			variables,
+			networkRequest: fakeNetworkRequest
+		};
+		const fragmentResult = readButDoNotEvaluate(environment, fragment, fakeNetworkRequestOptions).item;
+		const readerArtifact = resolvedReaderWithRefetchQueries.readerArtifact;
+		switch (readerArtifact.kind) {
+			case "ComponentReaderArtifact": return getOrCreateCachedComponent(environment, {
+				kind: "FragmentReference",
+				readerWithRefetchQueries: wrapResolvedValue({
+					kind: "ReaderWithRefetchQueries",
+					readerArtifact,
+					nestedRefetchQueries: resolvedReaderWithRefetchQueries.nestedRefetchQueries
+				}),
+				fieldName: readerArtifact.fieldName,
+				readerArtifactKind: readerArtifact.kind,
+				root,
+				variables,
+				networkRequest: fakeNetworkRequest
+			}, fakeNetworkRequestOptions);
+			case "EagerReaderArtifact": return readerArtifact.resolver({
+				data: fragmentResult,
+				parameters: variables,
+				...readerArtifact.hasUpdatable ? { startUpdate: getOrCreateCachedStartUpdate(environment, fragment, fakeNetworkRequestOptions) } : void 0
+			});
+		}
+	}
+	return null;
+}
+function fetchNormalizationAstAndRetainArtifact(environment, artifact, variables) {
+	const retainedQuery = {
+		normalizationAst: artifact.networkRequestInfo.normalizationAst.kind === "NormalizationAst" ? wrapResolvedValue(artifact.networkRequestInfo.normalizationAst) : wrapPromise(artifact.networkRequestInfo.normalizationAst.loader()),
+		variables,
+		root: {
+			__link: ROOT_ID,
+			__typename: artifact.concreteType
+		}
+	};
+	retainQuery(environment, retainedQuery);
+	return retainedQuery;
+}
+function makeOptimisticUpdate(environment, artifact, variables, optimisticNetworkResponse) {
+	const root = {
+		__link: ROOT_ID,
+		__typename: artifact.concreteType
+	};
+	if (artifact.networkRequestInfo.normalizationAst.kind === "NormalizationAstLoader") throw new Error("Using lazy loaded normalizationAst with optimisticNetworkResponse is not supported.");
+	const encounteredIds = /* @__PURE__ */ new Map();
+	const optimistic = environment.store = addOptimisticNetworkResponseStoreLayer(environment.store);
+	normalizeData(environment, environment.store, artifact.networkRequestInfo.normalizationAst.selections, optimisticNetworkResponse, variables, root, encounteredIds);
+	logMessage(environment, () => ({
+		kind: "AfterNormalization",
+		store: environment.store,
+		encounteredIds
+	}));
+	callSubscriptions(environment, encounteredIds);
+	return optimistic;
+}
+function revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(environment, status, normalizeData$1) {
+	if (status.optimistic != null) revertOptimisticStoreLayerAndMaybeReplace(environment, status.optimistic, normalizeData$1);
+	return {
+		kind: "UndisposedComplete",
+		retainedQuery: status.retainedQuery
+	};
+}
+function unretainAndGarbageCollect(environment, status) {
+	if (unretainQuery(environment, status.retainedQuery)) garbageCollectEnvironment(environment);
+	return { kind: "Disposed" };
+}
+
+//#endregion
+export { makeNetworkRequest, maybeMakeNetworkRequest, retainQueryWithoutMakingNetworkRequest };
+//# sourceMappingURL=makeNetworkRequest.mjs.map

package/dist/core/makeNetworkRequest.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeNetworkRequest.mjs","names":["status:\n    | NetworkRequestStatusUndisposedComplete\n    | NetworkRequestStatusDisposed","status: NetworkRequestStatus","readerWithRefetchQueries","encounteredIds: EncounteredIds","fragment: FragmentReference<TReadFromStore, TClientFieldValue>","retainedQuery: RetainedQuery","normalizeData"],"sources":["../../src/core/makeNetworkRequest.ts"],"sourcesContent":["import type { ItemCleanupPair } from '@isograph/disposable-types';\nimport {\n  normalizeData,\n  type EncounteredIds,\n  type NetworkResponseObject,\n} from './cache';\nimport type { FetchOptions } from './check';\nimport { check, DEFAULT_SHOULD_FETCH_VALUE } from './check';\nimport { getOrCreateCachedComponent } from './componentCache';\nimport type {\n  IsographEntrypoint,\n  NormalizationAst,\n  NormalizationAstLoader,\n  ReaderWithRefetchQueries,\n  RefetchQueryNormalizationArtifact,\n} from './entrypoint';\nimport type {\n  ExtractParameters,\n  FragmentReference,\n  UnknownTReadFromStore,\n} from './FragmentReference';\nimport type { RetainedQuery } from './garbageCollection';\nimport {\n  garbageCollectEnvironment,\n  retainQuery,\n  unretainQuery,\n} from './garbageCollection';\nimport type { IsographEnvironment, StoreLink } from './IsographEnvironment';\nimport { ROOT_ID } from './IsographEnvironment';\nimport { logMessage } from './logging';\nimport {\n  addNetworkResponseStoreLayer,\n  addOptimisticNetworkResponseStoreLayer,\n  revertOptimisticStoreLayerAndMaybeReplace,\n  type OptimisticStoreLayer,\n  type StoreLayerWithData,\n} from './optimisticProxy';\nimport type { AnyError, PromiseWrapper } from './PromiseWrapper';\nimport { wrapPromise, wrapResolvedValue } from './PromiseWrapper';\nimport { readButDoNotEvaluate } from './read';\nimport { getOrCreateCachedStartUpdate } from './startUpdate';\nimport { callSubscriptions } from './subscribe';\n\nlet networkRequestId = 0;\n\nexport function maybeMakeNetworkRequest<\n  TReadFromStore extends UnknownTReadFromStore,\n  TClientFieldValue,\n  TNormalizationAst extends NormalizationAst | NormalizationAstLoader,\n  TRawResponseType extends NetworkResponseObject,\n>(\n  environment: IsographEnvironment,\n  artifact:\n    | RefetchQueryNormalizationArtifact\n    | IsographEntrypoint<\n        TReadFromStore,\n        TClientFieldValue,\n        TNormalizationAst,\n        TRawResponseType\n      >,\n  variables: ExtractParameters<TReadFromStore>,\n  readerWithRefetchQueries: PromiseWrapper<\n    ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>\n  > | null,\n  fetchOptions: FetchOptions<TClientFieldValue, TRawResponseType> | null,\n): ItemCleanupPair<PromiseWrapper<void, AnyError>> {\n  switch (fetchOptions?.shouldFetch ?? DEFAULT_SHOULD_FETCH_VALUE) {\n    case 'Yes': {\n      return makeNetworkRequest(\n        environment,\n        artifact,\n        variables,\n        readerWithRefetchQueries,\n        fetchOptions,\n      );\n    }\n    case 'No': {\n      return retainQueryWithoutMakingNetworkRequest(\n        environment,\n        artifact,\n        variables,\n      );\n    }\n    case 'IfNecessary': {\n      if (\n        artifact.networkRequestInfo.normalizationAst.kind ===\n        'NormalizationAstLoader'\n      ) {\n        throw new Error(\n          'Using lazy loaded normalizationAst with shouldFetch: \"IfNecessary\" is ' +\n            'not supported as it will lead to a network waterfall.',\n        );\n      }\n      const result = check(\n        environment,\n        artifact.networkRequestInfo.normalizationAst.selections,\n        variables,\n        {\n          __link: ROOT_ID,\n          __typename: artifact.concreteType,\n        },\n      );\n\n      if (result.kind === 'EnoughData') {\n        return retainQueryWithoutMakingNetworkRequest(\n          environment,\n          artifact,\n          variables,\n        );\n      } else {\n        return makeNetworkRequest(\n          environment,\n          artifact,\n          variables,\n          readerWithRefetchQueries,\n          fetchOptions,\n        );\n      }\n    }\n  }\n}\n\nexport function retainQueryWithoutMakingNetworkRequest<\n  TReadFromStore extends UnknownTReadFromStore,\n  TClientFieldValue,\n  TRawResponseType extends NetworkResponseObject,\n>(\n  environment: IsographEnvironment,\n  artifact:\n    | RefetchQueryNormalizationArtifact\n    | IsographEntrypoint<\n        TReadFromStore,\n        TClientFieldValue,\n        NormalizationAst | NormalizationAstLoader,\n        TRawResponseType\n      >,\n  variables: ExtractParameters<TReadFromStore>,\n): ItemCleanupPair<PromiseWrapper<void, AnyError>> {\n  let status:\n    | NetworkRequestStatusUndisposedComplete\n    | NetworkRequestStatusDisposed = {\n    kind: 'UndisposedComplete',\n    retainedQuery: fetchNormalizationAstAndRetainArtifact(\n      environment,\n      artifact,\n      variables,\n    ),\n  };\n  return [\n    wrapResolvedValue(undefined),\n    () => {\n      if (status.kind !== 'Disposed') {\n        status = unretainAndGarbageCollect(environment, status);\n      }\n    },\n  ];\n}\n\nexport function makeNetworkRequest<\n  TReadFromStore extends UnknownTReadFromStore,\n  TClientFieldValue,\n  TNormalizationAst extends NormalizationAst | NormalizationAstLoader,\n  TRawResponseType extends NetworkResponseObject,\n>(\n  environment: IsographEnvironment,\n  artifact:\n    | RefetchQueryNormalizationArtifact\n    | IsographEntrypoint<\n        TReadFromStore,\n        TClientFieldValue,\n        TNormalizationAst,\n        TRawResponseType\n      >,\n  variables: ExtractParameters<TReadFromStore>,\n  readerWithRefetchQueries: PromiseWrapper<\n    ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>\n  > | null,\n  fetchOptions: FetchOptions<TClientFieldValue, TRawResponseType> | null,\n): ItemCleanupPair<PromiseWrapper<void, AnyError>> {\n  // TODO this should be a DataId and stored in the store\n  const myNetworkRequestId = networkRequestId + '';\n  networkRequestId++;\n  let status: NetworkRequestStatus = {\n    kind: 'UndisposedIncomplete',\n    retainedQuery: fetchNormalizationAstAndRetainArtifact(\n      environment,\n      artifact,\n      variables,\n    ),\n    optimistic:\n      fetchOptions?.optimisticNetworkResponse != null\n        ? makeOptimisticUpdate(\n            environment,\n            artifact,\n            variables,\n            fetchOptions?.optimisticNetworkResponse,\n          )\n        : null,\n  };\n\n  logMessage(environment, () => ({\n    kind: 'MakeNetworkRequest',\n    artifact,\n    variables,\n    networkRequestId: myNetworkRequestId,\n  }));\n\n  // This should be an observable, not a promise\n  const promise = Promise.all([\n    environment.networkFunction(\n      artifact.networkRequestInfo.operation,\n      variables,\n    ),\n    status.retainedQuery.normalizationAst.promise,\n    readerWithRefetchQueries?.promise,\n  ])\n    .then(([networkResponse, normalizationAst, readerWithRefetchQueries]) => {\n      logMessage(environment, () => ({\n        kind: 'ReceivedNetworkResponse',\n        networkResponse,\n        networkRequestId: myNetworkRequestId,\n      }));\n\n      if (networkResponse.errors != null) {\n        try {\n          fetchOptions?.onError?.();\n        } catch {}\n        throw new Error('Network response had errors', {\n          cause: networkResponse,\n        });\n      }\n\n      const root = { __link: ROOT_ID, __typename: artifact.concreteType };\n\n      if (status.kind === 'UndisposedIncomplete') {\n        if (status.optimistic != null) {\n          status =\n            revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(\n              environment,\n              status,\n              (storeLayer) =>\n                normalizeData(\n                  environment,\n                  storeLayer,\n                  normalizationAst.selections,\n                  networkResponse.data ?? {},\n                  variables,\n                  root,\n                  new Map(),\n                ),\n            );\n        } else {\n          const encounteredIds: EncounteredIds = new Map();\n          environment.store = addNetworkResponseStoreLayer(environment.store);\n          normalizeData(\n            environment,\n            environment.store,\n            normalizationAst.selections,\n            networkResponse.data ?? {},\n            variables,\n            root,\n            encounteredIds,\n          );\n\n          logMessage(environment, () => ({\n            kind: 'AfterNormalization',\n            store: environment.store,\n            encounteredIds: encounteredIds,\n          }));\n\n          callSubscriptions(environment, encounteredIds);\n\n          status = {\n            kind: 'UndisposedComplete',\n            retainedQuery: status.retainedQuery,\n          };\n        }\n      }\n\n      const onComplete = fetchOptions?.onComplete;\n      if (onComplete != null) {\n        let data = readDataForOnComplete(\n          artifact,\n          environment,\n          root,\n          variables,\n          readerWithRefetchQueries,\n        );\n\n        try {\n          // @ts-expect-error this problem will be fixed when we remove RefetchQueryNormalizationArtifact\n          // (or we can fix this by having a single param of type { kind: 'Entrypoint', entrypoint,\n          // fetchOptions: FetchOptions<TReadFromStore> } | { kind: 'RefetchQuery', refetchQuery,\n          // fetchOptions: FetchOptions<void> }).\n          onComplete(data);\n        } catch {}\n      }\n    })\n    .catch((e) => {\n      logMessage(environment, () => ({\n        kind: 'ReceivedNetworkError',\n        networkRequestId: myNetworkRequestId,\n        error: e,\n      }));\n      try {\n        fetchOptions?.onError?.();\n      } catch {}\n\n      if (status.kind === 'UndisposedIncomplete') {\n        status =\n          revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(\n            environment,\n            status,\n            null,\n          );\n      }\n\n      throw e;\n    });\n\n  const wrapper = wrapPromise(promise);\n\n  const response: ItemCleanupPair<PromiseWrapper<void, AnyError>> = [\n    wrapper,\n    () => {\n      if (status.kind === 'UndisposedIncomplete') {\n        status =\n          revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(\n            environment,\n            status,\n            null,\n          );\n      }\n      if (status.kind !== 'Disposed') {\n        status = unretainAndGarbageCollect(environment, status);\n      }\n    },\n  ];\n  return response;\n}\n\ntype NetworkRequestStatusUndisposedIncomplete = {\n  readonly kind: 'UndisposedIncomplete';\n  readonly retainedQuery: RetainedQuery;\n  readonly optimistic: OptimisticStoreLayer | null;\n};\n\ntype NetworkRequestStatusUndisposedComplete = {\n  readonly kind: 'UndisposedComplete';\n  readonly retainedQuery: RetainedQuery;\n};\n\ntype NetworkRequestStatusDisposed = {\n  readonly kind: 'Disposed';\n};\n\ntype NetworkRequestStatus =\n  | NetworkRequestStatusUndisposedIncomplete\n  | NetworkRequestStatusUndisposedComplete\n  | NetworkRequestStatusDisposed;\n\nfunction readDataForOnComplete<\n  TReadFromStore extends UnknownTReadFromStore,\n  TClientFieldValue,\n  TNormalizationAst extends NormalizationAst | NormalizationAstLoader,\n  TRawResponseType extends NetworkResponseObject,\n>(\n  artifact:\n    | RefetchQueryNormalizationArtifact\n    | IsographEntrypoint<\n        TReadFromStore,\n        TClientFieldValue,\n        TNormalizationAst,\n        TRawResponseType\n      >,\n  environment: IsographEnvironment,\n  root: StoreLink,\n  variables: ExtractParameters<TReadFromStore>,\n  readerWithRefetchQueries:\n    | ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>\n    | undefined,\n): TClientFieldValue | null {\n  // An entrypoint, but not a RefetchQueryNormalizationArtifact, has a reader ASTs.\n  // So, we can only pass data to onComplete if makeNetworkRequest was passed an entrypoint.\n  // This is awkward, since we don't express that in the types of the parameters\n  // (i.e. FetchOptions could be passed, along with a RefetchQueryNormalizationArtifact).\n  //\n  // However, this isn't a big deal: RefetchQueryNormalizationArtifact is going away.\n  if (artifact.kind === 'Entrypoint') {\n    // TODO this is a smell!\n    const fakeNetworkRequest = wrapResolvedValue(undefined);\n    // TODO this is a smell — we know the network response is not in flight,\n    // so we don't really care!\n    const fakeNetworkRequestOptions = {\n      suspendIfInFlight: false,\n      throwOnNetworkError: false,\n    };\n    const resolvedReaderWithRefetchQueries =\n      readerWithRefetchQueries as ReaderWithRefetchQueries<\n        TReadFromStore,\n        TClientFieldValue\n      >;\n\n    const fragment: FragmentReference<TReadFromStore, TClientFieldValue> = {\n      kind: 'FragmentReference',\n      // TODO this smells.\n      readerWithRefetchQueries: wrapResolvedValue(\n        resolvedReaderWithRefetchQueries,\n      ),\n      fieldName: resolvedReaderWithRefetchQueries.readerArtifact.fieldName,\n      readerArtifactKind: resolvedReaderWithRefetchQueries.readerArtifact.kind,\n      root,\n      variables,\n      networkRequest: fakeNetworkRequest,\n    };\n    const fragmentResult = readButDoNotEvaluate(\n      environment,\n      fragment,\n      fakeNetworkRequestOptions,\n    ).item;\n    const readerArtifact = resolvedReaderWithRefetchQueries.readerArtifact;\n    switch (readerArtifact.kind) {\n      case 'ComponentReaderArtifact': {\n        // @ts-expect-error We should find a way to encode this in the type system:\n        // if we have a ComponentReaderArtifact, we will necessarily have a\n        // TClientFieldValue which is a React.FC<...>\n        return getOrCreateCachedComponent(\n          environment,\n          {\n            kind: 'FragmentReference',\n            readerWithRefetchQueries: wrapResolvedValue({\n              kind: 'ReaderWithRefetchQueries',\n              readerArtifact: readerArtifact,\n              nestedRefetchQueries:\n                resolvedReaderWithRefetchQueries.nestedRefetchQueries,\n            }),\n            fieldName: readerArtifact.fieldName,\n            readerArtifactKind: readerArtifact.kind,\n            root,\n            variables,\n            networkRequest: fakeNetworkRequest,\n          } as const,\n          fakeNetworkRequestOptions,\n        );\n      }\n      case 'EagerReaderArtifact': {\n        return readerArtifact.resolver({\n          data: fragmentResult,\n          parameters: variables,\n          ...(readerArtifact.hasUpdatable\n            ? {\n                startUpdate: getOrCreateCachedStartUpdate(\n                  environment,\n                  fragment,\n                  fakeNetworkRequestOptions,\n                ),\n              }\n            : undefined),\n        });\n      }\n    }\n  }\n  return null;\n}\n\nfunction fetchNormalizationAstAndRetainArtifact<\n  TReadFromStore extends UnknownTReadFromStore,\n  TClientFieldValue,\n  TRawResponseType extends NetworkResponseObject,\n>(\n  environment: IsographEnvironment,\n  artifact:\n    | RefetchQueryNormalizationArtifact\n    | IsographEntrypoint<\n        TReadFromStore,\n        TClientFieldValue,\n        NormalizationAst | NormalizationAstLoader,\n        TRawResponseType\n      >,\n  variables: ExtractParameters<TReadFromStore>,\n): RetainedQuery {\n  const normalizationAst =\n    artifact.networkRequestInfo.normalizationAst.kind === 'NormalizationAst'\n      ? wrapResolvedValue(artifact.networkRequestInfo.normalizationAst)\n      : wrapPromise(artifact.networkRequestInfo.normalizationAst.loader());\n\n  const root = { __link: ROOT_ID, __typename: artifact.concreteType };\n  const retainedQuery: RetainedQuery = {\n    normalizationAst: normalizationAst,\n    variables,\n    root,\n  };\n  retainQuery(environment, retainedQuery);\n  return retainedQuery;\n}\n\nfunction makeOptimisticUpdate<\n  TReadFromStore extends UnknownTReadFromStore,\n  TClientFieldValue,\n  TNormalizationAst extends NormalizationAst | NormalizationAstLoader,\n  TRawResponseType extends NetworkResponseObject,\n>(\n  environment: IsographEnvironment,\n  artifact:\n    | RefetchQueryNormalizationArtifact\n    | IsographEntrypoint<\n        TReadFromStore,\n        TClientFieldValue,\n        TNormalizationAst,\n        TRawResponseType\n      >,\n  variables: ExtractParameters<TReadFromStore>,\n  optimisticNetworkResponse: TRawResponseType,\n): OptimisticStoreLayer {\n  const root = { __link: ROOT_ID, __typename: artifact.concreteType };\n\n  if (\n    artifact.networkRequestInfo.normalizationAst.kind ===\n    'NormalizationAstLoader'\n  ) {\n    throw new Error(\n      'Using lazy loaded normalizationAst with optimisticNetworkResponse is not supported.',\n    );\n  }\n  const encounteredIds: EncounteredIds = new Map();\n  const optimistic = (environment.store =\n    addOptimisticNetworkResponseStoreLayer(environment.store));\n  normalizeData(\n    environment,\n    environment.store,\n    artifact.networkRequestInfo.normalizationAst.selections,\n    optimisticNetworkResponse,\n    variables,\n    root,\n    encounteredIds,\n  );\n\n  logMessage(environment, () => ({\n    kind: 'AfterNormalization',\n    store: environment.store,\n    encounteredIds: encounteredIds,\n  }));\n\n  callSubscriptions(environment, encounteredIds);\n  return optimistic;\n}\n\nfunction revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(\n  environment: IsographEnvironment,\n  status: NetworkRequestStatusUndisposedIncomplete,\n  normalizeData: null | ((storeLayer: StoreLayerWithData) => void),\n): NetworkRequestStatusUndisposedComplete {\n  if (status.optimistic != null) {\n    revertOptimisticStoreLayerAndMaybeReplace(\n      environment,\n      status.optimistic,\n      normalizeData,\n    );\n  }\n\n  return {\n    kind: 'UndisposedComplete',\n    retainedQuery: status.retainedQuery,\n  };\n}\n\nfunction unretainAndGarbageCollect(\n  environment: IsographEnvironment,\n  status: NetworkRequestStatusUndisposedComplete,\n): NetworkRequestStatusDisposed {\n  const didUnretainSomeQuery = unretainQuery(environment, status.retainedQuery);\n  if (didUnretainSomeQuery) {\n    garbageCollectEnvironment(environment);\n  }\n\n  return {\n    kind: 'Disposed',\n  };\n}\n"],"mappings":"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"}

package/dist/core/optimisticProxy.d.mts

@@ -0,0 +1,43 @@
+import { BaseStoreLayerData, StoreLayerData } from "./IsographEnvironment.mjs";
+
+//#region src/core/optimisticProxy.d.ts
+
+type BaseStoreLayer = {
+  readonly kind: 'BaseStoreLayer';
+  childStoreLayer: OptimisticStoreLayer | null;
+  readonly parentStoreLayer: null;
+  readonly data: BaseStoreLayerData;
+};
+type NetworkResponseStoreLayer = {
+  readonly kind: 'NetworkResponseStoreLayer';
+  childStoreLayer: OptimisticStoreLayer | StartUpdateStoreLayer | null;
+  parentStoreLayer: OptimisticStoreLayer | StartUpdateStoreLayer;
+  readonly data: StoreLayerData;
+};
+type DataUpdate<TStoreLayer extends StoreLayer> = (storeLayer: TStoreLayer) => void;
+type StartUpdateStoreLayer = {
+  readonly kind: 'StartUpdateStoreLayer';
+  childStoreLayer: OptimisticStoreLayer | NetworkResponseStoreLayer | null;
+  parentStoreLayer: OptimisticStoreLayer | NetworkResponseStoreLayer;
+  data: StoreLayerData;
+  startUpdate: DataUpdate<StartUpdateStoreLayer | BaseStoreLayer>;
+};
+type OptimisticStoreLayer = OptimisticUpdaterStoreLayer | OptimisticNetworkResponseStoreLayer;
+type OptimisticUpdaterStoreLayer = {
+  readonly kind: 'OptimisticUpdaterStoreLayer';
+  childStoreLayer: OptimisticStoreLayer | StartUpdateStoreLayer | NetworkResponseStoreLayer | null;
+  parentStoreLayer: OptimisticStoreLayer | StartUpdateStoreLayer | NetworkResponseStoreLayer | BaseStoreLayer;
+  data: StoreLayerData;
+  readonly startUpdate: DataUpdate<OptimisticUpdaterStoreLayer>;
+};
+type OptimisticNetworkResponseStoreLayer = {
+  readonly kind: 'OptimisticNetworkResponseStoreLayer';
+  childStoreLayer: OptimisticStoreLayer | StartUpdateStoreLayer | NetworkResponseStoreLayer | null;
+  parentStoreLayer: OptimisticStoreLayer | StartUpdateStoreLayer | NetworkResponseStoreLayer | BaseStoreLayer;
+  data: StoreLayerData;
+};
+type StoreLayer = OptimisticStoreLayer | NetworkResponseStoreLayer | StartUpdateStoreLayer | BaseStoreLayer;
+type StoreLayerWithData = BaseStoreLayer | NetworkResponseStoreLayer | OptimisticNetworkResponseStoreLayer;
+//#endregion
+export { StoreLayer, StoreLayerWithData };
+//# sourceMappingURL=optimisticProxy.d.mts.map

package/dist/core/optimisticProxy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimisticProxy.d.mts","names":[],"sources":["../../src/core/optimisticProxy.ts"],"sourcesContent":[],"mappings":";;;;AA8GiB,KAXL,cAAA,GAWK;EAAc,SAAA,IAAA,EAAA,gBAAA;EAGnB,eAAU,EAZH,oBAYwB,GAAA,IAAA;EAI/B,SAAA,gBAAqB,EAAA,IAAA;EAEd,SAAA,IAAA,EAhBF,kBAgBE;CAAuB;AACtB,KAdR,yBAAA,GAcQ;EAAuB,SAAA,IAAA,EAAA,2BAAA;EACnC,eAAA,EAbW,oBAaX,GAbkC,qBAalC,GAAA,IAAA;EACkB,gBAAA,EAbN,oBAaM,GAbiB,qBAajB;EAAwB,SAAA,IAAA,EAZjC,cAYiC;CAAnC;AAAU,KATb,UASa,CAAA,oBATkB,UASlB,CAAA,GAAA,CAAA,UAAA,EARX,WAQW,EAAA,GAAA,IAAA;AAGb,KARA,qBAAA,GAQoB;EAIpB,SAAA,IAAA,EAAA,uBAA2B;EAGjC,eAAA,EAba,oBAab,GAboC,yBAapC,GAAA,IAAA;EACA,gBAAA,EAbc,oBAad,GAbqC,yBAarC;EACA,IAAA,EAbE,cAaF;EAGA,WAAA,EAfS,UAeT,CAfoB,qBAepB,GAf4C,cAe5C,CAAA;CACA;AACA,KAdM,oBAAA,GACR,2BAaE,GAZF,mCAYE;AACA,KAXM,2BAAA,GAWN;EACE,SAAA,IAAA,EAAA,6BAAA;EAC2B,eAAA,EAV7B,oBAU6B,GAT7B,qBAS6B,GAR7B,yBAQ6B,GAAA,IAAA;EAAX,gBAAA,EALlB,oBAKkB,GAJlB,qBAIkB,GAHlB,yBAGkB,GAFlB,cAEkB;EAAU,IAAA,EAD1B,cAC0B;EAGtB,SAAA,WAAA,EAHY,UAGZ,CAHuB,2BAGY,CAAA;CAGzC;AACA,KAJM,mCAAA,GAIN;EACA,SAAA,IAAA,EAAA,qCAAA;EAGA,eAAA,EALA,oBAKA,GAJA,qBAIA,GAHA,yBAGA,GAAA,IAAA;EACA,gBAAA,EADA,oBACA,GAAA,qBAAA,GACA,yBADA,GAEA,cAFA;EACA,IAAA,EAEE,cAFF;CACA;KAkVM,UAAA,GACR,uBACA,4BACA,wBACA;KAEQ,kBAAA,GACR,iBACA,4BACA"}

package/dist/core/optimisticProxy.d.ts

@@ -0,0 +1,43 @@
+import { BaseStoreLayerData, StoreLayerData } from "./IsographEnvironment.js";
+
+//#region src/core/optimisticProxy.d.ts
+
+type BaseStoreLayer = {
+  readonly kind: 'BaseStoreLayer';
+  childStoreLayer: OptimisticStoreLayer | null;
+  readonly parentStoreLayer: null;
+  readonly data: BaseStoreLayerData;
+};
+type NetworkResponseStoreLayer = {
+  readonly kind: 'NetworkResponseStoreLayer';
+  childStoreLayer: OptimisticStoreLayer | StartUpdateStoreLayer | null;
+  parentStoreLayer: OptimisticStoreLayer | StartUpdateStoreLayer;
+  readonly data: StoreLayerData;
+};
+type DataUpdate<TStoreLayer extends StoreLayer> = (storeLayer: TStoreLayer) => void;
+type StartUpdateStoreLayer = {
+  readonly kind: 'StartUpdateStoreLayer';
+  childStoreLayer: OptimisticStoreLayer | NetworkResponseStoreLayer | null;
+  parentStoreLayer: OptimisticStoreLayer | NetworkResponseStoreLayer;
+  data: StoreLayerData;
+  startUpdate: DataUpdate<StartUpdateStoreLayer | BaseStoreLayer>;
+};
+type OptimisticStoreLayer = OptimisticUpdaterStoreLayer | OptimisticNetworkResponseStoreLayer;
+type OptimisticUpdaterStoreLayer = {
+  readonly kind: 'OptimisticUpdaterStoreLayer';
+  childStoreLayer: OptimisticStoreLayer | StartUpdateStoreLayer | NetworkResponseStoreLayer | null;
+  parentStoreLayer: OptimisticStoreLayer | StartUpdateStoreLayer | NetworkResponseStoreLayer | BaseStoreLayer;
+  data: StoreLayerData;
+  readonly startUpdate: DataUpdate<OptimisticUpdaterStoreLayer>;
+};
+type OptimisticNetworkResponseStoreLayer = {
+  readonly kind: 'OptimisticNetworkResponseStoreLayer';
+  childStoreLayer: OptimisticStoreLayer | StartUpdateStoreLayer | NetworkResponseStoreLayer | null;
+  parentStoreLayer: OptimisticStoreLayer | StartUpdateStoreLayer | NetworkResponseStoreLayer | BaseStoreLayer;
+  data: StoreLayerData;
+};
+type StoreLayer = OptimisticStoreLayer | NetworkResponseStoreLayer | StartUpdateStoreLayer | BaseStoreLayer;
+type StoreLayerWithData = BaseStoreLayer | NetworkResponseStoreLayer | OptimisticNetworkResponseStoreLayer;
+//#endregion
+export { StoreLayer, StoreLayerWithData };
+//# sourceMappingURL=optimisticProxy.d.ts.map

package/dist/core/optimisticProxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimisticProxy.d.ts","names":[],"sources":["../../src/core/optimisticProxy.ts"],"sourcesContent":[],"mappings":";;;;AA8GiB,KAXL,cAAA,GAWK;EAAc,SAAA,IAAA,EAAA,gBAAA;EAGnB,eAAU,EAZH,oBAYwB,GAAA,IAAA;EAI/B,SAAA,gBAAqB,EAAA,IAAA;EAEd,SAAA,IAAA,EAhBF,kBAgBE;CAAuB;AACtB,KAdR,yBAAA,GAcQ;EAAuB,SAAA,IAAA,EAAA,2BAAA;EACnC,eAAA,EAbW,oBAaX,GAbkC,qBAalC,GAAA,IAAA;EACkB,gBAAA,EAbN,oBAaM,GAbiB,qBAajB;EAAwB,SAAA,IAAA,EAZjC,cAYiC;CAAnC;AAAU,KATb,UASa,CAAA,oBATkB,UASlB,CAAA,GAAA,CAAA,UAAA,EARX,WAQW,EAAA,GAAA,IAAA;AAGb,KARA,qBAAA,GAQoB;EAIpB,SAAA,IAAA,EAAA,uBAA2B;EAGjC,eAAA,EAba,oBAab,GAboC,yBAapC,GAAA,IAAA;EACA,gBAAA,EAbc,oBAad,GAbqC,yBAarC;EACA,IAAA,EAbE,cAaF;EAGA,WAAA,EAfS,UAeT,CAfoB,qBAepB,GAf4C,cAe5C,CAAA;CACA;AACA,KAdM,oBAAA,GACR,2BAaE,GAZF,mCAYE;AACA,KAXM,2BAAA,GAWN;EACE,SAAA,IAAA,EAAA,6BAAA;EAC2B,eAAA,EAV7B,oBAU6B,GAT7B,qBAS6B,GAR7B,yBAQ6B,GAAA,IAAA;EAAX,gBAAA,EALlB,oBAKkB,GAJlB,qBAIkB,GAHlB,yBAGkB,GAFlB,cAEkB;EAAU,IAAA,EAD1B,cAC0B;EAGtB,SAAA,WAAA,EAHY,UAGZ,CAHuB,2BAGY,CAAA;CAGzC;AACA,KAJM,mCAAA,GAIN;EACA,SAAA,IAAA,EAAA,qCAAA;EAGA,eAAA,EALA,oBAKA,GAJA,qBAIA,GAHA,yBAGA,GAAA,IAAA;EACA,gBAAA,EADA,oBACA,GAAA,qBAAA,GACA,yBADA,GAEA,cAFA;EACA,IAAA,EAEE,cAFF;CACA;KAkVM,UAAA,GACR,uBACA,4BACA,wBACA;KAEQ,kBAAA,GACR,iBACA,4BACA"}

package/dist/core/optimisticProxy.js

@@ -0,0 +1,273 @@
+const require_subscribe = require('./subscribe.js');
+const require_cache = require('./cache.js');
+
+//#region src/core/optimisticProxy.ts
+function getOrInsertRecord(dataLayer, link) {
+	const recordsById = dataLayer[link.__typename] ??= {};
+	return recordsById[link.__link] ??= {};
+}
+/**
+* Given the child-most store layer (i.e. environment.store) and a link (identifying a
+* store record), create a proxy object that attempts to read through each successive
+* store layer until a value (i.e. field name) is found. If found, return that value.
+*/
+function getStoreRecordProxy(storeLayer, link) {
+	let startNode = storeLayer;
+	while (startNode != null) {
+		const storeRecord = startNode.data[link.__typename]?.[link.__link];
+		if (storeRecord === void 0) {
+			startNode = startNode.parentStoreLayer;
+			continue;
+		}
+		if (storeRecord == null) return null;
+		return getMutableStoreRecordProxy(startNode, link);
+	}
+}
+function getMutableStoreRecordProxy(childMostStoreLayer, link) {
+	return new Proxy({}, {
+		get(_, propertyName) {
+			let currentStoreLayer = childMostStoreLayer;
+			while (currentStoreLayer != null) {
+				const storeRecord = currentStoreLayer.data[link.__typename]?.[link.__link];
+				if (storeRecord !== void 0) {
+					if (storeRecord == null) return;
+					const value = Reflect.get(storeRecord, propertyName);
+					if (value !== void 0) return value;
+				}
+				currentStoreLayer = currentStoreLayer.parentStoreLayer;
+			}
+		},
+		has(_, propertyName) {
+			let currentStoreLayer = childMostStoreLayer;
+			while (currentStoreLayer != null) {
+				const storeRecord = currentStoreLayer.data[link.__typename]?.[link.__link];
+				if (storeRecord !== void 0) {
+					if (storeRecord == null) return false;
+					if (Reflect.has(storeRecord, propertyName)) return true;
+				}
+				currentStoreLayer = currentStoreLayer.parentStoreLayer;
+			}
+			return false;
+		},
+		set(_, p, newValue) {
+			return Reflect.set(getOrInsertRecord(childMostStoreLayer.data, link), p, newValue);
+		}
+	});
+}
+function addNetworkResponseStoreLayer(parent) {
+	switch (parent.kind) {
+		case "NetworkResponseStoreLayer":
+		case "BaseStoreLayer": return parent;
+		case "StartUpdateStoreLayer":
+		case "OptimisticNetworkResponseStoreLayer":
+		case "OptimisticUpdaterStoreLayer": {
+			const node = {
+				kind: "NetworkResponseStoreLayer",
+				parentStoreLayer: parent,
+				childStoreLayer: null,
+				data: {}
+			};
+			parent.childStoreLayer = node;
+			return node;
+		}
+	}
+}
+function mergeDataLayer(target, source) {
+	for (const [typeName, sourceById] of Object.entries(source)) {
+		if (sourceById == null) {
+			target[typeName] = sourceById;
+			continue;
+		}
+		const targetRecordById = target[typeName] ??= {};
+		for (const [id, sourceRecord] of Object.entries(sourceById)) {
+			if (sourceRecord == null) {
+				targetRecordById[id] = null;
+				continue;
+			}
+			const targetRecord = targetRecordById[id] ??= {};
+			Object.assign(targetRecord, sourceRecord);
+		}
+	}
+}
+function addStartUpdateStoreLayer(parent, startUpdate) {
+	switch (parent.kind) {
+		case "BaseStoreLayer":
+			startUpdate(parent);
+			return parent;
+		case "StartUpdateStoreLayer": {
+			const node = parent;
+			const prevStartUpdate = node.startUpdate;
+			node.startUpdate = () => {
+				prevStartUpdate(node);
+				startUpdate(node);
+			};
+			startUpdate(node);
+			return node;
+		}
+		case "NetworkResponseStoreLayer":
+		case "OptimisticNetworkResponseStoreLayer":
+		case "OptimisticUpdaterStoreLayer": {
+			const node = {
+				kind: "StartUpdateStoreLayer",
+				parentStoreLayer: parent,
+				childStoreLayer: null,
+				data: {},
+				startUpdate
+			};
+			parent.childStoreLayer = node;
+			startUpdate(node);
+			return node;
+		}
+	}
+}
+function addOptimisticNetworkResponseStoreLayer(parent) {
+	switch (parent.kind) {
+		case "BaseStoreLayer":
+		case "StartUpdateStoreLayer":
+		case "NetworkResponseStoreLayer":
+		case "OptimisticNetworkResponseStoreLayer":
+		case "OptimisticUpdaterStoreLayer": {
+			const node = {
+				kind: "OptimisticNetworkResponseStoreLayer",
+				parentStoreLayer: parent,
+				childStoreLayer: null,
+				data: {}
+			};
+			parent.childStoreLayer = node;
+			return node;
+		}
+	}
+}
+/**
+* Merge storeLayerToMerge, and its children, into baseStoreLayer.
+* We can merge until we reach a revertible layer (i.e. an optimistic layer).
+* All other layers cannot be reverted, so for housekeeping + perf, we merge
+* them into a single layer.
+*
+* Note that BaseStoreLayer.childStoreLayer has type OptimisticStoreLayer | null.
+* So, the state of the stack is never e.g. base <- network response. Instead,
+* we have a base + a child that we would like to attach to the base. So, we merge
+* (flatten) until we reach an optimistic layer or null, at which point, we can
+* set baseStoreLayer.childStoreLayer = storeLayerToMerge (via setChildOfNode).
+*/
+function mergeLayersWithDataIntoBaseLayer(environment, storeLayerToMerge, baseStoreLayer) {
+	while (storeLayerToMerge != null && storeLayerToMerge.kind !== "OptimisticUpdaterStoreLayer") {
+		mergeDataLayer(baseStoreLayer.data, storeLayerToMerge.data);
+		storeLayerToMerge = storeLayerToMerge.childStoreLayer;
+	}
+	setChildOfNode(environment, baseStoreLayer, storeLayerToMerge);
+}
+/**
+* Now that we have replaced the optimistic layer with a network response layer, we need
+* to
+* - re-execute startUpdate and optimistic nodes, in light of the replaced data, and
+* - create two objects containing the old merged data (from the optimistic update layer
+*   onward) and the new merged data (from the network response layer onward).
+* - we will compare the new and old merged data in order to determine the changed records
+*   and trigger subscriptions.
+*
+* Here, "merged data" means all of the records + fields that were modified, starting at
+* storeLayer, e.g. in BaseLayer <- OptimisticLayer <- StartUpdateLayer, if we
+* are replacing Optimistic, then oldData will contain the records + fields modified by
+* OptimisticLayer + StartUpdateLayer.
+*/
+function reexecuteUpdatesAndMergeData(storeLayer, oldMergedData, newMergedData) {
+	while (storeLayer != null) {
+		mergeDataLayer(oldMergedData, storeLayer.data);
+		switch (storeLayer.kind) {
+			case "OptimisticNetworkResponseStoreLayer":
+			case "NetworkResponseStoreLayer": break;
+			case "StartUpdateStoreLayer":
+				storeLayer.data = {};
+				storeLayer.startUpdate(storeLayer);
+				break;
+			case "OptimisticUpdaterStoreLayer":
+				storeLayer.data = {};
+				storeLayer.startUpdate(storeLayer);
+				break;
+		}
+		mergeDataLayer(newMergedData, storeLayer.data);
+		storeLayer = storeLayer.childStoreLayer;
+	}
+}
+/**
+* Set storeLayerToModify's child to a given layer. This may be null!
+* If it is null, set the environment.store to storeLayerToModify.
+* If it is not null, then the existing environment.store value remains
+* valid.
+*/
+function setChildOfNode(environment, storeLayerToModify, newChildStoreLayer) {
+	storeLayerToModify.childStoreLayer = newChildStoreLayer;
+	if (newChildStoreLayer != null) newChildStoreLayer.parentStoreLayer = storeLayerToModify;
+	else environment.store = storeLayerToModify;
+}
+/**
+* Remove an optimistic store layer from the stack, potentially replacing it
+* with a network response.
+*
+* After we do this, we must re-execute all child startUpdate and optimistic
+* layers (since their data may have changed.) We also keep track of changed
+* records, in order to call affected subscriptions.
+*/
+function revertOptimisticStoreLayerAndMaybeReplace(environment, optimisticNode, normalizeData) {
+	const oldMergedData = optimisticNode.data;
+	optimisticNode.data = {};
+	let newMergedData = {};
+	let childNode = optimisticNode.childStoreLayer;
+	if (normalizeData != null) {
+		const networkResponseStoreLayer = {
+			kind: "NetworkResponseStoreLayer",
+			data: {},
+			parentStoreLayer: optimisticNode,
+			childStoreLayer: null
+		};
+		normalizeData(networkResponseStoreLayer);
+		if (childNode?.kind === "NetworkResponseStoreLayer") {
+			mergeDataLayer(networkResponseStoreLayer.data, childNode.data);
+			mergeDataLayer(oldMergedData, childNode.data);
+			childNode = childNode.childStoreLayer;
+		}
+		newMergedData = structuredClone(networkResponseStoreLayer.data);
+		setChildOfNode(environment, networkResponseStoreLayer, childNode);
+		optimisticNode.childStoreLayer = networkResponseStoreLayer;
+	}
+	reexecuteUpdatesAndMergeData(childNode, oldMergedData, newMergedData);
+	if (optimisticNode.parentStoreLayer.kind === "BaseStoreLayer") mergeLayersWithDataIntoBaseLayer(environment, optimisticNode.childStoreLayer, optimisticNode.parentStoreLayer);
+	else if (optimisticNode.parentStoreLayer.kind === "NetworkResponseStoreLayer" && optimisticNode.childStoreLayer?.kind === "NetworkResponseStoreLayer") {
+		mergeDataLayer(optimisticNode.parentStoreLayer.data, optimisticNode.childStoreLayer.data);
+		setChildOfNode(environment, optimisticNode.parentStoreLayer, optimisticNode.childStoreLayer.childStoreLayer);
+	} else setChildOfNode(environment, optimisticNode.parentStoreLayer, optimisticNode.childStoreLayer);
+	let encounteredIds = /* @__PURE__ */ new Map();
+	compareData(oldMergedData, newMergedData, encounteredIds);
+	require_subscribe.callSubscriptions(environment, encounteredIds);
+}
+function compareData(oldData, newData, encounteredIds) {
+	const oldDataTypeNames = new Set(Object.keys(oldData));
+	const newDataTypeNames = new Set(Object.keys(newData));
+	for (const oldTypeName of oldDataTypeNames.difference(newDataTypeNames)) {
+		const set = require_cache.insertEmptySetIfMissing(encounteredIds, oldTypeName);
+		for (const id in oldData[oldTypeName]) set.add(id);
+	}
+	for (const [typeName, newRecords] of Object.entries(newData)) {
+		if (newRecords == null) continue;
+		const oldRecords = oldData[typeName];
+		outer: for (const [id, newRecord] of Object.entries(newRecords)) {
+			if (newRecord == null) continue;
+			const oldRecord = oldRecords?.[id];
+			for (const [recordKey, newRecordValue] of Object.entries(newRecord)) if (newRecordValue !== oldRecord?.[recordKey]) {
+				require_cache.insertEmptySetIfMissing(encounteredIds, typeName).add(id);
+				continue outer;
+			}
+			encounteredIds.get(typeName)?.delete(id);
+		}
+	}
+}
+
+//#endregion
+exports.addNetworkResponseStoreLayer = addNetworkResponseStoreLayer;
+exports.addOptimisticNetworkResponseStoreLayer = addOptimisticNetworkResponseStoreLayer;
+exports.addStartUpdateStoreLayer = addStartUpdateStoreLayer;
+exports.getMutableStoreRecordProxy = getMutableStoreRecordProxy;
+exports.getOrInsertRecord = getOrInsertRecord;
+exports.getStoreRecordProxy = getStoreRecordProxy;
+exports.revertOptimisticStoreLayerAndMaybeReplace = revertOptimisticStoreLayerAndMaybeReplace;