@soda-gql/core 0.11.25 → 0.12.0

package/dist/{index-BcK5E-j7.d.ts → index-BnsQQUy6.d.cts}

@@ -1,5 +1,6 @@
-import { $ as PrimitiveTypeProfile, C as AnyFieldName, Ct as DeferredInputSpecifier, D as InferInputKind, Dt as DeferredOutputSpecifier, Et as DeferredOutputInferrableSpecifier, F as OperationType, Ft as InputTypeSpecifiers, H as AnyVarRef, Jt as ApplyTypeModifier, K as VarRef, Kt as VarSpecifier, L as ResolveInputProfileFromMeta, N as ObjectFieldRecord, Nt as InputTypeKind, O as InferInputProfile, Q as ObjectTypeProfile, Qt as ConstValue, S as AllInputTypeNames, T as AnyTypeName, Tt as DeferredOutputFieldWithArgs, U as AnyVarRefBrand, Vt as OutputTypeKind, X as GetConstAssignableType, Xt as TypeModifier, Yt as GetSignature, Z as GetModifiedType, _ as FragmentMetadataBuilder, a as DefaultMetadataAdapter, at as InputDepthOverrides, c as ExtractAdapterTypes, dt as GetSpecKind, en as FieldPath, et as TypeProfile, ft as GetSpecModifier, i as DefaultAdapter, k as InferOutputProfile, n as AnyAdapter, p as OperationDocumentTransformer, pt as GetSpecName, qt as VariableDefinitions, r as AnyMetadataAdapter, s as DocumentTransformer, t as Adapter, ut as GetSpecDefaultValue, w as AnyGraphqlSchema, xt as CreatableInputTypeKind, y as MetadataBuilder, yt as AnyDefaultValue } from "./index-BJ6nWenl.js";
-import { ConstValueNode, NamedTypeNode, OperationTypeNode, TypeNode, ValueNode, VariableDefinitionNode } from "graphql";
+import { $ as PrimitiveTypeProfile, C as AnyFieldName, Ct as DeferredInputSpecifier, D as InferInputKind, Dt as DeferredOutputSpecifier, Et as DeferredOutputInferrableSpecifier, F as OperationType, Ft as InputTypeSpecifiers, H as AnyVarRef, Jt as ApplyTypeModifier, K as VarRef, Kt as VarSpecifier, L as ResolveInputProfileFromMeta, N as ObjectFieldRecord, Nt as InputTypeKind, O as InferInputProfile, Q as ObjectTypeProfile, Qt as ConstValue, S as AllInputTypeNames, T as AnyTypeName, Tt as DeferredOutputFieldWithArgs, U as AnyVarRefBrand, Vt as OutputTypeKind, X as GetConstAssignableType, Xt as TypeModifier, Yt as GetSignature, Z as GetModifiedType, a as DefaultMetadataAdapter, at as InputDepthOverrides, c as ExtractAdapterTypes, dt as GetSpecKind, en as FieldPath, et as TypeProfile, ft as GetSpecModifier, i as DefaultAdapter, k as InferOutputProfile, n as AnyAdapter, p as OperationDocumentTransformer, pt as GetSpecName, qt as VariableDefinitions, r as AnyMetadataAdapter, s as DocumentTransformer, t as Adapter, ut as GetSpecDefaultValue, w as AnyGraphqlSchema, xt as CreatableInputTypeKind, y as MetadataBuilder, yt as AnyDefaultValue } from "./index-PnGDsBZE.cjs";
+import * as graphql0 from "graphql";
+import { ConstDirectiveNode, ConstValueNode, DocumentNode, EnumValueDefinitionNode, FieldDefinitionNode, InputValueDefinitionNode, NamedTypeNode, OperationTypeNode, SelectionSetNode, TypeNode, ValueNode, VariableDefinitionNode } from "graphql";
 import { TypedDocumentNode } from "@graphql-typed-document-node/core";
 
 //#region packages/core/src/types/type-foundation/directive-ref.d.ts
@@ -189,7 +190,7 @@ type FieldArgumentValue<TSchema$1 extends AnyGraphqlSchema, TSpecifier$1 extends
  * This name appears in TypeScript error messages when variable access fails.
  */
 type DeclaredVariables<TSchema$1 extends AnyGraphqlSchema, TVarDefs extends VariableDefinitions> = { readonly [K in keyof TVarDefs]-?: VarRef<TypeProfile.DeclaredVariableType<ResolveInputProfileFromMeta<TSchema$1, TVarDefs[K]["name"], TVarDefs[K]["kind"], TVarDefs[K]["modifier"]>>> };
-type AssignableInputByFieldName<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"], TFieldName$1 extends keyof TSchema$1["object"][TTypeName$1]["fields"]> = AssignableInput<TSchema$1, TSchema$1["object"][TTypeName$1]["fields"][TFieldName$1]["arguments"]>;
+type AssignableInputByFieldName<TSchema$1 extends AnyGraphqlSchema, TTypeName extends keyof TSchema$1["object"], TFieldName$1 extends keyof TSchema$1["object"][TTypeName]["fields"]> = AssignableInput<TSchema$1, TSchema$1["object"][TTypeName]["fields"][TFieldName$1]["arguments"]>;
 //#endregion
 //#region packages/core/src/types/fragment/directives.d.ts
 /**
@@ -250,8 +251,8 @@ type AnyFields = {
  *
  * Supports shorthand syntax in nested object selections via AnyNestedObjectExtended.
  */
-type AbstractFieldSelection<TTypeName$1 extends AnyTypeName, TFieldName$1 extends AnyFieldName, TSpecifier$1 extends DeferredOutputFieldWithArgs, TArgs extends AnyAssignableInput, TDirectives extends AnyDirectiveAttachments, TObject extends AnyNestedObjectExtended | null, TUnionSelections extends AnyNestedUnion | null, TUnionTypename extends boolean> = {
-  readonly parent: TTypeName$1;
+type AbstractFieldSelection<TTypeName extends AnyTypeName, TFieldName$1 extends AnyFieldName, TSpecifier$1 extends DeferredOutputFieldWithArgs, TArgs extends AnyAssignableInput, TDirectives extends AnyDirectiveAttachments, TObject extends AnyNestedObjectExtended | null, TUnionSelections extends AnyNestedUnion | null, TUnionTypename extends boolean> = {
+  readonly parent: TTypeName;
   readonly field: TFieldName$1;
   readonly type: TSpecifier$1;
   readonly args: TArgs;
@@ -260,7 +261,7 @@ type AbstractFieldSelection<TTypeName$1 extends AnyTypeName, TFieldName$1 extend
   readonly union: TUnionSelections extends AnyNestedUnion ? UnionSelection<TUnionSelections, TUnionTypename> : null;
 };
 /** Convenience alias to obtain a typed field reference from the schema. */
-type FieldSelectionTemplateOf<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string, TFieldName$1 extends keyof TSchema$1["object"][TTypeName$1]["fields"] & string, TRef extends DeferredOutputFieldWithArgs = TSchema$1["object"][TTypeName$1]["fields"][TFieldName$1]> = AbstractFieldSelection<TTypeName$1, TFieldName$1, TRef, AssignableInputByFieldName<TSchema$1, TTypeName$1, TFieldName$1>, AnyDirectiveAttachments, GetSpecKind<TRef["spec"]> extends "object" ? AnyNestedObjectExtended : null, GetSpecKind<TRef["spec"]> extends "union" ? AnyNestedUnion : null, boolean>;
+type FieldSelectionTemplateOf<TSchema$1 extends AnyGraphqlSchema, TTypeName extends keyof TSchema$1["object"] & string, TFieldName$1 extends keyof TSchema$1["object"][TTypeName]["fields"] & string, TRef extends DeferredOutputFieldWithArgs = TSchema$1["object"][TTypeName]["fields"][TFieldName$1]> = AbstractFieldSelection<TTypeName, TFieldName$1, TRef, AssignableInputByFieldName<TSchema$1, TTypeName, TFieldName$1>, AnyDirectiveAttachments, GetSpecKind<TRef["spec"]> extends "object" ? AnyNestedObjectExtended : null, GetSpecKind<TRef["spec"]> extends "union" ? AnyNestedUnion : null, boolean>;
 /** Resolve the data shape produced by a set of field selections. */
 type InferFields<TSchema$1 extends AnyGraphqlSchema, TFields$1 extends AnyFields> = { [_ in TSchema$1["label"]]: { [TAliasName in keyof TFields$1]: InferField<TSchema$1, TFields$1[TAliasName]> } & {} }[TSchema$1["label"]];
 /**
@@ -314,26 +315,26 @@ type RequiredKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K }[k
 /**
  * Check if a field has no required arguments.
  */
-type HasNoRequiredArgs<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string, TFieldName$1 extends keyof TSchema$1["object"][TTypeName$1]["fields"] & string> = keyof RequiredKeys<AssignableInputByFieldName<TSchema$1, TTypeName$1, TFieldName$1>> extends never ? true : false;
+type HasNoRequiredArgs<TSchema$1 extends AnyGraphqlSchema, TTypeName extends keyof TSchema$1["object"] & string, TFieldName$1 extends keyof TSchema$1["object"][TTypeName]["fields"] & string> = keyof RequiredKeys<AssignableInputByFieldName<TSchema$1, TTypeName, TFieldName$1>> extends never ? true : false;
 /**
  * Validate that shorthand `true` is only used for fields without required arguments.
  * Fields with required arguments must use factory syntax.
  */
-type ValidateShorthand<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string, TFieldName$1 extends string, TValue$1> = TValue$1 extends true ? TFieldName$1 extends keyof TSchema$1["object"][TTypeName$1]["fields"] & string ? HasNoRequiredArgs<TSchema$1, TTypeName$1, TFieldName$1> extends true ? true : never : never : TValue$1;
+type ValidateShorthand<TSchema$1 extends AnyGraphqlSchema, TTypeName extends keyof TSchema$1["object"] & string, TFieldName$1 extends string, TValue$1> = TValue$1 extends true ? TFieldName$1 extends keyof TSchema$1["object"][TTypeName]["fields"] & string ? HasNoRequiredArgs<TSchema$1, TTypeName, TFieldName$1> extends true ? true : never : never : TValue$1;
 /**
  * Infer the output type for a scalar/enum field by looking up the schema.
  * Used for shorthand syntax where field type info is not embedded in the value.
  */
-type InferScalarFieldByName<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string, TFieldName$1 extends keyof TSchema$1["object"][TTypeName$1]["fields"]> = TSchema$1["object"][TTypeName$1]["fields"][TFieldName$1] extends infer TSpecifier extends DeferredOutputInferrableSpecifier ? GetModifiedType<InferOutputProfile<TSchema$1, TSpecifier>, GetSpecModifier<TSpecifier>> : never;
+type InferScalarFieldByName<TSchema$1 extends AnyGraphqlSchema, TTypeName extends keyof TSchema$1["object"] & string, TFieldName$1 extends keyof TSchema$1["object"][TTypeName]["fields"]> = TSchema$1["object"][TTypeName]["fields"][TFieldName$1] extends infer TSpecifier extends DeferredOutputInferrableSpecifier ? GetModifiedType<InferOutputProfile<TSchema$1, TSpecifier>, GetSpecModifier<TSpecifier>> : never;
 /**
  * Infer the output type for a single field value (shorthand or factory return).
  */
-type InferFieldValue<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string, TFieldKey extends string, TValue$1> = TValue$1 extends true ? TFieldKey extends keyof TSchema$1["object"][TTypeName$1]["fields"] & string ? ValidateShorthand<TSchema$1, TTypeName$1, TFieldKey, TValue$1> extends true ? InferScalarFieldByName<TSchema$1, TTypeName$1, TFieldKey> : never : never : TValue$1 extends AnyFieldSelection ? InferField<TSchema$1, TValue$1> : never;
+type InferFieldValue<TSchema$1 extends AnyGraphqlSchema, TTypeName extends keyof TSchema$1["object"] & string, TFieldKey extends string, TValue$1> = TValue$1 extends true ? TFieldKey extends keyof TSchema$1["object"][TTypeName]["fields"] & string ? ValidateShorthand<TSchema$1, TTypeName, TFieldKey, TValue$1> extends true ? InferScalarFieldByName<TSchema$1, TTypeName, TFieldKey> : never : never : TValue$1 extends AnyFieldSelection ? InferField<TSchema$1, TValue$1> : never;
 /**
  * Infer fields with shorthand support.
  * Requires TTypeName to look up field types when value is shorthand (true).
  */
-type InferFieldsExtended<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string, TFields$1 extends AnyFieldsExtended> = { [_ in TSchema$1["label"]]: { [K in keyof TFields$1]: InferFieldValue<TSchema$1, TTypeName$1, K & string, TFields$1[K]> } & {} }[TSchema$1["label"]];
+type InferFieldsExtended<TSchema$1 extends AnyGraphqlSchema, TTypeName extends keyof TSchema$1["object"] & string, TFields$1 extends AnyFieldsExtended> = { [_ in TSchema$1["label"]]: { [K in keyof TFields$1]: InferFieldValue<TSchema$1, TTypeName, K & string, TFields$1[K]> } & {} }[TSchema$1["label"]];
 //#endregion
 //#region packages/core/src/utils/deferred-specifier-parser.d.ts
 type ParsedInputSpecifier = {
@@ -443,14 +444,14 @@ declare const buildOperationTypeNode: (operation: OperationType) => OperationTyp
  * @param options - Operation configuration (name, type, variables, fields, schema)
  * @returns TypedDocumentNode with inferred input/output types
  */
-declare const buildDocument: <TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string, TFields$1 extends AnyFieldsExtended, TVarDefinitions$1 extends VariableDefinitions>(options: {
+declare const buildDocument: <TSchema$1 extends AnyGraphqlSchema, TTypeName extends keyof TSchema$1["object"] & string, TFields$1 extends AnyFieldsExtended, TVarDefinitions$1 extends VariableDefinitions>(options: {
   operationName: string;
   operationType: OperationType;
-  operationTypeName: TTypeName$1;
+  operationTypeName: TTypeName;
   variables: TVarDefinitions$1;
   fields: TFields$1;
   schema: TSchema$1;
-}) => TypedDocumentNode<InferFieldsExtended<TSchema$1, TTypeName$1, TFields$1>, ConstAssignableInputFromVarDefs<TSchema$1, TVarDefinitions$1>>;
+}) => TypedDocumentNode<InferFieldsExtended<TSchema$1, TTypeName, TFields$1>, ConstAssignableInputFromVarDefs<TSchema$1, TVarDefinitions$1>>;
 //#endregion
 //#region packages/core/src/utils/type-utils.d.ts
 type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
@@ -463,7 +464,7 @@ type StripSymbols<T extends object> = { [K in keyof T as K extends symbol | "$in
  * Type for colocated field entries.
  * Maps labels to their corresponding field selections.
  */
-type ColocatedEntries = Record<string, AnyFields>;
+type ColocatedEntries = Record<string, AnyFieldsExtended>;
 /**
  * Result type for colocated fields.
  * Merges all prefixed entries into a single object.
@@ -552,14 +553,14 @@ declare const empty: () => EmptyObject;
  *
  * Supports both shorthand syntax (`id: true`) and factory syntax (`...f.id()`).
  */
-type FieldsBuilder<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string, TVariableDefinitions extends VariableDefinitions, TFields$1 extends AnyFieldsExtended> = (tools: NoInfer<FieldsBuilderTools<TSchema$1, TTypeName$1, TVariableDefinitions>>) => TFields$1;
+type FieldsBuilder<TSchema$1 extends AnyGraphqlSchema, TTypeName extends keyof TSchema$1["object"] & string, TVariableDefinitions extends VariableDefinitions, TFields$1 extends AnyFieldsExtended> = (tools: NoInfer<FieldsBuilderTools<TSchema$1, TTypeName, TVariableDefinitions>>) => TFields$1;
 /**
  * Tools provided to field builder callbacks.
  * - `f`: Field selection factories for the current type
  * - `$`: Variable references for the current scope
  */
-type FieldsBuilderTools<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string, TVariableDefinitions extends VariableDefinitions> = {
-  f: FieldSelectionFactories<TSchema$1, TTypeName$1>;
+type FieldsBuilderTools<TSchema$1 extends AnyGraphqlSchema, TTypeName extends keyof TSchema$1["object"] & string, TVariableDefinitions extends VariableDefinitions> = {
+  f: FieldSelectionFactories<TSchema$1, TTypeName>;
   $: DeclaredVariables<TSchema$1, TVariableDefinitions>;
 };
 /**
@@ -568,13 +569,13 @@ type FieldsBuilderTools<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends
  *
  * Supports both shorthand syntax (`id: true`) and factory syntax (`...f.id()`).
  */
-type NestedObjectFieldsBuilder<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string, TFields$1 extends AnyFieldsExtended> = (tools: NoInfer<NestedObjectFieldsBuilderTools<TSchema$1, TTypeName$1>>) => TFields$1;
+type NestedObjectFieldsBuilder<TSchema$1 extends AnyGraphqlSchema, TTypeName extends keyof TSchema$1["object"] & string, TFields$1 extends AnyFieldsExtended> = (tools: NoInfer<NestedObjectFieldsBuilderTools<TSchema$1, TTypeName>>) => TFields$1;
 /**
  * Tools for nested object builders (no variable access).
  * @internal
  */
-type NestedObjectFieldsBuilderTools<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string> = {
-  f: FieldSelectionFactories<TSchema$1, TTypeName$1>;
+type NestedObjectFieldsBuilderTools<TSchema$1 extends AnyGraphqlSchema, TTypeName extends keyof TSchema$1["object"] & string> = {
+  f: FieldSelectionFactories<TSchema$1, TTypeName>;
 };
 /**
  * Builder for union type selections with per-member field definitions.
@@ -588,7 +589,7 @@ type NestedUnionFieldsBuilder<TSchema$1 extends AnyGraphqlSchema, TMemberName ex
   __typename?: true;
 };
 /** Map each field to a factory capable of emitting fully-typed references. */
-type FieldSelectionFactories<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string> = { [TFieldName in keyof ObjectFieldRecord<TSchema$1, TTypeName$1> & string]: FieldSelectionFactory<TSchema$1, FieldSelectionTemplateOf<TSchema$1, TTypeName$1, TFieldName>> };
+type FieldSelectionFactories<TSchema$1 extends AnyGraphqlSchema, TTypeName extends keyof TSchema$1["object"] & string> = { [TFieldName in keyof ObjectFieldRecord<TSchema$1, TTypeName> & string]: FieldSelectionFactory<TSchema$1, FieldSelectionTemplateOf<TSchema$1, TTypeName, TFieldName>> };
 /**
  * Type-erased field selection factory.
  * @internal
@@ -723,6 +724,33 @@ type ExtractCompatSpec<T> = T extends CompatSpec<infer TSchema, infer TOperation
   variables: TVarDefinitions;
   fields: TFields;
 } : never;
+/**
+ * Specification for a tagged template compat operation.
+ * Stores raw GraphQL source string instead of fieldsBuilder callback.
+ * Created by `query.compat\`...\``, `mutation.compat\`...\``, `subscription.compat\`...\``.
+ *
+ * Unlike {@link CompatSpec}, this type is not generic — tagged template compat
+ * does not carry type-level field or variable information. Types come from typegen.
+ *
+ * The graphqlSource is stored raw (unparsed). Parsing happens inside extend()
+ * at extend-time, preserving the deferred execution model.
+ */
+type TemplateCompatSpec = {
+  readonly schema: AnyGraphqlSchema;
+  readonly operationType: OperationType;
+  readonly operationName: string;
+  readonly graphqlSource: string;
+};
+/**
+ * Type guard to distinguish TemplateCompatSpec from CompatSpec at runtime.
+ * Uses structural discrimination (presence of `graphqlSource` field).
+ */
+declare const isTemplateCompatSpec: (spec: AnyCompatSpec | TemplateCompatSpec) => spec is TemplateCompatSpec;
+/**
+ * Union type for specs that extend() can accept.
+ * Includes both callback builder compat specs and tagged template compat specs.
+ */
+type AnyExtendableSpec = AnyCompatSpec | TemplateCompatSpec;
 //#endregion
 //#region packages/core/src/types/element/lazy-evaluator.d.ts
 /**
@@ -909,12 +937,12 @@ type FragmentInferMeta<TVariables, TOutput extends object> = {
  * Internal artifact shape produced by fragment evaluation.
  * @internal
  */
-interface FragmentArtifact<TTypeName$1 extends string, TVariables extends Partial<AnyAssignableInput> | void, TFields$1 extends Partial<AnyFieldsExtended>> {
-  readonly typename: TTypeName$1;
+interface FragmentArtifact<TTypeName extends string, TVariables extends Partial<AnyAssignableInput> | void, TFields$1 extends Partial<AnyFieldsExtended>> {
+  readonly typename: TTypeName;
   readonly key: string | undefined;
   readonly schemaLabel: string;
   readonly variableDefinitions: VariableDefinitions;
-  readonly spread: (variables: TVariables) => TFields$1;
+  readonly spread: (...args: TVariables extends void ? [] : [variables: TVariables]) => TFields$1;
 }
 declare const __FRAGMENT_BRAND__: unique symbol;
 /**
@@ -928,11 +956,11 @@ declare const __FRAGMENT_BRAND__: unique symbol;
  * @template TFields - The selected fields structure
  * @template TOutput - Inferred output type from selected fields
  */
-declare class Fragment<TTypeName$1 extends string, TVariables extends Partial<AnyAssignableInput> | void, TFields$1 extends Partial<AnyFieldsExtended>, TOutput extends object> extends GqlElement<FragmentArtifact<TTypeName$1, TVariables, TFields$1>, FragmentInferMeta<TVariables, TOutput>> implements FragmentArtifact<TTypeName$1, TVariables, TFields$1> {
+declare class Fragment<TTypeName extends string, TVariables extends Partial<AnyAssignableInput> | void, TFields$1 extends Partial<AnyFieldsExtended>, TOutput extends object> extends GqlElement<FragmentArtifact<TTypeName, TVariables, TFields$1>, FragmentInferMeta<TVariables, TOutput>> implements FragmentArtifact<TTypeName, TVariables, TFields$1> {
   private readonly [__FRAGMENT_BRAND__];
   private constructor();
   /** The GraphQL type name this fragment selects from. */
-  get typename(): TTypeName$1;
+  get typename(): TTypeName;
   /** Optional unique key for prebuilt type lookup. */
   get key(): string | undefined;
   /** The schema label this fragment belongs to. */
@@ -943,21 +971,21 @@ declare class Fragment<TTypeName$1 extends string, TVariables extends Partial<An
    * Spreads this fragment's fields into a parent selection.
    * Pass variables if the fragment defines any.
    */
-  get spread(): (variables: TVariables) => TFields$1;
+  get spread(): (...args: TVariables extends void ? [] : [variables: TVariables]) => TFields$1;
   /**
    * Creates a new Fragment instance.
    * Prefer using the `gql(({ fragment }) => ...)` API instead.
    * @internal
    */
-  static create<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string, TVariableDefinitions extends VariableDefinitions, TFields$1 extends AnyFieldsExtended>(define: () => {
-    typename: TTypeName$1;
+  static create<TSchema$1 extends AnyGraphqlSchema, TTypeName extends keyof TSchema$1["object"] & string, TVariableDefinitions extends VariableDefinitions, TFields$1 extends AnyFieldsExtended>(define: () => {
+    typename: TTypeName;
     key: string | undefined;
     schemaLabel: TSchema$1["label"];
     variableDefinitions: TVariableDefinitions;
-    spread: (variables: OptionalArg<AssignableInputFromVarDefs<TSchema$1, TVariableDefinitions>>) => TFields$1;
-  }): Fragment<TTypeName$1, OptionalArg<AssignableInputFromVarDefs<TSchema$1, TVariableDefinitions>>, TFields$1 & {
+    spread: (...args: OptionalArg<AssignableInputFromVarDefs<TSchema$1, TVariableDefinitions>> extends void ? [] : [variables: OptionalArg<AssignableInputFromVarDefs<TSchema$1, TVariableDefinitions>>]) => TFields$1;
+  }): Fragment<TTypeName, OptionalArg<AssignableInputFromVarDefs<TSchema$1, TVariableDefinitions>>, TFields$1 & {
     [key: symbol]: never;
-  }, InferFieldsExtended<TSchema$1, TTypeName$1, TFields$1> & {
+  }, InferFieldsExtended<TSchema$1, TTypeName, TFields$1> & {
     [key: symbol]: never;
   }>;
 }
@@ -1054,13 +1082,13 @@ declare class Operation<TOperationType$1 extends OperationType, TOperationName$1
 /**
  * Options for creating a compat operation specification.
  */
-type CompatOptions<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string, TOperationName$1 extends string, TVarDefinitions$1 extends VariableDefinitions, TFields$1 extends AnyFields> = {
+type CompatOptions<TSchema$1 extends AnyGraphqlSchema, TTypeName extends keyof TSchema$1["object"] & string, TOperationName$1 extends string, TVarDefinitions$1 extends VariableDefinitions, TFields$1 extends AnyFields> = {
   /** The operation name */
   name: TOperationName$1;
   /** Optional variable definitions */
   variables?: TVarDefinitions$1;
   /** Field selection builder */
-  fields: FieldsBuilder<TSchema$1, TTypeName$1, TVarDefinitions$1, TFields$1>;
+  fields: FieldsBuilder<TSchema$1, TTypeName, TVarDefinitions$1, TFields$1>;
 };
 /**
  * Creates a factory for composing compat operation specifications.
@@ -1076,6 +1104,20 @@ type CompatOptions<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof
  */
 declare const createCompatComposer: <TSchema$1 extends AnyGraphqlSchema, TOperationType$1 extends OperationType>(schema: NoInfer<TSchema$1>, operationType: TOperationType$1) => <TOperationName$1 extends string, TFields$1 extends AnyFields, TVarDefinitions$1 extends VariableDefinitions = {}>(options: CompatOptions<TSchema$1, TSchema$1["operations"][TOperationType$1] & keyof TSchema$1["object"] & string, TOperationName$1, TVarDefinitions$1, TFields$1>) => GqlDefine<CompatSpec<TSchema$1, TOperationType$1, TOperationName$1, TVarDefinitions$1, TFields$1>>;
 //#endregion
+//#region packages/core/src/composer/compat-tagged-template.d.ts
+/** Tagged template function type for compat operations. */
+type CompatTaggedTemplate = (strings: TemplateStringsArray, ...values: never[]) => GqlDefine<TemplateCompatSpec>;
+/** Curried compat function type: query.compat("name")`{ fields }` */
+type CurriedCompatFunction = (operationName: string) => CompatTaggedTemplate;
+/**
+ * Creates a curried tagged template function for compat mode operations.
+ * New API: `query.compat("name")\`($vars) { fields }\`` returns GqlDefine<TemplateCompatSpec>.
+ *
+ * @param schema - The GraphQL schema definition
+ * @param operationType - The operation type (query, mutation, subscription)
+ */
+declare const createCompatTaggedTemplate: <TSchema$1 extends AnyGraphqlSchema>(schema: TSchema$1, operationType: OperationType) => CurriedCompatFunction;
+//#endregion
 //#region packages/core/src/composer/directive-builder.d.ts
 /**
  * A method that creates a DirectiveRef with specific type information.
@@ -1224,7 +1266,7 @@ type ExtendOptions<TSchema$1 extends AnyGraphqlSchema, TVarDefinitions$1 extends
  *
  * @internal Used by `createGqlElementComposer`
  */
-declare const createExtendComposer: <TSchema$1 extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter>(schema: NoInfer<TSchema$1>, adapter?: TAdapter, transformDocument?: DocumentTransformer<ExtractAdapterTypes<TAdapter>["schemaLevel"], ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"]>) => <TOperationType$1 extends OperationType, TOperationName$1 extends string, TVarDefinitions$1 extends VariableDefinitions, TFields$1 extends AnyFields, TOperationMetadata = unknown>(compat: GqlDefine<CompatSpec<TSchema$1, TOperationType$1, TOperationName$1, TVarDefinitions$1, TFields$1>>, options?: ExtendOptions<TSchema$1, TVarDefinitions$1, TOperationMetadata, ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"], ExtractAdapterTypes<TAdapter>["schemaLevel"]>) => Operation<TOperationType$1, TOperationName$1, (keyof TVarDefinitions$1 & string)[], ConstAssignableInputFromVarDefs<TSchema$1, TVarDefinitions$1>, TFields$1, InferFieldsExtended<TSchema$1, TSchema$1["operations"][TOperationType$1] & keyof TSchema$1["object"] & string, TFields$1>>;
+declare const createExtendComposer: <TSchema$1 extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter>(schema: NoInfer<TSchema$1>, adapter?: TAdapter, transformDocument?: DocumentTransformer<ExtractAdapterTypes<TAdapter>["schemaLevel"], ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"]>) => <TOperationType$1 extends OperationType, TOperationName$1 extends string, TVarDefinitions$1 extends VariableDefinitions, TFields$1 extends AnyFields, TOperationMetadata = unknown>(compat: GqlDefine<CompatSpec<TSchema$1, TOperationType$1, TOperationName$1, TVarDefinitions$1, TFields$1>> | GqlDefine<TemplateCompatSpec>, options?: ExtendOptions<TSchema$1, TVarDefinitions$1, TOperationMetadata, ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"], ExtractAdapterTypes<TAdapter>["schemaLevel"]>) => any;
 //#endregion
 //#region packages/core/src/composer/fields-builder.d.ts
 /**
@@ -1239,67 +1281,120 @@ declare const createExtendComposer: <TSchema$1 extends AnyGraphqlSchema, TAdapte
  *
  * @internal Used by operation and fragment composers
  */
-declare const createFieldFactories: <TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string>(schema: TSchema$1, typeName: TTypeName$1) => FieldSelectionFactories<TSchema$1, TTypeName$1>;
+declare const createFieldFactories: <TSchema$1 extends AnyGraphqlSchema, TTypeName extends keyof TSchema$1["object"] & string>(schema: TSchema$1, typeName: TTypeName) => FieldSelectionFactories<TSchema$1, TTypeName>;
 //#endregion
-//#region packages/core/src/composer/input.d.ts
-/**
- * Creates variable assignments from provided values.
- *
- * Maps variable definitions to VarRefs. If a value is provided,
- * wraps it as a nested-value VarRef. If not provided, creates
- * an undefined VarRef (field will be omitted).
- *
- * Used when spreading fragments with partial variable values.
+//#region packages/core/src/graphql/schema-index.d.ts
+type OperationTypeNames = {
+  query?: string;
+  mutation?: string;
+  subscription?: string;
+};
+type ObjectRecord = {
+  readonly name: string;
+  readonly fields: Map<string, FieldDefinitionNode>;
+  directives: ConstDirectiveNode[];
+};
+type InputRecord = {
+  readonly name: string;
+  readonly fields: Map<string, InputValueDefinitionNode>;
+  directives: ConstDirectiveNode[];
+};
+type EnumRecord = {
+  readonly name: string;
+  readonly values: Map<string, EnumValueDefinitionNode>;
+  directives: ConstDirectiveNode[];
+};
+type UnionRecord = {
+  readonly name: string;
+  readonly members: Map<string, NamedTypeNode>;
+  directives: ConstDirectiveNode[];
+};
+type ScalarRecord = {
+  readonly name: string;
+  directives: ConstDirectiveNode[];
+};
+type DirectiveRecord = {
+  readonly name: string;
+  readonly locations: readonly string[];
+  readonly args: Map<string, InputValueDefinitionNode>;
+  readonly isRepeatable: boolean;
+};
+type SchemaIndex = {
+  readonly objects: Map<string, ObjectRecord>;
+  readonly inputs: Map<string, InputRecord>;
+  readonly enums: Map<string, EnumRecord>;
+  readonly unions: Map<string, UnionRecord>;
+  readonly scalars: Map<string, ScalarRecord>;
+  readonly directives: Map<string, DirectiveRecord>;
+  readonly operationTypes: OperationTypeNames;
+};
+/** Build a schema index from a parsed GraphQL schema document. */
+declare const createSchemaIndex: (document: DocumentNode) => SchemaIndex;
+//#endregion
+//#region packages/core/src/composer/operation-tagged-template.d.ts
+/** Options for fragment TemplateResult resolution. */
+type FragmentTemplateMetadataOptions = {
+  metadata?: unknown | ((context: {
+    $: Readonly<Record<string, unknown>>;
+  }) => unknown | Promise<unknown>);
+};
+/** Options for operation TemplateResult resolution — receives full metadata pipeline context. */
+type OperationTemplateMetadataOptions = {
+  metadata?: unknown | ((context: {
+    $: Readonly<Record<string, unknown>>;
+    document: graphql0.DocumentNode;
+    fragmentMetadata: unknown;
+    schemaLevel: unknown;
+  }) => unknown | Promise<unknown>);
+};
+/** @deprecated Use `FragmentTemplateMetadataOptions` or `OperationTemplateMetadataOptions` instead. */
+type TemplateResultMetadataOptions = FragmentTemplateMetadataOptions;
+/** Callable result from tagged template - resolves to Operation or Fragment. */
+type TemplateResult<TElement extends AnyOperationOf<OperationType> | AnyFragment, TOptions = (TElement extends AnyOperationOf<OperationType> ? OperationTemplateMetadataOptions : FragmentTemplateMetadataOptions)> = (options?: TOptions) => TElement;
+/** Tagged template function type for operations. */
+type OperationTaggedTemplateFunction<TOperationType$1 extends OperationType = OperationType> = (strings: TemplateStringsArray, ...values: (AnyFragment | ((ctx: {
+  $: Readonly<Record<string, AnyVarRef>>;
+}) => AnyFieldsExtended))[]) => TemplateResult<AnyOperationOf<TOperationType$1>>;
+/** Curried operation function type: query("name")`($var: Type!) { fields }` */
+type CurriedOperationFunction<TOperationType$1 extends OperationType = OperationType> = (operationName: string) => OperationTaggedTemplateFunction<TOperationType$1>;
+/**
+ * Creates a curried tagged template function for a specific operation type.
+ * New API: `query("name")\`($var: Type!) { fields }\`` returns TemplateResult<Operation>.
  *
- * @internal
+ * @param schema - The GraphQL schema definition
+ * @param operationType - The operation type (query, mutation, subscription)
+ * @param metadataAdapter - Optional metadata adapter for metadata aggregation
+ * @param adapterTransformDocument - Optional document transformer from adapter
  */
-declare const createVarAssignments: <TSchema$1 extends AnyGraphqlSchema, TVariableDefinitions extends VariableDefinitions>(definitions: TVariableDefinitions, providedValues: AnyAssignableInput | void) => DeclaredVariables<TSchema$1, TVariableDefinitions>;
+declare const createOperationTaggedTemplate: <TSchema$1 extends AnyGraphqlSchema, TOperationType$1 extends OperationType>(schema: TSchema$1, operationType: TOperationType$1, metadataAdapter?: AnyMetadataAdapter, adapterTransformDocument?: DocumentTransformer<any, any>) => CurriedOperationFunction<TOperationType$1>;
+//#endregion
+//#region packages/core/src/composer/fragment-tagged-template.d.ts
+/** Tagged template function type for fragments. */
+type FragmentTaggedTemplateFunction = (strings: TemplateStringsArray, ...values: (AnyFragment | ((ctx: {
+  $: Readonly<Record<string, AnyVarRef>>;
+}) => AnyFieldsExtended))[]) => TemplateResult<AnyFragment>;
 /**
- * Creates variable references from variable definitions.
- *
- * Maps each variable definition to a VarRef pointing to that variable.
- * Used in operation builders to create the `$` context object.
- *
- * @internal
+ * Extract variable definitions from Fragment Arguments syntax.
+ * Wraps the argument list in a synthetic query to parse with graphql-js.
  */
-declare const createVarRefs: <TSchema$1 extends AnyGraphqlSchema, TVarDefinitions$1 extends VariableDefinitions>(definitions: TVarDefinitions$1) => DeclaredVariables<TSchema$1, TVarDefinitions$1>;
-//#endregion
-//#region packages/core/src/composer/fragment.d.ts
+declare function extractFragmentVariables(rawSource: string, schemaIndex: SchemaIndex): VariableDefinitions;
 /**
- * Type alias for a fragment builder function for a specific object type.
- *
- * Used by codegen to generate explicit fragment builder types instead of
- * expensive mapped types. This improves IDE performance for large schemas.
+ * Builds field selections from a GraphQL AST SelectionSet by driving field factories.
+ * Converts parsed AST selections into the AnyFieldsExtended format that the document builder expects.
+ * Also used by typegen for static field extraction from tagged templates.
  */
-type FragmentBuilderFor<TSchema$1 extends AnyGraphqlSchema, TTypeName$1 extends keyof TSchema$1["object"] & string, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter> = <TFields$1 extends AnyFieldsExtended, TVarDefinitions$1 extends VariableDefinitions = {}>(options: {
-  /** Optional unique key for prebuilt type lookup. */
-  key?: string;
-  variables?: TVarDefinitions$1;
-  metadata?: FragmentMetadataBuilder<ReturnType<typeof createVarRefs<TSchema$1, TVarDefinitions$1>>, ExtractAdapterTypes<TAdapter>["fragmentMetadata"]>;
-  fields: FieldsBuilder<TSchema$1, TTypeName$1, TVarDefinitions$1, TFields$1>;
-}) => ReturnType<typeof Fragment.create<TSchema$1, TTypeName$1, TVarDefinitions$1, TFields$1>>;
+declare function buildFieldsFromSelectionSet(selectionSet: SelectionSetNode, schema: AnyGraphqlSchema, typeName: string, varAssignments?: Readonly<Record<string, AnyVarRef>>, interpolationMap?: ReadonlyMap<string, AnyFragment | ((ctx: {
+  $: Readonly<Record<string, AnyVarRef>>;
+}) => AnyFieldsExtended)>): AnyFieldsExtended;
+/** Curried fragment function type: fragment("name", "type")`{ fields }` */
+type CurriedFragmentFunction = (name: string, typeName: string) => FragmentTaggedTemplateFunction;
 /**
- * Creates fragment builder functions for all object types in the schema.
- *
- * Returns an object with a builder for each type (e.g., `fragment.User`, `fragment.Post`).
- * Each builder creates a `Fragment` that can be spread into operations.
+ * Creates a curried tagged template function for fragments.
+ * New API: `fragment("name", "type")\`{ fields }\`` returns TemplateResult<AnyFragment>.
  *
  * @param schema - The GraphQL schema definition
- * @param _adapter - Optional metadata adapter (for fragment metadata)
- * @returns Object mapping type names to fragment builder functions
- *
- * @internal Used by `createGqlElementComposer`
  */
-declare const createGqlFragmentComposers: <TSchema$1 extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter>(schema: NoInfer<TSchema$1>, _adapter?: TAdapter) => { readonly [TTypeName in keyof TSchema$1["object"]]: TTypeName extends string ? <TFields$1 extends AnyFieldsExtended, TVarDefinitions$1 extends VariableDefinitions = {}>(options: {
-  key?: string;
-  variables?: TVarDefinitions$1 | undefined;
-  metadata?: FragmentMetadataBuilder<DeclaredVariables<TSchema$1, TVarDefinitions$1>, ExtractAdapterTypes<TAdapter>["fragmentMetadata"]> | undefined;
-  fields: FieldsBuilder<TSchema$1, TTypeName, TVarDefinitions$1, TFields$1>;
-}) => Fragment<TTypeName, OptionalArg<AssignableInputFromVarDefs<TSchema$1, TVarDefinitions$1>>, TFields$1 & {
-  [key: symbol]: never;
-}, InferFieldsExtended<TSchema$1, TTypeName, TFields$1> & {
-  [key: symbol]: never;
-}> : never };
+declare function createFragmentTaggedTemplate<TSchema$1 extends AnyGraphqlSchema>(schema: TSchema$1): CurriedFragmentFunction;
 //#endregion
 //#region packages/core/src/composer/fragment-usage-context.d.ts
 /**
@@ -1382,9 +1477,9 @@ type AssignableDefaultValue<TSchema$1 extends AnyGraphqlSchema, TKind extends Cr
  *
  * Created by `$var.TypeName("modifier", { default?: ... })` calls.
  */
-type GenericVarSpecifier<TKind extends CreatableInputTypeKind, TTypeName$1 extends string, TModifier extends TypeModifier, TDefaultFn extends (() => unknown) | null, TDirectives extends AnyConstDirectiveAttachments> = {
+type GenericVarSpecifier<TKind extends CreatableInputTypeKind, TTypeName extends string, TModifier extends TypeModifier, TDefaultFn extends (() => unknown) | null, TDirectives extends AnyConstDirectiveAttachments> = {
   kind: TKind;
-  name: TTypeName$1;
+  name: TTypeName;
   modifier: TModifier;
   defaultValue: TDefaultFn extends null ? null : {
     default: ReturnType<NonNullable<TDefaultFn>>;
@@ -1397,10 +1492,10 @@ type GenericVarSpecifier<TKind extends CreatableInputTypeKind, TTypeName$1 exten
  *
  * @deprecated Use createVarMethodFactory instead for proper type inference with nested input objects.
  */
-declare const createVarMethod: <TKind extends CreatableInputTypeKind, TTypeName$1 extends string>(kind: TKind, typeName: TTypeName$1) => <TSchema$1 extends AnyGraphqlSchema, const TModifier extends TypeModifier, const TDefaultFn extends (() => AssignableDefaultValue<TSchema$1, TKind, TTypeName$1, TModifier>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(modifier: TModifier, extras?: {
-  default?: TDefaultFn & (() => AssignableDefaultValue<TSchema$1, TKind, TTypeName$1, TModifier>);
+declare const createVarMethod: <TKind extends CreatableInputTypeKind, TTypeName extends string>(kind: TKind, typeName: TTypeName) => <TSchema$1 extends AnyGraphqlSchema, const TModifier extends TypeModifier, const TDefaultFn extends (() => AssignableDefaultValue<TSchema$1, TKind, TTypeName, TModifier>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(modifier: TModifier, extras?: {
+  default?: TDefaultFn & (() => AssignableDefaultValue<TSchema$1, TKind, TTypeName, TModifier>);
   directives?: TDirectives;
-}) => GenericVarSpecifier<TKind, TTypeName$1, TModifier, TDefaultFn, TDirectives>;
+}) => GenericVarSpecifier<TKind, TTypeName, TModifier, TDefaultFn, TDirectives>;
 /**
  * Creates a factory function for generating schema-scoped variable methods.
  * This ensures proper type inference for nested input objects by binding the schema type upfront.
@@ -1414,14 +1509,14 @@ declare const createVarMethod: <TKind extends CreatableInputTypeKind, TTypeName$
  * } satisfies InputTypeMethods<typeof schema>;
  * ```
  */
-declare const createVarMethodFactory: <TSchema$1 extends AnyGraphqlSchema>() => <TKind extends CreatableInputTypeKind, TTypeName$1 extends AllInputTypeNames<TSchema$1>>(kind: TKind, typeName: TTypeName$1) => InputTypeMethod<TSchema$1, TKind, TTypeName$1>;
+declare const createVarMethodFactory: <TSchema$1 extends AnyGraphqlSchema>() => <TKind extends CreatableInputTypeKind, TTypeName extends AllInputTypeNames<TSchema$1>>(kind: TKind, typeName: TTypeName) => InputTypeMethod<TSchema$1, TKind, TTypeName>;
 /**
  * Type for a single input type method.
  */
-type InputTypeMethod<TSchema$1 extends AnyGraphqlSchema, TKind extends CreatableInputTypeKind, TTypeName$1 extends string> = <const TModifier extends TypeModifier, const TDefaultFn extends (() => AssignableDefaultValue<TSchema$1, TKind, TTypeName$1, TModifier>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(modifier: TModifier, extras?: {
-  default?: TDefaultFn & (() => AssignableDefaultValue<TSchema$1, TKind, TTypeName$1, TModifier>);
+type InputTypeMethod<TSchema$1 extends AnyGraphqlSchema, TKind extends CreatableInputTypeKind, TTypeName extends string> = <const TModifier extends TypeModifier, const TDefaultFn extends (() => AssignableDefaultValue<TSchema$1, TKind, TTypeName, TModifier>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(modifier: TModifier, extras?: {
+  default?: TDefaultFn & (() => AssignableDefaultValue<TSchema$1, TKind, TTypeName, TModifier>);
   directives?: TDirectives;
-}) => GenericVarSpecifier<TKind, TTypeName$1, TModifier, TDefaultFn, TDirectives>;
+}) => GenericVarSpecifier<TKind, TTypeName, TModifier, TDefaultFn, TDirectives>;
 /**
  * Type for all input type methods in a schema.
  */
@@ -1429,10 +1524,10 @@ type InputTypeMethods<TSchema$1 extends AnyGraphqlSchema> = { [TName in AllInput
 /**
  * Type for a wrapped variable method that includes the variable name in the result.
  */
-type WrappedVarMethod<TVarName extends string, TSchema$1 extends AnyGraphqlSchema, TKind extends CreatableInputTypeKind, TTypeName$1 extends string> = <const TModifier extends TypeModifier, const TDefaultFn extends (() => AssignableDefaultValue<TSchema$1, TKind, TTypeName$1, TModifier>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(modifier: TModifier, extras?: {
-  default?: TDefaultFn & (() => AssignableDefaultValue<TSchema$1, TKind, TTypeName$1, TModifier>);
+type WrappedVarMethod<TVarName extends string, TSchema$1 extends AnyGraphqlSchema, TKind extends CreatableInputTypeKind, TTypeName extends string> = <const TModifier extends TypeModifier, const TDefaultFn extends (() => AssignableDefaultValue<TSchema$1, TKind, TTypeName, TModifier>) | null = null, const TDirectives extends AnyConstDirectiveAttachments = {}>(modifier: TModifier, extras?: {
+  default?: TDefaultFn & (() => AssignableDefaultValue<TSchema$1, TKind, TTypeName, TModifier>);
   directives?: TDirectives;
-}) => { [K in TVarName]: GenericVarSpecifier<TKind, TTypeName$1, TModifier, TDefaultFn, TDirectives> };
+}) => { [K in TVarName]: GenericVarSpecifier<TKind, TTypeName, TModifier, TDefaultFn, TDirectives> };
 /**
  * Type for the variable builder methods for a specific variable name.
  */
@@ -1532,11 +1627,6 @@ type ExtractHelpers<TAdapter extends AnyAdapter> = TAdapter extends Adapter<infe
 type ExtractMetadataAdapter<TAdapter extends AnyAdapter> = TAdapter extends {
   metadata?: infer M;
 } ? NonNullable<M> extends AnyMetadataAdapter ? NonNullable<M> : DefaultMetadataAdapter : DefaultMetadataAdapter;
-/**
- * Default fragment builders type computed from schema.
- * This is the mapped type that's expensive to compute for large schemas.
- */
-type FragmentBuildersAll<TSchema$1 extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter> = { readonly [TTypeName in keyof TSchema$1["object"]]: TTypeName extends string ? FragmentBuilderFor<TSchema$1, TTypeName, TAdapter> : never };
 /**
  * Configuration options for `createGqlElementComposer`.
  */
@@ -1553,7 +1643,7 @@ type GqlElementComposerOptions<_TSchema extends AnyGraphqlSchema, TDirectiveMeth
  *
  * This is the main entry point for defining GraphQL operations and fragments.
  * The returned function provides a context with:
- * - `fragment`: Builders for each object type
+ * - `fragment`: Tagged template function for fragment definitions
  * - `query/mutation/subscription`: Operation builders
  * - `$var`: Variable definition helpers
  * - `$dir`: Field directive helpers (@skip, @include)
@@ -1581,9 +1671,9 @@ type GqlElementComposerOptions<_TSchema extends AnyGraphqlSchema, TDirectiveMeth
  * );
  * ```
  */
-declare const createGqlElementComposer: <TSchema$1 extends AnyGraphqlSchema, TFragmentBuilders, TDirectiveMethods extends StandardDirectives, TAdapter extends AnyAdapter = DefaultAdapter>(schema: NoInfer<TSchema$1>, options: GqlElementComposerOptions<NoInfer<TSchema$1>, NoInfer<TDirectiveMethods>, NoInfer<TAdapter>>) => GqlElementComposerWithSchema<{
-  fragment: TFragmentBuilders;
-  query: {
+declare const createGqlElementComposer: <TSchema$1 extends AnyGraphqlSchema, TDirectiveMethods extends StandardDirectives, TAdapter extends AnyAdapter = DefaultAdapter>(schema: NoInfer<TSchema$1>, options: GqlElementComposerOptions<NoInfer<TSchema$1>, NoInfer<TDirectiveMethods>, NoInfer<TAdapter>>) => GqlElementComposerWithSchema<{
+  fragment: CurriedFragmentFunction;
+  query: CurriedOperationFunction<"query"> & {
     operation: <TOperationName$1 extends string, TFields$1 extends AnyFieldsExtended, TVarDefinitions$1 extends VariableDefinitions = {}, TOperationMetadata = unknown>(options: {
       name: TOperationName$1;
       variables?: TVarDefinitions$1 | undefined;
@@ -1591,9 +1681,9 @@ declare const createGqlElementComposer: <TSchema$1 extends AnyGraphqlSchema, TFr
       fields: FieldsBuilder<TSchema$1, TSchema$1["operations"]["query"] & keyof TSchema$1["object"] & string, TVarDefinitions$1, TFields$1>;
       transformDocument?: OperationDocumentTransformer<TOperationMetadata> | undefined;
     }) => Operation<"query", TOperationName$1, (keyof TVarDefinitions$1 & string)[], ConstAssignableInputFromVarDefs<TSchema$1, TVarDefinitions$1>, TFields$1, InferFieldsExtended<TSchema$1, TSchema$1["operations"]["query"] & keyof TSchema$1["object"] & string, TFields$1>>;
-    compat: <TOperationName$1 extends string, TFields_1 extends AnyFields, TVarDefinitions_1 extends VariableDefinitions = {}>(options: CompatOptions<TSchema$1, TSchema$1["operations"]["query"] & keyof TSchema$1["object"] & string, TOperationName$1, TVarDefinitions_1, TFields_1>) => GqlDefine<CompatSpec<TSchema$1, "query", TOperationName$1, TVarDefinitions_1, TFields_1>>;
+    compat: CurriedCompatFunction;
   };
-  mutation: {
+  mutation: CurriedOperationFunction<"mutation"> & {
     operation: <TOperationName$1 extends string, TFields$1 extends AnyFieldsExtended, TVarDefinitions$1 extends VariableDefinitions = {}, TOperationMetadata = unknown>(options: {
       name: TOperationName$1;
       variables?: TVarDefinitions$1 | undefined;
@@ -1601,9 +1691,9 @@ declare const createGqlElementComposer: <TSchema$1 extends AnyGraphqlSchema, TFr
       fields: FieldsBuilder<TSchema$1, TSchema$1["operations"]["mutation"] & keyof TSchema$1["object"] & string, TVarDefinitions$1, TFields$1>;
       transformDocument?: OperationDocumentTransformer<TOperationMetadata> | undefined;
     }) => Operation<"mutation", TOperationName$1, (keyof TVarDefinitions$1 & string)[], ConstAssignableInputFromVarDefs<TSchema$1, TVarDefinitions$1>, TFields$1, InferFieldsExtended<TSchema$1, TSchema$1["operations"]["mutation"] & keyof TSchema$1["object"] & string, TFields$1>>;
-    compat: <TOperationName$1 extends string, TFields_1 extends AnyFields, TVarDefinitions_1 extends VariableDefinitions = {}>(options: CompatOptions<TSchema$1, TSchema$1["operations"]["mutation"] & keyof TSchema$1["object"] & string, TOperationName$1, TVarDefinitions_1, TFields_1>) => GqlDefine<CompatSpec<TSchema$1, "mutation", TOperationName$1, TVarDefinitions_1, TFields_1>>;
+    compat: CurriedCompatFunction;
   };
-  subscription: {
+  subscription: CurriedOperationFunction<"subscription"> & {
     operation: <TOperationName$1 extends string, TFields$1 extends AnyFieldsExtended, TVarDefinitions$1 extends VariableDefinitions = {}, TOperationMetadata = unknown>(options: {
       name: TOperationName$1;
       variables?: TVarDefinitions$1 | undefined;
@@ -1611,10 +1701,10 @@ declare const createGqlElementComposer: <TSchema$1 extends AnyGraphqlSchema, TFr
       fields: FieldsBuilder<TSchema$1, TSchema$1["operations"]["subscription"] & keyof TSchema$1["object"] & string, TVarDefinitions$1, TFields$1>;
       transformDocument?: OperationDocumentTransformer<TOperationMetadata> | undefined;
     }) => Operation<"subscription", TOperationName$1, (keyof TVarDefinitions$1 & string)[], ConstAssignableInputFromVarDefs<TSchema$1, TVarDefinitions$1>, TFields$1, InferFieldsExtended<TSchema$1, TSchema$1["operations"]["subscription"] & keyof TSchema$1["object"] & string, TFields$1>>;
-    compat: <TOperationName$1 extends string, TFields_1 extends AnyFields, TVarDefinitions_1 extends VariableDefinitions = {}>(options: CompatOptions<TSchema$1, TSchema$1["operations"]["subscription"] & keyof TSchema$1["object"] & string, TOperationName$1, TVarDefinitions_1, TFields_1>) => GqlDefine<CompatSpec<TSchema$1, "subscription", TOperationName$1, TVarDefinitions_1, TFields_1>>;
+    compat: CurriedCompatFunction;
   };
   define: <TValue$1>(factory: () => TValue$1 | Promise<TValue$1>) => GqlDefine<TValue$1>;
-  extend: <TOperationType$1 extends OperationType, TOperationName$1 extends string, TVarDefinitions_2 extends VariableDefinitions, TFields_2 extends AnyFields, TOperationMetadata_1 = unknown>(compat: GqlDefine<CompatSpec<TSchema$1, TOperationType$1, TOperationName$1, TVarDefinitions_2, TFields_2>>, options?: ExtendOptions<TSchema$1, TVarDefinitions_2, TOperationMetadata_1, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined) => Operation<TOperationType$1, TOperationName$1, (keyof TVarDefinitions_2 & string)[], ConstAssignableInputFromVarDefs<TSchema$1, TVarDefinitions_2>, TFields_2, InferFieldsExtended<TSchema$1, TSchema$1["operations"][TOperationType$1] & keyof TSchema$1["object"] & string, TFields_2>>;
+  extend: <TOperationType$1 extends OperationType, TOperationName$1 extends string, TVarDefinitions_1 extends VariableDefinitions, TFields_1 extends AnyFields, TOperationMetadata_1 = unknown>(compat: GqlDefine<TemplateCompatSpec> | GqlDefine<CompatSpec<TSchema$1, TOperationType$1, TOperationName$1, TVarDefinitions_1, TFields_1>>, options?: ExtendOptions<TSchema$1, TVarDefinitions_1, TOperationMetadata_1, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined) => any;
   $var: VarBuilder<TSchema$1>;
   $dir: TDirectiveMethods;
   $colocate: <TEntries extends ColocatedEntries>(entries: TEntries) => ColocatedFields<TEntries>;
@@ -1629,16 +1719,16 @@ declare const createGqlElementComposer: <TSchema$1 extends AnyGraphqlSchema, TFr
  * the Context type.
  */
 type AnyGqlContext = {
-  readonly fragment: Record<string, unknown>;
-  readonly query: {
+  readonly fragment: (...args: unknown[]) => unknown;
+  readonly query: ((...args: unknown[]) => unknown) & {
     operation: (...args: unknown[]) => AnyOperation;
     compat: (...args: unknown[]) => AnyGqlDefine;
   };
-  readonly mutation: {
+  readonly mutation: ((...args: unknown[]) => unknown) & {
     operation: (...args: unknown[]) => AnyOperation;
     compat: (...args: unknown[]) => AnyGqlDefine;
   };
-  readonly subscription: {
+  readonly subscription: ((...args: unknown[]) => unknown) & {
     operation: (...args: unknown[]) => AnyOperation;
     compat: (...args: unknown[]) => AnyGqlDefine;
   };
@@ -1650,6 +1740,29 @@ type AnyGqlContext = {
   readonly [key: string]: unknown;
 };
 //#endregion
+//#region packages/core/src/composer/input.d.ts
+/**
+ * Creates variable assignments from provided values.
+ *
+ * Maps variable definitions to VarRefs. If a value is provided,
+ * wraps it as a nested-value VarRef. If not provided, creates
+ * an undefined VarRef (field will be omitted).
+ *
+ * Used when spreading fragments with partial variable values.
+ *
+ * @internal
+ */
+declare const createVarAssignments: <TSchema$1 extends AnyGraphqlSchema, TVariableDefinitions extends VariableDefinitions>(definitions: TVariableDefinitions, providedValues: AnyAssignableInput | void) => DeclaredVariables<TSchema$1, TVariableDefinitions>;
+/**
+ * Creates variable references from variable definitions.
+ *
+ * Maps each variable definition to a VarRef pointing to that variable.
+ * Used in operation builders to create the `$` context object.
+ *
+ * @internal
+ */
+declare const createVarRefs: <TSchema$1 extends AnyGraphqlSchema, TVarDefinitions$1 extends VariableDefinitions>(definitions: TVarDefinitions$1) => DeclaredVariables<TSchema$1, TVarDefinitions$1>;
+//#endregion
 //#region packages/core/src/composer/operation.d.ts
 /**
  * Creates a factory for composing GraphQL operations.
@@ -1677,21 +1790,52 @@ declare const createOperationComposerFactory: <TSchema$1 extends AnyGraphqlSchem
 //#endregion
 //#region packages/core/src/composer/operation-core.d.ts
 /**
- * Parameters for building an operation artifact.
- * Used by both operation and extend composers.
+ * Shared base parameters for building an operation artifact.
+ * @internal
  */
-type OperationCoreParams<TSchema$1 extends AnyGraphqlSchema, TOperationType$1 extends OperationType, TOperationName$1 extends string, TVarDefinitions$1 extends VariableDefinitions, TFields$1 extends AnyFieldsExtended, TOperationMetadata, TAdapter extends AnyMetadataAdapter> = {
+type OperationCoreParamsBase<TSchema$1 extends AnyGraphqlSchema, TOperationType$1 extends OperationType, TOperationName$1 extends string, TVarDefinitions$1 extends VariableDefinitions, TOperationMetadata, TAdapter extends AnyMetadataAdapter> = {
   readonly schema: TSchema$1;
   readonly operationType: TOperationType$1;
   readonly operationTypeName: TSchema$1["operations"][TOperationType$1] & keyof TSchema$1["object"] & string;
   readonly operationName: TOperationName$1;
   readonly variables: TVarDefinitions$1;
-  readonly fieldsFactory: FieldsBuilder<TSchema$1, TSchema$1["operations"][TOperationType$1] & keyof TSchema$1["object"] & string, TVarDefinitions$1, TFields$1>;
   readonly adapter: TAdapter;
   readonly metadata?: MetadataBuilder<DeclaredVariables<TSchema$1, TVarDefinitions$1>, TOperationMetadata, ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"], ExtractAdapterTypes<TAdapter>["schemaLevel"]>;
   readonly transformDocument?: OperationDocumentTransformer<TOperationMetadata>;
   readonly adapterTransformDocument?: DocumentTransformer<ExtractAdapterTypes<TAdapter>["schemaLevel"], ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"]>;
 };
+/**
+ * Field factory mode: evaluates fields and builds document at runtime.
+ * @internal
+ */
+type FieldsFactoryParams<TSchema$1 extends AnyGraphqlSchema, TOperationType$1 extends OperationType, TOperationName$1 extends string, TVarDefinitions$1 extends VariableDefinitions, TFields$1 extends AnyFieldsExtended, TOperationMetadata, TAdapter extends AnyMetadataAdapter> = OperationCoreParamsBase<TSchema$1, TOperationType$1, TOperationName$1, TVarDefinitions$1, TOperationMetadata, TAdapter> & {
+  readonly mode: "fieldsFactory";
+  readonly fieldsFactory: FieldsBuilder<TSchema$1, TSchema$1["operations"][TOperationType$1] & keyof TSchema$1["object"] & string, TVarDefinitions$1, TFields$1>;
+  readonly prebuiltDocument?: never;
+  readonly prebuiltVariableNames?: never;
+};
+/**
+ * Pre-built document mode: uses pre-parsed DocumentNode directly.
+ * Fragment usages are empty (GraphQL-level fragment spreads in the AST
+ * don't participate in soda-gql metadata pipeline).
+ * @internal
+ */
+type PrebuiltDocumentParams<TSchema$1 extends AnyGraphqlSchema, TOperationType$1 extends OperationType, TOperationName$1 extends string, TVarDefinitions$1 extends VariableDefinitions, TFields$1 extends AnyFieldsExtended, TOperationMetadata, TAdapter extends AnyMetadataAdapter> = OperationCoreParamsBase<TSchema$1, TOperationType$1, TOperationName$1, TVarDefinitions$1, TOperationMetadata, TAdapter> & {
+  readonly mode: "prebuilt";
+  readonly prebuiltDocument: graphql0.DocumentNode;
+  readonly prebuiltVariableNames?: string[];
+  readonly fieldsFactory?: never;
+};
+/**
+ * Parameters for building an operation artifact.
+ * Used by both operation and extend composers.
+ *
+ * Discriminated union of two mutually exclusive modes:
+ * - **Field factory mode**: Uses `fieldsFactory` to evaluate fields and build document.
+ * - **Pre-built document mode**: Uses `prebuiltDocument` and `prebuiltVariableNames` to skip
+ *   field evaluation and document building.
+ */
+type OperationCoreParams<TSchema$1 extends AnyGraphqlSchema, TOperationType$1 extends OperationType, TOperationName$1 extends string, TVarDefinitions$1 extends VariableDefinitions, TFields$1 extends AnyFieldsExtended, TOperationMetadata, TAdapter extends AnyMetadataAdapter> = FieldsFactoryParams<TSchema$1, TOperationType$1, TOperationName$1, TVarDefinitions$1, TFields$1, TOperationMetadata, TAdapter> | PrebuiltDocumentParams<TSchema$1, TOperationType$1, TOperationName$1, TVarDefinitions$1, TFields$1, TOperationMetadata, TAdapter>;
 /**
  * Result type from buildOperationArtifact.
  * Matches the artifact shape expected by Operation.create().
@@ -1718,9 +1862,357 @@ type OperationArtifactResult<TOperationType$1 extends OperationType, TOperationN
  * @param params - Operation building parameters
  * @returns Operation artifact or Promise of artifact (if async metadata)
  *
- * @internal Used by operation.ts and extend.ts
+ * @internal Used by operation.ts, extend.ts, and operation-tagged-template.ts
  */
 declare const buildOperationArtifact: <TSchema$1 extends AnyGraphqlSchema, TOperationType$1 extends OperationType, TOperationName$1 extends string, TVarDefinitions$1 extends VariableDefinitions, TFields$1 extends AnyFieldsExtended, TOperationMetadata, TAdapter extends AnyMetadataAdapter>(params: OperationCoreParams<TSchema$1, TOperationType$1, TOperationName$1, TVarDefinitions$1, TFields$1, TOperationMetadata, TAdapter>) => OperationArtifactResult<TOperationType$1, TOperationName$1, TVarDefinitions$1, TFields$1, TOperationMetadata> | Promise<OperationArtifactResult<TOperationType$1, TOperationName$1, TVarDefinitions$1, TFields$1, TOperationMetadata>>;
+/**
+ * Wraps a buildOperationArtifact call into an Operation.create() invocation,
+ * handling both sync and async artifact results.
+ *
+ * @param artifactFactory - Factory that produces the artifact (may return Promise for async metadata)
+ * @param overrideDocumentSource - When true, overrides documentSource to return empty object.
+ *   Required for pre-built document mode where fields = {} and the real documentSource is meaningless.
+ *   Must be false for fieldsFactory mode to preserve real field selections.
+ *
+ * @internal Used by extend.ts and operation-tagged-template.ts
+ */
+declare const wrapArtifactAsOperation: <TOperationType$1 extends OperationType>(artifactFactory: () => OperationArtifactResult<TOperationType$1, string, VariableDefinitions, AnyFieldsExtended, unknown> | Promise<OperationArtifactResult<TOperationType$1, string, VariableDefinitions, AnyFieldsExtended, unknown>>, overrideDocumentSource: boolean) => AnyOperationOf<TOperationType$1>;
+//#endregion
+//#region packages/core/src/graphql/fragment-args-preprocessor.d.ts
+/**
+ * Preprocessor for Fragment Arguments RFC syntax.
+ *
+ * Strips fragment argument declarations and spread arguments by replacing
+ * them with equal-length whitespace to preserve line/column alignment.
+ *
+ * @module
+ */
+/** Result of fragment arguments preprocessing. */
+type PreprocessResult = {
+  /** Content with Fragment Arguments syntax replaced by whitespace. */
+  readonly preprocessed: string;
+  /** Whether any preprocessing was applied. */
+  readonly modified: boolean;
+};
+/**
+ * Preprocess Fragment Arguments RFC syntax by replacing argument lists with spaces.
+ *
+ * Transforms:
+ * - `fragment UserProfile($showEmail: Boolean = false) on User` -> `fragment UserProfile                               on User`
+ * - `...UserProfile(showEmail: true)` -> `...UserProfile                  `
+ */
+declare const preprocessFragmentArgs: (content: string) => PreprocessResult;
+//#endregion
+//#region packages/core/src/graphql/result.d.ts
+/**
+ * Self-contained Result type for GraphQL parser utilities.
+ * Avoids neverthrow dependency in @soda-gql/core.
+ * @module
+ */
+/** Discriminated union: ok=true carries value, ok=false carries error */
+type Result<T, E> = OkResult<T> | ErrResult<E>;
+type OkResult<T> = {
+  readonly ok: true;
+  readonly value: T;
+};
+type ErrResult<E> = {
+  readonly ok: false;
+  readonly error: E;
+};
+/** Create a successful Result */
+declare const ok: <T>(value: T) => OkResult<T>;
+/** Create a failed Result */
+declare const err: <E>(error: E) => ErrResult<E>;
+//#endregion
+//#region packages/core/src/graphql/types.d.ts
+/**
+ * Parsed GraphQL operation (query, mutation, subscription).
+ */
+type ParsedOperation = {
+  readonly kind: "query" | "mutation" | "subscription";
+  readonly name: string;
+  readonly variables: readonly ParsedVariable[];
+  readonly selections: readonly ParsedSelection[];
+  readonly sourceFile: string;
+};
+/**
+ * Parsed GraphQL fragment definition.
+ */
+type ParsedFragment = {
+  readonly name: string;
+  readonly onType: string;
+  readonly selections: readonly ParsedSelection[];
+  readonly sourceFile: string;
+};
+/**
+ * Type information consisting of base type name and modifier.
+ */
+type TypeInfo = {
+  readonly typeName: string;
+  readonly modifier: string;
+};
+/**
+ * Inferred variable from fragment field arguments.
+ */
+type InferredVariable = {
+  readonly name: string;
+  readonly typeName: string;
+  readonly modifier: string;
+  readonly typeKind: "scalar" | "enum" | "input";
+};
+/**
+ * Parsed variable definition from a GraphQL operation.
+ */
+type ParsedVariable = {
+  readonly name: string;
+  readonly typeName: string;
+  readonly modifier: string;
+  readonly typeKind: "scalar" | "enum" | "input";
+  readonly defaultValue?: ParsedValue;
+};
+/**
+ * Parsed selection from a SelectionSet.
+ */
+type ParsedSelection = ParsedFieldSelection | ParsedFragmentSpread | ParsedInlineFragment;
+/**
+ * Parsed field selection.
+ */
+type ParsedFieldSelection = {
+  readonly kind: "field";
+  readonly name: string;
+  readonly alias?: string;
+  readonly arguments?: readonly ParsedArgument[];
+  readonly selections?: readonly ParsedSelection[];
+};
+/**
+ * Parsed fragment spread (...FragmentName).
+ */
+type ParsedFragmentSpread = {
+  readonly kind: "fragmentSpread";
+  readonly name: string;
+};
+/**
+ * Parsed inline fragment (... on Type { }).
+ */
+type ParsedInlineFragment = {
+  readonly kind: "inlineFragment";
+  readonly onType: string;
+  readonly selections: readonly ParsedSelection[];
+};
+/**
+ * Parsed argument for a field.
+ */
+type ParsedArgument = {
+  readonly name: string;
+  readonly value: ParsedValue;
+};
+/**
+ * Parsed value (can be literal or variable reference).
+ */
+type ParsedValue = {
+  readonly kind: "variable";
+  readonly name: string;
+} | {
+  readonly kind: "int";
+  readonly value: string;
+} | {
+  readonly kind: "float";
+  readonly value: string;
+} | {
+  readonly kind: "string";
+  readonly value: string;
+} | {
+  readonly kind: "boolean";
+  readonly value: boolean;
+} | {
+  readonly kind: "null";
+} | {
+  readonly kind: "enum";
+  readonly value: string;
+} | {
+  readonly kind: "list";
+  readonly values: readonly ParsedValue[];
+} | {
+  readonly kind: "object";
+  readonly fields: readonly ParsedObjectField[];
+};
+/**
+ * Parsed object field in an object value.
+ */
+type ParsedObjectField = {
+  readonly name: string;
+  readonly value: ParsedValue;
+};
+/**
+ * Result of parsing a GraphQL source.
+ */
+type ParseResult = {
+  readonly document: DocumentNode;
+  readonly operations: readonly ParsedOperation[];
+  readonly fragments: readonly ParsedFragment[];
+};
+/**
+ * Error types for GraphQL analysis operations.
+ */
+type GraphqlAnalysisError = {
+  readonly code: "GRAPHQL_FILE_NOT_FOUND";
+  readonly message: string;
+  readonly filePath: string;
+} | {
+  readonly code: "GRAPHQL_PARSE_ERROR";
+  readonly message: string;
+  readonly filePath: string;
+  readonly line?: number;
+  readonly column?: number;
+} | {
+  readonly code: "GRAPHQL_INVALID_OPERATION";
+  readonly message: string;
+  readonly operationName?: string;
+} | {
+  readonly code: "GRAPHQL_UNKNOWN_TYPE";
+  readonly message: string;
+  readonly typeName: string;
+} | {
+  readonly code: "GRAPHQL_FRAGMENT_NOT_FOUND";
+  readonly message: string;
+  readonly fragmentName: string;
+} | {
+  readonly code: "GRAPHQL_OUTPUT_ERROR";
+  readonly message: string;
+  readonly outputPath: string;
+} | {
+  readonly code: "GRAPHQL_INLINE_FRAGMENT_ON_INTERFACE";
+  readonly message: string;
+  readonly onType: string;
+} | {
+  readonly code: "GRAPHQL_UNDECLARED_VARIABLE";
+  readonly message: string;
+  readonly variableName: string;
+} | {
+  readonly code: "GRAPHQL_INLINE_FRAGMENT_WITHOUT_TYPE";
+  readonly message: string;
+} | {
+  readonly code: "GRAPHQL_VARIABLE_TYPE_MISMATCH";
+  readonly message: string;
+  readonly variableName: string;
+} | {
+  readonly code: "GRAPHQL_VARIABLE_MODIFIER_INCOMPATIBLE";
+  readonly message: string;
+  readonly variableName: string;
+} | {
+  readonly code: "GRAPHQL_FRAGMENT_CIRCULAR_DEPENDENCY";
+  readonly message: string;
+  readonly fragmentNames: readonly string[];
+} | {
+  readonly code: "GRAPHQL_UNKNOWN_FIELD";
+  readonly message: string;
+  readonly typeName: string;
+  readonly fieldName: string;
+} | {
+  readonly code: "GRAPHQL_UNKNOWN_ARGUMENT";
+  readonly message: string;
+  readonly fieldName: string;
+  readonly argumentName: string;
+};
+//#endregion
+//#region packages/core/src/graphql/parser.d.ts
+/** Parse GraphQL source string directly. No file I/O. */
+declare const parseGraphqlSource: (source: string, sourceFile: string) => Result<ParseResult, GraphqlAnalysisError>;
+/**
+ * Parse a GraphQL TypeNode into type name and modifier.
+ *
+ * Format: inner nullability + list modifiers
+ * - Inner: `!` (non-null) or `?` (nullable)
+ * - List: `[]!` (non-null list) or `[]?` (nullable list)
+ */
+declare const parseTypeNode: (node: TypeNode) => TypeInfo;
+//#endregion
+//#region packages/core/src/graphql/schema-adapter.d.ts
+/**
+ * Create a minimal SchemaIndex from AnyGraphqlSchema.
+ *
+ * IMPORTANT: This adapter produces a "name-resolution only" SchemaIndex.
+ * Only the name-level Maps are populated (.has() lookups work).
+ * Field-level data (FieldDefinitionNode, InputValueDefinitionNode, etc.)
+ * is NOT populated -- those Maps are empty.
+ *
+ * Use this when you need SchemaIndex for type kind resolution only
+ * (e.g., buildVarSpecifier). For full SchemaIndex with field-level data,
+ * use createSchemaIndex(DocumentNode) from schema-index.ts.
+ */
+declare const createSchemaIndexFromSchema: (schema: AnyGraphqlSchema) => SchemaIndex;
+//#endregion
+//#region packages/core/src/graphql/transformer.d.ts
+declare const isModifierAssignable: (source: string, target: string) => boolean;
+declare const mergeModifiers: (a: string, b: string) => {
+  ok: true;
+  value: string;
+} | {
+  ok: false;
+  reason: string;
+};
+type VariableUsage = {
+  readonly name: string;
+  readonly typeName: string;
+  readonly expectedModifier: string;
+  readonly minimumModifier: string;
+  readonly typeKind: "scalar" | "enum" | "input";
+};
+declare const getArgumentType: (schema: SchemaIndex, parentTypeName: string, fieldName: string, argumentName: string) => TypeInfo | null;
+declare const getInputFieldType: (schema: SchemaIndex, inputTypeName: string, fieldName: string) => TypeInfo | null;
+declare const collectVariableUsages: (selections: readonly ParsedSelection[], parentTypeName: string, schema: SchemaIndex) => Result<VariableUsage[], GraphqlAnalysisError>;
+declare const getFieldReturnType: (schema: SchemaIndex, parentTypeName: string, fieldName: string) => string | null;
+declare const mergeVariableUsages: (variableName: string, usages: readonly VariableUsage[]) => Result<InferredVariable, GraphqlAnalysisError>;
+declare const inferVariablesFromUsages: (usages: readonly VariableUsage[]) => Result<InferredVariable[], GraphqlAnalysisError>;
+declare const sortFragmentsByDependency: (fragments: readonly ParsedFragment[]) => Result<ParsedFragment[], GraphqlAnalysisError>;
+type EnrichedOperation = Omit<ParsedOperation, "variables"> & {
+  readonly variables: readonly EnrichedVariable[];
+  readonly fragmentDependencies: readonly string[];
+};
+type EnrichedFragment = ParsedFragment & {
+  readonly fragmentDependencies: readonly string[];
+  readonly variables: readonly InferredVariable[];
+};
+type EnrichedVariable = Omit<ParsedVariable, "typeKind"> & {
+  readonly typeKind: "scalar" | "enum" | "input";
+};
+type TransformResult = {
+  readonly operations: readonly EnrichedOperation[];
+  readonly fragments: readonly EnrichedFragment[];
+};
+type TransformOptions = {
+  readonly schemaDocument: DocumentNode;
+};
+declare const transformParsedGraphql: (parsed: ParseResult, options: TransformOptions) => Result<TransformResult, GraphqlAnalysisError>;
+//#endregion
+//#region packages/core/src/graphql/var-specifier-builder.d.ts
+/**
+ * Runtime VarSpecifier shape produced by this builder.
+ * Compatible with GenericVarSpecifier from var-builder.ts.
+ */
+type BuiltVarSpecifier = {
+  readonly kind: "scalar" | "enum" | "input";
+  readonly name: string;
+  readonly modifier: string;
+  readonly defaultValue: null | {
+    readonly default: unknown;
+  };
+  readonly directives: Record<string, never>;
+};
+/**
+ * Convert a VariableDefinitionNode to a VarSpecifier.
+ * Resolves `kind` (scalar/enum/input) from the schema index.
+ *
+ * @throws Error if type name cannot be resolved in schema
+ */
+declare const buildVarSpecifier: (node: VariableDefinitionNode, schema: SchemaIndex) => BuiltVarSpecifier;
+/**
+ * Convert all variable definitions from a list of VariableDefinitionNodes
+ * into a record keyed by variable name.
+ *
+ * @throws Error if any type name cannot be resolved in schema
+ */
+declare const buildVarSpecifiers: (nodes: readonly VariableDefinitionNode[], schema: SchemaIndex) => Record<string, BuiltVarSpecifier>;
 //#endregion
 //#region packages/core/src/prebuilt/type-calculator.d.ts
 /**
@@ -1905,8 +2397,8 @@ type PrebuiltTypeRegistry = {
  * Empty registry type for when no prebuilt types are available.
  */
 type EmptyPrebuiltTypeRegistry = {
-  readonly fragments: Record<string, never>;
-  readonly operations: Record<string, never>;
+  readonly fragments: {};
+  readonly operations: {};
 };
 /**
  * Extract the input type for a fragment from the registry.
@@ -1966,5 +2458,5 @@ type Hidden<T> = () => T;
 //#region packages/core/src/utils/wrap-by-key.d.ts
 declare function wrapByKey<TName$1 extends string, TValue$1>(name: TName$1, value: TValue$1): { [K in TName$1]: TValue$1 };
 //#endregion
-export { FragmentBuilderFor as $, ConstAssignableInputValue as $n, SwitchIfOmittable as $t, createOperationComposerFactory as A, AnyNestedUnion as An, GqlElementAttachment as At, InputTypeMethod as B, AnyAssignableInputValue as Bn, FieldSelectionFactoryFieldArguments as Bt, getEnumType as C, AbstractFieldSelection as Cn, AnyFragment as Ct, OperationArtifactResult as D, AnyFieldsExtended as Dn, DefineInferMeta as Dt, graphqlTypeToTypeScript as E, AnyFields as En, AnyGqlDefine as Et, GqlElementComposerOptions as F, InferFieldsExtended as Fn, ExtractCompatSpec as Ft, VarBuilder as G, DeclaredVariables as Gn, FieldsBuilder as Gt, ResolveTypeFromMeta as H, AssignableInput as Hn, FieldSelectionFactoryPrimitiveReturn as Ht, GqlElementComposerWithSchema as I, ScalarShorthand as In, AnyFieldSelectionFactory as It, createVarMethod as J, AnyConstDirectiveAttachments as Jn, NestedObjectFieldsBuilderTools as Jt, VarBuilderMethods as K, FieldArgumentValue as Kn, FieldsBuilderTools as Kt, createGqlElementComposer as L, UnionSelection as Ln, AnyFieldSelectionFactoryReturn as Lt, ExtractMetadataAdapter as M, FieldSelectionTemplateOf as Mn, GqlElementDefinitionFactory as Mt, FragmentBuildersAll as N, InferField as Nn, AnyCompatSpec as Nt, OperationCoreParams as O, AnyNestedObject as On, GqlDefine as Ot, GqlElementComposer as P, InferFields as Pn, CompatSpec as Pt, withFragmentUsageCollection as Q, ConstAssignableInputFromVarDefs as Qn, OptionalArg as Qt, AnyInputTypeMethods as R, AnyDirectiveAttachments as Rn, FieldSelectionFactories as Rt, generateInputTypeFromVarDefs as S, parseOutputSpecifier as Sn, OperationInferMeta as St, getScalarOutputType as T, AnyFieldValue as Tn, FragmentInferMeta as Tt, SchemaAwareGetNameAt as U, AssignableInputByFieldName as Un, FieldSelectionFactoryReturn as Ut, InputTypeMethods as V, AnyAssigningInput as Vn, FieldSelectionFactoryObjectReturn as Vt, SchemaAwareGetValueAt as W, AssignableInputFromVarDefs as Wn, FieldSelectionFactoryUnionReturn as Wt, FragmentUsageRecord as X, AnyConstAssignableInputValue as Xn, EmptyObject as Xt, createVarMethodFactory as Y, AnyConstAssignableInput as Yn, NestedUnionFieldsBuilder as Yt, recordFragmentUsage as Z, ConstAssignableInput as Zn, IfOmittable as Zt, calculateFieldType as _, buildOperationTypeNode as _n, CompatOptions as _t, HasPrebuiltFragment as a, ColocatedEntries as an, DirectiveLocation as ar, createExtendComposer as at, generateInputType as b, ParsedOutputSpecifier as bn, AnyOperationOf as bt, PrebuiltFragmentInput as c, StripFunctions as cn, ExecutableDirectiveLocation as cr, DirectiveArgumentSpecifiers as ct, PrebuiltOperationOutput as d, UnionToIntersection as dn, StandardDirectives as dt, empty as en, ConstAssignableInputValueFromVarSpec as er, createGqlFragmentComposers as et, PrebuiltTypeRegistry as f, AnyVarSpecifier as fn, createDirectiveBuilder as ft, applyTypeModifier as g, buildDocument as gn, isDirectiveRef as gt, TypeFormatters as h, buildConstValueNode as hn, createTypedDirectiveMethod as ht, EmptyPrebuiltTypeRegistry as i, ColocateHelper as in, DirectiveArgumentSpecifier as ir, ExtendOptions as it, AnyGqlContext as j, AnyUnionSelection as jn, GqlElementContext as jt, buildOperationArtifact as k, AnyNestedObjectExtended as kn, GqlElement as kt, PrebuiltFragmentOutput as l, StripSymbols as ln, TypeSystemDirectiveLocation as lr, DirectiveBuilder as lt, GenerateInputObjectTypeOptions as m, buildArgumentValue as mn, createStandardDirectives as mt, Hidden as n, AttachmentToProperty as nn, AnyDirectiveRef as nr, createVarRefs as nt, HasPrebuiltOperation as o, ColocatedFields as on, DirectiveRef as or, AnyDirectiveMethod as ot, PrebuiltUnknownElement as p, EnumLookup as pn, createDirectiveMethod as pt, createVarBuilder as q, FragmentVariableValue as qn, NestedObjectFieldsBuilder as qt, hidden as r, AttachmentsTupleToIntersection as rn, AnyDirectiveRefBrand as rr, createFieldFactories as rt, PrebuiltEntryNotFound as s, createColocateHelper as sn, DirectiveRefInner as sr, DirectiveArgValue as st, wrapByKey as t, AttachmentShape as tn, GetAssignableType as tr, createVarAssignments as tt, PrebuiltOperationInput as u, Tuple as un, DirectiveMethod as ut, calculateFieldsType as v, buildWithTypeModifier as vn, createCompatComposer as vt, getScalarInputType as w, AnyFieldSelection as wn, Fragment as wt, generateInputTypeFromSpecifiers as x, parseInputSpecifier as xn, Operation as xt, generateInputObjectType as y, ParsedInputSpecifier as yn, AnyOperation as yt, GenericVarSpecifier as z, AnyAssignableInput as zn, FieldSelectionFactory as zt };
-//# sourceMappingURL=index-BcK5E-j7.d.ts.map
+export { ParsedFieldSelection as $, FieldSelectionFactory as $n, AnyAssignableInput as $r, TemplateResult as $t, EnrichedFragment as A, AnyOperation as An, buildDocument as Ar, GenericVarSpecifier as At, inferVariablesFromUsages as B, GqlElement as Bn, AnyFields as Br, createVarMethodFactory as Bt, getEnumType as C, TypeSystemDirectiveLocation as Ci, createTypedDirectiveMethod as Cn, StripSymbols as Cr, AnyGqlContext as Ct, BuiltVarSpecifier as D, createCompatTaggedTemplate as Dn, EnumLookup as Dr, GqlElementComposerWithSchema as Dt, graphqlTypeToTypeScript as E, CurriedCompatFunction as En, AnyVarSpecifier as Er, GqlElementComposerOptions as Et, VariableUsage as F, Fragment as Fn, parseInputSpecifier as Fr, SchemaAwareGetValueAt as Ft, transformParsedGraphql as G, AnyExtendableSpec as Gn, AnyUnionSelection as Gr, FragmentTaggedTemplateFunction as Gt, mergeModifiers as H, GqlElementContext as Hn, AnyNestedObject as Hr, recordFragmentUsage as Ht, collectVariableUsages as I, FragmentInferMeta as In, parseOutputSpecifier as Ir, VarBuilder as It, parseTypeNode as J, TemplateCompatSpec as Jn, InferFields as Jr, extractFragmentVariables as Jt, createSchemaIndexFromSchema as K, CompatSpec as Kn, FieldSelectionTemplateOf as Kr, buildFieldsFromSelectionSet as Kt, getArgumentType as L, AnyGqlDefine as Ln, AbstractFieldSelection as Lr, VarBuilderMethods as Lt, EnrichedVariable as M, Operation as Mn, buildWithTypeModifier as Mr, InputTypeMethods as Mt, TransformOptions as N, OperationInferMeta as Nn, ParsedInputSpecifier as Nr, ResolveTypeFromMeta as Nt, buildVarSpecifier as O, CompatOptions as On, buildArgumentValue as Or, createGqlElementComposer as Ot, TransformResult as P, AnyFragment as Pn, ParsedOutputSpecifier as Pr, SchemaAwareGetNameAt as Pt, ParsedArgument as Q, FieldSelectionFactories as Qn, AnyDirectiveAttachments as Qr, OperationTemplateMetadataOptions as Qt, getFieldReturnType as R, DefineInferMeta as Rn, AnyFieldSelection as Rr, createVarBuilder as Rt, generateInputTypeFromVarDefs as S, ExecutableDirectiveLocation as Si, createStandardDirectives as Sn, StripFunctions as Sr, createVarRefs as St, getScalarOutputType as T, CompatTaggedTemplate as Tn, UnionToIntersection as Tr, GqlElementComposer as Tt, mergeVariableUsages as U, GqlElementDefinitionFactory as Un, AnyNestedObjectExtended as Ur, withFragmentUsageCollection as Ut, isModifierAssignable as V, GqlElementAttachment as Vn, AnyFieldsExtended as Vr, FragmentUsageRecord as Vt, sortFragmentsByDependency as W, AnyCompatSpec as Wn, AnyNestedUnion as Wr, CurriedFragmentFunction as Wt, InferredVariable as X, AnyFieldSelectionFactory as Xn, ScalarShorthand as Xr, FragmentTemplateMetadataOptions as Xt, GraphqlAnalysisError as Y, isTemplateCompatSpec as Yn, InferFieldsExtended as Yr, CurriedOperationFunction as Yt, ParseResult as Z, AnyFieldSelectionFactoryReturn as Zn, UnionSelection as Zr, OperationTaggedTemplateFunction as Zt, calculateFieldType as _, AnyDirectiveRefBrand as _i, DirectiveBuilder as _n, AttachmentsTupleToIntersection as _r, OperationCoreParams as _t, HasPrebuiltFragment as a, DeclaredVariables as ai, ObjectRecord as an, FieldsBuilder as ar, ParsedSelection as at, generateInputType as b, DirectiveRef as bi, createDirectiveBuilder as bn, ColocatedFields as br, createOperationComposerFactory as bt, PrebuiltFragmentInput as c, AnyConstDirectiveAttachments as ci, SchemaIndex as cn, NestedObjectFieldsBuilderTools as cr, TypeInfo as ct, PrebuiltOperationOutput as d, ConstAssignableInput as di, createFieldFactories as dn, IfOmittable as dr, Result as dt, AnyAssignableInputValue as ei, TemplateResultMetadataOptions as en, FieldSelectionFactoryFieldArguments as er, ParsedFragment as et, PrebuiltTypeRegistry as f, ConstAssignableInputFromVarDefs as fi, ExtendOptions as fn, OptionalArg as fr, err as ft, applyTypeModifier as g, AnyDirectiveRef as gi, DirectiveArgumentSpecifiers as gn, AttachmentToProperty as gr, OperationArtifactResult as gt, TypeFormatters as h, GetAssignableType as hi, DirectiveArgValue as hn, AttachmentShape as hr, preprocessFragmentArgs as ht, EmptyPrebuiltTypeRegistry as i, AssignableInputFromVarDefs as ii, InputRecord as in, FieldSelectionFactoryUnionReturn as ir, ParsedOperation as it, EnrichedOperation as j, AnyOperationOf as jn, buildOperationTypeNode as jr, InputTypeMethod as jt, buildVarSpecifiers as k, createCompatComposer as kn, buildConstValueNode as kr, AnyInputTypeMethods as kt, PrebuiltFragmentOutput as l, AnyConstAssignableInput as li, UnionRecord as ln, NestedUnionFieldsBuilder as lr, ErrResult as lt, GenerateInputObjectTypeOptions as m, ConstAssignableInputValueFromVarSpec as mi, AnyDirectiveMethod as mn, empty as mr, PreprocessResult as mt, Hidden as n, AssignableInput as ni, DirectiveRecord as nn, FieldSelectionFactoryPrimitiveReturn as nr, ParsedInlineFragment as nt, HasPrebuiltOperation as o, FieldArgumentValue as oi, OperationTypeNames as on, FieldsBuilderTools as or, ParsedValue as ot, PrebuiltUnknownElement as p, ConstAssignableInputValue as pi, createExtendComposer as pn, SwitchIfOmittable as pr, ok as pt, parseGraphqlSource as q, ExtractCompatSpec as qn, InferField as qr, createFragmentTaggedTemplate as qt, hidden as r, AssignableInputByFieldName as ri, EnumRecord as rn, FieldSelectionFactoryReturn as rr, ParsedObjectField as rt, PrebuiltEntryNotFound as s, FragmentVariableValue as si, ScalarRecord as sn, NestedObjectFieldsBuilder as sr, ParsedVariable as st, wrapByKey as t, AnyAssigningInput as ti, createOperationTaggedTemplate as tn, FieldSelectionFactoryObjectReturn as tr, ParsedFragmentSpread as tt, PrebuiltOperationInput as u, AnyConstAssignableInputValue as ui, createSchemaIndex as un, EmptyObject as ur, OkResult as ut, calculateFieldsType as v, DirectiveArgumentSpecifier as vi, DirectiveMethod as vn, ColocateHelper as vr, buildOperationArtifact as vt, getScalarInputType as w, isDirectiveRef as wn, Tuple as wr, ExtractMetadataAdapter as wt, generateInputTypeFromSpecifiers as x, DirectiveRefInner as xi, createDirectiveMethod as xn, createColocateHelper as xr, createVarAssignments as xt, generateInputObjectType as y, DirectiveLocation as yi, StandardDirectives as yn, ColocatedEntries as yr, wrapArtifactAsOperation as yt, getInputFieldType as z, GqlDefine as zn, AnyFieldValue as zr, createVarMethod as zt };
+//# sourceMappingURL=index-BnsQQUy6.d.cts.map