@isograph/react 0.0.0-main-dc9ca2f6 → 0.0.0-main-1bfd646b

package/dist/IsographEnvironment.d.ts

@@ -1,8 +1,6 @@
-import { ReactNode } from 'react';
-import * as React from 'react';
+/// <reference types="react" />
 import { ParentCache } from '@isograph/isograph-react-disposable-state';
-import { NormalizationAst } from './index';
-export declare const IsographEnvironmentContext: React.Context<IsographEnvironment | null>;
+import { RetainedQuery } from './garbageCollection';
 type ComponentName = string;
 type StringifiedArgs = string;
 type ComponentCache = {
@@ -16,10 +14,6 @@ export type Subscriptions = Set<() => void>;
 type SuspenseCache = {
     [index: string]: ParentCache<any>;
 };
-export type RetainedQuery = {
-    normalizationAst: NormalizationAst;
-    variables: {};
-};
 export type IsographEnvironment = {
     store: IsographStore;
     networkFunction: IsographNetworkFunction;
@@ -51,18 +45,8 @@ export type IsographStore = {
     [index: DataId]: StoreRecord | null;
     __ROOT: StoreRecord;
 };
-export type IsographEnvironmentProviderProps = {
-    environment: IsographEnvironment;
-    children: ReactNode;
-};
-export declare function IsographEnvironmentProvider({ environment, children, }: IsographEnvironmentProviderProps): React.JSX.Element;
-export declare function useIsographEnvironment(): IsographEnvironment;
 export declare function createIsographEnvironment(store: IsographStore, networkFunction: IsographNetworkFunction, missingFieldHandler?: MissingFieldHandler): IsographEnvironment;
 export declare function createIsographStore(): {
     __ROOT: {};
 };
-export declare function garbageCollectEnvironment(environment: IsographEnvironment): void;
-type DidUnretainSomeQuery = boolean;
-export declare function unretainQuery(environment: IsographEnvironment, retainedQuery: RetainedQuery): DidUnretainSomeQuery;
-export declare function retainQuery(environment: IsographEnvironment, queryToRetain: RetainedQuery): void;
 export {};

package/dist/IsographEnvironment.js

@@ -1,47 +1,7 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.retainQuery = exports.unretainQuery = exports.garbageCollectEnvironment = exports.createIsographStore = exports.createIsographEnvironment = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.ROOT_ID = exports.IsographEnvironmentContext = void 0;
-const react_1 = require("react");
-const React = __importStar(require("react"));
-const cache_1 = require("./cache");
-exports.IsographEnvironmentContext = (0, react_1.createContext)(null);
+exports.createIsographStore = exports.createIsographEnvironment = exports.ROOT_ID = void 0;
 exports.ROOT_ID = '__ROOT';
-function IsographEnvironmentProvider({ environment, children, }) {
-    return (React.createElement(exports.IsographEnvironmentContext.Provider, { value: environment }, children));
-}
-exports.IsographEnvironmentProvider = IsographEnvironmentProvider;
-function useIsographEnvironment() {
-    const context = (0, react_1.useContext)(exports.IsographEnvironmentContext);
-    if (context == null) {
-        throw new Error('Unexpected null environment context. Make sure to render ' +
-            'this component within an IsographEnvironmentProvider component');
-    }
-    return context;
-}
-exports.useIsographEnvironment = useIsographEnvironment;
 const DEFAULT_GC_BUFFER_SIZE = 10;
 function createIsographEnvironment(store, networkFunction, missingFieldHandler) {
     return {
@@ -63,82 +23,3 @@ function createIsographStore() {
     };
 }
 exports.createIsographStore = createIsographStore;
-function garbageCollectEnvironment(environment) {
-    const retainedIds = new Set([exports.ROOT_ID]);
-    for (const query of environment.retainedQueries) {
-        recordReachableIds(environment.store, query, retainedIds);
-    }
-    for (const query of environment.gcBuffer) {
-        recordReachableIds(environment.store, query, retainedIds);
-    }
-    for (const dataId in environment.store) {
-        if (!retainedIds.has(dataId)) {
-            delete environment.store[dataId];
-        }
-    }
-}
-exports.garbageCollectEnvironment = garbageCollectEnvironment;
-function recordReachableIds(store, retainedQuery, mutableRetainedIds) {
-    recordReachableIdsFromRecord(store, store[exports.ROOT_ID], mutableRetainedIds, retainedQuery.normalizationAst, retainedQuery.variables);
-}
-function getLinkedId(data) {
-    // @ts-expect-error
-    if (data.__link != null) {
-        // @ts-expect-error
-        return data.__link;
-    }
-    else {
-        throw new Error('Record in an invalid state');
-    }
-}
-function recordReachableIdsFromRecord(store, currentRecord, mutableRetainedIds, selections, variables) {
-    for (const selection of selections) {
-        switch (selection.kind) {
-            case 'Linked':
-                const linkKey = (0, cache_1.getParentRecordKey)(selection, variables !== null && variables !== void 0 ? variables : {});
-                const linkedFieldOrFields = currentRecord[linkKey];
-                const ids = [];
-                if (Array.isArray(linkedFieldOrFields)) {
-                    for (const link of linkedFieldOrFields) {
-                        if (link != null) {
-                            const id = getLinkedId(link);
-                            ids.push(id);
-                        }
-                    }
-                }
-                else {
-                    if (linkedFieldOrFields != null) {
-                        const id = getLinkedId(linkedFieldOrFields);
-                        ids.push(id);
-                    }
-                }
-                for (const nextRecordId of ids) {
-                    const nextRecord = store[nextRecordId];
-                    if (nextRecord != null) {
-                        mutableRetainedIds.add(nextRecordId);
-                        recordReachableIdsFromRecord(store, nextRecord, mutableRetainedIds, selection.selections, variables);
-                    }
-                }
-                continue;
-            case 'Scalar':
-                continue;
-        }
-    }
-}
-function unretainQuery(environment, retainedQuery) {
-    environment.retainedQueries.delete(retainedQuery);
-    environment.gcBuffer.push(retainedQuery);
-    if (environment.gcBuffer.length > environment.gcBufferSize) {
-        environment.gcBuffer.shift();
-        return true;
-    }
-    return false;
-}
-exports.unretainQuery = unretainQuery;
-function retainQuery(environment, queryToRetain) {
-    environment.retainedQueries.add(queryToRetain);
-    // TODO can we remove this query from the buffer somehow?
-    // We are relying on === equality, but we really should be comparing
-    // id + variables
-}
-exports.retainQuery = retainQuery;

package/dist/IsographEnvironmentProvider.d.ts

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

package/dist/IsographEnvironmentProvider.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.IsographEnvironmentContext = void 0;
+const React = __importStar(require("react"));
+const react_1 = require("react");
+exports.IsographEnvironmentContext = (0, react_1.createContext)(null);
+function IsographEnvironmentProvider({ environment, children, }) {
+    return (React.createElement(exports.IsographEnvironmentContext.Provider, { value: environment }, children));
+}
+exports.IsographEnvironmentProvider = IsographEnvironmentProvider;
+function useIsographEnvironment() {
+    const context = (0, react_1.useContext)(exports.IsographEnvironmentContext);
+    if (context == null) {
+        throw new Error('Unexpected null environment context. Make sure to render ' +
+            'this component within an IsographEnvironmentProvider component');
+    }
+    return context;
+}
+exports.useIsographEnvironment = useIsographEnvironment;

package/dist/cache.js

@@ -4,6 +4,7 @@ exports.SECOND_SPLIT_KEY = exports.FIRST_SPLIT_KEY = exports.getParentRecordKey
 const react_disposable_state_1 = require("@isograph/react-disposable-state");
 const PromiseWrapper_1 = require("./PromiseWrapper");
 const IsographEnvironment_1 = require("./IsographEnvironment");
+const garbageCollection_1 = require("./garbageCollection");
 function getOrCreateCache(environment, index, factory) {
     if (typeof window !== 'undefined' && window.__LOG) {
         console.log('getting cache for', {
@@ -69,7 +70,7 @@ function makeNetworkRequest(environment, artifact, variables) {
                 kind: 'UndisposedComplete',
                 retainedQuery,
             };
-            (0, IsographEnvironment_1.retainQuery)(environment, retainedQuery);
+            (0, garbageCollection_1.retainQuery)(environment, retainedQuery);
         }
         // TODO return null
         return networkResponse;
@@ -79,9 +80,9 @@ function makeNetworkRequest(environment, artifact, variables) {
         wrapper,
         () => {
             if (status.kind === 'UndisposedComplete') {
-                const didUnretainSomeQuery = (0, IsographEnvironment_1.unretainQuery)(environment, status.retainedQuery);
+                const didUnretainSomeQuery = (0, garbageCollection_1.unretainQuery)(environment, status.retainedQuery);
                 if (didUnretainSomeQuery) {
-                    (0, IsographEnvironment_1.garbageCollectEnvironment)(environment);
+                    (0, garbageCollection_1.garbageCollectEnvironment)(environment);
                 }
             }
             status = {

package/dist/entrypoint.d.ts

@@ -0,0 +1,32 @@
+import { Arguments } from './index';
+import { ReaderArtifact } from './reader';
+export type IsographEntrypoint<TReadFromStore extends Object, TResolverResult> = {
+    kind: 'Entrypoint';
+    queryText: string;
+    normalizationAst: NormalizationAst;
+    readerArtifact: ReaderArtifact<TReadFromStore, TResolverResult>;
+    nestedRefetchQueries: RefetchQueryArtifactWrapper[];
+};
+export type NormalizationAstNode = NormalizationScalarField | NormalizationLinkedField;
+export type NormalizationAst = NormalizationAstNode[];
+export type NormalizationScalarField = {
+    kind: 'Scalar';
+    fieldName: string;
+    arguments: Arguments | null;
+};
+export type NormalizationLinkedField = {
+    kind: 'Linked';
+    fieldName: string;
+    arguments: Arguments | null;
+    selections: NormalizationAst;
+};
+export type RefetchQueryArtifact = {
+    kind: 'RefetchQuery';
+    queryText: string;
+    normalizationAst: NormalizationAst;
+};
+export type RefetchQueryArtifactWrapper = {
+    artifact: RefetchQueryArtifact;
+    allowedVariables: string[];
+};
+export declare function assertIsEntrypoint<TReadFromStore extends Object, TResolverResult>(value: IsographEntrypoint<TReadFromStore, TResolverResult> | ((_: any) => any) | any): asserts value is IsographEntrypoint<TReadFromStore, TResolverResult>;

package/dist/entrypoint.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertIsEntrypoint = void 0;
+function assertIsEntrypoint(value) {
+    if (typeof value === 'function')
+        throw new Error('Not a string');
+}
+exports.assertIsEntrypoint = assertIsEntrypoint;

package/dist/garbageCollection.d.ts

@@ -0,0 +1,11 @@
+import { IsographEnvironment } from './IsographEnvironment';
+import { NormalizationAst } from './index';
+export type RetainedQuery = {
+    normalizationAst: NormalizationAst;
+    variables: {};
+};
+type DidUnretainSomeQuery = boolean;
+export declare function unretainQuery(environment: IsographEnvironment, retainedQuery: RetainedQuery): DidUnretainSomeQuery;
+export declare function retainQuery(environment: IsographEnvironment, queryToRetain: RetainedQuery): void;
+export declare function garbageCollectEnvironment(environment: IsographEnvironment): void;
+export {};

package/dist/garbageCollection.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.garbageCollectEnvironment = exports.retainQuery = exports.unretainQuery = void 0;
+const IsographEnvironment_1 = require("./IsographEnvironment");
+const cache_1 = require("./cache");
+function unretainQuery(environment, retainedQuery) {
+    environment.retainedQueries.delete(retainedQuery);
+    environment.gcBuffer.push(retainedQuery);
+    if (environment.gcBuffer.length > environment.gcBufferSize) {
+        environment.gcBuffer.shift();
+        return true;
+    }
+    return false;
+}
+exports.unretainQuery = unretainQuery;
+function retainQuery(environment, queryToRetain) {
+    environment.retainedQueries.add(queryToRetain);
+    // TODO can we remove this query from the buffer somehow?
+    // We are relying on === equality, but we really should be comparing
+    // id + variables
+}
+exports.retainQuery = retainQuery;
+function garbageCollectEnvironment(environment) {
+    const retainedIds = new Set([IsographEnvironment_1.ROOT_ID]);
+    for (const query of environment.retainedQueries) {
+        recordReachableIds(environment.store, query, retainedIds);
+    }
+    for (const query of environment.gcBuffer) {
+        recordReachableIds(environment.store, query, retainedIds);
+    }
+    for (const dataId in environment.store) {
+        if (!retainedIds.has(dataId)) {
+            delete environment.store[dataId];
+        }
+    }
+}
+exports.garbageCollectEnvironment = garbageCollectEnvironment;
+function recordReachableIds(store, retainedQuery, mutableRetainedIds) {
+    recordReachableIdsFromRecord(store, store[IsographEnvironment_1.ROOT_ID], mutableRetainedIds, retainedQuery.normalizationAst, retainedQuery.variables);
+}
+function getLinkedId(data) {
+    // @ts-expect-error
+    if (data.__link != null) {
+        // @ts-expect-error
+        return data.__link;
+    }
+    else {
+        throw new Error('Record in an invalid state');
+    }
+}
+function recordReachableIdsFromRecord(store, currentRecord, mutableRetainedIds, selections, variables) {
+    for (const selection of selections) {
+        switch (selection.kind) {
+            case 'Linked':
+                const linkKey = (0, cache_1.getParentRecordKey)(selection, variables !== null && variables !== void 0 ? variables : {});
+                const linkedFieldOrFields = currentRecord[linkKey];
+                const ids = [];
+                if (Array.isArray(linkedFieldOrFields)) {
+                    for (const link of linkedFieldOrFields) {
+                        if (link != null) {
+                            const id = getLinkedId(link);
+                            ids.push(id);
+                        }
+                    }
+                }
+                else {
+                    if (linkedFieldOrFields != null) {
+                        const id = getLinkedId(linkedFieldOrFields);
+                        ids.push(id);
+                    }
+                }
+                for (const nextRecordId of ids) {
+                    const nextRecord = store[nextRecordId];
+                    if (nextRecord != null) {
+                        mutableRetainedIds.add(nextRecordId);
+                        recordReachableIdsFromRecord(store, nextRecord, mutableRetainedIds, selection.selections, variables);
+                    }
+                }
+                continue;
+            case 'Scalar':
+                continue;
+        }
+    }
+}

package/dist/index.d.ts

@@ -1,85 +1,16 @@
 import { DataId, IsographEnvironment, Link, StoreRecord } from './IsographEnvironment';
+import { ReaderArtifact } from './reader';
+import { IsographEntrypoint, RefetchQueryArtifactWrapper } from './entrypoint';
+export { retainQuery, unretainQuery, type RetainedQuery, garbageCollectEnvironment, } from './garbageCollection';
 export { type PromiseWrapper } from './PromiseWrapper';
 export { makeNetworkRequest, subscribe } from './cache';
-export { IsographEnvironmentContext, ROOT_ID, type DataId, type DataTypeValue, type IsographEnvironment, IsographEnvironmentProvider, type IsographEnvironmentProviderProps, type IsographNetworkFunction, type IsographStore, type Link, type StoreRecord, useIsographEnvironment, createIsographEnvironment, createIsographStore, } from './IsographEnvironment';
+export { ROOT_ID, type DataId, type DataTypeValue, type IsographEnvironment, type IsographNetworkFunction, type IsographStore, type Link, type StoreRecord, createIsographEnvironment, createIsographStore, } from './IsographEnvironment';
+export { IsographEnvironmentProvider, useIsographEnvironment, type IsographEnvironmentProviderProps, } from './IsographEnvironmentProvider';
 export { useImperativeReference } from './useImperativeReference';
 export { EntrypointReader } from './EntrypointReader';
-export type IsographEntrypoint<TReadFromStore extends Object, TResolverResult> = {
-    kind: 'Entrypoint';
-    queryText: string;
-    normalizationAst: NormalizationAst;
-    readerArtifact: ReaderArtifact<TReadFromStore, TResolverResult>;
-    nestedRefetchQueries: RefetchQueryArtifactWrapper[];
-};
-export type ReaderArtifact<TReadFromStore extends Object, TResolverResult> = {
-    kind: 'ReaderArtifact';
-    readerAst: ReaderAst<TReadFromStore>;
-    resolver: (data: TReadFromStore, runtimeProps: any) => TResolverResult;
-    variant: ReaderResolverVariant;
-};
-export type ReaderAstNode = ReaderScalarField | ReaderLinkedField | ReaderResolverField | ReaderRefetchField | ReaderMutationField;
-export type ReaderAst<TReadFromStore> = ReaderAstNode[];
+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 type ExtractSecondParam<T extends (arg1: any, arg2: any) => any> = T extends (arg1: any, arg2: infer P) => any ? P : never;
-export type ReaderScalarField = {
-    kind: 'Scalar';
-    fieldName: string;
-    alias: string | null;
-    arguments: Arguments | null;
-};
-export type ReaderLinkedField = {
-    kind: 'Linked';
-    fieldName: string;
-    alias: string | null;
-    selections: ReaderAst<unknown>;
-    arguments: Arguments | null;
-};
-export type ReaderResolverVariant = {
-    kind: 'Eager';
-} | {
-    kind: 'Component';
-    componentName: string;
-};
-export type ReaderResolverField = {
-    kind: 'Resolver';
-    alias: string;
-    readerArtifact: ReaderArtifact<any, any>;
-    arguments: Arguments | null;
-    usedRefetchQueries: number[];
-};
-export type ReaderRefetchField = {
-    kind: 'RefetchField';
-    alias: string;
-    readerArtifact: ReaderArtifact<any, any>;
-    refetchQuery: number;
-};
-export type ReaderMutationField = {
-    kind: 'MutationField';
-    alias: string;
-    readerArtifact: ReaderArtifact<any, any>;
-    refetchQuery: number;
-};
-export type NormalizationAstNode = NormalizationScalarField | NormalizationLinkedField;
-export type NormalizationAst = NormalizationAstNode[];
-export type NormalizationScalarField = {
-    kind: 'Scalar';
-    fieldName: string;
-    arguments: Arguments | null;
-};
-export type NormalizationLinkedField = {
-    kind: 'Linked';
-    fieldName: string;
-    arguments: Arguments | null;
-    selections: NormalizationAst;
-};
-export type RefetchQueryArtifact = {
-    kind: 'RefetchQuery';
-    queryText: string;
-    normalizationAst: NormalizationAst;
-};
-export type RefetchQueryArtifactWrapper = {
-    artifact: RefetchQueryArtifact;
-    allowedVariables: string[];
-};
 export type Arguments = Argument[];
 export type Argument = [ArgumentName, ArgumentValue];
 export type ArgumentName = string;

package/dist/index.js

@@ -1,36 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultMissingFieldHandler = exports.readButDoNotEvaluate = exports.read = exports.useResult = exports.useLazyReference = exports.EntrypointReader = exports.useImperativeReference = exports.createIsographStore = exports.createIsographEnvironment = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.ROOT_ID = exports.IsographEnvironmentContext = exports.subscribe = exports.makeNetworkRequest = void 0;
+exports.defaultMissingFieldHandler = exports.readButDoNotEvaluate = exports.read = exports.useResult = exports.useLazyReference = exports.assertIsEntrypoint = exports.EntrypointReader = exports.useImperativeReference = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.createIsographStore = exports.createIsographEnvironment = exports.ROOT_ID = exports.subscribe = exports.makeNetworkRequest = exports.garbageCollectEnvironment = exports.unretainQuery = exports.retainQuery = void 0;
 const cache_1 = require("./cache");
 const react_disposable_state_1 = require("@isograph/react-disposable-state");
 const componentCache_1 = require("./componentCache");
 const IsographEnvironment_1 = require("./IsographEnvironment");
 const react_1 = require("react");
+const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
+const entrypoint_1 = require("./entrypoint");
+var garbageCollection_1 = require("./garbageCollection");
+Object.defineProperty(exports, "retainQuery", { enumerable: true, get: function () { return garbageCollection_1.retainQuery; } });
+Object.defineProperty(exports, "unretainQuery", { enumerable: true, get: function () { return garbageCollection_1.unretainQuery; } });
+Object.defineProperty(exports, "garbageCollectEnvironment", { enumerable: true, get: function () { return garbageCollection_1.garbageCollectEnvironment; } });
 var cache_2 = require("./cache");
 Object.defineProperty(exports, "makeNetworkRequest", { enumerable: true, get: function () { return cache_2.makeNetworkRequest; } });
 Object.defineProperty(exports, "subscribe", { enumerable: true, get: function () { return cache_2.subscribe; } });
 var IsographEnvironment_2 = require("./IsographEnvironment");
-Object.defineProperty(exports, "IsographEnvironmentContext", { enumerable: true, get: function () { return IsographEnvironment_2.IsographEnvironmentContext; } });
 Object.defineProperty(exports, "ROOT_ID", { enumerable: true, get: function () { return IsographEnvironment_2.ROOT_ID; } });
-Object.defineProperty(exports, "IsographEnvironmentProvider", { enumerable: true, get: function () { return IsographEnvironment_2.IsographEnvironmentProvider; } });
-Object.defineProperty(exports, "useIsographEnvironment", { enumerable: true, get: function () { return IsographEnvironment_2.useIsographEnvironment; } });
 Object.defineProperty(exports, "createIsographEnvironment", { enumerable: true, get: function () { return IsographEnvironment_2.createIsographEnvironment; } });
 Object.defineProperty(exports, "createIsographStore", { enumerable: true, get: function () { return IsographEnvironment_2.createIsographStore; } });
+var IsographEnvironmentProvider_2 = require("./IsographEnvironmentProvider");
+Object.defineProperty(exports, "IsographEnvironmentProvider", { enumerable: true, get: function () { return IsographEnvironmentProvider_2.IsographEnvironmentProvider; } });
+Object.defineProperty(exports, "useIsographEnvironment", { enumerable: true, get: function () { return IsographEnvironmentProvider_2.useIsographEnvironment; } });
 var useImperativeReference_1 = require("./useImperativeReference");
 Object.defineProperty(exports, "useImperativeReference", { enumerable: true, get: function () { return useImperativeReference_1.useImperativeReference; } });
 var EntrypointReader_1 = require("./EntrypointReader");
 Object.defineProperty(exports, "EntrypointReader", { enumerable: true, get: function () { return EntrypointReader_1.EntrypointReader; } });
-function assertIsEntrypoint(value) {
-    if (typeof value === 'function')
-        throw new Error('Not a string');
-}
+var entrypoint_2 = require("./entrypoint");
+Object.defineProperty(exports, "assertIsEntrypoint", { enumerable: true, get: function () { return entrypoint_2.assertIsEntrypoint; } });
 // Note: we cannot write TEntrypoint extends IsographEntrypoint<any, any, any>, or else
 // if we do not explicitly pass a type, the read out type will be any.
 // We cannot write TEntrypoint extends IsographEntrypoint<never, never, never>, or else
 // any actual Entrypoint we pass will not be valid.
 function useLazyReference(entrypoint, variables) {
-    const environment = (0, IsographEnvironment_1.useIsographEnvironment)();
-    assertIsEntrypoint(entrypoint);
+    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
+    (0, entrypoint_1.assertIsEntrypoint)(entrypoint);
     const cache = (0, cache_1.getOrCreateCacheForArtifact)(environment, entrypoint, variables);
     // TODO add comment explaining why we never use this value
     // @ts-ignore
@@ -47,7 +51,7 @@ function useLazyReference(entrypoint, variables) {
 }
 exports.useLazyReference = useLazyReference;
 function useResult(fragmentReference) {
-    const environment = (0, IsographEnvironment_1.useIsographEnvironment)();
+    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
     const [, setState] = (0, react_1.useState)();
     (0, react_1.useEffect)(() => {
         return (0, cache_1.subscribe)(environment, () => {

package/dist/reader.d.ts

@@ -0,0 +1,47 @@
+import { Arguments } from './index';
+export type ReaderArtifact<TReadFromStore extends Object, TResolverResult> = {
+    kind: 'ReaderArtifact';
+    readerAst: ReaderAst<TReadFromStore>;
+    resolver: (data: TReadFromStore, runtimeProps: any) => TResolverResult;
+    variant: ReaderResolverVariant;
+};
+export type ReaderAstNode = ReaderScalarField | ReaderLinkedField | ReaderResolverField | ReaderRefetchField | ReaderMutationField;
+export type ReaderAst<TReadFromStore> = ReaderAstNode[];
+export type ReaderScalarField = {
+    kind: 'Scalar';
+    fieldName: string;
+    alias: string | null;
+    arguments: Arguments | null;
+};
+export type ReaderLinkedField = {
+    kind: 'Linked';
+    fieldName: string;
+    alias: string | null;
+    selections: ReaderAst<unknown>;
+    arguments: Arguments | null;
+};
+export type ReaderResolverVariant = {
+    kind: 'Eager';
+} | {
+    kind: 'Component';
+    componentName: string;
+};
+export type ReaderResolverField = {
+    kind: 'Resolver';
+    alias: string;
+    readerArtifact: ReaderArtifact<any, any>;
+    arguments: Arguments | null;
+    usedRefetchQueries: number[];
+};
+export type ReaderRefetchField = {
+    kind: 'RefetchField';
+    alias: string;
+    readerArtifact: ReaderArtifact<any, any>;
+    refetchQuery: number;
+};
+export type ReaderMutationField = {
+    kind: 'MutationField';
+    alias: string;
+    readerArtifact: ReaderArtifact<any, any>;
+    refetchQuery: number;
+};

package/dist/reader.js

@@ -0,0 +1,3 @@
+"use strict";
+// TODO this should probably be at least three distinct types, for @component,
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.0.0-main-dc9ca2f6",
+  "version": "0.0.0-main-1bfd646b",
   "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-dc9ca2f6",
-    "@isograph/react-disposable-state": "0.0.0-main-dc9ca2f6",
+    "@isograph/disposable-types": "0.0.0-main-1bfd646b",
+    "@isograph/react-disposable-state": "0.0.0-main-1bfd646b",
     "react": "^18.2.0"
   },
   "devDependencies": {

package/src/IsographEnvironment.tsx

@@ -1,11 +1,5 @@
-import { ReactNode, createContext, useContext } from 'react';
-import * as React from 'react';
 import { ParentCache } from '@isograph/isograph-react-disposable-state';
-import { NormalizationAst } from './index';
-import { getParentRecordKey } from './cache';
-
-export const IsographEnvironmentContext =
-  createContext<IsographEnvironment | null>(null);
+import { RetainedQuery } from './garbageCollection';
 
 type ComponentName = string;
 type StringifiedArgs = string;
@@ -18,11 +12,6 @@ type ComponentCache = {
 export type Subscriptions = Set<() => void>;
 type SuspenseCache = { [index: string]: ParentCache<any> };
 
-export type RetainedQuery = {
-  normalizationAst: NormalizationAst;
-  variables: {};
-};
-
 export type IsographEnvironment = {
   store: IsographStore;
   networkFunction: IsographNetworkFunction;
@@ -51,6 +40,7 @@ export type IsographNetworkFunction = (
 export type Link = {
   __link: DataId;
 };
+
 export type DataTypeValue =
   // N.B. undefined is here to support optional id's, but
   // undefined should not *actually* be present in the store.
@@ -81,33 +71,6 @@ export type IsographStore = {
   __ROOT: StoreRecord;
 };
 
-export type IsographEnvironmentProviderProps = {
-  environment: IsographEnvironment;
-  children: ReactNode;
-};
-
-export function IsographEnvironmentProvider({
-  environment,
-  children,
-}: IsographEnvironmentProviderProps) {
-  return (
-    <IsographEnvironmentContext.Provider value={environment}>
-      {children}
-    </IsographEnvironmentContext.Provider>
-  );
-}
-
-export function useIsographEnvironment(): IsographEnvironment {
-  const context = useContext(IsographEnvironmentContext);
-  if (context == null) {
-    throw new Error(
-      'Unexpected null environment context. Make sure to render ' +
-        'this component within an IsographEnvironmentProvider component',
-    );
-  }
-  return context;
-}
-
 const DEFAULT_GC_BUFFER_SIZE = 10;
 export function createIsographEnvironment(
   store: IsographStore,
@@ -132,119 +95,3 @@ export function createIsographStore() {
     [ROOT_ID]: {},
   };
 }
-
-export function garbageCollectEnvironment(environment: IsographEnvironment) {
-  const retainedIds = new Set<DataId>([ROOT_ID]);
-
-  for (const query of environment.retainedQueries) {
-    recordReachableIds(environment.store, query, retainedIds);
-  }
-  for (const query of environment.gcBuffer) {
-    recordReachableIds(environment.store, query, retainedIds);
-  }
-
-  for (const dataId in environment.store) {
-    if (!retainedIds.has(dataId)) {
-      delete environment.store[dataId];
-    }
-  }
-}
-
-function recordReachableIds(
-  store: IsographStore,
-  retainedQuery: RetainedQuery,
-  mutableRetainedIds: Set<DataId>,
-) {
-  recordReachableIdsFromRecord(
-    store,
-    store[ROOT_ID],
-    mutableRetainedIds,
-    retainedQuery.normalizationAst,
-    retainedQuery.variables,
-  );
-}
-
-function getLinkedId(data: Exclude<DataTypeValue, null | void>): string {
-  // @ts-expect-error
-  if (data.__link != null) {
-    // @ts-expect-error
-    return data.__link;
-  } else {
-    throw new Error('Record in an invalid state');
-  }
-}
-
-function recordReachableIdsFromRecord(
-  store: IsographStore,
-  currentRecord: StoreRecord,
-  mutableRetainedIds: Set<DataId>,
-  selections: NormalizationAst,
-  variables: { [index: string]: string } | null,
-) {
-  for (const selection of selections) {
-    switch (selection.kind) {
-      case 'Linked':
-        const linkKey = getParentRecordKey(selection, variables ?? {});
-        const linkedFieldOrFields = currentRecord[linkKey];
-
-        const ids = [];
-        if (Array.isArray(linkedFieldOrFields)) {
-          for (const link of linkedFieldOrFields) {
-            if (link != null) {
-              const id = getLinkedId(link);
-              ids.push(id);
-            }
-          }
-        } else {
-          if (linkedFieldOrFields != null) {
-            const id = getLinkedId(linkedFieldOrFields);
-            ids.push(id);
-          }
-        }
-
-        for (const nextRecordId of ids) {
-          const nextRecord = store[nextRecordId];
-          if (nextRecord != null) {
-            mutableRetainedIds.add(nextRecordId);
-            recordReachableIdsFromRecord(
-              store,
-              nextRecord,
-              mutableRetainedIds,
-              selection.selections,
-              variables,
-            );
-          }
-        }
-
-        continue;
-      case 'Scalar':
-        continue;
-    }
-  }
-}
-
-type DidUnretainSomeQuery = boolean;
-export function unretainQuery(
-  environment: IsographEnvironment,
-  retainedQuery: RetainedQuery,
-): DidUnretainSomeQuery {
-  environment.retainedQueries.delete(retainedQuery);
-  environment.gcBuffer.push(retainedQuery);
-
-  if (environment.gcBuffer.length > environment.gcBufferSize) {
-    environment.gcBuffer.shift();
-    return true;
-  }
-
-  return false;
-}
-
-export function retainQuery(
-  environment: IsographEnvironment,
-  queryToRetain: RetainedQuery,
-) {
-  environment.retainedQueries.add(queryToRetain);
-  // TODO can we remove this query from the buffer somehow?
-  // We are relying on === equality, but we really should be comparing
-  // id + variables
-}

package/src/IsographEnvironmentProvider.tsx

@@ -0,0 +1,33 @@
+import * as React from 'react';
+import { ReactNode, createContext, useContext } from 'react';
+import { type IsographEnvironment } from './IsographEnvironment';
+
+export const IsographEnvironmentContext =
+  createContext<IsographEnvironment | null>(null);
+
+export type IsographEnvironmentProviderProps = {
+  environment: IsographEnvironment;
+  children: ReactNode;
+};
+
+export function IsographEnvironmentProvider({
+  environment,
+  children,
+}: IsographEnvironmentProviderProps) {
+  return (
+    <IsographEnvironmentContext.Provider value={environment}>
+      {children}
+    </IsographEnvironmentContext.Provider>
+  );
+}
+
+export function useIsographEnvironment(): IsographEnvironment {
+  const context = useContext(IsographEnvironmentContext);
+  if (context == null) {
+    throw new Error(
+      'Unexpected null environment context. Make sure to render ' +
+        'this component within an IsographEnvironmentProvider component',
+    );
+  }
+  return context;
+}

package/src/cache.tsx

@@ -21,11 +21,13 @@ import {
   StoreRecord,
   Link,
   type IsographEnvironment,
-  garbageCollectEnvironment,
+} from './IsographEnvironment';
+import {
   RetainedQuery,
-  unretainQuery,
+  garbageCollectEnvironment,
   retainQuery,
-} from './IsographEnvironment';
+  unretainQuery,
+} from './garbageCollection';
 
 declare global {
   interface Window {

package/src/entrypoint.ts

@@ -0,0 +1,59 @@
+import { Arguments } from './index';
+import { ReaderArtifact } from './reader';
+
+// This type should be treated as an opaque type.
+export type IsographEntrypoint<
+  TReadFromStore extends Object,
+  TResolverResult,
+> = {
+  kind: 'Entrypoint';
+  queryText: string;
+  normalizationAst: NormalizationAst;
+  readerArtifact: ReaderArtifact<TReadFromStore, TResolverResult>;
+  nestedRefetchQueries: RefetchQueryArtifactWrapper[];
+};
+
+export type NormalizationAstNode =
+  | NormalizationScalarField
+  | NormalizationLinkedField;
+export type NormalizationAst = NormalizationAstNode[];
+
+export type NormalizationScalarField = {
+  kind: 'Scalar';
+  fieldName: string;
+  arguments: Arguments | null;
+};
+
+export type NormalizationLinkedField = {
+  kind: 'Linked';
+  fieldName: string;
+  arguments: Arguments | null;
+  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;
+};
+
+// TODO rename
+export type RefetchQueryArtifactWrapper = {
+  artifact: RefetchQueryArtifact;
+  allowedVariables: string[];
+};
+
+export function assertIsEntrypoint<
+  TReadFromStore extends Object,
+  TResolverResult,
+>(
+  value:
+    | IsographEntrypoint<TReadFromStore, TResolverResult>
+    | ((_: any) => any)
+    // Temporarily, allow any here. Once we automatically provide
+    // types to entrypoints, we probably don't need this.
+    | any,
+): asserts value is IsographEntrypoint<TReadFromStore, TResolverResult> {
+  if (typeof value === 'function') throw new Error('Not a string');
+}

package/src/garbageCollection.ts

@@ -0,0 +1,131 @@
+import {
+  DataId,
+  DataTypeValue,
+  IsographEnvironment,
+  IsographStore,
+  ROOT_ID,
+  StoreRecord,
+} from './IsographEnvironment';
+import { NormalizationAst } from './index';
+import { getParentRecordKey } from './cache';
+
+export type RetainedQuery = {
+  normalizationAst: NormalizationAst;
+  variables: {};
+};
+
+type DidUnretainSomeQuery = boolean;
+export function unretainQuery(
+  environment: IsographEnvironment,
+  retainedQuery: RetainedQuery,
+): DidUnretainSomeQuery {
+  environment.retainedQueries.delete(retainedQuery);
+  environment.gcBuffer.push(retainedQuery);
+
+  if (environment.gcBuffer.length > environment.gcBufferSize) {
+    environment.gcBuffer.shift();
+    return true;
+  }
+
+  return false;
+}
+
+export function retainQuery(
+  environment: IsographEnvironment,
+  queryToRetain: RetainedQuery,
+) {
+  environment.retainedQueries.add(queryToRetain);
+  // TODO can we remove this query from the buffer somehow?
+  // We are relying on === equality, but we really should be comparing
+  // id + variables
+}
+
+export function garbageCollectEnvironment(environment: IsographEnvironment) {
+  const retainedIds = new Set<DataId>([ROOT_ID]);
+
+  for (const query of environment.retainedQueries) {
+    recordReachableIds(environment.store, query, retainedIds);
+  }
+  for (const query of environment.gcBuffer) {
+    recordReachableIds(environment.store, query, retainedIds);
+  }
+
+  for (const dataId in environment.store) {
+    if (!retainedIds.has(dataId)) {
+      delete environment.store[dataId];
+    }
+  }
+}
+
+function recordReachableIds(
+  store: IsographStore,
+  retainedQuery: RetainedQuery,
+  mutableRetainedIds: Set<DataId>,
+) {
+  recordReachableIdsFromRecord(
+    store,
+    store[ROOT_ID],
+    mutableRetainedIds,
+    retainedQuery.normalizationAst,
+    retainedQuery.variables,
+  );
+}
+
+function getLinkedId(data: Exclude<DataTypeValue, null | void>): string {
+  // @ts-expect-error
+  if (data.__link != null) {
+    // @ts-expect-error
+    return data.__link;
+  } else {
+    throw new Error('Record in an invalid state');
+  }
+}
+
+function recordReachableIdsFromRecord(
+  store: IsographStore,
+  currentRecord: StoreRecord,
+  mutableRetainedIds: Set<DataId>,
+  selections: NormalizationAst,
+  variables: { [index: string]: string } | null,
+) {
+  for (const selection of selections) {
+    switch (selection.kind) {
+      case 'Linked':
+        const linkKey = getParentRecordKey(selection, variables ?? {});
+        const linkedFieldOrFields = currentRecord[linkKey];
+
+        const ids = [];
+        if (Array.isArray(linkedFieldOrFields)) {
+          for (const link of linkedFieldOrFields) {
+            if (link != null) {
+              const id = getLinkedId(link);
+              ids.push(id);
+            }
+          }
+        } else {
+          if (linkedFieldOrFields != null) {
+            const id = getLinkedId(linkedFieldOrFields);
+            ids.push(id);
+          }
+        }
+
+        for (const nextRecordId of ids) {
+          const nextRecord = store[nextRecordId];
+          if (nextRecord != null) {
+            mutableRetainedIds.add(nextRecordId);
+            recordReachableIdsFromRecord(
+              store,
+              nextRecord,
+              mutableRetainedIds,
+              selection.selections,
+              variables,
+            );
+          }
+        }
+
+        continue;
+      case 'Scalar':
+        continue;
+    }
+  }
+}

package/src/index.tsx

@@ -14,140 +14,68 @@ import {
   Link,
   ROOT_ID,
   StoreRecord,
-  useIsographEnvironment,
 } from './IsographEnvironment';
 import { useEffect, useState } from 'react';
+import { useIsographEnvironment } from './IsographEnvironmentProvider';
+import { ReaderArtifact, ReaderAst } from './reader';
+import {
+  IsographEntrypoint,
+  RefetchQueryArtifactWrapper,
+  assertIsEntrypoint,
+} from './entrypoint';
 
+export {
+  retainQuery,
+  unretainQuery,
+  type RetainedQuery,
+  garbageCollectEnvironment,
+} from './garbageCollection';
 export { type PromiseWrapper } from './PromiseWrapper';
 export { makeNetworkRequest, subscribe } from './cache';
 export {
-  IsographEnvironmentContext,
   ROOT_ID,
   type DataId,
   type DataTypeValue,
   type IsographEnvironment,
-  IsographEnvironmentProvider,
-  type IsographEnvironmentProviderProps,
   type IsographNetworkFunction,
   type IsographStore,
   type Link,
   type StoreRecord,
-  useIsographEnvironment,
   createIsographEnvironment,
   createIsographStore,
 } from './IsographEnvironment';
+export {
+  IsographEnvironmentProvider,
+  useIsographEnvironment,
+  type IsographEnvironmentProviderProps,
+} from './IsographEnvironmentProvider';
 export { useImperativeReference } from './useImperativeReference';
 export { EntrypointReader } from './EntrypointReader';
-
-// This type should be treated as an opaque type.
-export type IsographEntrypoint<
-  TReadFromStore extends Object,
-  TResolverResult,
-> = {
-  kind: 'Entrypoint';
-  queryText: string;
-  normalizationAst: NormalizationAst;
-  readerArtifact: ReaderArtifact<TReadFromStore, TResolverResult>;
-  nestedRefetchQueries: RefetchQueryArtifactWrapper[];
-};
-
-// TODO this should probably be at least three distinct types, for @component,
-// non-@component and refetch resolvers
-export type ReaderArtifact<TReadFromStore extends Object, TResolverResult> = {
-  kind: 'ReaderArtifact';
-  readerAst: ReaderAst<TReadFromStore>;
-  resolver: (data: TReadFromStore, runtimeProps: any) => TResolverResult;
-  variant: ReaderResolverVariant;
-};
-
-export type ReaderAstNode =
-  | ReaderScalarField
-  | ReaderLinkedField
-  | ReaderResolverField
-  | ReaderRefetchField
-  | ReaderMutationField;
-
-// @ts-ignore
-export type ReaderAst<TReadFromStore> = ReaderAstNode[];
+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 type ExtractSecondParam<T extends (arg1: any, arg2: any) => any> =
   T extends (arg1: any, arg2: infer P) => any ? P : never;
 
-export type ReaderScalarField = {
-  kind: 'Scalar';
-  fieldName: string;
-  alias: string | null;
-  arguments: Arguments | null;
-};
-export type ReaderLinkedField = {
-  kind: 'Linked';
-  fieldName: string;
-  alias: string | null;
-  selections: ReaderAst<unknown>;
-  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 };
-
-export type ReaderResolverField = {
-  kind: 'Resolver';
-  alias: string;
-  readerArtifact: ReaderArtifact<any, any>;
-  arguments: Arguments | null;
-  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;
-};
-
-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;
-};
-
-export type NormalizationAstNode =
-  | NormalizationScalarField
-  | NormalizationLinkedField;
-export type NormalizationAst = NormalizationAstNode[];
-
-export type NormalizationScalarField = {
-  kind: 'Scalar';
-  fieldName: string;
-  arguments: Arguments | null;
-};
-
-export type NormalizationLinkedField = {
-  kind: 'Linked';
-  fieldName: string;
-  arguments: Arguments | null;
-  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;
-};
-
-// TODO rename
-export type RefetchQueryArtifactWrapper = {
-  artifact: RefetchQueryArtifact;
-  allowedVariables: string[];
-};
-
 export type Arguments = Argument[];
 export type Argument = [ArgumentName, ArgumentValue];
 export type ArgumentName = string;
@@ -176,17 +104,6 @@ export type FragmentReference<
   nestedRefetchQueries: RefetchQueryArtifactWrapper[];
 };
 
-function assertIsEntrypoint<TReadFromStore extends Object, TResolverResult>(
-  value:
-    | IsographEntrypoint<TReadFromStore, TResolverResult>
-    | ((_: any) => any)
-    // Temporarily, allow any here. Once we automatically provide
-    // types to entrypoints, we probably don't need this.
-    | any,
-): asserts value is IsographEntrypoint<TReadFromStore, TResolverResult> {
-  if (typeof value === 'function') throw new Error('Not a string');
-}
-
 export type ExtractReadFromStore<Type> =
   Type extends IsographEntrypoint<infer X, any> ? X : never;
 export type ExtractResolverResult<Type> =

package/src/reader.ts

@@ -0,0 +1,65 @@
+// TODO this should probably be at least three distinct types, for @component,
+
+import { Arguments } from './index';
+
+// non-@component and refetch resolvers
+export type ReaderArtifact<TReadFromStore extends Object, TResolverResult> = {
+  kind: 'ReaderArtifact';
+  readerAst: ReaderAst<TReadFromStore>;
+  resolver: (data: TReadFromStore, runtimeProps: any) => TResolverResult;
+  variant: ReaderResolverVariant;
+};
+
+export type ReaderAstNode =
+  | ReaderScalarField
+  | ReaderLinkedField
+  | ReaderResolverField
+  | ReaderRefetchField
+  | ReaderMutationField;
+
+// @ts-ignore
+export type ReaderAst<TReadFromStore> = ReaderAstNode[];
+
+export type ReaderScalarField = {
+  kind: 'Scalar';
+  fieldName: string;
+  alias: string | null;
+  arguments: Arguments | null;
+};
+export type ReaderLinkedField = {
+  kind: 'Linked';
+  fieldName: string;
+  alias: string | null;
+  selections: ReaderAst<unknown>;
+  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 };
+
+export type ReaderResolverField = {
+  kind: 'Resolver';
+  alias: string;
+  readerArtifact: ReaderArtifact<any, any>;
+  arguments: Arguments | null;
+  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;
+};
+
+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;
+};