@isograph/react 0.0.0-main-df52a61c → 0.0.0-main-2f4311e8

package/dist/core/FragmentReference.d.ts

@@ -5,7 +5,10 @@ export type VariableValue = string | number | boolean | null | object;
 export type Variables = {
     readonly [index: string]: VariableValue;
 };
-export type FragmentReference<TReadFromStore extends Object, TClientFieldValue> = {
+export type FragmentReference<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}, TClientFieldValue> = {
     readonly kind: 'FragmentReference';
     readonly readerWithRefetchQueries: PromiseWrapper<ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>>;
     readonly root: DataId;

package/dist/core/IsographEnvironment.d.ts

@@ -15,7 +15,10 @@ type ComponentCache = {
         };
     };
 };
-export type FragmentSubscription<TReadFromStore extends Object> = {
+export type FragmentSubscription<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}> = {
     readonly kind: 'FragmentSubscription';
     readonly callback: (newEncounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>) => void;
     /** The value read out from the previous call to readButDoNotEvaluate */
@@ -27,7 +30,10 @@ type AnyRecordSubscription = {
     readonly kind: 'AnyRecords';
     readonly callback: () => void;
 };
-type Subscription = FragmentSubscription<Object> | AnyRecordSubscription;
+type Subscription = FragmentSubscription<{
+    parameters: object;
+    data: object;
+}> | AnyRecordSubscription;
 type Subscriptions = Set<Subscription>;
 type CacheMap<T> = {
     [index: string]: ParentCache<T>;

package/dist/core/cache.d.ts

@@ -4,14 +4,20 @@ import { IsographEntrypoint, NormalizationAst, NormalizationLinkedField, Normali
 import { ReaderLinkedField, ReaderScalarField, type ReaderAst } from './reader';
 import { WithEncounteredRecords } from './read';
 import { FragmentReference, Variables } from './FragmentReference';
-export declare function getOrCreateItemInSuspenseCache<TReadFromStore extends Object, TClientFieldValue>(environment: IsographEnvironment, index: string, factory: Factory<FragmentReference<TReadFromStore, TClientFieldValue>>): ParentCache<FragmentReference<TReadFromStore, TClientFieldValue>>;
+export declare function getOrCreateItemInSuspenseCache<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}, TClientFieldValue>(environment: IsographEnvironment, index: string, factory: Factory<FragmentReference<TReadFromStore, TClientFieldValue>>): ParentCache<FragmentReference<TReadFromStore, TClientFieldValue>>;
 /**
  * Creates a copy of the provided value, ensuring any nested objects have their
  * keys sorted such that equivalent values would have identical JSON.stringify
  * results.
  */
 export declare function stableCopy<T>(value: T): T;
-export declare function getOrCreateCacheForArtifact<TReadFromStore extends Object, TClientFieldValue>(environment: IsographEnvironment, entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>, variables: Variables): ParentCache<FragmentReference<TReadFromStore, TClientFieldValue>>;
+export declare function getOrCreateCacheForArtifact<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}, TClientFieldValue>(environment: IsographEnvironment, entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>, variables: Variables): ParentCache<FragmentReference<TReadFromStore, TClientFieldValue>>;
 type NetworkResponseScalarValue = string | number | boolean;
 type NetworkResponseValue = NetworkResponseScalarValue | null | NetworkResponseObject | NetworkResponseObject[] | NetworkResponseScalarValue[];
 type NetworkResponseObject = {
@@ -20,7 +26,10 @@ type NetworkResponseObject = {
 };
 export declare function normalizeData(environment: IsographEnvironment, normalizationAst: NormalizationAst, networkResponse: NetworkResponseObject, variables: Variables, nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[]): Set<DataId>;
 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, readerAst: ReaderAst<TReadFromStore>): () => void;
+export declare function subscribe<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}>(environment: IsographEnvironment, encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>, fragmentReference: FragmentReference<TReadFromStore, any>, callback: (newEncounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>) => void, readerAst: ReaderAst<TReadFromStore>): () => void;
 export declare function onNextChange(environment: IsographEnvironment): Promise<void>;
 export declare function getParentRecordKey(astNode: NormalizationLinkedField | NormalizationScalarField | ReaderLinkedField | ReaderScalarField, variables: Variables): string;
 export declare const FIRST_SPLIT_KEY = "____";

package/dist/core/entrypoint.d.ts

@@ -1,18 +1,27 @@
 /// <reference types="react" />
 import { TopLevelReaderArtifact } from './reader';
 import { Arguments } from './util';
-export type ReaderWithRefetchQueries<TReadFromStore extends Object, TClientFieldValue> = {
+export type ReaderWithRefetchQueries<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}, TClientFieldValue> = {
     readonly kind: 'ReaderWithRefetchQueries';
     readonly readerArtifact: TopLevelReaderArtifact<TReadFromStore, TClientFieldValue, any>;
     readonly nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[];
 };
-export type IsographEntrypoint<TReadFromStore extends Object, TClientFieldValue> = {
+export type IsographEntrypoint<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}, TClientFieldValue> = {
     readonly kind: 'Entrypoint';
     readonly queryText: string;
     readonly normalizationAst: NormalizationAst;
     readonly readerWithRefetchQueries: ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>;
 };
-export type IsographEntrypointLoader<TReadFromStore extends Object, TClientFieldValue> = {
+export type IsographEntrypointLoader<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}, TClientFieldValue> = {
     readonly kind: 'EntrypointLoader';
     readonly typeAndField: string;
     readonly loader: () => Promise<IsographEntrypoint<TReadFromStore, TClientFieldValue>>;
@@ -44,7 +53,10 @@ 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 declare function assertIsEntrypoint<TReadFromStore extends {
+    parameters: object;
+    data: 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;
 export type ExtractResolverResult<Type> = Type extends IsographEntrypoint<any, infer X> ? X : never;
 export type ExtractProps<Type> = Type extends React.FC<infer X> ? X : never;

package/dist/core/read.d.ts

@@ -4,7 +4,10 @@ export type WithEncounteredRecords<T> = {
     readonly encounteredRecords: Set<DataId>;
     readonly item: T;
 };
-export declare function readButDoNotEvaluate<TReadFromStore extends Object>(environment: IsographEnvironment, fragmentReference: FragmentReference<TReadFromStore, unknown>, networkRequestOptions: NetworkRequestReaderOptions): WithEncounteredRecords<TReadFromStore>;
+export declare function readButDoNotEvaluate<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}>(environment: IsographEnvironment, fragmentReference: FragmentReference<TReadFromStore, unknown>, networkRequestOptions: NetworkRequestReaderOptions): WithEncounteredRecords<TReadFromStore>;
 export type NetworkRequestReaderOptions = {
     suspendIfInFlight: boolean;
     throwOnNetworkError: boolean;

package/dist/core/reader.d.ts

@@ -4,19 +4,28 @@ import { FragmentReference, Variables } from './FragmentReference';
 import { ComponentOrFieldName, DataId, IsographEnvironment } from './IsographEnvironment';
 import { IsographEntrypoint, IsographEntrypointLoader, RefetchQueryNormalizationArtifact, RefetchQueryNormalizationArtifactWrapper } from './entrypoint';
 import { Arguments } from './util';
-export type TopLevelReaderArtifact<TReadFromStore extends Object, TClientFieldValue, TComponentProps extends Record<string, never>, TVariables = Variables> = EagerReaderArtifact<TReadFromStore, TClientFieldValue, TVariables> | ComponentReaderArtifact<TReadFromStore, TComponentProps, TVariables>;
-export type EagerReaderArtifact<TReadFromStore extends Object, TClientFieldValue, TVariables = Variables> = {
+export type TopLevelReaderArtifact<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}, TClientFieldValue, TComponentProps extends Record<string, never>, TVariables = Variables> = EagerReaderArtifact<TReadFromStore, TClientFieldValue, TVariables> | ComponentReaderArtifact<TReadFromStore, TComponentProps, TVariables>;
+export type EagerReaderArtifact<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}, TClientFieldValue, TVariables = Variables> = {
     readonly kind: 'EagerReaderArtifact';
     readonly readerAst: ReaderAst<TReadFromStore>;
     readonly resolver: (data: ResolverFirstParameter<TReadFromStore, TVariables>) => TClientFieldValue;
 };
-export type ComponentReaderArtifact<TReadFromStore extends Object, TComponentProps extends Record<string, unknown> = Record<string, never>, TVariables = Variables> = {
+export type ComponentReaderArtifact<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}, TComponentProps extends Record<string, unknown> = Record<string, never>, TVariables = Variables> = {
     readonly kind: 'ComponentReaderArtifact';
     readonly componentName: ComponentOrFieldName;
     readonly readerAst: ReaderAst<TReadFromStore>;
     readonly resolver: (data: ResolverFirstParameter<TReadFromStore, TVariables>, runtimeProps: TComponentProps) => React.ReactNode;
 };
-export type ResolverFirstParameter<TReadFromStore extends Object, TVariables = Variables> = {
+export type ResolverFirstParameter<TReadFromStore extends object, TVariables = Variables> = {
     readonly data: TReadFromStore;
     readonly parameters: TVariables;
 };

package/dist/loadable-hooks/useClientSideDefer.d.ts

@@ -1,8 +1,8 @@
 import { FragmentReference } from '../core/FragmentReference';
 import { LoadableField } from '../core/reader';
 export declare function useClientSideDefer<TResult>(loadableField: LoadableField<void, TResult>): {
-    fragmentReference: FragmentReference<Record<string, never>, TResult>;
+    fragmentReference: FragmentReference<any, TResult>;
 };
-export declare function useClientSideDefer<TArgs extends Object, TResult>(loadableField: LoadableField<TArgs, TResult>, args: TArgs): {
-    fragmentReference: FragmentReference<TArgs, TResult>;
+export declare function useClientSideDefer<TArgs extends object, TResult>(loadableField: LoadableField<TArgs, TResult>, args: TArgs): {
+    fragmentReference: FragmentReference<any, TResult>;
 };

package/dist/loadable-hooks/useSkipLimitPagination.d.ts

@@ -14,5 +14,8 @@ type UseSkipLimitReturnValue<TArgs, TItem> = {
 export declare function useSkipLimitPagination<TArgs extends {
     skip: number | void | null;
     limit: number | void | null;
-}, TItem, TReadFromStore extends Object>(loadableField: LoadableField<TArgs, ReadonlyArray<TItem>>): UseSkipLimitReturnValue<TArgs, TItem>;
+}, TItem, TReadFromStore extends {
+    parameters: object;
+    data: object;
+}>(loadableField: LoadableField<TArgs, ReadonlyArray<TItem>>): UseSkipLimitReturnValue<TArgs, TItem>;
 export {};

package/dist/react/useImperativeReference.d.ts

@@ -1,7 +1,10 @@
 import { UnassignedState } from '@isograph/react-disposable-state';
 import { IsographEntrypoint } from '../core/entrypoint';
 import { FragmentReference, Variables } from '../core/FragmentReference';
-export declare function useImperativeReference<TReadFromStore extends Object, TClientFieldValue>(entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>): {
+export declare function useImperativeReference<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}, TClientFieldValue>(entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>): {
     fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue> | UnassignedState;
     loadFragmentReference: (variables: Variables) => void;
 };

package/dist/react/useLazyReference.d.ts

@@ -1,5 +1,8 @@
 import { FragmentReference, Variables } from '../core/FragmentReference';
 import { IsographEntrypoint } from '../core/entrypoint';
-export declare function useLazyReference<TReadFromStore extends Object, TClientFieldValue>(entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>, variables: Variables): {
+export declare function useLazyReference<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}, TClientFieldValue>(entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>, variables: Variables): {
     fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>;
 };

package/dist/react/useReadAndSubscribe.d.ts

@@ -4,8 +4,14 @@ import type { ReaderAst } from '../core/reader';
 /**
  * Read the data from a fragment reference and subscribe to updates.
  */
-export declare function useReadAndSubscribe<TReadFromStore extends Object>(fragmentReference: FragmentReference<TReadFromStore, any>, networkRequestOptions: NetworkRequestReaderOptions, readerAst: ReaderAst<TReadFromStore>): TReadFromStore;
-export declare function useSubscribeToMultiple<TReadFromStore extends Object>(items: ReadonlyArray<{
+export declare function useReadAndSubscribe<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}>(fragmentReference: FragmentReference<TReadFromStore, any>, networkRequestOptions: NetworkRequestReaderOptions, readerAst: ReaderAst<TReadFromStore>): TReadFromStore;
+export declare function useSubscribeToMultiple<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}>(items: ReadonlyArray<{
     records: WithEncounteredRecords<TReadFromStore>;
     callback: (updatedRecords: WithEncounteredRecords<TReadFromStore>) => void;
     fragmentReference: FragmentReference<TReadFromStore, any>;

package/dist/react/useRerenderOnChange.d.ts

@@ -1,4 +1,7 @@
 import { WithEncounteredRecords } from '../core/read';
 import { FragmentReference } from '../core/FragmentReference';
 import type { ReaderAst } from '../core/reader';
-export declare function useRerenderOnChange<TReadFromStore extends Object>(encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>, fragmentReference: FragmentReference<any, any>, setEncounteredDataAndRecords: (data: WithEncounteredRecords<TReadFromStore>) => void, readerAst: ReaderAst<TReadFromStore>): void;
+export declare function useRerenderOnChange<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}>(encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>, fragmentReference: FragmentReference<any, any>, setEncounteredDataAndRecords: (data: WithEncounteredRecords<TReadFromStore>) => void, readerAst: ReaderAst<TReadFromStore>): void;

package/dist/react/useResult.d.ts

@@ -1,5 +1,8 @@
 import { FragmentReference } from '../core/FragmentReference';
 import { NetworkRequestReaderOptions } from '../core/read';
 import { PromiseWrapper } from '../core/PromiseWrapper';
-export declare function useResult<TReadFromStore extends Object, TClientFieldValue>(fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>, partialNetworkRequestOptions?: Partial<NetworkRequestReaderOptions> | void): TClientFieldValue;
+export declare function useResult<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}, TClientFieldValue>(fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>, partialNetworkRequestOptions?: Partial<NetworkRequestReaderOptions> | void): TClientFieldValue;
 export declare function maybeUnwrapNetworkRequest(networkRequest: PromiseWrapper<void, any>, networkRequestOptions: NetworkRequestReaderOptions): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.0.0-main-df52a61c",
+  "version": "0.0.0-main-2f4311e8",
   "description": "Use Isograph with React",
   "homepage": "https://isograph.dev",
   "main": "dist/index.js",
@@ -17,9 +17,9 @@
     "tsc": "tsc"
   },
   "dependencies": {
-    "@isograph/disposable-types": "0.0.0-main-df52a61c",
-    "@isograph/react-disposable-state": "0.0.0-main-df52a61c",
-    "@isograph/reference-counted-pointer": "0.0.0-main-df52a61c"
+    "@isograph/disposable-types": "0.0.0-main-2f4311e8",
+    "@isograph/react-disposable-state": "0.0.0-main-2f4311e8",
+    "@isograph/reference-counted-pointer": "0.0.0-main-2f4311e8"
   },
   "peerDependencies": {
     "react": "18.2.0"

package/src/core/FragmentReference.ts

@@ -8,7 +8,7 @@ export type VariableValue = string | number | boolean | null | object;
 export type Variables = { readonly [index: string]: VariableValue };
 
 export type FragmentReference<
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
   TClientFieldValue,
 > = {
   readonly kind: 'FragmentReference';

package/src/core/IsographEnvironment.ts

@@ -14,7 +14,9 @@ type ComponentCache = {
   };
 };
 
-export type FragmentSubscription<TReadFromStore extends Object> = {
+export type FragmentSubscription<
+  TReadFromStore extends { parameters: object; data: object },
+> = {
   readonly kind: 'FragmentSubscription';
   readonly callback: (
     newEncounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>,
@@ -29,7 +31,9 @@ type AnyRecordSubscription = {
   readonly callback: () => void;
 };
 
-type Subscription = FragmentSubscription<Object> | AnyRecordSubscription;
+type Subscription =
+  | FragmentSubscription<{ parameters: object; data: object }>
+  | AnyRecordSubscription;
 type Subscriptions = Set<Subscription>;
 // Should this be a map?
 type CacheMap<T> = { [index: string]: ParentCache<T> };

package/src/core/cache.ts

@@ -32,7 +32,7 @@ import { wrapResolvedValue } from './PromiseWrapper';
 const TYPENAME_FIELD_NAME = '__typename';
 
 export function getOrCreateItemInSuspenseCache<
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
   TClientFieldValue,
 >(
   environment: IsographEnvironment,
@@ -77,7 +77,7 @@ export function stableCopy<T>(value: T): T {
 }
 
 export function getOrCreateCacheForArtifact<
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
   TClientFieldValue,
 >(
   environment: IsographEnvironment,
@@ -180,7 +180,9 @@ export function subscribeToAnyChange(
 }
 
 // TODO we should re-read and call callback if the value has changed
-export function subscribe<TReadFromStore extends Object>(
+export function subscribe<
+  TReadFromStore extends { parameters: object; data: object },
+>(
   environment: IsographEnvironment,
   encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>,
   fragmentReference: FragmentReference<TReadFromStore, any>,

package/src/core/entrypoint.ts

@@ -2,7 +2,7 @@ import { TopLevelReaderArtifact } from './reader';
 import { Arguments } from './util';
 
 export type ReaderWithRefetchQueries<
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
   TClientFieldValue,
 > = {
   readonly kind: 'ReaderWithRefetchQueries';
@@ -17,7 +17,7 @@ export type ReaderWithRefetchQueries<
 
 // This type should be treated as an opaque type.
 export type IsographEntrypoint<
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
   TClientFieldValue,
 > = {
   readonly kind: 'Entrypoint';
@@ -30,7 +30,7 @@ export type IsographEntrypoint<
 };
 
 export type IsographEntrypointLoader<
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
   TClientFieldValue,
 > = {
   readonly kind: 'EntrypointLoader';
@@ -79,7 +79,7 @@ export type RefetchQueryNormalizationArtifactWrapper = {
 };
 
 export function assertIsEntrypoint<
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
   TClientFieldValue,
 >(
   value:

package/src/core/read.ts

@@ -29,7 +29,9 @@ export type WithEncounteredRecords<T> = {
   readonly item: T;
 };
 
-export function readButDoNotEvaluate<TReadFromStore extends Object>(
+export function readButDoNotEvaluate<
+  TReadFromStore extends { parameters: object; data: object },
+>(
   environment: IsographEnvironment,
   fragmentReference: FragmentReference<TReadFromStore, unknown>,
   networkRequestOptions: NetworkRequestReaderOptions,

package/src/core/reader.ts

@@ -14,7 +14,7 @@ import {
 import { Arguments } from './util';
 
 export type TopLevelReaderArtifact<
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
   TClientFieldValue,
   TComponentProps extends Record<string, never>,
   TVariables = Variables,
@@ -23,7 +23,7 @@ export type TopLevelReaderArtifact<
   | ComponentReaderArtifact<TReadFromStore, TComponentProps, TVariables>;
 
 export type EagerReaderArtifact<
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
   TClientFieldValue,
   TVariables = Variables,
 > = {
@@ -35,7 +35,7 @@ export type EagerReaderArtifact<
 };
 
 export type ComponentReaderArtifact<
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
   TComponentProps extends Record<string, unknown> = Record<string, never>,
   TVariables = Variables,
 > = {
@@ -49,7 +49,7 @@ export type ComponentReaderArtifact<
 };
 
 export type ResolverFirstParameter<
-  TReadFromStore extends Object,
+  TReadFromStore extends object,
   TVariables = Variables,
 > = {
   readonly data: TReadFromStore;

package/src/loadable-hooks/useClientSideDefer.ts

@@ -6,17 +6,17 @@ import { LoadableField } from '../core/reader';
 
 export function useClientSideDefer<TResult>(
   loadableField: LoadableField<void, TResult>,
-): { fragmentReference: FragmentReference<Record<string, never>, TResult> };
+): { fragmentReference: FragmentReference<any, TResult> };
 
-export function useClientSideDefer<TArgs extends Object, TResult>(
+export function useClientSideDefer<TArgs extends object, TResult>(
   loadableField: LoadableField<TArgs, TResult>,
   args: TArgs,
-): { fragmentReference: FragmentReference<TArgs, TResult> };
+): { fragmentReference: FragmentReference<any, TResult> };
 
-export function useClientSideDefer<TArgs extends Object, TResult>(
+export function useClientSideDefer<TArgs extends object, TResult>(
   loadableField: LoadableField<TArgs, TResult>,
   args?: TArgs,
-): { fragmentReference: FragmentReference<TArgs, TResult> } {
+): { fragmentReference: FragmentReference<any, TResult> } {
   // @ts-expect-error args is missing iff it has the type void
   const [id, loader] = loadableField(args);
   const environment = useIsographEnvironment();

package/src/loadable-hooks/useSkipLimitPagination.ts

@@ -36,17 +36,17 @@ type UseSkipLimitReturnValue<TArgs, TItem> =
     };
 
 type ArrayFragmentReference<
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
   TItem,
 > = FragmentReference<TReadFromStore, ReadonlyArray<TItem>>;
 
 type LoadedFragmentReferences<
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
   TItem,
 > = ReadonlyArray<LoadedFragmentReference<TReadFromStore, TItem>>;
 
 type LoadedFragmentReference<
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
   TItem,
 > = ItemCleanupPair<
   ReferenceCountedPointer<ArrayFragmentReference<TReadFromStore, TItem>>
@@ -68,7 +68,7 @@ export function useSkipLimitPagination<
     limit: number | void | null;
   },
   TItem,
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
 >(
   loadableField: LoadableField<TArgs, ReadonlyArray<TItem>>,
 ): UseSkipLimitReturnValue<TArgs, TItem> {

package/src/react/useImperativeReference.ts

@@ -12,7 +12,7 @@ import { wrapResolvedValue } from '../core/PromiseWrapper';
 // TODO rename this to useImperativelyLoadedEntrypoint
 
 export function useImperativeReference<
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
   TClientFieldValue,
 >(
   entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>,

package/src/react/useLazyReference.ts

@@ -5,7 +5,7 @@ import { getOrCreateCacheForArtifact } from '../core/cache';
 import { useLazyDisposableState } from '@isograph/react-disposable-state';
 
 export function useLazyReference<
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
   TClientFieldValue,
 >(
   entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>,

package/src/react/useReadAndSubscribe.ts

@@ -16,7 +16,9 @@ import type { ReaderAst } from '../core/reader';
 /**
  * Read the data from a fragment reference and subscribe to updates.
  */
-export function useReadAndSubscribe<TReadFromStore extends Object>(
+export function useReadAndSubscribe<
+  TReadFromStore extends { parameters: object; data: object },
+>(
   fragmentReference: FragmentReference<TReadFromStore, any>,
   networkRequestOptions: NetworkRequestReaderOptions,
   readerAst: ReaderAst<TReadFromStore>,
@@ -34,7 +36,9 @@ export function useReadAndSubscribe<TReadFromStore extends Object>(
   return readOutDataAndRecords.item;
 }
 
-export function useSubscribeToMultiple<TReadFromStore extends Object>(
+export function useSubscribeToMultiple<
+  TReadFromStore extends { parameters: object; data: object },
+>(
   items: ReadonlyArray<{
     records: WithEncounteredRecords<TReadFromStore>;
     callback: (updatedRecords: WithEncounteredRecords<TReadFromStore>) => void;

package/src/react/useRerenderOnChange.ts

@@ -7,7 +7,9 @@ import type { ReaderAst } from '../core/reader';
 
 // TODO add unit tests for this. Add integration tests that test
 // behavior when the encounteredRecords underneath a fragment change.
-export function useRerenderOnChange<TReadFromStore extends Object>(
+export function useRerenderOnChange<
+  TReadFromStore extends { parameters: object; data: object },
+>(
   encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>,
   fragmentReference: FragmentReference<any, any>,
   setEncounteredDataAndRecords: (

package/src/react/useResult.ts

@@ -12,7 +12,10 @@ import {
   readPromise,
 } from '../core/PromiseWrapper';
 
-export function useResult<TReadFromStore extends Object, TClientFieldValue>(
+export function useResult<
+  TReadFromStore extends { parameters: object; data: object },
+  TClientFieldValue,
+>(
   fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>,
   partialNetworkRequestOptions?: Partial<NetworkRequestReaderOptions> | void,
 ): TClientFieldValue {

package/src/tests/__isograph/iso.ts

@@ -10,7 +10,7 @@ import entrypoint_Query__nodeField from '../__isograph/Query/nodeField/entrypoin
 // This means that the type of the exported iso literal is exactly
 // the type of the passed-in function, which takes one parameter
 // of type TParam.
-type IdentityWithParam<TParam extends Object> = <TClientFieldReturn, TVariables = Variables>(
+type IdentityWithParam<TParam extends object> = <TClientFieldReturn, TVariables = Variables>(
   clientField: (param: TParam) => TClientFieldReturn
 ) => (param: ResolverFirstParameter<TParam, TVariables>) => TClientFieldReturn;
 
@@ -21,7 +21,7 @@ type IdentityWithParam<TParam extends Object> = <TClientFieldReturn, TVariables
 //
 // TComponentProps becomes the types of the props you must pass
 // whenever the @component field is rendered.
-type IdentityWithParamComponent<TParam extends Object> = <
+type IdentityWithParamComponent<TParam extends object> = <
   TClientFieldReturn,
   TComponentProps = Record<string, never>,
   TVariables = Variables