@isograph/react 0.5.0 → 0.5.1

package/dist/react/useLazyReference.js

@@ -1,42 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useLazyReference = useLazyReference;
-const react_disposable_state_1 = require("@isograph/react-disposable-state");
-const cache_1 = require("../core/cache");
-const logging_1 = require("../core/logging");
-const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
+const require_logging = require('../core/logging.js');
+const require_IsographEnvironmentProvider = require('./IsographEnvironmentProvider.js');
+const require_getOrCreateCacheForArtifact = require('../core/getOrCreateCacheForArtifact.js');
+let __isograph_react_disposable_state = require("@isograph/react-disposable-state");
+__isograph_react_disposable_state = require_rolldown_runtime.__toESM(__isograph_react_disposable_state);
+
+//#region src/react/useLazyReference.ts
 function useLazyReference(entrypoint, variables, ...[fetchOptions]) {
-    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
-    if ((entrypoint === null || entrypoint === void 0 ? void 0 : entrypoint.kind) !== 'Entrypoint') {
-        // TODO have a separate error logger
-        (0, logging_1.logMessage)(environment, () => ({
-            kind: 'NonEntrypointReceived',
-            entrypoint,
-        }));
-    }
-    const cache = (0, cache_1.getOrCreateCacheForArtifact)(environment, entrypoint, variables, fetchOptions);
-    return {
-        fragmentReference: (0, react_disposable_state_1.useLazyDisposableState)(cache).state,
-    };
-}
-// @ts-ignore
-function tsTests() {
-    let withAst;
-    let withAstLoader;
-    let withAstOrLoader;
-    useLazyReference(withAst, {});
-    useLazyReference(withAst, {}, { shouldFetch: 'Yes' });
-    useLazyReference(withAst, {}, { shouldFetch: 'IfNecessary' });
-    // @ts-expect-error if there's no ast, require `shouldFetch` to be specified
-    useLazyReference(withAstLoader, {});
-    useLazyReference(withAstLoader, {}, { shouldFetch: 'Yes' });
-    // @ts-expect-error if there's no ast, `shouldFetch` can't be `IfNecessary`
-    useLazyReference(withAstLoader, {}, { shouldFetch: 'IfNecessary' });
-    // if the type is unknown there can be no ast so we should use the same rules
-    // but because of TS bugs with inference we just return unknown
-    // @ts-expect-error this returns unknown which doesn't satisfy the constraint
-    useLazyReference(withAstOrLoader, {});
-    // @ts-expect-error this returns unknown which doesn't satisfy the constraint
-    useLazyReference(withAstOrLoader, {}, { shouldFetch: 'Yes' });
-    useLazyReference(withAstOrLoader, {}, { shouldFetch: 'IfNecessary' });
+	const environment = require_IsographEnvironmentProvider.useIsographEnvironment();
+	if (entrypoint?.kind !== "Entrypoint") require_logging.logMessage(environment, () => ({
+		kind: "NonEntrypointReceived",
+		entrypoint
+	}));
+	return { fragmentReference: (0, __isograph_react_disposable_state.useLazyDisposableState)(require_getOrCreateCacheForArtifact.getOrCreateCacheForArtifact(environment, entrypoint, variables, fetchOptions)).state };
 }
+
+//#endregion
+exports.useLazyReference = useLazyReference;

package/dist/react/useLazyReference.mjs

@@ -0,0 +1,18 @@
+import { logMessage } from "../core/logging.mjs";
+import { useIsographEnvironment } from "./IsographEnvironmentProvider.mjs";
+import { getOrCreateCacheForArtifact } from "../core/getOrCreateCacheForArtifact.mjs";
+import { useLazyDisposableState } from "@isograph/react-disposable-state";
+
+//#region src/react/useLazyReference.ts
+function useLazyReference(entrypoint, variables, ...[fetchOptions]) {
+	const environment = useIsographEnvironment();
+	if (entrypoint?.kind !== "Entrypoint") logMessage(environment, () => ({
+		kind: "NonEntrypointReceived",
+		entrypoint
+	}));
+	return { fragmentReference: useLazyDisposableState(getOrCreateCacheForArtifact(environment, entrypoint, variables, fetchOptions)).state };
+}
+
+//#endregion
+export { useLazyReference };
+//# sourceMappingURL=useLazyReference.mjs.map

package/dist/react/useLazyReference.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLazyReference.mjs","names":[],"sources":["../../src/react/useLazyReference.ts"],"sourcesContent":["import { useLazyDisposableState } from '@isograph/react-disposable-state';\nimport { type NetworkResponseObject } from '../core/cache';\nimport type { FetchOptions } from '../core/check';\nimport { type RequiredFetchOptions } from '../core/check';\nimport type { IsographEntrypoint } from '../core/entrypoint';\nimport {\n  type NormalizationAst,\n  type NormalizationAstLoader,\n} from '../core/entrypoint';\nimport type {\n  ExtractParameters,\n  FragmentReference,\n} from '../core/FragmentReference';\nimport { type UnknownTReadFromStore } from '../core/FragmentReference';\nimport { logMessage } from '../core/logging';\nimport { useIsographEnvironment } from './IsographEnvironmentProvider';\nimport { getOrCreateCacheForArtifact } from '../core/getOrCreateCacheForArtifact';\n\nexport function useLazyReference<\n  TReadFromStore extends UnknownTReadFromStore,\n  TClientFieldValue,\n  TNormalizationAst extends NormalizationAst | NormalizationAstLoader,\n  TRawResponseType extends NetworkResponseObject,\n>(\n  entrypoint: IsographEntrypoint<\n    TReadFromStore,\n    TClientFieldValue,\n    TNormalizationAst,\n    TRawResponseType\n  >,\n  variables: ExtractParameters<TReadFromStore>,\n  ...[fetchOptions]: TNormalizationAst extends NormalizationAstLoader\n    ? [fetchOptions: RequiredFetchOptions<TClientFieldValue>]\n    : [fetchOptions?: FetchOptions<TClientFieldValue, TRawResponseType>]\n): NormalizationAst | NormalizationAstLoader extends TNormalizationAst\n  ? unknown\n  : {\n      fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>;\n    } {\n  const environment = useIsographEnvironment();\n\n  if (entrypoint?.kind !== 'Entrypoint') {\n    // TODO have a separate error logger\n    logMessage(environment, () => ({\n      kind: 'NonEntrypointReceived',\n      entrypoint,\n    }));\n  }\n\n  const cache = getOrCreateCacheForArtifact(\n    environment,\n    entrypoint,\n    variables,\n    fetchOptions,\n  );\n\n  return {\n    fragmentReference: useLazyDisposableState(cache).state,\n  };\n}\n\n// @ts-ignore\nfunction tsTests() {\n  let withAst!: IsographEntrypoint<any, unknown, NormalizationAst, any>;\n  let withAstLoader!: IsographEntrypoint<\n    any,\n    unknown,\n    NormalizationAstLoader,\n    {}\n  >;\n  let withAstOrLoader!: IsographEntrypoint<\n    any,\n    unknown,\n    NormalizationAst | NormalizationAstLoader,\n    {}\n  >;\n\n  useLazyReference(withAst, {}) satisfies {};\n  useLazyReference(withAst, {}, { shouldFetch: 'Yes' }) satisfies {};\n  useLazyReference(withAst, {}, { shouldFetch: 'IfNecessary' }) satisfies {};\n\n  // @ts-expect-error if there's no ast, require `shouldFetch` to be specified\n  useLazyReference(withAstLoader, {});\n  useLazyReference(withAstLoader, {}, { shouldFetch: 'Yes' }) satisfies {};\n  // @ts-expect-error if there's no ast, `shouldFetch` can't be `IfNecessary`\n  useLazyReference(withAstLoader, {}, { shouldFetch: 'IfNecessary' });\n\n  // if the type is unknown there can be no ast so we should use the same rules\n  // but because of TS bugs with inference we just return unknown\n  // @ts-expect-error this returns unknown which doesn't satisfy the constraint\n  useLazyReference(withAstOrLoader, {}) satisfies {};\n  // @ts-expect-error this returns unknown which doesn't satisfy the constraint\n  useLazyReference(withAstOrLoader, {}, { shouldFetch: 'Yes' }) satisfies {};\n  useLazyReference(\n    withAstOrLoader,\n    {},\n    { shouldFetch: 'IfNecessary' },\n    // @ts-expect-error this returns unknown which doesn't satisfy the constraint\n  ) satisfies {};\n}\n"],"mappings":";;;;;;AAkBA,SAAgB,iBAMd,YAMA,WACA,GAAG,CAAC,eAOA;CACJ,MAAM,cAAc,wBAAwB;AAE5C,KAAI,YAAY,SAAS,aAEvB,YAAW,oBAAoB;EAC7B,MAAM;EACN;EACD,EAAE;AAUL,QAAO,EACL,mBAAmB,uBARP,4BACZ,aACA,YACA,WACA,aACD,CAGiD,CAAC,OAClD"}

package/dist/react/useReadAndSubscribe.d.mts

@@ -0,0 +1,20 @@
+import { ReaderAst } from "../core/reader.mjs";
+import { NetworkRequestReaderOptions, WithEncounteredRecords } from "../core/read.mjs";
+import "../core/IsographEnvironment.mjs";
+import { ExtractData, FragmentReference, UnknownTReadFromStore } from "../core/FragmentReference.mjs";
+
+//#region src/react/useReadAndSubscribe.d.ts
+
+/**
+ * Read the data from a fragment reference and subscribe to updates.
+ */
+declare function useReadAndSubscribe<TReadFromStore extends UnknownTReadFromStore>(fragmentReference: FragmentReference<TReadFromStore, any>, networkRequestOptions: NetworkRequestReaderOptions, readerAst: ReaderAst<TReadFromStore>): ExtractData<TReadFromStore>;
+declare function useSubscribeToMultiple<TReadFromStore extends UnknownTReadFromStore>(items: ReadonlyArray<{
+  records: WithEncounteredRecords<TReadFromStore>;
+  callback: (updatedRecords: WithEncounteredRecords<TReadFromStore>) => void;
+  fragmentReference: FragmentReference<TReadFromStore, any>;
+  readerAst: ReaderAst<TReadFromStore>;
+}>): void;
+//#endregion
+export { useReadAndSubscribe, useSubscribeToMultiple };
+//# sourceMappingURL=useReadAndSubscribe.d.mts.map

package/dist/react/useReadAndSubscribe.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useReadAndSubscribe.d.mts","names":[],"sources":["../../src/react/useReadAndSubscribe.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAwBA;AACyB,iBADT,mBACS,CAAA,uBAAA,qBAAA,CAAA,CAAA,iBAAA,EAEJ,iBAFI,CAEc,cAFd,EAAA,GAAA,CAAA,EAAA,qBAAA,EAGA,2BAHA,EAAA,SAAA,EAIZ,SAJY,CAIF,cAJE,CAAA,CAAA,EAKtB,WALsB,CAKV,cALU,CAAA;AAEc,iBAiBvB,sBAjBuB,CAAA,uBAkBd,qBAlBc,CAAA,CAAA,KAAA,EAoB9B,aApB8B,CAAA;EAAlB,OAAA,EAqBR,sBArBQ,CAqBe,cArBf,CAAA;EACI,QAAA,EAAA,CAAA,cAAA,EAqBM,sBArBN,CAqB6B,cArB7B,CAAA,EAAA,GAAA,IAAA;EACF,iBAAA,EAqBA,iBArBA,CAqBkB,cArBlB,EAAA,GAAA,CAAA;EAAV,SAAA,EAsBE,SAtBF,CAsBY,cAtBZ,CAAA;CACE,CAAA,CAAA,EAAA,IAAA"}

package/dist/react/useReadAndSubscribe.d.ts

@@ -1,14 +1,19 @@
-import { ExtractData, FragmentReference, type UnknownTReadFromStore } from '../core/FragmentReference';
-import { NetworkRequestReaderOptions, WithEncounteredRecords } from '../core/read';
-import type { ReaderAst } from '../core/reader';
+import { ReaderAst } from "../core/reader.js";
+import { NetworkRequestReaderOptions, WithEncounteredRecords } from "../core/read.js";
+import { ExtractData, FragmentReference, UnknownTReadFromStore } from "../core/FragmentReference.js";
+
+//#region src/react/useReadAndSubscribe.d.ts
+
 /**
  * Read the data from a fragment reference and subscribe to updates.
  */
-export declare function useReadAndSubscribe<TReadFromStore extends UnknownTReadFromStore>(fragmentReference: FragmentReference<TReadFromStore, any>, networkRequestOptions: NetworkRequestReaderOptions, readerAst: ReaderAst<TReadFromStore>): ExtractData<TReadFromStore>;
-export declare function useSubscribeToMultiple<TReadFromStore extends UnknownTReadFromStore>(items: ReadonlyArray<{
-    records: WithEncounteredRecords<TReadFromStore>;
-    callback: (updatedRecords: WithEncounteredRecords<TReadFromStore>) => void;
-    fragmentReference: FragmentReference<TReadFromStore, any>;
-    readerAst: ReaderAst<TReadFromStore>;
+declare function useReadAndSubscribe<TReadFromStore extends UnknownTReadFromStore>(fragmentReference: FragmentReference<TReadFromStore, any>, networkRequestOptions: NetworkRequestReaderOptions, readerAst: ReaderAst<TReadFromStore>): ExtractData<TReadFromStore>;
+declare function useSubscribeToMultiple<TReadFromStore extends UnknownTReadFromStore>(items: ReadonlyArray<{
+  records: WithEncounteredRecords<TReadFromStore>;
+  callback: (updatedRecords: WithEncounteredRecords<TReadFromStore>) => void;
+  fragmentReference: FragmentReference<TReadFromStore, any>;
+  readerAst: ReaderAst<TReadFromStore>;
 }>): void;
+//#endregion
+export { useReadAndSubscribe, useSubscribeToMultiple };
 //# sourceMappingURL=useReadAndSubscribe.d.ts.map

package/dist/react/useReadAndSubscribe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useReadAndSubscribe.d.ts","sourceRoot":"","sources":["../../src/react/useReadAndSubscribe.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,WAAW,EACX,iBAAiB,EAEjB,KAAK,qBAAqB,EAC3B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,2BAA2B,EAE3B,sBAAsB,EACvB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAIhD;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,cAAc,SAAS,qBAAqB,EAE5C,iBAAiB,EAAE,iBAAiB,CAAC,cAAc,EAAE,GAAG,CAAC,EACzD,qBAAqB,EAAE,2BAA2B,EAClD,SAAS,EAAE,SAAS,CAAC,cAAc,CAAC,GACnC,WAAW,CAAC,cAAc,CAAC,CAY7B;AAED,wBAAgB,sBAAsB,CACpC,cAAc,SAAS,qBAAqB,EAE5C,KAAK,EAAE,aAAa,CAAC;IACnB,OAAO,EAAE,sBAAsB,CAAC,cAAc,CAAC,CAAC;IAChD,QAAQ,EAAE,CAAC,cAAc,EAAE,sBAAsB,CAAC,cAAc,CAAC,KAAK,IAAI,CAAC;IAC3E,iBAAiB,EAAE,iBAAiB,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC;IAC1D,SAAS,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC;CACtC,CAAC,QAiCH"}
+{"version":3,"file":"useReadAndSubscribe.d.ts","names":[],"sources":["../../src/react/useReadAndSubscribe.ts"],"sourcesContent":[],"mappings":";;;;;;;AAwBA;;AAGuC,iBAHvB,mBAGuB,CAAA,uBAFd,qBAEc,CAAA,CAAA,iBAAA,EAAlB,iBAAkB,CAAA,cAAA,EAAA,GAAA,CAAA,EAAA,qBAAA,EACd,2BADc,EAAA,SAAA,EAE1B,SAF0B,CAEhB,cAFgB,CAAA,CAAA,EAGpC,WAHoC,CAGxB,cAHwB,CAAA;AAAlB,iBAiBL,sBAjBK,CAAA,uBAkBI,qBAlBJ,CAAA,CAAA,KAAA,EAoBZ,aApBY,CAAA;EACI,OAAA,EAoBZ,sBApBY,CAoBW,cApBX,CAAA;EACF,QAAA,EAAA,CAAA,cAAA,EAoBQ,sBApBR,CAoB+B,cApB/B,CAAA,EAAA,GAAA,IAAA;EAAV,iBAAA,EAqBU,iBArBV,CAqB4B,cArB5B,EAAA,GAAA,CAAA;EACE,SAAA,EAqBA,SArBA,CAqBU,cArBV,CAAA;CAAZ,CAAA,CAAA,EAAA,IAAA"}

package/dist/react/useReadAndSubscribe.js

@@ -1,42 +1,62 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useReadAndSubscribe = useReadAndSubscribe;
-exports.useSubscribeToMultiple = useSubscribeToMultiple;
-const react_1 = require("react");
-const cache_1 = require("../core/cache");
-const FragmentReference_1 = require("../core/FragmentReference");
-const read_1 = require("../core/read");
-const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
-const useRerenderOnChange_1 = require("./useRerenderOnChange");
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
+const require_PromiseWrapper = require('../core/PromiseWrapper.js');
+const require_logging = require('../core/logging.js');
+const require_FragmentReference = require('../core/FragmentReference.js');
+const require_read = require('../core/read.js');
+const require_subscribe = require('../core/subscribe.js');
+const require_IsographEnvironmentProvider = require('./IsographEnvironmentProvider.js');
+const require_maybeUnwrapNetworkRequest = require('./maybeUnwrapNetworkRequest.js');
+const require_useRerenderOnChange = require('./useRerenderOnChange.js');
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+
+//#region src/react/useReadAndSubscribe.ts
 /**
- * Read the data from a fragment reference and subscribe to updates.
- */
+* Read the data from a fragment reference and subscribe to updates.
+*/
 function useReadAndSubscribe(fragmentReference, networkRequestOptions, readerAst) {
-    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
-    const [readOutDataAndRecords, setReadOutDataAndRecords] = (0, react_1.useState)(() => (0, read_1.readButDoNotEvaluate)(environment, fragmentReference, networkRequestOptions));
-    (0, useRerenderOnChange_1.useRerenderOnChange)(readOutDataAndRecords, fragmentReference, setReadOutDataAndRecords, readerAst);
-    return readOutDataAndRecords.item;
+	const environment = require_IsographEnvironmentProvider.useIsographEnvironment();
+	const [readOutDataAndRecords, setReadOutDataAndRecords] = (0, react.useState)(() => require_read.readButDoNotEvaluate(environment, fragmentReference, networkRequestOptions));
+	require_useRerenderOnChange.useRerenderOnChange(readOutDataAndRecords, fragmentReference, setReadOutDataAndRecords, readerAst);
+	return readOutDataAndRecords.item;
 }
 function useSubscribeToMultiple(items) {
-    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
-    (0, react_1.useEffect)(() => {
-        const cleanupFns = items.map(({ records, callback, fragmentReference, readerAst }) => {
-            return (0, cache_1.subscribe)(environment, records, fragmentReference, callback, readerAst);
-        });
-        return () => {
-            cleanupFns.forEach((loader) => {
-                loader();
-            });
-        };
-    }, 
-    // By analogy to useReadAndSubscribe, we can have an empty dependency array?
-    // Maybe callback has to be depended on. I don't know!
-    // TODO find out
-    [
-        items
-            .map(({ fragmentReference }) => {
-            (0, FragmentReference_1.stableIdForFragmentReference)(fragmentReference);
-        })
-            .join('.'),
-    ]);
+	const environment = require_IsographEnvironmentProvider.useIsographEnvironment();
+	(0, react.useEffect)(() => {
+		const cleanupFns = items.map(({ records, callback, fragmentReference, readerAst }) => {
+			return require_subscribe.subscribe(environment, records, fragmentReference, callback, readerAst);
+		});
+		return () => {
+			cleanupFns.forEach((loader) => {
+				loader();
+			});
+		};
+	}, [items.map(({ fragmentReference }) => {
+		require_FragmentReference.stableIdForFragmentReference(fragmentReference);
+	}).join(".")]);
 }
+const componentFunction = (environment, fragmentReference, networkRequestOptions, startUpdate) => {
+	function Component(additionalRuntimeProps) {
+		require_maybeUnwrapNetworkRequest.maybeUnwrapNetworkRequest(fragmentReference.networkRequest, networkRequestOptions);
+		const readerWithRefetchQueries = require_PromiseWrapper.readPromise(fragmentReference.readerWithRefetchQueries);
+		const data = useReadAndSubscribe(fragmentReference, networkRequestOptions, readerWithRefetchQueries.readerArtifact.readerAst);
+		require_logging.logMessage(environment, () => ({
+			kind: "ComponentRerendered",
+			componentName: fragmentReference.fieldName,
+			rootLink: fragmentReference.root
+		}));
+		return readerWithRefetchQueries.readerArtifact.resolver({
+			data,
+			parameters: fragmentReference.variables,
+			startUpdate: readerWithRefetchQueries.readerArtifact.hasUpdatable ? startUpdate : void 0
+		}, additionalRuntimeProps);
+	}
+	const idString = `(type: ${fragmentReference.root.__typename}, id: ${fragmentReference.root.__link})`;
+	Component.displayName = `${fragmentReference.fieldName} ${idString} @component`;
+	return Component;
+};
+
+//#endregion
+exports.componentFunction = componentFunction;
+exports.useReadAndSubscribe = useReadAndSubscribe;
+exports.useSubscribeToMultiple = useSubscribeToMultiple;

package/dist/react/useReadAndSubscribe.mjs

@@ -0,0 +1,59 @@
+import { readPromise } from "../core/PromiseWrapper.mjs";
+import { logMessage } from "../core/logging.mjs";
+import { stableIdForFragmentReference } from "../core/FragmentReference.mjs";
+import { readButDoNotEvaluate } from "../core/read.mjs";
+import { subscribe } from "../core/subscribe.mjs";
+import { useIsographEnvironment } from "./IsographEnvironmentProvider.mjs";
+import { maybeUnwrapNetworkRequest } from "./maybeUnwrapNetworkRequest.mjs";
+import { useRerenderOnChange } from "./useRerenderOnChange.mjs";
+import { useEffect, useState } from "react";
+
+//#region src/react/useReadAndSubscribe.ts
+/**
+* Read the data from a fragment reference and subscribe to updates.
+*/
+function useReadAndSubscribe(fragmentReference, networkRequestOptions, readerAst) {
+	const environment = useIsographEnvironment();
+	const [readOutDataAndRecords, setReadOutDataAndRecords] = useState(() => readButDoNotEvaluate(environment, fragmentReference, networkRequestOptions));
+	useRerenderOnChange(readOutDataAndRecords, fragmentReference, setReadOutDataAndRecords, readerAst);
+	return readOutDataAndRecords.item;
+}
+function useSubscribeToMultiple(items) {
+	const environment = useIsographEnvironment();
+	useEffect(() => {
+		const cleanupFns = items.map(({ records, callback, fragmentReference, readerAst }) => {
+			return subscribe(environment, records, fragmentReference, callback, readerAst);
+		});
+		return () => {
+			cleanupFns.forEach((loader) => {
+				loader();
+			});
+		};
+	}, [items.map(({ fragmentReference }) => {
+		stableIdForFragmentReference(fragmentReference);
+	}).join(".")]);
+}
+const componentFunction = (environment, fragmentReference, networkRequestOptions, startUpdate) => {
+	function Component(additionalRuntimeProps) {
+		maybeUnwrapNetworkRequest(fragmentReference.networkRequest, networkRequestOptions);
+		const readerWithRefetchQueries = readPromise(fragmentReference.readerWithRefetchQueries);
+		const data = useReadAndSubscribe(fragmentReference, networkRequestOptions, readerWithRefetchQueries.readerArtifact.readerAst);
+		logMessage(environment, () => ({
+			kind: "ComponentRerendered",
+			componentName: fragmentReference.fieldName,
+			rootLink: fragmentReference.root
+		}));
+		return readerWithRefetchQueries.readerArtifact.resolver({
+			data,
+			parameters: fragmentReference.variables,
+			startUpdate: readerWithRefetchQueries.readerArtifact.hasUpdatable ? startUpdate : void 0
+		}, additionalRuntimeProps);
+	}
+	const idString = `(type: ${fragmentReference.root.__typename}, id: ${fragmentReference.root.__link})`;
+	Component.displayName = `${fragmentReference.fieldName} ${idString} @component`;
+	return Component;
+};
+
+//#endregion
+export { componentFunction, useReadAndSubscribe, useSubscribeToMultiple };
+//# sourceMappingURL=useReadAndSubscribe.mjs.map

package/dist/react/useReadAndSubscribe.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useReadAndSubscribe.mjs","names":["componentFunction: IsographComponentFunction"],"sources":["../../src/react/useReadAndSubscribe.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\nimport {\n  type ExtractData,\n  type FragmentReference,\n  stableIdForFragmentReference,\n  type UnknownTReadFromStore,\n} from '../core/FragmentReference';\nimport type { IsographComponentFunction } from '../core/IsographEnvironment';\nimport { logMessage } from '../core/logging';\nimport { readPromise } from '../core/PromiseWrapper';\nimport {\n  type NetworkRequestReaderOptions,\n  readButDoNotEvaluate,\n  type WithEncounteredRecords,\n} from '../core/read';\nimport type { ReaderAst } from '../core/reader';\nimport { subscribe } from '../core/subscribe';\nimport { useIsographEnvironment } from './IsographEnvironmentProvider';\nimport { maybeUnwrapNetworkRequest } from './maybeUnwrapNetworkRequest';\nimport { useRerenderOnChange } from './useRerenderOnChange';\n\n/**\n * Read the data from a fragment reference and subscribe to updates.\n */\nexport function useReadAndSubscribe<\n  TReadFromStore extends UnknownTReadFromStore,\n>(\n  fragmentReference: FragmentReference<TReadFromStore, any>,\n  networkRequestOptions: NetworkRequestReaderOptions,\n  readerAst: ReaderAst<TReadFromStore>,\n): ExtractData<TReadFromStore> {\n  const environment = useIsographEnvironment();\n  const [readOutDataAndRecords, setReadOutDataAndRecords] = useState(() =>\n    readButDoNotEvaluate(environment, fragmentReference, networkRequestOptions),\n  );\n  useRerenderOnChange(\n    readOutDataAndRecords,\n    fragmentReference,\n    setReadOutDataAndRecords,\n    readerAst,\n  );\n  return readOutDataAndRecords.item;\n}\n\nexport function useSubscribeToMultiple<\n  TReadFromStore extends UnknownTReadFromStore,\n>(\n  items: ReadonlyArray<{\n    records: WithEncounteredRecords<TReadFromStore>;\n    callback: (updatedRecords: WithEncounteredRecords<TReadFromStore>) => void;\n    fragmentReference: FragmentReference<TReadFromStore, any>;\n    readerAst: ReaderAst<TReadFromStore>;\n  }>,\n) {\n  const environment = useIsographEnvironment();\n  useEffect(\n    () => {\n      const cleanupFns = items.map(\n        ({ records, callback, fragmentReference, readerAst }) => {\n          return subscribe(\n            environment,\n            records,\n            fragmentReference,\n            callback,\n            readerAst,\n          );\n        },\n      );\n      return () => {\n        cleanupFns.forEach((loader) => {\n          loader();\n        });\n      };\n    },\n    // By analogy to useReadAndSubscribe, we can have an empty dependency array?\n    // Maybe callback has to be depended on. I don't know!\n    // TODO find out\n    [\n      items\n        .map(({ fragmentReference }) => {\n          stableIdForFragmentReference(fragmentReference);\n        })\n        .join('.'),\n    ],\n  );\n}\n\nexport const componentFunction: IsographComponentFunction = (\n  environment,\n  fragmentReference,\n  networkRequestOptions,\n  startUpdate,\n) => {\n  function Component(additionalRuntimeProps: { [key: string]: any }) {\n    maybeUnwrapNetworkRequest(\n      fragmentReference.networkRequest,\n      networkRequestOptions,\n    );\n    const readerWithRefetchQueries = readPromise(\n      fragmentReference.readerWithRefetchQueries,\n    );\n\n    const data = useReadAndSubscribe(\n      fragmentReference,\n      networkRequestOptions,\n      readerWithRefetchQueries.readerArtifact.readerAst,\n    );\n\n    logMessage(environment, () => ({\n      kind: 'ComponentRerendered',\n      componentName: fragmentReference.fieldName,\n      rootLink: fragmentReference.root,\n    }));\n\n    return readerWithRefetchQueries.readerArtifact.resolver(\n      // @ts-expect-error\n      {\n        data,\n        parameters: fragmentReference.variables,\n        startUpdate: readerWithRefetchQueries.readerArtifact.hasUpdatable\n          ? startUpdate\n          : undefined,\n      },\n      additionalRuntimeProps,\n    );\n  }\n  const idString = `(type: ${fragmentReference.root.__typename}, id: ${fragmentReference.root.__link})`;\n  Component.displayName = `${fragmentReference.fieldName} ${idString} @component`;\n  return Component;\n};\n"],"mappings":";;;;;;;;;;;;;;AAwBA,SAAgB,oBAGd,mBACA,uBACA,WAC6B;CAC7B,MAAM,cAAc,wBAAwB;CAC5C,MAAM,CAAC,uBAAuB,4BAA4B,eACxD,qBAAqB,aAAa,mBAAmB,sBAAsB,CAC5E;AACD,qBACE,uBACA,mBACA,0BACA,UACD;AACD,QAAO,sBAAsB;;AAG/B,SAAgB,uBAGd,OAMA;CACA,MAAM,cAAc,wBAAwB;AAC5C,iBACQ;EACJ,MAAM,aAAa,MAAM,KACtB,EAAE,SAAS,UAAU,mBAAmB,gBAAgB;AACvD,UAAO,UACL,aACA,SACA,mBACA,UACA,UACD;IAEJ;AACD,eAAa;AACX,cAAW,SAAS,WAAW;AAC7B,YAAQ;KACR;;IAMN,CACE,MACG,KAAK,EAAE,wBAAwB;AAC9B,+BAA6B,kBAAkB;GAC/C,CACD,KAAK,IAAI,CACb,CACF;;AAGH,MAAaA,qBACX,aACA,mBACA,uBACA,gBACG;CACH,SAAS,UAAU,wBAAgD;AACjE,4BACE,kBAAkB,gBAClB,sBACD;EACD,MAAM,2BAA2B,YAC/B,kBAAkB,yBACnB;EAED,MAAM,OAAO,oBACX,mBACA,uBACA,yBAAyB,eAAe,UACzC;AAED,aAAW,oBAAoB;GAC7B,MAAM;GACN,eAAe,kBAAkB;GACjC,UAAU,kBAAkB;GAC7B,EAAE;AAEH,SAAO,yBAAyB,eAAe,SAE7C;GACE;GACA,YAAY,kBAAkB;GAC9B,aAAa,yBAAyB,eAAe,eACjD,cACA;GACL,EACD,uBACD;;CAEH,MAAM,WAAW,UAAU,kBAAkB,KAAK,WAAW,QAAQ,kBAAkB,KAAK,OAAO;AACnG,WAAU,cAAc,GAAG,kBAAkB,UAAU,GAAG,SAAS;AACnE,QAAO"}

package/dist/react/useRerenderOnChange.d.mts

@@ -0,0 +1,12 @@
+import { ReaderAst } from "../core/reader.mjs";
+import { WithEncounteredRecords } from "../core/read.mjs";
+import { FragmentReference } from "../core/FragmentReference.mjs";
+
+//#region src/react/useRerenderOnChange.d.ts
+declare function useRerenderOnChange<TReadFromStore extends {
+  parameters: object;
+  data: object;
+}>(encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>, fragmentReference: FragmentReference<any, any>, setEncounteredDataAndRecords: (data: WithEncounteredRecords<TReadFromStore>) => void, readerAst: ReaderAst<TReadFromStore>): void;
+//#endregion
+export { useRerenderOnChange };
+//# sourceMappingURL=useRerenderOnChange.d.mts.map

package/dist/react/useRerenderOnChange.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRerenderOnChange.d.mts","names":[],"sources":["../../src/react/useRerenderOnChange.ts"],"sourcesContent":[],"mappings":";;;;;iBASgB;;EAAA,IAAA,EAAA,MAAA;CAGoC,CAAA,CAAA,yBAAA,EAAvB,sBAAuB,CAAA,cAAA,CAAA,EAAA,iBAAA,EAC/B,iBAD+B,CAAA,GAAA,EAAA,GAAA,CAAA,EAAA,4BAAA,EAAA,CAAA,IAAA,EAG1C,sBAH0C,CAGnB,cAHmB,CAAA,EAAA,GAAA,IAAA,EAAA,SAAA,EAKvC,SALuC,CAK7B,cAL6B,CAAA,CAAA,EAAA,IAAA"}

package/dist/react/useRerenderOnChange.d.ts

@@ -1,8 +1,12 @@
-import { FragmentReference } from '../core/FragmentReference';
-import { WithEncounteredRecords } from '../core/read';
-import type { ReaderAst } from '../core/reader';
-export declare function useRerenderOnChange<TReadFromStore extends {
-    parameters: object;
-    data: object;
+import { ReaderAst } from "../core/reader.js";
+import { WithEncounteredRecords } from "../core/read.js";
+import { FragmentReference } from "../core/FragmentReference.js";
+
+//#region src/react/useRerenderOnChange.d.ts
+declare function useRerenderOnChange<TReadFromStore extends {
+  parameters: object;
+  data: object;
 }>(encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>, fragmentReference: FragmentReference<any, any>, setEncounteredDataAndRecords: (data: WithEncounteredRecords<TReadFromStore>) => void, readerAst: ReaderAst<TReadFromStore>): void;
+//#endregion
+export { useRerenderOnChange };
 //# sourceMappingURL=useRerenderOnChange.d.ts.map

package/dist/react/useRerenderOnChange.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useRerenderOnChange.d.ts","sourceRoot":"","sources":["../../src/react/useRerenderOnChange.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAKhD,wBAAgB,mBAAmB,CACjC,cAAc,SAAS;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAE3D,yBAAyB,EAAE,sBAAsB,CAAC,cAAc,CAAC,EACjE,iBAAiB,EAAE,iBAAiB,CAAC,GAAG,EAAE,GAAG,CAAC,EAC9C,4BAA4B,EAAE,CAC5B,IAAI,EAAE,sBAAsB,CAAC,cAAc,CAAC,KACzC,IAAI,EACT,SAAS,EAAE,SAAS,CAAC,cAAc,CAAC,QAoBrC"}
+{"version":3,"file":"useRerenderOnChange.d.ts","names":[],"sources":["../../src/react/useRerenderOnChange.ts"],"sourcesContent":[],"mappings":";;;;;iBASgB;;EAAA,IAAA,EAAA,MAAA;CAGoC,CAAA,CAAA,yBAAA,EAAvB,sBAAuB,CAAA,cAAA,CAAA,EAAA,iBAAA,EAC/B,iBAD+B,CAAA,GAAA,EAAA,GAAA,CAAA,EAAA,4BAAA,EAAA,CAAA,IAAA,EAG1C,sBAH0C,CAGnB,cAHmB,CAAA,EAAA,GAAA,IAAA,EAAA,SAAA,EAKvC,SALuC,CAK7B,cAL6B,CAAA,CAAA,EAAA,IAAA"}

package/dist/react/useRerenderOnChange.js

@@ -1,22 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useRerenderOnChange = useRerenderOnChange;
-const react_1 = require("react");
-const cache_1 = require("../core/cache");
-const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
-// TODO add unit tests for this. Add integration tests that test
-// behavior when the encounteredRecords underneath a fragment change.
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
+const require_subscribe = require('../core/subscribe.js');
+const require_IsographEnvironmentProvider = require('./IsographEnvironmentProvider.js');
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+
+//#region src/react/useRerenderOnChange.ts
 function useRerenderOnChange(encounteredDataAndRecords, fragmentReference, setEncounteredDataAndRecords, readerAst) {
-    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
-    (0, react_1.useEffect)(() => {
-        return (0, cache_1.subscribe)(environment, encounteredDataAndRecords, fragmentReference, (newEncounteredDataAndRecords) => {
-            setEncounteredDataAndRecords(newEncounteredDataAndRecords);
-        }, readerAst);
-        // Note: this is an empty array on purpose:
-        // - the fragment reference is stable for the life of the component
-        // - ownership of encounteredDataAndRecords is transferred into the
-        //   environment
-        // - though maybe we need to include setEncounteredDataAndRecords in
-        //   the dependency array
-    }, []);
+	const environment = require_IsographEnvironmentProvider.useIsographEnvironment();
+	(0, react.useEffect)(() => {
+		return require_subscribe.subscribe(environment, encounteredDataAndRecords, fragmentReference, (newEncounteredDataAndRecords) => {
+			setEncounteredDataAndRecords(newEncounteredDataAndRecords);
+		}, readerAst);
+	}, []);
 }
+
+//#endregion
+exports.useRerenderOnChange = useRerenderOnChange;

package/dist/react/useRerenderOnChange.mjs

@@ -0,0 +1,17 @@
+import { subscribe } from "../core/subscribe.mjs";
+import { useIsographEnvironment } from "./IsographEnvironmentProvider.mjs";
+import { useEffect } from "react";
+
+//#region src/react/useRerenderOnChange.ts
+function useRerenderOnChange(encounteredDataAndRecords, fragmentReference, setEncounteredDataAndRecords, readerAst) {
+	const environment = useIsographEnvironment();
+	useEffect(() => {
+		return subscribe(environment, encounteredDataAndRecords, fragmentReference, (newEncounteredDataAndRecords) => {
+			setEncounteredDataAndRecords(newEncounteredDataAndRecords);
+		}, readerAst);
+	}, []);
+}
+
+//#endregion
+export { useRerenderOnChange };
+//# sourceMappingURL=useRerenderOnChange.mjs.map

package/dist/react/useRerenderOnChange.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRerenderOnChange.mjs","names":[],"sources":["../../src/react/useRerenderOnChange.ts"],"sourcesContent":["import { useEffect } from 'react';\nimport type { FragmentReference } from '../core/FragmentReference';\nimport type { WithEncounteredRecords } from '../core/read';\nimport type { ReaderAst } from '../core/reader';\nimport { subscribe } from '../core/subscribe';\nimport { useIsographEnvironment } from './IsographEnvironmentProvider';\n\n// TODO add unit tests for this. Add integration tests that test\n// behavior when the encounteredRecords underneath a fragment change.\nexport function useRerenderOnChange<\n  TReadFromStore extends { parameters: object; data: object },\n>(\n  encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>,\n  fragmentReference: FragmentReference<any, any>,\n  setEncounteredDataAndRecords: (\n    data: WithEncounteredRecords<TReadFromStore>,\n  ) => void,\n  readerAst: ReaderAst<TReadFromStore>,\n) {\n  const environment = useIsographEnvironment();\n  useEffect(() => {\n    return subscribe(\n      environment,\n      encounteredDataAndRecords,\n      fragmentReference,\n      (newEncounteredDataAndRecords) => {\n        setEncounteredDataAndRecords(newEncounteredDataAndRecords);\n      },\n      readerAst,\n    );\n    // Note: this is an empty array on purpose:\n    // - the fragment reference is stable for the life of the component\n    // - ownership of encounteredDataAndRecords is transferred into the\n    //   environment\n    // - though maybe we need to include setEncounteredDataAndRecords in\n    //   the dependency array\n  }, []);\n}\n"],"mappings":";;;;;AASA,SAAgB,oBAGd,2BACA,mBACA,8BAGA,WACA;CACA,MAAM,cAAc,wBAAwB;AAC5C,iBAAgB;AACd,SAAO,UACL,aACA,2BACA,oBACC,iCAAiC;AAChC,gCAA6B,6BAA6B;KAE5D,UACD;IAOA,EAAE,CAAC"}

package/dist/react/useResult.d.mts

@@ -0,0 +1,8 @@
+import { NetworkRequestReaderOptions } from "../core/read.mjs";
+import { FragmentReference, UnknownTReadFromStore } from "../core/FragmentReference.mjs";
+
+//#region src/react/useResult.d.ts
+declare function useResult<TReadFromStore extends UnknownTReadFromStore, TClientFieldValue>(fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>, partialNetworkRequestOptions?: Partial<NetworkRequestReaderOptions> | void): TClientFieldValue;
+//#endregion
+export { useResult };
+//# sourceMappingURL=useResult.d.mts.map

package/dist/react/useResult.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useResult.d.mts","names":[],"sources":["../../src/react/useResult.ts"],"sourcesContent":[],"mappings":";;;;iBAegB,iCACS,6DAGJ,kBAAkB,gBAAgB,mDACtB,QAAQ,sCACtC"}

package/dist/react/useResult.d.ts

@@ -1,6 +1,8 @@
-import { FragmentReference, type UnknownTReadFromStore } from '../core/FragmentReference';
-import { PromiseWrapper } from '../core/PromiseWrapper';
-import { NetworkRequestReaderOptions } from '../core/read';
-export declare function useResult<TReadFromStore extends UnknownTReadFromStore, TClientFieldValue>(fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>, partialNetworkRequestOptions?: Partial<NetworkRequestReaderOptions> | void): TClientFieldValue;
-export declare function maybeUnwrapNetworkRequest(networkRequest: PromiseWrapper<void, any>, networkRequestOptions: NetworkRequestReaderOptions): void;
+import { NetworkRequestReaderOptions } from "../core/read.js";
+import { FragmentReference, UnknownTReadFromStore } from "../core/FragmentReference.js";
+
+//#region src/react/useResult.d.ts
+declare function useResult<TReadFromStore extends UnknownTReadFromStore, TClientFieldValue>(fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>, partialNetworkRequestOptions?: Partial<NetworkRequestReaderOptions> | void): TClientFieldValue;
+//#endregion
+export { useResult };
 //# sourceMappingURL=useResult.d.ts.map

package/dist/react/useResult.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useResult.d.ts","sourceRoot":"","sources":["../../src/react/useResult.ts"],"names":[],"mappings":"AACA,OAAO,EACL,iBAAiB,EACjB,KAAK,qBAAqB,EAC3B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAEL,cAAc,EAEf,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAEL,2BAA2B,EAC5B,MAAM,cAAc,CAAC;AAKtB,wBAAgB,SAAS,CACvB,cAAc,SAAS,qBAAqB,EAC5C,iBAAiB,EAEjB,iBAAiB,EAAE,iBAAiB,CAAC,cAAc,EAAE,iBAAiB,CAAC,EACvE,4BAA4B,CAAC,EAAE,OAAO,CAAC,2BAA2B,CAAC,GAAG,IAAI,GACzE,iBAAiB,CA6CnB;AAED,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,EACzC,qBAAqB,EAAE,2BAA2B,QAWnD"}
+{"version":3,"file":"useResult.d.ts","names":[],"sources":["../../src/react/useResult.ts"],"sourcesContent":[],"mappings":";;;;iBAegB,iCACS,6DAGJ,kBAAkB,gBAAgB,mDACtB,QAAQ,sCACtC"}

package/dist/react/useResult.js

@@ -1,42 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useResult = useResult;
-exports.maybeUnwrapNetworkRequest = maybeUnwrapNetworkRequest;
-const componentCache_1 = require("../core/componentCache");
-const PromiseWrapper_1 = require("../core/PromiseWrapper");
-const read_1 = require("../core/read");
-const startUpdate_1 = require("../core/startUpdate");
-const IsographEnvironmentProvider_1 = require("../react/IsographEnvironmentProvider");
-const useReadAndSubscribe_1 = require("./useReadAndSubscribe");
+const require_PromiseWrapper = require('../core/PromiseWrapper.js');
+const require_startUpdate = require('../core/startUpdate.js');
+const require_componentCache = require('../core/componentCache.js');
+const require_read = require('../core/read.js');
+const require_IsographEnvironmentProvider = require('./IsographEnvironmentProvider.js');
+const require_maybeUnwrapNetworkRequest = require('./maybeUnwrapNetworkRequest.js');
+const require_useReadAndSubscribe = require('./useReadAndSubscribe.js');
+
+//#region src/react/useResult.ts
 function useResult(fragmentReference, partialNetworkRequestOptions) {
-    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
-    const networkRequestOptions = (0, read_1.getNetworkRequestOptionsWithDefaults)(partialNetworkRequestOptions);
-    switch (fragmentReference.readerArtifactKind) {
-        case 'ComponentReaderArtifact': {
-            // @ts-expect-error
-            return (0, componentCache_1.getOrCreateCachedComponent)(environment, fragmentReference, networkRequestOptions);
-        }
-        case 'EagerReaderArtifact': {
-            maybeUnwrapNetworkRequest(fragmentReference.networkRequest, networkRequestOptions);
-            const readerWithRefetchQueries = (0, PromiseWrapper_1.readPromise)(fragmentReference.readerWithRefetchQueries);
-            const data = (0, useReadAndSubscribe_1.useReadAndSubscribe)(fragmentReference, networkRequestOptions, readerWithRefetchQueries.readerArtifact.readerAst);
-            const param = Object.assign({ data: data, parameters: fragmentReference.variables }, (readerWithRefetchQueries.readerArtifact.hasUpdatable
-                ? {
-                    startUpdate: (0, startUpdate_1.getOrCreateCachedStartUpdate)(environment, fragmentReference, networkRequestOptions),
-                }
-                : undefined));
-            // @ts-expect-error
-            return readerWithRefetchQueries.readerArtifact.resolver(param);
-        }
-    }
-}
-function maybeUnwrapNetworkRequest(networkRequest, networkRequestOptions) {
-    const state = (0, PromiseWrapper_1.getPromiseState)(networkRequest);
-    if (state.kind === 'Err' && networkRequestOptions.throwOnNetworkError) {
-        throw state.error;
-    }
-    else if (state.kind === 'Pending' &&
-        networkRequestOptions.suspendIfInFlight) {
-        throw state.promise;
-    }
+	const environment = require_IsographEnvironmentProvider.useIsographEnvironment();
+	const networkRequestOptions = require_read.getNetworkRequestOptionsWithDefaults(partialNetworkRequestOptions);
+	switch (fragmentReference.readerArtifactKind) {
+		case "ComponentReaderArtifact": return require_componentCache.getOrCreateCachedComponent(environment, fragmentReference, networkRequestOptions);
+		case "EagerReaderArtifact": {
+			require_maybeUnwrapNetworkRequest.maybeUnwrapNetworkRequest(fragmentReference.networkRequest, networkRequestOptions);
+			const readerWithRefetchQueries = require_PromiseWrapper.readPromise(fragmentReference.readerWithRefetchQueries);
+			const param = {
+				data: require_useReadAndSubscribe.useReadAndSubscribe(fragmentReference, networkRequestOptions, readerWithRefetchQueries.readerArtifact.readerAst),
+				parameters: fragmentReference.variables,
+				...readerWithRefetchQueries.readerArtifact.hasUpdatable ? { startUpdate: require_startUpdate.getOrCreateCachedStartUpdate(environment, fragmentReference, networkRequestOptions) } : void 0
+			};
+			return readerWithRefetchQueries.readerArtifact.resolver(param);
+		}
+	}
 }
+
+//#endregion
+exports.useResult = useResult;

package/dist/react/useResult.mjs

@@ -0,0 +1,30 @@
+import { readPromise } from "../core/PromiseWrapper.mjs";
+import { getOrCreateCachedStartUpdate } from "../core/startUpdate.mjs";
+import { getOrCreateCachedComponent } from "../core/componentCache.mjs";
+import { getNetworkRequestOptionsWithDefaults } from "../core/read.mjs";
+import { useIsographEnvironment } from "./IsographEnvironmentProvider.mjs";
+import { maybeUnwrapNetworkRequest } from "./maybeUnwrapNetworkRequest.mjs";
+import { useReadAndSubscribe } from "./useReadAndSubscribe.mjs";
+
+//#region src/react/useResult.ts
+function useResult(fragmentReference, partialNetworkRequestOptions) {
+	const environment = useIsographEnvironment();
+	const networkRequestOptions = getNetworkRequestOptionsWithDefaults(partialNetworkRequestOptions);
+	switch (fragmentReference.readerArtifactKind) {
+		case "ComponentReaderArtifact": return getOrCreateCachedComponent(environment, fragmentReference, networkRequestOptions);
+		case "EagerReaderArtifact": {
+			maybeUnwrapNetworkRequest(fragmentReference.networkRequest, networkRequestOptions);
+			const readerWithRefetchQueries = readPromise(fragmentReference.readerWithRefetchQueries);
+			const param = {
+				data: useReadAndSubscribe(fragmentReference, networkRequestOptions, readerWithRefetchQueries.readerArtifact.readerAst),
+				parameters: fragmentReference.variables,
+				...readerWithRefetchQueries.readerArtifact.hasUpdatable ? { startUpdate: getOrCreateCachedStartUpdate(environment, fragmentReference, networkRequestOptions) } : void 0
+			};
+			return readerWithRefetchQueries.readerArtifact.resolver(param);
+		}
+	}
+}
+
+//#endregion
+export { useResult };
+//# sourceMappingURL=useResult.mjs.map

package/dist/react/useResult.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useResult.mjs","names":[],"sources":["../../src/react/useResult.ts"],"sourcesContent":["import { getOrCreateCachedComponent } from '../core/componentCache';\nimport type {\n  FragmentReference,\n  UnknownTReadFromStore,\n} from '../core/FragmentReference';\nimport { readPromise } from '../core/PromiseWrapper';\nimport {\n  type NetworkRequestReaderOptions,\n  getNetworkRequestOptionsWithDefaults,\n} from '../core/read';\nimport { getOrCreateCachedStartUpdate } from '../core/startUpdate';\nimport { useIsographEnvironment } from './IsographEnvironmentProvider';\nimport { maybeUnwrapNetworkRequest } from './maybeUnwrapNetworkRequest';\nimport { useReadAndSubscribe } from './useReadAndSubscribe';\n\nexport function useResult<\n  TReadFromStore extends UnknownTReadFromStore,\n  TClientFieldValue,\n>(\n  fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>,\n  partialNetworkRequestOptions?: Partial<NetworkRequestReaderOptions> | void,\n): TClientFieldValue {\n  const environment = useIsographEnvironment();\n  const networkRequestOptions = getNetworkRequestOptionsWithDefaults(\n    partialNetworkRequestOptions,\n  );\n\n  switch (fragmentReference.readerArtifactKind) {\n    case 'ComponentReaderArtifact': {\n      // @ts-expect-error\n      return getOrCreateCachedComponent(\n        environment,\n        fragmentReference,\n        networkRequestOptions,\n      );\n    }\n    case 'EagerReaderArtifact': {\n      maybeUnwrapNetworkRequest(\n        fragmentReference.networkRequest,\n        networkRequestOptions,\n      );\n      const readerWithRefetchQueries = readPromise(\n        fragmentReference.readerWithRefetchQueries,\n      );\n      const data = useReadAndSubscribe(\n        fragmentReference,\n        networkRequestOptions,\n        readerWithRefetchQueries.readerArtifact.readerAst,\n      );\n      const param = {\n        data: data,\n        parameters: fragmentReference.variables,\n        ...(readerWithRefetchQueries.readerArtifact.hasUpdatable\n          ? {\n              startUpdate: getOrCreateCachedStartUpdate(\n                environment,\n                fragmentReference,\n                networkRequestOptions,\n              ),\n            }\n          : undefined),\n      };\n      // @ts-expect-error\n      return readerWithRefetchQueries.readerArtifact.resolver(param);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;AAeA,SAAgB,UAId,mBACA,8BACmB;CACnB,MAAM,cAAc,wBAAwB;CAC5C,MAAM,wBAAwB,qCAC5B,6BACD;AAED,SAAQ,kBAAkB,oBAA1B;EACE,KAAK,0BAEH,QAAO,2BACL,aACA,mBACA,sBACD;EAEH,KAAK,uBAAuB;AAC1B,6BACE,kBAAkB,gBAClB,sBACD;GACD,MAAM,2BAA2B,YAC/B,kBAAkB,yBACnB;GAMD,MAAM,QAAQ;IACZ,MANW,oBACX,mBACA,uBACA,yBAAyB,eAAe,UACzC;IAGC,YAAY,kBAAkB;IAC9B,GAAI,yBAAyB,eAAe,eACxC,EACE,aAAa,6BACX,aACA,mBACA,sBACD,EACF,GACD;IACL;AAED,UAAO,yBAAyB,eAAe,SAAS,MAAM"}