diff --git a/src/__tests__/api.test.ts b/src/__tests__/api.test.ts
new file mode 100644
index 00000000..51a8c380
--- /dev/null
+++ b/src/__tests__/api.test.ts
@@ -0,0 +1,13 @@
+import { simpleIntrospection } from './fixtures/simpleIntrospection';
+import { $tada } from '../namespace';
+import { graphql } from '../api';
+
+declare module '../api' {
+  interface setupSchema {
+    introspection: typeof simpleIntrospection;
+  }
+}
+
+const fragment = graphql('fragment Test on Query { __typename }');
+
+const document = graphql('{ ...Test }', [fragment]);
diff --git a/src/__tests__/fragments.test-d.ts b/src/__tests__/fragments.test-d.ts
deleted file mode 100644
index 0d1a4f50..00000000
--- a/src/__tests__/fragments.test-d.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { assertType, test } from 'vitest';
-import { simpleIntrospection } from './fixtures/simpleIntrospection';
-import { parseDocument } from '../parser';
-import { mapIntrospection } from '../introspection';
-import { getFragmentType } from '../selection';
-
-type introspection = mapIntrospection<typeof simpleIntrospection>;
-
-const any = {} as any;
-
-test('creates a type for a given fragment', () => {
-  const unionQuery = `
-  fragment Fields on Todo {
-    id
-    text
-    complete
-    __typename
-  }
-`;
-
-  type doc = parseDocument<typeof unionQuery>;
-  type typedDoc = getFragmentType<doc, introspection>;
-
-  const actual = any as typedDoc;
-
-  assertType<{
-    id: string | number;
-    text: string;
-    complete: boolean | null;
-    __typename: 'Todo';
-  }>(actual);
-});
diff --git a/src/__tests__/parser.test-d.ts b/src/__tests__/parser.test-d.ts
index d0bb96fe..d3073e35 100644
--- a/src/__tests__/parser.test-d.ts
+++ b/src/__tests__/parser.test-d.ts
@@ -854,9 +854,10 @@ describe('parseDocument', () => {
   it('parses kitchen sink query', () => {
     type kitchensinkQuery = typeof import('./fixtures/kitchensinkQuery').kitchensinkQuery;
     type kitchensinkDocument = import('./fixtures/kitchensinkQuery').kitchensinkDocument;
+    type actual = parseDocument<kitchensinkQuery>;
 
-    expectTypeOf<parseDocument<kitchensinkQuery>>().toEqualTypeOf<kitchensinkDocument>();
-    expectTypeOf<parseDocument<kitchensinkQuery>>().toMatchTypeOf<kitchensinkDocument>();
-    expectTypeOf<parseDocument<kitchensinkQuery>>().toMatchTypeOf<DocumentNode>();
+    expectTypeOf<actual>().toEqualTypeOf<kitchensinkDocument>();
+    expectTypeOf<actual>().toMatchTypeOf<kitchensinkDocument>();
+    expectTypeOf<actual>().toMatchTypeOf<DocumentNode>();
   });
 });
diff --git a/src/__tests__/selection.test-d.ts b/src/__tests__/selection.test-d.ts
index ab34ce46..6dd6c045 100644
--- a/src/__tests__/selection.test-d.ts
+++ b/src/__tests__/selection.test-d.ts
@@ -1,6 +1,6 @@
 import { expectTypeOf, test } from 'vitest';
 import { simpleSchema } from './fixtures/simpleSchema';
-import { $tada } from '../namespace';
+import { $tada, decorateDocument, getFragmentsOfDocumentsRec } from '../namespace';
 import { parseDocument } from '../parser';
 import { mapIntrospection } from '../introspection';
 import { getDocumentType } from '../selection';
@@ -114,23 +114,20 @@ test('infers fragment spreads', () => {
 
 test('infers fragment spreads for fragment refs', () => {
   type fragment = parseDocument</* GraphQL */ `
-    fragment Fields on Todo { id text __typename }
-  `>['definitions'][0] & {
-    [$tada.fragmentName]: 'Fields';
-  };
+    fragment Fields on Query { __typename }
+  `>;
 
   type query = parseDocument</* GraphQL */ `
-    query { todos { ...Fields } }
+    query { ...Fields }
   `>;
 
-  type actual = getDocumentType<query, schema, { Fields: fragment }>;
+  type extraFragments = getFragmentsOfDocumentsRec<[decorateDocument<fragment>]>;
+  type actual = getDocumentType<query, schema, extraFragments>;
 
   type expected = {
-    todos: Array<{
-      [$tada.fragmentRefs]: {
-        Fields: fragment;
-      };
-    } | null> | null;
+    [$tada.fragmentRefs]?: {
+      Fields: extraFragments['Fields'][$tada.fragmentId];
+    };
   };
 
   expectTypeOf<expected>().toEqualTypeOf<actual>();
@@ -275,3 +272,25 @@ test('infers queries from GitHub introspection schema', () => {
 
   expectTypeOf<expected>().toEqualTypeOf<actual>();
 });
+
+test('creates a type for a given fragment', () => {
+  type fragment = parseDocument<`
+    fragment Fields on Todo {
+      id
+      text
+      complete
+      __typename
+    }
+  `>;
+
+  type actual = getDocumentType<fragment, schema>;
+
+  type expected = {
+    __typename: 'Todo';
+    id: string | number;
+    text: string;
+    complete: boolean | null;
+  };
+
+  expectTypeOf<expected>().toEqualTypeOf<actual>();
+});
diff --git a/src/api.ts b/src/api.ts
index 54c24c5e..de4bbb63 100644
--- a/src/api.ts
+++ b/src/api.ts
@@ -1,9 +1,57 @@
 import { parse as _parse } from '@0no-co/graphql.web';
-import type { stringLiteral } from './utils';
-import type { parseDocument } from './parser';
+import type {
+  IntrospectionQuery,
+  ScalarsLike,
+  IntrospectionLikeType,
+  mapIntrospection,
+} from './introspection';
+import type {
+  decorateDocument,
+  getFragmentsOfDocumentsRec,
+  FragmentDocumentNode,
+} from './namespace';
+import type { getDocumentType } from './selection';
+import type { getVariablesType } from './variables';
+import type { parseDocument, DocumentNodeLike } from './parser';
+import type { stringLiteral, TypedDocumentNode } from './utils';
+
+interface AbstractSetupSchema {
+  introspection: IntrospectionQuery;
+  scalars: ScalarsLike;
+}
+
+interface setupSchema extends AbstractSetupSchema {
+  /*empty*/
+}
+
+type Schema = mapIntrospection<setupSchema['introspection'], setupSchema['scalars']>;
 
 function parse<const In extends stringLiteral<In>>(input: In): parseDocument<In> {
   return _parse(input) as any;
 }
 
-export { parse };
+type getDocumentNode<
+  In extends string,
+  Introspection extends IntrospectionLikeType,
+  Fragments extends { [name: string]: any } = {},
+> = parseDocument<In> extends infer Document extends DocumentNodeLike
+  ? getDocumentType<Document, Introspection, Fragments> extends infer Result
+    ? Result extends never
+      ? never
+      : TypedDocumentNode<Result, getVariablesType<Document, Introspection>> &
+          decorateDocument<Document>
+    : never
+  : never;
+
+function graphql<
+  const In extends stringLiteral<In>,
+  const Fragments extends readonly [...FragmentDocumentNode[]],
+>(
+  input: In,
+  _fragments?: Fragments
+): getDocumentNode<In, Schema, getFragmentsOfDocumentsRec<Fragments>> {
+  return _parse(input) as any;
+}
+
+export { parse, graphql };
+export type { setupSchema };
diff --git a/src/fragments.ts b/src/fragments.ts
deleted file mode 100644
index 1a1aa3f8..00000000
--- a/src/fragments.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import type { Kind } from '@0no-co/graphql.web';
-import type { DocumentNodeLike } from './parser';
-
-type _getFragmentMapRec<Definitions> = Definitions extends readonly [
-  infer Definition,
-  ...infer Rest,
-]
-  ? (Definition extends { kind: Kind.FRAGMENT_DEFINITION; name: any }
-      ? { [Name in Definition['name']['value']]: Definition }
-      : {}) &
-      _getFragmentMapRec<Rest>
-  : {};
-
-export type getFragmentMap<Document extends DocumentNodeLike> = _getFragmentMapRec<
-  Document['definitions']
->;
diff --git a/src/introspection.ts b/src/introspection.ts
index 0758fb17..9b7951a8 100644
--- a/src/introspection.ts
+++ b/src/introspection.ts
@@ -1,6 +1,6 @@
 import type { obj } from './utils';
 
-interface IntrospectionQuery {
+export interface IntrospectionQuery {
   readonly __schema: IntrospectionSchema;
 }
 
diff --git a/src/namespace.ts b/src/namespace.ts
index 321598fd..c65c0e8d 100644
--- a/src/namespace.ts
+++ b/src/namespace.ts
@@ -1,3 +1,7 @@
+import type { Kind } from '@0no-co/graphql.web';
+import type { DocumentNodeLike } from './parser';
+import type { TypedDocumentNode } from './utils';
+
 /** Private namespace holding our symbols for markers.
  *
  * @remarks
@@ -10,8 +14,48 @@ declare namespace $tada {
   const fragmentRefs: unique symbol;
   export type fragmentRefs = typeof fragmentRefs;
 
-  const fragmentName: unique symbol;
-  export type fragmentName = typeof fragmentName;
+  const fragmentDef: unique symbol;
+  export type fragmentDef = typeof fragmentDef;
+
+  const fragmentId: unique symbol;
+  export type fragmentId = typeof fragmentId;
+}
+
+type decorateDocument<Document extends DocumentNodeLike> = Document['definitions'][0] extends {
+  kind: Kind.FRAGMENT_DEFINITION;
+  name: any;
+  typeCondition: any;
 }
+  ? {
+      [$tada.fragmentDef]?: Document['definitions'][0] & {
+        readonly [$tada.fragmentId]: unique symbol;
+      };
+    }
+  : {};
+
+type getFragmentsOfDocumentsRec<Documents> = Documents extends readonly [
+  infer Document,
+  ...infer Rest,
+]
+  ? (Document extends { [$tada.fragmentDef]?: any }
+      ? Exclude<Document[$tada.fragmentDef], undefined> extends infer FragmentDef extends {
+          kind: Kind.FRAGMENT_DEFINITION;
+          name: any;
+          typeCondition: any;
+        }
+        ? { [Name in FragmentDef['name']['value']]: FragmentDef }
+        : {}
+      : {}) &
+      getFragmentsOfDocumentsRec<Rest>
+  : {};
+
+type FragmentDocumentNode = {
+  [$tada.fragmentDef]?: {
+    readonly [$tada.fragmentId]: symbol;
+    kind: Kind.FRAGMENT_DEFINITION;
+    name: any;
+    typeCondition: any;
+  };
+};
 
-export type { $tada };
+export type { $tada, decorateDocument, getFragmentsOfDocumentsRec, FragmentDocumentNode };
diff --git a/src/selection.ts b/src/selection.ts
index 655a1226..af7f0d1a 100644
--- a/src/selection.ts
+++ b/src/selection.ts
@@ -8,7 +8,6 @@ import type {
 
 import type { $tada } from './namespace';
 import type { obj, objValues } from './utils';
-import type { getFragmentMap } from './fragments';
 import type { DocumentNodeLike } from './parser';
 
 import type {
@@ -81,10 +80,12 @@ type getFragmentSelection<
   ? getSelection<Node['selectionSet']['selections'], Type, Introspection, Fragments>
   : Node extends { kind: Kind.FRAGMENT_SPREAD; name: any }
     ? Node['name']['value'] extends keyof Fragments
-      ? Fragments[Node['name']['value']] extends infer Fragment extends {
-          [$tada.fragmentName]: string;
-        }
-        ? { [$tada.fragmentRefs]: { [Name in Fragment[$tada.fragmentName]]: Fragment } }
+      ? Fragments[Node['name']['value']] extends { readonly [$tada.fragmentId]: symbol }
+        ? {
+            [$tada.fragmentRefs]?: {
+              [Name in Node['name']['value']]: Fragments[Node['name']['value']][$tada.fragmentId];
+            };
+          }
         : getSelection<
             Fragments[Node['name']['value']]['selectionSet']['selections'],
             Type,
@@ -196,55 +197,53 @@ type getFragmentsSelection<
     ? _getFragmentsSelectionRec<Selections, Type['name'], Type, Introspection, Fragments>
     : {};
 
-type getDefinitionSelectionRec<
-  Definitions extends any[],
+type getOperationSelectionType<
+  Definition,
   Introspection extends IntrospectionLikeType,
   Fragments extends { [name: string]: any },
-> = Definitions extends readonly [infer Definition, ...infer Rest]
-  ? Definition extends {
-      kind: Kind.OPERATION_DEFINITION;
-      selectionSet: { kind: Kind.SELECTION_SET; selections: [...infer Selections] };
-      operation: any;
-    }
-    ? Introspection['types'][Introspection[Definition['operation']]] extends ObjectLikeType
-      ? getSelection<
-          Selections,
-          Introspection['types'][Introspection[Definition['operation']]],
-          Introspection,
-          Fragments
-        >
-      : {}
-    : getDefinitionSelectionRec<Rest, Introspection, Fragments>
-  : {};
+> = Definition extends {
+  kind: Kind.OPERATION_DEFINITION;
+  selectionSet: any;
+  operation: any;
+}
+  ? Introspection['types'][Introspection[Definition['operation']]] extends infer Type extends
+      ObjectLikeType
+    ? getSelection<Definition['selectionSet']['selections'], Type, Introspection, Fragments>
+    : {}
+  : never;
 
-type getDocumentType<
-  Document extends DocumentNodeLike,
+type getFragmentSelectionType<
+  Definition,
   Introspection extends IntrospectionLikeType,
-  Fragments extends { [name: string]: any } = {},
-> = getDefinitionSelectionRec<
-  Document['definitions'],
-  Introspection,
-  getFragmentMap<Document> & Fragments
->;
+  Fragments extends { [name: string]: any },
+> = Definition extends {
+  kind: Kind.FRAGMENT_DEFINITION;
+  selectionSet: any;
+  typeCondition: any;
+}
+  ? Introspection['types'][Definition['typeCondition']['name']['value']] extends infer Type extends
+      ObjectLikeType
+    ? getSelection<Definition['selectionSet']['selections'], Type, Introspection, Fragments>
+    : {}
+  : never;
 
-type getFragmentType<
+type getDocumentType<
   Document extends DocumentNodeLike,
   Introspection extends IntrospectionLikeType,
   Fragments extends { [name: string]: any } = {},
-> = Document['definitions'][0] extends {
-  kind: Kind.FRAGMENT_DEFINITION;
-  typeCondition: { name: { value: infer TypeName } };
-}
-  ? TypeName extends keyof Introspection['types']
-    ? Introspection['types'][TypeName] extends ObjectLikeType
-      ? getSelection<
-          Document['definitions'][0]['selectionSet']['selections'],
-          Introspection['types'][TypeName],
-          Introspection,
-          getFragmentMap<Document> & Fragments
-        >
+> = Document['definitions'] extends readonly [infer Definition, ...infer Rest]
+  ? Definition extends { kind: Kind.OPERATION_DEFINITION }
+    ? getOperationSelectionType<Definition, Introspection, getFragmentMapRec<Rest> & Fragments>
+    : Definition extends { kind: Kind.FRAGMENT_DEFINITION }
+      ? getFragmentSelectionType<Definition, Introspection, getFragmentMapRec<Rest> & Fragments>
       : never
-    : never
   : never;
 
-export type { getDocumentType, getFragmentType };
+type getFragmentMapRec<Definitions> = Definitions extends readonly [infer Definition, ...infer Rest]
+  ? (Definition extends { kind: Kind.FRAGMENT_DEFINITION; name: any }
+      ? { [Name in Definition['name']['value']]: Definition }
+      : {}) &
+      getFragmentMapRec<Rest>
+  : {};
+
+export type { getDocumentType, getFragmentMapRec };
diff --git a/src/utils.ts b/src/utils.ts
index db8b550b..034384e8 100644
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -22,7 +22,7 @@ export type objValues<T> = T[keyof T] extends infer U
     : U
   : never;
 
-/** A GraphQL `DocumentNode` with attached generics for its result data and variables.
+/** Annotations for GraphQL’s `DocumentNode` with attached generics for its result data and variables types.
  *
  * @remarks
  * A GraphQL {@link DocumentNode} defines both the variables it accepts on request and the `data`
@@ -41,10 +41,10 @@ export type objValues<T> = T[keyof T] extends infer U
  *
  * @see {@link https://github.com/dotansimha/graphql-typed-document-node} for more information.
  */
-export type TypedDocumentNode<
+export interface DocumentDecoration<
   Result = { [key: string]: any },
   Variables = { [key: string]: any },
-> = DocumentNode & {
+> {
   /** Type to support `@graphql-typed-document-node/core`
    * @internal
    */
@@ -53,4 +53,29 @@ export type TypedDocumentNode<
    * @internal
    */
   __ensureTypesOfVariablesAndResultMatching?: (variables: Variables) => Result;
-};
+}
+
+/** A GraphQL `DocumentNode` with attached generics for its result data and variables.
+ *
+ * @remarks
+ * A GraphQL {@link DocumentNode} defines both the variables it accepts on request and the `data`
+ * shape it delivers on a response in the GraphQL query language.
+ *
+ * To bridge the gap to TypeScript, tools may be used to generate TypeScript types that define the shape
+ * of `data` and `variables` ahead of time. These types are then attached to GraphQL documents using this
+ * `TypedDocumentNode` type.
+ *
+ * Using a `DocumentNode` that is typed like this will cause any `urql` API to type its input `variables`
+ * and resulting `data` using the types provided.
+ *
+ * @privateRemarks
+ * For compatibility reasons this type has been copied and internalized from:
+ * https://github.com/dotansimha/graphql-typed-document-node/blob/3711b12/packages/core/src/index.ts#L3-L10
+ *
+ * @see {@link https://github.com/dotansimha/graphql-typed-document-node} for more information.
+ */
+export interface TypedDocumentNode<
+  Result = { [key: string]: any },
+  Variables = { [key: string]: any },
+> extends DocumentNode,
+    DocumentDecoration<Result, Variables> {}
diff --git a/src/variables.ts b/src/variables.ts
index 54b3a6bc..46ecac73 100644
--- a/src/variables.ts
+++ b/src/variables.ts
@@ -1,5 +1,6 @@
 import type { Kind, TypeNode } from '@0no-co/graphql.web';
 import type { IntrospectionLikeType } from './introspection';
+import type { DocumentNodeLike } from './parser';
 import type { obj } from './utils';
 
 type getInputObjectTypeRec<
@@ -86,26 +87,14 @@ type getVariablesRec<
       getVariablesRec<Rest, Introspection>
   : {};
 
-type getDefinitionVariablesRec<
-  Definitions extends readonly unknown[],
+type getVariablesType<
+  Document extends DocumentNodeLike,
   Introspection extends IntrospectionLikeType,
-> = (Definitions[0] extends {
+> = Document['definitions'][0] extends {
   kind: Kind.OPERATION_DEFINITION;
-  variableDefinitions: infer VarDefs;
+  variableDefinitions: any;
 }
-  ? VarDefs extends Array<{ kind: Kind.VARIABLE_DEFINITION }>
-    ? getVariablesRec<VarDefs, Introspection>
-    : never
-  : never) &
-  (Definitions extends readonly [any, ...infer Rest]
-    ? Rest extends readonly []
-      ? {}
-      : getDefinitionVariablesRec<Rest, Introspection>
-    : never);
-
-type getVariablesType<
-  D extends { kind: Kind.DOCUMENT; definitions: any[] },
-  I extends IntrospectionLikeType,
-> = obj<getDefinitionVariablesRec<D['definitions'], I>>;
+  ? obj<getVariablesRec<Document['definitions'][0]['variableDefinitions'], Introspection>>
+  : {};
 
 export type { getVariablesType };