react-relay 0.0.0-main-ff9b2fed → 0.0.0-main-dc0b087a

package/ReactRelayContext.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-ff9b2fed
+ * Relay v0.0.0-main-dc0b087a
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/ReactRelayTypes.d.ts

@@ -0,0 +1,377 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import * as React from 'react';
+import {
+  _FragmentRefs,
+  _RefType,
+  CacheConfig,
+  ConcreteRequest,
+  Disposable,
+  DisposeFn,
+  Environment,
+  FetchPolicy,
+  FragmentType,
+  GraphQLResponse,
+  IEnvironment,
+  Observable,
+  Observer,
+  OperationType,
+  PreloadableConcreteRequest,
+  RenderPolicy,
+  Variables,
+  VariablesOf,
+} from 'relay-runtime';
+
+export { FragmentRef } from 'relay-runtime';
+export { VariablesOf } from 'relay-runtime';
+
+// --- Legacy container types ---
+
+export interface RelayProp {
+    environment: Environment;
+    refetch: undefined; // ensures no RelayRefetchProp is used with a fragment container
+    hasMore: undefined; // ensures no RelayPaginationProp is used with a fragment container
+}
+
+export interface RelayRefetchProp {
+    environment: Environment;
+    refetch: (
+        refetchVariables: Variables | ((fragmentVariables: Variables) => Variables),
+        renderVariables?: Variables | null,
+        observerOrCallback?: ObserverOrCallback | null,
+        options?: RefetchOptions,
+    ) => Disposable;
+    hasMore: undefined; // ensures no RelayPaginationProp is used with a refetch container
+}
+export interface RefetchOptions {
+    force?: boolean | undefined;
+    fetchPolicy?: 'store-or-network' | 'network-only' | undefined;
+}
+
+type ObserverOrCallback = Observer<void> | ((error: Error | null | undefined) => void);
+
+export interface RelayPaginationProp {
+    readonly environment: Environment;
+    readonly hasMore: () => boolean;
+    readonly isLoading: () => boolean;
+    readonly loadMore: (
+        pageSize: number,
+        observerOrCallback?: ObserverOrCallback | null,
+        options?: RefetchOptions | null,
+    ) => Disposable | null | undefined;
+    readonly refetchConnection: (
+        totalCount: number,
+        observerOrCallback?: ObserverOrCallback | null,
+        refetchVariables?: Variables | null,
+    ) => Disposable | null | undefined;
+    refetch: undefined; // ensures no RelayRefetchProp is used with a pagination container
+}
+
+export type FragmentOrRegularProp<T> = T extends _RefType<infer U> ? _FragmentRefs<U>
+    : T extends ReadonlyArray<_RefType<infer U>> ? ReadonlyArray<_FragmentRefs<U>>
+    : T;
+
+export type MappedFragmentProps<T> = {
+    [K in keyof T]: FragmentOrRegularProp<T[K]>;
+};
+
+// --- Fragment key types (from helpers) ---
+
+export type KeyType<TData = unknown> = Readonly<{
+    ' $data'?: TData | undefined;
+    ' $fragmentSpreads': FragmentType;
+}>;
+
+export type KeyTypeData<TKey extends KeyType<TData>, TData = unknown> = Required<TKey>[' $data'];
+
+export type ArrayKeyType<TData = unknown> = ReadonlyArray<KeyType<readonly TData[]> | null | undefined>;
+export type ArrayKeyTypeData<TKey extends ArrayKeyType<TData>, TData = unknown> = KeyTypeData<
+    NonNullable<TKey[number]>
+>;
+
+export type GetEntryPointParamsFromEntryPoint<TEntryPoint> = TEntryPoint extends EntryPoint<
+    infer _TEntryPointComponent,
+    infer TEntryPointParams
+> ? TEntryPointParams
+    : never;
+
+export type GetEntryPointComponentFromEntryPoint<TEntryPoint> = TEntryPoint extends EntryPoint<
+    infer TEntryPointComponent,
+    infer _TEntryPointParams
+> ? TEntryPointComponent
+    : never;
+
+// --- EntryPoint types ---
+
+export interface JSResourceReference<TModule> {
+    getModuleId(): string;
+
+    getModuleIfRequired(): TModule | null;
+
+    load(): Promise<TModule>;
+}
+
+export type PreloadFetchPolicy = 'store-or-network' | 'store-and-network' | 'network-only';
+
+export type PreloadOptions = Readonly<{
+    fetchKey?: string | number | undefined;
+    fetchPolicy?: PreloadFetchPolicy | null | undefined;
+    networkCacheConfig?: CacheConfig | null | undefined;
+}>;
+
+export type LoadQueryOptions = Readonly<{
+    fetchPolicy?: FetchPolicy | null | undefined;
+    networkCacheConfig?: CacheConfig | null | undefined;
+    onQueryAstLoadTimeout?: (() => void) | null | undefined;
+}>;
+
+export type EnvironmentProviderOptions<T extends Record<string, unknown> = Record<string, unknown>> = T;
+
+export type PreloadedQuery<
+    TQuery extends OperationType,
+    TEnvironmentProviderOptions = EnvironmentProviderOptions,
+> = Readonly<{
+    kind: 'PreloadedQuery';
+    environment: IEnvironment;
+    environmentProviderOptions?: TEnvironmentProviderOptions | null | undefined;
+    fetchKey: string | number;
+    fetchPolicy: PreloadFetchPolicy;
+    networkCacheConfig?: CacheConfig | null | undefined;
+    id?: string | null | undefined;
+    name: string;
+    source?: Observable<GraphQLResponse> | null | undefined;
+    variables: VariablesOf<TQuery>;
+    dispose: DisposeFn;
+    isDisposed: boolean;
+}>;
+
+export type PreloadQueryStatus = Readonly<{
+    cacheConfig?: CacheConfig | null | undefined;
+    source: 'cache' | 'network';
+    fetchTime?: number | null | undefined;
+}>;
+
+/**
+ * The Interface of the EntryPoints .entrypoint files
+ *
+ * Every .entrypoint file it's an object that must have two required fields:
+ * - getPreloadProps(...)  function that will return the description of preloaded
+ *   queries and preloaded (nested) entry points for the current entry point
+ * - root - JSResource of the module that will render those preloaded queries
+ *
+ * TEntryPointParams - object that contains all necessary information to execute
+ * the preloaders (routeParams, query variables)
+ *
+ * TPreloadedQueries -  queries, defined in the root components
+ *
+ * TNestedEntryPoints - nested entry points, defined in the root components
+ *
+ * TRuntimeProps - the type of additional props that you may pass to the
+ * component (like `onClick` handler, etc) during runtime. Values for them
+ * defined during component runtime
+ *
+ * TExtraProps - a bag of extra props that you may define in `entrypoint` file
+ * and they will be passed to the EntryPointComponent as `extraProps`
+ */
+type InternalEntryPointRepresentation<
+    TEntryPointParams extends Record<string, unknown>,
+    TPreloadedQueries extends Record<string, OperationType>,
+    TNestedEntryPoints extends Record<string, unknown>,
+    TRuntimeProps extends Record<string, unknown>,
+    TExtraProps extends Record<string, unknown> | null,
+> = Readonly<{
+    root: JSResourceReference<
+        EntryPointComponent<TPreloadedQueries, TNestedEntryPoints, TRuntimeProps, TExtraProps>
+    >;
+    getPreloadProps: (
+        entryPointParams: TEntryPointParams,
+    ) => PreloadProps<TEntryPointParams, TPreloadedQueries, TNestedEntryPoints, TExtraProps>;
+}>;
+
+type ThinQueryParamsObject<TPreloadedQueries extends Record<string, OperationType> = Record<string, never>> = {
+    [K in keyof TPreloadedQueries]: ThinQueryParams<TPreloadedQueries[K]>;
+};
+
+type ThinNestedEntryPointParamsObject<
+    TEntryPoints extends Record<string, EntryPoint<any, any> | undefined> = Record<string, never>,
+> = {
+    [K in keyof TEntryPoints]: ThinNestedEntryPointParams<TEntryPoints[K]>;
+};
+
+type PreloadedQueries<TPreloadedQueries> = TPreloadedQueries extends Record<string, OperationType> ? {
+        [T in keyof TPreloadedQueries]: PreloadedQuery<TPreloadedQueries[T]>;
+    }
+    : never;
+
+type PreloadedEntryPoints<TEntryPoints> = TEntryPoints extends Record<
+    string,
+    InternalEntryPointRepresentation<any, any, any, any, any> | undefined
+> ? {
+        [T in keyof TEntryPoints]: PreloadedEntryPoint<
+            GetEntryPointComponentFromEntryPoint<TEntryPoints[T]>
+        >;
+    }
+    : never;
+
+export type PreloadProps<
+    _TPreloadParams extends Record<string, unknown>,
+    TPreloadedQueries extends Record<string, OperationType>,
+    TNestedEntryPoints extends Record<string, EntryPoint<any, any> | undefined>,
+    TExtraProps extends Record<string, unknown> | null,
+> = Readonly<{
+    entryPoints?: ThinNestedEntryPointParamsObject<TNestedEntryPoints> | undefined;
+    extraProps?: TExtraProps | undefined;
+    queries?: ThinQueryParamsObject<TPreloadedQueries> | undefined;
+}>;
+
+export type EntryPointProps<TPreloadedQueries, TNestedEntryPoints, TRuntimeProps, TExtraProps> = Readonly<{
+    entryPoints: PreloadedEntryPoints<TNestedEntryPoints>;
+    extraProps: TExtraProps;
+    props: TRuntimeProps;
+    queries: PreloadedQueries<TPreloadedQueries>;
+}>;
+
+export type EntryPointComponent<
+    TPreloadedQueries extends Record<string, OperationType>,
+    TNestedEntryPoints extends Record<string, EntryPoint<any, any> | undefined>,
+    TRuntimeProps extends Record<string, unknown> = Record<string, unknown>,
+    TExtraProps extends Record<string, unknown> | null = Record<string, unknown>,
+> = React.ComponentType<EntryPointProps<TPreloadedQueries, TNestedEntryPoints, TRuntimeProps, TExtraProps>>;
+
+export type PreloadedEntryPoint<TEntryPointComponent> = TEntryPointComponent extends EntryPointComponent<
+    infer TPreloadedQueries,
+    infer TNestedEntryPoints,
+    infer _TRuntimeProps,
+    infer TExtraProps
+> ? Readonly<{
+        dispose: DisposeFn;
+        entryPoints: PreloadedEntryPoints<TNestedEntryPoints>;
+        extraProps: TExtraProps;
+        getComponent: () => TEntryPointComponent;
+        isDisposed: boolean;
+        queries: PreloadedQueries<TPreloadedQueries>;
+        rootModuleID: string;
+    }>
+    : never;
+
+export type ThinQueryParams<
+    TQuery extends OperationType,
+    TEnvironmentProviderOptions extends EnvironmentProviderOptions = EnvironmentProviderOptions,
+> = Readonly<{
+    parameters: ConcreteRequest | PreloadableConcreteRequest<TQuery>;
+    variables: VariablesOf<TQuery>;
+    options?: PreloadOptions | null | undefined;
+    environmentProviderOptions?: TEnvironmentProviderOptions | null | undefined;
+}>;
+
+export type ThinNestedEntryPointParams<TEntryPoint> = Readonly<{
+    entryPoint: TEntryPoint;
+    entryPointParams: GetEntryPointParamsFromEntryPoint<TEntryPoint>;
+}>;
+
+export type EntryPoint<TEntryPointComponent, TEntryPointParams extends Record<string, unknown> = Record<string, unknown>> = InternalEntryPointRepresentation<
+    TEntryPointParams,
+    TEntryPointComponent extends EntryPointComponent<infer TPreloadedQueries, any, any, any> ? TPreloadedQueries
+        : never,
+    TEntryPointComponent extends EntryPointComponent<any, infer TNestedEntryPoints, any, any> ? TNestedEntryPoints
+        : never,
+    TEntryPointComponent extends EntryPointComponent<any, any, infer TRuntimeProps, any> ? TRuntimeProps : never,
+    TEntryPointComponent extends EntryPointComponent<any, any, any, infer TExtraProps> ? TExtraProps : never
+>;
+
+export interface IEnvironmentProvider<TOptions> {
+    getEnvironment(options: TOptions | null): IEnvironment;
+}
+
+// --- Refetchable fragment types (from useRefetchableFragmentNode) ---
+
+export type RefetchFn<TQuery extends OperationType, TOptions = RefetchableOptions> = RefetchFnExact<TQuery, TOptions>;
+
+export type RefetchFnDynamic<
+    TQuery extends OperationType,
+    _TKey extends KeyType | null | undefined,
+    TOptions = RefetchableOptions,
+> = RefetchInexactDynamicResponse<TQuery, TOptions> & RefetchExactDynamicResponse<TQuery, TOptions>;
+
+export type RefetchInexact<TQuery extends OperationType, TOptions> = (
+    data?: unknown,
+) => RefetchFnInexact<TQuery, TOptions>;
+export type RefetchInexactDynamicResponse<TQuery extends OperationType, TOptions> = ReturnType<
+    RefetchInexact<TQuery, TOptions>
+>;
+
+export type RefetchExact<TQuery extends OperationType, TOptions> = (
+    data?: unknown | null,
+) => RefetchFnExact<TQuery, TOptions>;
+export type RefetchExactDynamicResponse<TQuery extends OperationType, TOptions> = ReturnType<
+    RefetchExact<TQuery, TOptions>
+>;
+
+export type RefetchFnBase<TVars, TOptions> = (vars: TVars, options?: TOptions) => Disposable;
+
+export type RefetchFnExact<TQuery extends OperationType, TOptions = RefetchableOptions> = RefetchFnBase<
+    VariablesOf<TQuery>,
+    TOptions
+>;
+export type RefetchFnInexact<TQuery extends OperationType, TOptions = RefetchableOptions> = RefetchFnBase<
+    Partial<VariablesOf<TQuery>>,
+    TOptions
+>;
+
+export interface ReturnTypeNode<
+    TQuery extends OperationType,
+    TKey extends KeyType | null | undefined,
+    TOptions = RefetchableOptions,
+> {
+    fragmentData: unknown;
+    fragmentRef: unknown;
+    refetch: RefetchFnDynamic<TQuery, TKey, TOptions>;
+    disableStoreUpdates: () => void;
+    enableStoreUpdates: () => void;
+}
+
+export interface RefetchableOptions {
+    fetchPolicy?: FetchPolicy | undefined;
+    onComplete?: ((arg: Error | null) => void) | undefined;
+    UNSTABLE_renderPolicy?: RenderPolicy | undefined;
+}
+
+export interface InternalRefetchableOptions extends RefetchableOptions {
+    __environment?: IEnvironment | undefined;
+}
+
+export type RefetchableAction =
+    | {
+        type: 'reset';
+        environment: IEnvironment;
+        fragmentIdentifier: string;
+    }
+    | {
+        type: 'refetch';
+        refetchVariables: Variables;
+        fetchPolicy?: FetchPolicy | undefined;
+        renderPolicy?: RenderPolicy | undefined;
+        onComplete?: ((args: Error | null) => void) | undefined;
+        environment?: IEnvironment | null | undefined;
+    };
+
+export interface RefetchState {
+    fetchPolicy?: FetchPolicy | undefined;
+    renderPolicy?: RenderPolicy | undefined;
+    mirroredEnvironment: IEnvironment;
+    mirroredFragmentIdentifier: string;
+    onComplete?: ((arg: Error | null) => void) | undefined;
+    refetchEnvironment?: IEnvironment | null | undefined;
+    refetchVariables?: Variables | null | undefined;
+    refetchGeneration: number;
+}
+
+export interface DebugIDandTypename {
+    id: string;
+    typename: string;
+}

package/hooks.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+export {
+    EntryPoint,
+    EntryPointComponent,
+    EntryPointProps,
+    EnvironmentProviderOptions,
+    IEnvironmentProvider,
+    JSResourceReference,
+    LoadQueryOptions,
+    PreloadedEntryPoint,
+    PreloadedQuery,
+    PreloadFetchPolicy,
+    PreloadOptions,
+    PreloadProps,
+    PreloadQueryStatus,
+    ThinNestedEntryPointParams,
+    ThinQueryParams,
+    VariablesOf,
+} from './ReactRelayTypes';
+
+export {
+    DataID,
+    DeclarativeMutationConfig,
+    Disposable,
+    FetchPolicy,
+    GraphQLTaggedNode,
+    // RelayRuntime has two environment exports: one interface, one concrete.
+    IEnvironment as Environment,
+    MutationType,
+    MutationTypes,
+    NormalizationSelector,
+    OperationDescriptor,
+    RangeOperation,
+    RangeOperations,
+    ReaderSelector,
+    RelayContext,
+    Snapshot,
+    Variables,
+} from 'relay-runtime';
+export { MatchContainerProps, MatchPointer } from './relay-hooks/MatchContainer';
+export { ProfilerContextType } from './relay-hooks/ProfilerContext';
+export { Direction, LoadMoreFn } from './relay-hooks/useLoadMoreFunction';
+export { UseMutationConfig } from './relay-hooks/useMutation';
+export { UseQueryLoaderLoadQueryOptions } from './relay-hooks/useQueryLoader';
+export { RefetchableOptions as RefetchOptions, RefetchFn, RefetchFnDynamic } from './ReactRelayTypes';
+
+// /**
+//  * The public interface for Relay Hooks.
+//  */
+
+export { graphql } from 'relay-runtime';
+
+export { ConnectionHandler } from 'relay-runtime';
+
+export { applyOptimisticMutation } from 'relay-runtime';
+export { commitLocalUpdate } from 'relay-runtime';
+export { commitMutation } from 'relay-runtime';
+
+export { readInlineData } from 'relay-runtime';
+export { requestSubscription } from 'relay-runtime';
+
+export { EntryPointContainer } from './relay-hooks/EntryPointContainer.react';
+export { RelayEnvironmentProvider } from './relay-hooks/RelayEnvironmentProvider';
+
+export { ProfilerContext } from './relay-hooks/ProfilerContext';
+
+export { fetchQuery } from 'relay-runtime';
+
+export { loadEntryPoint } from './relay-hooks/loadEntryPoint';
+export { loadQuery } from './relay-hooks/loadQuery';
+
+export { useClientQuery } from './relay-hooks/useClientQuery';
+export { useEntryPointLoader } from './relay-hooks/useEntryPointLoader';
+export { useFragment } from './relay-hooks/useFragment';
+export { useLazyLoadQuery } from './relay-hooks/useLazyLoadQuery';
+export { useMutation } from './relay-hooks/useMutation';
+export { usePaginationFragment } from './relay-hooks/usePaginationFragment';
+export { usePreloadedQuery } from './relay-hooks/usePreloadedQuery';
+export { useQueryLoader } from './relay-hooks/useQueryLoader';
+export { useRefetchableFragment } from './relay-hooks/useRefetchableFragment';
+export { useRelayEnvironment } from './relay-hooks/useRelayEnvironment';
+export { useSubscribeToInvalidationState } from './relay-hooks/useSubscribeToInvalidationState';
+export { useSubscription } from './relay-hooks/useSubscription';

package/hooks.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-ff9b2fed
+ * Relay v0.0.0-main-dc0b087a
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+export * from './hooks';
+export * from './legacy';

package/index.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-ff9b2fed
+ * Relay v0.0.0-main-dc0b087a
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/legacy.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {MappedFragmentProps, RelayPaginationProp, RelayProp, RelayRefetchProp} from './ReactRelayTypes';
+import * as React from 'react';
+import {
+  _FragmentRefs,
+  _RefType,
+  CacheConfig,
+  FetchPolicy,
+  GraphQLTaggedNode,
+  IEnvironment,
+  OperationType,
+  PageInfo,
+  RelayContext,
+  Variables,
+} from 'relay-runtime';
+
+export { FragmentRef, RelayPaginationProp, RelayProp, RelayRefetchProp } from './ReactRelayTypes';
+
+export {
+    DataID,
+    DeclarativeMutationConfig,
+    Disposable,
+    FetchPolicy,
+    GraphQLTaggedNode,
+    // RelayRuntime has two environment exports: one interface, one concrete.
+    IEnvironment as Environment,
+    MutationType,
+    NormalizationSelector,
+    OperationDescriptor,
+    RangeOperation,
+    ReaderSelector,
+    RelayContext,
+    Snapshot,
+    Variables,
+} from 'relay-runtime';
+
+/**
+ * Legacy react-relay exports.
+ * Should prefer using interface defined in ./hooks.js
+ */
+export { ConnectionHandler } from 'relay-runtime';
+export interface QueryRendererProps<TOperation extends OperationType> {
+    environment: IEnvironment;
+    query: GraphQLTaggedNode | null | undefined;
+    render: (renderProps: {
+        error: Error | null;
+        props: TOperation['response'] | null;
+        retry: (() => void) | null;
+    }) => React.ReactNode;
+    variables: TOperation['variables'];
+}
+declare class ReactRelayQueryRenderer<TOperation extends OperationType> extends React.Component<
+    {
+        cacheConfig?: CacheConfig | null | undefined;
+        fetchPolicy?: FetchPolicy | undefined;
+    } & QueryRendererProps<TOperation>
+> {}
+export { ReactRelayQueryRenderer as QueryRenderer };
+
+declare class ReactRelayLocalQueryRenderer<TOperation extends OperationType> extends React.Component<
+    QueryRendererProps<TOperation>
+> {}
+export { ReactRelayLocalQueryRenderer as LocalQueryRenderer };
+
+export { MutationTypes } from 'relay-runtime';
+export { RangeOperations } from 'relay-runtime';
+
+export const ReactRelayContext: React.Context<RelayContext | null>;
+
+export { applyOptimisticMutation } from 'relay-runtime';
+export { commitLocalUpdate } from 'relay-runtime';
+export { commitMutation } from 'relay-runtime';
+
+export type ContainerProps<Props> = MappedFragmentProps<Pick<Props, Exclude<keyof Props, 'relay'>>>;
+export type RelayProps<Props> = ContainerProps<Props>; // TODO: validate this
+export type Container<Props> = React.ComponentType<
+    ContainerProps<Props> & { componentRef?: ((ref: any) => void) | undefined }
+>;
+
+// TODO: validate the bellow three
+export type RelayFragmentContainer<TComponent extends React.ElementType> = React.ComponentType<
+    ContainerProps<React.ComponentPropsWithoutRef<TComponent>>
+>;
+
+export type RelayPaginationContainer<TComponent extends React.ElementType> = React.ComponentType<
+    ContainerProps<React.ComponentPropsWithoutRef<TComponent>>
+>;
+
+export type RelayRefetchContainer<TComponent extends React.ElementType> = React.ComponentType<
+    ContainerProps<React.ComponentPropsWithoutRef<TComponent>>
+>;
+
+type PropsWithoutRelay<C extends keyof React.JSX.IntrinsicElements | React.JSXElementConstructor<any>> =
+    React.JSX.LibraryManagedAttributes<C, Omit<React.ComponentProps<C>, 'relay'>>;
+
+export function createFragmentContainer<
+    C extends React.ComponentType<React.ComponentProps<C> & { relay?: RelayProp | undefined }>,
+>(Component: C, fragmentSpec: Record<string, GraphQLTaggedNode>): Container<PropsWithoutRelay<C>>;
+
+export { fetchQuery_DEPRECATED } from 'relay-runtime';
+
+export { graphql } from 'relay-runtime';
+export { readInlineData } from 'relay-runtime';
+export { requestSubscription } from 'relay-runtime';
+
+export function createPaginationContainer<
+    C extends React.ComponentType<React.ComponentProps<C> & { relay: RelayPaginationProp }>,
+>(
+    Component: C,
+    fragmentSpec: Record<string, GraphQLTaggedNode>,
+    connectionConfig: ConnectionConfig<PropsWithoutRelay<C>>,
+): Container<PropsWithoutRelay<C>>;
+
+export function createRefetchContainer<
+    C extends React.ComponentType<React.ComponentProps<C> & { relay: RelayRefetchProp }>,
+>(
+    Component: C,
+    fragmentSpec: Record<string, GraphQLTaggedNode>,
+    refetchQuery: GraphQLTaggedNode,
+): Container<PropsWithoutRelay<C>>;
+
+export interface ConnectionConfig<Props = object> {
+    direction?: 'backward' | 'forward' | undefined;
+    getConnectionFromProps?: ((props: Props) => ConnectionData | null | undefined) | undefined;
+    getFragmentVariables?: ((prevVars: Variables, totalCount: number) => Variables) | undefined;
+    getVariables: (
+        props: Props,
+        paginationInfo: { count: number; cursor?: string | null | undefined },
+        fragmentVariables: Variables,
+    ) => Variables;
+    query: GraphQLTaggedNode;
+}
+
+interface ConnectionData {
+    edges?: readonly any[] | null | undefined;
+    pageInfo?: Partial<PageInfo> | null | undefined;
+}

package/legacy.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-ff9b2fed
+ * Relay v0.0.0-main-dc0b087a
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-relay",
   "description": "A framework for building GraphQL-driven React applications.",
-  "version": "0.0.0-main-ff9b2fed",
+  "version": "0.0.0-main-dc0b087a",
   "keywords": [
     "graphql",
     "relay",
@@ -20,7 +20,7 @@
     "fbjs": "^3.0.2",
     "invariant": "^2.2.4",
     "nullthrows": "^1.1.1",
-    "relay-runtime": "0.0.0-main-ff9b2fed"
+    "relay-runtime": "0.0.0-main-dc0b087a"
   },
   "peerDependencies": {
     "react": "^16.9.0 || ^17 || ^18 || ^19"

package/relay-hooks/EntryPointContainer.react.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {EntryPointComponent, PreloadedEntryPoint} from '../ReactRelayTypes';
+import { ReactElement } from 'react';
+
+type GetComponentFromPreloadedEntryPoint<T> = T extends PreloadedEntryPoint<infer C> ? C : never;
+type GetRuntimePropsFromComponent<T> = T extends EntryPointComponent<any, any, infer R, any> ? R : never;
+
+export function EntryPointContainer<TPreloadedEntryPoint extends PreloadedEntryPoint<any>>({
+    entryPointReference,
+    props,
+}: Readonly<{
+    entryPointReference: TPreloadedEntryPoint;
+    props: GetRuntimePropsFromComponent<GetComponentFromPreloadedEntryPoint<TPreloadedEntryPoint>>;
+}>): ReactElement;
+
+export {};

package/relay-hooks/MatchContainer.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {ComponentType, ElementType, ReactNode} from 'react';
+
+/**
+ * Renders the results of a data-driven dependency fetched with the `@match`
+ * directive. The `@match` directive can be used to specify a mapping of
+ * result types to the containers used to render those types. The result
+ * value is an opaque object that described which component was selected
+ * and a reference to its data. Use <MatchContainer/> to render these
+ * values.
+ *
+ * ## Example
+ *
+ * For example, consider a piece of media content that might be text or
+ * an image, where for clients that don't support images the application
+ * should fall back to rendering the image caption as text. @match can be
+ * used to dynamically select whether to render a given media item as
+ * an image or text (on the server) and then fetch the corresponding
+ * React component and its data dependencies (information about the
+ * image or about the text).
+ *
+ * ```
+ * // Media.react.js
+ *
+ * // Define a React component that uses <MatchContainer /> to render the
+ * // results of a @module selection
+ * function Media(props) {
+ *   const {media, ...restProps} = props;
+ *
+ *   const loader = moduleReference => {
+ *      // given the data returned by your server for the @module directive,
+ *      // return the React component (or throw a Suspense promise if
+ *      // it is loading asynchronously).
+ *      todo_returnModuleOrThrowPromise(moduleReference);
+ *   };
+ *   return <MatchContainer
+ *     loader={loader}
+ *     match={media.mediaAttachment}
+ *     props={restProps}
+ *   />;
+ * }
+ *
+ * module.exports = createSuspenseFragmentContainer(
+ *   Media,
+ *   {
+ *     media: graphql`
+ *       fragment Media_media on Media {
+ *         # ...
+ *         mediaAttachment @match {
+ *            ...ImageContainer_image @module(name: "ImageContainer.react")
+ *            ...TextContainer_text @module(name: "TextContainer.react")
+ *         }
+ *       }
+ *     `
+ *   },
+ * );
+ * ```
+ *
+ * ## API
+ *
+ * MatchContainer accepts the following props:
+ * - `match`: The results (an opaque object) of a `@match` field.
+ * - `props`: Props that should be passed through to the dynamically
+ *   selected component. Note that any of the components listed in
+ *   `@module()` could be selected, so all components should accept
+ *   the value passed here.
+ * - `loader`: A function to load a module given a reference (whatever
+ *   your server returns for the `js(moduleName: String)` field).
+ */
+
+type TypenameOnlyPointer = Readonly<{ __typename: string }>;
+export type MatchPointer = Readonly<{
+    __fragmentPropName?: string | null | undefined;
+    __module_component?: unknown | undefined;
+    ' $fragmentSpreads': unknown;
+}>;
+
+export type MatchContainerProps<TProps = Record<string, unknown>, TFallback = ReactNode> = Readonly<{
+    fallback?: TFallback | null | undefined;
+    loader: (module: unknown) => ComponentType<TProps>;
+    match?: MatchPointer | TypenameOnlyPointer | null | undefined;
+    props?: TProps | undefined;
+}>;
+
+export function MatchContainer<TProps = Record<string, unknown>, TFallback = ReactNode>(
+    props: MatchContainerProps<TProps, TFallback>,
+): ElementType<TProps> | TFallback | null;
+
+export {};

package/relay-hooks/ProfilerContext.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// This contextual profiler can be used to wrap a react sub-tree. It will bind
+// the RelayProfiler during the render phase of these components. Allows
+// collecting metrics for a specific part of your application.
+
+import { Context } from 'react';
+
+export interface ProfilerContextType {
+    wrapPrepareQueryResource: <T>(cb: () => T) => T;
+}
+
+export const ProfilerContext: Context<ProfilerContextType>;

package/relay-hooks/RelayEnvironmentProvider.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {ProviderProps, ReactElement, ReactNode} from 'react';
+import {IEnvironment, RelayContext} from 'relay-runtime';
+
+export interface Props {
+    children: ReactNode;
+    environment: IEnvironment;
+}
+
+export function RelayEnvironmentProvider(props: Props): ReactElement<ProviderProps<RelayContext>>;

package/relay-hooks/loadEntryPoint.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {EnvironmentProviderOptions, GetEntryPointComponentFromEntryPoint, GetEntryPointParamsFromEntryPoint, IEnvironmentProvider, PreloadedEntryPoint} from '../ReactRelayTypes';
+
+export function loadEntryPoint<TEntryPoint>(
+    environmentProvider: IEnvironmentProvider<EnvironmentProviderOptions>,
+    entryPoint: TEntryPoint,
+    entryPointParams: GetEntryPointParamsFromEntryPoint<TEntryPoint>,
+): PreloadedEntryPoint<GetEntryPointComponentFromEntryPoint<TEntryPoint>>;

package/relay-hooks/loadQuery.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {EnvironmentProviderOptions, LoadQueryOptions, PreloadedQuery} from '../ReactRelayTypes';
+import {GraphQLTaggedNode, IEnvironment, OperationType, PreloadableConcreteRequest, VariablesOf} from 'relay-runtime';
+
+export function loadQuery<
+    TQuery extends OperationType,
+    TEnvironmentProviderOptions extends EnvironmentProviderOptions = Record<string, unknown>,
+>(
+    environment: IEnvironment,
+    preloadableRequest: GraphQLTaggedNode | PreloadableConcreteRequest<TQuery>,
+    variables: VariablesOf<TQuery>,
+    options?: LoadQueryOptions,
+    environmentProviderOptions?: TEnvironmentProviderOptions,
+): PreloadedQuery<TQuery, TEnvironmentProviderOptions>;

package/relay-hooks/useClientQuery.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {GraphQLTaggedNode, OperationType, RenderPolicy, VariablesOf} from 'relay-runtime';
+
+export function useClientQuery<TQuery extends OperationType>(
+    gqlQuery: GraphQLTaggedNode,
+    variables: VariablesOf<TQuery>,
+    options?: {
+        UNSTABLE_renderPolicy?: RenderPolicy | undefined;
+    },
+): TQuery['response'];

package/relay-hooks/useEntryPointLoader.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {EnvironmentProviderOptions, GetEntryPointComponentFromEntryPoint, GetEntryPointParamsFromEntryPoint, IEnvironmentProvider, PreloadedEntryPoint} from '../ReactRelayTypes';
+import { DisposeFn } from 'relay-runtime';
+
+export type UseEntryPointLoaderHookType<TEntryPoint> = [
+    PreloadedEntryPoint<GetEntryPointComponentFromEntryPoint<TEntryPoint>> | null | undefined,
+    (entryPointParams: GetEntryPointParamsFromEntryPoint<TEntryPoint>) => void,
+    DisposeFn,
+];
+
+export function useEntryPointLoader<TEntryPoint>(
+    environmentProvider: IEnvironmentProvider<EnvironmentProviderOptions>,
+    entryPoint: TEntryPoint,
+    // Have opted to not include the TEST_ONLY__initialEntryPointData object here—as is FB internal
+): UseEntryPointLoaderHookType<TEntryPoint>;

package/relay-hooks/useFragment.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {ArrayKeyType, ArrayKeyTypeData, KeyType, KeyTypeData} from '../ReactRelayTypes';
+import { GraphQLTaggedNode } from 'relay-runtime';
+
+// NOTE: These declares ensure that the type of the returned data is:
+//   - non-nullable if the provided ref type is non-nullable
+//   - nullable if the provided ref type is nullable
+//   - array of non-nullable if the provided ref type is an array of
+//     non-nullable refs
+//   - array of nullable if the provided ref type is an array of nullable refs
+
+export function useFragment<TKey extends KeyType>(
+    fragmentInput: GraphQLTaggedNode,
+    fragmentRef: TKey,
+): KeyTypeData<TKey>;
+
+export function useFragment<TKey extends KeyType>(
+    fragmentInput: GraphQLTaggedNode,
+    fragmentRef: TKey | null | undefined,
+): KeyTypeData<TKey> | null | undefined;
+
+export function useFragment<TKey extends ArrayKeyType>(
+    fragmentInput: GraphQLTaggedNode,
+    fragmentRef: TKey,
+): ArrayKeyTypeData<TKey>;
+
+export function useFragment<TKey extends ArrayKeyType>(
+    fragmentInput: GraphQLTaggedNode,
+    fragmentRef: TKey | null | undefined,
+): ArrayKeyTypeData<TKey> | null | undefined;

package/relay-hooks/useLazyLoadQuery.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {CacheConfig, FetchPolicy, GraphQLTaggedNode, OperationType, RenderPolicy, VariablesOf} from 'relay-runtime';
+
+export function useLazyLoadQuery<TQuery extends OperationType>(
+    gqlQuery: GraphQLTaggedNode,
+    variables: VariablesOf<TQuery>,
+    options?: {
+        fetchKey?: string | number | undefined;
+        fetchPolicy?: FetchPolicy | undefined;
+        networkCacheConfig?: CacheConfig | undefined;
+        UNSTABLE_renderPolicy?: RenderPolicy | undefined;
+    },
+): TQuery['response'];

package/relay-hooks/useLoadMoreFunction.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {
+  ConcreteRequest,
+  Disposable,
+  DisposeFn,
+  GraphQLResponse,
+  Observer,
+  OperationType,
+  ReaderFragment,
+  ReaderPaginationMetadata,
+  VariablesOf,
+} from 'relay-runtime';
+
+export type Direction = 'forward' | 'backward';
+
+export type LoadMoreFn<TQuery extends OperationType> = (
+    count: number,
+    options?: {
+        onComplete?: ((arg: Error | null) => void) | undefined;
+        UNSTABLE_extraVariables?: Partial<VariablesOf<TQuery>> | undefined;
+    },
+) => Disposable;
+
+export interface UseLoadMoreFunctionArgs {
+    direction: Direction;
+    fragmentNode: ReaderFragment;
+    fragmentRef: unknown;
+    fragmentIdentifier: string;
+    fragmentData: unknown;
+    connectionPathInFragmentData: ReadonlyArray<string | number>;
+    identifierField?: string | null | undefined;
+    paginationRequest: ConcreteRequest;
+    paginationMetadata: ReaderPaginationMetadata;
+    componentDisplayName: string;
+    observer: Observer<GraphQLResponse>;
+    onReset: () => void;
+}
+export function useLoadMoreFunction<TQuery extends OperationType>(
+    args: UseLoadMoreFunctionArgs,
+): [LoadMoreFn<TQuery>, boolean, DisposeFn];
+
+export function getConnectionState(
+    direction: Direction,
+    fragmentNode: ReaderFragment,
+    fragmentData: unknown,
+    connectionPathInFragmentData: ReadonlyArray<string | number>,
+): {
+    cursor?: string | null | undefined;
+    hasMore: boolean;
+};

package/relay-hooks/useMutation.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {
+  DeclarativeMutationConfig,
+  Disposable,
+  GraphQLTaggedNode,
+  IEnvironment,
+  MutationConfig,
+  MutationParameters,
+  PayloadError,
+  SelectorStoreUpdater,
+  UploadableMap,
+  VariablesOf,
+} from 'relay-runtime';
+
+export interface UseMutationConfig<TMutation extends MutationParameters> {
+    variables: VariablesOf<TMutation>;
+    updater?: SelectorStoreUpdater<TMutation['response']> | null | undefined;
+    uploadables?: UploadableMap | undefined;
+    optimisticUpdater?: SelectorStoreUpdater<TMutation['response']> | null | undefined;
+    optimisticResponse?: TMutation['rawResponse'] | undefined;
+    configs?: DeclarativeMutationConfig[] | undefined;
+    onError?: ((error: Error) => void | null) | undefined;
+    onCompleted?: ((response: TMutation['response'], errors: PayloadError[] | null) => void | null) | undefined;
+    onUnsubscribe?: (() => void | null) | undefined;
+}
+
+export function useMutation<TMutation extends MutationParameters>(
+    mutation: GraphQLTaggedNode,
+    commitMutationFn?: (environment: IEnvironment, config: MutationConfig<TMutation>) => Disposable,
+): [(config: UseMutationConfig<TMutation>) => Disposable, boolean];

package/relay-hooks/usePaginationFragment.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {KeyType, KeyTypeData, RefetchFnDynamic} from '../ReactRelayTypes';
+import { LoadMoreFn } from './useLoadMoreFunction';
+import {GraphQLTaggedNode, OperationType} from 'relay-runtime';
+
+export interface usePaginationFragmentHookType<
+    TQuery extends OperationType,
+    TKey extends KeyType | null | undefined,
+    TFragmentData,
+> {
+    data: TFragmentData;
+    loadNext: LoadMoreFn<TQuery>;
+    loadPrevious: LoadMoreFn<TQuery>;
+    hasNext: boolean;
+    hasPrevious: boolean;
+    isLoadingNext: boolean;
+    isLoadingPrevious: boolean;
+    refetch: RefetchFnDynamic<TQuery, TKey>;
+}
+export function usePaginationFragment<TQuery extends OperationType, TKey extends KeyType>(
+    fragmentInput: GraphQLTaggedNode,
+    parentFragmentRef: TKey,
+): usePaginationFragmentHookType<TQuery, TKey, KeyTypeData<TKey>>;
+export function usePaginationFragment<TQuery extends OperationType, TKey extends KeyType>(
+    fragmentInput: GraphQLTaggedNode,
+    parentFragmentRef: TKey | null | undefined,
+): usePaginationFragmentHookType<TQuery, TKey | null, KeyTypeData<TKey> | null | undefined>;

package/relay-hooks/usePreloadedQuery.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { PreloadedQuery } from '../ReactRelayTypes';
+import {GraphQLTaggedNode, OperationType, RenderPolicy} from 'relay-runtime';
+
+export function usePreloadedQuery<TQuery extends OperationType>(
+    gqlQuery: GraphQLTaggedNode,
+    preloadedQuery: PreloadedQuery<TQuery>,
+    options?: {
+        UNSTABLE_renderPolicy?: RenderPolicy | undefined;
+    },
+): TQuery['response'];

package/relay-hooks/useQueryLoader.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {LoadQueryOptions, PreloadedQuery} from '../ReactRelayTypes';
+import {
+  DisposeFn,
+  GraphQLTaggedNode,
+  IEnvironment,
+  OperationType,
+  PreloadableConcreteRequest,
+  VariablesOf,
+} from 'relay-runtime';
+
+export type useQueryLoaderHookType<TQuery extends OperationType> = [
+    PreloadedQuery<TQuery> | null | undefined,
+    (variables: VariablesOf<TQuery>, options?: UseQueryLoaderLoadQueryOptions) => void,
+    DisposeFn,
+];
+
+export type UseQueryLoaderLoadQueryOptions =
+    & LoadQueryOptions
+    & Readonly<{
+        __environment?: IEnvironment | null | undefined;
+    }>;
+
+export function useQueryLoader<TQuery extends OperationType>(
+    preloadableRequest: GraphQLTaggedNode | PreloadableConcreteRequest<TQuery>,
+    initialQueryReference?: PreloadedQuery<TQuery> | null,
+): useQueryLoaderHookType<TQuery>;

package/relay-hooks/useRefetchableFragment.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {KeyType, KeyTypeData, RefetchFnDynamic} from '../ReactRelayTypes';
+import {GraphQLTaggedNode, OperationType} from 'relay-runtime';
+
+export type useRefetchableFragmentHookType<
+    TQuery extends OperationType,
+    TKey extends KeyType | null | undefined,
+    TFragmentData,
+> = [TFragmentData, RefetchFnDynamic<TQuery, TKey>];
+export function useRefetchableFragment<TQuery extends OperationType, TKey extends KeyType>(
+    fragmentInput: GraphQLTaggedNode,
+    fragmentRef: TKey,
+): useRefetchableFragmentHookType<TQuery, TKey, KeyTypeData<TKey>>;
+export function useRefetchableFragment<TQuery extends OperationType, TKey extends KeyType>(
+    fragmentInput: GraphQLTaggedNode,
+    fragmentRef: TKey | null | undefined,
+): useRefetchableFragmentHookType<TQuery, TKey, KeyTypeData<TKey> | null | undefined>;

package/relay-hooks/useRelayEnvironment.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { Environment } from 'relay-runtime';
+
+export function useRelayEnvironment(): Environment;

package/relay-hooks/useSubscribeToInvalidationState.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {DataID, Disposable} from 'relay-runtime';
+
+/**
+ * This hook subscribes a callback to the invalidation state of the given data
+ * ids.
+ * Any time the invalidation state of the given data ids changes, the provided
+ * callback will be called.
+ * If new ids or a new callback are provided, the subscription will be
+ * re-established and the previous one will be disposed.
+ * The subscription will automatically be disposed on unmount
+ */
+export function useSubscribeToInvalidationState(dataIDs: readonly DataID[], callback: () => void): Disposable;

package/relay-hooks/useSubscription.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {GraphQLSubscriptionConfig, OperationType, requestSubscription} from 'relay-runtime';
+
+export function useSubscription<TSubscriptionPayload extends OperationType>(
+    // The actual subtype of OperationType is required to allow for type inference inside GraphQLSubscriptionConfig.s
+    config: GraphQLSubscriptionConfig<TSubscriptionPayload>,
+    requestSubscriptionFn?: typeof requestSubscription,
+): void;

package/rsc-client_EXPERIMENTAL.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { PreloadedQueryRef } from './rsc_EXPERIMENTAL';
+import {GraphQLTaggedNode, OperationType} from 'relay-runtime';
+
+export function useQueryFromServer<T extends OperationType>(
+    query: GraphQLTaggedNode,
+    queryRef: PreloadedQueryRef<T['variables'], T['response']>,
+    options?: { staleThresholdMs?: number },
+): T['response'];
+
+export { PreloadedQueryRef };

package/rsc-client_EXPERIMENTAL.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-ff9b2fed
+ * Relay v0.0.0-main-dc0b087a
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/rsc_EXPERIMENTAL.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {ArrayKeyType, ArrayKeyTypeData, KeyType, KeyTypeData} from './ReactRelayTypes';
+import {GraphQLTaggedNode, IEnvironment, OperationType} from 'relay-runtime';
+
+export interface PreloadedQueryResponse<TData> {
+    readonly data: TData;
+    readonly errors?: ReadonlyArray<{ readonly message: string }>;
+}
+
+export interface PreloadedQueryRef<TVariables, TData> {
+    readonly kind: 'PreloadedQueryRef';
+    readonly queryId: string;
+    readonly variables: TVariables;
+    readonly _response: Promise<PreloadedQueryResponse<TData>>;
+    readonly fetchedAt: number;
+}
+
+export interface ServerEnvironment {
+    readonly getEnvironment: () => IEnvironment;
+    readonly serverFetchQuery: <T extends OperationType>(
+        query: GraphQLTaggedNode,
+        variables: T['variables'],
+    ) => Promise<T['response']>;
+    readonly serverPreloadQuery: <T extends OperationType>(
+        query: GraphQLTaggedNode,
+        variables: T['variables'],
+    ) => PreloadedQueryRef<T['variables'], T['response']>;
+    readonly serverReadFragment: {
+        <TKey extends KeyType>(
+            fragment: GraphQLTaggedNode,
+            fragmentRef: TKey,
+        ): Promise<KeyTypeData<TKey>>;
+        <TKey extends ArrayKeyType>(
+            fragment: GraphQLTaggedNode,
+            fragmentRef: TKey,
+        ): Promise<ArrayKeyTypeData<TKey>>;
+    };
+}
+
+export function createServerEnvironment(
+    create: () => IEnvironment,
+): ServerEnvironment;

package/rsc_EXPERIMENTAL.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-ff9b2fed
+ * Relay v0.0.0-main-dc0b087a
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *