@isograph/react 0.0.0-main-ad899464 → 0.0.0-main-084bfeee

package/dist/FragmentReference.d.ts

@@ -1,14 +1,14 @@
 import { DataId } from './IsographEnvironment';
-import { RefetchQueryArtifactWrapper } from './entrypoint';
-import { ReaderArtifact } from './reader';
+import { RefetchQueryNormalizationArtifactWrapper } from './entrypoint';
+import { TopLevelReaderArtifact } from './reader';
 export type Variable = any;
 export type Variables = {
     readonly [index: string]: Variable;
 };
 export type FragmentReference<TReadFromStore extends Object, TClientFieldValue> = {
-    kind: 'FragmentReference';
-    readerArtifact: ReaderArtifact<TReadFromStore, TClientFieldValue>;
-    root: DataId;
-    variables: Variables | null;
-    nestedRefetchQueries: RefetchQueryArtifactWrapper[];
+    readonly kind: 'FragmentReference';
+    readonly readerArtifact: TopLevelReaderArtifact<TReadFromStore, TClientFieldValue, any>;
+    readonly root: DataId;
+    readonly variables: Variables | null;
+    readonly nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[];
 };

package/dist/IsographEnvironment.d.ts

@@ -29,15 +29,15 @@ type SuspenseCache = {
     [index: string]: ParentCache<any>;
 };
 export type IsographEnvironment = {
-    store: IsographStore;
-    networkFunction: IsographNetworkFunction;
-    missingFieldHandler: MissingFieldHandler | null;
-    componentCache: ComponentCache;
-    subscriptions: Subscriptions;
-    suspenseCache: SuspenseCache;
-    retainedQueries: Set<RetainedQuery>;
-    gcBuffer: Array<RetainedQuery>;
-    gcBufferSize: number;
+    readonly store: IsographStore;
+    readonly networkFunction: IsographNetworkFunction;
+    readonly missingFieldHandler: MissingFieldHandler | null;
+    readonly componentCache: ComponentCache;
+    readonly subscriptions: Subscriptions;
+    readonly suspenseCache: SuspenseCache;
+    readonly retainedQueries: Set<RetainedQuery>;
+    readonly gcBuffer: Array<RetainedQuery>;
+    readonly gcBufferSize: number;
 };
 export type MissingFieldHandler = (storeRecord: StoreRecord, root: DataId, fieldName: string, arguments_: {
     [index: string]: any;
@@ -46,18 +46,18 @@ export type MissingFieldHandler = (storeRecord: StoreRecord, root: DataId, field
 } | null) => Link | undefined;
 export type IsographNetworkFunction = (queryText: string, variables: object) => Promise<any>;
 export type Link = {
-    __link: DataId;
+    readonly __link: DataId;
 };
 export type DataTypeValue = undefined | number | boolean | string | null | Link | DataTypeValue[];
 export type StoreRecord = {
     [index: DataId | string]: DataTypeValue;
-    id?: DataId;
+    readonly id?: DataId;
 };
 export type DataId = string;
 export declare const ROOT_ID: DataId & '__ROOT';
 export type IsographStore = {
     [index: DataId]: StoreRecord | null;
-    __ROOT: StoreRecord;
+    readonly __ROOT: StoreRecord;
 };
 export declare function createIsographEnvironment(store: IsographStore, networkFunction: IsographNetworkFunction, missingFieldHandler?: MissingFieldHandler): IsographEnvironment;
 export declare function createIsographStore(): {

package/dist/IsographEnvironmentProvider.d.ts

@@ -3,8 +3,8 @@ import { ReactNode } from 'react';
 import { type IsographEnvironment } from './IsographEnvironment';
 export declare const IsographEnvironmentContext: React.Context<IsographEnvironment | null>;
 export type IsographEnvironmentProviderProps = {
-    environment: IsographEnvironment;
-    children: ReactNode;
+    readonly environment: IsographEnvironment;
+    readonly children: ReactNode;
 };
 export declare function IsographEnvironmentProvider({ environment, children, }: IsographEnvironmentProviderProps): React.JSX.Element;
 export declare function useIsographEnvironment(): IsographEnvironment;

package/dist/PromiseWrapper.d.ts

@@ -5,7 +5,7 @@ type NotSet = typeof NOT_SET;
  * Before the promise is resolved, value becomes non-null.
  */
 export type PromiseWrapper<T> = {
-    promise: Promise<T>;
+    readonly promise: Promise<T>;
     value: Exclude<T, NotSet> | NotSet;
 };
 export declare function wrapPromise<T>(promise: Promise<T>): PromiseWrapper<T>;

package/dist/cache.d.ts

@@ -1,7 +1,7 @@
 import { ItemCleanupPair, ParentCache } from '@isograph/react-disposable-state';
 import { PromiseWrapper } from './PromiseWrapper';
 import { type IsographEnvironment } from './IsographEnvironment';
-import { IsographEntrypoint, NormalizationLinkedField, NormalizationScalarField } from './entrypoint';
+import { IsographEntrypoint, NormalizationLinkedField, NormalizationScalarField, RefetchQueryNormalizationArtifact } from './entrypoint';
 import { ReaderLinkedField, ReaderScalarField } from './reader';
 import { WithEncounteredRecords } from './read';
 import { FragmentReference } from './FragmentReference';
@@ -16,9 +16,8 @@ declare global {
  * results.
  */
 export declare function stableCopy<T>(value: T): T;
-type IsoResolver = IsographEntrypoint<any, any>;
 export declare function getOrCreateCacheForArtifact<TReadFromStore extends Object, TClientFieldValue>(environment: IsographEnvironment, artifact: IsographEntrypoint<TReadFromStore, TClientFieldValue>, variables: object): ParentCache<PromiseWrapper<TClientFieldValue>>;
-export declare function makeNetworkRequest<T>(environment: IsographEnvironment, artifact: IsoResolver, variables: object): ItemCleanupPair<PromiseWrapper<T>>;
+export declare function makeNetworkRequest<T>(environment: IsographEnvironment, artifact: RefetchQueryNormalizationArtifact | IsographEntrypoint<any, any>, variables: object): ItemCleanupPair<PromiseWrapper<T>>;
 export declare function subscribeToAnyChange(environment: IsographEnvironment, callback: () => void): () => void;
 export declare function subscribe<TReadFromStore extends Object>(environment: IsographEnvironment, encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>, fragmentReference: FragmentReference<TReadFromStore, any>, callback: (newEncounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>) => void): () => void;
 export declare function onNextChange(environment: IsographEnvironment): Promise<void>;
@@ -27,4 +26,3 @@ export declare function getParentRecordKey(astNode: NormalizationLinkedField | N
 }): string;
 export declare const FIRST_SPLIT_KEY = "____";
 export declare const SECOND_SPLIT_KEY = "___";
-export {};

package/dist/cache.js

@@ -63,7 +63,7 @@ function makeNetworkRequest(environment, artifact, variables) {
             console.log('network response', artifact, artifact);
         }
         if (status.kind === 'UndisposedIncomplete') {
-            normalizeData(environment, artifact.normalizationAst, networkResponse.data, variables, artifact.nestedRefetchQueries);
+            normalizeData(environment, artifact.normalizationAst, networkResponse.data, variables, artifact.kind === 'Entrypoint' ? artifact.nestedRefetchQueries : []);
             const retainedQuery = {
                 normalizationAst: artifact.normalizationAst,
                 variables,

package/dist/entrypoint.d.ts

@@ -1,33 +1,33 @@
-import { ReaderArtifact } from './reader';
+import { TopLevelReaderArtifact } from './reader';
 import { Arguments } from './util';
 export type IsographEntrypoint<TReadFromStore extends Object, TClientFieldValue> = {
-    kind: 'Entrypoint';
-    queryText: string;
-    normalizationAst: NormalizationAst;
-    readerArtifact: ReaderArtifact<TReadFromStore, TClientFieldValue>;
-    nestedRefetchQueries: RefetchQueryArtifactWrapper[];
+    readonly kind: 'Entrypoint';
+    readonly queryText: string;
+    readonly normalizationAst: NormalizationAst;
+    readonly readerArtifact: TopLevelReaderArtifact<TReadFromStore, TClientFieldValue, any>;
+    readonly nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[];
 };
 export type NormalizationAstNode = NormalizationScalarField | NormalizationLinkedField;
-export type NormalizationAst = NormalizationAstNode[];
+export type NormalizationAst = ReadonlyArray<NormalizationAstNode>;
 export type NormalizationScalarField = {
-    kind: 'Scalar';
-    fieldName: string;
-    arguments: Arguments | null;
+    readonly kind: 'Scalar';
+    readonly fieldName: string;
+    readonly arguments: Arguments | null;
 };
 export type NormalizationLinkedField = {
-    kind: 'Linked';
-    fieldName: string;
-    arguments: Arguments | null;
-    selections: NormalizationAst;
+    readonly kind: 'Linked';
+    readonly fieldName: string;
+    readonly arguments: Arguments | null;
+    readonly selections: NormalizationAst;
 };
-export type RefetchQueryArtifact = {
-    kind: 'RefetchQuery';
-    queryText: string;
-    normalizationAst: NormalizationAst;
+export type RefetchQueryNormalizationArtifact = {
+    readonly kind: 'RefetchQuery';
+    readonly queryText: string;
+    readonly normalizationAst: NormalizationAst;
 };
-export type RefetchQueryArtifactWrapper = {
-    artifact: RefetchQueryArtifact;
-    allowedVariables: string[];
+export type RefetchQueryNormalizationArtifactWrapper = {
+    readonly artifact: RefetchQueryNormalizationArtifact;
+    readonly allowedVariables: string[];
 };
 export declare function assertIsEntrypoint<TReadFromStore extends Object, TClientFieldValue>(value: IsographEntrypoint<TReadFromStore, TClientFieldValue> | ((_: any) => any) | any): asserts value is IsographEntrypoint<TReadFromStore, TClientFieldValue>;
 export type ExtractReadFromStore<Type> = Type extends IsographEntrypoint<infer X, any> ? X : never;

package/dist/garbageCollection.d.ts

@@ -1,8 +1,8 @@
 import { IsographEnvironment } from './IsographEnvironment';
 import { NormalizationAst } from './entrypoint';
 export type RetainedQuery = {
-    normalizationAst: NormalizationAst;
-    variables: {};
+    readonly normalizationAst: NormalizationAst;
+    readonly variables: {};
 };
 type DidUnretainSomeQuery = boolean;
 export declare function unretainQuery(environment: IsographEnvironment, retainedQuery: RetainedQuery): DidUnretainSomeQuery;

package/dist/index.d.ts

@@ -5,8 +5,8 @@ export { ROOT_ID, type DataId, type DataTypeValue, type IsographEnvironment, typ
 export { IsographEnvironmentProvider, useIsographEnvironment, type IsographEnvironmentProviderProps, } from './IsographEnvironmentProvider';
 export { useImperativeReference } from './useImperativeReference';
 export { EntrypointReader } from './EntrypointReader';
-export { type ReaderArtifact, ReaderAst, ReaderAstNode, ReaderLinkedField, ReaderMutationField, ReaderRefetchField, ReaderResolverField, ReaderResolverVariant, ReaderScalarField, } from './reader';
-export { NormalizationAst, NormalizationAstNode, NormalizationLinkedField, NormalizationScalarField, IsographEntrypoint, assertIsEntrypoint, RefetchQueryArtifact, RefetchQueryArtifactWrapper, } from './entrypoint';
+export { EagerReaderArtifact, ComponentReaderArtifact, MutationReaderArtifact, RefetchReaderArtifact, ReaderAst, ReaderAstNode, ReaderLinkedField, ReaderMutationField, ReaderRefetchField, ReaderResolverField, ReaderResolverVariant, ReaderScalarField, } from './reader';
+export { NormalizationAst, NormalizationAstNode, NormalizationLinkedField, NormalizationScalarField, IsographEntrypoint, assertIsEntrypoint, RefetchQueryNormalizationArtifact, RefetchQueryNormalizationArtifactWrapper, } from './entrypoint';
 export { readButDoNotEvaluate } from './read';
 export { useResult } from './useResult';
 export { type FragmentReference } from './FragmentReference';

package/dist/read.d.ts

@@ -1,7 +1,7 @@
 import { FragmentReference } from './FragmentReference';
 import { DataId, IsographEnvironment } from './IsographEnvironment';
 export type WithEncounteredRecords<T> = {
-    encounteredRecords: Set<DataId>;
-    item: T;
+    readonly encounteredRecords: Set<DataId>;
+    readonly item: T;
 };
 export declare function readButDoNotEvaluate<TReadFromStore extends Object>(environment: IsographEnvironment, reference: FragmentReference<TReadFromStore, unknown>): WithEncounteredRecords<TReadFromStore>;

package/dist/read.js

@@ -176,17 +176,15 @@ function readData(environment, ast, root, variables, nestedRefetchQueries, mutab
                     const refetchQuery = nestedRefetchQueries[refetchQueryIndex];
                     const refetchQueryArtifact = refetchQuery.artifact;
                     const allowedVariables = refetchQuery.allowedVariables;
-                    target[field.alias] = field.readerArtifact.resolver(environment, refetchQueryArtifact, 
-                    // @ts-expect-error
-                    data.data, filterVariables(variables, allowedVariables));
+                    target[field.alias] = field.readerArtifact.resolver(environment, refetchQueryArtifact, data.data, filterVariables(variables, allowedVariables));
                 }
                 break;
             }
             case 'Resolver': {
                 const usedRefetchQueries = field.usedRefetchQueries;
                 const resolverRefetchQueries = usedRefetchQueries.map((index) => nestedRefetchQueries[index]);
-                const variant = field.readerArtifact.variant;
-                if (variant.kind === 'Eager') {
+                const kind = field.readerArtifact.kind;
+                if (kind === 'EagerReaderArtifact') {
                     const data = readData(environment, field.readerArtifact.readerAst, root, variables, resolverRefetchQueries, mutableEncounteredRecords);
                     if (data.kind === 'MissingData') {
                         return {
@@ -196,12 +194,11 @@ function readData(environment, ast, root, variables, nestedRefetchQueries, mutab
                         };
                     }
                     else {
-                        // @ts-expect-error
                         target[field.alias] = field.readerArtifact.resolver(data.data);
                     }
                 }
-                else if (variant.kind === 'Component') {
-                    target[field.alias] = (0, componentCache_1.getOrCreateCachedComponent)(environment, variant.componentName, {
+                else if (kind === 'ComponentReaderArtifact') {
+                    target[field.alias] = (0, componentCache_1.getOrCreateCachedComponent)(environment, field.readerArtifact.componentName, {
                         kind: 'FragmentReference',
                         readerArtifact: field.readerArtifact,
                         root,

package/dist/reader.d.ts

@@ -1,49 +1,66 @@
-import { ComponentOrFieldName } from './IsographEnvironment';
+/// <reference types="react" />
+import { ComponentOrFieldName, IsographEnvironment } from './IsographEnvironment';
+import { RefetchQueryNormalizationArtifact } from './entrypoint';
 import { Arguments } from './util';
-export type ReaderArtifact<TReadFromStore extends Object, TClientFieldValue> = {
-    kind: 'ReaderArtifact';
-    fieldName: ComponentOrFieldName;
-    readerAst: ReaderAst<TReadFromStore>;
-    resolver: (data: TReadFromStore, runtimeProps: any) => TClientFieldValue;
-    variant: ReaderResolverVariant;
+export type TopLevelReaderArtifact<TReadFromStore extends Object, TClientFieldValue, TAdditionalProps extends Record<string, never>> = EagerReaderArtifact<TReadFromStore, TClientFieldValue> | ComponentReaderArtifact<TReadFromStore, TAdditionalProps>;
+export type EagerReaderArtifact<TReadFromStore extends Object, TClientFieldValue> = {
+    readonly kind: 'EagerReaderArtifact';
+    readonly readerAst: ReaderAst<TReadFromStore>;
+    readonly resolver: (data: TReadFromStore) => TClientFieldValue;
+};
+export type ComponentReaderArtifact<TReadFromStore extends Object, TAdditionalProps extends Record<string, unknown> = Record<string, never>> = {
+    readonly kind: 'ComponentReaderArtifact';
+    readonly componentName: ComponentOrFieldName;
+    readonly readerAst: ReaderAst<TReadFromStore>;
+    readonly resolver: (data: TReadFromStore, runtimeProps: TAdditionalProps) => React.ReactNode;
+};
+export type RefetchReaderArtifact = {
+    readonly kind: 'RefetchReaderArtifact';
+    readonly readerAst: ReaderAst<unknown>;
+    readonly resolver: (environment: IsographEnvironment, artifact: RefetchQueryNormalizationArtifact, variables: any) => () => void;
+};
+export type MutationReaderArtifact<TReadFromStore extends Object> = {
+    readonly kind: 'MutationReaderArtifact';
+    readonly readerAst: ReaderAst<unknown>;
+    readonly resolver: (environment: IsographEnvironment, entrypoint: RefetchQueryNormalizationArtifact, readOutData: TReadFromStore, filteredVariables: any) => (mutationParams: any) => void;
 };
 export type ReaderAstNode = ReaderScalarField | ReaderLinkedField | ReaderResolverField | ReaderRefetchField | ReaderMutationField;
-export type ReaderAst<TReadFromStore> = ReaderAstNode[];
+export type ReaderAst<TReadFromStore> = ReadonlyArray<ReaderAstNode>;
 export type ReaderScalarField = {
-    kind: 'Scalar';
-    fieldName: string;
-    alias: string | null;
-    arguments: Arguments | null;
+    readonly kind: 'Scalar';
+    readonly fieldName: string;
+    readonly alias: string | null;
+    readonly arguments: Arguments | null;
 };
 export type ReaderLinkedField = {
-    kind: 'Linked';
-    fieldName: string;
-    alias: string | null;
-    selections: ReaderAst<unknown>;
-    arguments: Arguments | null;
+    readonly kind: 'Linked';
+    readonly fieldName: string;
+    readonly alias: string | null;
+    readonly selections: ReaderAst<unknown>;
+    readonly arguments: Arguments | null;
 };
 export type ReaderResolverVariant = {
-    kind: 'Eager';
+    readonly kind: 'Eager';
 } | {
-    kind: 'Component';
-    componentName: string;
+    readonly kind: 'Component';
+    readonly componentName: string;
 };
 export type ReaderResolverField = {
-    kind: 'Resolver';
-    alias: string;
-    readerArtifact: ReaderArtifact<any, any>;
-    arguments: Arguments | null;
-    usedRefetchQueries: number[];
+    readonly kind: 'Resolver';
+    readonly alias: string;
+    readonly readerArtifact: TopLevelReaderArtifact<any, any, any>;
+    readonly arguments: Arguments | null;
+    readonly usedRefetchQueries: number[];
 };
 export type ReaderRefetchField = {
-    kind: 'RefetchField';
-    alias: string;
-    readerArtifact: ReaderArtifact<any, any>;
-    refetchQuery: number;
+    readonly kind: 'RefetchField';
+    readonly alias: string;
+    readonly readerArtifact: RefetchReaderArtifact;
+    readonly refetchQuery: number;
 };
 export type ReaderMutationField = {
-    kind: 'MutationField';
-    alias: string;
-    readerArtifact: ReaderArtifact<any, any>;
-    refetchQuery: number;
+    readonly kind: 'MutationField';
+    readonly alias: string;
+    readonly readerArtifact: MutationReaderArtifact<any>;
+    readonly refetchQuery: number;
 };

package/dist/useResult.js

@@ -6,14 +6,13 @@ const componentCache_1 = require("./componentCache");
 const useReadAndSubscribe_1 = require("./useReadAndSubscribe");
 function useResult(fragmentReference) {
     const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
-    switch (fragmentReference.readerArtifact.variant.kind) {
-        case 'Component': {
+    switch (fragmentReference.readerArtifact.kind) {
+        case 'ComponentReaderArtifact': {
             // @ts-expect-error
-            return (0, componentCache_1.getOrCreateCachedComponent)(environment, fragmentReference.readerArtifact.variant.componentName, fragmentReference);
+            return (0, componentCache_1.getOrCreateCachedComponent)(environment, fragmentReference.readerArtifact.componentName, fragmentReference);
         }
-        case 'Eager': {
+        case 'EagerReaderArtifact': {
             const data = (0, useReadAndSubscribe_1.useReadAndSubscribe)(environment, fragmentReference);
-            // @ts-expect-error resolver is incorrectly typed in ReaderArtifact
             return fragmentReference.readerArtifact.resolver(data);
         }
     }

package/dist/util.d.ts

@@ -3,9 +3,9 @@ export type Arguments = Argument[];
 export type Argument = [ArgumentName, ArgumentValue];
 export type ArgumentName = string;
 export type ArgumentValue = {
-    kind: 'Variable';
-    name: string;
+    readonly kind: 'Variable';
+    readonly name: string;
 } | {
-    kind: 'Literal';
-    value: any;
+    readonly kind: 'Literal';
+    readonly value: any;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.0.0-main-ad899464",
+  "version": "0.0.0-main-084bfeee",
   "description": "Use Isograph with React",
   "homepage": "https://isograph.dev",
   "main": "dist/index.js",
@@ -16,8 +16,8 @@
     "prepack": "yarn run test && yarn run compile"
   },
   "dependencies": {
-    "@isograph/disposable-types": "0.0.0-main-ad899464",
-    "@isograph/react-disposable-state": "0.0.0-main-ad899464",
+    "@isograph/disposable-types": "0.0.0-main-084bfeee",
+    "@isograph/react-disposable-state": "0.0.0-main-084bfeee",
     "react": "^18.2.0"
   },
   "devDependencies": {
@@ -30,5 +30,6 @@
     "type": "git",
     "url": "git+https://github.com/isographlabs/isograph.git",
     "directory": "libs/isograph-react"
-  }
+  },
+  "sideEffects": false
 }

package/src/FragmentReference.ts

@@ -1,6 +1,6 @@
 import { DataId } from './IsographEnvironment';
-import { RefetchQueryArtifactWrapper } from './entrypoint';
-import { ReaderArtifact } from './reader';
+import { RefetchQueryNormalizationArtifactWrapper } from './entrypoint';
+import { TopLevelReaderArtifact } from './reader';
 
 // TODO type this better
 export type Variable = any;
@@ -11,10 +11,14 @@ export type FragmentReference<
   TReadFromStore extends Object,
   TClientFieldValue,
 > = {
-  kind: 'FragmentReference';
-  readerArtifact: ReaderArtifact<TReadFromStore, TClientFieldValue>;
-  root: DataId;
-  variables: Variables | null;
+  readonly kind: 'FragmentReference';
+  readonly readerArtifact: TopLevelReaderArtifact<
+    TReadFromStore,
+    TClientFieldValue,
+    any
+  >;
+  readonly root: DataId;
+  readonly variables: Variables | null;
   // TODO: We should instead have ReaderAst<TClientFieldProps>
-  nestedRefetchQueries: RefetchQueryArtifactWrapper[];
+  readonly nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[];
 };

package/src/IsographEnvironment.tsx

@@ -30,15 +30,15 @@ type Subscriptions = Set<Subscription>;
 type SuspenseCache = { [index: string]: ParentCache<any> };
 
 export type IsographEnvironment = {
-  store: IsographStore;
-  networkFunction: IsographNetworkFunction;
-  missingFieldHandler: MissingFieldHandler | null;
-  componentCache: ComponentCache;
-  subscriptions: Subscriptions;
-  suspenseCache: SuspenseCache;
-  retainedQueries: Set<RetainedQuery>;
-  gcBuffer: Array<RetainedQuery>;
-  gcBufferSize: number;
+  readonly store: IsographStore;
+  readonly networkFunction: IsographNetworkFunction;
+  readonly missingFieldHandler: MissingFieldHandler | null;
+  readonly componentCache: ComponentCache;
+  readonly subscriptions: Subscriptions;
+  readonly suspenseCache: SuspenseCache;
+  readonly retainedQueries: Set<RetainedQuery>;
+  readonly gcBuffer: Array<RetainedQuery>;
+  readonly gcBufferSize: number;
 };
 
 export type MissingFieldHandler = (
@@ -55,7 +55,7 @@ export type IsographNetworkFunction = (
 ) => Promise<any>;
 
 export type Link = {
-  __link: DataId;
+  readonly __link: DataId;
 };
 
 export type DataTypeValue =
@@ -76,7 +76,7 @@ export type StoreRecord = {
   [index: DataId | string]: DataTypeValue;
   // TODO __typename?: T, which is restricted to being a concrete string
   // TODO this shouldn't always be named id
-  id?: DataId;
+  readonly id?: DataId;
 };
 
 export type DataId = string;
@@ -85,7 +85,7 @@ export const ROOT_ID: DataId & '__ROOT' = '__ROOT';
 
 export type IsographStore = {
   [index: DataId]: StoreRecord | null;
-  __ROOT: StoreRecord;
+  readonly __ROOT: StoreRecord;
 };
 
 const DEFAULT_GC_BUFFER_SIZE = 10;

package/src/IsographEnvironmentProvider.tsx

@@ -6,8 +6,8 @@ export const IsographEnvironmentContext =
   createContext<IsographEnvironment | null>(null);
 
 export type IsographEnvironmentProviderProps = {
-  environment: IsographEnvironment;
-  children: ReactNode;
+  readonly environment: IsographEnvironment;
+  readonly children: ReactNode;
 };
 
 export function IsographEnvironmentProvider({

package/src/PromiseWrapper.ts

@@ -6,7 +6,7 @@ type NotSet = typeof NOT_SET;
  * Before the promise is resolved, value becomes non-null.
  */
 export type PromiseWrapper<T> = {
-  promise: Promise<T>;
+  readonly promise: Promise<T>;
   value: Exclude<T, NotSet> | NotSet;
 };
 

package/src/cache.ts

@@ -24,7 +24,8 @@ import {
   NormalizationAst,
   NormalizationLinkedField,
   NormalizationScalarField,
-  RefetchQueryArtifactWrapper,
+  RefetchQueryNormalizationArtifact,
+  RefetchQueryNormalizationArtifactWrapper,
 } from './entrypoint';
 import { ReaderLinkedField, ReaderScalarField } from './reader';
 import { Argument, ArgumentValue } from './util';
@@ -79,8 +80,6 @@ export function stableCopy<T>(value: T): T {
   return stable as any;
 }
 
-type IsoResolver = IsographEntrypoint<any, any>;
-
 export function getOrCreateCacheForArtifact<
   TReadFromStore extends Object,
   TClientFieldValue,
@@ -101,19 +100,19 @@ export function getOrCreateCacheForArtifact<
 
 type NetworkRequestStatus =
   | {
-      kind: 'UndisposedIncomplete';
+      readonly kind: 'UndisposedIncomplete';
     }
   | {
-      kind: 'Disposed';
+      readonly kind: 'Disposed';
     }
   | {
-      kind: 'UndisposedComplete';
-      retainedQuery: RetainedQuery;
+      readonly kind: 'UndisposedComplete';
+      readonly retainedQuery: RetainedQuery;
     };
 
 export function makeNetworkRequest<T>(
   environment: IsographEnvironment,
-  artifact: IsoResolver,
+  artifact: RefetchQueryNormalizationArtifact | IsographEntrypoint<any, any>,
   variables: object,
 ): ItemCleanupPair<PromiseWrapper<T>> {
   if (typeof window !== 'undefined' && window.__LOG) {
@@ -136,7 +135,7 @@ export function makeNetworkRequest<T>(
           artifact.normalizationAst,
           networkResponse.data,
           variables,
-          artifact.nestedRefetchQueries,
+          artifact.kind === 'Entrypoint' ? artifact.nestedRefetchQueries : [],
         );
         const retainedQuery = {
           normalizationAst: artifact.normalizationAst,
@@ -193,7 +192,7 @@ function normalizeData(
   normalizationAst: NormalizationAst,
   networkResponse: NetworkResponseObject,
   variables: Object,
-  nestedRefetchQueries: RefetchQueryArtifactWrapper[],
+  nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
 ): Set<DataId> {
   const encounteredIds = new Set<DataId>();
 
@@ -344,7 +343,7 @@ function normalizeDataIntoRecord(
   targetParentRecord: StoreRecord,
   targetParentRecordId: DataId,
   variables: { [index: string]: string },
-  nestedRefetchQueries: RefetchQueryArtifactWrapper[],
+  nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
   mutableEncounteredIds: Set<DataId>,
 ) {
   let recordHasBeenUpdated = false;
@@ -416,7 +415,7 @@ function normalizeLinkedField(
   targetParentRecord: StoreRecord,
   targetParentRecordId: DataId,
   variables: { [index: string]: string },
-  nestedRefetchQueries: RefetchQueryArtifactWrapper[],
+  nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
   mutableEncounteredIds: Set<DataId>,
 ): RecordHasBeenUpdated {
   const networkResponseKey = getNetworkResponseKey(astNode);
@@ -504,7 +503,7 @@ function normalizeNetworkResponseObject(
   targetParentRecordId: string,
   variables: { [index: string]: string },
   index: number | null,
-  nestedRefetchQueries: RefetchQueryArtifactWrapper[],
+  nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
   mutableEncounteredIds: Set<DataId>,
 ): DataId /* The id of the modified or newly created item */ {
   const newStoreRecordId = getDataIdOfNetworkResponse(

package/src/entrypoint.ts

@@ -1,4 +1,4 @@
-import { ReaderArtifact } from './reader';
+import { TopLevelReaderArtifact } from './reader';
 import { Arguments } from './util';
 
 // This type should be treated as an opaque type.
@@ -6,42 +6,47 @@ export type IsographEntrypoint<
   TReadFromStore extends Object,
   TClientFieldValue,
 > = {
-  kind: 'Entrypoint';
-  queryText: string;
-  normalizationAst: NormalizationAst;
-  readerArtifact: ReaderArtifact<TReadFromStore, TClientFieldValue>;
-  nestedRefetchQueries: RefetchQueryArtifactWrapper[];
+  readonly kind: 'Entrypoint';
+  readonly queryText: string;
+  readonly normalizationAst: NormalizationAst;
+  readonly readerArtifact: TopLevelReaderArtifact<
+    TReadFromStore,
+    TClientFieldValue,
+    // TODO don't type this as any
+    any
+  >;
+  readonly nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[];
 };
 
 export type NormalizationAstNode =
   | NormalizationScalarField
   | NormalizationLinkedField;
-export type NormalizationAst = NormalizationAstNode[];
+export type NormalizationAst = ReadonlyArray<NormalizationAstNode>;
 
 export type NormalizationScalarField = {
-  kind: 'Scalar';
-  fieldName: string;
-  arguments: Arguments | null;
+  readonly kind: 'Scalar';
+  readonly fieldName: string;
+  readonly arguments: Arguments | null;
 };
 
 export type NormalizationLinkedField = {
-  kind: 'Linked';
-  fieldName: string;
-  arguments: Arguments | null;
-  selections: NormalizationAst;
+  readonly kind: 'Linked';
+  readonly fieldName: string;
+  readonly arguments: Arguments | null;
+  readonly selections: NormalizationAst;
 };
 
 // This is more like an entrypoint, but one specifically for a refetch query/mutation
-export type RefetchQueryArtifact = {
-  kind: 'RefetchQuery';
-  queryText: string;
-  normalizationAst: NormalizationAst;
+export type RefetchQueryNormalizationArtifact = {
+  readonly kind: 'RefetchQuery';
+  readonly queryText: string;
+  readonly normalizationAst: NormalizationAst;
 };
 
 // TODO rename
-export type RefetchQueryArtifactWrapper = {
-  artifact: RefetchQueryArtifact;
-  allowedVariables: string[];
+export type RefetchQueryNormalizationArtifactWrapper = {
+  readonly artifact: RefetchQueryNormalizationArtifact;
+  readonly allowedVariables: string[];
 };
 
 export function assertIsEntrypoint<

package/src/garbageCollection.ts

@@ -10,8 +10,8 @@ import { getParentRecordKey } from './cache';
 import { NormalizationAst } from './entrypoint';
 
 export type RetainedQuery = {
-  normalizationAst: NormalizationAst;
-  variables: {};
+  readonly normalizationAst: NormalizationAst;
+  readonly variables: {};
 };
 
 type DidUnretainSomeQuery = boolean;

package/src/index.ts

@@ -27,7 +27,10 @@ export {
 export { useImperativeReference } from './useImperativeReference';
 export { EntrypointReader } from './EntrypointReader';
 export {
-  type ReaderArtifact,
+  EagerReaderArtifact,
+  ComponentReaderArtifact,
+  MutationReaderArtifact,
+  RefetchReaderArtifact,
   ReaderAst,
   ReaderAstNode,
   ReaderLinkedField,
@@ -44,8 +47,8 @@ export {
   NormalizationScalarField,
   IsographEntrypoint,
   assertIsEntrypoint,
-  RefetchQueryArtifact,
-  RefetchQueryArtifactWrapper,
+  RefetchQueryNormalizationArtifact,
+  RefetchQueryNormalizationArtifactWrapper,
 } from './entrypoint';
 export { readButDoNotEvaluate } from './read';
 export { useResult } from './useResult';

package/src/read.ts

@@ -1,6 +1,6 @@
 import { getParentRecordKey, onNextChange } from './cache';
 import { getOrCreateCachedComponent } from './componentCache';
-import { RefetchQueryArtifactWrapper } from './entrypoint';
+import { RefetchQueryNormalizationArtifactWrapper } from './entrypoint';
 import { FragmentReference } from './FragmentReference';
 import {
   assertLink,
@@ -11,8 +11,8 @@ import {
 import { ReaderAst } from './reader';
 
 export type WithEncounteredRecords<T> = {
-  encounteredRecords: Set<DataId>;
-  item: T;
+  readonly encounteredRecords: Set<DataId>;
+  readonly item: T;
 };
 
 export function readButDoNotEvaluate<TReadFromStore extends Object>(
@@ -43,14 +43,14 @@ export function readButDoNotEvaluate<TReadFromStore extends Object>(
 
 type ReadDataResult<TReadFromStore> =
   | {
-      kind: 'Success';
-      data: TReadFromStore;
-      encounteredRecords: Set<DataId>;
+      readonly kind: 'Success';
+      readonly data: TReadFromStore;
+      readonly encounteredRecords: Set<DataId>;
     }
   | {
-      kind: 'MissingData';
-      reason: string;
-      nestedReason?: ReadDataResult<unknown>;
+      readonly kind: 'MissingData';
+      readonly reason: string;
+      readonly nestedReason?: ReadDataResult<unknown>;
     };
 
 function readData<TReadFromStore>(
@@ -58,7 +58,7 @@ function readData<TReadFromStore>(
   ast: ReaderAst<TReadFromStore>,
   root: DataId,
   variables: { [index: string]: string },
-  nestedRefetchQueries: RefetchQueryArtifactWrapper[],
+  nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
   mutableEncounteredRecords: Set<DataId>,
 ): ReadDataResult<TReadFromStore> {
   mutableEncounteredRecords.add(root);
@@ -222,11 +222,9 @@ function readData<TReadFromStore>(
             environment,
             // resolvers for refetch fields take 3 args, and this is not reflected in types
             refetchQueryArtifact,
-            // @ts-expect-error
             {
+              // @ts-expect-error
               ...data.data,
-              // TODO continue from here
-              // variables need to be filtered for what we need just for the refetch query
               ...filterVariables(variables, allowedVariables),
             },
           );
@@ -261,7 +259,6 @@ function readData<TReadFromStore>(
           target[field.alias] = field.readerArtifact.resolver(
             environment,
             refetchQueryArtifact,
-            // @ts-expect-error
             data.data,
             filterVariables(variables, allowedVariables),
           );
@@ -274,8 +271,8 @@ function readData<TReadFromStore>(
           (index) => nestedRefetchQueries[index],
         );
 
-        const variant = field.readerArtifact.variant;
-        if (variant.kind === 'Eager') {
+        const kind = field.readerArtifact.kind;
+        if (kind === 'EagerReaderArtifact') {
           const data = readData(
             environment,
             field.readerArtifact.readerAst,
@@ -291,13 +288,12 @@ function readData<TReadFromStore>(
               nestedReason: data,
             };
           } else {
-            // @ts-expect-error
             target[field.alias] = field.readerArtifact.resolver(data.data);
           }
-        } else if (variant.kind === 'Component') {
+        } else if (kind === 'ComponentReaderArtifact') {
           target[field.alias] = getOrCreateCachedComponent(
             environment,
-            variant.componentName,
+            field.readerArtifact.componentName,
             {
               kind: 'FragmentReference',
               readerArtifact: field.readerArtifact,

package/src/reader.ts

@@ -1,15 +1,63 @@
-import { ComponentOrFieldName } from './IsographEnvironment';
+import {
+  ComponentOrFieldName,
+  IsographEnvironment,
+} from './IsographEnvironment';
+import { RefetchQueryNormalizationArtifact } from './entrypoint';
 import { Arguments } from './util';
 
-// TODO this should probably be at least three distinct types, for @component,
-// non-@component and refetch resolvers
-export type ReaderArtifact<TReadFromStore extends Object, TClientFieldValue> = {
-  kind: 'ReaderArtifact';
-  fieldName: ComponentOrFieldName;
-  readerAst: ReaderAst<TReadFromStore>;
-  // TODO move resolver into the variant
-  resolver: (data: TReadFromStore, runtimeProps: any) => TClientFieldValue;
-  variant: ReaderResolverVariant;
+export type TopLevelReaderArtifact<
+  TReadFromStore extends Object,
+  TClientFieldValue,
+  TAdditionalProps extends Record<string, never>,
+> =
+  | EagerReaderArtifact<TReadFromStore, TClientFieldValue>
+  | ComponentReaderArtifact<TReadFromStore, TAdditionalProps>;
+
+export type EagerReaderArtifact<
+  TReadFromStore extends Object,
+  TClientFieldValue,
+> = {
+  readonly kind: 'EagerReaderArtifact';
+  readonly readerAst: ReaderAst<TReadFromStore>;
+  readonly resolver: (data: TReadFromStore) => TClientFieldValue;
+};
+
+export type ComponentReaderArtifact<
+  TReadFromStore extends Object,
+  TAdditionalProps extends Record<string, unknown> = Record<string, never>,
+> = {
+  readonly kind: 'ComponentReaderArtifact';
+  readonly componentName: ComponentOrFieldName;
+  readonly readerAst: ReaderAst<TReadFromStore>;
+  readonly resolver: (
+    data: TReadFromStore,
+    runtimeProps: TAdditionalProps,
+  ) => React.ReactNode;
+};
+
+export type RefetchReaderArtifact = {
+  readonly kind: 'RefetchReaderArtifact';
+  readonly readerAst: ReaderAst<unknown>;
+  readonly resolver: (
+    environment: IsographEnvironment,
+    artifact: RefetchQueryNormalizationArtifact,
+    // TODO type this better
+    variables: any,
+  ) => () => void;
+};
+
+export type MutationReaderArtifact<TReadFromStore extends Object> = {
+  readonly kind: 'MutationReaderArtifact';
+  readonly readerAst: ReaderAst<unknown>;
+  readonly resolver: (
+    environment: IsographEnvironment,
+    // TODO type this better
+    entrypoint: RefetchQueryNormalizationArtifact,
+    readOutData: TReadFromStore,
+    // TODO type this better
+    filteredVariables: any,
+    // TODO type this better
+  ) => (mutationParams: any) => void;
 };
 
 export type ReaderAstNode =
@@ -20,48 +68,47 @@ export type ReaderAstNode =
   | ReaderMutationField;
 
 // @ts-ignore
-export type ReaderAst<TReadFromStore> = ReaderAstNode[];
+export type ReaderAst<TReadFromStore> = ReadonlyArray<ReaderAstNode>;
 
 export type ReaderScalarField = {
-  kind: 'Scalar';
-  fieldName: string;
-  alias: string | null;
-  arguments: Arguments | null;
+  readonly kind: 'Scalar';
+  readonly fieldName: string;
+  readonly alias: string | null;
+  readonly arguments: Arguments | null;
 };
 export type ReaderLinkedField = {
-  kind: 'Linked';
-  fieldName: string;
-  alias: string | null;
-  selections: ReaderAst<unknown>;
-  arguments: Arguments | null;
+  readonly kind: 'Linked';
+  readonly fieldName: string;
+  readonly alias: string | null;
+  readonly selections: ReaderAst<unknown>;
+  readonly arguments: Arguments | null;
 };
 
 export type ReaderResolverVariant =
-  | { kind: 'Eager' }
-  // componentName is the component's cacheKey for getRefReaderByName
-  // and is the type + field concatenated
-  | { kind: 'Component'; componentName: string };
+  | { readonly kind: 'Eager' }
+  // componentName is type + field concatenated
+  | { readonly kind: 'Component'; readonly componentName: string };
 
 export type ReaderResolverField = {
-  kind: 'Resolver';
-  alias: string;
-  readerArtifact: ReaderArtifact<any, any>;
-  arguments: Arguments | null;
-  usedRefetchQueries: number[];
+  readonly kind: 'Resolver';
+  readonly alias: string;
+  // TODO don't type this as any
+  readonly readerArtifact: TopLevelReaderArtifact<any, any, any>;
+  readonly arguments: Arguments | null;
+  readonly usedRefetchQueries: number[];
 };
 
 export type ReaderRefetchField = {
-  kind: 'RefetchField';
-  alias: string;
-  // TODO this bad modeling. A refetch field cannot have variant: "Component" (I think)
-  readerArtifact: ReaderArtifact<any, any>;
-  refetchQuery: number;
+  readonly kind: 'RefetchField';
+  readonly alias: string;
+  readonly readerArtifact: RefetchReaderArtifact;
+  readonly refetchQuery: number;
 };
 
 export type ReaderMutationField = {
-  kind: 'MutationField';
-  alias: string;
-  // TODO this bad modeling. A mutation field cannot have variant: "Component" (I think)
-  readerArtifact: ReaderArtifact<any, any>;
-  refetchQuery: number;
+  readonly kind: 'MutationField';
+  readonly alias: string;
+  // TODO don't pass any here
+  readonly readerArtifact: MutationReaderArtifact<any>;
+  readonly refetchQuery: number;
 };

package/src/tests/__isograph/Query/meName/entrypoint.ts

@@ -1,8 +1,8 @@
-import type {IsographEntrypoint, NormalizationAst, RefetchQueryArtifactWrapper} from '@isograph/react';
+import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArtifactWrapper} from '@isograph/react';
 import {Query__meName__param} from './param_type';
 import {Query__meName__outputType} from './output_type';
 import readerResolver from './reader';
-const nestedRefetchQueries: RefetchQueryArtifactWrapper[] = [];
+const nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[] = [];
 
 const queryText = 'query meName  {\
   me {\

package/src/tests/__isograph/Query/meName/output_type.ts

@@ -1,4 +1,2 @@
-import type {ExtractSecondParam} from '@isograph/react';
 import { meNameField as resolver } from '../../../garbageCollection.test.ts';
-// the type, when read out (either via useLazyReference or via graph)
-export type Query__meName__outputType = ReturnType<typeof resolver>;
+export type Query__meName__outputType = ReturnType<typeof resolver>;

package/src/tests/__isograph/Query/meName/reader.ts

@@ -1,6 +1,6 @@
-import type {ReaderArtifact, ReaderAst} from '@isograph/react';
-import { Query__meName__param } from './param_type.ts';
-import { Query__meName__outputType } from './output_type.ts';
+import type {EagerReaderArtifact, ReaderAst, RefetchQueryNormalizationArtifact} from '@isograph/react';
+import { Query__meName__param } from './param_type';
+import { Query__meName__outputType } from './output_type';
 import { meNameField as resolver } from '../../../garbageCollection.test.ts';
 
 const readerAst: ReaderAst<Query__meName__param> = [
@@ -20,15 +20,13 @@ const readerAst: ReaderAst<Query__meName__param> = [
   },
 ];
 
-const artifact: ReaderArtifact<
+const artifact: EagerReaderArtifact<
   Query__meName__param,
   Query__meName__outputType
 > = {
-  kind: "ReaderArtifact",
-  fieldName: "meName",
-  resolver: resolver as any,
+  kind: "EagerReaderArtifact",
+  resolver,
   readerAst,
-  variant: { kind: "Eager" },
 };
 
 export default artifact;

package/src/tests/__isograph/Query/meNameSuccessor/entrypoint.ts

@@ -1,8 +1,8 @@
-import type {IsographEntrypoint, NormalizationAst, RefetchQueryArtifactWrapper} from '@isograph/react';
+import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArtifactWrapper} from '@isograph/react';
 import {Query__meNameSuccessor__param} from './param_type';
 import {Query__meNameSuccessor__outputType} from './output_type';
 import readerResolver from './reader';
-const nestedRefetchQueries: RefetchQueryArtifactWrapper[] = [];
+const nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[] = [];
 
 const queryText = 'query meNameSuccessor  {\
   me {\

package/src/tests/__isograph/Query/meNameSuccessor/output_type.ts

@@ -1,4 +1,2 @@
-import type {ExtractSecondParam} from '@isograph/react';
 import { meNameField as resolver } from '../../../meNameSuccessor.ts';
-// the type, when read out (either via useLazyReference or via graph)
-export type Query__meNameSuccessor__outputType = ReturnType<typeof resolver>;
+export type Query__meNameSuccessor__outputType = ReturnType<typeof resolver>;

package/src/tests/__isograph/Query/meNameSuccessor/reader.ts

@@ -1,6 +1,6 @@
-import type {ReaderArtifact, ReaderAst} from '@isograph/react';
-import { Query__meNameSuccessor__param } from './param_type.ts';
-import { Query__meNameSuccessor__outputType } from './output_type.ts';
+import type {EagerReaderArtifact, ReaderAst, RefetchQueryNormalizationArtifact} from '@isograph/react';
+import { Query__meNameSuccessor__param } from './param_type';
+import { Query__meNameSuccessor__outputType } from './output_type';
 import { meNameField as resolver } from '../../../meNameSuccessor.ts';
 
 const readerAst: ReaderAst<Query__meNameSuccessor__param> = [
@@ -42,15 +42,13 @@ const readerAst: ReaderAst<Query__meNameSuccessor__param> = [
   },
 ];
 
-const artifact: ReaderArtifact<
+const artifact: EagerReaderArtifact<
   Query__meNameSuccessor__param,
   Query__meNameSuccessor__outputType
 > = {
-  kind: "ReaderArtifact",
-  fieldName: "meNameSuccessor",
-  resolver: resolver as any,
+  kind: "EagerReaderArtifact",
+  resolver,
   readerAst,
-  variant: { kind: "Eager" },
 };
 
 export default artifact;

package/src/tests/__isograph/Query/nodeField/entrypoint.ts

@@ -1,8 +1,8 @@
-import type {IsographEntrypoint, NormalizationAst, RefetchQueryArtifactWrapper} from '@isograph/react';
+import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArtifactWrapper} from '@isograph/react';
 import {Query__nodeField__param} from './param_type';
 import {Query__nodeField__outputType} from './output_type';
 import readerResolver from './reader';
-const nestedRefetchQueries: RefetchQueryArtifactWrapper[] = [];
+const nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[] = [];
 
 const queryText = 'query nodeField ($id: ID!) {\
   node____id___v_id: node(id: $id) {\

package/src/tests/__isograph/Query/nodeField/output_type.ts

@@ -1,4 +1,2 @@
-import type {ExtractSecondParam} from '@isograph/react';
 import { nodeField as resolver } from '../../../nodeQuery.ts';
-// the type, when read out (either via useLazyReference or via graph)
-export type Query__nodeField__outputType = ReturnType<typeof resolver>;
+export type Query__nodeField__outputType = ReturnType<typeof resolver>;

package/src/tests/__isograph/Query/nodeField/reader.ts

@@ -1,6 +1,6 @@
-import type {ReaderArtifact, ReaderAst} from '@isograph/react';
-import { Query__nodeField__param } from './param_type.ts';
-import { Query__nodeField__outputType } from './output_type.ts';
+import type {EagerReaderArtifact, ReaderAst, RefetchQueryNormalizationArtifact} from '@isograph/react';
+import { Query__nodeField__param } from './param_type';
+import { Query__nodeField__outputType } from './output_type';
 import { nodeField as resolver } from '../../../nodeQuery.ts';
 
 const readerAst: ReaderAst<Query__nodeField__param> = [
@@ -25,15 +25,13 @@ const readerAst: ReaderAst<Query__nodeField__param> = [
   },
 ];
 
-const artifact: ReaderArtifact<
+const artifact: EagerReaderArtifact<
   Query__nodeField__param,
   Query__nodeField__outputType
 > = {
-  kind: "ReaderArtifact",
-  fieldName: "nodeField",
-  resolver: resolver as any,
+  kind: "EagerReaderArtifact",
+  resolver,
   readerAst,
-  variant: { kind: "Eager" },
 };
 
 export default artifact;

package/src/useResult.ts

@@ -8,18 +8,17 @@ export function useResult<TReadFromStore extends Object, TClientFieldValue>(
 ): TClientFieldValue {
   const environment = useIsographEnvironment();
 
-  switch (fragmentReference.readerArtifact.variant.kind) {
-    case 'Component': {
+  switch (fragmentReference.readerArtifact.kind) {
+    case 'ComponentReaderArtifact': {
       // @ts-expect-error
       return getOrCreateCachedComponent(
         environment,
-        fragmentReference.readerArtifact.variant.componentName,
+        fragmentReference.readerArtifact.componentName,
         fragmentReference,
       );
     }
-    case 'Eager': {
+    case 'EagerReaderArtifact': {
       const data = useReadAndSubscribe(environment, fragmentReference);
-      // @ts-expect-error resolver is incorrectly typed in ReaderArtifact
       return fragmentReference.readerArtifact.resolver(data);
     }
   }

package/src/util.ts

@@ -6,10 +6,10 @@ export type Argument = [ArgumentName, ArgumentValue];
 export type ArgumentName = string;
 export type ArgumentValue =
   | {
-      kind: 'Variable';
-      name: string;
+      readonly kind: 'Variable';
+      readonly name: string;
     }
   | {
-      kind: 'Literal';
-      value: any;
+      readonly kind: 'Literal';
+      readonly value: any;
     };