@soda-gql/core 0.13.2 → 0.14.0

package/dist/{index-DTUPt4z4.d.cts → index-DJ-yqsXz.d.ts}

@@ -1,4 +1,4 @@
-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 ObjectTypeProfile, $t as ConstValue, A as InferOutputProfile, Dt as DeferredOutputInferrableSpecifier, E as AnyTypeName, Et as DeferredOutputFieldWithArgs, Ht as OutputTypeKind, I as OperationType, It as InputTypeSpecifiers, Jt as VariableDefinitions, K as NestedValueElement, Ot as DeferredOutputSpecifier, Pt as InputTypeKind, Q as GetModifiedType, R as ResolveInputProfileFromMeta, S as VarRefTools, T as AnyGraphqlSchema, U as AnyVarRef, W as AnyVarRefBrand, Xt as GetSignature, Yt as ApplyTypeModifier, Z as GetConstAssignableType, Zt as TypeModifier, a as DefaultMetadataAdapter, bt as AnyDefaultValue, c as ExtractAdapterTypes, dt as GetSpecDefaultValue, et as PrimitiveTypeProfile, ft as GetSpecKind, i as DefaultAdapter, k as InferInputProfile, n as AnyAdapter, ot as InputDepthOverrides, p as OperationDocumentTransformer, pt as GetSpecModifier, q as VarRef, qt as VarSpecifier, r as AnyMetadataAdapter, s as DocumentTransformer, t as Adapter, tn as FieldPath, tt as TypeProfile, w as AnyFieldName, wt as DeferredInputSpecifier, y as MetadataBuilder } from "./index-D1T79XaT.js";
 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";
@@ -142,19 +142,14 @@ type AnyConstAssignableInput = {
 };
 type IsOptional$1<TSpecifier$1 extends DeferredInputSpecifier> = GetSpecModifier<TSpecifier$1> extends `${string}?` ? true : GetSpecDefaultValue<TSpecifier$1> extends AnyDefaultValue ? true : false;
 type IsOptionalVarSpec$1<TSpec$1 extends VarSpecifier> = TSpec$1["modifier"] extends `${string}?` ? true : TSpec$1["defaultValue"] extends AnyDefaultValue ? true : false;
-type ConstAssignableInput<TSchema$1 extends AnyGraphqlSchema, TSpecifiers extends InputTypeSpecifiers> = { readonly [K in keyof TSpecifiers as IsOptional$1<TSpecifiers[K]> extends true ? K : never]+?: ConstAssignableInputValue<TSchema$1, TSpecifiers[K]> } & { readonly [K in keyof TSpecifiers as IsOptional$1<TSpecifiers[K]> extends false ? K : never]-?: ConstAssignableInputValue<TSchema$1, TSpecifiers[K]> };
+type ConstAssignableInput<TSchema extends AnyGraphqlSchema, TSpecifiers extends InputTypeSpecifiers> = { readonly [K in keyof TSpecifiers as IsOptional$1<TSpecifiers[K]> extends true ? K : never]+?: ConstAssignableInputValue<TSchema, TSpecifiers[K]> } & { readonly [K in keyof TSpecifiers as IsOptional$1<TSpecifiers[K]> extends false ? K : never]-?: ConstAssignableInputValue<TSchema, TSpecifiers[K]> };
 /**
  * Constant-only assignable input type for operation variables.
  * Works with VariableDefinitions (VarSpecifier objects) instead of deferred strings.
  */
-type ConstAssignableInputFromVarDefs<TSchema$1 extends AnyGraphqlSchema, TVarDefs extends VariableDefinitions> = { readonly [K in keyof TVarDefs as IsOptionalVarSpec$1<TVarDefs[K]> extends true ? K : never]+?: ConstAssignableInputValueFromVarSpec<TSchema$1, TVarDefs[K]> } & { readonly [K in keyof TVarDefs as IsOptionalVarSpec$1<TVarDefs[K]> extends false ? K : never]-?: ConstAssignableInputValueFromVarSpec<TSchema$1, TVarDefs[K]> };
-type ConstAssignableInputValue<TSchema$1 extends AnyGraphqlSchema, TSpecifier$1 extends DeferredInputSpecifier> = GetConstAssignableType<InferInputProfile<TSchema$1, TSpecifier$1>> & {};
-type ConstAssignableInputValueFromVarSpec<TSchema$1 extends AnyGraphqlSchema, TSpec$1 extends VarSpecifier> = GetConstAssignableType<ResolveInputProfileFromMeta<TSchema$1, TSpec$1["name"], TSpec$1["kind"], TSpec$1["modifier"]>> & {};
-//#endregion
-//#region packages/core/src/types/schema/const-directives.d.ts
-type AnyConstDirectiveAttachments = {
-  readonly [key: string]: AnyConstAssignableInputValue;
-};
+type ConstAssignableInputFromVarDefs<TSchema extends AnyGraphqlSchema, TVarDefs extends VariableDefinitions> = { readonly [K in keyof TVarDefs as IsOptionalVarSpec$1<TVarDefs[K]> extends true ? K : never]+?: ConstAssignableInputValueFromVarSpec<TSchema, TVarDefs[K]> } & { readonly [K in keyof TVarDefs as IsOptionalVarSpec$1<TVarDefs[K]> extends false ? K : never]-?: ConstAssignableInputValueFromVarSpec<TSchema, TVarDefs[K]> };
+type ConstAssignableInputValue<TSchema extends AnyGraphqlSchema, TSpecifier$1 extends DeferredInputSpecifier> = GetConstAssignableType<InferInputProfile<TSchema, TSpecifier$1>> & {};
+type ConstAssignableInputValueFromVarSpec<TSchema extends AnyGraphqlSchema, TSpec$1 extends VarSpecifier> = GetConstAssignableType<ResolveInputProfileFromMeta<TSchema, TSpec$1["name"], TSpec$1["kind"], TSpec$1["modifier"]>> & {};
 //#endregion
 //#region packages/core/src/types/fragment/assignable-input.d.ts
 type AnyAssignableInputValue = ConstValue | AnyVarRef | {
@@ -168,29 +163,29 @@ type AnyAssigningInput = {
 };
 type IsOptional<TSpecifier$1 extends DeferredInputSpecifier> = GetSpecModifier<TSpecifier$1> extends `${string}?` ? true : GetSpecDefaultValue<TSpecifier$1> extends AnyDefaultValue ? true : false;
 type IsOptionalVarSpec<TSpec$1 extends VarSpecifier> = TSpec$1["modifier"] extends `${string}?` ? true : TSpec$1["defaultValue"] extends AnyDefaultValue ? true : false;
-type AssignableInput<TSchema$1 extends AnyGraphqlSchema, TSpecifiers extends InputTypeSpecifiers> = { readonly [K in keyof TSpecifiers as IsOptional<TSpecifiers[K]> extends true ? K : never]+?: FieldArgumentValue<TSchema$1, TSpecifiers[K]> } & { readonly [K in keyof TSpecifiers as IsOptional<TSpecifiers[K]> extends false ? K : never]-?: FieldArgumentValue<TSchema$1, TSpecifiers[K]> };
+type AssignableInput<TSchema extends AnyGraphqlSchema, TSpecifiers extends InputTypeSpecifiers> = { readonly [K in keyof TSpecifiers as IsOptional<TSpecifiers[K]> extends true ? K : never]+?: FieldArgumentValue<TSchema, TSpecifiers[K]> } & { readonly [K in keyof TSpecifiers as IsOptional<TSpecifiers[K]> extends false ? K : never]-?: FieldArgumentValue<TSchema, TSpecifiers[K]> };
 /**
  * Assignable input type for fragment/operation variables.
  * Works with VariableDefinitions (VarSpecifier objects) instead of deferred strings.
  */
-type AssignableInputFromVarDefs<TSchema$1 extends AnyGraphqlSchema, TVarDefs extends VariableDefinitions> = { readonly [K in keyof TVarDefs as IsOptionalVarSpec<TVarDefs[K]> extends true ? K : never]+?: FragmentVariableValue<TSchema$1, TVarDefs[K]> } & { readonly [K in keyof TVarDefs as IsOptionalVarSpec<TVarDefs[K]> extends false ? K : never]-?: FragmentVariableValue<TSchema$1, TVarDefs[K]> };
+type AssignableInputFromVarDefs<TSchema extends AnyGraphqlSchema, TVarDefs extends VariableDefinitions> = { readonly [K in keyof TVarDefs as IsOptionalVarSpec<TVarDefs[K]> extends true ? K : never]+?: FragmentVariableValue<TSchema, TVarDefs[K]> } & { readonly [K in keyof TVarDefs as IsOptionalVarSpec<TVarDefs[K]> extends false ? K : never]-?: FragmentVariableValue<TSchema, TVarDefs[K]> };
 /**
  * Fragment variable value type using VarSpecifier properties.
  */
-type FragmentVariableValue<TSchema$1 extends AnyGraphqlSchema, TSpec$1 extends VarSpecifier> = GetAssignableType<ResolveInputProfileFromMeta<TSchema$1, TSpec$1["name"], TSpec$1["kind"], TSpec$1["modifier"]>>;
+type FragmentVariableValue<TSchema extends AnyGraphqlSchema, TSpec$1 extends VarSpecifier> = GetAssignableType<ResolveInputProfileFromMeta<TSchema, TSpec$1["name"], TSpec$1["kind"], TSpec$1["modifier"]>>;
 /**
  * Field argument value type using typeName + kind for VarRef comparison.
  * Uses GetAssignableType which derives typeName + kind from the profile.
  * This name appears in TypeScript error messages when argument types don't match.
  */
-type FieldArgumentValue<TSchema$1 extends AnyGraphqlSchema, TSpecifier$1 extends DeferredInputSpecifier> = GetAssignableType<InferInputProfile<TSchema$1, TSpecifier$1>>;
+type FieldArgumentValue<TSchema extends AnyGraphqlSchema, TSpecifier$1 extends DeferredInputSpecifier> = GetAssignableType<InferInputProfile<TSchema, TSpecifier$1>>;
 /**
  * Declared variables record for an operation or fragment.
  * Maps variable names to their VarRef types with proper branding.
  * 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 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"]>;
+type DeclaredVariables<TSchema extends AnyGraphqlSchema, TVarDefs extends VariableDefinitions> = { readonly [K in keyof TVarDefs]-?: VarRef<TypeProfile.DeclaredVariableType<ResolveInputProfileFromMeta<TSchema, TVarDefs[K]["name"], TVarDefs[K]["kind"], TVarDefs[K]["modifier"]>>> };
+type AssignableInputByFieldName<TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema["object"], TFieldName extends keyof TSchema["object"][TTypeName]["fields"]> = AssignableInput<TSchema, TSchema["object"][TTypeName]["fields"][TFieldName]["arguments"]>;
 //#endregion
 //#region packages/core/src/types/fragment/directives.d.ts
 /**
@@ -226,11 +221,20 @@ type AnyNestedObjectExtended = {
   readonly [alias: string]: AnyFieldValue;
 };
 /**
- * Nested selection produced when resolving a union field. Supports shorthand syntax.
- * Maps union member type names to their field selections.
+ * Wrapper for a single union member's selection within a union field.
+ * Carries both the member's field selections and any directives applied
+ * to the inline fragment (e.g., `... on Article @defer { id }`).
+ */
+type UnionMemberSelection<TFields$1 extends AnyNestedObjectExtended = AnyNestedObjectExtended, TDirectives extends AnyDirectiveAttachments = AnyDirectiveAttachments> = {
+  readonly fields: TFields$1;
+  readonly directives: TDirectives;
+};
+/**
+ * Nested selection produced when resolving a union field.
+ * Maps union member type names to their wrapped field selections with directives.
  */
 type AnyNestedUnion = {
-  readonly [typeName: string]: AnyNestedObjectExtended | undefined;
+  readonly [typeName: string]: UnionMemberSelection | undefined;
 };
 /**
  * Structured union selection with explicit __typename flag.
@@ -251,9 +255,9 @@ type AnyFields = {
  *
  * Supports shorthand syntax in nested object selections via AnyNestedObjectExtended.
  */
-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> = {
+type AbstractFieldSelection<TTypeName extends AnyTypeName, TFieldName 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 field: TFieldName;
   readonly type: TSpecifier$1;
   readonly args: TArgs;
   readonly directives: TDirectives;
@@ -261,9 +265,9 @@ type AbstractFieldSelection<TTypeName extends AnyTypeName, TFieldName$1 extends
   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 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>;
+type FieldSelectionTemplateOf<TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema["object"] & string, TFieldName extends keyof TSchema["object"][TTypeName]["fields"] & string, TRef extends DeferredOutputFieldWithArgs = TSchema["object"][TTypeName]["fields"][TFieldName]> = AbstractFieldSelection<TTypeName, TFieldName, TRef, AssignableInputByFieldName<TSchema, TTypeName, TFieldName>, 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"]];
+type InferFields<TSchema extends AnyGraphqlSchema, TFields$1 extends AnyFields> = { [_ in TSchema["label"]]: { [TAliasName in keyof TFields$1]: InferField<TSchema, TFields$1[TAliasName]> } & {} }[TSchema["label"]];
 /**
  * Remove index signature from a type, keeping only literal string keys.
  * This is needed for inferring union selections where we want to iterate over explicit member keys.
@@ -273,24 +277,24 @@ type RemoveIndexSignature<T> = { [K in keyof T as string extends K ? never : K]:
  * Infer union type with __typename for all members when __typename: true is set.
  * Selected members get their fields + __typename, unselected members get only __typename.
  */
-type InferUnionWithTypename<TSchema$1 extends AnyGraphqlSchema, TUnionName$1 extends keyof TSchema$1["union"] & string, TSelections extends AnyNestedUnion, TSelectionsClean = RemoveIndexSignature<TSelections>> = { [TTypename in keyof TSchema$1["union"][TUnionName$1]["types"] & string]: TTypename extends keyof TSelectionsClean ? TSelectionsClean[TTypename] extends infer TFields extends AnyNestedObjectExtended ? InferFieldsExtended<TSchema$1, TTypename & (keyof TSchema$1["object"] & string), TFields> & {
+type InferUnionWithTypename<TSchema extends AnyGraphqlSchema, TUnionName$1 extends keyof TSchema["union"] & string, TSelections extends AnyNestedUnion, TSelectionsClean = RemoveIndexSignature<TSelections>> = { [TTypename in keyof TSchema["union"][TUnionName$1]["types"] & string]: TTypename extends keyof TSelectionsClean ? TSelectionsClean[TTypename] extends UnionMemberSelection<infer TFields extends AnyNestedObjectExtended> ? InferFieldsExtended<TSchema, TTypename & (keyof TSchema["object"] & string), TFields> & {
   readonly __typename: TTypename;
 } : {
   readonly __typename: TTypename;
 } : {
   readonly __typename: TTypename;
-} }[keyof TSchema$1["union"][TUnionName$1]["types"] & string];
+} }[keyof TSchema["union"][TUnionName$1]["types"] & string];
 /**
  * Infer union type without __typename catch-all (original behavior).
  * Only includes members that have explicit selections.
  */
-type InferUnionWithoutTypename<TSchema$1 extends AnyGraphqlSchema, TSelections extends AnyNestedUnion, TSelectionsClean = RemoveIndexSignature<TSelections>> = { [TTypename in keyof TSelectionsClean]: TSelectionsClean[TTypename] extends infer TFields extends AnyNestedObjectExtended ? InferFieldsExtended<TSchema$1, TTypename & (keyof TSchema$1["object"] & string), TFields> : never }[keyof TSelectionsClean];
+type InferUnionWithoutTypename<TSchema extends AnyGraphqlSchema, TSelections extends AnyNestedUnion, TSelectionsClean = RemoveIndexSignature<TSelections>> = { [TTypename in keyof TSelectionsClean]: TSelectionsClean[TTypename] extends UnionMemberSelection<infer TFields extends AnyNestedObjectExtended> ? InferFieldsExtended<TSchema, TTypename & (keyof TSchema["object"] & string), TFields> : never }[keyof TSelectionsClean];
 /** Resolve the data shape for a single field reference, including nested objects/unions. */
-type InferField<TSchema$1 extends AnyGraphqlSchema, TSelection extends AnyFieldSelection> = TSelection["type"]["spec"] extends infer TSpec extends DeferredOutputSpecifier ? (TSpec extends `o|${infer TName extends string}|${string}` ? TSelection extends {
+type InferField<TSchema extends AnyGraphqlSchema, TSelection extends AnyFieldSelection> = TSelection["type"]["spec"] extends infer TSpec extends DeferredOutputSpecifier ? (TSpec extends `o|${infer TName extends string}|${string}` ? TSelection extends {
   object: infer TNested extends AnyNestedObjectExtended;
-} ? ApplyTypeModifier<InferFieldsExtended<TSchema$1, TName, TNested>, GetSpecModifier<TSpec>> : never : never) | (TSpec extends `u|${infer TUnionName extends keyof TSchema$1["union"] & string}|${string}` ? TSelection extends {
+} ? ApplyTypeModifier<InferFieldsExtended<TSchema, TName, TNested>, GetSpecModifier<TSpec>> : never : never) | (TSpec extends `u|${infer TUnionName extends keyof TSchema["union"] & string}|${string}` ? TSelection extends {
   union: infer TUnion extends AnyUnionSelection;
-} ? ApplyTypeModifier<TUnion["__typename"] extends true ? InferUnionWithTypename<TSchema$1, TUnionName, TUnion["selections"]> : InferUnionWithoutTypename<TSchema$1, TUnion["selections"]>, GetSpecModifier<TSpec>> : never : never) | (TSpec extends DeferredOutputInferrableSpecifier ? GetModifiedType<InferOutputProfile<TSchema$1, TSpec>, GetSpecModifier<TSpec>> : never) : never;
+} ? ApplyTypeModifier<TUnion["__typename"] extends true ? InferUnionWithTypename<TSchema, TUnionName, TUnion["selections"]> : InferUnionWithoutTypename<TSchema, TUnion["selections"]>, GetSpecModifier<TSpec>> : never : never) | (TSpec extends DeferredOutputInferrableSpecifier ? GetModifiedType<InferOutputProfile<TSchema, TSpec>, GetSpecModifier<TSpec>> : never) : never;
 /**
  * Shorthand value for scalar/enum fields without args or directives.
  * Only `true` is valid - use factory syntax for args/directives.
@@ -315,26 +319,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 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;
+type HasNoRequiredArgs<TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema["object"] & string, TFieldName extends keyof TSchema["object"][TTypeName]["fields"] & string> = keyof RequiredKeys<AssignableInputByFieldName<TSchema, TTypeName, TFieldName>> 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 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;
+type ValidateShorthand<TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema["object"] & string, TFieldName extends string, TValue$1> = TValue$1 extends true ? TFieldName extends keyof TSchema["object"][TTypeName]["fields"] & string ? HasNoRequiredArgs<TSchema, TTypeName, TFieldName> 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 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;
+type InferScalarFieldByName<TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema["object"] & string, TFieldName extends keyof TSchema["object"][TTypeName]["fields"]> = TSchema["object"][TTypeName]["fields"][TFieldName] extends infer TSpecifier extends DeferredOutputInferrableSpecifier ? GetModifiedType<InferOutputProfile<TSchema, TSpecifier>, GetSpecModifier<TSpecifier>> : never;
 /**
  * Infer the output type for a single field value (shorthand or factory return).
  */
-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;
+type InferFieldValue<TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema["object"] & string, TFieldKey extends string, TValue$1> = TValue$1 extends true ? TFieldKey extends keyof TSchema["object"][TTypeName]["fields"] & string ? ValidateShorthand<TSchema, TTypeName, TFieldKey, TValue$1> extends true ? InferScalarFieldByName<TSchema, TTypeName, TFieldKey> : never : never : TValue$1 extends AnyFieldSelection ? InferField<TSchema, 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 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"]];
+type InferFieldsExtended<TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema["object"] & string, TFields$1 extends AnyFieldsExtended> = { [_ in TSchema["label"]]: { [K in keyof TFields$1]: InferFieldValue<TSchema, TTypeName, K & string, TFields$1[K]> } & {} }[TSchema["label"]];
 //#endregion
 //#region packages/core/src/utils/deferred-specifier-parser.d.ts
 type ParsedInputSpecifier = {
@@ -411,25 +415,12 @@ declare const buildConstValueNode: (value: ConstValue, enumLookup: EnumLookup) =
  * followed by `[]?` or `[]!` pairs for lists.
  *
  * @example
- * - `"!"` → `String!`
- * - `"?"` → `String`
- * - `"![]!"` → `[String!]!`
- * - `"?[]?"` → `[String]`
+ * - `"!"` -> `String!`
+ * - `"?"` -> `String`
+ * - `"![]!"` -> `[String!]!`
+ * - `"?[]?"` -> `[String]`
  */
 declare const buildWithTypeModifier: (modifier: TypeModifier, buildType: () => NamedTypeNode) => TypeNode;
-/**
- * VarSpecifier shape from $var() at runtime.
- * Operation variables use structured objects, not deferred strings.
- */
-type AnyVarSpecifier = {
-  kind: "scalar" | "enum" | "input";
-  name: string;
-  modifier: TypeModifier;
-  defaultValue: null | {
-    default: ConstValue;
-  };
-  directives: Record<string, unknown>;
-};
 /**
  * Converts an operation type string to a GraphQL AST OperationTypeNode.
  */
@@ -444,14 +435,15 @@ 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 extends keyof TSchema$1["object"] & string, TFields$1 extends AnyFieldsExtended, TVarDefinitions$1 extends VariableDefinitions>(options: {
+declare const buildDocument: <TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema["object"] & string, TFields$1 extends AnyFieldsExtended, TVarDefinitions extends VariableDefinitions>(options: {
   operationName: string;
   operationType: OperationType;
   operationTypeName: TTypeName;
-  variables: TVarDefinitions$1;
+  variableDefinitionNodes?: readonly VariableDefinitionNode[];
+  variables: TVarDefinitions;
   fields: TFields$1;
-  schema: TSchema$1;
-}) => TypedDocumentNode<InferFieldsExtended<TSchema$1, TTypeName, TFields$1>, ConstAssignableInputFromVarDefs<TSchema$1, TVarDefinitions$1>>;
+  schema: TSchema;
+}) => TypedDocumentNode<any, any>;
 //#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;
@@ -480,13 +472,13 @@ type ColocatedFields<TEntries extends ColocatedEntries> = UnionToIntersection<{
  * @example
  * ```typescript
  * // In operation definition
- * query.operation({
- *   name: "GetData",
- *   fields: ({ $ }) => $colocate({
- *     userCard: userCardFragment.spread({ userId: $.userId }),
- *     posts: postsFragment.spread({ userId: $.userId }),
+ * query("GetData")({
+ *   variables: `($userId: ID!)`,
+ *   fields: ({ f, $ }) => $colocate({
+ *     userCard: { ...f("user", { id: $.userId })(() => ({ ...userCardFragment.spread() })) },
+ *     posts: { ...f("posts", { userId: $.userId })(() => ({ ...postsFragment.spread() })) },
  *   }),
- * });
+ * })({});
  *
  * // In parser definition (same labels)
  * createExecutionResultParser({
@@ -498,6 +490,53 @@ type ColocatedFields<TEntries extends ColocatedEntries> = UnionToIntersection<{
 declare const createColocateHelper: () => <TEntries extends ColocatedEntries>(entries: TEntries) => ColocatedFields<TEntries>;
 type ColocateHelper = ReturnType<typeof createColocateHelper>;
 //#endregion
+//#region packages/core/src/composer/fields-builder.d.ts
+/** Builder callback for top-level field selections (has $ variable access) */
+type FieldsBuilder<TFields$1 extends AnyFieldsExtended = AnyFieldsExtended> = (tools: {
+  f: FieldAccessorFunction;
+  $: Readonly<Record<string, AnyVarRef>>;
+}) => TFields$1;
+/** Builder callback for nested object field selections (no $ access) */
+type NestedObjectFieldsBuilder<TFields$1 extends AnyFieldsExtended = AnyFieldsExtended> = (tools: {
+  f: FieldAccessorFunction;
+}) => TFields$1;
+/** Builder for union type selections with per-member field definitions */
+type NestedUnionFieldsBuilder = {
+  [typeName: string]: NestedObjectFieldsBuilder | undefined;
+} & {
+  __typename?: true;
+};
+/**
+ * Type-erased return from field accessor.
+ * The actual runtime shape is a function: for scalar/enum fields it takes no args,
+ * for object fields it takes a NestedObjectFieldsBuilder, for union fields a NestedUnionFieldsBuilder.
+ * This type preserves enough structure so that nested `({ f })` callbacks infer `f` properly.
+ */
+/**
+ * Type-erased return from field accessor.
+ * For object fields: accepts NestedObjectFieldsBuilder (typed `{ f }` callback).
+ * For union fields and scalar thunks: uses catch-all signature.
+ */
+type AnyFieldAccessorReturn = ((nest: NestedObjectFieldsBuilder) => any) & ((...args: any[]) => any);
+/** Function-call field accessor: f("fieldName", args, extras) */
+type FieldAccessorFunction = (fieldName: string, fieldArgs?: AnyFieldSelection["args"] | null | void, extras?: {
+  alias?: string;
+  directives?: AnyDirectiveRef[];
+}) => AnyFieldAccessorReturn;
+/**
+ * Creates a field accessor function for a given object type.
+ *
+ * Returns a function f("fieldName", args, extras) for building field selections.
+ * Factories are cached per schema+type to avoid recreation.
+ *
+ * @param schema - The GraphQL schema definition
+ * @param typeName - The object type name to create factories for
+ * @returns FieldAccessorFunction for building field selections
+ *
+ * @internal Used by operation and fragment composers
+ */
+declare const createFieldFactories: <TSchema extends AnyGraphqlSchema>(schema: TSchema, typeName: string) => FieldAccessorFunction;
+//#endregion
 //#region packages/core/src/types/element/attachment-types.d.ts
 /**
  * Shape constraint for attachment objects used in type utilities.
@@ -527,209 +566,13 @@ type AttachmentToProperty<TAttachment> = TAttachment extends {
  */
 type AttachmentsTupleToIntersection<TAttachments extends readonly AttachmentShape[]> = TAttachments extends readonly [infer First extends AttachmentShape, ...infer Rest extends readonly AttachmentShape[]] ? AttachmentToProperty<First> & AttachmentsTupleToIntersection<Rest> : unknown;
 //#endregion
-//#region packages/core/src/utils/empty-object.d.ts
-declare const __EMPTY_SYMBOL__: unique symbol;
-type EmptyObject = {
-  readonly [__EMPTY_SYMBOL__]: never;
-};
-type IsEmpty<T> = keyof T extends never ? true : false;
-type IsOmittable<T> = {} extends T ? true : false;
-type IfOmittable<TTarget, TType> = IsOmittable<TTarget> extends true ? TType : never;
-type SwitchIfOmittable<TTarget, TTrue, TFalse> = IsOmittable<TTarget> extends true ? TTrue : TFalse;
-/**
- * Make argument optional based on type structure:
- * - Empty object (no keys) → void (must omit)
- * - All-optional object → T | void (can omit or provide)
- * - Has required fields → T (must provide)
- */
-type OptionalArg<T> = IsEmpty<T> extends true ? void : IsOmittable<T> extends true ? T | void : T;
-declare const empty: () => EmptyObject;
-//#endregion
-//#region packages/core/src/types/element/fields-builder.d.ts
-/**
- * Builder signature exposed to userland `model` and `slice` helpers. The
- * tooling `f`/`fields`/`_` aliases provide ergonomic access to GraphQL fields
- * while preserving the original schema information for inference.
- *
- * Supports both shorthand syntax (`id: true`) and factory syntax (`...f.id()`).
- */
-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 extends keyof TSchema$1["object"] & string, TVariableDefinitions extends VariableDefinitions> = {
-  f: FieldSelectionFactories<TSchema$1, TTypeName>;
-  $: DeclaredVariables<TSchema$1, TVariableDefinitions>;
-};
-/**
- * Builder for nested object field selections.
- * Used when a field returns an object type requiring sub-selections.
- *
- * Supports both shorthand syntax (`id: true`) and factory syntax (`...f.id()`).
- */
-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 extends keyof TSchema$1["object"] & string> = {
-  f: FieldSelectionFactories<TSchema$1, TTypeName>;
-};
-/**
- * Builder for union type selections with per-member field definitions.
- * Supports shorthand syntax (`id: true`) within each member's field builder.
- * Use `__typename: true` to enable catch-all __typename discrimination for all union members.
- *
- * Note: The mapped type only includes union member names. The __typename flag is added via
- * intersection. TUnionFields will NOT capture __typename - use direct input inspection instead.
- */
-type NestedUnionFieldsBuilder<TSchema$1 extends AnyGraphqlSchema, TMemberName extends string, TUnionFields extends AnyNestedUnion> = { [TTypename in keyof TUnionFields & TMemberName]?: NestedObjectFieldsBuilder<TSchema$1, TTypename, NonNullable<TUnionFields[TTypename]> & AnyFieldsExtended> } & {
-  __typename?: true;
-};
-/** Map each field to a factory capable of emitting fully-typed references. */
-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
- */
-type AnyFieldSelectionFactory = <TAlias extends string | null = null>(fieldArgs: AnyAssignableInput | void, extras?: {
-  alias?: TAlias;
-  directives?: AnyDirectiveRef[];
-}) => AnyFieldSelectionFactoryReturn<TAlias>;
-/**
- * Factory function for creating a typed field selection.
- * Accepts field arguments and optional alias/directives.
- */
-type FieldSelectionFactory<TSchema$1 extends AnyGraphqlSchema, TSelection extends AnyFieldSelection> = <TAlias extends string | null = null>(fieldArgs: TSelection["args"] | IfOmittable<TSelection["args"], void | null>, extras?: {
-  alias?: TAlias;
-  directives?: AnyDirectiveRef[];
-}) => FieldSelectionFactoryReturn<TSchema$1, TSelection, TAlias>;
-/** Deferred specifier pattern for object types: o|{name}|{modifier} */
-type ObjectSpecifierPattern = `o|${string}|${string}`;
-/** Deferred specifier pattern for union types: u|{name}|{modifier} */
-type UnionSpecifierPattern = `u|${string}|${string}`;
-/** Deferred specifier pattern for primitive types (scalar, enum): s|{name}|{modifier} or e|{name}|{modifier} */
-type PrimitiveSpecifierPattern = `s|${string}|${string}` | `e|${string}|${string}`;
-/** Helper to extract spec from field type */
-type GetFieldTypeSpec<T> = T extends {
-  spec: infer S;
-} ? S : never;
-type AnyFieldSelectionFactoryReturn<TAlias extends string | null> = FieldSelectionFactoryReturn<AnyGraphqlSchema, AnyFieldSelection & {
-  type: {
-    spec: ObjectSpecifierPattern;
-  };
-}, TAlias> | FieldSelectionFactoryReturn<AnyGraphqlSchema, AnyFieldSelection & {
-  type: {
-    spec: UnionSpecifierPattern;
-  };
-}, TAlias> | FieldSelectionFactoryReturn<AnyGraphqlSchema, AnyFieldSelection & {
-  type: {
-    spec: PrimitiveSpecifierPattern;
-  };
-}, TAlias>;
-type FieldSelectionFactoryReturn<TSchema$1 extends AnyGraphqlSchema, TSelection extends AnyFieldSelection, TAlias extends string | null> = GetFieldTypeSpec<TSelection["type"]> extends ObjectSpecifierPattern ? FieldSelectionFactoryObjectReturn<TSchema$1, TSelection & {
-  type: {
-    spec: ObjectSpecifierPattern;
-  };
-}, TAlias> : GetFieldTypeSpec<TSelection["type"]> extends UnionSpecifierPattern ? FieldSelectionFactoryUnionReturn<TSchema$1, TSelection & {
-  type: {
-    spec: UnionSpecifierPattern;
-  };
-}, TAlias> : GetFieldTypeSpec<TSelection["type"]> extends PrimitiveSpecifierPattern ? FieldSelectionFactoryPrimitiveReturn<TSelection & {
-  type: {
-    spec: PrimitiveSpecifierPattern;
-  };
-}, TAlias> : never;
-type FieldSelectionFactoryObjectReturn<TSchema$1 extends AnyGraphqlSchema, TSelection extends AnyFieldSelection & {
-  type: {
-    spec: ObjectSpecifierPattern;
-  };
-}, TAlias extends string | null> = <TNested$1 extends AnyFieldsExtended>(nest: NestedObjectFieldsBuilder<TSchema$1, GetSpecName<TSelection["type"]["spec"]> & keyof TSchema$1["object"] & string, TNested$1>) => { [_ in TAlias extends null ? TSelection["field"] : TAlias]: AbstractFieldSelection<TSelection["parent"], TSelection["field"], TSelection["type"], TSelection["args"], TSelection["directives"], TNested$1, null, false> };
-/**
- * Remove __typename key from a type to get pure selections.
- */
-type OmitTypename<T> = { [K in keyof T as K extends "__typename" ? never : K]: T[K] };
-/**
- * Detect if T has __typename: true (not optional or missing).
- * Uses a pattern that checks if the property is exactly `true` after removing index signatures.
- */
-type InferTypenameFlag<T> = "__typename" extends keyof T ? (T["__typename"] extends true ? true : false) : false;
-/**
- * Constraint for union builder input that allows member builders and optional __typename.
- */
-type UnionBuilderInputConstraint<TSchema$1 extends AnyGraphqlSchema, TMemberName extends string> = { [K in TMemberName]?: NestedObjectFieldsBuilder<TSchema$1, K, AnyFieldsExtended> } & {
-  __typename?: true;
-};
-type FieldSelectionFactoryUnionReturn<TSchema$1 extends AnyGraphqlSchema, TSelection extends AnyFieldSelection & {
-  type: {
-    spec: UnionSpecifierPattern;
-  };
-}, TAlias extends string | null, TMemberName extends string = UnionMemberNameFromDeferred<TSchema$1, TSelection["type"]["spec"]>> = <TInput extends UnionBuilderInputConstraint<TSchema$1, TMemberName>>(nest: TInput) => { [_ in TAlias extends null ? TSelection["field"] : TAlias]: AbstractFieldSelection<TSelection["parent"], TSelection["field"], TSelection["type"], TSelection["args"], TSelection["directives"], null, OmitTypename<TInput> & AnyNestedUnion, InferTypenameFlag<TInput>> };
-/** Helper to get union member names from a deferred union specifier */
-type UnionMemberNameFromDeferred<TSchema$1 extends AnyGraphqlSchema, TSpecifier$1 extends DeferredOutputSpecifier> = GetSpecName<TSpecifier$1> extends keyof TSchema$1["union"] ? Extract<keyof TSchema$1["union"][GetSpecName<TSpecifier$1>]["types"], string> : never;
-type FieldSelectionFactoryPrimitiveReturn<TSelection extends AnyFieldSelection & {
-  type: {
-    spec: PrimitiveSpecifierPattern;
-  };
-}, TAlias extends string | null> = { [_ in TAlias extends null ? TSelection["field"] : TAlias]: AbstractFieldSelection<TSelection["parent"], TSelection["field"], TSelection["type"], TSelection["args"], TSelection["directives"], null, null, false> };
-type FieldSelectionFactoryFieldArguments<TFieldSelectionTemplate extends AnyFieldSelection> = TFieldSelectionTemplate["args"] | IfOmittable<TFieldSelectionTemplate["args"], void | null>;
-//#endregion
 //#region packages/core/src/types/element/compat-spec.d.ts
-/**
- * Specification for a compat operation, storing unevaluated fieldsBuilder.
- * Created by `query.compat()`, `mutation.compat()`, `subscription.compat()`.
- *
- * The fieldsBuilder is stored unevaluated and will be evaluated when
- * `extend()` is called to create the final Operation.
- *
- * @template TSchema - The GraphQL schema type
- * @template TOperationType - The operation type ('query' | 'mutation' | 'subscription')
- * @template TOperationName - The operation name literal type
- * @template TVarDefinitions - The variable definitions type
- * @template TFields - The fields type returned by the fieldsBuilder
- *
- * @example
- * ```typescript
- * // This is created internally by query.compat()
- * const spec: CompatSpec<Schema, 'query', 'GetUser', { userId: VarSpec }, Fields> = {
- *   schema,
- *   operationType: 'query',
- *   operationName: 'GetUser',
- *   variables: { userId: varSpec },
- *   fieldsBuilder: ({ f, $ }) => ({ ...f.user({ id: $.userId })(...) }),
- * };
- * ```
- */
-type CompatSpec<TSchema$1 extends AnyGraphqlSchema, TOperationType$1 extends OperationType, TOperationName$1 extends string, TVarDefinitions$1 extends VariableDefinitions, TFields$1 extends AnyFields> = {
-  readonly schema: TSchema$1;
-  readonly operationType: TOperationType$1;
-  readonly operationName: TOperationName$1;
-  readonly variables: TVarDefinitions$1;
-  readonly fieldsBuilder: FieldsBuilder<TSchema$1, TSchema$1["operations"][TOperationType$1] & keyof TSchema$1["object"] & string, TVarDefinitions$1, TFields$1>;
-};
-/**
- * Type alias for any CompatSpec instance.
- */
-type AnyCompatSpec = CompatSpec<AnyGraphqlSchema, OperationType, string, VariableDefinitions, AnyFields>;
-/**
- * Extracts type information from a CompatSpec.
- * Used by extend() to infer types from the compat operation.
- */
-type ExtractCompatSpec<T> = T extends CompatSpec<infer TSchema, infer TOperationType, infer TOperationName, infer TVarDefinitions, infer TFields> ? {
-  schema: TSchema;
-  operationType: TOperationType;
-  operationName: TOperationName;
-  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
+ * 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()
@@ -741,16 +584,6 @@ type TemplateCompatSpec = {
   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
 /**
@@ -920,6 +753,24 @@ declare class GqlDefine<TValue$1> extends GqlElement<DefineArtifact<TValue$1>, D
   static create<TValue$1>(factory: () => TValue$1 | Promise<TValue$1>): GqlDefine<TValue$1>;
 }
 //#endregion
+//#region packages/core/src/utils/empty-object.d.ts
+declare const __EMPTY_SYMBOL__: unique symbol;
+type EmptyObject = {
+  readonly [__EMPTY_SYMBOL__]: never;
+};
+type IsEmpty<T> = keyof T extends never ? true : false;
+type IsOmittable<T> = {} extends T ? true : false;
+type IfOmittable<TTarget, TType> = IsOmittable<TTarget> extends true ? TType : never;
+type SwitchIfOmittable<TTarget, TTrue, TFalse> = IsOmittable<TTarget> extends true ? TTrue : TFalse;
+/**
+ * Make argument optional based on type structure:
+ * - Empty object (no keys) → void (must omit)
+ * - All-optional object → T | void (can omit or provide)
+ * - Has required fields → T (must provide)
+ */
+type OptionalArg<T> = IsEmpty<T> extends true ? void : IsOmittable<T> extends true ? T | void : T;
+declare const empty: () => EmptyObject;
+//#endregion
 //#region packages/core/src/types/element/fragment.d.ts
 /**
  * Type alias for any Fragment instance.
@@ -948,7 +799,7 @@ declare const __FRAGMENT_BRAND__: unique symbol;
 /**
  * Represents a reusable GraphQL field selection on a specific type.
  *
- * Fragments are created via `gql(({ fragment }) => fragment.TypeName({ ... }))`.
+ * Fragments are created via `gql(({ fragment }) => fragment("Name", "TypeName")\`{ ... }\`())`.
  * Use `spread()` to include the fragment's fields in an operation.
  *
  * @template TTypeName - The GraphQL type this fragment selects from
@@ -977,15 +828,15 @@ declare class Fragment<TTypeName extends string, TVariables extends Partial<AnyA
    * Prefer using the `gql(({ fragment }) => ...)` API instead.
    * @internal
    */
-  static create<TSchema$1 extends AnyGraphqlSchema, TTypeName extends keyof TSchema$1["object"] & string, TVariableDefinitions extends VariableDefinitions, TFields$1 extends AnyFieldsExtended>(define: () => {
+  static create<TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema["object"] & string, TVariableDefinitions extends VariableDefinitions, TFields$1 extends AnyFieldsExtended>(define: () => {
     typename: TTypeName;
     key: string | undefined;
-    schemaLabel: TSchema$1["label"];
+    schemaLabel: TSchema["label"];
     variableDefinitions: TVariableDefinitions;
-    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 & {
+    spread: (...args: OptionalArg<AssignableInputFromVarDefs<TSchema, TVariableDefinitions>> extends void ? [] : [variables: OptionalArg<AssignableInputFromVarDefs<TSchema, TVariableDefinitions>>]) => TFields$1;
+  }): Fragment<TTypeName, OptionalArg<AssignableInputFromVarDefs<TSchema, TVariableDefinitions>>, TFields$1 & {
     [key: symbol]: never;
-  }, InferFieldsExtended<TSchema$1, TTypeName, TFields$1> & {
+  }, InferFieldsExtended<TSchema, TTypeName, TFields$1> & {
     [key: symbol]: never;
   }>;
 }
@@ -998,7 +849,7 @@ type AnyOperation = AnyOperationOf<"query"> | AnyOperationOf<"mutation"> | AnyOp
 /**
  * Type alias for an Operation of a specific type.
  */
-type AnyOperationOf<TOperationType$1 extends OperationType> = Operation<TOperationType$1, string, string[], any, any, any>;
+type AnyOperationOf<TOperationType extends OperationType> = Operation<TOperationType, string, string[], any, any, any>;
 /**
  * Type inference metadata for operations.
  * Access via `typeof operation.$infer`.
@@ -1012,9 +863,9 @@ declare const __OPERATION_BRAND__: unique symbol;
  * Internal artifact shape produced by operation evaluation.
  * @internal
  */
-type OperationArtifact<TOperationType$1 extends OperationType, TOperationName$1 extends string, TVariableNames extends string[], TVariables extends Record<string, unknown>, TFields$1 extends Partial<AnyFieldsExtended>, TData extends object> = {
-  readonly operationType: TOperationType$1;
-  readonly operationName: TOperationName$1;
+type OperationArtifact<TOperationType extends OperationType, TOperationName extends string, TVariableNames extends string[], TVariables extends Record<string, unknown>, TFields$1 extends Partial<AnyFieldsExtended>, TData extends object> = {
+  readonly operationType: TOperationType;
+  readonly operationName: TOperationName;
   readonly schemaLabel: string;
   readonly variableNames: TVariableNames;
   readonly documentSource: () => TFields$1;
@@ -1024,7 +875,7 @@ type OperationArtifact<TOperationType$1 extends OperationType, TOperationName$1
 /**
  * Represents a GraphQL operation (query, mutation, or subscription).
  *
- * Operations are created via `gql(({ query }) => query.operation({ ... }))`.
+ * Operations are created via `gql(({ query }) => query("Name")\`{ ... }\`())`.
  * Produces a TypedDocumentNode for type-safe execution with GraphQL clients.
  *
  * @template TOperationType - 'query' | 'mutation' | 'subscription'
@@ -1034,13 +885,13 @@ type OperationArtifact<TOperationType$1 extends OperationType, TOperationName$1
  * @template TFields - Selected fields structure
  * @template TData - Inferred response data type
  */
-declare class Operation<TOperationType$1 extends OperationType, TOperationName$1 extends string, TVariableNames extends string[], TVariables extends Record<string, unknown>, TFields$1 extends Partial<AnyFieldsExtended>, TData extends object> extends GqlElement<OperationArtifact<TOperationType$1, TOperationName$1, TVariableNames, TVariables, TFields$1, TData>, OperationInferMeta<TVariables, TData>> implements OperationArtifact<TOperationType$1, TOperationName$1, TVariableNames, TVariables, TFields$1, TData> {
+declare class Operation<TOperationType extends OperationType, TOperationName extends string, TVariableNames extends string[], TVariables extends Record<string, unknown>, TFields$1 extends Partial<AnyFieldsExtended>, TData extends object> extends GqlElement<OperationArtifact<TOperationType, TOperationName, TVariableNames, TVariables, TFields$1, TData>, OperationInferMeta<TVariables, TData>> implements OperationArtifact<TOperationType, TOperationName, TVariableNames, TVariables, TFields$1, TData> {
   private readonly [__OPERATION_BRAND__];
   private constructor();
   /** The operation type: 'query', 'mutation', or 'subscription'. */
-  get operationType(): TOperationType$1;
+  get operationType(): TOperationType;
   /** The unique name of this operation. */
-  get operationName(): TOperationName$1;
+  get operationName(): TOperationName;
   /** The schema label this operation belongs to. */
   get schemaLabel(): string;
   /** List of variable names defined for this operation. */
@@ -1059,51 +910,25 @@ declare class Operation<TOperationType$1 extends OperationType, TOperationName$1
    * Prefer using the `gql(({ query }) => ...)` API instead.
    * @internal
    */
-  static create<TSchema$1 extends AnyGraphqlSchema, TOperationType$1 extends OperationType, TOperationName$1 extends string, TVariableDefinitions extends VariableDefinitions, TFields$1 extends AnyFieldsExtended>(define: (context: GqlElementContext | null) => {
-    operationType: TOperationType$1;
-    operationName: TOperationName$1;
-    schemaLabel: TSchema$1["label"];
+  static create<TSchema extends AnyGraphqlSchema, TOperationType extends OperationType, TOperationName extends string, TVariableDefinitions extends VariableDefinitions, TFields$1 extends AnyFieldsExtended>(define: (context: GqlElementContext | null) => {
+    operationType: TOperationType;
+    operationName: TOperationName;
+    schemaLabel: TSchema["label"];
     variableNames: (keyof TVariableDefinitions & string)[];
     documentSource: () => TFields$1;
-    document: TypedDocumentNode<InferFieldsExtended<TSchema$1, TSchema$1["operations"][TOperationType$1] & keyof TSchema$1["object"] & string, TFields$1>, ConstAssignableInputFromVarDefs<TSchema$1, TVariableDefinitions>>;
+    document: TypedDocumentNode<InferFieldsExtended<TSchema, TSchema["operations"][TOperationType] & keyof TSchema["object"] & string, TFields$1>, ConstAssignableInputFromVarDefs<TSchema, TVariableDefinitions>>;
     metadata?: unknown;
   } | Promise<{
-    operationType: TOperationType$1;
-    operationName: TOperationName$1;
-    schemaLabel: TSchema$1["label"];
+    operationType: TOperationType;
+    operationName: TOperationName;
+    schemaLabel: TSchema["label"];
     variableNames: (keyof TVariableDefinitions & string)[];
     documentSource: () => TFields$1;
-    document: TypedDocumentNode<InferFieldsExtended<TSchema$1, TSchema$1["operations"][TOperationType$1] & keyof TSchema$1["object"] & string, TFields$1>, ConstAssignableInputFromVarDefs<TSchema$1, TVariableDefinitions>>;
+    document: TypedDocumentNode<InferFieldsExtended<TSchema, TSchema["operations"][TOperationType] & keyof TSchema["object"] & string, TFields$1>, ConstAssignableInputFromVarDefs<TSchema, TVariableDefinitions>>;
     metadata?: unknown;
-  }>): Operation<TOperationType$1, TOperationName$1, (keyof TVariableDefinitions & string)[], ConstAssignableInputFromVarDefs<TSchema$1, TVariableDefinitions>, TFields$1, InferFieldsExtended<TSchema$1, TSchema$1["operations"][TOperationType$1] & keyof TSchema$1["object"] & string, TFields$1>>;
+  }>): Operation<TOperationType, TOperationName, (keyof TVariableDefinitions & string)[], ConstAssignableInputFromVarDefs<TSchema, TVariableDefinitions>, TFields$1, InferFieldsExtended<TSchema, TSchema["operations"][TOperationType] & keyof TSchema["object"] & string, TFields$1>>;
 }
 //#endregion
-//#region packages/core/src/composer/compat.d.ts
-/**
- * Options for creating a compat operation specification.
- */
-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, TVarDefinitions$1, TFields$1>;
-};
-/**
- * Creates a factory for composing compat operation specifications.
- *
- * Returns a function that creates a `GqlDefine<CompatSpec<...>>` storing
- * the operation specification with unevaluated fieldsBuilder.
- *
- * @param schema - The GraphQL schema definition
- * @param operationType - The operation type ('query' | 'mutation' | 'subscription')
- * @returns Compat operation composer function
- *
- * @internal Used by `createGqlElementComposer`
- */
-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>;
@@ -1116,7 +941,7 @@ type CurriedCompatFunction = (operationName: string) => CompatTaggedTemplate;
  * @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;
+declare const createCompatTaggedTemplate: <TSchema extends AnyGraphqlSchema>(schema: TSchema, operationType: OperationType) => CurriedCompatFunction;
 //#endregion
 //#region packages/core/src/composer/directive-builder.d.ts
 /**
@@ -1247,17 +1072,17 @@ declare const isDirectiveRef: (value: unknown) => value is AnyDirectiveRef;
 /**
  * Options for extending a compat spec into a full operation.
  */
-type ExtendOptions<TSchema$1 extends AnyGraphqlSchema, TVarDefinitions$1 extends VariableDefinitions, TOperationMetadata, TAggregatedFragmentMetadata, TSchemaLevel> = {
+type ExtendOptions<_TSchema extends AnyGraphqlSchema, _TVarDefinitions extends VariableDefinitions, TOperationMetadata, TAggregatedFragmentMetadata, TSchemaLevel> = {
   /** Optional metadata builder */
-  metadata?: MetadataBuilder<DeclaredVariables<TSchema$1, TVarDefinitions$1>, TOperationMetadata, TAggregatedFragmentMetadata, TSchemaLevel>;
+  metadata?: MetadataBuilder<Readonly<Record<string, AnyVarRef>>, TOperationMetadata, TAggregatedFragmentMetadata, TSchemaLevel>;
   /** Optional document transformer */
   transformDocument?: OperationDocumentTransformer<TOperationMetadata>;
 };
 /**
  * Creates a factory for extending compat specs into full operations.
  *
- * The extend function takes a compat spec (created by `query.compat()`) and
- * optional metadata/transformDocument options, then creates a full Operation.
+ * The extend function takes a TemplateCompatSpec (created by `query.compat("Name")\`...\``)
+ * and optional metadata/transformDocument options, then creates a full Operation.
  *
  * @param schema - The GraphQL schema definition
  * @param adapter - Optional metadata adapter for custom metadata handling
@@ -1266,22 +1091,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>> | 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
-/**
- * Creates field selection factories for a given object type.
- *
- * Returns an object with a factory for each field defined on the type.
- * Factories are cached per schema+type to avoid recreation.
- *
- * @param schema - The GraphQL schema definition
- * @param typeName - The object type name to create factories for
- * @returns Object mapping field names to their selection factories
- *
- * @internal Used by operation and fragment composers
- */
-declare const createFieldFactories: <TSchema$1 extends AnyGraphqlSchema, TTypeName extends keyof TSchema$1["object"] & string>(schema: TSchema$1, typeName: TTypeName) => FieldSelectionFactories<TSchema$1, TTypeName>;
+declare const createExtendComposer: <TSchema extends AnyGraphqlSchema, TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter>(schema: NoInfer<TSchema>, adapter?: TAdapter, transformDocument?: DocumentTransformer<ExtractAdapterTypes<TAdapter>["schemaLevel"], ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"]>) => <_TOperationType extends OperationType, _TOperationName extends string, TVarDefinitions extends VariableDefinitions, _TFields extends AnyFields, TOperationMetadata = unknown>(compat: GqlDefine<TemplateCompatSpec>, options?: ExtendOptions<TSchema, TVarDefinitions, TOperationMetadata, ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"], ExtractAdapterTypes<TAdapter>["schemaLevel"]>) => any;
 //#endregion
 //#region packages/core/src/graphql/schema-index.d.ts
 type OperationTypeNames = {
@@ -1336,37 +1146,53 @@ declare const createSchemaIndex: (document: DocumentNode) => SchemaIndex;
 type FragmentTemplateMetadataOptions = {
   metadata?: unknown | ((context: {
     $: Readonly<Record<string, unknown>>;
+    $var: VarRefTools;
   }) => unknown | Promise<unknown>);
 };
+/** Context provided to operation metadata callbacks. */
+type OperationMetadataContext = {
+  readonly $: Readonly<Record<string, any>>;
+  readonly $var: VarRefTools;
+  readonly document: graphql0.DocumentNode;
+  readonly fragmentMetadata: any;
+  readonly schemaLevel: any;
+};
 /** 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>);
+  metadata?: unknown;
+  /** Optional per-operation document transformer */
+  transformDocument?: OperationDocumentTransformer<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: {
+type OperationTaggedTemplateFunction<TOperationType 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>;
+}) => AnyFieldsExtended))[]) => TemplateResult<AnyOperationOf<TOperationType>>;
+/** Options object for callback builder path */
+type OperationOptionsObject = {
+  variables?: string;
+  fields: FieldsBuilder;
+};
+/** Dispatch: tagged template OR options object */
+type OperationBuilderDispatch<TOperationType extends OperationType = OperationType> = OperationTaggedTemplateFunction<TOperationType> & ((options: OperationOptionsObject) => TemplateResult<AnyOperationOf<TOperationType>>);
+/** Curried operation function type: query("name")`($var: Type!) { fields }` or query("name")({ variables, fields }) */
+type CurriedOperationFunction<TOperationType extends OperationType = OperationType> = (operationName: string) => OperationBuilderDispatch<TOperationType>;
 /**
- * Creates a curried tagged template function for a specific operation type.
- * New API: `query("name")\`($var: Type!) { fields }\`` returns TemplateResult<Operation>.
+ * Creates a curried function for a specific operation type.
+ * Supports both tagged template and options object dispatch.
+ *
+ * Tagged template: `query("name")\`($var: Type!) { fields }\`` returns TemplateResult<Operation>.
+ * Options object: `query("name")({ variables, fields })` returns TemplateResult<Operation>.
  *
  * @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 createOperationTaggedTemplate: <TSchema$1 extends AnyGraphqlSchema, TOperationType$1 extends OperationType>(schema: TSchema$1, operationType: TOperationType$1, metadataAdapter?: AnyMetadataAdapter, adapterTransformDocument?: DocumentTransformer<any, any>) => CurriedOperationFunction<TOperationType$1>;
+declare const createOperationTaggedTemplate: <TSchema extends AnyGraphqlSchema, TOperationType extends OperationType>(schema: TSchema, operationType: TOperationType, metadataAdapter?: AnyMetadataAdapter, adapterTransformDocument?: DocumentTransformer<any, any>) => CurriedOperationFunction<TOperationType>;
 //#endregion
 //#region packages/core/src/composer/fragment-tagged-template.d.ts
 /** Tagged template function type for fragments. */
@@ -1400,7 +1226,7 @@ type CurriedFragmentFunction = (name: string, typeName: string) => FragmentTagge
  *
  * @param schema - The GraphQL schema definition
  */
-declare function createFragmentTaggedTemplate<TSchema$1 extends AnyGraphqlSchema>(schema: TSchema$1): CurriedFragmentFunction;
+declare function createFragmentTaggedTemplate<TSchema extends AnyGraphqlSchema>(schema: TSchema): CurriedFragmentFunction;
 //#endregion
 //#region packages/core/src/composer/fragment-usage-context.d.ts
 /**
@@ -1433,155 +1259,6 @@ declare const withFragmentUsageCollection: <T>(fn: () => T) => {
  */
 declare const recordFragmentUsage: (record: FragmentUsageRecord) => void;
 //#endregion
-//#region packages/core/src/composer/var-ref-tools.d.ts
-/**
- * Get the variable name from a VarRef.
- * Throws if the VarRef contains a nested-value instead of a variable reference.
- */
-declare const getVarRefName: (varRef: AnyVarRef) => string;
-/**
- * Get the const value from a VarRef.
- * Throws if the VarRef contains a variable reference instead of a nested-value,
- * or if the nested-value contains any VarRef inside.
- */
-declare const getVarRefValue: (varRef: AnyVarRef) => ConstValue;
-/**
- * Path segment types for navigating nested values.
- */
-type PathSegment = string;
-/**
- * Gets the full path to a variable within a nested structure.
- *
- * Returns path segments starting with `$variableName` followed by
- * property accesses within that variable's value.
- *
- * @example
- * ```typescript
- * getVariablePath($.filter, p => p.user.id)
- * // Returns: ["$filter", "user", "id"]
- * ```
- */
-declare const getVariablePath: <T, U>(varRef: VarRef<AnyVarRefBrand>, selector: (proxy: T) => U) => readonly PathSegment[];
-//#endregion
-//#region packages/core/src/composer/var-builder.d.ts
-/**
- * Type for the default value function for a variable.
- */
-type AssignableDefaultValue<TSchema$1 extends AnyGraphqlSchema, TKind extends CreatableInputTypeKind, TName$1 extends string, TModifier extends TypeModifier> = ConstAssignableInputValueFromVarSpec<TSchema$1, {
-  kind: TKind;
-  name: TName$1;
-  modifier: TModifier;
-  directives: {};
-  defaultValue: null;
-}>;
-/**
- * Represents a variable definition with its type, modifier, and optional default.
- *
- * Created by `$var.TypeName("modifier", { default?: ... })` calls.
- */
-type GenericVarSpecifier<TKind extends CreatableInputTypeKind, TTypeName extends string, TModifier extends TypeModifier, TDefaultFn extends (() => unknown) | null, TDirectives extends AnyConstDirectiveAttachments> = {
-  kind: TKind;
-  name: TTypeName;
-  modifier: TModifier;
-  defaultValue: TDefaultFn extends null ? null : {
-    default: ReturnType<NonNullable<TDefaultFn>>;
-  };
-  directives: 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.
- *
- * @example
- * ```typescript
- * const createMethod = createVarMethodFactory<typeof schema>();
- * const inputTypeMethods = {
- *   Boolean: createMethod("scalar", "Boolean"),
- *   user_bool_exp: createMethod("input", "user_bool_exp"),
- * } satisfies InputTypeMethods<typeof schema>;
- * ```
- */
-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 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, TModifier, TDefaultFn, TDirectives>;
-/**
- * Type for all input type methods in a schema.
- */
-type InputTypeMethods<TSchema$1 extends AnyGraphqlSchema> = { [TName in AllInputTypeNames<TSchema$1>]: InputTypeMethod<TSchema$1, InferInputKind<TSchema$1, TName>, TName> };
-/**
- * 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 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, TModifier, TDefaultFn, TDirectives> };
-/**
- * Type for the variable builder methods for a specific variable name.
- */
-type VarBuilderMethods<TVarName extends string, TSchema$1 extends AnyGraphqlSchema> = { [TName in AllInputTypeNames<TSchema$1>]: WrappedVarMethod<TVarName, TSchema$1, InferInputKind<TSchema$1, TName>, TName> };
-/**
- * Variable builder function type.
- *
- * Call with a variable name to get type-specific methods.
- * Also provides utilities for extracting values from VarRefs.
- *
- * @example
- * ```typescript
- * // In operation definition:
- * variables: { userId: $var("userId").ID("!") }
- *
- * // In metadata builder:
- * $var.getValueAt($.userId, p => p)
- * ```
- */
-type VarBuilder<TSchema$1 extends AnyGraphqlSchema> = {
-  <TVarName extends string>(varName: TVarName): VarBuilderMethods<TVarName, TSchema$1>;
-  getName: typeof getVarRefName;
-  getValue: typeof getVarRefValue;
-  getNameAt: SchemaAwareGetNameAt<TSchema$1>;
-  getValueAt: SchemaAwareGetValueAt<TSchema$1>;
-  getVariablePath: typeof getVariablePath;
-};
-/**
- * Resolves the TypeScript type from VarRef meta using schema.
- * This is used for getValueAt/getNameAt with type structure resolution.
- */
-type ResolveTypeFromMeta<TSchema$1 extends AnyGraphqlSchema, TMeta extends AnyVarRefBrand> = TypeProfile.Type<ResolveInputProfileFromMeta<TSchema$1, TMeta["typeName"], TMeta["kind"], "!">>;
-/**
- * Schema-aware getValueAt type.
- * Resolves type structure from schema using typeName + kind.
- */
-type SchemaAwareGetValueAt<TSchema$1 extends AnyGraphqlSchema> = <T extends AnyVarRefBrand, U>(varRef: VarRef<T>, selector: (proxy: ResolveTypeFromMeta<TSchema$1, T>) => U) => U;
-/**
- * Schema-aware getNameAt type.
- * Resolves type structure from schema using typeName + kind.
- */
-type SchemaAwareGetNameAt<TSchema$1 extends AnyGraphqlSchema> = <T extends AnyVarRefBrand, U>(varRef: VarRef<T>, selector: (proxy: ResolveTypeFromMeta<TSchema$1, T>) => U) => string;
-/**
- * Type-erased input type methods for performance optimization.
- * Uses permissive function signature to allow any generated inputTypeMethods.
- * @internal
- */
-type AnyInputTypeMethods = Record<string, (...args: any[]) => unknown>;
-/**
- * Creates a variable builder using injected input type methods.
- *
- * The returned builder provides type-safe variable definition methods
- * for all input types in the schema. Also includes utilities for
- * extracting variable names and values from VarRefs.
- *
- * @param inputTypeMethods - Methods for each input type (from codegen)
- * @returns Variable builder with methods for all input types
- *
- * @internal Used by `createGqlElementComposer`
- */
-declare const createVarBuilder: <TSchema$1 extends AnyGraphqlSchema>(inputTypeMethods: AnyInputTypeMethods) => VarBuilder<TSchema$1>;
-//#endregion
 //#region packages/core/src/composer/gql-composer.d.ts
 /**
  * Function signature for composing GraphQL elements (fragments or operations).
@@ -1599,12 +1276,12 @@ type GqlElementComposer<TContext> = <TResult extends AnyFragment | AnyOperation
  * - Runtime schema introspection
  * - Debugging and tooling
  */
-type GqlElementComposerWithSchema<TContext, TSchema$1 extends AnyGraphqlSchema> = GqlElementComposer<TContext> & {
+type GqlElementComposerWithSchema<TContext, TSchema extends AnyGraphqlSchema> = GqlElementComposer<TContext> & {
   /**
    * The GraphQL schema definition used by this composer.
    * Provides runtime access to schema types, operations, and metadata.
    */
-  readonly $schema: TSchema$1;
+  readonly $schema: TSchema;
 };
 /**
  * Extracts the helpers type from an adapter.
@@ -1625,8 +1302,6 @@ type ExtractMetadataAdapter<TAdapter extends AnyAdapter> = TAdapter extends {
 type GqlElementComposerOptions<_TSchema extends AnyGraphqlSchema, TDirectiveMethods extends StandardDirectives, TAdapter extends AnyAdapter = DefaultAdapter> = {
   /** Optional adapter for custom helpers and metadata handling. */
   adapter?: TAdapter;
-  /** Methods for building variable type specifiers. */
-  inputTypeMethods: AnyInputTypeMethods;
   /** Optional custom directive methods (including schema-defined directives). */
   directiveMethods?: TDirectiveMethods;
 };
@@ -1636,71 +1311,41 @@ 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`: Tagged template function for fragment definitions
- * - `query/mutation/subscription`: Operation builders
- * - `$var`: Variable definition helpers
+ * - `query/mutation/subscription`: Operation builders (tagged template + options object + .compat)
  * - `$dir`: Field directive helpers (@skip, @include)
  * - `$colocate`: Fragment colocation utilities
  *
  * @param schema - The GraphQL schema definition
- * @param options - Configuration including input type methods and optional adapter
+ * @param options - Configuration including optional adapter
  * @returns Element composer function
  *
  * @example
  * ```typescript
- * const gql = createGqlElementComposer(schema, { inputTypeMethods });
- *
- * const GetUser = gql(({ query, $var, $dir }) =>
- *   query.operation({
- *     name: "GetUser",
- *     variables: { showEmail: $var("showEmail").Boolean("!") },
- *     fields: ({ f, $ }) => ({
- *       ...f.user({ id: "1" })(({ f }) => ({
- *         ...f.name(),
- *         ...f.email({}, { directives: [$dir.skip({ if: $.showEmail })] }),
- *       })),
- *     }),
- *   })
+ * const gql = createGqlElementComposer(schema, {});
+ *
+ * const GetUser = gql(({ query, $dir }) =>
+ *   query("GetUser")`($id: ID!) {
+ *     user(id: $id) { name email }
+ *   }`()
  * );
  * ```
  */
-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<{
+declare const createGqlElementComposer: <TSchema extends AnyGraphqlSchema, TDirectiveMethods extends StandardDirectives, TAdapter extends AnyAdapter = DefaultAdapter>(schema: NoInfer<TSchema>, options: GqlElementComposerOptions<NoInfer<TSchema>, 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;
-      metadata?: MetadataBuilder<DeclaredVariables<TSchema$1, TVarDefinitions$1>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
-      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: CurriedCompatFunction;
   };
   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;
-      metadata?: MetadataBuilder<DeclaredVariables<TSchema$1, TVarDefinitions$1>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
-      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: CurriedCompatFunction;
   };
   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;
-      metadata?: MetadataBuilder<DeclaredVariables<TSchema$1, TVarDefinitions$1>, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined;
-      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: CurriedCompatFunction;
   };
   define: <TValue$1>(factory: () => TValue$1 | Promise<TValue$1>) => GqlDefine<TValue$1>;
-  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>;
+  extend: <_TOperationType extends OperationType, _TOperationName extends string, TVarDefinitions extends VariableDefinitions, _TFields extends AnyFields, TOperationMetadata = unknown>(compat: GqlDefine<TemplateCompatSpec>, options?: ExtendOptions<TSchema, TVarDefinitions, TOperationMetadata, ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["aggregatedFragmentMetadata"], ExtractAdapterTypes<ExtractMetadataAdapter<TAdapter>>["schemaLevel"]> | undefined) => any;
   $dir: TDirectiveMethods;
   $colocate: <TEntries extends ColocatedEntries>(entries: TEntries) => ColocatedFields<TEntries>;
-} & ExtractHelpers<TAdapter>, TSchema$1>;
+} & ExtractHelpers<TAdapter>, TSchema>;
 /**
  * Abstract Context type for prebuilt composers.
  *
@@ -1713,20 +1358,16 @@ declare const createGqlElementComposer: <TSchema$1 extends AnyGraphqlSchema, TDi
 type AnyGqlContext = {
   readonly fragment: (...args: unknown[]) => unknown;
   readonly query: ((...args: unknown[]) => unknown) & {
-    operation: (...args: unknown[]) => AnyOperation;
     compat: (...args: unknown[]) => AnyGqlDefine;
   };
   readonly mutation: ((...args: unknown[]) => unknown) & {
-    operation: (...args: unknown[]) => AnyOperation;
     compat: (...args: unknown[]) => AnyGqlDefine;
   };
   readonly subscription: ((...args: unknown[]) => unknown) & {
-    operation: (...args: unknown[]) => AnyOperation;
     compat: (...args: unknown[]) => AnyGqlDefine;
   };
   readonly define: <TValue$1>(factory: () => TValue$1 | Promise<TValue$1>) => GqlDefine<TValue$1>;
   readonly extend: (...args: unknown[]) => AnyOperation;
-  readonly $var: unknown;
   readonly $dir: StandardDirectives;
   readonly $colocate: unknown;
   readonly [key: string]: unknown;
@@ -1744,7 +1385,7 @@ type AnyGqlContext = {
  *
  * @internal
  */
-declare const createVarAssignments: <TSchema$1 extends AnyGraphqlSchema, TVariableDefinitions extends VariableDefinitions>(definitions: TVariableDefinitions, providedValues: AnyAssignableInput | void) => DeclaredVariables<TSchema$1, TVariableDefinitions>;
+declare const createVarAssignments: <TVariableDefinitions extends VariableDefinitions>(definitions: TVariableDefinitions, providedValues: AnyAssignableInput | void) => Readonly<Record<string, AnyVarRef>>;
 /**
  * Creates variable references from variable definitions.
  *
@@ -1753,46 +1394,23 @@ declare const createVarAssignments: <TSchema$1 extends AnyGraphqlSchema, TVariab
  *
  * @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.
- *
- * Returns a curried function: first select operation type (query/mutation/subscription),
- * then define the operation with name, variables, and fields.
- *
- * Handles metadata aggregation from fragments (sync or async) and builds
- * the TypedDocumentNode automatically.
- *
- * @param schema - The GraphQL schema definition
- * @param adapter - Optional metadata adapter for custom metadata handling
- * @param transformDocument - Optional document transformer called after building
- * @returns Operation type selector function
- *
- * @internal Used by `createGqlElementComposer`
- */
-declare const createOperationComposerFactory: <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>(operationType: TOperationType$1) => <TOperationName$1 extends string, TFields$1 extends AnyFieldsExtended, TVarDefinitions$1 extends VariableDefinitions = {}, TOperationMetadata = unknown>(options: {
-  name: TOperationName$1;
-  variables?: TVarDefinitions$1;
-  metadata?: MetadataBuilder<ReturnType<typeof createVarRefs<TSchema$1, TVarDefinitions$1>>, TOperationMetadata, ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"], ExtractAdapterTypes<TAdapter>["schemaLevel"]>;
-  fields: FieldsBuilder<TSchema$1, TSchema$1["operations"][TOperationType$1] & keyof TSchema$1["object"] & string, TVarDefinitions$1, TFields$1>;
-  transformDocument?: OperationDocumentTransformer<TOperationMetadata>;
-}) => 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 createVarRefs: <TVarDefinitions extends VariableDefinitions>(definitions: TVarDefinitions) => Readonly<Record<string, AnyVarRef>>;
 //#endregion
 //#region packages/core/src/composer/operation-core.d.ts
 /**
  * Shared base parameters for building an operation artifact.
  * @internal
  */
-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;
+type OperationCoreParamsBase<TSchema extends AnyGraphqlSchema, TOperationType extends OperationType, TOperationName extends string, TVarDefinitions extends VariableDefinitions, TOperationMetadata, TAdapter extends AnyMetadataAdapter> = {
+  readonly schema: TSchema;
+  readonly operationType: TOperationType;
+  readonly operationTypeName: TSchema["operations"][TOperationType] & keyof TSchema["object"] & string;
+  readonly operationName: TOperationName;
+  readonly variables: TVarDefinitions;
+  /** Pre-parsed VariableDefinitionNode[] from tagged template or options object parser */
+  readonly variableDefinitionNodes?: readonly VariableDefinitionNode[];
   readonly adapter: TAdapter;
-  readonly metadata?: MetadataBuilder<DeclaredVariables<TSchema$1, TVarDefinitions$1>, TOperationMetadata, ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"], ExtractAdapterTypes<TAdapter>["schemaLevel"]>;
+  readonly metadata?: MetadataBuilder<Readonly<Record<string, AnyVarRef>>, TOperationMetadata, ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"], ExtractAdapterTypes<TAdapter>["schemaLevel"]>;
   readonly transformDocument?: OperationDocumentTransformer<TOperationMetadata>;
   readonly adapterTransformDocument?: DocumentTransformer<ExtractAdapterTypes<TAdapter>["schemaLevel"], ExtractAdapterTypes<TAdapter>["aggregatedFragmentMetadata"]>;
 };
@@ -1800,20 +1418,20 @@ type OperationCoreParamsBase<TSchema$1 extends AnyGraphqlSchema, TOperationType$
  * Parameters for building an operation artifact.
  * Uses `fieldsFactory` to evaluate fields and build document.
  *
- * @internal Used by operation.ts, extend.ts, and operation-tagged-template.ts
+ * @internal Used by extend.ts and operation-tagged-template.ts
  */
-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> = OperationCoreParamsBase<TSchema$1, TOperationType$1, TOperationName$1, TVarDefinitions$1, TOperationMetadata, TAdapter> & {
-  readonly fieldsFactory: FieldsBuilder<TSchema$1, TSchema$1["operations"][TOperationType$1] & keyof TSchema$1["object"] & string, TVarDefinitions$1, TFields$1>;
+type OperationCoreParams<TSchema extends AnyGraphqlSchema, TOperationType extends OperationType, TOperationName extends string, TVarDefinitions extends VariableDefinitions, TFields$1 extends AnyFieldsExtended, TOperationMetadata, TAdapter extends AnyMetadataAdapter> = OperationCoreParamsBase<TSchema, TOperationType, TOperationName, TVarDefinitions, TOperationMetadata, TAdapter> & {
+  readonly fieldsFactory: FieldsBuilder<TFields$1>;
 };
 /**
  * Result type from buildOperationArtifact.
  * Matches the artifact shape expected by Operation.create().
  */
-type OperationArtifactResult<TOperationType$1 extends OperationType, TOperationName$1 extends string, TVarDefinitions$1 extends VariableDefinitions, TFields$1 extends AnyFieldsExtended, TOperationMetadata> = {
-  readonly operationType: TOperationType$1;
-  readonly operationName: TOperationName$1;
+type OperationArtifactResult<TOperationType extends OperationType, TOperationName extends string, TVarDefinitions extends VariableDefinitions, TFields$1 extends AnyFieldsExtended, TOperationMetadata> = {
+  readonly operationType: TOperationType;
+  readonly operationName: TOperationName;
   readonly schemaLabel: string;
-  readonly variableNames: (keyof TVarDefinitions$1 & string)[];
+  readonly variableNames: (keyof TVarDefinitions & string)[];
   readonly documentSource: () => TFields$1;
   readonly document: ReturnType<typeof buildDocument>;
   readonly metadata: TOperationMetadata | undefined;
@@ -1831,9 +1449,9 @@ 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, extend.ts, and operation-tagged-template.ts
+ * @internal Used by 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>>;
+declare const buildOperationArtifact: <TSchema extends AnyGraphqlSchema, TOperationType extends OperationType, TOperationName extends string, TVarDefinitions extends VariableDefinitions, TFields$1 extends AnyFieldsExtended, TOperationMetadata, TAdapter extends AnyMetadataAdapter>(params: OperationCoreParams<TSchema, TOperationType, TOperationName, TVarDefinitions, TFields$1, TOperationMetadata, TAdapter>) => OperationArtifactResult<TOperationType, TOperationName, TVarDefinitions, TFields$1, TOperationMetadata> | Promise<OperationArtifactResult<TOperationType, TOperationName, TVarDefinitions, TFields$1, TOperationMetadata>>;
 /**
  * Wraps a buildOperationArtifact call into an Operation.create() invocation,
  * handling both sync and async artifact results.
@@ -1842,7 +1460,81 @@ declare const buildOperationArtifact: <TSchema$1 extends AnyGraphqlSchema, TOper
  *
  * @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>>) => AnyOperationOf<TOperationType$1>;
+declare const wrapArtifactAsOperation: <TOperationType extends OperationType>(artifactFactory: () => OperationArtifactResult<TOperationType, string, VariableDefinitions, AnyFieldsExtended, unknown> | Promise<OperationArtifactResult<TOperationType, string, VariableDefinitions, AnyFieldsExtended, unknown>>) => AnyOperationOf<TOperationType>;
+//#endregion
+//#region packages/core/src/composer/var-ref-tools.d.ts
+/**
+ * Recursively checks if a NestedValue contains any VarRef.
+ *
+ * Used by getVarRefValue to determine if it's safe to return as ConstValue.
+ * @internal
+ */
+declare const hasVarRefInside: (value: NestedValueElement | unknown) => boolean;
+/**
+ * Get the variable name from a VarRef.
+ * Throws if the VarRef contains a nested-value instead of a variable reference.
+ */
+declare const getVarRefName: (varRef: AnyVarRef) => string;
+/**
+ * Get the const value from a VarRef.
+ * Throws if the VarRef contains a variable reference instead of a nested-value,
+ * or if the nested-value contains any VarRef inside.
+ */
+declare const getVarRefValue: (varRef: AnyVarRef) => ConstValue;
+/**
+ * Path segment types for navigating nested values.
+ */
+type PathSegment = string;
+/**
+ * Type-safe path builder function.
+ * Used with getNameAt and getValueAt helpers.
+ */
+type Selector<T, U> = (proxy: T) => U;
+/**
+ * Get the variable name from a VarRef at a specific path.
+ *
+ * @param varRef - The VarRef containing a nested-value
+ * @param selector - Path builder function, e.g., p => p.user.age
+ * @returns The variable name at the specified path
+ * @throws If path doesn't lead to a VarRef with type "variable"
+ *
+ * @example
+ * const ref = createVarRefFromNestedValue({
+ *   user: { age: someVariableRef }
+ * });
+ * getNameAt(ref, p => p.user.age); // returns the variable name
+ */
+declare const getNameAt: <T, U>(varRef: VarRef<AnyVarRefBrand>, selector: (proxy: T) => U) => string;
+/**
+ * Get the const value from a nested-value VarRef at a specific path.
+ *
+ * @param varRef - The VarRef containing a nested-value
+ * @param pathFn - Path builder function, e.g., p => p.user.name
+ * @returns The const value at the specified path
+ * @throws If path leads to a VarRef or if value contains VarRef inside
+ *
+ * @example
+ * const ref = createVarRefFromNestedValue({
+ *   user: { name: "Alice", age: someVariableRef }
+ * });
+ * getValueAt(ref, p => p.user.name); // returns "Alice"
+ */
+declare const getValueAt: <T, U>(varRef: VarRef<AnyVarRefBrand>, selector: (proxy: T) => U) => U;
+/**
+ * Gets the full path to a variable within a nested structure.
+ *
+ * Returns path segments starting with `$variableName` followed by
+ * property accesses within that variable's value.
+ *
+ * @example
+ * ```typescript
+ * getVariablePath($.filter, p => p.user.id)
+ * // Returns: ["$filter", "user", "id"]
+ * ```
+ */
+declare const getVariablePath: <T, U>(varRef: VarRef<AnyVarRefBrand>, selector: (proxy: T) => U) => readonly PathSegment[];
+/** Pre-built tools object passed as `$var` in metadata builder callbacks. */
+declare const varRefTools: VarRefTools;
 //#endregion
 //#region packages/core/src/graphql/fragment-args-preprocessor.d.ts
 /**
@@ -2327,7 +2019,7 @@ declare const generateInputTypeFromSpecifiers: (schema: AnyGraphqlSchema, specif
  * Generate a TypeScript type string for input variables from VariableDefinitions.
  *
  * Unlike generateInputTypeFromSpecifiers which works with deferred specifier strings,
- * this function works with VarSpecifier objects created by $var().
+ * this function works with VarSpecifier objects from variable definitions.
  * Used for generating Fragment input types in prebuilt mode.
  *
  * @param schema - The GraphQL schema
@@ -2362,6 +2054,8 @@ type PrebuiltTypeRegistry = {
     readonly [key: string]: {
       readonly input: object;
       readonly output: object;
+      readonly varTypes?: unknown;
+      readonly fields?: unknown;
     };
   };
 };
@@ -2389,5 +2083,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 { ParsedSelection as $, FieldsBuilderTools as $n, FieldArgumentValue as $r, ObjectRecord as $t, getArgumentType as A, FragmentInferMeta as An, AbstractFieldSelection as Ar, VarBuilder as At, parseGraphqlSource as B, ExtractCompatSpec as Bn, InferField as Br, createFragmentTaggedTemplate as Bt, EnrichedFragment as C, createCompatComposer as Cn, buildDocument as Cr, AnyInputTypeMethods as Ct, TransformResult as D, OperationInferMeta as Dn, ParsedOutputSpecifier as Dr, ResolveTypeFromMeta as Dt, TransformOptions as E, Operation as En, ParsedInputSpecifier as Er, InputTypeMethods as Et, mergeModifiers as F, GqlElementContext as Fn, AnyNestedObject as Fr, recordFragmentUsage as Ft, ParseResultBase as G, FieldSelectionFactories as Gn, AnyDirectiveAttachments as Gr, OperationTaggedTemplateFunction as Gt, GraphqlAnalysisError as H, isTemplateCompatSpec as Hn, InferFieldsExtended as Hr, filterUnresolvedFragmentSpreads as Ht, mergeVariableUsages as I, GqlElementDefinitionFactory as In, AnyNestedObjectExtended as Ir, withFragmentUsageCollection as It, ParsedFragment as J, FieldSelectionFactoryObjectReturn as Jn, AnyAssigningInput as Jr, TemplateResultMetadataOptions as Jt, ParsedArgument as K, FieldSelectionFactory as Kn, AnyAssignableInput as Kr, OperationTemplateMetadataOptions as Kt, sortFragmentsByDependency as L, AnyCompatSpec as Ln, AnyNestedUnion as Lr, CurriedFragmentFunction as Lt, getInputFieldType as M, GqlDefine as Mn, AnyFieldValue as Mr, createVarBuilder as Mt, inferVariablesFromUsages as N, GqlElement as Nn, AnyFields as Nr, createVarMethodFactory as Nt, VariableUsage as O, AnyFragment as On, parseInputSpecifier as Or, SchemaAwareGetNameAt as Ot, isModifierAssignable as P, GqlElementAttachment as Pn, AnyFieldsExtended as Pr, FragmentUsageRecord as Pt, ParsedOperation as Q, FieldsBuilder as Qn, DeclaredVariables as Qr, InputRecord as Qt, transformParsedGraphql as R, AnyExtendableSpec as Rn, AnyUnionSelection as Rr, FragmentTaggedTemplateFunction as Rt, buildVarSpecifiers as S, CompatOptions as Sn, buildConstValueNode as Sr, createGqlElementComposer as St, EnrichedVariable as T, AnyOperationOf as Tn, buildWithTypeModifier as Tr, InputTypeMethod as Tt, InferredVariable as U, AnyFieldSelectionFactory as Un, ScalarShorthand as Ur, CurriedOperationFunction as Ut, parseTypeNode as V, TemplateCompatSpec as Vn, InferFields as Vr, extractFragmentVariables as Vt, ParseResult as W, AnyFieldSelectionFactoryReturn as Wn, UnionSelection as Wr, FragmentTemplateMetadataOptions as Wt, ParsedInlineFragment as X, FieldSelectionFactoryReturn as Xn, AssignableInputByFieldName as Xr, DirectiveRecord as Xt, ParsedFragmentSpread as Y, FieldSelectionFactoryPrimitiveReturn as Yn, AssignableInput as Yr, createOperationTaggedTemplate as Yt, ParsedObjectField as Z, FieldSelectionFactoryUnionReturn as Zn, AssignableInputFromVarDefs as Zr, EnumRecord as Zt, getScalarInputType as _, createTypedDirectiveMethod as _n, Tuple as _r, AnyGqlContext as _t, PrebuiltEntryNotFound as a, ConstAssignableInputFromVarDefs as ai, createFieldFactories as an, OptionalArg as ar, Result as at, BuiltVarSpecifier as b, CurriedCompatFunction as bn, EnumLookup as br, GqlElementComposerOptions as bt, TypeFormatters as c, GetAssignableType as ci, AnyDirectiveMethod as cn, AttachmentShape as cr, PreprocessResult as ct, calculateFieldsType as d, DirectiveArgumentSpecifier as di, DirectiveBuilder as dn, ColocateHelper as dr, OperationCoreParams as dt, FragmentVariableValue as ei, OperationTypeNames as en, NestedObjectFieldsBuilder as er, ParsedValue as et, generateInputObjectType as f, DirectiveLocation as fi, DirectiveMethod as fn, ColocatedEntries as fr, buildOperationArtifact as ft, getEnumType as g, TypeSystemDirectiveLocation as gi, createStandardDirectives as gn, StripSymbols as gr, createVarRefs as gt, generateInputTypeFromVarDefs as h, ExecutableDirectiveLocation as hi, createDirectiveMethod as hn, StripFunctions as hr, createVarAssignments as ht, AssertExtends as i, ConstAssignableInput as ii, createSchemaIndex as in, IfOmittable as ir, OkResult as it, getFieldReturnType as j, AnyGqlDefine as jn, AnyFieldSelection as jr, VarBuilderMethods as jt, collectVariableUsages as k, Fragment as kn, parseOutputSpecifier as kr, SchemaAwareGetValueAt as kt, applyTypeModifier as l, AnyDirectiveRef as li, DirectiveArgValue as ln, AttachmentToProperty as lr, preprocessFragmentArgs as lt, generateInputTypeFromSpecifiers as m, DirectiveRefInner as mi, createDirectiveBuilder as mn, createColocateHelper as mr, createOperationComposerFactory as mt, Hidden as n, AnyConstAssignableInput as ni, SchemaIndex as nn, NestedUnionFieldsBuilder as nr, TypeInfo as nt, PrebuiltTypeRegistry as o, ConstAssignableInputValue as oi, ExtendOptions as on, SwitchIfOmittable as or, err as ot, generateInputType as p, DirectiveRef as pi, StandardDirectives as pn, ColocatedFields as pr, wrapArtifactAsOperation as pt, ParsedFieldSelection as q, FieldSelectionFactoryFieldArguments as qn, AnyAssignableInputValue as qr, TemplateResult as qt, hidden as r, AnyConstAssignableInputValue as ri, UnionRecord as rn, EmptyObject as rr, ErrResult as rt, GenerateInputObjectTypeOptions as s, ConstAssignableInputValueFromVarSpec as si, createExtendComposer as sn, empty as sr, ok as st, wrapByKey as t, AnyConstDirectiveAttachments as ti, ScalarRecord as tn, NestedObjectFieldsBuilderTools as tr, ParsedVariable as tt, calculateFieldType as u, AnyDirectiveRefBrand as ui, DirectiveArgumentSpecifiers as un, AttachmentsTupleToIntersection as ur, OperationArtifactResult as ut, getScalarOutputType as v, isDirectiveRef as vn, UnionToIntersection as vr, ExtractMetadataAdapter as vt, EnrichedOperation as w, AnyOperation as wn, buildOperationTypeNode as wr, GenericVarSpecifier as wt, buildVarSpecifier as x, createCompatTaggedTemplate as xn, buildArgumentValue as xr, GqlElementComposerWithSchema as xt, graphqlTypeToTypeScript as y, CompatTaggedTemplate as yn, AnyVarSpecifier as yr, GqlElementComposer as yt, createSchemaIndexFromSchema as z, CompatSpec as zn, FieldSelectionTemplateOf as zr, buildFieldsFromSelectionSet as zt };
-//# sourceMappingURL=index-DTUPt4z4.d.cts.map
+export { ParsedSelection as $, StripSymbols as $n, ObjectRecord as $t, getArgumentType as A, OptionalArg as An, AnyAssignableInputValue as Ar, createGqlElementComposer as At, parseGraphqlSource as B, AttachmentShape as Bn, ConstAssignableInput as Br, CurriedOperationFunction as Bt, EnrichedFragment as C, Operation as Cn, InferFields as Cr, createVarAssignments as Ct, TransformResult as D, FragmentInferMeta as Dn, UnionSelection as Dr, GqlElementComposer as Dt, TransformOptions as E, Fragment as En, UnionMemberSelection as Er, ExtractMetadataAdapter as Et, mergeModifiers as F, GqlElement as Fn, DeclaredVariables as Fr, FragmentTaggedTemplateFunction as Ft, ParseResultBase as G, NestedObjectFieldsBuilder as Gn, AnyDirectiveRef as Gr, OperationTaggedTemplateFunction as Gt, GraphqlAnalysisError as H, AttachmentsTupleToIntersection as Hn, ConstAssignableInputValue as Hr, OperationBuilderDispatch as Ht, mergeVariableUsages as I, GqlElementAttachment as In, FieldArgumentValue as Ir, buildFieldsFromSelectionSet as It, ParsedFragment as J, ColocateHelper as Jn, DirectiveLocation as Jr, TemplateResultMetadataOptions as Jt, ParsedArgument as K, NestedUnionFieldsBuilder as Kn, AnyDirectiveRefBrand as Kr, OperationTemplateMetadataOptions as Kt, sortFragmentsByDependency as L, GqlElementContext as Ln, FragmentVariableValue as Lr, createFragmentTaggedTemplate as Lt, getInputFieldType as M, empty as Mn, AssignableInput as Mr, recordFragmentUsage as Mt, inferVariablesFromUsages as N, AnyGqlDefine as Nn, AssignableInputByFieldName as Nr, withFragmentUsageCollection as Nt, VariableUsage as O, EmptyObject as On, AnyDirectiveAttachments as Or, GqlElementComposerOptions as Ot, isModifierAssignable as P, GqlDefine as Pn, AssignableInputFromVarDefs as Pr, CurriedFragmentFunction as Pt, ParsedOperation as Q, StripFunctions as Qn, TypeSystemDirectiveLocation as Qr, InputRecord as Qt, transformParsedGraphql as R, GqlElementDefinitionFactory as Rn, AnyConstAssignableInput as Rr, extractFragmentVariables as Rt, buildVarSpecifiers as S, AnyOperationOf as Sn, InferField as Sr, wrapArtifactAsOperation as St, EnrichedVariable as T, AnyFragment as Tn, ScalarShorthand as Tr, AnyGqlContext as Tt, InferredVariable as U, FieldAccessorFunction as Un, ConstAssignableInputValueFromVarSpec as Ur, OperationMetadataContext as Ut, parseTypeNode as V, AttachmentToProperty as Vn, ConstAssignableInputFromVarDefs as Vr, FragmentTemplateMetadataOptions as Vt, ParseResult as W, FieldsBuilder as Wn, GetAssignableType as Wr, OperationOptionsObject as Wt, ParsedInlineFragment as X, ColocatedFields as Xn, DirectiveRefInner as Xr, DirectiveRecord as Xt, ParsedFragmentSpread as Y, ColocatedEntries as Yn, DirectiveRef as Yr, createOperationTaggedTemplate as Yt, ParsedObjectField as Z, createColocateHelper as Zn, ExecutableDirectiveLocation as Zr, EnumRecord as Zt, getScalarInputType as _, isDirectiveRef as _n, AnyNestedObject as _r, hasVarRefInside as _t, PrebuiltEntryNotFound as a, ExtendOptions as an, buildDocument as ar, Result as at, BuiltVarSpecifier as b, createCompatTaggedTemplate as bn, AnyUnionSelection as br, OperationCoreParams as bt, TypeFormatters as c, DirectiveArgValue as cn, ParsedInputSpecifier as cr, PreprocessResult as ct, calculateFieldsType as d, DirectiveMethod as dn, parseOutputSpecifier as dr, Selector as dt, OperationTypeNames as en, Tuple as er, ParsedValue as et, generateInputObjectType as f, StandardDirectives as fn, AbstractFieldSelection as fr, getNameAt as ft, getEnumType as g, createTypedDirectiveMethod as gn, AnyFieldsExtended as gr, getVariablePath as gt, generateInputTypeFromVarDefs as h, createStandardDirectives as hn, AnyFields as hr, getVarRefValue as ht, AssertExtends as i, createSchemaIndex as in, buildConstValueNode as ir, OkResult as it, getFieldReturnType as j, SwitchIfOmittable as jn, AnyAssigningInput as jr, FragmentUsageRecord as jt, collectVariableUsages as k, IfOmittable as kn, AnyAssignableInput as kr, GqlElementComposerWithSchema as kt, applyTypeModifier as l, DirectiveArgumentSpecifiers as ln, ParsedOutputSpecifier as lr, preprocessFragmentArgs as lt, generateInputTypeFromSpecifiers as m, createDirectiveMethod as mn, AnyFieldValue as mr, getVarRefName as mt, Hidden as n, SchemaIndex as nn, EnumLookup as nr, TypeInfo as nt, PrebuiltTypeRegistry as o, createExtendComposer as on, buildOperationTypeNode as or, err as ot, generateInputType as p, createDirectiveBuilder as pn, AnyFieldSelection as pr, getValueAt as pt, ParsedFieldSelection as q, createFieldFactories as qn, DirectiveArgumentSpecifier as qr, TemplateResult as qt, hidden as r, UnionRecord as rn, buildArgumentValue as rr, ErrResult as rt, GenerateInputObjectTypeOptions as s, AnyDirectiveMethod as sn, buildWithTypeModifier as sr, ok as st, wrapByKey as t, ScalarRecord as tn, UnionToIntersection as tr, ParsedVariable as tt, calculateFieldType as u, DirectiveBuilder as un, parseInputSpecifier as ur, PathSegment as ut, getScalarOutputType as v, CompatTaggedTemplate as vn, AnyNestedObjectExtended as vr, varRefTools as vt, EnrichedOperation as w, OperationInferMeta as wn, InferFieldsExtended as wr, createVarRefs as wt, buildVarSpecifier as x, AnyOperation as xn, FieldSelectionTemplateOf as xr, buildOperationArtifact as xt, graphqlTypeToTypeScript as y, CurriedCompatFunction as yn, AnyNestedUnion as yr, OperationArtifactResult as yt, createSchemaIndexFromSchema as z, TemplateCompatSpec as zn, AnyConstAssignableInputValue as zr, filterUnresolvedFragmentSpreads as zt };
+//# sourceMappingURL=index-DJ-yqsXz.d.ts.map