diff --git a/.changeset/gentle-kiwis-promise.md b/.changeset/gentle-kiwis-promise.md
new file mode 100644
index 00000000000..dfe650df934
--- /dev/null
+++ b/.changeset/gentle-kiwis-promise.md
@@ -0,0 +1,5 @@
+---
+'@rest-hooks/react': minor
+---
+
+useController().fetch resolves to denormalized form
diff --git a/.changeset/good-spoons-look.md b/.changeset/good-spoons-look.md
new file mode 100644
index 00000000000..9d2e4c59cd7
--- /dev/null
+++ b/.changeset/good-spoons-look.md
@@ -0,0 +1,5 @@
+---
+'@rest-hooks/rest': patch
+---
+
+Add commonjs export for /next
diff --git a/.changeset/perfect-grapes-glow.md b/.changeset/perfect-grapes-glow.md
new file mode 100644
index 00000000000..c045680d7dc
--- /dev/null
+++ b/.changeset/perfect-grapes-glow.md
@@ -0,0 +1,6 @@
+---
+'@rest-hooks/react': minor
+'@rest-hooks/core': minor
+---
+
+Add /next export for early adoption of breaking changes
diff --git a/.changeset/smart-dragons-rhyme.md b/.changeset/smart-dragons-rhyme.md
new file mode 100644
index 00000000000..59b29127f75
--- /dev/null
+++ b/.changeset/smart-dragons-rhyme.md
@@ -0,0 +1,5 @@
+---
+'@rest-hooks/core': minor
+---
+
+Controller.fetch resolves to denormalized form and is fully typed
diff --git a/docs/core/api/Controller.md b/docs/core/api/Controller.md
index 53af9ddf051..8f79014f29d 100644
--- a/docs/core/api/Controller.md
+++ b/docs/core/api/Controller.md
@@ -113,16 +113,15 @@ function PostListItem({ post }: { post: PostResource }) {
 :::tip
 
 `fetch` has the same return value as the [Endpoint](/rest/api/Endpoint) passed to it.
-When using schemas, the denormalized value can be retrieved using a combination of
-[Controller.getResponse](#getResponse) and [Controller.getState](#getState)
+When using schemas, the denormalized value can be retrieved using the future-compatible /next import
 
 ```ts
-await controller.fetch(PostResource.create, createPayload);
-const { data: denormalizedResponse } = controller.getResponse(
-  PostResource.create,
-  createPayload,
-  controller.getState(),
-);
+// highlight-next-line
+import { useController } from '@rest-hooks/react/next';
+
+const post = await controller.fetch(PostResource.create, createPayload);
+post.title;
+post.pk();
 ```
 
 :::
diff --git a/docs/core/api/useController.md b/docs/core/api/useController.md
index 1e13256bc34..1f772b8c398 100644
--- a/docs/core/api/useController.md
+++ b/docs/core/api/useController.md
@@ -7,6 +7,8 @@ title: useController()
   <meta name="docsearch:pagerank" content="10"/>
 </head>
 
+import TypeScriptEditor from '@site/src/components/TypeScriptEditor';
+
 [Controller](./Controller.md) provides type-safe methods to manipulate the store.
 
 For instance [fetch](./Controller.md#fetch), [invalidate](./Controller.md#invalidate),
@@ -43,6 +45,19 @@ function MyComponent({ id }) {
 
 ## Examples
 
+### /next
+
+`@rest-hooks/react/next` contains the version of `useController()` that will ship with the next version.
+This provides a return value that matches [useSuspense()](./useSuspense.md) - utilizing the [Endpoint.schema](/rest/api/RestEndpoint#schema)
+
+```ts
+import { useController } from '@rest-hooks/react/next';
+
+const post = await controller.fetch(PostResource.create, createPayload);
+post.title;
+post.pk();
+```
+
 ### Todo App
 
 <iframe
diff --git a/jest.config.js b/jest.config.js
index 944ee657ba7..197922ee0cb 100644
--- a/jest.config.js
+++ b/jest.config.js
@@ -25,6 +25,8 @@ const baseConfig = {
     'packages/redux',
     'packages/ssr',
     'packages/rest/src/next',
+    'packages/core/src/next',
+    'packages/react/src/next',
     'packages/legacy/src/resource',
     'packages/legacy/src/rest-3',
     'packages/rest-hooks/src/hooks/hasUsableData',
diff --git a/packages/core/.gitignore b/packages/core/.gitignore
index 6f791d55291..94450d85e37 100644
--- a/packages/core/.gitignore
+++ b/packages/core/.gitignore
@@ -2,3 +2,4 @@
 /dist
 /legacy
 /index.d.ts
+/next.d.ts
diff --git a/packages/core/package.json b/packages/core/package.json
index 061035324d6..fad4803516b 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -13,6 +13,9 @@
       "": [
         "lib/index.d.ts"
       ],
+      "next": [
+        "lib/next/index.d.ts"
+      ],
       "*": [
         "lib/index.d.ts"
       ]
@@ -21,6 +24,9 @@
       "": [
         "ts3.4/index.d.ts"
       ],
+      "next": [
+        "ts3.4/next/index.d.ts"
+      ],
       "*": [
         "ts3.4/index.d.ts"
       ]
@@ -33,6 +39,11 @@
       "require": "./dist/index.js",
       "default": "./lib/index.js"
     },
+    "./next": {
+      "types": "./lib/next/index.d.ts",
+      "require": "./dist/next.js",
+      "default": "./lib/next/index.js"
+    },
     "./package.json": "./package.json"
   },
   "type": "module",
diff --git a/packages/core/rollup.config.js b/packages/core/rollup.config.js
index c1dbceb1af1..38fc5e1c04c 100644
--- a/packages/core/rollup.config.js
+++ b/packages/core/rollup.config.js
@@ -1,13 +1,13 @@
-import commonjs from 'rollup-plugin-commonjs';
-import resolve from 'rollup-plugin-node-resolve';
 import babel from 'rollup-plugin-babel';
-import json from 'rollup-plugin-json';
-import { terser } from 'rollup-plugin-terser';
+import commonjs from 'rollup-plugin-commonjs';
 import filesize from 'rollup-plugin-filesize';
+import json from 'rollup-plugin-json';
+import resolve from 'rollup-plugin-node-resolve';
 import replace from 'rollup-plugin-replace';
+import { terser } from 'rollup-plugin-terser';
 
-import { typeConfig } from '../../rollup-utils';
 import pkg from './package.json';
+import { typeConfig, typeConfigNext } from '../../rollup-utils';
 
 const dependencies = Object.keys(pkg.dependencies)
   //.concat(Object.keys(pkg.peerDependencies))
@@ -44,23 +44,29 @@ if (process.env.BROWSERSLIST_ENV !== 'node12') {
     ],
   });
   configs.push(typeConfig);
+  configs.push(typeConfigNext);
 } else {
   // node-friendly commonjs build
-  configs.push({
-    input: 'lib/index.js',
-    external: isExternal,
-    output: [{ file: pkg.main, format: 'cjs' }],
-    plugins: [
-      babel({
-        exclude: ['node_modules/**', '**/__tests__/**', '**/*.d.ts'],
-        extensions: nativeExtensions,
-        rootMode: 'upward',
-        runtimeHelpers: true,
-      }),
-      replace({ 'process.env.CJS': 'true' }),
-      resolve({ extensions: nativeExtensions }),
-      commonjs({ extensions: nativeExtensions }),
-    ],
+  [
+    { input: 'lib/index.js', output: pkg.main },
+    { input: 'lib/next/index.js', output: 'dist/next.js' },
+  ].forEach(({ input, output }) => {
+    configs.push({
+      input,
+      external: isExternal,
+      output: [{ file: output, format: 'cjs' }],
+      plugins: [
+        babel({
+          exclude: ['node_modules/**', '**/__tests__/**', '**/*.d.ts'],
+          extensions: nativeExtensions,
+          rootMode: 'upward',
+          runtimeHelpers: true,
+        }),
+        replace({ 'process.env.CJS': 'true' }),
+        resolve({ extensions: nativeExtensions }),
+        commonjs({ extensions: nativeExtensions }),
+      ],
+    });
   });
 }
 export default configs;
diff --git a/packages/core/src/controller/BaseController.ts b/packages/core/src/controller/BaseController.ts
new file mode 100644
index 00000000000..f16b025134c
--- /dev/null
+++ b/packages/core/src/controller/BaseController.ts
@@ -0,0 +1,495 @@
+import type {
+  EndpointInterface,
+  FetchFunction,
+  ResolveType,
+  DenormalizeNullable,
+  EntityTable,
+  Path,
+} from '@rest-hooks/normalizr';
+import {
+  ExpiryStatus,
+  ErrorTypes,
+  SnapshotInterface,
+  denormalize,
+  DenormalizeCache,
+  isEntity,
+  Schema,
+  WeakEntityMap,
+} from '@rest-hooks/normalizr';
+import { inferResults } from '@rest-hooks/normalizr';
+
+import createInvalidate from './createInvalidate.js';
+import createInvalidateAll from './createInvalidateAll.js';
+import createReceive from './createReceive.js';
+import createReset from './createReset.js';
+import {
+  createUnsubscription,
+  createSubscription,
+} from './createSubscription.js';
+import type { EndpointUpdateFunction } from './types.js';
+import { initialState } from '../state/reducer/createReducer.js';
+import selectMeta from '../state/selectMeta.js';
+import type {
+  ActionTypes as BroadActionTypes,
+  CombinedActionTypes,
+  State,
+} from '../types.js';
+
+export type GenericDispatch = (value: any) => Promise<void>;
+export type CompatibleDispatch = (value: CombinedActionTypes) => Promise<void>;
+type PreviousDispatch = (value: BroadActionTypes) => Promise<void>;
+
+interface ConstructorProps<D extends GenericDispatch = CompatibleDispatch> {
+  dispatch?: D;
+  getState?: () => State<unknown>;
+  globalCache?: DenormalizeCache;
+}
+
+const unsetDispatch = (action: unknown): Promise<void> => {
+  throw new Error(
+    `Dispatching while constructing your middleware is not allowed. ` +
+      `Other middleware would not be applied to this dispatch.`,
+  );
+};
+const unsetState = (): State<unknown> => {
+  // This is only the value until it is set by the CacheProvider
+  /* istanbul ignore next */
+  return initialState;
+};
+
+/**
+ * Imperative control of Rest Hooks store
+ * @see https://resthooks.io/docs/api/Controller
+ */
+export default class Controller<
+  D extends GenericDispatch = CompatibleDispatch,
+> {
+  /**
+   * Dispatches an action to Rest Hooks reducer.
+   *
+   * @see https://resthooks.io/docs/api/Controller#dispatch
+   */
+  declare readonly dispatch: D;
+  /**
+   * Gets the latest state snapshot that is fully committed.
+   *
+   * This can be useful for imperative use-cases like event handlers.
+   * This should *not* be used to render; instead useSuspense() or useCache()
+   * @see https://resthooks.io/docs/api/Controller#getState
+   */
+  declare readonly getState: () => State<unknown>;
+  declare readonly globalCache: DenormalizeCache;
+
+  constructor({
+    dispatch = unsetDispatch as any,
+    getState = unsetState,
+    globalCache = {
+      entities: {},
+      results: {},
+    },
+  }: ConstructorProps<D> = {}) {
+    this.dispatch = dispatch;
+    this.getState = getState;
+    this.globalCache = globalCache;
+  }
+
+  /*************** Action Dispatchers ***************/
+
+  /**
+   * Forces refetching and suspense on useSuspense with the same Endpoint and parameters.
+   * @see https://resthooks.io/docs/api/Controller#invalidate
+   */
+  invalidate = <E extends EndpointInterface>(
+    endpoint: E,
+    ...args: readonly [...Parameters<E>] | readonly [null]
+  ): Promise<void> =>
+    args[0] !== null
+      ? this.dispatch(
+          createInvalidate(endpoint, {
+            args: args as readonly [...Parameters<E>],
+          }),
+        )
+      : Promise.resolve();
+
+  /**
+   * Forces refetching and suspense on useSuspense on all matching endpoint result keys.
+   * @see https://resthooks.io/docs/api/Controller#invalidateAll
+   */
+  invalidateAll = (options: { testKey: (key: string) => boolean }) =>
+    this.dispatch(createInvalidateAll((key: string) => options.testKey(key)));
+
+  /**
+   * Resets the entire Rest Hooks cache. All inflight requests will not resolve.
+   * @see https://resthooks.io/docs/api/Controller#resetEntireStore
+   */
+  resetEntireStore = (): Promise<void> => this.dispatch(createReset());
+
+  /**
+   * Stores response in cache for given Endpoint and args.
+   * @see https://resthooks.io/docs/api/Controller#set
+   */
+  setResponse = <
+    E extends EndpointInterface & {
+      update?: EndpointUpdateFunction<E>;
+    },
+  >(
+    endpoint: E,
+    ...rest: readonly [...Parameters<E>, any]
+  ): Promise<void> => {
+    const response: ResolveType<E> = rest[rest.length - 1];
+    const action = createReceive(endpoint, {
+      args: rest.slice(0, rest.length - 1) as Parameters<E>,
+      response,
+    });
+    return this.dispatch(action);
+  };
+
+  // TODO: deprecate
+  /**
+   * Another name for setResponse
+   * @see https://resthooks.io/docs/api/Controller#setResponse
+   */
+  /* istanbul ignore next */ receive = <
+    E extends EndpointInterface & {
+      update?: EndpointUpdateFunction<E>;
+    },
+  >(
+    endpoint: E,
+    ...rest: readonly [...Parameters<E>, any]
+  ): Promise<void> => {
+    /* istanbul ignore next */
+    return this.setResponse(endpoint, ...rest);
+  };
+
+  /**
+   * Stores the result of Endpoint and args as the error provided.
+   * @see https://resthooks.io/docs/api/Controller#setError
+   */
+  setError = <
+    E extends EndpointInterface & {
+      update?: EndpointUpdateFunction<E>;
+    },
+  >(
+    endpoint: E,
+    ...rest: readonly [...Parameters<E>, Error]
+  ): Promise<void> => {
+    const response: Error = rest[rest.length - 1];
+    const action = createReceive(endpoint, {
+      args: rest.slice(0, rest.length - 1) as Parameters<E>,
+      response,
+      error: true,
+    });
+    return this.dispatch(action);
+  };
+
+  // TODO: deprecate
+  /**
+   * Another name for setError
+   * @see https://resthooks.io/docs/api/Controller#setError
+   */
+  /* istanbul ignore next */ receiveError = <
+    E extends EndpointInterface & {
+      update?: EndpointUpdateFunction<E>;
+    },
+  >(
+    endpoint: E,
+    ...rest: readonly [...Parameters<E>, Error]
+  ): Promise<void> => {
+    /* istanbul ignore next */
+    return this.setError(endpoint, ...rest);
+  };
+
+  /**
+   * Resolves an inflight fetch. `fetchedAt` should `fetch`'s `createdAt`
+   * @see https://resthooks.io/docs/api/Controller#resolve
+   */
+  resolve = <
+    E extends EndpointInterface & {
+      update?: EndpointUpdateFunction<E>;
+    },
+  >(
+    endpoint: E,
+    meta:
+      | {
+          args: readonly [...Parameters<E>];
+          response: Error;
+          fetchedAt: number;
+          error: true;
+        }
+      | {
+          args: readonly [...Parameters<E>];
+          response: any;
+          fetchedAt: number;
+          error?: false;
+        },
+  ): Promise<void> => {
+    return this.dispatch(createReceive(endpoint, meta as any));
+  };
+
+  /**
+   * Marks a new subscription to a given Endpoint.
+   * @see https://resthooks.io/docs/api/Controller#subscribe
+   */
+  subscribe = <
+    E extends EndpointInterface<
+      FetchFunction,
+      Schema | undefined,
+      undefined | false
+    >,
+  >(
+    endpoint: E,
+    ...args: readonly [...Parameters<E>] | readonly [null]
+  ): Promise<void> =>
+    args[0] !== null
+      ? this.dispatch(
+          createSubscription(endpoint, {
+            args: args as readonly [...Parameters<E>],
+          }),
+        )
+      : Promise.resolve();
+
+  /**
+   * Marks completion of subscription to a given Endpoint.
+   * @see https://resthooks.io/docs/api/Controller#unsubscribe
+   */
+  unsubscribe = <
+    E extends EndpointInterface<
+      FetchFunction,
+      Schema | undefined,
+      undefined | false
+    >,
+  >(
+    endpoint: E,
+    ...args: readonly [...Parameters<E>] | readonly [null]
+  ): Promise<void> =>
+    args[0] !== null
+      ? this.dispatch(
+          createUnsubscription(endpoint, {
+            args: args as readonly [...Parameters<E>],
+          }),
+        )
+      : Promise.resolve();
+
+  /*************** More ***************/
+
+  /* TODO:
+  abort = <E extends EndpointInterface>(
+    endpoint: E,
+    ...args: readonly [...Parameters<E>]
+  ): Promise<void>
+  */
+
+  /**
+   * Gets a snapshot (https://resthooks.io/docs/api/Snapshot)
+   * @see https://resthooks.io/docs/api/Controller#snapshot
+   */
+  snapshot = (state: State<unknown>, fetchedAt?: number): SnapshotInterface => {
+    return new Snapshot(this, state, fetchedAt);
+  };
+
+  /**
+   * Gets the error, if any, for a given endpoint. Returns undefined for no errors.
+   * @see https://resthooks.io/docs/api/Controller#getError
+   */
+  getError = <
+    E extends Pick<EndpointInterface, 'key'>,
+    Args extends readonly [...Parameters<E['key']>] | readonly [null],
+  >(
+    endpoint: E,
+    ...rest: [...Args, State<unknown>]
+  ): ErrorTypes | undefined => {
+    if (rest[0] === null) return;
+    const state = rest[rest.length - 1] as State<unknown>;
+    // this is typescript generics breaking
+    const args: any = rest.slice(0, rest.length - 1) as Parameters<E['key']>;
+    const key = endpoint.key(...args);
+
+    const meta = selectMeta(state, key);
+    const results = state.results[key];
+
+    if (results !== undefined && meta?.errorPolicy === 'soft') return;
+
+    return meta?.error as any;
+  };
+
+  /**
+   * Gets the (globally referentially stable) response for a given endpoint/args pair from state given.
+   * @see https://resthooks.io/docs/api/Controller#getResponse
+   */
+  getResponse = <
+    E extends Pick<EndpointInterface, 'key' | 'schema' | 'invalidIfStale'>,
+    Args extends readonly [...Parameters<E['key']>] | readonly [null],
+  >(
+    endpoint: E,
+    ...rest: [...Args, State<unknown>]
+  ): {
+    data: DenormalizeNullable<E['schema']>;
+    expiryStatus: ExpiryStatus;
+    expiresAt: number;
+  } => {
+    const state = rest[rest.length - 1] as State<unknown>;
+    // this is typescript generics breaking
+    const args: any = rest.slice(0, rest.length - 1) as Parameters<E['key']>;
+    const isActive = args.length !== 1 || args[0] !== null;
+    const key = isActive ? endpoint.key(...args) : '';
+    const cacheResults = isActive && state.results[key];
+    const schema = endpoint.schema;
+    const meta = selectMeta(state, key);
+    let expiresAt = meta?.expiresAt;
+
+    const results = this.getResults(
+      endpoint.schema,
+      cacheResults,
+      args,
+      state.indexes,
+      state.entities,
+    );
+
+    if (!endpoint.schema || !schemaHasEntity(endpoint.schema)) {
+      return {
+        data: results,
+        expiryStatus: meta?.invalidated
+          ? ExpiryStatus.Invalid
+          : cacheResults && !endpoint.invalidIfStale
+          ? ExpiryStatus.Valid
+          : ExpiryStatus.InvalidIfStale,
+        expiresAt: expiresAt || 0,
+      } as {
+        data: DenormalizeNullable<E['schema']>;
+        expiryStatus: ExpiryStatus;
+        expiresAt: number;
+      };
+    }
+    // Warn users with bad configurations
+    /* istanbul ignore next */
+    if (process.env.NODE_ENV !== 'production' && schema && isEntity(schema)) {
+      if (Array.isArray(results)) {
+        throw new Error(
+          `fetch key ${key} has list results when single result is expected`,
+        );
+      }
+      if (typeof results === 'object') {
+        throw new Error(
+          `fetch key ${key} has object results when entity's primary key (string) result is expected`,
+        );
+      }
+    }
+
+    if (isActive && !this.globalCache.results[key])
+      this.globalCache.results[key] = new WeakEntityMap();
+
+    // second argument is false if any entities are missing
+    // eslint-disable-next-line prefer-const
+    const [data, found, suspend, entityPaths] = denormalize(
+      results,
+      schema,
+      state.entities,
+      this.globalCache.entities,
+      isActive ? this.globalCache.results[key] : undefined,
+    ) as [DenormalizeNullable<E['schema']>, boolean, boolean, Path[]];
+
+    // fallback to entity expiry time
+    if (!expiresAt) {
+      // expiresAt existance is equivalent to cacheResults
+      if (found) {
+        const entityMeta = state.entityMeta;
+        // oldest entity dictates age
+        expiresAt = entityPaths.reduce(
+          (expiresAt: number, { pk, key }) =>
+            Math.min(expiresAt, entityMeta[key]?.[pk]?.expiresAt ?? Infinity),
+          Infinity,
+        );
+        /*expiresAt = entityPaths
+          .map(({ pk, key }) => entityMeta[key]?.[pk]?.expiresAt)
+          .filter(a => a)
+          .reduce((a, b) => Math.min(a, b), Infinity); Alternative method - is it faster?*/
+      } else {
+        expiresAt = 0;
+      }
+    }
+
+    // https://resthooks.io/docs/concepts/expiry-policy#expiry-status
+    // we don't track the difference between stale or fresh because that is tied to triggering
+    // conditions
+    const expiryStatus =
+      meta?.invalidated || (suspend && !meta?.error)
+        ? ExpiryStatus.Invalid
+        : suspend || endpoint.invalidIfStale || (!cacheResults && !found)
+        ? ExpiryStatus.InvalidIfStale
+        : ExpiryStatus.Valid;
+
+    return { data, expiryStatus, expiresAt };
+  };
+
+  private getResults = (
+    schema: Schema | undefined,
+    cacheResults: any,
+    args: any[],
+    indexes: any,
+    entities: EntityTable,
+  ) => {
+    if (cacheResults || schema === undefined) return cacheResults;
+
+    return inferResults(schema, args, indexes, entities);
+  };
+}
+
+/** Determine whether the schema has any entities.
+ *
+ * Without entities, denormalization is not needed, and results should not be inferred.
+ */
+function schemaHasEntity(schema: Schema): boolean {
+  if (isEntity(schema)) return true;
+  if (Array.isArray(schema))
+    return schema.length !== 0 && schemaHasEntity(schema[0]);
+  if (schema && (typeof schema === 'object' || typeof schema === 'function')) {
+    const nestedSchema =
+      'schema' in schema ? (schema.schema as Record<string, Schema>) : schema;
+    if (typeof nestedSchema === 'function') {
+      return schemaHasEntity(nestedSchema);
+    }
+    return Object.values(nestedSchema).some(x => schemaHasEntity(x));
+  }
+  return false;
+}
+
+export type { ErrorTypes };
+
+class Snapshot<T = unknown> implements SnapshotInterface {
+  private state: State<T>;
+  private controller: Controller;
+  readonly fetchedAt: number;
+
+  constructor(controller: Controller, state: State<T>, fetchedAt = 0) {
+    this.state = state;
+    this.controller = controller;
+    this.fetchedAt = fetchedAt;
+  }
+
+  /*************** Data Access ***************/
+  /** @see https://resthooks.io/docs/api/Snapshot#getResponse */
+  getResponse = <
+    E extends Pick<EndpointInterface, 'key' | 'schema' | 'invalidIfStale'>,
+    Args extends readonly [...Parameters<E['key']>],
+  >(
+    endpoint: E,
+    ...args: Args
+  ): {
+    data: DenormalizeNullable<E['schema']>;
+    expiryStatus: ExpiryStatus;
+    expiresAt: number;
+  } => {
+    return this.controller.getResponse(endpoint, ...args, this.state);
+  };
+
+  /** @see https://resthooks.io/docs/api/Snapshot#getError */
+  getError = <
+    E extends Pick<EndpointInterface, 'key'>,
+    Args extends readonly [...Parameters<E['key']>],
+  >(
+    endpoint: E,
+    ...args: Args
+  ): ErrorTypes | undefined => {
+    return this.controller.getError(endpoint, ...args, this.state);
+  };
+}
diff --git a/packages/core/src/controller/Controller.ts b/packages/core/src/controller/Controller.ts
index 3e8b6634eff..ff4280ed4f4 100644
--- a/packages/core/src/controller/Controller.ts
+++ b/packages/core/src/controller/Controller.ts
@@ -1,101 +1,15 @@
-import type {
-  EndpointInterface,
-  FetchFunction,
-  ResolveType,
-  DenormalizeNullable,
-  EntityTable,
-  Path,
-} from '@rest-hooks/normalizr';
-import { ExpiryStatus } from '@rest-hooks/normalizr';
-import {
-  ErrorTypes,
-  SnapshotInterface,
-  denormalize,
-  DenormalizeCache,
-  isEntity,
-  Schema,
-  WeakEntityMap,
-} from '@rest-hooks/normalizr';
-import { inferResults } from '@rest-hooks/normalizr';
+import type { EndpointInterface } from '@rest-hooks/normalizr';
 
+import BaseController, {
+  CompatibleDispatch,
+  GenericDispatch,
+} from './BaseController.js';
 import createFetch from './createFetch.js';
-import createInvalidate from './createInvalidate.js';
-import createInvalidateAll from './createInvalidateAll.js';
-import createReceive from './createReceive.js';
-import createReset from './createReset.js';
-import {
-  createUnsubscription,
-  createSubscription,
-} from './createSubscription.js';
 import type { EndpointUpdateFunction } from './types.js';
-import { initialState } from '../state/reducer/createReducer.js';
-import selectMeta from '../state/selectMeta.js';
-import type {
-  ActionTypes as BroadActionTypes,
-  CombinedActionTypes,
-  State,
-} from '../types.js';
 
-export type GenericDispatch = (value: any) => Promise<void>;
-export type CompatibleDispatch = (value: CombinedActionTypes) => Promise<void>;
-type PreviousDispatch = (value: BroadActionTypes) => Promise<void>;
-
-interface ConstructorProps<D extends GenericDispatch = CompatibleDispatch> {
-  dispatch?: D;
-  getState?: () => State<unknown>;
-  globalCache?: DenormalizeCache;
-}
-
-const unsetDispatch = (action: unknown): Promise<void> => {
-  throw new Error(
-    `Dispatching while constructing your middleware is not allowed. ` +
-      `Other middleware would not be applied to this dispatch.`,
-  );
-};
-const unsetState = (): State<unknown> => {
-  // This is only the value until it is set by the CacheProvider
-  /* istanbul ignore next */
-  return initialState;
-};
-
-/**
- * Imperative control of Rest Hooks store
- * @see https://resthooks.io/docs/api/Controller
- */
 export default class Controller<
   D extends GenericDispatch = CompatibleDispatch,
-> {
-  /**
-   * Dispatches an action to Rest Hooks reducer.
-   *
-   * @see https://resthooks.io/docs/api/Controller#dispatch
-   */
-  declare readonly dispatch: D;
-  /**
-   * Gets the latest state snapshot that is fully committed.
-   *
-   * This can be useful for imperative use-cases like event handlers.
-   * This should *not* be used to render; instead useSuspense() or useCache()
-   * @see https://resthooks.io/docs/api/Controller#getState
-   */
-  declare readonly getState: () => State<unknown>;
-  declare readonly globalCache: DenormalizeCache;
-
-  constructor({
-    dispatch = unsetDispatch as any,
-    getState = unsetState,
-    globalCache = {
-      entities: {},
-      results: {},
-    },
-  }: ConstructorProps<D> = {}) {
-    this.dispatch = dispatch;
-    this.getState = getState;
-    this.globalCache = globalCache;
-  }
-
-  /*************** Action Dispatchers ***************/
-
+> extends BaseController<D> {
   /**
    * Fetches the endpoint with given args, updating the Rest Hooks cache with the response or error upon completion.
    * @see https://resthooks.io/docs/api/Controller#fetch
@@ -113,396 +27,6 @@ export default class Controller<
 
     return action.meta.promise as ReturnType<E>;
   };
-
-  /**
-   * Forces refetching and suspense on useSuspense with the same Endpoint and parameters.
-   * @see https://resthooks.io/docs/api/Controller#invalidate
-   */
-  invalidate = <E extends EndpointInterface>(
-    endpoint: E,
-    ...args: readonly [...Parameters<E>] | readonly [null]
-  ): Promise<void> =>
-    args[0] !== null
-      ? this.dispatch(
-          createInvalidate(endpoint, {
-            args: args as readonly [...Parameters<E>],
-          }),
-        )
-      : Promise.resolve();
-
-  /**
-   * Forces refetching and suspense on useSuspense on all matching endpoint result keys.
-   * @see https://resthooks.io/docs/api/Controller#invalidateAll
-   */
-  invalidateAll = (options: { testKey: (key: string) => boolean }) =>
-    this.dispatch(createInvalidateAll((key: string) => options.testKey(key)));
-
-  /**
-   * Resets the entire Rest Hooks cache. All inflight requests will not resolve.
-   * @see https://resthooks.io/docs/api/Controller#resetEntireStore
-   */
-  resetEntireStore = (): Promise<void> => this.dispatch(createReset());
-
-  /**
-   * Stores response in cache for given Endpoint and args.
-   * @see https://resthooks.io/docs/api/Controller#set
-   */
-  setResponse = <
-    E extends EndpointInterface & {
-      update?: EndpointUpdateFunction<E>;
-    },
-  >(
-    endpoint: E,
-    ...rest: readonly [...Parameters<E>, any]
-  ): Promise<void> => {
-    const response: ResolveType<E> = rest[rest.length - 1];
-    const action = createReceive(endpoint, {
-      args: rest.slice(0, rest.length - 1) as Parameters<E>,
-      response,
-    });
-    return this.dispatch(action);
-  };
-
-  // TODO: deprecate
-  /**
-   * Another name for setResponse
-   * @see https://resthooks.io/docs/api/Controller#setResponse
-   */
-  /* istanbul ignore next */ receive = <
-    E extends EndpointInterface & {
-      update?: EndpointUpdateFunction<E>;
-    },
-  >(
-    endpoint: E,
-    ...rest: readonly [...Parameters<E>, any]
-  ): Promise<void> => {
-    /* istanbul ignore next */
-    return this.setResponse(endpoint, ...rest);
-  };
-
-  /**
-   * Stores the result of Endpoint and args as the error provided.
-   * @see https://resthooks.io/docs/api/Controller#setError
-   */
-  setError = <
-    E extends EndpointInterface & {
-      update?: EndpointUpdateFunction<E>;
-    },
-  >(
-    endpoint: E,
-    ...rest: readonly [...Parameters<E>, Error]
-  ): Promise<void> => {
-    const response: Error = rest[rest.length - 1];
-    const action = createReceive(endpoint, {
-      args: rest.slice(0, rest.length - 1) as Parameters<E>,
-      response,
-      error: true,
-    });
-    return this.dispatch(action);
-  };
-
-  // TODO: deprecate
-  /**
-   * Another name for setError
-   * @see https://resthooks.io/docs/api/Controller#setError
-   */
-  /* istanbul ignore next */ receiveError = <
-    E extends EndpointInterface & {
-      update?: EndpointUpdateFunction<E>;
-    },
-  >(
-    endpoint: E,
-    ...rest: readonly [...Parameters<E>, Error]
-  ): Promise<void> => {
-    /* istanbul ignore next */
-    return this.setError(endpoint, ...rest);
-  };
-
-  /**
-   * Resolves an inflight fetch. `fetchedAt` should `fetch`'s `createdAt`
-   * @see https://resthooks.io/docs/api/Controller#resolve
-   */
-  resolve = <
-    E extends EndpointInterface & {
-      update?: EndpointUpdateFunction<E>;
-    },
-  >(
-    endpoint: E,
-    meta:
-      | {
-          args: readonly [...Parameters<E>];
-          response: Error;
-          fetchedAt: number;
-          error: true;
-        }
-      | {
-          args: readonly [...Parameters<E>];
-          response: any;
-          fetchedAt: number;
-          error?: false;
-        },
-  ): Promise<void> => {
-    return this.dispatch(createReceive(endpoint, meta as any));
-  };
-
-  /**
-   * Marks a new subscription to a given Endpoint.
-   * @see https://resthooks.io/docs/api/Controller#subscribe
-   */
-  subscribe = <
-    E extends EndpointInterface<
-      FetchFunction,
-      Schema | undefined,
-      undefined | false
-    >,
-  >(
-    endpoint: E,
-    ...args: readonly [...Parameters<E>] | readonly [null]
-  ): Promise<void> =>
-    args[0] !== null
-      ? this.dispatch(
-          createSubscription(endpoint, {
-            args: args as readonly [...Parameters<E>],
-          }),
-        )
-      : Promise.resolve();
-
-  /**
-   * Marks completion of subscription to a given Endpoint.
-   * @see https://resthooks.io/docs/api/Controller#unsubscribe
-   */
-  unsubscribe = <
-    E extends EndpointInterface<
-      FetchFunction,
-      Schema | undefined,
-      undefined | false
-    >,
-  >(
-    endpoint: E,
-    ...args: readonly [...Parameters<E>] | readonly [null]
-  ): Promise<void> =>
-    args[0] !== null
-      ? this.dispatch(
-          createUnsubscription(endpoint, {
-            args: args as readonly [...Parameters<E>],
-          }),
-        )
-      : Promise.resolve();
-
-  /*************** More ***************/
-
-  /* TODO:
-  abort = <E extends EndpointInterface>(
-    endpoint: E,
-    ...args: readonly [...Parameters<E>]
-  ): Promise<void>
-  */
-
-  snapshot = (state: State<unknown>, fetchedAt?: number): SnapshotInterface => {
-    return new Snapshot(this, state, fetchedAt);
-  };
-
-  /**
-   * Gets the error, if any, for a given endpoint. Returns undefined for no errors.
-   * @see https://resthooks.io/docs/api/Controller#getError
-   */
-  getError = <
-    E extends Pick<EndpointInterface, 'key'>,
-    Args extends readonly [...Parameters<E['key']>] | readonly [null],
-  >(
-    endpoint: E,
-    ...rest: [...Args, State<unknown>]
-  ): ErrorTypes | undefined => {
-    if (rest[0] === null) return;
-    const state = rest[rest.length - 1] as State<unknown>;
-    // this is typescript generics breaking
-    const args: any = rest.slice(0, rest.length - 1) as Parameters<E['key']>;
-    const key = endpoint.key(...args);
-
-    const meta = selectMeta(state, key);
-    const results = state.results[key];
-
-    if (results !== undefined && meta?.errorPolicy === 'soft') return;
-
-    return meta?.error as any;
-  };
-
-  /**
-   * Gets the (globally referentially stable) response for a given endpoint/args pair from state given.
-   * @see https://resthooks.io/docs/api/Controller#getResponse
-   */
-  getResponse = <
-    E extends Pick<EndpointInterface, 'key' | 'schema' | 'invalidIfStale'>,
-    Args extends readonly [...Parameters<E['key']>] | readonly [null],
-  >(
-    endpoint: E,
-    ...rest: [...Args, State<unknown>]
-  ): {
-    data: DenormalizeNullable<E['schema']>;
-    expiryStatus: ExpiryStatus;
-    expiresAt: number;
-  } => {
-    const state = rest[rest.length - 1] as State<unknown>;
-    // this is typescript generics breaking
-    const args: any = rest.slice(0, rest.length - 1) as Parameters<E['key']>;
-    const isActive = args.length !== 1 || args[0] !== null;
-    const key = isActive ? endpoint.key(...args) : '';
-    const cacheResults = isActive && state.results[key];
-    const schema = endpoint.schema;
-    const meta = selectMeta(state, key);
-    let expiresAt = meta?.expiresAt;
-
-    const results = this.getResults(
-      endpoint.schema,
-      cacheResults,
-      args,
-      state.indexes,
-      state.entities,
-    );
-
-    if (!endpoint.schema || !schemaHasEntity(endpoint.schema)) {
-      return {
-        data: results,
-        expiryStatus: meta?.invalidated
-          ? ExpiryStatus.Invalid
-          : cacheResults && !endpoint.invalidIfStale
-          ? ExpiryStatus.Valid
-          : ExpiryStatus.InvalidIfStale,
-        expiresAt: expiresAt || 0,
-      } as {
-        data: DenormalizeNullable<E['schema']>;
-        expiryStatus: ExpiryStatus;
-        expiresAt: number;
-      };
-    }
-    // Warn users with bad configurations
-    /* istanbul ignore next */
-    if (process.env.NODE_ENV !== 'production' && schema && isEntity(schema)) {
-      if (Array.isArray(results)) {
-        throw new Error(
-          `fetch key ${key} has list results when single result is expected`,
-        );
-      }
-      if (typeof results === 'object') {
-        throw new Error(
-          `fetch key ${key} has object results when entity's primary key (string) result is expected`,
-        );
-      }
-    }
-
-    if (isActive && !this.globalCache.results[key])
-      this.globalCache.results[key] = new WeakEntityMap();
-
-    // second argument is false if any entities are missing
-    // eslint-disable-next-line prefer-const
-    const [data, found, suspend, entityPaths] = denormalize(
-      results,
-      schema,
-      state.entities,
-      this.globalCache.entities,
-      isActive ? this.globalCache.results[key] : undefined,
-    ) as [DenormalizeNullable<E['schema']>, boolean, boolean, Path[]];
-
-    // fallback to entity expiry time
-    if (!expiresAt) {
-      // expiresAt existance is equivalent to cacheResults
-      if (found) {
-        const entityMeta = state.entityMeta;
-        // oldest entity dictates age
-        expiresAt = entityPaths.reduce(
-          (expiresAt: number, { pk, key }) =>
-            Math.min(expiresAt, entityMeta[key]?.[pk]?.expiresAt ?? Infinity),
-          Infinity,
-        );
-        /*expiresAt = entityPaths
-          .map(({ pk, key }) => entityMeta[key]?.[pk]?.expiresAt)
-          .filter(a => a)
-          .reduce((a, b) => Math.min(a, b), Infinity); Alternative method - is it faster?*/
-      } else {
-        expiresAt = 0;
-      }
-    }
-
-    // https://resthooks.io/docs/concepts/expiry-policy#expiry-status
-    // we don't track the difference between stale or fresh because that is tied to triggering
-    // conditions
-    const expiryStatus =
-      meta?.invalidated || (suspend && !meta?.error)
-        ? ExpiryStatus.Invalid
-        : suspend || endpoint.invalidIfStale || (!cacheResults && !found)
-        ? ExpiryStatus.InvalidIfStale
-        : ExpiryStatus.Valid;
-
-    return { data, expiryStatus, expiresAt };
-  };
-
-  private getResults = (
-    schema: Schema | undefined,
-    cacheResults: any,
-    args: any[],
-    indexes: any,
-    entities: EntityTable,
-  ) => {
-    if (cacheResults || schema === undefined) return cacheResults;
-
-    return inferResults(schema, args, indexes, entities);
-  };
 }
 
-/** Determine whether the schema has any entities.
- *
- * Without entities, denormalization is not needed, and results should not be inferred.
- */
-function schemaHasEntity(schema: Schema): boolean {
-  if (isEntity(schema)) return true;
-  if (Array.isArray(schema))
-    return schema.length !== 0 && schemaHasEntity(schema[0]);
-  if (schema && (typeof schema === 'object' || typeof schema === 'function')) {
-    const nestedSchema =
-      'schema' in schema ? (schema.schema as Record<string, Schema>) : schema;
-    if (typeof nestedSchema === 'function') {
-      return schemaHasEntity(nestedSchema);
-    }
-    return Object.values(nestedSchema).some(x => schemaHasEntity(x));
-  }
-  return false;
-}
-
-export type { ErrorTypes };
-
-class Snapshot<T = unknown> implements SnapshotInterface {
-  private state: State<T>;
-  private controller: Controller;
-  readonly fetchedAt: number;
-
-  constructor(controller: Controller, state: State<T>, fetchedAt = 0) {
-    this.state = state;
-    this.controller = controller;
-    this.fetchedAt = fetchedAt;
-  }
-
-  /*************** Data Access ***************/
-  getResponse = <
-    E extends Pick<EndpointInterface, 'key' | 'schema' | 'invalidIfStale'>,
-    Args extends readonly [...Parameters<E['key']>],
-  >(
-    endpoint: E,
-    ...args: Args
-  ): {
-    data: DenormalizeNullable<E['schema']>;
-    expiryStatus: ExpiryStatus;
-    expiresAt: number;
-  } => {
-    return this.controller.getResponse(endpoint, ...args, this.state);
-  };
-
-  getError = <
-    E extends Pick<EndpointInterface, 'key'>,
-    Args extends readonly [...Parameters<E['key']>],
-  >(
-    endpoint: E,
-    ...args: Args
-  ): ErrorTypes | undefined => {
-    return this.controller.getError(endpoint, ...args, this.state);
-  };
-}
+export * from './BaseController.js';
diff --git a/packages/core/src/next/Controller.ts b/packages/core/src/next/Controller.ts
new file mode 100644
index 00000000000..730df51ef9f
--- /dev/null
+++ b/packages/core/src/next/Controller.ts
@@ -0,0 +1,39 @@
+import type { EndpointInterface, Denormalize } from '@rest-hooks/normalizr';
+import { denormalize } from '@rest-hooks/normalizr';
+
+import BaseController, {
+  CompatibleDispatch,
+  GenericDispatch,
+} from '../controller/BaseController.js';
+import createFetch from '../controller/createFetch.js';
+import type { EndpointUpdateFunction } from '../controller/types.js';
+
+export default class Controller<
+  D extends GenericDispatch = CompatibleDispatch,
+> extends BaseController<D> {
+  /**
+   * Fetches the endpoint with given args, updating the Rest Hooks cache with the response or error upon completion.
+   * @see https://resthooks.io/docs/api/Controller#fetch
+   */
+  fetch = <
+    E extends EndpointInterface & { update?: EndpointUpdateFunction<E> },
+  >(
+    endpoint: E,
+    ...args: readonly [...Parameters<E>]
+  ): E['schema'] extends undefined | null
+    ? ReturnType<E>
+    : Promise<Denormalize<E['schema']>> => {
+    const action = createFetch(endpoint, {
+      args,
+    });
+    this.dispatch(action);
+
+    if (endpoint.schema) {
+      return action.meta.promise.then(
+        input => denormalize(input, endpoint.schema, {})[0],
+      ) as any;
+    }
+    return action.meta.promise as any;
+  };
+}
+export * from '../controller/BaseController.js';
diff --git a/packages/core/src/next/index.ts b/packages/core/src/next/index.ts
new file mode 100644
index 00000000000..2c17ccd1301
--- /dev/null
+++ b/packages/core/src/next/index.ts
@@ -0,0 +1,2 @@
+export { default as Controller } from './Controller.js';
+export * from './Controller.js';
diff --git a/packages/react/.gitignore b/packages/react/.gitignore
index 6f791d55291..94450d85e37 100644
--- a/packages/react/.gitignore
+++ b/packages/react/.gitignore
@@ -2,3 +2,4 @@
 /dist
 /legacy
 /index.d.ts
+/next.d.ts
diff --git a/packages/react/package.json b/packages/react/package.json
index 13922a26923..39e5c88b3a9 100644
--- a/packages/react/package.json
+++ b/packages/react/package.json
@@ -18,6 +18,9 @@
       "makeCacheProvider": [
         "lib/makeCacheProvider.d.ts"
       ],
+      "next": [
+        "lib/next/index.d.ts"
+      ],
       "*": [
         "lib/index.d.ts"
       ]
@@ -29,6 +32,9 @@
       "makeCacheProvider": [
         "ts3.4/makeCacheProvider.d.ts"
       ],
+      "next": [
+        "ts3.4/next/index.d.ts"
+      ],
       "*": [
         "ts3.4/index.d.ts"
       ]
@@ -48,6 +54,11 @@
       "require": "./dist/makeCacheProvider.js",
       "default": "./lib/makeCacheProvider.js"
     },
+    "./next": {
+      "types": "./lib/next/index.d.ts",
+      "require": "./dist/next.js",
+      "default": "./lib/next/index.js"
+    },
     "./package.json": "./package.json"
   },
   "type": "module",
diff --git a/packages/react/rollup.config.js b/packages/react/rollup.config.js
index 0a1bf78c6c9..bacbeadf043 100644
--- a/packages/react/rollup.config.js
+++ b/packages/react/rollup.config.js
@@ -1,13 +1,13 @@
-import commonjs from 'rollup-plugin-commonjs';
-import resolve from 'rollup-plugin-node-resolve';
 import babel from 'rollup-plugin-babel';
-import json from 'rollup-plugin-json';
-import { terser } from 'rollup-plugin-terser';
+import commonjs from 'rollup-plugin-commonjs';
 import filesize from 'rollup-plugin-filesize';
+import json from 'rollup-plugin-json';
+import resolve from 'rollup-plugin-node-resolve';
 import replace from 'rollup-plugin-replace';
+import { terser } from 'rollup-plugin-terser';
 
-import { typeConfig } from '../../rollup-utils';
 import pkg from './package.json';
+import { typeConfig, typeConfigNext } from '../../rollup-utils';
 
 const dependencies = Object.keys(pkg.dependencies)
   .concat(Object.keys(pkg.peerDependencies))
@@ -47,10 +47,12 @@ if (process.env.BROWSERSLIST_ENV !== 'node12') {
     ],
   });
   configs.push(typeConfig);
+  configs.push(typeConfigNext);
 } else {
   // node-friendly commonjs build
   [
     { input: 'lib/index.js', output: pkg.main },
+    { input: 'lib/next/index.js', output: 'dist/next.js' },
     { input: 'lib/makeCacheProvider.js', output: 'dist/makeCacheProvider.js' },
   ].forEach(({ input, output }) => {
     configs.push({
diff --git a/packages/react/src/next/__tests__/__snapshots__/fetch.tsx.snap b/packages/react/src/next/__tests__/__snapshots__/fetch.tsx.snap
new file mode 100644
index 00000000000..2b97976593c
--- /dev/null
+++ b/packages/react/src/next/__tests__/__snapshots__/fetch.tsx.snap
@@ -0,0 +1,23 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`CacheProvider should log error message when user update method throws 1`] = `
+[
+  [
+    "The following error occured during Endpoint.update() for POST http://test.com/article-cooler",
+  ],
+  [
+    [Error: usererror],
+  ],
+]
+`;
+
+exports[`ExternalCacheProvider should log error message when user update method throws 1`] = `
+[
+  [
+    "The following error occured during Endpoint.update() for POST http://test.com/article-cooler",
+  ],
+  [
+    [Error: usererror],
+  ],
+]
+`;
diff --git a/packages/react/src/next/__tests__/fetch.tsx b/packages/react/src/next/__tests__/fetch.tsx
new file mode 100644
index 00000000000..6562f442c61
--- /dev/null
+++ b/packages/react/src/next/__tests__/fetch.tsx
@@ -0,0 +1,291 @@
+import { ResolveType } from '@rest-hooks/core';
+import { CacheProvider } from '@rest-hooks/react';
+import { CacheProvider as ExternalCacheProvider } from '@rest-hooks/redux';
+import { act } from '@testing-library/react-hooks';
+import { CoolerArticle, FutureArticleResource } from '__tests__/new';
+import nock from 'nock';
+
+import { useCache, useSuspense } from '../..';
+// relative imports to avoid circular dependency in tsconfig references
+import { makeRenderRestHook, FixtureEndpoint } from '../../../../test';
+import useController from '../useController';
+
+export const payload = {
+  id: 5,
+  title: 'hi ho',
+  content: 'whatever',
+  tags: ['a', 'best', 'react'],
+};
+
+export const createPayload = {
+  id: 1,
+  title: 'hi ho',
+  content: 'whatever',
+  tags: ['a', 'best', 'react'],
+};
+
+export const nested = [
+  {
+    id: 5,
+    title: 'hi ho',
+    content: 'whatever',
+    tags: ['a', 'best', 'react'],
+    author: {
+      id: 23,
+      username: 'bob',
+    },
+  },
+  {
+    id: 3,
+    title: 'the next time',
+    content: 'whatever',
+    author: {
+      id: 23,
+      username: 'charles',
+      email: 'bob@bob.com',
+    },
+  },
+];
+
+describe.each([
+  ['CacheProvider', CacheProvider],
+  ['ExternalCacheProvider', ExternalCacheProvider],
+] as const)(`%s`, (_, makeProvider) => {
+  // TODO: add nested resource test case that has multiple partials to test merge functionality
+
+  let renderRestHook: ReturnType<typeof makeRenderRestHook>;
+  let mynock: nock.Scope;
+
+  beforeEach(() => {
+    nock(/.*/)
+      .persist()
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'application/json',
+      })
+      .options(/.*/)
+      .reply(200)
+      .get(`/article-cooler/${payload.id}`)
+      .reply(200, payload)
+      .delete(`/article-cooler/${payload.id}`)
+      .reply(204, '')
+      .delete(`/article/${payload.id}`)
+      .reply(200, {})
+      .get(`/article-cooler/0`)
+      .reply(403, {})
+      .get(`/article-cooler/666`)
+      .reply(200, '')
+      .get(`/article-cooler`)
+      .reply(200, nested)
+      .post(`/article-cooler`)
+      .reply(200, createPayload);
+
+    mynock = nock(/.*/).defaultReplyHeaders({
+      'Access-Control-Allow-Origin': '*',
+      'Content-Type': 'application/json',
+    });
+  });
+
+  afterEach(() => {
+    nock.cleanAll();
+  });
+
+  beforeEach(() => {
+    renderRestHook = makeRenderRestHook(makeProvider);
+  });
+
+  let errorspy: jest.SpyInstance;
+  beforeEach(() => {
+    errorspy = jest.spyOn(global.console, 'error');
+  });
+  afterEach(() => {
+    errorspy.mockRestore();
+  });
+
+  it('should fetch', async () => {
+    const { result } = renderRestHook(() => {
+      return {
+        data: useCache(FutureArticleResource.get, payload.id),
+        fetch: useController().fetch,
+      };
+    });
+    expect(result.current.data).toBeUndefined();
+    result.current.fetch(FutureArticleResource.get, payload.id);
+    result.current.fetch(FutureArticleResource.get, payload.id);
+    result.current.fetch(FutureArticleResource.get, payload.id);
+    const response = await result.current.fetch(
+      FutureArticleResource.get,
+      payload.id,
+    );
+    expect(result.current.data).toBeDefined();
+    expect(result.current.data?.content).toEqual(payload.content);
+    expect(response).toEqual(CoolerArticle.fromJS(payload));
+    expect(response.content).toBe(payload.content);
+
+    // @ts-expect-error
+    () => response.slkdf;
+
+    // type tests
+    // TODO: move these to own unit tests if/when applicable
+    () => {
+      // @ts-expect-error
+      result.current.fetch(FutureArticleResource.get);
+      // @ts-expect-error
+      result.current.fetch(FutureArticleResource.get, {
+        id: payload.id,
+      });
+      result.current.fetch(FutureArticleResource.create, payload);
+      // @ts-expect-error
+      result.current.fetch(FutureArticleResource.create, {}, payload);
+      result.current.fetch(FutureArticleResource.update, payload.id, payload);
+      // @ts-expect-error
+      result.current.fetch(FutureArticleResource.update, payload);
+    };
+  });
+
+  it('should fetch with resolver', async () => {
+    // we use this id because it is not nock'd
+    const id = 10000;
+    const fixture = {
+      endpoint: FutureArticleResource.get,
+      args: [10000],
+      response: payload,
+    };
+    const { result } = renderRestHook(
+      () => {
+        return {
+          data: useCache(FutureArticleResource.get, id),
+          fetch: useController().fetch,
+        };
+      },
+      { resolverFixtures: [fixture] },
+    );
+    expect(result.current.data).toBeUndefined();
+    result.current.fetch(FutureArticleResource.get, id);
+    result.current.fetch(FutureArticleResource.get, id);
+    result.current.fetch(FutureArticleResource.get, id);
+    await result.current.fetch(FutureArticleResource.get, id);
+  });
+
+  it('should update on create', async () => {
+    const endpoint = FutureArticleResource.create;
+    const response: ResolveType<typeof endpoint> = createPayload;
+    const fixtures: FixtureEndpoint[] = [
+      {
+        endpoint,
+        args: [{ id: 1 }],
+        response,
+      },
+    ];
+    // use nock, and use resolver
+    for (const resolverFixtures of [undefined, fixtures]) {
+      const { result, waitForNextUpdate } = renderRestHook(
+        () => {
+          const articles = useSuspense(FutureArticleResource.getList);
+          const fetch = useController().fetch;
+          return { articles, fetch };
+        },
+        { resolverFixtures },
+      );
+      await waitForNextUpdate();
+      await act(async () => {
+        const article = await result.current.fetch(
+          FutureArticleResource.create,
+          {
+            id: 1,
+          },
+        );
+        article.content;
+        // @ts-expect-error
+        article.asdf;
+        article.pk();
+      });
+
+      expect(result.current.articles.map(({ id }) => id)).toEqual([1, 5, 3]);
+    }
+  });
+
+  it('should log error message when user update method throws', async () => {
+    const endpoint = FutureArticleResource.create.extend({
+      update: () => {
+        throw new Error('usererror');
+      },
+    });
+    const response: ResolveType<typeof endpoint> = createPayload;
+    const fixtures: FixtureEndpoint[] = [
+      {
+        endpoint,
+        args: [{ id: 1 }],
+        response,
+      },
+    ];
+    const { result, waitForNextUpdate } = renderRestHook(
+      () => {
+        const articles = useSuspense(FutureArticleResource.getList);
+        const fetch = useController().fetch;
+        return { articles, fetch };
+      },
+      { resolverFixtures: fixtures },
+    );
+    await waitForNextUpdate();
+    await act(async () => {
+      await result.current.fetch(endpoint, {
+        id: 1,
+      });
+    }),
+      // still keeps old list
+      expect(result.current.articles.map(({ id }) => id)).toEqual([5, 3]);
+
+    expect(errorspy.mock.calls).toMatchSnapshot();
+  });
+
+  it('should not suspend once deleted and redirected at same time', async () => {
+    const temppayload = {
+      ...payload,
+      id: 1234,
+    };
+    mynock
+      .get(`/article-cooler/${temppayload.id}`)
+      .reply(200, temppayload)
+      .delete(`/article-cooler/${temppayload.id}`)
+      .reply(204, '');
+    const throws: Promise<any>[] = [];
+    const { result, waitForNextUpdate, rerender } = renderRestHook(
+      ({ id }) => {
+        try {
+          return [
+            useSuspense(FutureArticleResource.get, id) ?? null,
+            useController().fetch,
+          ] as const;
+        } catch (e: any) {
+          if (typeof e.then === 'function') {
+            if (e !== throws[throws.length - 1]) {
+              throws.push(e);
+            }
+          }
+          throw e;
+        }
+      },
+      { initialProps: { id: temppayload.id as number | null } },
+    );
+    expect(result.current).toBeUndefined();
+    await waitForNextUpdate();
+    const [data, fetch] = result.current;
+    expect(data).toBeInstanceOf(CoolerArticle);
+    expect(data?.title).toBe(temppayload.title);
+    expect(throws.length).toBe(1);
+
+    mynock
+      .persist()
+      .get(`/article-cooler/${temppayload.id}`)
+      .reply(200, { ...temppayload, title: 'othertitle' });
+
+    expect(throws.length).toBe(1);
+    await act(async () => {
+      await fetch(FutureArticleResource.delete, temppayload.id);
+      rerender({ id: null });
+    });
+    expect(throws.length).toBe(1);
+    expect(result.current[0]).toBe(null);
+  });
+});
diff --git a/packages/react/src/next/index.ts b/packages/react/src/next/index.ts
new file mode 100644
index 00000000000..e8a268f1ec5
--- /dev/null
+++ b/packages/react/src/next/index.ts
@@ -0,0 +1 @@
+export { default as useController } from './useController.js';
diff --git a/packages/react/src/next/useController.ts b/packages/react/src/next/useController.ts
new file mode 100644
index 00000000000..7037a569c5f
--- /dev/null
+++ b/packages/react/src/next/useController.ts
@@ -0,0 +1,19 @@
+// Server Side Component compatibility (specifying this cannot be used as such)
+// context does not work in server components
+// https://beta.nextjs.org/docs/rendering/server-and-client-components#third-party-packages
+'use client';
+import { Controller } from '@rest-hooks/core/next';
+import { useContext, useMemo } from 'react';
+
+import { ControllerContext } from '../context.js';
+
+/**
+ * Imperative control of Rest Hooks store
+ * @see https://resthooks.io/docs/api/useController
+ */
+export default function useController(): Controller {
+  const base = useContext(ControllerContext);
+  return useMemo(() => {
+    return new Controller(base);
+  }, [base]);
+}
diff --git a/packages/rest/package.json b/packages/rest/package.json
index 7e44bebbd71..9a70160d322 100644
--- a/packages/rest/package.json
+++ b/packages/rest/package.json
@@ -13,6 +13,9 @@
       "": [
         "lib/index.d.ts"
       ],
+      "next": [
+        "lib/next/index.d.ts"
+      ],
       "*": [
         "lib/index.d.ts"
       ]
@@ -21,6 +24,9 @@
       "": [
         "ts4.0/index.d.ts"
       ],
+      "next": [
+        "ts4.0/next/index.d.ts"
+      ],
       "*": [
         "ts4.0/index.d.ts"
       ]
@@ -35,6 +41,7 @@
     },
     "./next": {
       "types": "./lib/next/index.d.ts",
+      "require": "./dist/next.js",
       "default": "./lib/next/index.js"
     },
     "./package.json": "./package.json"
diff --git a/packages/rest/rollup.config.js b/packages/rest/rollup.config.js
index 1cc93072faa..35d512322fe 100644
--- a/packages/rest/rollup.config.js
+++ b/packages/rest/rollup.config.js
@@ -47,21 +47,26 @@ if (process.env.BROWSERSLIST_ENV !== 'node12') {
   configs.push(typeConfigNext);
 } else {
   // node-friendly commonjs build
-  configs.push({
-    input: 'lib/index.js',
-    external: isExternal,
-    output: [{ file: pkg.main, format: 'cjs' }],
-    plugins: [
-      babel({
-        exclude: ['node_modules/**', '**/__tests__/**', '**/*.d.ts'],
-        extensions: nativeExtensions,
-        rootMode: 'upward',
-        runtimeHelpers: true,
-      }),
-      replace({ 'process.env.CJS': 'true' }),
-      resolve({ extensions: nativeExtensions }),
-      commonjs({ extensions: nativeExtensions }),
-    ],
+  [
+    { input: 'lib/index.js', output: pkg.main },
+    { input: 'lib/next/index.js', output: 'dist/next.js' },
+  ].forEach(({ input, output }) => {
+    configs.push({
+      input,
+      external: isExternal,
+      output: [{ file: output, format: 'cjs' }],
+      plugins: [
+        babel({
+          exclude: ['node_modules/**', '**/__tests__/**', '**/*.d.ts'],
+          extensions: nativeExtensions,
+          rootMode: 'upward',
+          runtimeHelpers: true,
+        }),
+        replace({ 'process.env.CJS': 'true' }),
+        resolve({ extensions: nativeExtensions }),
+        commonjs({ extensions: nativeExtensions }),
+      ],
+    });
   });
 }
 export default configs;
diff --git a/packages/rest/src/next/index.ts b/packages/rest/src/next/index.ts
index 8ead72cdd37..f825ba03a0c 100644
--- a/packages/rest/src/next/index.ts
+++ b/packages/rest/src/next/index.ts
@@ -1,4 +1,4 @@
-export {
+export type {
   GetEndpoint,
   MutateEndpoint,
   NewGetEndpoint,
diff --git a/scripts/copywebsitetypes.sh b/scripts/copywebsitetypes.sh
index 0d011d52c6f..a78e787fd5b 100644
--- a/scripts/copywebsitetypes.sh
+++ b/scripts/copywebsitetypes.sh
@@ -6,4 +6,9 @@ cp ./packages/hooks/index.d.ts ./website/src/components/Playground/editor-types/
 cp ./packages/normalizr/index.d.ts ./website/src/components/Playground/editor-types/@rest-hooks/normalizr.d.ts
 cp ./packages/react/index.d.ts ./website/src/components/Playground/editor-types/@rest-hooks/react.d.ts
 cp ./packages/rest/index.d.ts ./website/src/components/Playground/editor-types/@rest-hooks/rest.d.ts
+mkdir -p ./website/src/components/Playground/editor-types/@rest-hooks/rest
+mkdir -p ./website/src/components/Playground/editor-types/@rest-hooks/core
+mkdir -p ./website/src/components/Playground/editor-types/@rest-hooks/react
 cp ./packages/rest/next.d.ts ./website/src/components/Playground/editor-types/@rest-hooks/rest/next.d.ts
+cp ./packages/core/next.d.ts ./website/src/components/Playground/editor-types/@rest-hooks/core/next.d.ts
+cp ./packages/react/next.d.ts ./website/src/components/Playground/editor-types/@rest-hooks/react/next.d.ts
diff --git a/website/src/components/Playground/editor-types/@rest-hooks/core.d.ts b/website/src/components/Playground/editor-types/@rest-hooks/core.d.ts
index 1ed3054f6d5..8fe48f2da8b 100644
--- a/website/src/components/Playground/editor-types/@rest-hooks/core.d.ts
+++ b/website/src/components/Playground/editor-types/@rest-hooks/core.d.ts
@@ -700,7 +700,7 @@ interface ConstructorProps<D extends GenericDispatch = CompatibleDispatch> {
  * Imperative control of Rest Hooks store
  * @see https://resthooks.io/docs/api/Controller
  */
-declare class Controller<D extends GenericDispatch = CompatibleDispatch> {
+declare class Controller$1<D extends GenericDispatch = CompatibleDispatch> {
     /**
      * Dispatches an action to Rest Hooks reducer.
      *
@@ -718,13 +718,6 @@ declare class Controller<D extends GenericDispatch = CompatibleDispatch> {
     readonly globalCache: DenormalizeCache;
     constructor({ dispatch, getState, globalCache, }?: ConstructorProps<D>);
     /*************** Action Dispatchers ***************/
-    /**
-     * Fetches the endpoint with given args, updating the Rest Hooks cache with the response or error upon completion.
-     * @see https://resthooks.io/docs/api/Controller#fetch
-     */
-    fetch: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
-        update?: EndpointUpdateFunction<E> | undefined;
-    }>(endpoint: E, ...args_0: Parameters<E>) => ReturnType<E>;
     /**
      * Forces refetching and suspense on useSuspense with the same Endpoint and parameters.
      * @see https://resthooks.io/docs/api/Controller#invalidate
@@ -816,6 +809,16 @@ declare class Controller<D extends GenericDispatch = CompatibleDispatch> {
     private getResults;
 }
 
+declare class Controller<D extends GenericDispatch = CompatibleDispatch> extends Controller$1<D> {
+    /**
+     * Fetches the endpoint with given args, updating the Rest Hooks cache with the response or error upon completion.
+     * @see https://resthooks.io/docs/api/Controller#fetch
+     */
+    fetch: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, ...args_0: Parameters<E>) => ReturnType<E>;
+}
+
 declare function createReducer(controller: Controller): ReducerType;
 declare const initialState: State<unknown>;
 type ReducerType = (state: State<unknown> | undefined, action: ActionTypes) => State<unknown>;
diff --git a/website/src/components/Playground/editor-types/@rest-hooks/core/next.d.ts b/website/src/components/Playground/editor-types/@rest-hooks/core/next.d.ts
new file mode 100644
index 00000000000..215d69cb016
--- /dev/null
+++ b/website/src/components/Playground/editor-types/@rest-hooks/core/next.d.ts
@@ -0,0 +1,633 @@
+import { ErrorFluxStandardActionWithPayloadAndMeta, FSA, FSAWithPayloadAndMeta, FSAWithMeta } from 'flux-standard-action';
+
+type Schema = null | string | {
+    [K: string]: any;
+} | Schema[] | SchemaSimple | Serializable;
+type Serializable<T extends {
+    toJSON(): string;
+} = {
+    toJSON(): string;
+}> = {
+    prototype: T;
+};
+interface SchemaSimple<T = any> {
+    normalize(input: any, parent: any, key: any, visit: (...args: any) => any, addEntity: (...args: any) => any, visitedEntities: Record<string, any>): any;
+    denormalize(input: {}, unvisit: UnvisitFunction): [denormalized: T, found: boolean, suspend: boolean];
+    infer(args: readonly any[], indexes: NormalizedIndex, recurse: (...args: any) => any, entities: EntityTable): any;
+}
+interface SchemaClass<T = any, N = T | undefined> extends SchemaSimple<T> {
+    _normalizeNullable(): any;
+    _denormalizeNullable(): [N, boolean, boolean];
+}
+interface EntityInterface<T = any> extends SchemaSimple {
+    createIfValid?(props: any): any;
+    pk(params: any, parent?: any, key?: string): string | undefined;
+    readonly key: string;
+    merge(existing: any, incoming: any): any;
+    expiresAt?(meta: any, input: any): number;
+    mergeWithStore?(existingMeta: any, incomingMeta: any, existing: any, incoming: any): any;
+    useIncoming?(existingMeta: any, incomingMeta: any, existing: any, incoming: any): boolean;
+    indexes?: any;
+    schema: Record<string, Schema>;
+    prototype: T;
+}
+interface UnvisitFunction {
+    (input: any, schema: any): [any, boolean, boolean];
+    og?: UnvisitFunction;
+    setLocal?: (entity: any) => void;
+}
+interface NormalizedIndex {
+    readonly [entityKey: string]: {
+        readonly [indexName: string]: {
+            readonly [lookup: string]: string;
+        };
+    };
+}
+interface EntityTable {
+    [entityKey: string]: {
+        [pk: string]: unknown;
+    } | undefined;
+}
+
+/** Maps entity dependencies to a value (usually their denormalized form)
+ *
+ * Dependencies store `Path` to enable quick traversal using only `State`
+ * If *any* members of the dependency get cleaned up, so does that key/value pair get removed.
+ */
+declare class WeakEntityMap<K extends object, V> {
+    readonly next: WeakMap<K, Link<K, V>>;
+    get(entity: K, getEntity: GetEntity<K | symbol>): readonly [undefined, undefined] | [V, Path[]];
+    set(dependencies: Dep<K>[], value: V): void;
+}
+type GetEntity<K = object | symbol> = (lookup: Path) => K;
+/** Link in a chain */
+declare class Link<K extends object, V> {
+    next: WeakMap<K, Link<K, V>>;
+    value?: V;
+    journey?: Path[];
+    nextPath?: Path;
+}
+interface Dep<K = object> {
+    path: Path;
+    entity: K;
+}
+
+interface Path {
+    key: string;
+    pk: string;
+}
+type AbstractInstanceType<T> = T extends new (...args: any) => infer U ? U : T extends {
+    prototype: infer U;
+} ? U : never;
+type DenormalizeObject<S extends Record<string, any>> = {
+    [K in keyof S]: S[K] extends Schema ? Denormalize$1<S[K]> : S[K];
+};
+type DenormalizeNullableObject<S extends Record<string, any>> = {
+    [K in keyof S]: S[K] extends Schema ? DenormalizeNullable$1<S[K]> : S[K];
+};
+type NormalizeObject<S extends Record<string, any>> = {
+    [K in keyof S]: S[K] extends Schema ? Normalize$1<S[K]> : S[K];
+};
+interface NestedSchemaClass<T = any> {
+    schema: Record<string, Schema>;
+    prototype: T;
+}
+interface RecordClass<T = any> extends NestedSchemaClass<T> {
+    fromJS: (...args: any) => AbstractInstanceType<T>;
+}
+interface DenormalizeCache {
+    entities: {
+        [key: string]: {
+            [pk: string]: WeakMap<EntityInterface, WeakEntityMap<object, any>>;
+        };
+    };
+    results: {
+        [key: string]: WeakEntityMap<object, any>;
+    };
+}
+type DenormalizeNullableNestedSchema<S extends NestedSchemaClass> = keyof S['schema'] extends never ? S['prototype'] : string extends keyof S['schema'] ? S['prototype'] : S['prototype'];
+type DenormalizeReturnType<T> = T extends (input: any, unvisit: any) => [infer R, any, any] ? R : never;
+type NormalizeReturnType<T> = T extends (...args: any) => infer R ? R : never;
+type Denormalize$1<S> = S extends EntityInterface<infer U> ? U : S extends RecordClass ? AbstractInstanceType<S> : S extends SchemaClass ? DenormalizeReturnType<S['denormalize']> : S extends Serializable<infer T> ? T : S extends Array<infer F> ? Denormalize$1<F>[] : S extends {
+    [K: string]: any;
+} ? DenormalizeObject<S> : S;
+type DenormalizeNullable$1<S> = S extends EntityInterface<any> ? DenormalizeNullableNestedSchema<S> | undefined : S extends RecordClass ? DenormalizeNullableNestedSchema<S> : S extends SchemaClass ? DenormalizeReturnType<S['_denormalizeNullable']> : S extends Serializable<infer T> ? T : S extends Array<infer F> ? Denormalize$1<F>[] | undefined : S extends {
+    [K: string]: any;
+} ? DenormalizeNullableObject<S> : S;
+type Normalize$1<S> = S extends EntityInterface ? string : S extends RecordClass ? NormalizeObject<S['schema']> : S extends SchemaClass ? NormalizeReturnType<S['normalize']> : S extends Serializable<infer T> ? T : S extends Array<infer F> ? Normalize$1<F>[] : S extends {
+    [K: string]: any;
+} ? NormalizeObject<S> : S;
+
+interface NetworkError extends Error {
+    status: number;
+    response?: Response;
+}
+interface UnknownError extends Error {
+    status?: unknown;
+    response?: unknown;
+}
+type ErrorTypes = NetworkError | UnknownError;
+
+/** What the function's promise resolves to */
+type ResolveType<E extends (...args: any) => any> = ReturnType<E> extends Promise<infer R> ? R : never;
+/** Fallback to schema if fetch function isn't defined */
+type InferReturn<F extends FetchFunction, S extends Schema | undefined> = S extends undefined ? ReturnType<F> : ReturnType<F> extends unknown ? Promise<Denormalize$1<S>> : ReturnType<F>;
+
+declare const enum ExpiryStatus {
+    Invalid = 1,
+    InvalidIfStale = 2,
+    Valid = 3
+}
+type ExpiryStatusInterface = 1 | 2 | 3;
+
+interface SnapshotInterface {
+    getResponse: <E extends Pick<EndpointInterface, 'key' | 'schema' | 'invalidIfStale'>, Args extends readonly [...Parameters<E['key']>]>(endpoint: E, ...args: Args) => {
+        data: any;
+        expiryStatus: ExpiryStatusInterface;
+        expiresAt: number;
+    };
+    getError: <E extends Pick<EndpointInterface, 'key'>, Args extends readonly [...Parameters<E['key']>]>(endpoint: E, ...args: Args) => ErrorTypes | undefined;
+    readonly fetchedAt: number;
+}
+
+/** Defines a networking endpoint */
+interface EndpointInterface<F extends FetchFunction = FetchFunction, S extends Schema | undefined = Schema | undefined, M extends boolean | undefined = boolean | undefined> extends EndpointExtraOptions<F> {
+    (...args: Parameters<F>): InferReturn<F, S>;
+    key(...args: Parameters<F>): string;
+    readonly sideEffect?: M;
+    readonly schema?: S;
+}
+interface EndpointExtraOptions<F extends FetchFunction = FetchFunction> {
+    /** Default data expiry length, will fall back to NetworkManager default if not defined */
+    readonly dataExpiryLength?: number;
+    /** Default error expiry length, will fall back to NetworkManager default if not defined */
+    readonly errorExpiryLength?: number;
+    /** Poll with at least this frequency in miliseconds */
+    readonly pollFrequency?: number;
+    /** Marks cached resources as invalid if they are stale */
+    readonly invalidIfStale?: boolean;
+    /** Enables optimistic updates for this request - uses return value as assumed network response
+     * @deprecated use https://resthooks.io/docs/api/Endpoint#getoptimisticresponse instead
+     */
+    optimisticUpdate?(...args: Parameters<F>): ResolveType<F>;
+    /** Enables optimistic updates for this request - uses return value as assumed network response */
+    getOptimisticResponse?(snap: SnapshotInterface, ...args: Parameters<F>): ResolveType<F>;
+    /** Determines whether to throw or fallback to */
+    errorPolicy?(error: any): 'hard' | 'soft' | undefined;
+    /** User-land extra data to send */
+    readonly extra?: any;
+}
+type UpdateFunction<SourceSchema extends Schema | undefined, DestSchema extends Schema> = (sourceResults: Normalize$1<SourceSchema>, destResults: Normalize$1<DestSchema> | undefined) => Normalize$1<DestSchema>;
+
+type FetchFunction<A extends readonly any[] = any, R = any> = (...args: A) => Promise<R>;
+
+/** This file exists to keep compatibility with SchemaDetail, and SchemaList type hacks
+ * Support can be dropped once @rest-hooks/rest@5 support is dropped
+ */
+
+type Denormalize<S> = Extract<S, EntityInterface> extends never ? Extract<S, EntityInterface[]> extends never ? Denormalize$1<S> : Denormalize$1<Extract<S, EntityInterface[]>> : Denormalize$1<Extract<S, EntityInterface>>;
+type DenormalizeNullable<S> = Extract<S, EntityInterface> extends never ? Extract<S, EntityInterface[]> extends never ? DenormalizeNullable$1<S> : DenormalizeNullable$1<Extract<S, EntityInterface[]>> : DenormalizeNullable$1<Extract<S, EntityInterface>>;
+type Normalize<S> = Extract<S, EntityInterface> extends never ? Extract<S, EntityInterface[]> extends never ? Normalize$1<S> : Normalize$1<Extract<S, EntityInterface[]>> : Normalize$1<Extract<S, EntityInterface>>;
+
+type ResultEntry<E extends EndpointInterface> = E['schema'] extends undefined | null ? ResolveType<E> : Normalize<E>;
+type EndpointUpdateFunction<Source extends EndpointInterface, Updaters extends Record<string, any> = Record<string, any>> = (source: ResultEntry<Source>, ...args: any) => {
+    [K in keyof Updaters]: (result: Updaters[K]) => Updaters[K];
+};
+
+declare const FETCH_TYPE: "rest-hooks/fetch";
+declare const RECEIVE_TYPE: "rest-hooks/receive";
+declare const SET_TYPE: "rest-hooks/receive";
+declare const OPTIMISTIC_TYPE: "rest-hooks/optimistic";
+declare const RESET_TYPE: "rest-hooks/reset";
+declare const SUBSCRIBE_TYPE: "rest-hooks/subscribe";
+declare const UNSUBSCRIBE_TYPE: "rest-hook/unsubscribe";
+declare const INVALIDATE_TYPE: "rest-hooks/invalidate";
+declare const GC_TYPE: "rest-hooks/gc";
+
+interface ReceiveMeta$2 {
+    args: readonly any[];
+    fetchedAt: number;
+    date: number;
+    expiresAt: number;
+}
+interface ReceiveActionSuccess<E extends EndpointInterface = EndpointInterface> {
+    type: typeof SET_TYPE;
+    endpoint: E;
+    meta: ReceiveMeta$2;
+    payload: ResolveType<E>;
+    error?: false;
+}
+interface ReceiveActionError<E extends EndpointInterface = EndpointInterface> {
+    type: typeof SET_TYPE;
+    endpoint: E;
+    meta: ReceiveMeta$2;
+    payload: UnknownError;
+    error: true;
+}
+interface FetchMeta$1 {
+    args: readonly any[];
+    throttle: boolean;
+    resolve: (value?: any | PromiseLike<any>) => void;
+    reject: (reason?: any) => void;
+    promise: PromiseLike<any>;
+    createdAt: number;
+    nm?: boolean;
+}
+interface FetchAction$2<E extends EndpointInterface = EndpointInterface> {
+    type: typeof FETCH_TYPE;
+    endpoint: E;
+    meta: FetchMeta$1;
+    payload: () => ReturnType<E>;
+}
+interface OptimisticAction$2<E extends EndpointInterface & {
+    update?: EndpointUpdateFunction<E>;
+} = EndpointInterface & {
+    update?: EndpointUpdateFunction<EndpointInterface>;
+}> {
+    type: typeof OPTIMISTIC_TYPE;
+    endpoint: E;
+    meta: ReceiveMeta$2;
+    error?: boolean;
+}
+interface SubscribeAction$2<E extends EndpointInterface = EndpointInterface> {
+    type: typeof SUBSCRIBE_TYPE;
+    endpoint: E;
+    meta: {
+        args: readonly any[];
+    };
+}
+interface UnsubscribeAction$2<E extends EndpointInterface = EndpointInterface> {
+    type: typeof UNSUBSCRIBE_TYPE;
+    endpoint: E;
+    meta: {
+        args: readonly any[];
+    };
+}
+interface InvalidateAction$1 {
+    type: typeof INVALIDATE_TYPE;
+    meta: {
+        key: string;
+    };
+}
+interface ResetAction$2 {
+    type: typeof RESET_TYPE;
+    date: number;
+}
+interface GCAction$1 {
+    type: typeof GC_TYPE;
+    entities: [string, string][];
+    results: string[];
+}
+
+interface CompatibleFetchMeta extends FetchMeta$1 {
+    key: string;
+    schema?: Schema;
+    type: 'mutate' | 'read';
+    update?: (result: any, ...args: any) => Record<string, (...args: any) => any>;
+    options?: EndpointExtraOptions;
+    optimisticResponse?: {};
+}
+interface CompatibleFetchAction<E extends EndpointInterface = EndpointInterface> extends FetchAction$2<E> {
+    meta: CompatibleFetchMeta;
+}
+interface CompatibleReceiveMeta extends ReceiveMeta$2 {
+    key: string;
+    schema?: any;
+    update?: (result: any, ...args: any) => Record<string, (...args: any) => any>;
+    errorPolicy?: (error: any) => 'hard' | 'soft' | undefined;
+}
+interface CompatibleReceiveActionSuccess<E extends EndpointInterface = EndpointInterface> extends ReceiveActionSuccess<E> {
+    meta: CompatibleReceiveMeta;
+    payload: any;
+}
+interface CompatibleReceiveActionError<E extends EndpointInterface = EndpointInterface> extends ReceiveActionError<E> {
+    meta: CompatibleReceiveMeta;
+    payload: any;
+}
+type CompatibleReceiveAction<E extends EndpointInterface = EndpointInterface> = CompatibleReceiveActionSuccess<E> | CompatibleReceiveActionError<E>;
+interface CompatibleSubscribeAction<E extends EndpointInterface = EndpointInterface> extends SubscribeAction$2<E> {
+    meta: {
+        args: readonly any[];
+        schema: Schema | undefined;
+        fetch: () => Promise<any>;
+        key: string;
+        options: EndpointExtraOptions | undefined;
+    };
+}
+interface CompatibleUnsubscribeAction<E extends EndpointInterface = EndpointInterface> extends UnsubscribeAction$2<E> {
+    meta: {
+        args: readonly any[];
+        key: string;
+        options: EndpointExtraOptions | undefined;
+    };
+}
+
+/** Defines the shape of a network request */
+interface FetchShape<S extends Schema | undefined, Params extends Readonly<object> = Readonly<object>, Body extends Readonly<object | string> | void | unknown = Readonly<object | string> | undefined, Response = any> {
+    readonly type: 'read' | 'mutate' | 'delete';
+    fetch(params: Params, body?: Body): Promise<Response>;
+    getFetchKey(params: Params): string;
+    readonly schema: S;
+    readonly options?: EndpointExtraOptions;
+}
+
+type ErrorableFSAWithPayloadAndMeta<Type extends string = string, Payload = undefined, Meta = undefined, CustomError extends Error = Error> = ErrorFluxStandardActionWithPayloadAndMeta<Type, CustomError, Meta> | NoErrorFluxStandardActionWithPayloadAndMeta<Type, Payload, Meta>;
+interface NoErrorFluxStandardAction<Type extends string = string, Payload = undefined, Meta = undefined> extends FSA<Type, Payload, Meta> {
+    error?: false;
+}
+/**
+ * A Flux Standard action with a required payload property.
+ */
+interface NoErrorFluxStandardActionWithPayload<Type extends string = string, Payload = undefined, Meta = undefined> extends NoErrorFluxStandardAction<Type, Payload, Meta> {
+    /**
+     * The required `payload` property MAY be any type of value.
+     * It represents the payload of the action.
+     * Any information about the action that is not the type or status of the action should be part of the `payload` field.
+     * By convention, if `error` is `true`, the `payload` SHOULD be an error object.
+     * This is akin to rejecting a promise with an error object.
+     */
+    payload: Payload;
+}
+/**
+ * A Flux Standard action with a required metadata property.
+ */
+interface NoErrorFluxStandardActionWithMeta<Type extends string = string, Payload = undefined, Meta = undefined> extends NoErrorFluxStandardAction<Type, Payload, Meta> {
+    /**
+     * The required `meta` property MAY be any type of value.
+     * It is intended for any extra information that is not part of the payload.
+     */
+    meta: Meta;
+}
+/**
+ * A Flux Standard action with required payload and metadata properties.
+ */
+type NoErrorFluxStandardActionWithPayloadAndMeta<Type extends string = string, Payload = undefined, Meta = undefined> = NoErrorFluxStandardActionWithPayload<Type, Payload, Meta> & NoErrorFluxStandardActionWithMeta<Type, Payload, Meta>;
+
+interface ReceiveMeta$1<S extends Schema | undefined> {
+    schema?: S;
+    key: string;
+    args?: readonly any[];
+    updaters?: Record<string, UpdateFunction<S, any>>;
+    update?: (result: any, ...args: any) => Record<string, (...args: any) => any>;
+    fetchedAt?: number;
+    date: number;
+    expiresAt: number;
+    errorPolicy?: (error: any) => 'hard' | 'soft' | undefined;
+}
+type ReceiveAction$2<Payload extends object | string | number | null = object | string | number | null, S extends Schema | undefined = any> = ErrorableFSAWithPayloadAndMeta<typeof RECEIVE_TYPE, Payload, ReceiveMeta$1<S>>;
+interface ResetAction$1 {
+    type: typeof RESET_TYPE;
+    date: number | Date;
+}
+interface FetchMeta<Payload extends object | string | number | null = object | string | number | null, S extends Schema | undefined = any> {
+    type: FetchShape<any, any>['type'];
+    schema?: S;
+    key: string;
+    args?: readonly any[];
+    updaters?: Record<string, UpdateFunction<S, any>>;
+    update?: (result: any, ...args: any) => Record<string, (...args: any) => any>;
+    options?: EndpointExtraOptions;
+    throttle: boolean;
+    resolve: (value?: any | PromiseLike<any>) => void;
+    reject: (reason?: any) => void;
+    promise: PromiseLike<any>;
+    createdAt: number | Date;
+    optimisticResponse?: Payload;
+    nm?: boolean;
+}
+interface FetchAction$1<Payload extends object | string | number | null = object | string | number | null, S extends Schema | undefined = any> extends FSAWithPayloadAndMeta<typeof FETCH_TYPE, () => Promise<Payload>, FetchMeta<any, any>> {
+    meta: FetchMeta<Payload, S>;
+    endpoint?: undefined;
+}
+interface SubscribeAction$1 extends FSAWithMeta<typeof SUBSCRIBE_TYPE, undefined, any> {
+    meta: {
+        args?: readonly any[];
+        schema: Schema | undefined;
+        fetch: () => Promise<any>;
+        key: string;
+        options: EndpointExtraOptions | undefined;
+    };
+    endpoint?: undefined;
+}
+interface UnsubscribeAction$1 extends FSAWithMeta<typeof UNSUBSCRIBE_TYPE, undefined, any> {
+    meta: {
+        args?: readonly any[];
+        key: string;
+        options: EndpointExtraOptions | undefined;
+    };
+    endpoint?: undefined;
+}
+
+interface ReceiveMeta<S extends Schema | undefined> {
+    schema?: S;
+    key: string;
+    args?: readonly any[];
+    updaters?: Record<string, UpdateFunction<S, any>>;
+    update?: (result: any, ...args: any) => Record<string, (...args: any) => any>;
+    fetchedAt?: number;
+    date: number;
+    expiresAt: number;
+    errorPolicy?: (error: any) => 'hard' | 'soft' | undefined;
+}
+type ReceiveAction$1<Payload extends object | string | number | null = object | string | number | null, S extends Schema | undefined = any> = ErrorableFSAWithPayloadAndMeta<typeof RECEIVE_TYPE, Payload, ReceiveMeta<S>> & {
+    endpoint?: EndpointInterface;
+};
+type OptimisticAction$1<E extends EndpointInterface & {
+    update?: EndpointUpdateFunction<E>;
+} = EndpointInterface & {
+    update?: EndpointUpdateFunction<EndpointInterface>;
+}> = {
+    type: typeof OPTIMISTIC_TYPE;
+    meta: {
+        schema: E['schema'];
+        key: string;
+        args: readonly any[];
+        update?: (result: any, ...args: any) => Record<string, (...args: any) => any>;
+        fetchedAt: number;
+        date: number;
+        expiresAt: number;
+        errorPolicy?: (error: any) => 'hard' | 'soft' | undefined;
+    };
+    endpoint: E;
+    error?: undefined;
+};
+
+type PK = string;
+interface State<T> {
+    readonly entities: {
+        readonly [entityKey: string]: {
+            readonly [pk: string]: T;
+        } | undefined;
+    };
+    readonly indexes: NormalizedIndex;
+    readonly results: {
+        readonly [key: string]: unknown | PK[] | PK | undefined;
+    };
+    readonly meta: {
+        readonly [key: string]: {
+            readonly date: number;
+            readonly error?: ErrorTypes;
+            readonly expiresAt: number;
+            readonly prevExpiresAt?: number;
+            readonly invalidated?: boolean;
+            readonly errorPolicy?: 'hard' | 'soft' | undefined;
+        };
+    };
+    readonly entityMeta: {
+        readonly [entityKey: string]: {
+            readonly [pk: string]: {
+                readonly date: number;
+                readonly expiresAt: number;
+                readonly fetchedAt: number;
+            };
+        };
+    };
+    readonly optimistic: (ReceiveAction$1 | OptimisticAction$1)[];
+    readonly lastReset: Date | number;
+}
+
+type OptimisticAction<E extends EndpointInterface & {
+    update?: EndpointUpdateFunction<E>;
+} = EndpointInterface & {
+    update?: EndpointUpdateFunction<EndpointInterface>;
+}> = OptimisticAction$2<E>;
+type InvalidateAction = InvalidateAction$1;
+type ResetAction = ResetAction$2 | ResetAction$1;
+type GCAction = GCAction$1;
+type FetchAction<Payload extends object | string | number | null = object | string | number | null, S extends Schema | undefined = any> = CompatibleFetchAction | FetchAction$1<Payload, S>;
+type ReceiveAction<Payload extends object | string | number | null = object | string | number | null, S extends Schema | undefined = any> = CompatibleReceiveAction | ReceiveAction$2<Payload, S>;
+type SubscribeAction = CompatibleSubscribeAction | SubscribeAction$1;
+type UnsubscribeAction = CompatibleUnsubscribeAction | UnsubscribeAction$1;
+type CombinedActionTypes = OptimisticAction | InvalidateAction | ResetAction | GCAction | FetchAction | ReceiveAction | SubscribeAction | UnsubscribeAction;
+
+type GenericDispatch = (value: any) => Promise<void>;
+type CompatibleDispatch = (value: CombinedActionTypes) => Promise<void>;
+interface ConstructorProps<D extends GenericDispatch = CompatibleDispatch> {
+    dispatch?: D;
+    getState?: () => State<unknown>;
+    globalCache?: DenormalizeCache;
+}
+/**
+ * Imperative control of Rest Hooks store
+ * @see https://resthooks.io/docs/api/Controller
+ */
+declare class Controller$1<D extends GenericDispatch = CompatibleDispatch> {
+    /**
+     * Dispatches an action to Rest Hooks reducer.
+     *
+     * @see https://resthooks.io/docs/api/Controller#dispatch
+     */
+    readonly dispatch: D;
+    /**
+     * Gets the latest state snapshot that is fully committed.
+     *
+     * This can be useful for imperative use-cases like event handlers.
+     * This should *not* be used to render; instead useSuspense() or useCache()
+     * @see https://resthooks.io/docs/api/Controller#getState
+     */
+    readonly getState: () => State<unknown>;
+    readonly globalCache: DenormalizeCache;
+    constructor({ dispatch, getState, globalCache, }?: ConstructorProps<D>);
+    /*************** Action Dispatchers ***************/
+    /**
+     * Forces refetching and suspense on useSuspense with the same Endpoint and parameters.
+     * @see https://resthooks.io/docs/api/Controller#invalidate
+     */
+    invalidate: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined>>(endpoint: E, ...args: readonly [...Parameters<E>] | readonly [null]) => Promise<void>;
+    /**
+     * Forces refetching and suspense on useSuspense on all matching endpoint result keys.
+     * @see https://resthooks.io/docs/api/Controller#invalidateAll
+     */
+    invalidateAll: (options: {
+        testKey: (key: string) => boolean;
+    }) => Promise<void>;
+    /**
+     * Resets the entire Rest Hooks cache. All inflight requests will not resolve.
+     * @see https://resthooks.io/docs/api/Controller#resetEntireStore
+     */
+    resetEntireStore: () => Promise<void>;
+    /**
+     * Stores response in cache for given Endpoint and args.
+     * @see https://resthooks.io/docs/api/Controller#set
+     */
+    setResponse: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, ...rest: readonly [...Parameters<E>, any]) => Promise<void>;
+    /**
+     * Another name for setResponse
+     * @see https://resthooks.io/docs/api/Controller#setResponse
+     */
+    receive: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, ...rest: readonly [...Parameters<E>, any]) => Promise<void>;
+    /**
+     * Stores the result of Endpoint and args as the error provided.
+     * @see https://resthooks.io/docs/api/Controller#setError
+     */
+    setError: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, ...rest: readonly [...Parameters<E>, Error]) => Promise<void>;
+    /**
+     * Another name for setError
+     * @see https://resthooks.io/docs/api/Controller#setError
+     */
+    receiveError: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, ...rest: readonly [...Parameters<E>, Error]) => Promise<void>;
+    /**
+     * Resolves an inflight fetch. `fetchedAt` should `fetch`'s `createdAt`
+     * @see https://resthooks.io/docs/api/Controller#resolve
+     */
+    resolve: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, meta: {
+        args: readonly [...Parameters<E>];
+        response: Error;
+        fetchedAt: number;
+        error: true;
+    } | {
+        args: readonly [...Parameters<E>];
+        response: any;
+        fetchedAt: number;
+        error?: false | undefined;
+    }) => Promise<void>;
+    /**
+     * Marks a new subscription to a given Endpoint.
+     * @see https://resthooks.io/docs/api/Controller#subscribe
+     */
+    subscribe: <E extends EndpointInterface<FetchFunction, Schema | undefined, false | undefined>>(endpoint: E, ...args: readonly [null] | readonly [...Parameters<E>]) => Promise<void>;
+    /**
+     * Marks completion of subscription to a given Endpoint.
+     * @see https://resthooks.io/docs/api/Controller#unsubscribe
+     */
+    unsubscribe: <E extends EndpointInterface<FetchFunction, Schema | undefined, false | undefined>>(endpoint: E, ...args: readonly [null] | readonly [...Parameters<E>]) => Promise<void>;
+    /*************** More ***************/
+    snapshot: (state: State<unknown>, fetchedAt?: number) => SnapshotInterface;
+    /**
+     * Gets the error, if any, for a given endpoint. Returns undefined for no errors.
+     * @see https://resthooks.io/docs/api/Controller#getError
+     */
+    getError: <E extends Pick<EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined>, "key">, Args extends readonly [null] | readonly [...Parameters<E["key"]>]>(endpoint: E, ...rest: [...Args, State<unknown>]) => ErrorTypes | undefined;
+    /**
+     * Gets the (globally referentially stable) response for a given endpoint/args pair from state given.
+     * @see https://resthooks.io/docs/api/Controller#getResponse
+     */
+    getResponse: <E extends Pick<EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined>, "schema" | "key" | "invalidIfStale">, Args extends readonly [null] | readonly [...Parameters<E["key"]>]>(endpoint: E, ...rest: [...Args, State<unknown>]) => {
+        data: DenormalizeNullable<E["schema"]>;
+        expiryStatus: ExpiryStatus;
+        expiresAt: number;
+    };
+    private getResults;
+}
+
+declare class Controller<D extends GenericDispatch = CompatibleDispatch> extends Controller$1<D> {
+    /**
+     * Fetches the endpoint with given args, updating the Rest Hooks cache with the response or error upon completion.
+     * @see https://resthooks.io/docs/api/Controller#fetch
+     */
+    fetch: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, ...args_0: Parameters<E>) => E["schema"] extends null | undefined ? ReturnType<E> : Promise<Denormalize<E["schema"]>>;
+}
+
+export { Controller };
diff --git a/website/src/components/Playground/editor-types/@rest-hooks/react/next.d.ts b/website/src/components/Playground/editor-types/@rest-hooks/react/next.d.ts
new file mode 100644
index 00000000000..822c607da30
--- /dev/null
+++ b/website/src/components/Playground/editor-types/@rest-hooks/react/next.d.ts
@@ -0,0 +1,9 @@
+import { Controller } from '@rest-hooks/core/next';
+
+/**
+ * Imperative control of Rest Hooks store
+ * @see https://resthooks.io/docs/api/useController
+ */
+declare function useController(): Controller;
+
+export { useController };
diff --git a/website/src/components/Playground/monaco-init.ts b/website/src/components/Playground/monaco-init.ts
index 09a15fa1de7..43c6fdf4938 100644
--- a/website/src/components/Playground/monaco-init.ts
+++ b/website/src/components/Playground/monaco-init.ts
@@ -9,6 +9,8 @@ if (
   const rhDeps = [
     'rest',
     'rest/next',
+    'react/next',
+    'core/next',
     'core',
     'react',
     'endpoint',