@soda-gql/core 0.11.13 → 0.11.15

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["inner: VarRefInner","inner: DirectiveRefInner","Kind","fieldTypeSpecifier: InputTypeSpecifier | null","field","curr: Readonly<{ modifier: string; type: TypeNode }>","OperationTypeNode","cache: { value: T } | null","promise: Promise<void> | null","cache: object | null","lazyCreateEvaluationGenerator","lazyEvaluateSync","defaultMetadataAdapter: DefaultMetadataAdapter","fieldPathContext: { current: FieldPath | null }","newSegment: FieldPathSegment","cacheMap: CacheMap","factory: AnyFieldSelectionFactory","wrapByKey","fragmentUsageContext: { current: FragmentUsageRecord[] | null }","usages: FragmentUsageRecord[]","fragmentMetaInfos: FragmentMetaInfo<TFragmentMetadata>[]","fragmentMetadataResults: (TFragmentMetadata | undefined | Promise<TFragmentMetadata>)[]","aggregated","operationTypeName: TTypeName | null","proxy: T","wrapByKey","applyContextTransformer","elementComposer: GqlElementComposer<typeof context>","baseType: string","memberTypes: string[]","Kind"],"sources":["../src/types/type-foundation/var-ref.ts","../src/types/type-foundation/directive-ref.ts","../src/composer/build-document.ts","../src/composer/colocate.ts","../src/utils/promise.ts","../src/types/element/lazy-evaluator.ts","../src/types/element/gql-element.ts","../src/types/element/define.ts","../src/types/element/fragment.ts","../src/types/element/operation.ts","../src/composer/compat.ts","../src/composer/directive-builder.ts","../src/types/metadata/adapter.ts","../src/utils/map-values.ts","../src/composer/field-path-context.ts","../src/composer/fields-builder.ts","../src/composer/fragment-usage-context.ts","../src/composer/input.ts","../src/composer/operation-core.ts","../src/composer/extend.ts","../src/composer/fragment.ts","../src/composer/operation.ts","../src/composer/var-ref-tools.ts","../src/composer/var-builder.ts","../src/composer/gql-composer.ts","../src/prebuilt/type-calculator.ts"],"sourcesContent":["import type { InputTypeKind } from \"./type-specifier\";\n\n/**\n * VarRef meta interface using typeName + kind instead of full profile.\n * This simplifies type comparison and improves error messages.\n */\nexport interface AnyVarRefBrand {\n  readonly typeName: string;\n  readonly kind: InputTypeKind;\n  readonly signature: unknown;\n}\n\n/**\n * A nested value that can contain:\n * - Primitive ConstValue (string, number, boolean, null, undefined)\n * - VarRef at any nesting level\n * - Objects with NestedValue fields\n * - Arrays of NestedValue\n */\nexport type NestedValue =\n  | string\n  | number\n  | boolean\n  | null\n  | undefined\n  | { readonly [key: string]: NestedValueElement }\n  | readonly NestedValueElement[];\n\nexport type NestedValueElement =\n  | string\n  | number\n  | boolean\n  | null\n  | undefined\n  | AnyVarRef\n  | { readonly [key: string]: NestedValueElement }\n  | readonly NestedValueElement[];\n\nexport type VarRefInner =\n  | {\n      type: \"variable\";\n      name: string;\n    }\n  | {\n      type: \"nested-value\";\n      value: NestedValue;\n    };\n\nexport type AnyVarRef = VarRef<any>;\n\ndeclare const __VAR_REF_BRAND__: unique symbol;\nexport class VarRef<TBrand extends AnyVarRefBrand> {\n  declare readonly [__VAR_REF_BRAND__]: TBrand;\n\n  constructor(private readonly inner: VarRefInner) {}\n\n  static getInner(varRef: AnyVarRef): VarRefInner {\n    return varRef.inner;\n  }\n}\n\n/**\n * Creates a VarRef from a variable name.\n * Returns AnyVarRef - type safety is enforced at assignment sites.\n */\nexport function createVarRefFromVariable(name: string): AnyVarRef {\n  return new VarRef({ type: \"variable\", name });\n}\n\n/**\n * Creates a VarRef from a nested value.\n * Returns AnyVarRef - type safety is enforced at assignment sites.\n */\nexport function createVarRefFromNestedValue(value: NestedValue): AnyVarRef {\n  return new VarRef({ type: \"nested-value\", value });\n}\n","/**\n * DirectiveRef type for representing field-level directives.\n *\n * Similar to VarRef, DirectiveRef uses a branded type pattern to carry\n * type information about the directive (name, locations, arguments) while\n * allowing relaxed type checking at the field builder level.\n *\n * @module\n */\n\n/**\n * Executable directive locations (used in operations/fragments).\n */\nexport type ExecutableDirectiveLocation =\n  | \"QUERY\"\n  | \"MUTATION\"\n  | \"SUBSCRIPTION\"\n  | \"FIELD\"\n  | \"FRAGMENT_DEFINITION\"\n  | \"FRAGMENT_SPREAD\"\n  | \"INLINE_FRAGMENT\"\n  | \"VARIABLE_DEFINITION\";\n\n/**\n * Type system directive locations (used in schema definitions).\n */\nexport type TypeSystemDirectiveLocation =\n  | \"SCHEMA\"\n  | \"SCALAR\"\n  | \"OBJECT\"\n  | \"FIELD_DEFINITION\"\n  | \"ARGUMENT_DEFINITION\"\n  | \"INTERFACE\"\n  | \"UNION\"\n  | \"ENUM\"\n  | \"ENUM_VALUE\"\n  | \"INPUT_OBJECT\"\n  | \"INPUT_FIELD_DEFINITION\";\n\n/**\n * All valid locations where a directive can be applied.\n * Matches GraphQL specification DirectiveLocation enum.\n */\nexport type DirectiveLocation = ExecutableDirectiveLocation | TypeSystemDirectiveLocation;\n\n/**\n * Brand interface for DirectiveRef type information.\n * Contains the directive name and valid locations.\n */\nexport interface AnyDirectiveRefBrand {\n  readonly directiveName: string;\n  readonly locations: readonly DirectiveLocation[];\n}\n\n/**\n * Type specifier for a directive argument.\n * Used to enable enum detection when building directive arguments.\n */\nexport type DirectiveArgumentSpecifier = {\n  readonly kind: \"scalar\" | \"enum\" | \"input\";\n  readonly name: string;\n  readonly modifier: string;\n};\n\n/**\n * Internal structure of a DirectiveRef.\n * Contains the directive name, arguments, valid locations, and optional argument specifiers.\n */\nexport type DirectiveRefInner = {\n  readonly name: string;\n  readonly arguments: Readonly<Record<string, unknown>>;\n  readonly locations: readonly DirectiveLocation[];\n  /**\n   * Type specifiers for arguments, enabling enum detection.\n   * Generated by codegen for typed directives.\n   */\n  readonly argumentSpecs?: Readonly<Record<string, DirectiveArgumentSpecifier>>;\n};\n\ndeclare const __DIRECTIVE_REF_BRAND__: unique symbol;\n\n/**\n * A reference to a directive that can be applied to fields.\n *\n * DirectiveRef carries type information about the directive via the TBrand\n * type parameter, but this information is only used for type inference,\n * not for runtime validation.\n *\n * @example\n * ```typescript\n * const skipDirective = new DirectiveRef({\n *   name: \"skip\",\n *   arguments: { if: true },\n *   locations: [\"FIELD\", \"FRAGMENT_SPREAD\", \"INLINE_FRAGMENT\"],\n * });\n * ```\n */\nexport class DirectiveRef<TBrand extends AnyDirectiveRefBrand> {\n  declare readonly [__DIRECTIVE_REF_BRAND__]: TBrand;\n\n  constructor(private readonly inner: DirectiveRefInner) {}\n\n  /**\n   * Extracts the inner structure from a DirectiveRef.\n   * Used by build-document.ts to generate DirectiveNode.\n   */\n  static getInner(ref: AnyDirectiveRef): DirectiveRefInner {\n    return ref.inner;\n  }\n}\n\n/**\n * Type-erased DirectiveRef for use in contexts where\n * the specific directive type is not needed.\n */\nexport type AnyDirectiveRef = DirectiveRef<AnyDirectiveRefBrand>;\n","/**\n * Builds GraphQL AST nodes from field selections.\n *\n * Converts the type-safe field selection DSL into GraphQL AST,\n * producing a TypedDocumentNode for use with GraphQL clients.\n *\n * @module\n */\n\nimport type { TypedDocumentNode } from \"@graphql-typed-document-node/core\";\nimport {\n  type ArgumentNode,\n  type ConstObjectFieldNode,\n  type ConstValueNode,\n  type DirectiveNode,\n  type DocumentNode,\n  type FieldNode,\n  type InlineFragmentNode,\n  Kind,\n  type NamedTypeNode,\n  type ObjectFieldNode,\n  OperationTypeNode,\n  type TypeNode,\n  type ValueNode,\n  type VariableDefinitionNode,\n} from \"graphql\";\nimport {\n  type AnyAssignableInput,\n  type AnyAssignableInputValue,\n  type AnyDirectiveAttachments,\n  type AnyFields,\n  type AnyNestedUnion,\n  type InferFields,\n  VarRef,\n} from \"../types/fragment\";\nimport type { AnyGraphqlSchema, ConstAssignableInput, OperationType } from \"../types/schema\";\nimport type { ConstValue, InputTypeSpecifier, InputTypeSpecifiers, TypeModifier } from \"../types/type-foundation\";\nimport { type AnyDirectiveRef, type DirectiveLocation, DirectiveRef } from \"../types/type-foundation/directive-ref\";\n\n/**\n * Context for determining if a value should be output as an enum.\n * Contains the schema for looking up nested input types and the current type specifier.\n */\nexport type EnumLookup = {\n  schema: AnyGraphqlSchema;\n  /** Type specifier for the current value. null means enum detection is skipped. */\n  typeSpecifier: InputTypeSpecifier | null;\n};\n\n/**\n * Converts an assignable input value to a GraphQL AST ValueNode.\n *\n * Handles primitives, arrays, objects, and variable references.\n * Returns null for undefined values (field is omitted).\n *\n * @param value - The value to convert\n * @param enumLookup - Context for enum detection. String values will be output\n *                     as Kind.ENUM if typeSpecifier indicates an enum type.\n */\nexport const buildArgumentValue = (value: AnyAssignableInputValue, enumLookup: EnumLookup): ValueNode | null => {\n  if (value === undefined) {\n    return null;\n  }\n\n  if (value === null) {\n    return {\n      kind: Kind.NULL,\n    };\n  }\n\n  if (value instanceof VarRef) {\n    const inner = VarRef.getInner(value);\n    if (inner.type === \"variable\") {\n      return {\n        kind: Kind.VARIABLE,\n        name: { kind: Kind.NAME, value: inner.name },\n      };\n    }\n\n    if (inner.type === \"nested-value\") {\n      // Recursively process the nested value\n      // This handles VarRefs inside the nested structure\n      return buildArgumentValue(inner.value as AnyAssignableInputValue, enumLookup);\n    }\n\n    throw new Error(`Unknown var ref type: ${inner satisfies never}`);\n  }\n\n  if (Array.isArray(value)) {\n    // For list types, the inner type specifier remains the same (e.g., [Status!]! uses Status for each item)\n    return {\n      kind: Kind.LIST,\n      values: value.map((item) => buildArgumentValue(item, enumLookup)).filter((item) => item !== null),\n    };\n  }\n\n  if (typeof value === \"object\") {\n    return {\n      kind: Kind.OBJECT,\n      fields: Object.entries(value)\n        .map(([key, fieldValue]): ObjectFieldNode | null => {\n          // Look up field type in nested InputObject for enum detection\n          let fieldTypeSpecifier: InputTypeSpecifier | null = null;\n          if (enumLookup.typeSpecifier?.kind === \"input\") {\n            const inputDef = enumLookup.schema.input[enumLookup.typeSpecifier.name];\n            fieldTypeSpecifier = inputDef?.fields[key] ?? null;\n          }\n\n          const valueNode = buildArgumentValue(fieldValue, {\n            schema: enumLookup.schema,\n            typeSpecifier: fieldTypeSpecifier,\n          });\n          return valueNode\n            ? {\n                kind: Kind.OBJECT_FIELD,\n                name: { kind: Kind.NAME, value: key },\n                value: valueNode,\n              }\n            : null;\n        })\n        .filter((item) => item !== null),\n    };\n  }\n\n  if (typeof value === \"string\") {\n    // Output as Kind.ENUM if the type specifier indicates this is an enum type\n    if (enumLookup.typeSpecifier?.kind === \"enum\") {\n      return {\n        kind: Kind.ENUM,\n        value,\n      };\n    }\n    return {\n      kind: Kind.STRING,\n      value,\n    };\n  }\n\n  if (typeof value === \"number\") {\n    // Distinguish between INT and FLOAT\n    const isFloat = !Number.isInteger(value) || value.toString().includes(\".\");\n    return {\n      kind: isFloat ? Kind.FLOAT : Kind.INT,\n      value: value.toString(),\n    };\n  }\n\n  if (typeof value === \"boolean\") {\n    return {\n      kind: Kind.BOOLEAN,\n      value,\n    };\n  }\n\n  throw new Error(`Unknown value type: ${typeof (value satisfies never)}`);\n};\n\nconst buildArguments = (\n  args: AnyAssignableInput,\n  argumentSpecifiers: InputTypeSpecifiers,\n  schema: AnyGraphqlSchema,\n): ArgumentNode[] =>\n  Object.entries(args ?? {})\n    .map(([name, value]): ArgumentNode | null => {\n      const typeSpecifier = argumentSpecifiers[name] ?? null;\n      const valueNode = buildArgumentValue(value, { schema, typeSpecifier });\n      return valueNode\n        ? {\n            kind: Kind.ARGUMENT,\n            name: { kind: Kind.NAME, value: name },\n            value: valueNode,\n          }\n        : null;\n    })\n    .filter((item) => item !== null);\n\n/**\n * Validates that a directive can be used at the specified location.\n *\n * @param directive - The directive reference to validate\n * @param expectedLocation - The location where the directive is being used\n * @throws Error if the directive is not valid at the specified location\n */\nconst validateDirectiveLocation = (directive: AnyDirectiveRef, expectedLocation: DirectiveLocation): void => {\n  const inner = DirectiveRef.getInner(directive);\n  if (!inner.locations.includes(expectedLocation)) {\n    throw new Error(\n      `Directive @${inner.name} cannot be used on ${expectedLocation}. ` + `Valid locations: ${inner.locations.join(\", \")}`,\n    );\n  }\n};\n\n/**\n * Builds DirectiveNode array from field directives.\n *\n * Filters for DirectiveRef instances, validates their locations,\n * and converts them to GraphQL AST DirectiveNode objects.\n *\n * @param directives - Array of directive references (or unknown values)\n * @param location - The location context for validation\n * @param schema - The schema for type lookups\n * @returns Array of DirectiveNode for the GraphQL AST\n *\n * Uses argument specifiers from DirectiveRef (when available via createTypedDirectiveMethod)\n * to properly output enum arguments as Kind.ENUM instead of Kind.STRING.\n */\nconst buildDirectives = (\n  directives: AnyDirectiveAttachments,\n  location: DirectiveLocation,\n  schema: AnyGraphqlSchema,\n): DirectiveNode[] => {\n  return directives\n    .filter((d): d is AnyDirectiveRef => d instanceof DirectiveRef)\n    .map((directive) => {\n      validateDirectiveLocation(directive, location);\n      const inner = DirectiveRef.getInner(directive);\n\n      // Use argument specifiers from DirectiveRef for enum detection\n      // Cast is safe because DirectiveArgumentSpecifier matches InputTypeSpecifier structure\n      const argumentSpecifiers = (inner.argumentSpecs ?? {}) as InputTypeSpecifiers;\n\n      return {\n        kind: Kind.DIRECTIVE as const,\n        name: { kind: Kind.NAME as const, value: inner.name },\n        arguments: buildArguments(inner.arguments as AnyAssignableInput, argumentSpecifiers, schema),\n      };\n    });\n};\n\nconst buildUnionSelection = (union: AnyNestedUnion, schema: AnyGraphqlSchema): InlineFragmentNode[] =>\n  Object.entries(union)\n    .map(([typeName, object]): InlineFragmentNode | null => {\n      return object\n        ? {\n            kind: Kind.INLINE_FRAGMENT,\n            typeCondition: {\n              kind: Kind.NAMED_TYPE,\n              name: { kind: Kind.NAME, value: typeName },\n            },\n            selectionSet: {\n              kind: Kind.SELECTION_SET,\n              selections: buildField(object, schema),\n            },\n          }\n        : null;\n    })\n    .filter((item) => item !== null);\n\nconst buildField = (field: AnyFields, schema: AnyGraphqlSchema): FieldNode[] =>\n  Object.entries(field).map(([alias, { args, field, object, union, directives, type }]): FieldNode => {\n    const builtDirectives = buildDirectives(directives, \"FIELD\", schema);\n    return {\n      kind: Kind.FIELD,\n      name: { kind: Kind.NAME, value: field },\n      alias: alias !== field ? { kind: Kind.NAME, value: alias } : undefined,\n      arguments: buildArguments(args, type.arguments, schema),\n      directives: builtDirectives.length > 0 ? builtDirectives : undefined,\n      selectionSet: object\n        ? {\n            kind: Kind.SELECTION_SET,\n            selections: buildField(object, schema),\n          }\n        : union\n          ? {\n              kind: Kind.SELECTION_SET,\n              selections: buildUnionSelection(union, schema),\n            }\n          : undefined,\n    };\n  });\n\n/**\n * Converts a constant value to a GraphQL AST ConstValueNode.\n *\n * Unlike `buildArgumentValue`, this only handles literal values\n * (no variable references). Used for default values.\n *\n * @param value - The constant value to convert\n * @param enumLookup - Context for enum detection. String values will be output\n *                     as Kind.ENUM if typeSpecifier indicates an enum type.\n */\nexport const buildConstValueNode = (value: ConstValue, enumLookup: EnumLookup): ConstValueNode | null => {\n  if (value === undefined) {\n    return null;\n  }\n\n  if (value === null) {\n    return { kind: Kind.NULL };\n  }\n\n  if (Array.isArray(value)) {\n    // For list types, the inner type specifier remains the same\n    return {\n      kind: Kind.LIST,\n      values: value.map((item) => buildConstValueNode(item, enumLookup)).filter((item) => item !== null),\n    };\n  }\n\n  if (typeof value === \"object\") {\n    return {\n      kind: Kind.OBJECT,\n      fields: Object.entries(value)\n        .map(([key, fieldValue]): ConstObjectFieldNode | null => {\n          // Look up field type in nested InputObject for enum detection\n          let fieldTypeSpecifier: InputTypeSpecifier | null = null;\n          if (enumLookup.typeSpecifier?.kind === \"input\") {\n            const inputDef = enumLookup.schema.input[enumLookup.typeSpecifier.name];\n            fieldTypeSpecifier = inputDef?.fields[key] ?? null;\n          }\n\n          const valueNode = buildConstValueNode(fieldValue, {\n            schema: enumLookup.schema,\n            typeSpecifier: fieldTypeSpecifier,\n          });\n          return valueNode\n            ? {\n                kind: Kind.OBJECT_FIELD,\n                name: { kind: Kind.NAME, value: key },\n                value: valueNode,\n              }\n            : null;\n        })\n        .filter((item) => item !== null),\n    };\n  }\n\n  if (typeof value === \"string\") {\n    // Output as Kind.ENUM if the type specifier indicates this is an enum type\n    if (enumLookup.typeSpecifier?.kind === \"enum\") {\n      return { kind: Kind.ENUM, value };\n    }\n    return { kind: Kind.STRING, value };\n  }\n\n  if (typeof value === \"boolean\") {\n    return { kind: Kind.BOOLEAN, value };\n  }\n\n  if (typeof value === \"number\") {\n    // Distinguish between INT and FLOAT\n    const isFloat = !Number.isInteger(value) || value.toString().includes(\".\");\n    return { kind: isFloat ? Kind.FLOAT : Kind.INT, value: value.toString() };\n  }\n\n  throw new Error(`Unknown value type: ${typeof (value satisfies never)}`);\n};\n\n/**\n * Wraps a named type with modifiers (non-null, list).\n *\n * Modifier format: starts with `?` (nullable) or `!` (non-null),\n * followed by `[]?` or `[]!` pairs for lists.\n *\n * @example\n * - `\"!\"` → `String!`\n * - `\"?\"` → `String`\n * - `\"![]!\"` → `[String!]!`\n * - `\"?[]?\"` → `[String]`\n */\nexport const buildWithTypeModifier = (modifier: TypeModifier, buildType: () => NamedTypeNode): TypeNode => {\n  const baseType = buildType();\n\n  if (modifier === \"?\") {\n    return baseType;\n  }\n\n  if (modifier === \"!\") {\n    return { kind: Kind.NON_NULL_TYPE, type: baseType };\n  }\n\n  // Validate modifier format: must start with ? or !, followed by []? or []! pairs\n  // Valid patterns: \"?\", \"!\", \"?[]?\", \"?[]!\", \"![]?\", \"![]!\", \"?[]?[]?\", etc.\n  const validModifierPattern = /^[?!](\\[\\][?!])*$/;\n  if (!validModifierPattern.test(modifier)) {\n    throw new Error(`Unknown modifier: ${modifier}`);\n  }\n\n  // New format: starts with inner type modifier (? or !), then []? or []! pairs\n  // e.g., \"?[]?\" = nullable list of nullable, \"![]!\" = non-null list of non-null\n  let curr: Readonly<{ modifier: string; type: TypeNode }> = {\n    modifier,\n    type: baseType,\n  };\n\n  while (curr.modifier.length > 0) {\n    // Handle inner type modifier (? or !)\n    if (curr.modifier.startsWith(\"?\")) {\n      // Nullable inner type - type stays as-is\n      curr = {\n        modifier: curr.modifier.slice(1),\n        type: curr.type,\n      };\n      continue;\n    }\n\n    if (curr.modifier.startsWith(\"!\")) {\n      // Non-null inner type\n      curr = {\n        modifier: curr.modifier.slice(1),\n        type: curr.type.kind === Kind.NON_NULL_TYPE ? curr.type : { kind: Kind.NON_NULL_TYPE, type: curr.type },\n      };\n      continue;\n    }\n\n    // Handle list modifiers ([]? or []!)\n    if (curr.modifier.startsWith(\"[]?\")) {\n      // Nullable list\n      curr = {\n        modifier: curr.modifier.slice(3),\n        type: { kind: Kind.LIST_TYPE, type: curr.type },\n      };\n      continue;\n    }\n\n    if (curr.modifier.startsWith(\"[]!\")) {\n      // Non-null list\n      curr = {\n        modifier: curr.modifier.slice(3),\n        type: {\n          kind: Kind.NON_NULL_TYPE,\n          type: { kind: Kind.LIST_TYPE, type: curr.type },\n        },\n      };\n      continue;\n    }\n\n    throw new Error(`Unknown modifier: ${curr.modifier}`);\n  }\n\n  return curr.type;\n};\n\nconst buildVariables = (variables: InputTypeSpecifiers, schema: AnyGraphqlSchema): VariableDefinitionNode[] => {\n  return Object.entries(variables).map(\n    ([name, ref]): VariableDefinitionNode => ({\n      kind: Kind.VARIABLE_DEFINITION,\n      variable: { kind: Kind.VARIABLE, name: { kind: Kind.NAME, value: name } },\n      defaultValue:\n        (ref.defaultValue && buildConstValueNode(ref.defaultValue.default, { schema, typeSpecifier: ref })) || undefined,\n      type: buildWithTypeModifier(ref.modifier, () => ({\n        kind: Kind.NAMED_TYPE,\n        name: { kind: Kind.NAME, value: ref.name },\n      })),\n    }),\n  );\n};\n\n/**\n * Converts an operation type string to a GraphQL AST OperationTypeNode.\n */\nexport const buildOperationTypeNode = (operation: OperationType): OperationTypeNode => {\n  switch (operation) {\n    case \"query\":\n      return OperationTypeNode.QUERY;\n    case \"mutation\":\n      return OperationTypeNode.MUTATION;\n    case \"subscription\":\n      return OperationTypeNode.SUBSCRIPTION;\n    default:\n      throw new Error(`Unknown operation type: ${operation}`);\n  }\n};\n\n/**\n * Builds a TypedDocumentNode from operation options.\n *\n * This is the main entry point for converting field selections into\n * a GraphQL document AST. The result can be used with any GraphQL\n * client that supports TypedDocumentNode.\n *\n * @param options - Operation configuration (name, type, variables, fields, schema)\n * @returns TypedDocumentNode with inferred input/output types\n */\nexport const buildDocument = <\n  TSchema extends AnyGraphqlSchema,\n  TFields extends AnyFields,\n  TVarDefinitions extends InputTypeSpecifiers,\n>(options: {\n  operationName: string;\n  operationType: OperationType;\n  variables: TVarDefinitions;\n  fields: TFields;\n  schema: TSchema;\n}): TypedDocumentNode<InferFields<TSchema, TFields>, ConstAssignableInput<TSchema, TVarDefinitions>> => {\n  const { operationName, operationType, variables, fields, schema } = options;\n  return {\n    kind: Kind.DOCUMENT,\n    definitions: [\n      {\n        kind: Kind.OPERATION_DEFINITION,\n        operation: buildOperationTypeNode(operationType),\n        name: { kind: Kind.NAME, value: operationName },\n        variableDefinitions: buildVariables(variables, schema),\n        // directives: directives || [],\n        selectionSet: {\n          kind: Kind.SELECTION_SET,\n          selections: buildField(fields, schema),\n        },\n      },\n    ],\n  } satisfies DocumentNode as TypedDocumentNode<InferFields<TSchema, TFields>, ConstAssignableInput<TSchema, TVarDefinitions>>;\n};\n","import type { AnyFields } from \"../types/fragment\";\nimport type { UnionToIntersection } from \"../utils/type-utils\";\n\n/**\n * Type for colocated field entries.\n * Maps labels to their corresponding field selections.\n */\nexport type ColocatedEntries = Record<string, AnyFields>;\n\n/**\n * Result type for colocated fields.\n * Merges all prefixed entries into a single object.\n */\nexport type ColocatedFields<TEntries extends ColocatedEntries> = UnionToIntersection<\n  {\n    [KPrefix in keyof TEntries]: KPrefix extends string\n      ? {\n          [KField in keyof TEntries[KPrefix] as KField extends string\n            ? `${KPrefix}_${KField}`\n            : never]: TEntries[KPrefix][KField];\n        }\n      : never;\n  }[keyof TEntries]\n>;\n\n/**\n * Creates a $colocate helper function for fragment colocation.\n *\n * $colocate takes an object of { label: fields } and applies prefix-based\n * aliasing to each entry. This mirrors the structure of createExecutionResultParser\n * from @soda-gql/colocation-tools.\n *\n * @example\n * ```typescript\n * // In operation definition\n * query.operation({\n *   name: \"GetData\",\n *   fields: ({ $ }) => $colocate({\n *     userCard: userCardFragment.spread({ userId: $.userId }),\n *     posts: postsFragment.spread({ userId: $.userId }),\n *   }),\n * });\n *\n * // In parser definition (same labels)\n * createExecutionResultParser({\n *   userCard: userCardProjection,\n *   posts: postsProjection,\n * });\n * ```\n */\nexport const createColocateHelper = () => {\n  /**\n   * Colocate multiple field selections with labeled prefixes.\n   *\n   * @param entries - Object mapping labels to field selections\n   * @returns Merged object of all prefixed field entries\n   */\n  const $colocate = <TEntries extends ColocatedEntries>(entries: TEntries): ColocatedFields<TEntries> =>\n    Object.fromEntries(\n      Object.entries(entries).flatMap(([label, fields]) =>\n        Object.entries(fields).map(([key, value]) => [`${label}_${key}`, value] as const),\n      ),\n    ) as ColocatedFields<TEntries>;\n\n  return $colocate;\n};\n\nexport type ColocateHelper = ReturnType<typeof createColocateHelper>;\n","/**\n * Promise detection utilities for cross-realm compatibility.\n * @module\n */\n\n/**\n * Check if a value is Promise-like (has .then method).\n *\n * This function uses duck typing instead of `instanceof Promise` to work across\n * VM sandbox boundaries where Promises created in a different realm have a\n * different constructor.\n *\n * @example\n * ```typescript\n * // Works with native Promises\n * isPromiseLike(Promise.resolve(42)); // true\n *\n * // Works with VM sandbox Promises (instanceof would fail)\n * const vmPromise = vm.runInContext(\"Promise.resolve(42)\", context);\n * isPromiseLike(vmPromise); // true (instanceof Promise would be false)\n *\n * // Rejects non-Promises\n * isPromiseLike({ then: \"not a function\" }); // false\n * isPromiseLike(null); // false\n * isPromiseLike(42); // false\n * ```\n */\nexport const isPromiseLike = <T>(value: unknown): value is PromiseLike<T> => {\n  return value !== null && typeof value === \"object\" && \"then\" in value && typeof value.then === \"function\";\n};\n","import { isPromiseLike } from \"../../utils/promise\";\n\n/**\n * Context passed to the definition factory during evaluation.\n */\nexport type LazyEvaluatorContext = {\n  canonicalId: string;\n};\n\n/**\n * Factory function that produces the definition value.\n * Can be sync or async.\n */\nexport type LazyDefinitionFactory<T> = (context: LazyEvaluatorContext | null) => T | Promise<T>;\n\n/**\n * Function that provides dependencies to evaluate before the main definition.\n */\nexport type LazyDependencyProvider<TDep> = () => TDep[];\n\n/**\n * Internal generator that handles the evaluation protocol.\n */\nexport type LazyEvaluatorExecutor<T> = (context: LazyEvaluatorContext | null) => Generator<Promise<void>, T, void>;\n\n/**\n * Creates a lazy evaluator with caching, async support, and dependency ordering.\n *\n * @param define - Factory function that produces the value\n * @param getDeps - Optional function returning dependencies to evaluate first\n * @param createDepGenerator - Function to create evaluation generator for a dependency\n * @returns An executor generator function\n */\nexport const createLazyEvaluator = <T, TDep>(\n  define: LazyDefinitionFactory<T>,\n  getDeps: LazyDependencyProvider<TDep> | undefined,\n  createDepGenerator: (dep: TDep) => Generator<Promise<void>, void, void>,\n): LazyEvaluatorExecutor<T> => {\n  let cache: { value: T } | null = null;\n  let promise: Promise<void> | null = null;\n\n  return function* execute(context: LazyEvaluatorContext | null): Generator<Promise<void>, T, void> {\n    if (cache) {\n      return cache.value;\n    }\n\n    if (promise) {\n      yield promise;\n      // biome-ignore lint/style/noNonNullAssertion: cache is guaranteed to be set after promise resolves\n      return cache!.value;\n    }\n\n    if (getDeps) {\n      // Need to evaluate the dependencies before the current element is evaluated.\n      //\n      // When dependencies is evaluated while the current element is being evaluated,\n      // the evaluation method will be synchronous regardless of how the current builder\n      // performs. If the dependencies need to be evaluated asynchronously, they throw an error.\n      for (const dep of getDeps()) {\n        yield* createDepGenerator(dep);\n      }\n    }\n\n    const defined = define(context);\n    // Use duck typing for VM sandbox compatibility (instanceof Promise fails for cross-realm Promises)\n    if (!isPromiseLike(defined)) {\n      return (cache = { value: defined }).value;\n    }\n\n    // Create a promise to resolve the value of the element asynchronously.\n    // Yield the promise to make the builder process handle the asynchronous operation if it supports it.\n    promise = defined.then((value) => {\n      cache = { value };\n      promise = null;\n    });\n\n    yield promise;\n    // biome-ignore lint/style/noNonNullAssertion: cache is guaranteed to be set after promise resolves\n    return cache!.value;\n  };\n};\n\n/**\n * Creates an evaluation generator from an executor.\n * Wraps the executor's generator and discards its return value.\n */\nexport function* createEvaluationGenerator<T>(\n  executor: LazyEvaluatorExecutor<T>,\n  context: LazyEvaluatorContext | null,\n): Generator<Promise<void>, void, void> {\n  yield* executor(context);\n}\n\n/**\n * Executes the evaluator synchronously.\n * Throws if async operation is encountered.\n */\nexport const evaluateSync = <T>(executor: LazyEvaluatorExecutor<T>, context: LazyEvaluatorContext | null): T => {\n  const result = executor(context).next();\n\n  if (!result.done) {\n    throw new Error(\"Async operation is not supported in sync evaluation.\");\n  }\n\n  return result.value;\n};\n","import type { AttachmentShape, AttachmentsTupleToIntersection } from \"./attachment-types\";\nimport {\n  createLazyEvaluator,\n  type LazyEvaluatorContext,\n  type LazyEvaluatorExecutor,\n  createEvaluationGenerator as lazyCreateEvaluationGenerator,\n  evaluateSync as lazyEvaluateSync,\n} from \"./lazy-evaluator\";\n\nconst GQL_ELEMENT_FACTORY = Symbol(\"GQL_ELEMENT_FACTORY\");\nconst GQL_ELEMENT_CONTEXT = Symbol(\"GQL_ELEMENT_CONTEXT\");\n\n/**\n * Context passed to element definition factories, containing the canonical ID.\n */\nexport type GqlElementContext = LazyEvaluatorContext;\n\n/**\n * Factory function that produces the element definition.\n * May be sync or async (async requires async build mode).\n */\nexport type GqlElementDefinitionFactory<T> = (context: GqlElementContext | null) => T | Promise<T>;\n\n/**\n * Configuration for attaching a computed property to an element.\n */\nexport type GqlElementAttachment<TElement extends object, TName extends string, TValue extends object> = {\n  name: TName;\n  createValue: (element: TElement) => TValue;\n};\n\n/**\n * Abstract base class for all GraphQL elements (Fragment, Operation).\n *\n * Uses lazy evaluation with caching - definition is computed on first access.\n * Subclasses should not be instantiated directly; use static `create` methods.\n *\n * @template TDefinition - The shape of the evaluated definition\n * @template TInfer - Type inference metadata (access via `$infer`)\n */\nexport abstract class GqlElement<TDefinition extends object, TInfer extends object> {\n  /**\n   * Type-only property for inference. Throws at runtime.\n   * Use with `typeof element.$infer` to extract input/output types.\n   */\n  declare readonly $infer: TInfer;\n\n  private [GQL_ELEMENT_FACTORY]: LazyEvaluatorExecutor<TDefinition>;\n  private [GQL_ELEMENT_CONTEXT]: GqlElementContext | null = null;\n\n  protected constructor(define: GqlElementDefinitionFactory<TDefinition>, getDeps?: () => GqlElement<any, any>[]) {\n    this[GQL_ELEMENT_FACTORY] = createLazyEvaluator(define, getDeps, GqlElement.createEvaluationGenerator);\n\n    Object.defineProperty(this, \"$infer\", {\n      get() {\n        throw new Error(\"This property is only for type meta. Do not access this property directly.\");\n      },\n    });\n  }\n\n  /**\n   * Attaches lazily-computed properties to this element.\n   * Properties are computed once on first access after evaluation.\n   *\n   * @example Single attachment\n   * ```typescript\n   * const fragment = gql.default(...)\n   *   .attach({ name: \"utils\", createValue: (el) => ({ ... }) });\n   * ```\n   *\n   * @example Multiple attachments (use `as const` for full type inference)\n   * ```typescript\n   * const fragment = gql.default(...)\n   *   .attach([\n   *     { name: \"a\", createValue: () => ({ x: 1 }) },\n   *     { name: \"b\", createValue: () => ({ y: 2 }) },\n   *   ] as const);\n   * ```\n   */\n  public attach<TName extends string, TValue extends object>(\n    attachment: GqlElementAttachment<this, TName, TValue>,\n  ): this & { [K in TName]: TValue };\n  public attach<const TAttachments extends readonly AttachmentShape[]>(\n    attachments: TAttachments,\n  ): this & AttachmentsTupleToIntersection<TAttachments>;\n  public attach<TName extends string, TValue extends object>(\n    attachmentOrAttachments: GqlElementAttachment<this, TName, TValue> | readonly AttachmentShape[],\n  ): this & { [K in TName]: TValue } {\n    const attachments = Array.isArray(attachmentOrAttachments) ? attachmentOrAttachments : [attachmentOrAttachments];\n\n    for (const attachment of attachments) {\n      let cache: object | null = null;\n      const self = this;\n\n      Object.defineProperty(this, attachment.name, {\n        get() {\n          if (cache) {\n            return cache;\n          }\n\n          GqlElement.evaluateInstantly(self);\n\n          return (cache = attachment.createValue(self));\n        },\n      });\n    }\n\n    return this as this & { [K in TName]: TValue };\n  }\n\n  /**\n   * Sets the canonical context for an element. Used by the builder.\n   * @internal\n   */\n  static setContext<TElement extends GqlElement<any, any>>(element: TElement, context: GqlElementContext): void {\n    element[GQL_ELEMENT_CONTEXT] = context;\n  }\n\n  /**\n   * Gets the canonical context of an element, if set.\n   * @internal\n   */\n  static getContext(element: GqlElement<any, any>): GqlElementContext | null {\n    return element[GQL_ELEMENT_CONTEXT];\n  }\n\n  /**\n   * Creates a generator for async evaluation. Used by the builder.\n   * @internal\n   */\n  static createEvaluationGenerator(element: GqlElement<any, any>): Generator<Promise<void>, void, void> {\n    return lazyCreateEvaluationGenerator(element[GQL_ELEMENT_FACTORY], element[GQL_ELEMENT_CONTEXT]);\n  }\n\n  private static evaluateInstantly<TValue extends object>(element: GqlElement<TValue, any>): TValue {\n    return lazyEvaluateSync(element[GQL_ELEMENT_FACTORY], element[GQL_ELEMENT_CONTEXT]);\n  }\n\n  /**\n   * Forces synchronous evaluation. Throws if async operation is needed.\n   * @internal\n   */\n  static evaluateSync(element: GqlElement<any, any>): void {\n    void GqlElement.evaluateInstantly(element);\n  }\n\n  /**\n   * Evaluates and returns the element's definition.\n   * Throws if async operation is needed.\n   * @internal\n   */\n  static get<TValue extends object>(element: GqlElement<TValue, any>): TValue {\n    return GqlElement.evaluateInstantly(element);\n  }\n}\n","/**\n * Define element for storing arbitrary value factories.\n * @module\n */\n\nimport { isPromiseLike } from \"../../utils/promise\";\nimport { GqlElement, type GqlElementContext } from \"./gql-element\";\n\n/**\n * Type alias for any GqlDefine instance.\n */\nexport type AnyGqlDefine = GqlDefine<unknown>;\n\n/**\n * Type inference metadata for define elements.\n * Access via `typeof defineElement.$infer`.\n */\nexport type DefineInferMeta<TValue> = {\n  readonly value: TValue;\n};\n\ndeclare const __DEFINE_BRAND__: unique symbol;\n\n/**\n * Internal artifact shape produced by define evaluation.\n * @internal\n */\ntype DefineArtifact<TValue> = {\n  readonly factoryResult: TValue;\n};\n\n/**\n * Represents a factory-based value definition.\n *\n * Define elements are created via `gql(({ define }) => define(() => value))`.\n * The factory is evaluated lazily and the result is cached.\n *\n * @template TValue - The type of value produced by the factory\n *\n * @example\n * ```typescript\n * // Store a primitive value\n * const myNumber = gql.default(({ define }) => define(() => 42));\n * console.log(myNumber.value); // 42\n *\n * // Store a plain object\n * const myConfig = gql.default(({ define }) => define(() => ({\n *   apiUrl: \"https://api.example.com\",\n *   timeout: 5000,\n * })));\n * console.log(myConfig.value.apiUrl); // \"https://api.example.com\"\n * ```\n */\nexport class GqlDefine<TValue> extends GqlElement<DefineArtifact<TValue>, DefineInferMeta<TValue>> {\n  private declare readonly [__DEFINE_BRAND__]: void;\n\n  private constructor(define: (context: GqlElementContext | null) => DefineArtifact<TValue> | Promise<DefineArtifact<TValue>>) {\n    super(define);\n  }\n\n  /**\n   * The evaluated value from the factory.\n   * Triggers lazy evaluation on first access.\n   */\n  public get value(): TValue {\n    return GqlElement.get(this).factoryResult;\n  }\n\n  /**\n   * Creates a new GqlDefine instance.\n   *\n   * Prefer using the `gql(({ define }) => define(() => value))` API instead.\n   *\n   * @param factory - Function that produces the value. Can be sync or async.\n   * @returns A new GqlDefine instance wrapping the factory result.\n   *\n   * @example\n   * ```typescript\n   * // Sync factory\n   * const syncDefine = GqlDefine.create(() => 42);\n   *\n   * // Async factory\n   * const asyncDefine = GqlDefine.create(async () => {\n   *   const data = await fetch('/api/config');\n   *   return data.json();\n   * });\n   * ```\n   */\n  static create<TValue>(factory: () => TValue | Promise<TValue>): GqlDefine<TValue> {\n    return new GqlDefine((_context) => {\n      const result = factory();\n      // Handle async factories\n      if (isPromiseLike<TValue>(result)) {\n        return result.then((value) => ({ factoryResult: value }));\n      }\n      return { factoryResult: result as TValue };\n    });\n  }\n}\n","/**\n * Fragment types for reusable field selections.\n * @module\n */\n\nimport type { OptionalArg } from \"../../utils/empty-object\";\nimport type { AnyAssignableInput, AnyFields, AssignableInput, InferFields } from \"../fragment\";\nimport type { AnyGraphqlSchema } from \"../schema\";\nimport type { InputTypeSpecifiers } from \"../type-foundation\";\nimport { GqlElement } from \"./gql-element\";\n\n/**\n * Type alias for any Fragment instance.\n */\nexport type AnyFragment = Fragment<string, any, AnyFields, any>;\n\n/**\n * Type inference metadata for fragments.\n * Access via `typeof fragment.$infer`.\n */\nexport type FragmentInferMeta<TVariables, TOutput extends object> = {\n  readonly input: TVariables;\n  readonly output: TOutput;\n};\n\n/**\n * Internal artifact shape produced by fragment evaluation.\n * @internal\n */\ninterface FragmentArtifact<\n  TTypeName extends string,\n  TVariables extends Partial<AnyAssignableInput> | void,\n  TFields extends Partial<AnyFields>,\n> {\n  readonly typename: TTypeName;\n  readonly key: string | undefined;\n  readonly schemaLabel: string;\n  readonly variableDefinitions: InputTypeSpecifiers;\n  readonly spread: (variables: TVariables) => TFields;\n}\n\ndeclare const __FRAGMENT_BRAND__: unique symbol;\n\n/**\n * Represents a reusable GraphQL field selection on a specific type.\n *\n * Fragments are created via `gql(({ fragment }) => fragment.TypeName({ ... }))`.\n * Use `spread()` to include the fragment's fields in an operation.\n *\n * @template TTypeName - The GraphQL type this fragment selects from\n * @template TVariables - Variables required when spreading\n * @template TFields - The selected fields structure\n * @template TOutput - Inferred output type from selected fields\n */\nexport class Fragment<\n    TTypeName extends string,\n    TVariables extends Partial<AnyAssignableInput> | void,\n    TFields extends Partial<AnyFields>,\n    TOutput extends object,\n  >\n  extends GqlElement<FragmentArtifact<TTypeName, TVariables, TFields>, FragmentInferMeta<TVariables, TOutput>>\n  implements FragmentArtifact<TTypeName, TVariables, TFields>\n{\n  private declare readonly [__FRAGMENT_BRAND__]: void;\n\n  private constructor(define: () => FragmentArtifact<TTypeName, TVariables, TFields>) {\n    super(define);\n  }\n\n  /** The GraphQL type name this fragment selects from. */\n  public get typename() {\n    return GqlElement.get(this).typename;\n  }\n\n  /** Optional unique key for prebuilt type lookup. */\n  public get key() {\n    return GqlElement.get(this).key;\n  }\n\n  /** The schema label this fragment belongs to. */\n  public get schemaLabel() {\n    return GqlElement.get(this).schemaLabel;\n  }\n\n  /** Variable definitions for this fragment. */\n  public get variableDefinitions() {\n    return GqlElement.get(this).variableDefinitions;\n  }\n\n  /**\n   * Spreads this fragment's fields into a parent selection.\n   * Pass variables if the fragment defines any.\n   */\n  public get spread() {\n    return GqlElement.get(this).spread;\n  }\n\n  /**\n   * Creates a new Fragment instance.\n   * Prefer using the `gql(({ fragment }) => ...)` API instead.\n   * @internal\n   */\n  static create<\n    TSchema extends AnyGraphqlSchema,\n    TTypeName extends keyof TSchema[\"object\"] & string,\n    TVariableDefinitions extends InputTypeSpecifiers,\n    TFields extends AnyFields,\n  >(\n    define: () => {\n      typename: TTypeName;\n      key: string | undefined;\n      schemaLabel: TSchema[\"label\"];\n      variableDefinitions: TVariableDefinitions;\n      spread: (variables: OptionalArg<AssignableInput<TSchema, TVariableDefinitions>>) => TFields;\n    },\n  ) {\n    type Fields = TFields & { [key: symbol]: never };\n    type Output = InferFields<TSchema, TFields> & { [key: symbol]: never };\n    type Variables = OptionalArg<AssignableInput<TSchema, TVariableDefinitions>>;\n\n    return new Fragment<TTypeName, Variables, Fields, Output>(define as () => FragmentArtifact<TTypeName, Variables, Fields>);\n  }\n}\n","/**\n * Operation types for GraphQL queries, mutations, and subscriptions.\n * @module\n */\n\nimport type { TypedDocumentNode } from \"@graphql-typed-document-node/core\";\nimport type { AnyFields, InferFields } from \"../fragment\";\nimport type { AnyConstAssignableInput, AnyGraphqlSchema, ConstAssignableInput, OperationType } from \"../schema\";\nimport type { InputTypeSpecifiers } from \"../type-foundation\";\nimport { GqlElement, type GqlElementContext } from \"./gql-element\";\n\n/**\n * Type alias for any Operation instance.\n */\nexport type AnyOperation = AnyOperationOf<\"query\"> | AnyOperationOf<\"mutation\"> | AnyOperationOf<\"subscription\">;\n\n/**\n * Type alias for an Operation of a specific type.\n */\nexport type AnyOperationOf<TOperationType extends OperationType> = Operation<\n  TOperationType,\n  string,\n  string[],\n  any,\n  AnyFields,\n  any\n>;\n\n/**\n * Type inference metadata for operations.\n * Access via `typeof operation.$infer`.\n */\nexport type OperationInferMeta<TVariables, TData extends object> = {\n  readonly input: TVariables;\n  readonly output: TData;\n};\n\ndeclare const __OPERATION_BRAND__: unique symbol;\n\n/**\n * Internal artifact shape produced by operation evaluation.\n * @internal\n */\ntype OperationArtifact<\n  TOperationType extends OperationType,\n  TOperationName extends string,\n  TVariableNames extends string[],\n  TVariables extends AnyConstAssignableInput,\n  TFields extends Partial<AnyFields>,\n  TData extends object,\n> = {\n  readonly operationType: TOperationType;\n  readonly operationName: TOperationName;\n  readonly schemaLabel: string;\n  readonly variableNames: TVariableNames;\n  readonly documentSource: () => TFields;\n  readonly document: TypedDocumentNode<TData, TVariables>;\n  readonly metadata?: unknown;\n};\n\n/**\n * Represents a GraphQL operation (query, mutation, or subscription).\n *\n * Operations are created via `gql(({ query }) => query.operation({ ... }))`.\n * Produces a TypedDocumentNode for type-safe execution with GraphQL clients.\n *\n * @template TOperationType - 'query' | 'mutation' | 'subscription'\n * @template TOperationName - The unique operation name\n * @template TVariableNames - Tuple of variable names\n * @template TVariables - Variable types for the operation\n * @template TFields - Selected fields structure\n * @template TData - Inferred response data type\n */\nexport class Operation<\n    TOperationType extends OperationType,\n    TOperationName extends string,\n    TVariableNames extends string[],\n    TVariables extends AnyConstAssignableInput,\n    TFields extends Partial<AnyFields>,\n    TData extends object,\n  >\n  extends GqlElement<\n    OperationArtifact<TOperationType, TOperationName, TVariableNames, TVariables, TFields, TData>,\n    OperationInferMeta<TVariables, TData>\n  >\n  implements OperationArtifact<TOperationType, TOperationName, TVariableNames, TVariables, TFields, TData>\n{\n  private declare readonly [__OPERATION_BRAND__]: void;\n\n  private constructor(\n    define: (\n      context: GqlElementContext | null,\n    ) =>\n      | OperationArtifact<TOperationType, TOperationName, TVariableNames, TVariables, TFields, TData>\n      | Promise<OperationArtifact<TOperationType, TOperationName, TVariableNames, TVariables, TFields, TData>>,\n  ) {\n    super(define);\n  }\n\n  /** The operation type: 'query', 'mutation', or 'subscription'. */\n  public get operationType() {\n    return GqlElement.get(this).operationType;\n  }\n\n  /** The unique name of this operation. */\n  public get operationName() {\n    return GqlElement.get(this).operationName;\n  }\n\n  /** The schema label this operation belongs to. */\n  public get schemaLabel() {\n    return GqlElement.get(this).schemaLabel;\n  }\n\n  /** List of variable names defined for this operation. */\n  public get variableNames() {\n    return GqlElement.get(this).variableNames;\n  }\n\n  /**\n   * Returns the field selections. Used for document reconstruction.\n   * @internal\n   */\n  public get documentSource() {\n    return GqlElement.get(this).documentSource;\n  }\n\n  /** The TypedDocumentNode for use with GraphQL clients. */\n  public get document() {\n    return GqlElement.get(this).document;\n  }\n\n  /** Custom metadata attached to this operation, if any. */\n  public get metadata() {\n    return GqlElement.get(this).metadata;\n  }\n\n  /**\n   * Creates a new Operation instance.\n   * Prefer using the `gql(({ query }) => ...)` API instead.\n   * @internal\n   */\n  static create<\n    TSchema extends AnyGraphqlSchema,\n    TOperationType extends OperationType,\n    TOperationName extends string,\n    TVariableDefinitions extends InputTypeSpecifiers,\n    TFields extends AnyFields,\n  >(\n    define: (context: GqlElementContext | null) =>\n      | {\n          operationType: TOperationType;\n          operationName: TOperationName;\n          schemaLabel: TSchema[\"label\"];\n          variableNames: (keyof TVariableDefinitions & string)[];\n          documentSource: () => TFields;\n          document: TypedDocumentNode<InferFields<TSchema, TFields>, ConstAssignableInput<TSchema, TVariableDefinitions>>;\n          metadata?: unknown;\n        }\n      | Promise<{\n          operationType: TOperationType;\n          operationName: TOperationName;\n          schemaLabel: TSchema[\"label\"];\n          variableNames: (keyof TVariableDefinitions & string)[];\n          documentSource: () => TFields;\n          document: TypedDocumentNode<InferFields<TSchema, TFields>, ConstAssignableInput<TSchema, TVariableDefinitions>>;\n          metadata?: unknown;\n        }>,\n  ) {\n    return new Operation(define);\n  }\n}\n","/**\n * Compat composer factory for creating GraphQL operation specifications.\n * @module\n */\n\nimport { type FieldsBuilder, GqlDefine } from \"../types/element\";\nimport type { CompatSpec } from \"../types/element/compat-spec\";\nimport type { AnyFields } from \"../types/fragment\";\nimport type { AnyGraphqlSchema, OperationType } from \"../types/schema\";\nimport type { InputTypeSpecifiers } from \"../types/type-foundation\";\n\n/**\n * Options for creating a compat operation specification.\n */\nexport type CompatOptions<\n  TSchema extends AnyGraphqlSchema,\n  TTypeName extends keyof TSchema[\"object\"] & string,\n  TOperationName extends string,\n  TVarDefinitions extends InputTypeSpecifiers,\n  TFields extends AnyFields,\n> = {\n  /** The operation name */\n  name: TOperationName;\n  /** Optional variable definitions */\n  variables?: TVarDefinitions;\n  /** Field selection builder */\n  fields: FieldsBuilder<TSchema, TTypeName, TVarDefinitions, TFields>;\n};\n\n/**\n * Creates a factory for composing compat operation specifications.\n *\n * Returns a function that creates a `GqlDefine<CompatSpec<...>>` storing\n * the operation specification with unevaluated fieldsBuilder.\n *\n * @param schema - The GraphQL schema definition\n * @param operationType - The operation type ('query' | 'mutation' | 'subscription')\n * @returns Compat operation composer function\n *\n * @internal Used by `createGqlElementComposer`\n */\nexport const createCompatComposer = <TSchema extends AnyGraphqlSchema, TOperationType extends OperationType>(\n  schema: NoInfer<TSchema>,\n  operationType: TOperationType,\n) => {\n  type TTypeName = TSchema[\"operations\"][TOperationType] & keyof TSchema[\"object\"] & string;\n  const operationTypeName: TTypeName | null = schema.operations[operationType];\n  if (operationTypeName === null) {\n    throw new Error(`Operation type ${operationType} is not defined in schema roots`);\n  }\n\n  return <TOperationName extends string, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}>(\n    options: CompatOptions<TSchema, TTypeName, TOperationName, TVarDefinitions, TFields>,\n  ): GqlDefine<CompatSpec<TSchema, TOperationType, TOperationName, TVarDefinitions, TFields>> => {\n    return GqlDefine.create(() => ({\n      schema,\n      operationType,\n      operationName: options.name,\n      variables: (options.variables ?? {}) as TVarDefinitions,\n      fieldsBuilder: options.fields,\n    }));\n  };\n};\n","/**\n * Directive builder utilities for creating field-level directives.\n *\n * Provides type-safe methods for creating directive references that can be\n * applied to field selections. The builder follows a similar pattern to\n * the variable builder ($var).\n *\n * @module\n */\n\nimport {\n  type AnyDirectiveRef,\n  type DirectiveArgumentSpecifier,\n  type DirectiveLocation,\n  DirectiveRef,\n} from \"../types/type-foundation/directive-ref\";\nimport type { AnyVarRef } from \"../types/type-foundation/var-ref\";\n\n/**\n * A method that creates a DirectiveRef with specific type information.\n * The TArgs type defines the expected argument shape for the directive.\n */\nexport type DirectiveMethod<TDirectiveName extends string, TLocations extends readonly DirectiveLocation[], TArgs> = (\n  args: TArgs,\n) => DirectiveRef<{\n  directiveName: TDirectiveName;\n  locations: TLocations;\n}>;\n\n/**\n * Type for directive arguments that can include VarRef values.\n * This allows using variables in directive arguments like `{ if: $.shouldSkip }`.\n */\nexport type DirectiveArgValue = boolean | string | number | null | AnyVarRef;\n\n/**\n * Standard GraphQL directives that are always available.\n */\nexport type StandardDirectives = {\n  /**\n   * @skip directive - conditionally skip a field.\n   * @example\n   * ```typescript\n   * f.email({}, { directives: [$dir.skip({ if: $.hideEmail })] })\n   * ```\n   */\n  skip: DirectiveMethod<\"skip\", readonly [\"FIELD\", \"FRAGMENT_SPREAD\", \"INLINE_FRAGMENT\"], { if: DirectiveArgValue }>;\n\n  /**\n   * @include directive - conditionally include a field.\n   * @example\n   * ```typescript\n   * f.email({}, { directives: [$dir.include({ if: $.showEmail })] })\n   * ```\n   */\n  include: DirectiveMethod<\"include\", readonly [\"FIELD\", \"FRAGMENT_SPREAD\", \"INLINE_FRAGMENT\"], { if: DirectiveArgValue }>;\n};\n\n/**\n * Creates a directive method factory for a specific directive.\n *\n * @param name - The directive name (without @)\n * @param locations - Valid locations where the directive can be applied\n * @returns A function that creates DirectiveRef instances\n *\n * @example\n * ```typescript\n * const skipMethod = createDirectiveMethod(\"skip\", [\"FIELD\", \"FRAGMENT_SPREAD\", \"INLINE_FRAGMENT\"] as const);\n * const skipDirective = skipMethod({ if: true });\n * ```\n */\nexport const createDirectiveMethod = <TDirectiveName extends string, const TLocations extends readonly DirectiveLocation[]>(\n  name: TDirectiveName,\n  locations: TLocations,\n): (<TArgs extends Record<string, unknown>>(\n  args: TArgs,\n) => DirectiveRef<{\n  directiveName: TDirectiveName;\n  locations: TLocations;\n}>) => {\n  return (args) =>\n    new DirectiveRef({\n      name,\n      arguments: args,\n      locations,\n    }) as DirectiveRef<{\n      directiveName: TDirectiveName;\n      locations: TLocations;\n    }>;\n};\n\n/**\n * Type for directive argument specifiers.\n * Maps argument names to their type information.\n */\nexport type DirectiveArgumentSpecifiers = {\n  readonly [argName: string]: DirectiveArgumentSpecifier;\n};\n\n/**\n * Creates a typed directive method with argument type specifiers.\n * Enables enum value output in directive arguments.\n *\n * @param name - The directive name (without @)\n * @param locations - Valid locations where the directive can be applied\n * @param argSpecs - Type specifiers for directive arguments\n * @returns A function that creates DirectiveRef instances with argument type info\n *\n * @example\n * ```typescript\n * const authMethod = createTypedDirectiveMethod(\n *   \"auth\",\n *   [\"FIELD\"] as const,\n *   { role: { kind: \"enum\", name: \"Role\", modifier: \"!\" } }\n * );\n * const authDirective = authMethod({ role: \"ADMIN\" });\n * ```\n */\nexport const createTypedDirectiveMethod = <\n  TDirectiveName extends string,\n  const TLocations extends readonly DirectiveLocation[],\n  const TArgSpecs extends DirectiveArgumentSpecifiers,\n>(\n  name: TDirectiveName,\n  locations: TLocations,\n  argSpecs: TArgSpecs,\n): (<TArgs extends Record<string, unknown>>(\n  args: TArgs,\n) => DirectiveRef<{\n  directiveName: TDirectiveName;\n  locations: TLocations;\n}>) => {\n  return (args) =>\n    new DirectiveRef({\n      name,\n      arguments: args,\n      locations,\n      argumentSpecs: argSpecs,\n    }) as DirectiveRef<{\n      directiveName: TDirectiveName;\n      locations: TLocations;\n    }>;\n};\n\n/**\n * Standard directive locations for @skip and @include.\n */\nconst CONDITIONAL_DIRECTIVE_LOCATIONS = [\"FIELD\", \"FRAGMENT_SPREAD\", \"INLINE_FRAGMENT\"] as const;\n\n/**\n * Creates the standard GraphQL directives (@skip, @include).\n * These are always available regardless of schema definition.\n *\n * @returns Object containing skip and include directive methods\n *\n * @example\n * ```typescript\n * const $dir = createStandardDirectives();\n * const skipDirective = $dir.skip({ if: true });\n * ```\n */\nexport const createStandardDirectives = (): StandardDirectives => ({\n  skip: createDirectiveMethod(\"skip\", CONDITIONAL_DIRECTIVE_LOCATIONS),\n  include: createDirectiveMethod(\"include\", CONDITIONAL_DIRECTIVE_LOCATIONS),\n});\n\n/**\n * Type for any directive method (type-erased).\n */\n// biome-ignore lint/suspicious/noExplicitAny: intentionally erased for flexibility\nexport type AnyDirectiveMethod = (args: any) => AnyDirectiveRef;\n\n/**\n * Type for the directive builder that includes standard directives\n * and can be extended with schema-specific directives.\n */\nexport type DirectiveBuilder<TCustomDirectives extends Record<string, AnyDirectiveMethod> = {}> = StandardDirectives &\n  TCustomDirectives;\n\n/**\n * Creates a directive builder with standard directives and optional custom directives.\n *\n * @param customDirectives - Additional directive methods from schema (generated by codegen)\n * @returns Combined directive builder with all available directives\n *\n * @internal Used by codegen to create schema-specific directive builders\n */\nexport const createDirectiveBuilder = <TCustomDirectives extends Record<string, AnyDirectiveMethod> = {}>(\n  customDirectives?: TCustomDirectives,\n): DirectiveBuilder<TCustomDirectives> => {\n  return {\n    ...createStandardDirectives(),\n    ...(customDirectives ?? ({} as TCustomDirectives)),\n  };\n};\n\n/**\n * Type guard to check if a value is a DirectiveRef.\n *\n * @param value - Value to check\n * @returns True if value is a DirectiveRef instance\n */\nexport const isDirectiveRef = (value: unknown): value is AnyDirectiveRef => {\n  return value instanceof DirectiveRef;\n};\n","import type { DocumentNode } from \"graphql\";\nimport type { FieldPath } from \"../../composer/field-path-context\";\nimport type { OperationType } from \"../schema\";\nimport type { OperationMetadata } from \"./metadata\";\n\n/**\n * Information about a fragment's metadata when spread in an operation.\n */\nexport type FragmentMetaInfo<TFragmentMetadata> = {\n  /** The evaluated metadata from the fragment, if defined */\n  readonly metadata: TFragmentMetadata | undefined;\n  /** Field path where the fragment was spread */\n  readonly fieldPath: FieldPath | null;\n};\n\n/**\n * Metadata adapter that defines how fragment metadata is aggregated\n * and provides schema-level configuration.\n *\n * This adapter allows complete customization of:\n * - Fragment metadata type (TFragmentMetadata)\n * - How fragment metadata is aggregated (aggregateFragmentMetadata)\n * - Schema-level fixed values available to all operation metadata builders (schemaLevel)\n *\n * Note: Operation metadata type is inferred from the operation's metadata callback return type.\n *\n * @template TFragmentMetadata - The metadata type returned by fragment metadata builders\n * @template TAggregatedFragmentMetadata - The type returned by aggregateFragmentMetadata\n * @template TSchemaLevel - The type of schema-level configuration values\n */\nexport type MetadataAdapter<TFragmentMetadata = unknown, TAggregatedFragmentMetadata = unknown, TSchemaLevel = unknown> = {\n  /**\n   * Aggregates metadata from all spread fragments in an operation.\n   * Called with the metadata from each spread fragment.\n   * The return type becomes the `fragmentMetadata` parameter in operation metadata builders.\n   */\n  readonly aggregateFragmentMetadata: (fragments: readonly FragmentMetaInfo<TFragmentMetadata>[]) => TAggregatedFragmentMetadata;\n  /**\n   * Schema-level fixed values that are passed to all operation metadata builders.\n   * Useful for configuration that should be consistent across all operations.\n   */\n  readonly schemaLevel?: TSchemaLevel;\n};\n\n/**\n * Extracts the type parameters from a MetadataAdapter.\n */\nexport type ExtractAdapterTypes<T> = T extends MetadataAdapter<infer TFragment, infer TAggregated, infer TSchemaLevel>\n  ? {\n      fragmentMetadata: TFragment;\n      aggregatedFragmentMetadata: TAggregated;\n      schemaLevel: TSchemaLevel;\n    }\n  : never;\n\n/**\n * Generic type for any metadata adapter.\n */\nexport type AnyMetadataAdapter = MetadataAdapter<any, any, any>;\n\n/**\n * Arguments passed to document transformer function.\n * Destructurable for convenient access.\n *\n * @template TSchemaLevel - Schema-level configuration type\n * @template TAggregatedFragmentMetadata - Aggregated fragment metadata type\n */\nexport type DocumentTransformArgs<TSchemaLevel = unknown, TAggregatedFragmentMetadata = unknown> = {\n  /** The GraphQL document to transform */\n  readonly document: DocumentNode;\n  /** The operation name */\n  readonly operationName: string;\n  /** The operation type (query, mutation, subscription) */\n  readonly operationType: OperationType;\n  /** Variable names defined for this operation */\n  readonly variableNames: readonly string[];\n  /** Schema-level configuration from adapter */\n  readonly schemaLevel: TSchemaLevel | undefined;\n  /** Aggregated fragment metadata */\n  readonly fragmentMetadata: TAggregatedFragmentMetadata | undefined;\n};\n\n/**\n * Document transformer function.\n * Receives the built DocumentNode and returns a transformed DocumentNode.\n *\n * @template TSchemaLevel - Schema-level configuration type\n * @template TAggregatedFragmentMetadata - Aggregated fragment metadata type\n */\nexport type DocumentTransformer<TSchemaLevel = unknown, TAggregatedFragmentMetadata = unknown> = (\n  args: DocumentTransformArgs<TSchemaLevel, TAggregatedFragmentMetadata>,\n) => DocumentNode;\n\n/**\n * Arguments passed to operation-level document transformer.\n * Receives typed operation metadata.\n *\n * @template TOperationMetadata - The operation's metadata type\n */\nexport type OperationDocumentTransformArgs<TOperationMetadata = unknown> = {\n  /** The GraphQL document to transform */\n  readonly document: DocumentNode;\n  /** The operation metadata (typed per-operation) */\n  readonly metadata: TOperationMetadata | undefined;\n};\n\n/**\n * Operation-level document transformer function.\n * Applied before the adapter-level transform.\n *\n * **Best Practice:** Define transform logic in adapter helpers for reusability,\n * then reference the helper in the operation's `transformDocument` option.\n *\n * @example\n * ```typescript\n * // Define in adapter helpers\n * const adapter = defineAdapter({\n *   helpers: {\n *     transform: {\n *       addCache: (ttl: number) => ({ document }) => visit(document, { ... }),\n *     },\n *   },\n * });\n *\n * // Use in operation\n * query.operation({\n *   transformDocument: transform.addCache(300),\n *   ...\n * });\n * ```\n *\n * @template TOperationMetadata - The operation's metadata type\n */\nexport type OperationDocumentTransformer<TOperationMetadata = unknown> = (\n  args: OperationDocumentTransformArgs<TOperationMetadata>,\n) => DocumentNode;\n\n/**\n * Unified adapter that combines helpers and metadata configuration.\n *\n * @template THelpers - Custom helper functions accessible in gql composer callbacks\n * @template TFragmentMetadata - The metadata type returned by fragment metadata builders\n * @template TAggregatedFragmentMetadata - The type returned by aggregateFragmentMetadata\n * @template TSchemaLevel - The type of schema-level configuration values\n *\n * @example\n * ```typescript\n * const adapter = defineAdapter({\n *   helpers: {\n *     auth: {\n *       requiresLogin: () => ({ requiresAuth: true }),\n *     },\n *   },\n *   metadata: {\n *     aggregateFragmentMetadata: (fragments) => fragments.map((m) => m.metadata),\n *     schemaLevel: { apiVersion: \"v2\" },\n *   },\n * });\n * ```\n */\nexport type Adapter<\n  THelpers extends object = object,\n  TFragmentMetadata = unknown,\n  TAggregatedFragmentMetadata = unknown,\n  TSchemaLevel = unknown,\n> = {\n  /** Custom helper functions accessible in gql composer callbacks */\n  readonly helpers?: THelpers;\n  /** Metadata configuration for fragments and operations */\n  readonly metadata?: MetadataAdapter<TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel>;\n  /** Optional document transformer called after document building */\n  readonly transformDocument?: DocumentTransformer<TSchemaLevel, TAggregatedFragmentMetadata>;\n};\n\n/**\n * Generic type for any unified adapter.\n */\nexport type AnyAdapter = Adapter<any, any, any, any>;\n\n/**\n * Extracts the type parameters from a unified Adapter.\n */\nexport type ExtractUnifiedAdapterTypes<T> = T extends Adapter<\n  infer THelpers,\n  infer TFragment,\n  infer TAggregated,\n  infer TSchemaLevel\n>\n  ? {\n      helpers: THelpers;\n      fragmentMetadata: TFragment;\n      aggregatedFragmentMetadata: TAggregated;\n      schemaLevel: TSchemaLevel;\n    }\n  : never;\n\n/**\n * Default adapter that maintains backwards compatibility with the original behavior.\n * Uses OperationMetadata for fragment metadata and aggregates by collecting metadata into a readonly array.\n */\nexport type DefaultMetadataAdapter = MetadataAdapter<OperationMetadata, readonly (OperationMetadata | undefined)[]>;\n\n/**\n * Default unified adapter type.\n */\nexport type DefaultAdapter = Adapter<object, OperationMetadata, readonly (OperationMetadata | undefined)[]>;\n\n/**\n * Creates the default adapter instance.\n * @internal\n */\nexport const createDefaultAdapter = (): DefaultMetadataAdapter => ({\n  aggregateFragmentMetadata: (fragments) => fragments.map((m) => m.metadata),\n});\n\n/**\n * The default adapter instance.\n */\nexport const defaultMetadataAdapter: DefaultMetadataAdapter = createDefaultAdapter();\n","type ArgEntries<T extends object> = { [K in keyof T]-?: [value: T[K], key: K] }[keyof T];\ntype Entries<T extends object> = { [K in keyof T]: [key: K, value: T[K]] }[keyof T];\n\nexport function mapValues<TObject extends object, TMappedValue>(\n  obj: TObject,\n  fn: (...args: ArgEntries<TObject>) => TMappedValue,\n): {\n  [K in keyof TObject]: TMappedValue;\n} {\n  return Object.fromEntries((Object.entries(obj) as Entries<TObject>[]).map(([key, value]) => [key, fn(value, key)])) as {\n    [K in keyof TObject]: TMappedValue;\n  };\n}\n","/**\n * Field path context using shared value container pattern.\n *\n * This module tracks the current field path during field building,\n * similar to how React tracks the current fiber.\n * No changes to field builder arguments are needed - use getCurrentFieldPath() to access.\n */\n\n/**\n * A segment in the field path.\n */\nexport type FieldPathSegment = {\n  /** The field name */\n  readonly field: string;\n  /** The parent type name */\n  readonly parent: string;\n  /** Whether this field returns a list */\n  readonly isList: boolean;\n};\n\n/**\n * Complete field path from root to current position.\n */\nexport type FieldPath = {\n  /** Full path string (e.g., \"$.user.posts[].author\") */\n  readonly full: string;\n  /** Individual path segments */\n  readonly segments: readonly FieldPathSegment[];\n};\n\n/**\n * Shared mutable container for field path context.\n * Only synchronous access is supported.\n */\nconst fieldPathContext: { current: FieldPath | null } = {\n  current: null,\n};\n\n/**\n * Get the current field path.\n * Returns null if not in a field building context.\n *\n * @example\n * ```typescript\n * import { getCurrentFieldPath } from '@soda-gql/core';\n *\n * // Inside a field builder or model spread:\n * const path = getCurrentFieldPath();\n * console.log(path?.full); // \"$.user.posts[].author\"\n * ```\n */\nexport const getCurrentFieldPath = (): FieldPath | null => fieldPathContext.current;\n\n/**\n * Run a function with a specific field path context.\n * Restores the previous path after the function completes.\n *\n * @internal\n */\nexport const withFieldPath = <T>(path: FieldPath, fn: () => T): T => {\n  const previousPath = fieldPathContext.current;\n  fieldPathContext.current = path;\n  try {\n    return fn();\n  } finally {\n    fieldPathContext.current = previousPath;\n  }\n};\n\n/**\n * Append a new segment to the current path.\n *\n * @internal\n */\nexport const appendToPath = (\n  parent: FieldPath | null,\n  segment: { field: string; parentType: string; isList: boolean },\n): FieldPath => {\n  const listSuffix = segment.isList ? \"[]\" : \"\";\n  const newSegment: FieldPathSegment = {\n    field: segment.field,\n    parent: segment.parentType,\n    isList: segment.isList,\n  };\n\n  if (!parent) {\n    return {\n      full: `$.${segment.field}${listSuffix}`,\n      segments: [newSegment],\n    };\n  }\n\n  return {\n    full: `${parent.full}.${segment.field}${listSuffix}`,\n    segments: [...parent.segments, newSegment],\n  };\n};\n\n/**\n * Check if a type specifier represents a list type.\n * Matches patterns like \"Type:![]!\", \"Type:![]?\", \"Type:?[]!\", etc.\n *\n * @internal\n */\nexport const isListType = (typeString: string): boolean => {\n  return typeString.includes(\"[]\");\n};\n","/**\n * Creates field selection factories for building GraphQL selections.\n * @module\n */\n\nimport type {\n  AnyFieldSelectionFactory,\n  AnyFieldSelectionFactoryReturn,\n  FieldSelectionFactories,\n  NestedObjectFieldsBuilder,\n  NestedUnionFieldsBuilder,\n} from \"../types/element\";\nimport type { AnyFieldSelection, AnyNestedObject, AnyNestedUnion } from \"../types/fragment\";\nimport type { AnyGraphqlSchema, UnionMemberName } from \"../types/schema\";\nimport type { OutputObjectSpecifier, OutputUnionSpecifier } from \"../types/type-foundation\";\nimport type { AnyDirectiveRef } from \"../types/type-foundation/directive-ref\";\nimport { mapValues } from \"../utils/map-values\";\nimport { wrapByKey } from \"../utils/wrap-by-key\";\nimport { appendToPath, getCurrentFieldPath, isListType, withFieldPath } from \"./field-path-context\";\n\n/**\n * Cache map type for field factories.\n * Schema-scoped to avoid cross-schema contamination.\n * @internal\n */\ntype CacheMap = Map<string, Record<string, AnyFieldSelectionFactory>>;\n\nconst cacheMapBySchema = new WeakMap<AnyGraphqlSchema, CacheMap>();\nconst ensureCacheMapBySchema = (schema: AnyGraphqlSchema) => {\n  const cachedCacheMap = cacheMapBySchema.get(schema);\n  if (cachedCacheMap) {\n    return cachedCacheMap;\n  }\n\n  const cacheMap: CacheMap = new Map();\n  cacheMapBySchema.set(schema, cacheMap);\n  return cacheMap;\n};\n\n/**\n * Creates field selection factories for a given object type.\n *\n * Returns an object with a factory for each field defined on the type.\n * Factories are cached per schema+type to avoid recreation.\n *\n * @param schema - The GraphQL schema definition\n * @param typeName - The object type name to create factories for\n * @returns Object mapping field names to their selection factories\n *\n * @internal Used by operation and fragment composers\n */\nexport const createFieldFactories = <TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema[\"object\"] & string>(\n  schema: TSchema,\n  typeName: TTypeName,\n): FieldSelectionFactories<TSchema, TTypeName> => {\n  const cacheMap = ensureCacheMapBySchema(schema);\n  const cached = cacheMap.get(typeName);\n  if (cached) {\n    return cached as unknown as FieldSelectionFactories<TSchema, TTypeName>;\n  }\n\n  const factories = createFieldFactoriesInner(schema, typeName);\n  cacheMap.set(typeName, factories as unknown as Record<string, AnyFieldSelectionFactory>);\n\n  return factories;\n};\n\nconst createFieldFactoriesInner = <TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema[\"object\"] & string>(\n  schema: TSchema,\n  typeName: TTypeName,\n): FieldSelectionFactories<TSchema, TTypeName> => {\n  const typeDef = schema.object[typeName];\n  if (!typeDef) {\n    throw new Error(`Type ${typeName} is not defined in schema objects`);\n  }\n\n  const entries = Object.entries(typeDef.fields).map(([fieldName, type]): [string, AnyFieldSelectionFactory] => {\n    const factory: AnyFieldSelectionFactory = <TAlias extends string | null = null>(\n      fieldArgs: AnyFieldSelection[\"args\"] | null | void,\n      extras?: { alias?: TAlias; directives?: AnyDirectiveRef[] },\n    ) => {\n      const wrap = <T>(value: T) => wrapByKey((extras?.alias ?? fieldName) as TAlias extends null ? string : TAlias, value);\n      const directives = extras?.directives ?? [];\n\n      if (type.kind === \"object\") {\n        type TSelection = AnyFieldSelection & { type: OutputObjectSpecifier };\n        const factoryReturn = (<TNested extends AnyNestedObject>(\n          nest: NestedObjectFieldsBuilder<TSchema, TSelection[\"type\"][\"name\"], TNested>,\n        ) => {\n          // Build new path for this field\n          const currentPath = getCurrentFieldPath();\n          const newPath = appendToPath(currentPath, {\n            field: fieldName,\n            parentType: typeName,\n            isList: isListType(type.modifier),\n          });\n\n          // Run nested builder with updated path context\n          const nestedFields = withFieldPath(newPath, () => nest({ f: createFieldFactories(schema, type.name) }));\n\n          return wrap({\n            parent: typeName,\n            field: fieldName,\n            type: type,\n            args: fieldArgs ?? {},\n            directives,\n            object: nestedFields,\n            union: null,\n          });\n        }) as unknown as AnyFieldSelectionFactoryReturn<TAlias>;\n\n        return factoryReturn;\n      }\n\n      if (type.kind === \"union\") {\n        type TSelection = AnyFieldSelection & { type: OutputUnionSpecifier };\n        const factoryReturn = (<TNested extends AnyNestedUnion>(\n          nest: NestedUnionFieldsBuilder<TSchema, UnionMemberName<TSchema, TSelection[\"type\"]>, TNested>,\n        ) => {\n          // Build new path for this field\n          const currentPath = getCurrentFieldPath();\n          const newPath = appendToPath(currentPath, {\n            field: fieldName,\n            parentType: typeName,\n            isList: isListType(type.modifier),\n          });\n\n          // Run nested builders with updated path context\n          const nestedUnion = withFieldPath(newPath, () =>\n            mapValues(\n              nest as Record<string, NestedObjectFieldsBuilder<TSchema, string, AnyNestedObject> | undefined>,\n              (builder, memberName) => {\n                if (!builder) {\n                  throw new Error(`Builder is undefined for member name: ${memberName}`);\n                }\n                return builder({ f: createFieldFactories(schema, memberName) });\n              },\n            ),\n          ) as TNested;\n\n          return wrap({\n            parent: typeName,\n            field: fieldName,\n            type: type,\n            args: fieldArgs ?? {},\n            directives,\n            object: null,\n            union: nestedUnion,\n          });\n        }) as unknown as AnyFieldSelectionFactoryReturn<TAlias>;\n\n        return factoryReturn;\n      }\n\n      if (type.kind === \"scalar\" || type.kind === \"enum\" || type.kind === \"typename\") {\n        const factoryReturn: AnyFieldSelectionFactoryReturn<TAlias> = wrap({\n          parent: typeName,\n          field: fieldName,\n          type,\n          args: fieldArgs ?? {},\n          directives,\n          object: null,\n          union: null,\n        });\n        return factoryReturn;\n      }\n\n      throw new Error(`Unsupported field type: ${type satisfies never}`);\n    };\n\n    return [fieldName, factory] as const;\n  });\n\n  const factories: Record<string, AnyFieldSelectionFactory> = Object.fromEntries(entries);\n\n  return factories as unknown as FieldSelectionFactories<TSchema, TTypeName>;\n};\n","/**\n * Fragment usage context using shared value container pattern.\n *\n * This module tracks fragment usages during operation building,\n * allowing metadata from spread fragments to be collected and aggregated.\n * Similar to field-path-context, uses a shared mutable container.\n */\n\nimport type { FieldPath } from \"./field-path-context\";\n\n/**\n * Record of a fragment being spread in an operation.\n * Stores metadata builder (not fragment reference) since fragment cannot reference itself.\n *\n * @template TFragmentMetadata - The type of metadata produced by the fragment's metadata builder\n */\nexport type FragmentUsageRecord<TFragmentMetadata = unknown> = {\n  /** Metadata builder factory from the fragment, if defined */\n  readonly metadataBuilder: (() => TFragmentMetadata | Promise<TFragmentMetadata>) | null;\n  /** Field path where the fragment was spread */\n  readonly path: FieldPath | null;\n};\n\n/**\n * Shared mutable container for collecting fragment usages.\n * Only synchronous access is supported.\n */\nconst fragmentUsageContext: { current: FragmentUsageRecord[] | null } = {\n  current: null,\n};\n\n/**\n * Run a function with fragment usage collection enabled.\n * Returns both the function result and collected fragment usages.\n *\n * @internal\n */\nexport const withFragmentUsageCollection = <T>(fn: () => T): { result: T; usages: FragmentUsageRecord[] } => {\n  const previousCollector = fragmentUsageContext.current;\n  const usages: FragmentUsageRecord[] = [];\n  fragmentUsageContext.current = usages;\n  try {\n    const result = fn();\n    return { result, usages };\n  } finally {\n    fragmentUsageContext.current = previousCollector;\n  }\n};\n\n/**\n * Record a fragment usage. Called when fragment.spread() is invoked.\n * No-op if not in a collection context.\n *\n * @internal\n */\nexport const recordFragmentUsage = (record: FragmentUsageRecord): void => {\n  if (fragmentUsageContext.current) {\n    fragmentUsageContext.current.push(record);\n  }\n};\n","/**\n * Utilities for creating variable assignments and references.\n * @module\n */\n\nimport {\n  type AnyAssignableInput,\n  createVarRefFromNestedValue,\n  createVarRefFromVariable,\n  type DeclaredVariables,\n  VarRef,\n} from \"../types/fragment\";\nimport type { AnyGraphqlSchema } from \"../types/schema\";\nimport type { AnyVarRef, InputTypeSpecifiers, NestedValue } from \"../types/type-foundation\";\nimport { mapValues } from \"../utils/map-values\";\n\n/**\n * Creates variable assignments from provided values.\n *\n * Maps variable definitions to VarRefs. If a value is provided,\n * wraps it as a nested-value VarRef. If not provided, creates\n * an undefined VarRef (field will be omitted).\n *\n * Used when spreading fragments with partial variable values.\n *\n * @internal\n */\nexport const createVarAssignments = <TSchema extends AnyGraphqlSchema, TVariableDefinitions extends InputTypeSpecifiers>(\n  definitions: TVariableDefinitions,\n  providedValues: AnyAssignableInput | void,\n): DeclaredVariables<TSchema, TVariableDefinitions> => {\n  return mapValues(definitions, (_, key): AnyVarRef => {\n    const varName = key as string;\n    if (!providedValues || providedValues[varName] === undefined) {\n      return createVarRefFromNestedValue(undefined);\n    }\n\n    const provided = providedValues[varName];\n    if (provided instanceof VarRef) {\n      return provided;\n    }\n\n    return createVarRefFromNestedValue(provided as NestedValue);\n  }) as DeclaredVariables<TSchema, TVariableDefinitions>;\n};\n\n/**\n * Creates variable references from variable definitions.\n *\n * Maps each variable definition to a VarRef pointing to that variable.\n * Used in operation builders to create the `$` context object.\n *\n * @internal\n */\nexport const createVarRefs = <TSchema extends AnyGraphqlSchema, TVarDefinitions extends InputTypeSpecifiers>(\n  definitions: TVarDefinitions,\n) =>\n  mapValues(definitions as InputTypeSpecifiers, (_, name): AnyVarRef => createVarRefFromVariable(name)) as DeclaredVariables<\n    TSchema,\n    TVarDefinitions\n  >;\n","/**\n * Core operation building logic shared by operation and extend composers.\n * @module\n * @internal\n */\n\nimport type { FieldsBuilder } from \"../types/element\";\nimport type { AnyFields, DeclaredVariables } from \"../types/fragment\";\nimport type {\n  AnyMetadataAdapter,\n  DocumentTransformer,\n  ExtractAdapterTypes,\n  FragmentMetaInfo,\n  MetadataBuilder,\n  OperationDocumentTransformer,\n} from \"../types/metadata\";\nimport type { AnyGraphqlSchema, OperationType } from \"../types/schema\";\nimport type { InputTypeSpecifiers } from \"../types/type-foundation\";\n\nimport { isPromiseLike } from \"../utils/promise\";\nimport { buildDocument } from \"./build-document\";\nimport { createFieldFactories } from \"./fields-builder\";\nimport { withFragmentUsageCollection } from \"./fragment-usage-context\";\nimport { createVarRefs } from \"./input\";\n\n/**\n * Parameters for building an operation artifact.\n * Used by both operation and extend composers.\n */\nexport type OperationCoreParams<\n  TSchema extends AnyGraphqlSchema,\n  TOperationType extends OperationType,\n  TOperationName extends string,\n  TVarDefinitions extends InputTypeSpecifiers,\n  TFields extends AnyFields,\n  TOperationMetadata,\n  TAdapter extends AnyMetadataAdapter,\n> = {\n  // Required\n  readonly schema: TSchema;\n  readonly operationType: TOperationType;\n  readonly operationTypeName: TSchema[\"operations\"][TOperationType] & keyof TSchema[\"object\"] & string;\n  readonly operationName: TOperationName;\n  readonly variables: TVarDefinitions;\n  readonly fieldsFactory: FieldsBuilder<\n    TSchema,\n    TSchema[\"operations\"][TOperationType] & keyof TSchema[\"object\"] & string,\n    TVarDefinitions,\n    TFields\n  >;\n\n  // Metadata handling\n  readonly adapter: TAdapter;\n  readonly metadata?: MetadataBuilder<\n    DeclaredVariables<TSchema, TVarDefinitions>,\n    TOperationMetadata,\n    ExtractAdapterTypes<TAdapter>[\"aggregatedFragmentMetadata\"],\n    ExtractAdapterTypes<TAdapter>[\"schemaLevel\"]\n  >;\n  readonly transformDocument?: OperationDocumentTransformer<TOperationMetadata>;\n  readonly adapterTransformDocument?: DocumentTransformer<\n    ExtractAdapterTypes<TAdapter>[\"schemaLevel\"],\n    ExtractAdapterTypes<TAdapter>[\"aggregatedFragmentMetadata\"]\n  >;\n};\n\n/**\n * Result type from buildOperationArtifact.\n * Matches the artifact shape expected by Operation.create().\n */\nexport type OperationArtifactResult<\n  TOperationType extends OperationType,\n  TOperationName extends string,\n  TVarDefinitions extends InputTypeSpecifiers,\n  TFields extends AnyFields,\n  TOperationMetadata,\n> = {\n  readonly operationType: TOperationType;\n  readonly operationName: TOperationName;\n  readonly schemaLabel: string;\n  readonly variableNames: (keyof TVarDefinitions & string)[];\n  readonly documentSource: () => TFields;\n  readonly document: ReturnType<typeof buildDocument>;\n  readonly metadata: TOperationMetadata | undefined;\n};\n\n/**\n * Builds an operation artifact from the provided parameters.\n *\n * This function contains the core logic for:\n * - Creating variable refs and field factories\n * - Evaluating fields with fragment usage tracking\n * - Building the document\n * - Handling metadata (sync and async)\n * - Applying document transformations\n *\n * @param params - Operation building parameters\n * @returns Operation artifact or Promise of artifact (if async metadata)\n *\n * @internal Used by operation.ts and extend.ts\n */\nexport const buildOperationArtifact = <\n  TSchema extends AnyGraphqlSchema,\n  TOperationType extends OperationType,\n  TOperationName extends string,\n  TVarDefinitions extends InputTypeSpecifiers,\n  TFields extends AnyFields,\n  TOperationMetadata,\n  TAdapter extends AnyMetadataAdapter,\n>(\n  params: OperationCoreParams<TSchema, TOperationType, TOperationName, TVarDefinitions, TFields, TOperationMetadata, TAdapter>,\n):\n  | OperationArtifactResult<TOperationType, TOperationName, TVarDefinitions, TFields, TOperationMetadata>\n  | Promise<OperationArtifactResult<TOperationType, TOperationName, TVarDefinitions, TFields, TOperationMetadata>> => {\n  type TFragmentMetadata = ExtractAdapterTypes<TAdapter>[\"fragmentMetadata\"];\n  type TAggregatedFragmentMetadata = ExtractAdapterTypes<TAdapter>[\"aggregatedFragmentMetadata\"];\n  type TSchemaLevel = ExtractAdapterTypes<TAdapter>[\"schemaLevel\"];\n\n  const {\n    schema,\n    operationType,\n    operationTypeName,\n    operationName,\n    variables,\n    fieldsFactory,\n    adapter,\n    metadata: metadataBuilder,\n    transformDocument: operationTransformDocument,\n    adapterTransformDocument,\n  } = params;\n\n  // 1. Create tools\n  const $ = createVarRefs<TSchema, TVarDefinitions>(variables);\n  const f = createFieldFactories(schema, operationTypeName);\n\n  // 2. Evaluate fields with fragment tracking\n  const { result: fields, usages: fragmentUsages } = withFragmentUsageCollection(() => fieldsFactory({ f, $ }));\n\n  // 3. Build document\n  const document = buildDocument<TSchema, TFields, TVarDefinitions>({\n    operationName,\n    operationType,\n    variables,\n    fields,\n    schema,\n  });\n\n  const variableNames = Object.keys(variables) as (keyof TVarDefinitions & string)[];\n\n  // 4. Check if any fragment has a metadata builder\n  const hasFragmentMetadata = fragmentUsages.some((u) => u.metadataBuilder);\n\n  // Fast path: no metadata to evaluate and no transform\n  if (!hasFragmentMetadata && !metadataBuilder && !adapterTransformDocument && !operationTransformDocument) {\n    return {\n      operationType,\n      operationName,\n      schemaLabel: schema.label,\n      variableNames,\n      documentSource: () => fields,\n      document: document as ReturnType<typeof buildDocument>,\n      metadata: undefined,\n    };\n  }\n\n  // 5. Helper to aggregate fragment metadata\n  const aggregateFragmentMetadata = (\n    resolvedFragmentMetadata: (TFragmentMetadata | undefined)[],\n  ): TAggregatedFragmentMetadata => {\n    const fragmentMetaInfos: FragmentMetaInfo<TFragmentMetadata>[] = fragmentUsages.map((usage, index) => ({\n      metadata: resolvedFragmentMetadata[index],\n      fieldPath: usage.path,\n    }));\n    return adapter.aggregateFragmentMetadata(fragmentMetaInfos) as TAggregatedFragmentMetadata;\n  };\n\n  // 6. Evaluate fragment metadata first (sync or async)\n  const fragmentMetadataResults: (TFragmentMetadata | undefined | Promise<TFragmentMetadata>)[] = fragmentUsages.map((usage) =>\n    usage.metadataBuilder ? usage.metadataBuilder() : undefined,\n  );\n\n  // Check if any fragment metadata is async\n  const hasAsyncFragmentMetadata = fragmentMetadataResults.some((r) => isPromiseLike(r));\n\n  // 7. Helper to build operation metadata from aggregated fragment metadata\n  const buildOperationMetadata = (\n    aggregatedFragmentMetadata: TAggregatedFragmentMetadata,\n  ): TOperationMetadata | undefined | Promise<TOperationMetadata | undefined> => {\n    const schemaLevel = adapter.schemaLevel as TSchemaLevel | undefined;\n    return metadataBuilder?.({ $, document, fragmentMetadata: aggregatedFragmentMetadata, schemaLevel });\n  };\n\n  // 8. Factory that creates the final artifact\n  const makeCreateArtifact = (aggregated: TAggregatedFragmentMetadata) => {\n    return ({\n      metadata,\n    }: {\n      metadata: TOperationMetadata | undefined;\n    }): OperationArtifactResult<TOperationType, TOperationName, TVarDefinitions, TFields, TOperationMetadata> => {\n      // Step 1: Operation transform (typed metadata) - FIRST\n      let finalDocument = operationTransformDocument\n        ? (operationTransformDocument({\n            document,\n            metadata,\n          }) as typeof document)\n        : document;\n\n      // Step 2: Adapter transform (schemaLevel + fragmentMetadata) - SECOND\n      if (adapterTransformDocument) {\n        finalDocument = adapterTransformDocument({\n          document: finalDocument,\n          operationName,\n          operationType,\n          variableNames,\n          schemaLevel: adapter.schemaLevel as TSchemaLevel | undefined,\n          fragmentMetadata: aggregated,\n        }) as typeof document;\n      }\n\n      return {\n        operationType,\n        operationName,\n        schemaLabel: schema.label,\n        variableNames,\n        documentSource: () => fields,\n        document: finalDocument as ReturnType<typeof buildDocument>,\n        metadata,\n      };\n    };\n  };\n\n  // 9. Handle async fragment metadata\n  if (hasAsyncFragmentMetadata) {\n    return Promise.all(fragmentMetadataResults).then(async (resolvedFragmentMetadata) => {\n      const aggregated = aggregateFragmentMetadata(resolvedFragmentMetadata);\n      const operationMetadata = await buildOperationMetadata(aggregated);\n      return makeCreateArtifact(aggregated)({ metadata: operationMetadata });\n    });\n  }\n\n  // 10. All fragment metadata is sync\n  const syncFragmentMetadata = fragmentMetadataResults as (TFragmentMetadata | undefined)[];\n  const aggregated = aggregateFragmentMetadata(syncFragmentMetadata);\n  const createArtifact = makeCreateArtifact(aggregated);\n\n  const operationMetadataResult = buildOperationMetadata(aggregated);\n\n  // Use duck typing for VM sandbox compatibility\n  if (isPromiseLike(operationMetadataResult)) {\n    return operationMetadataResult.then((metadata) => createArtifact({ metadata }));\n  }\n\n  return createArtifact({ metadata: operationMetadataResult });\n};\n","/**\n * Extend composer factory for creating Operations from compat specs.\n * @module\n */\n\nimport { type GqlDefine, Operation } from \"../types/element\";\nimport type { CompatSpec } from \"../types/element/compat-spec\";\nimport type { AnyFields, DeclaredVariables } from \"../types/fragment\";\nimport type {\n  AnyMetadataAdapter,\n  DefaultMetadataAdapter,\n  DocumentTransformer,\n  ExtractAdapterTypes,\n  MetadataBuilder,\n  OperationDocumentTransformer,\n} from \"../types/metadata\";\nimport { defaultMetadataAdapter } from \"../types/metadata\";\nimport type { AnyGraphqlSchema, OperationType } from \"../types/schema\";\nimport type { InputTypeSpecifiers } from \"../types/type-foundation\";\n\nimport { buildOperationArtifact } from \"./operation-core\";\n\n/**\n * Options for extending a compat spec into a full operation.\n */\nexport type ExtendOptions<\n  TSchema extends AnyGraphqlSchema,\n  TVarDefinitions extends InputTypeSpecifiers,\n  TOperationMetadata,\n  TAggregatedFragmentMetadata,\n  TSchemaLevel,\n> = {\n  /** Optional metadata builder */\n  metadata?: MetadataBuilder<\n    DeclaredVariables<TSchema, TVarDefinitions>,\n    TOperationMetadata,\n    TAggregatedFragmentMetadata,\n    TSchemaLevel\n  >;\n  /** Optional document transformer */\n  transformDocument?: OperationDocumentTransformer<TOperationMetadata>;\n};\n\n/**\n * Creates a factory for extending compat specs into full operations.\n *\n * The extend function takes a compat spec (created by `query.compat()`) and\n * optional metadata/transformDocument options, then creates a full Operation.\n *\n * @param schema - The GraphQL schema definition\n * @param adapter - Optional metadata adapter for custom metadata handling\n * @param transformDocument - Optional document transformer\n * @returns Extend composer function\n *\n * @internal Used by `createGqlElementComposer`\n */\nexport const createExtendComposer = <\n  TSchema extends AnyGraphqlSchema,\n  TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter,\n>(\n  schema: NoInfer<TSchema>,\n  adapter?: TAdapter,\n  transformDocument?: DocumentTransformer<\n    ExtractAdapterTypes<TAdapter>[\"schemaLevel\"],\n    ExtractAdapterTypes<TAdapter>[\"aggregatedFragmentMetadata\"]\n  >,\n) => {\n  const resolvedAdapter = adapter ?? (defaultMetadataAdapter as TAdapter);\n\n  type TAggregatedFragmentMetadata = ExtractAdapterTypes<TAdapter>[\"aggregatedFragmentMetadata\"];\n  type TSchemaLevel = ExtractAdapterTypes<TAdapter>[\"schemaLevel\"];\n\n  return <\n    TOperationType extends OperationType,\n    TOperationName extends string,\n    TVarDefinitions extends InputTypeSpecifiers,\n    TFields extends AnyFields,\n    TOperationMetadata = unknown,\n  >(\n    compat: GqlDefine<CompatSpec<TSchema, TOperationType, TOperationName, TVarDefinitions, TFields>>,\n    options?: ExtendOptions<TSchema, TVarDefinitions, TOperationMetadata, TAggregatedFragmentMetadata, TSchemaLevel>,\n  ) => {\n    // Extract the spec from GqlDefine\n    const spec = compat.value;\n    const { operationType, operationName, variables, fieldsBuilder } = spec;\n\n    // Get the operation type name from schema\n    type TTypeName = TSchema[\"operations\"][TOperationType] & keyof TSchema[\"object\"] & string;\n    const operationTypeName = schema.operations[operationType] as TTypeName;\n\n    type DefineResult = Parameters<typeof Operation.create<TSchema, TOperationType, TOperationName, TVarDefinitions, TFields>>[0];\n    // Type assertion needed because compat spec stores fieldsBuilder with schema-specific types\n    // that are compatible at runtime but need casting for TypeScript\n    return Operation.create<TSchema, TOperationType, TOperationName, TVarDefinitions, TFields>((() =>\n      buildOperationArtifact({\n        schema,\n        operationType,\n        operationTypeName,\n        operationName,\n        variables: variables as TVarDefinitions,\n        // biome-ignore lint/suspicious/noExplicitAny: Type cast needed for compat spec fieldsBuilder\n        fieldsFactory: fieldsBuilder as any,\n        adapter: resolvedAdapter,\n        metadata: options?.metadata,\n        transformDocument: options?.transformDocument,\n        adapterTransformDocument: transformDocument,\n      })) as unknown as DefineResult);\n  };\n};\n","/**\n * Fragment composer factory for creating reusable field selections.\n * @module\n */\n\nimport { type FieldsBuilder, Fragment } from \"../types/element\";\nimport type { AnyFields, DeclaredVariables } from \"../types/fragment\";\nimport type { AnyMetadataAdapter, DefaultMetadataAdapter, ExtractAdapterTypes, FragmentMetadataBuilder } from \"../types/metadata\";\nimport type { AnyGraphqlSchema } from \"../types/schema\";\nimport type { InputTypeSpecifiers } from \"../types/type-foundation\";\nimport { mapValues } from \"../utils/map-values\";\nimport { getCurrentFieldPath } from \"./field-path-context\";\nimport { createFieldFactories } from \"./fields-builder\";\nimport { recordFragmentUsage } from \"./fragment-usage-context\";\nimport { createVarAssignments, type createVarRefs } from \"./input\";\n\n/**\n * Type alias for a fragment builder function for a specific object type.\n *\n * Used by codegen to generate explicit fragment builder types instead of\n * expensive mapped types. This improves IDE performance for large schemas.\n */\nexport type FragmentBuilderFor<\n  TSchema extends AnyGraphqlSchema,\n  TTypeName extends keyof TSchema[\"object\"] & string,\n  TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter,\n> = <TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}>(options: {\n  /** Optional unique key for prebuilt type lookup. */\n  key?: string;\n  variables?: TVarDefinitions;\n  metadata?: FragmentMetadataBuilder<\n    ReturnType<typeof createVarRefs<TSchema, TVarDefinitions>>,\n    ExtractAdapterTypes<TAdapter>[\"fragmentMetadata\"]\n  >;\n  fields: FieldsBuilder<TSchema, TTypeName, TVarDefinitions, TFields>;\n}) => ReturnType<typeof Fragment.create<TSchema, TTypeName, TVarDefinitions, TFields>>;\n\n/**\n * Creates fragment builder functions for all object types in the schema.\n *\n * Returns an object with a builder for each type (e.g., `fragment.User`, `fragment.Post`).\n * Each builder creates a `Fragment` that can be spread into operations.\n *\n * @param schema - The GraphQL schema definition\n * @param _adapter - Optional metadata adapter (for fragment metadata)\n * @returns Object mapping type names to fragment builder functions\n *\n * @internal Used by `createGqlElementComposer`\n */\nexport const createGqlFragmentComposers = <\n  TSchema extends AnyGraphqlSchema,\n  TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter,\n>(\n  schema: NoInfer<TSchema>,\n  _adapter?: TAdapter,\n) => {\n  type TFragmentMetadata = ExtractAdapterTypes<TAdapter>[\"fragmentMetadata\"];\n\n  type FragmentBuilder<TTypeName extends keyof TSchema[\"object\"] & string> = <\n    TFields extends AnyFields,\n    TVarDefinitions extends InputTypeSpecifiers = {},\n  >(options: {\n    key?: string;\n    variables?: TVarDefinitions;\n    metadata?: FragmentMetadataBuilder<ReturnType<typeof createVarRefs<TSchema, TVarDefinitions>>, TFragmentMetadata>;\n    fields: FieldsBuilder<TSchema, TTypeName, TVarDefinitions, TFields>;\n  }) => ReturnType<typeof Fragment.create<TSchema, TTypeName, TVarDefinitions, TFields>>;\n\n  const createFragmentComposer = <TTypeName extends keyof TSchema[\"object\"] & string>(\n    typename: TTypeName,\n  ): FragmentBuilder<TTypeName> => {\n    return <TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}>(options: {\n      key?: string;\n      variables?: TVarDefinitions;\n      metadata?: FragmentMetadataBuilder<DeclaredVariables<TSchema, TVarDefinitions>, TFragmentMetadata>;\n      fields: FieldsBuilder<TSchema, TTypeName, TVarDefinitions, TFields>;\n    }) => {\n      const varDefinitions = (options.variables ?? {}) as TVarDefinitions;\n      const { key, metadata, fields } = options;\n\n      return Fragment.create<TSchema, TTypeName, TVarDefinitions, TFields>(() => ({\n        typename,\n        key,\n        schemaLabel: schema.label,\n        variableDefinitions: varDefinitions,\n        spread: (variables) => {\n          const f = createFieldFactories(schema, typename);\n          const $ = createVarAssignments<TSchema, TVarDefinitions>(varDefinitions, variables);\n\n          recordFragmentUsage({\n            metadataBuilder: metadata ? () => metadata({ $ }) : null,\n            path: getCurrentFieldPath(),\n          });\n\n          return fields({ f, $ });\n        },\n      }));\n    };\n  };\n\n  type FragmentBuildersAll = {\n    readonly [TTypeName in keyof TSchema[\"object\"]]: TTypeName extends string ? FragmentBuilder<TTypeName> : never;\n  };\n\n  // Include operation roots (Query, Mutation, Subscription) for fragment colocation\n  // These allow defining reusable fragments on operation root types\n  type FragmentBuilders = FragmentBuildersAll;\n\n  return mapValues(schema.object, (_, typename) => createFragmentComposer(typename)) as FragmentBuilders;\n};\n","/**\n * Operation composer factory for creating typed GraphQL operations.\n * @module\n */\n\nimport { type FieldsBuilder, Operation } from \"../types/element\";\nimport type { AnyFields } from \"../types/fragment\";\nimport type {\n  AnyMetadataAdapter,\n  DefaultMetadataAdapter,\n  DocumentTransformer,\n  ExtractAdapterTypes,\n  MetadataBuilder,\n  OperationDocumentTransformer,\n} from \"../types/metadata\";\nimport { defaultMetadataAdapter } from \"../types/metadata\";\nimport type { AnyGraphqlSchema, OperationType } from \"../types/schema\";\nimport type { InputTypeSpecifiers } from \"../types/type-foundation\";\nimport type { createVarRefs } from \"./input\";\nimport { buildOperationArtifact } from \"./operation-core\";\n\n/**\n * Creates a factory for composing GraphQL operations.\n *\n * Returns a curried function: first select operation type (query/mutation/subscription),\n * then define the operation with name, variables, and fields.\n *\n * Handles metadata aggregation from fragments (sync or async) and builds\n * the TypedDocumentNode automatically.\n *\n * @param schema - The GraphQL schema definition\n * @param adapter - Optional metadata adapter for custom metadata handling\n * @param transformDocument - Optional document transformer called after building\n * @returns Operation type selector function\n *\n * @internal Used by `createGqlElementComposer`\n */\nexport const createOperationComposerFactory = <\n  TSchema extends AnyGraphqlSchema,\n  TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter,\n>(\n  schema: NoInfer<TSchema>,\n  adapter?: TAdapter,\n  transformDocument?: DocumentTransformer<\n    ExtractAdapterTypes<TAdapter>[\"schemaLevel\"],\n    ExtractAdapterTypes<TAdapter>[\"aggregatedFragmentMetadata\"]\n  >,\n) => {\n  const resolvedAdapter = adapter ?? (defaultMetadataAdapter as TAdapter);\n\n  type TAggregatedFragmentMetadata = ExtractAdapterTypes<TAdapter>[\"aggregatedFragmentMetadata\"];\n  type TSchemaLevel = ExtractAdapterTypes<TAdapter>[\"schemaLevel\"];\n\n  return <TOperationType extends OperationType>(operationType: TOperationType) => {\n    type TTypeName = TSchema[\"operations\"][TOperationType] & keyof TSchema[\"object\"] & string;\n    const operationTypeName: TTypeName | null = schema.operations[operationType];\n    if (operationTypeName === null) {\n      throw new Error(`Operation type ${operationType} is not defined in schema roots`);\n    }\n\n    return <\n      TOperationName extends string,\n      TFields extends AnyFields,\n      TVarDefinitions extends InputTypeSpecifiers = {},\n      TOperationMetadata = unknown,\n    >(options: {\n      name: TOperationName;\n      variables?: TVarDefinitions;\n      metadata?: MetadataBuilder<\n        ReturnType<typeof createVarRefs<TSchema, TVarDefinitions>>,\n        TOperationMetadata,\n        TAggregatedFragmentMetadata,\n        TSchemaLevel\n      >;\n      fields: FieldsBuilder<TSchema, TTypeName, TVarDefinitions, TFields>;\n      transformDocument?: OperationDocumentTransformer<TOperationMetadata>;\n    }) => {\n      type DefineResult = Parameters<\n        typeof Operation.create<TSchema, TOperationType, TOperationName, TVarDefinitions, TFields>\n      >[0];\n      return Operation.create<TSchema, TOperationType, TOperationName, TVarDefinitions, TFields>((() =>\n        buildOperationArtifact({\n          schema,\n          operationType,\n          operationTypeName,\n          operationName: options.name,\n          variables: (options.variables ?? {}) as TVarDefinitions,\n          fieldsFactory: options.fields,\n          adapter: resolvedAdapter,\n          metadata: options.metadata,\n          transformDocument: options.transformDocument,\n          adapterTransformDocument: transformDocument,\n        })) as DefineResult);\n    };\n  };\n};\n","/**\n * Utilities for extracting values and paths from VarRefs.\n *\n * Provides type-safe access to nested values within VarRefs,\n * supporting both variable references and literal values.\n *\n * @module\n */\n\nimport type { ConstValue } from \"../types/type-foundation/const-value\";\nimport {\n  type AnyVarRef,\n  type AnyVarRefBrand,\n  type NestedValueElement,\n  VarRef,\n  type VarRefInner,\n} from \"../types/type-foundation/var-ref\";\n\n/**\n * Recursively checks if a NestedValue contains any VarRef.\n *\n * Used by getVarRefValue to determine if it's safe to return as ConstValue.\n * @internal\n */\nexport const hasVarRefInside = (value: NestedValueElement): boolean => {\n  if (value instanceof VarRef) {\n    return true;\n  }\n\n  if (Array.isArray(value)) {\n    return value.some(hasVarRefInside);\n  }\n\n  if (typeof value === \"object\" && value !== null) {\n    return Object.values(value).some(hasVarRefInside);\n  }\n\n  return false;\n};\n\n/**\n * Get the variable name from a VarRef.\n * Throws if the VarRef contains a nested-value instead of a variable reference.\n */\nexport const getVarRefName = (varRef: AnyVarRef): string => {\n  const inner = VarRef.getInner(varRef);\n  if (inner.type !== \"variable\") {\n    throw new Error(\"Expected variable reference, got nested-value\");\n  }\n  return inner.name;\n};\n\n/**\n * Get the const value from a VarRef.\n * Throws if the VarRef contains a variable reference instead of a nested-value,\n * or if the nested-value contains any VarRef inside.\n */\nexport const getVarRefValue = (varRef: AnyVarRef): ConstValue => {\n  const inner = VarRef.getInner(varRef);\n  if (inner.type !== \"nested-value\") {\n    throw new Error(\"Expected nested-value, got variable reference\");\n  }\n  if (hasVarRefInside(inner.value)) {\n    throw new Error(\"Cannot get const value: nested-value contains VarRef\");\n  }\n  return inner.value as ConstValue;\n};\n\n// ============================================================================\n// Path Types and Utilities\n// ============================================================================\n/**\n * Path segment types for navigating nested values.\n */\nexport type PathSegment = string;\n\n// biome-ignore lint/suspicious/noExplicitAny: abstract type\ntype AnySelectableProxy = SelectableProxy<any>;\n/**\n * Proxy type that records property accesses.\n */\nexport type SelectableProxy<T> = T;\n\n/**\n * Type-safe path builder function.\n * Used with getNameAt and getValueAt helpers.\n */\nexport type Selector<T, U> = (proxy: T) => U;\ntype ProxyInner = {\n  readonly varInner: VarRefInner | { type: \"virtual\"; varName: string; varSegments: readonly PathSegment[] };\n  readonly segments: readonly PathSegment[];\n};\nconst SelectableProxyInnerRegistry = new WeakMap<AnySelectableProxy, ProxyInner>();\nconst getSelectableProxyInner = (proxy: AnySelectableProxy): ProxyInner => {\n  const inner = SelectableProxyInnerRegistry.get(proxy);\n  if (!inner) {\n    throw new Error(`Proxy inner not found`);\n  }\n  return inner;\n};\nconst createSelectableProxy = <T>(current: ProxyInner): T => {\n  const proxy: T = new Proxy(Object.create(null), {\n    get(_, property) {\n      if (typeof property === \"symbol\") {\n        throw new Error(`Prohibited property access: ${String(property)}`);\n      }\n      const nextSegments = [...current.segments, property];\n\n      if (current.varInner.type === \"virtual\") {\n        return createSelectableProxy({\n          varInner: current.varInner,\n          segments: nextSegments,\n        });\n      }\n\n      if (current.varInner.type === \"variable\") {\n        return createSelectableProxy({\n          varInner: { type: \"virtual\", varName: current.varInner.name, varSegments: nextSegments },\n          segments: nextSegments,\n        });\n      }\n\n      if (typeof current.varInner.value === \"object\" && current.varInner.value !== null) {\n        const value = (current.varInner.value as { [key: string]: NestedValueElement })[property];\n        return createSelectableProxy({\n          varInner: value instanceof VarRef ? VarRef.getInner(value) : { type: \"nested-value\", value },\n          segments: nextSegments,\n        });\n      }\n\n      throw new Error(`Cannot access children of primitive value at path [${current.segments.join(\".\")}]`);\n    },\n  });\n\n  SelectableProxyInnerRegistry.set(proxy, current);\n\n  return proxy;\n};\n\n/**\n * Get the variable name from a VarRef at a specific path.\n *\n * @param varRef - The VarRef containing a nested-value\n * @param selector - Path builder function, e.g., p => p.user.age\n * @returns The variable name at the specified path\n * @throws If path doesn't lead to a VarRef with type \"variable\"\n *\n * @example\n * const ref = createVarRefFromNestedValue({\n *   user: { age: someVariableRef }\n * });\n * getNameAt(ref, p => p.user.age); // returns the variable name\n */\nexport const getNameAt = <T, U>(varRef: VarRef<AnyVarRefBrand>, selector: (proxy: T) => U): string => {\n  const proxy = createSelectableProxy<T>({ varInner: VarRef.getInner(varRef), segments: [] });\n  const selected = selector(proxy);\n  const inner = getSelectableProxyInner(selected);\n\n  if (inner.varInner.type === \"virtual\") {\n    throw new Error(`Value at path [${inner.segments.join(\".\")}] is inside a variable`);\n  }\n\n  if (inner.varInner.type !== \"variable\") {\n    throw new Error(`Value at path [${inner.segments.join(\".\")}] is not a variable`);\n  }\n\n  return inner.varInner.name;\n};\n\n/**\n * Get the const value from a nested-value VarRef at a specific path.\n *\n * @param varRef - The VarRef containing a nested-value\n * @param pathFn - Path builder function, e.g., p => p.user.name\n * @returns The const value at the specified path\n * @throws If path leads to a VarRef or if value contains VarRef inside\n *\n * @example\n * const ref = createVarRefFromNestedValue({\n *   user: { name: \"Alice\", age: someVariableRef }\n * });\n * getValueAt(ref, p => p.user.name); // returns \"Alice\"\n */\nexport const getValueAt = <T, U>(varRef: VarRef<AnyVarRefBrand>, selector: (proxy: SelectableProxy<T>) => U): U => {\n  const proxy = createSelectableProxy<T>({ varInner: VarRef.getInner(varRef), segments: [] });\n  const selected = selector(proxy);\n  const inner = getSelectableProxyInner(selected);\n\n  if (inner.varInner.type === \"virtual\") {\n    throw new Error(`Value at path [${inner.segments.join(\".\")}] is inside a variable`);\n  }\n\n  if (inner.varInner.type !== \"nested-value\") {\n    throw new Error(`Value at path [${inner.segments.join(\".\")}] is not a nested-value`);\n  }\n\n  if (hasVarRefInside(inner.varInner.value)) {\n    throw new Error(`Value at path [${inner.segments.join(\".\")}] contains nested VarRef`);\n  }\n\n  return inner.varInner.value as U;\n};\n\n/**\n * Gets the full path to a variable within a nested structure.\n *\n * Returns path segments starting with `$variableName` followed by\n * property accesses within that variable's value.\n *\n * @example\n * ```typescript\n * getVariablePath($.filter, p => p.user.id)\n * // Returns: [\"$filter\", \"user\", \"id\"]\n * ```\n */\nexport const getVariablePath = <T, U>(\n  varRef: VarRef<AnyVarRefBrand>,\n  selector: (proxy: SelectableProxy<T>) => U,\n): readonly PathSegment[] => {\n  const proxy = createSelectableProxy<T>({ varInner: VarRef.getInner(varRef), segments: [] });\n  const selected = selector(proxy);\n  const inner = getSelectableProxyInner(selected);\n\n  if (inner.varInner.type === \"virtual\") {\n    return [`$${inner.varInner.varName}`, ...inner.segments.slice(inner.varInner.varSegments.length)];\n  }\n\n  if (inner.varInner.type === \"variable\") {\n    return [`$${inner.varInner.name}`];\n  }\n\n  throw new Error(`Value at path [${inner.segments.join(\".\")}] is not a variable or inside a variable`);\n};\n","/**\n * Variable builder utilities for defining operation variables.\n *\n * Provides type-safe methods for creating variable definitions with\n * proper type inference for all input types in the schema.\n *\n * @module\n */\n\nimport type {\n  AllInputTypeNames,\n  AnyConstDirectiveAttachments,\n  AnyGraphqlSchema,\n  ConstAssignableInputValue,\n  InferInputKind,\n  ResolveInputProfileFromMeta,\n} from \"../types/schema\";\nimport type { InputTypeKind, TypeModifier, TypeProfile } from \"../types/type-foundation\";\nimport type { AnyVarRefBrand, VarRef } from \"../types/type-foundation/var-ref\";\nimport { wrapByKey } from \"../utils/wrap-by-key\";\nimport type { SelectableProxy } from \"./var-ref-tools\";\nimport { getNameAt, getValueAt, getVariablePath, getVarRefName, getVarRefValue } from \"./var-ref-tools\";\n\n/**\n * Type for the default value function for a variable.\n */\ntype AssignableDefaultValue<\n  TSchema extends AnyGraphqlSchema,\n  TKind extends InputTypeKind,\n  TName extends string,\n  TModifier extends TypeModifier,\n> = ConstAssignableInputValue<\n  TSchema,\n  {\n    scalar: { kind: \"scalar\"; name: TName; modifier: TModifier; directives: {}; defaultValue: null };\n    enum: { kind: \"enum\"; name: TName; modifier: TModifier; directives: {}; defaultValue: null };\n    input: { kind: \"input\"; name: TName; modifier: TModifier; directives: {}; defaultValue: null };\n  }[TKind]\n>;\n\n/**\n * Represents a variable definition with its type, modifier, and optional default.\n *\n * Created by `$var.TypeName(\"modifier\", { default?: ... })` calls.\n */\nexport type VarSpecifier<\n  TKind extends InputTypeKind,\n  TTypeName extends string,\n  TModifier extends TypeModifier,\n  TDefaultFn extends (() => unknown) | null,\n  TDirectives extends AnyConstDirectiveAttachments,\n> = {\n  kind: TKind;\n  name: TTypeName;\n  modifier: TModifier;\n  defaultValue: TDefaultFn extends null\n    ? null\n    : {\n        default: ReturnType<NonNullable<TDefaultFn>>;\n      };\n  directives: TDirectives;\n};\n\n/**\n * Creates a variable method for a specific input type.\n * This is used by codegen to generate type-specific variable methods.\n *\n * @deprecated Use createVarMethodFactory instead for proper type inference with nested input objects.\n */\nexport const createVarMethod = <TKind extends InputTypeKind, TTypeName extends string>(kind: TKind, typeName: TTypeName) => {\n  return <\n    TSchema extends AnyGraphqlSchema,\n    const TModifier extends TypeModifier,\n    const TDefaultFn extends (() => AssignableDefaultValue<TSchema, TKind, TTypeName, TModifier>) | null = null,\n    const TDirectives extends AnyConstDirectiveAttachments = {},\n  >(\n    modifier: TModifier,\n    extras?: {\n      default?: TDefaultFn & (() => AssignableDefaultValue<TSchema, TKind, TTypeName, TModifier>);\n      directives?: TDirectives;\n    },\n  ): VarSpecifier<TKind, TTypeName, TModifier, TDefaultFn, TDirectives> =>\n    ({\n      kind,\n      name: typeName,\n      modifier,\n      defaultValue: extras?.default ? { default: extras.default() } : null,\n      directives: extras?.directives ?? {},\n    }) as VarSpecifier<TKind, TTypeName, TModifier, TDefaultFn, TDirectives>;\n};\n\n/**\n * Creates a factory function for generating schema-scoped variable methods.\n * This ensures proper type inference for nested input objects by binding the schema type upfront.\n *\n * @example\n * ```typescript\n * const createMethod = createVarMethodFactory<typeof schema>();\n * const inputTypeMethods = {\n *   Boolean: createMethod(\"scalar\", \"Boolean\"),\n *   user_bool_exp: createMethod(\"input\", \"user_bool_exp\"),\n * } satisfies InputTypeMethods<typeof schema>;\n * ```\n */\nexport const createVarMethodFactory = <TSchema extends AnyGraphqlSchema>() => {\n  return <TKind extends InputTypeKind, TTypeName extends AllInputTypeNames<TSchema>>(\n    kind: TKind,\n    typeName: TTypeName,\n  ): InputTypeMethod<TSchema, TKind, TTypeName> => {\n    return ((modifier, extras) => ({\n      kind,\n      name: typeName,\n      modifier,\n      defaultValue: extras?.default ? { default: extras.default() } : null,\n      directives: extras?.directives ?? {},\n    })) as InputTypeMethod<TSchema, TKind, TTypeName>;\n  };\n};\n\n/**\n * Type for a single input type method.\n */\nexport type InputTypeMethod<TSchema extends AnyGraphqlSchema, TKind extends InputTypeKind, TTypeName extends string> = <\n  const TModifier extends TypeModifier,\n  const TDefaultFn extends (() => AssignableDefaultValue<TSchema, TKind, TTypeName, TModifier>) | null = null,\n  const TDirectives extends AnyConstDirectiveAttachments = {},\n>(\n  modifier: TModifier,\n  extras?: {\n    default?: TDefaultFn & (() => AssignableDefaultValue<TSchema, TKind, TTypeName, TModifier>);\n    directives?: TDirectives;\n  },\n) => VarSpecifier<TKind, TTypeName, TModifier, TDefaultFn, TDirectives>;\n\n/**\n * Type for all input type methods in a schema.\n */\nexport type InputTypeMethods<TSchema extends AnyGraphqlSchema> = {\n  [TName in AllInputTypeNames<TSchema>]: InputTypeMethod<TSchema, InferInputKind<TSchema, TName>, TName>;\n};\n\n/**\n * Type for a wrapped variable method that includes the variable name in the result.\n */\ntype WrappedVarMethod<\n  TVarName extends string,\n  TSchema extends AnyGraphqlSchema,\n  TKind extends InputTypeKind,\n  TTypeName extends string,\n> = <\n  const TModifier extends TypeModifier,\n  const TDefaultFn extends (() => AssignableDefaultValue<TSchema, TKind, TTypeName, TModifier>) | null = null,\n  const TDirectives extends AnyConstDirectiveAttachments = {},\n>(\n  modifier: TModifier,\n  extras?: {\n    default?: TDefaultFn & (() => AssignableDefaultValue<TSchema, TKind, TTypeName, TModifier>);\n    directives?: TDirectives;\n  },\n) => { [K in TVarName]: VarSpecifier<TKind, TTypeName, TModifier, TDefaultFn, TDirectives> };\n\n/**\n * Type for the variable builder methods for a specific variable name.\n */\nexport type VarBuilderMethods<TVarName extends string, TSchema extends AnyGraphqlSchema> = {\n  [TName in AllInputTypeNames<TSchema>]: WrappedVarMethod<TVarName, TSchema, InferInputKind<TSchema, TName>, TName>;\n};\n\n/**\n * Variable builder function type.\n *\n * Call with a variable name to get type-specific methods.\n * Also provides utilities for extracting values from VarRefs.\n *\n * @example\n * ```typescript\n * // In operation definition:\n * variables: { userId: $var(\"userId\").ID(\"!\") }\n *\n * // In metadata builder:\n * $var.getValueAt($.userId, p => p)\n * ```\n */\nexport type VarBuilder<TSchema extends AnyGraphqlSchema> = {\n  <TVarName extends string>(varName: TVarName): VarBuilderMethods<TVarName, TSchema>;\n  getName: typeof getVarRefName;\n  getValue: typeof getVarRefValue;\n  getNameAt: SchemaAwareGetNameAt<TSchema>;\n  getValueAt: SchemaAwareGetValueAt<TSchema>;\n  getVariablePath: typeof getVariablePath;\n};\n\n// ============================================================================\n// Schema-aware Type Resolution for VarRef Meta\n// ============================================================================\n\n/**\n * Resolves the TypeScript type from VarRef meta using schema.\n * This is used for getValueAt/getNameAt with type structure resolution.\n */\nexport type ResolveTypeFromMeta<TSchema extends AnyGraphqlSchema, TMeta extends AnyVarRefBrand> = TypeProfile.Type<\n  ResolveInputProfileFromMeta<TSchema, TMeta[\"typeName\"], TMeta[\"kind\"], \"!\">\n>;\n\n/**\n * Schema-aware getValueAt type.\n * Resolves type structure from schema using typeName + kind.\n */\nexport type SchemaAwareGetValueAt<TSchema extends AnyGraphqlSchema> = <T extends AnyVarRefBrand, U>(\n  varRef: VarRef<T>,\n  selector: (proxy: SelectableProxy<ResolveTypeFromMeta<TSchema, T>>) => U,\n) => U;\n\n/**\n * Schema-aware getNameAt type.\n * Resolves type structure from schema using typeName + kind.\n */\nexport type SchemaAwareGetNameAt<TSchema extends AnyGraphqlSchema> = <T extends AnyVarRefBrand, U>(\n  varRef: VarRef<T>,\n  selector: (proxy: ResolveTypeFromMeta<TSchema, T>) => U,\n) => string;\n\n/**\n * Generic input type method that can be called with any modifier.\n */\ntype AnyInputTypeMethod = (\n  modifier: TypeModifier,\n  extras?: { default?: () => unknown; directives?: AnyConstDirectiveAttachments },\n) => unknown;\n\n/**\n * Creates a variable builder using injected input type methods.\n *\n * The returned builder provides type-safe variable definition methods\n * for all input types in the schema. Also includes utilities for\n * extracting variable names and values from VarRefs.\n *\n * @param inputTypeMethods - Methods for each input type (from codegen)\n * @returns Variable builder with methods for all input types\n *\n * @internal Used by `createGqlElementComposer`\n */\nexport const createVarBuilder = <TSchema extends AnyGraphqlSchema>(\n  inputTypeMethods: InputTypeMethods<TSchema>,\n): VarBuilder<TSchema> => {\n  const varBuilder = <TVarName extends string>(varName: TVarName): VarBuilderMethods<TVarName, TSchema> => {\n    const wrappedMethods = {} as VarBuilderMethods<TVarName, TSchema>;\n\n    for (const [typeName, method] of Object.entries(inputTypeMethods) as [string, AnyInputTypeMethod][]) {\n      Object.defineProperty(wrappedMethods, typeName, {\n        value: ((modifier, extras) => wrapByKey(varName, method(modifier, extras))) satisfies AnyInputTypeMethod,\n        writable: false,\n        configurable: true,\n      });\n    }\n\n    return wrappedMethods;\n  };\n\n  varBuilder.getName = getVarRefName;\n  varBuilder.getValue = getVarRefValue;\n  varBuilder.getNameAt = getNameAt;\n  varBuilder.getValueAt = getValueAt;\n  varBuilder.getVariablePath = getVariablePath;\n\n  return varBuilder as VarBuilder<TSchema>;\n};\n","/**\n * Main entry point for composing GraphQL elements.\n * @module\n */\n\nimport type { AnyFragment, AnyGqlDefine, AnyOperation } from \"../types/element\";\nimport { GqlDefine } from \"../types/element\";\nimport type { Adapter, AnyAdapter, AnyMetadataAdapter, DefaultAdapter, DefaultMetadataAdapter } from \"../types/metadata\";\nimport type { AnyGraphqlSchema } from \"../types/schema\";\nimport { createColocateHelper } from \"./colocate\";\nimport { createCompatComposer } from \"./compat\";\nimport { applyContextTransformer } from \"./context-transformer\";\nimport { createStandardDirectives, type StandardDirectives } from \"./directive-builder\";\nimport { createExtendComposer } from \"./extend\";\nimport { createGqlFragmentComposers, type FragmentBuilderFor } from \"./fragment\";\nimport { createOperationComposerFactory } from \"./operation\";\nimport { createVarBuilder, type InputTypeMethods } from \"./var-builder\";\n\n/**\n * Function signature for composing GraphQL elements (fragments or operations).\n *\n * The composer provides a context with builders for fragments, operations,\n * variables, and colocation helpers.\n */\nexport type GqlElementComposer<TContext> = <TResult extends AnyFragment | AnyOperation | AnyGqlDefine>(\n  composeElement: (context: TContext) => TResult,\n) => TResult;\n\n/**\n * GQL element composer with schema access.\n *\n * Extends the base composer function with a `$schema` property that provides\n * runtime access to the schema definition. This is useful for:\n * - Type generation tools (typegen)\n * - Runtime schema introspection\n * - Debugging and tooling\n */\nexport type GqlElementComposerWithSchema<TContext, TSchema extends AnyGraphqlSchema> = GqlElementComposer<TContext> & {\n  /**\n   * The GraphQL schema definition used by this composer.\n   * Provides runtime access to schema types, operations, and metadata.\n   */\n  readonly $schema: TSchema;\n};\n\n/**\n * Extracts the helpers type from an adapter.\n * Uses `any` for non-target type parameters to avoid contravariance issues\n * with the `aggregateFragmentMetadata` function parameter type.\n */\n// biome-ignore lint/suspicious/noExplicitAny: Required to avoid contravariance issues in conditional type matching\ntype ExtractHelpers<TAdapter extends AnyAdapter> = TAdapter extends Adapter<infer THelpers, any, any, any> ? THelpers : object;\n\n/**\n * Extracts the metadata adapter type from an adapter.\n * Handles optional metadata property correctly.\n */\nexport type ExtractMetadataAdapter<TAdapter extends AnyAdapter> = TAdapter extends { metadata?: infer M }\n  ? NonNullable<M> extends AnyMetadataAdapter\n    ? NonNullable<M>\n    : DefaultMetadataAdapter\n  : DefaultMetadataAdapter;\n\n/**\n * Default fragment builders type computed from schema.\n * This is the mapped type that's expensive to compute for large schemas.\n */\nexport type FragmentBuildersAll<\n  TSchema extends AnyGraphqlSchema,\n  TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter,\n> = {\n  readonly [TTypeName in keyof TSchema[\"object\"]]: TTypeName extends string\n    ? FragmentBuilderFor<TSchema, TTypeName, TAdapter>\n    : never;\n};\n\n/**\n * Configuration options for `createGqlElementComposer`.\n */\nexport type GqlElementComposerOptions<\n  TSchema extends AnyGraphqlSchema,\n  TDirectiveMethods extends StandardDirectives,\n  TAdapter extends AnyAdapter = DefaultAdapter,\n> = {\n  /** Optional adapter for custom helpers and metadata handling. */\n  adapter?: TAdapter;\n  /** Methods for building variable type specifiers. */\n  inputTypeMethods: InputTypeMethods<TSchema>;\n  /** Optional custom directive methods (including schema-defined directives). */\n  directiveMethods?: TDirectiveMethods;\n};\n\n/**\n * Creates a GQL element composer for a given schema.\n *\n * This is the main entry point for defining GraphQL operations and fragments.\n * The returned function provides a context with:\n * - `fragment`: Builders for each object type\n * - `query/mutation/subscription`: Operation builders\n * - `$var`: Variable definition helpers\n * - `$dir`: Field directive helpers (@skip, @include)\n * - `$colocate`: Fragment colocation utilities\n *\n * @param schema - The GraphQL schema definition\n * @param options - Configuration including input type methods and optional adapter\n * @returns Element composer function\n *\n * @example\n * ```typescript\n * const gql = createGqlElementComposer(schema, { inputTypeMethods });\n *\n * const GetUser = gql(({ query, $var, $dir }) =>\n *   query.operation({\n *     name: \"GetUser\",\n *     variables: { showEmail: $var(\"showEmail\").Boolean(\"!\") },\n *     fields: ({ f, $ }) => ({\n *       ...f.user({ id: \"1\" })(({ f }) => ({\n *         ...f.name(),\n *         ...f.email({}, { directives: [$dir.skip({ if: $.showEmail })] }),\n *       })),\n *     }),\n *   })\n * );\n * ```\n */\nexport const createGqlElementComposer = <\n  TSchema extends AnyGraphqlSchema,\n  TFragmentBuilders,\n  TDirectiveMethods extends StandardDirectives,\n  TAdapter extends AnyAdapter = DefaultAdapter,\n>(\n  schema: NoInfer<TSchema>,\n  options: GqlElementComposerOptions<NoInfer<TSchema>, NoInfer<TDirectiveMethods>, NoInfer<TAdapter>>,\n) => {\n  type THelpers = ExtractHelpers<TAdapter>;\n  type TMetadataAdapter = ExtractMetadataAdapter<TAdapter>;\n  const { adapter, inputTypeMethods, directiveMethods } = options;\n  const helpers = adapter?.helpers as THelpers | undefined;\n  const metadataAdapter = adapter?.metadata as TMetadataAdapter | undefined;\n  const transformDocument = adapter?.transformDocument;\n  const fragment = createGqlFragmentComposers<TSchema, TMetadataAdapter>(schema, metadataAdapter) as TFragmentBuilders;\n  const createOperationComposer = createOperationComposerFactory<TSchema, TMetadataAdapter>(\n    schema,\n    metadataAdapter,\n    transformDocument,\n  );\n\n  // Wrap operation composers in objects with an `operation` method for extensibility\n  // This allows adding more factories (e.g., query.compat, mutation.compat) in the future\n  const context = {\n    fragment,\n    query: {\n      operation: createOperationComposer(\"query\"),\n      compat: createCompatComposer<TSchema, \"query\">(schema, \"query\"),\n    },\n    mutation: {\n      operation: createOperationComposer(\"mutation\"),\n      compat: createCompatComposer<TSchema, \"mutation\">(schema, \"mutation\"),\n    },\n    subscription: {\n      operation: createOperationComposer(\"subscription\"),\n      compat: createCompatComposer<TSchema, \"subscription\">(schema, \"subscription\"),\n    },\n    define: <TValue>(factory: () => TValue | Promise<TValue>) => GqlDefine.create(factory),\n    extend: createExtendComposer<TSchema, TMetadataAdapter>(schema, metadataAdapter, transformDocument),\n    $var: createVarBuilder<TSchema>(inputTypeMethods),\n    $dir: directiveMethods ?? (createStandardDirectives() as TDirectiveMethods),\n    $colocate: createColocateHelper(),\n    ...(helpers ?? ({} as THelpers)),\n  };\n\n  // Apply context transformer if set (for programmatic API like @soda-gql/sdk)\n  const transformedContext = applyContextTransformer(context);\n\n  const elementComposer: GqlElementComposer<typeof context> = (composeElement) => composeElement(transformedContext);\n\n  // Attach schema as readonly property for runtime access\n  const composerWithSchema = elementComposer as GqlElementComposerWithSchema<typeof context, TSchema>;\n  Object.defineProperty(composerWithSchema, \"$schema\", {\n    value: schema,\n    writable: false,\n    enumerable: true,\n    configurable: false,\n  });\n\n  return composerWithSchema;\n};\n\n/**\n * Abstract Context type for prebuilt composers.\n *\n * Provides minimal structure while allowing PrebuiltTypeRegistry to resolve\n * actual types. Used by prebuilt module to avoid heavy schema type inference.\n *\n * Type safety in prebuilt comes from `ResolvePrebuiltElement`, not from\n * the Context type.\n */\nexport type AnyGqlContext = {\n  readonly fragment: Record<string, unknown>;\n  readonly query: { operation: (...args: unknown[]) => AnyOperation; compat: (...args: unknown[]) => AnyGqlDefine };\n  readonly mutation: { operation: (...args: unknown[]) => AnyOperation; compat: (...args: unknown[]) => AnyGqlDefine };\n  readonly subscription: { operation: (...args: unknown[]) => AnyOperation; compat: (...args: unknown[]) => AnyGqlDefine };\n  readonly define: <TValue>(factory: () => TValue | Promise<TValue>) => GqlDefine<TValue>;\n  readonly extend: (...args: unknown[]) => AnyOperation;\n  readonly $var: unknown;\n  readonly $dir: StandardDirectives;\n  readonly $colocate: unknown;\n  readonly [key: string]: unknown;\n};\n","/**\n * Type calculator for generating TypeScript type strings from field selections.\n *\n * This is a runtime reimplementation of the InferFields type-level computation,\n * used for generating prebuilt types that can be bundled without losing type information.\n *\n * @module\n */\n\nimport { Kind, type TypeNode, type VariableDefinitionNode } from \"graphql\";\nimport type { AnyFieldSelection, AnyFields, AnyNestedObject, AnyNestedUnion } from \"../types/fragment\";\nimport type { AnyGraphqlSchema } from \"../types/schema\";\nimport type { InputDepthOverrides, InputTypeSpecifier, InputTypeSpecifiers, TypeModifier } from \"../types/type-foundation\";\n\n/**\n * Formatters for customizing type name output.\n *\n * Used by type generation functions to format scalar and input object type names\n * with custom prefixes or patterns (e.g., schema-specific prefixes).\n */\nexport type TypeFormatters = {\n  /**\n   * Format a scalar input type name.\n   * Default: `ScalarInput<\"Name\">`\n   */\n  readonly scalarInput?: (name: string) => string;\n  /**\n   * Format a scalar output type name.\n   * Default: `ScalarOutput<\"Name\">`\n   */\n  readonly scalarOutput?: (name: string) => string;\n  /**\n   * Format an input object type name.\n   * Default: returns the name unchanged\n   */\n  readonly inputObject?: (name: string) => string;\n};\n\n/**\n * Apply a type modifier to a base type string.\n *\n * Modifier format:\n * - \"!\" = required (T)\n * - \"?\" = optional (T | null | undefined)\n * - \"![]!\" = required array of required items (T[])\n * - \"![]?\" = optional array of required items (T[] | null | undefined)\n * - \"?[]!\" = required array of optional items ((T | null | undefined)[])\n * - \"?[]?\" = optional array of optional items ((T | null | undefined)[] | null | undefined)\n * - Deeper nesting follows the same pattern\n */\nexport const applyTypeModifier = (baseType: string, modifier: TypeModifier): string => {\n  // Parse modifier from inside out\n  // Modifier format: innerNullability[]outerNullability[]...\n  // e.g., \"?[]!\" means: inner is nullable, wrapped in non-null array\n\n  if (modifier === \"!\") {\n    return baseType;\n  }\n  if (modifier === \"?\") {\n    return `(${baseType} | null | undefined)`;\n  }\n\n  // For array types, parse the modifier pattern\n  // Pattern: (innerNullability)([]outerNullability)*\n  const parts = modifier.split(\"[]\");\n  if (parts.length < 2) {\n    // Fallback for unexpected modifier format\n    return baseType;\n  }\n\n  // Build type from inside out\n  let result = baseType;\n\n  // First part is the innermost nullability\n  const innerNullability = parts[0];\n  if (innerNullability === \"?\") {\n    result = `(${result} | null | undefined)`;\n  }\n\n  // Remaining parts are array wrappings with their nullability\n  for (let i = 1; i < parts.length; i++) {\n    const arrayNullability = parts[i];\n    result = `(${result})[]`;\n    if (arrayNullability === \"?\") {\n      result = `(${result} | null | undefined)`;\n    }\n  }\n\n  return result;\n};\n\n/**\n * Get the TypeScript type string for a scalar output type from the schema.\n *\n * Returns a `ScalarOutput<\"Name\">` reference for all scalars in the schema.\n * The actual type is resolved at compile time from the inject file's scalar definitions.\n * This allows users to customize even built-in scalars (ID, String, etc.).\n */\nexport const getScalarOutputType = (schema: AnyGraphqlSchema, scalarName: string): string => {\n  // ALL scalars use ScalarOutput reference - inject file is the source of truth\n  if (schema.scalar[scalarName]) {\n    return `ScalarOutput<\"${scalarName}\">`;\n  }\n  // Unknown scalar not in schema\n  return \"unknown\";\n};\n\n/**\n * Get the TypeScript type string for a scalar input type from the schema.\n *\n * Returns a `ScalarInput<\"Name\">` reference for all scalars in the schema.\n * Used for input/variable types in operations.\n */\nexport const getScalarInputType = (schema: AnyGraphqlSchema, scalarName: string): string => {\n  if (schema.scalar[scalarName]) {\n    return `ScalarInput<\"${scalarName}\">`;\n  }\n  return \"unknown\";\n};\n\n/**\n * Get the TypeScript type string for an enum type from the schema.\n */\nexport const getEnumType = (schema: AnyGraphqlSchema, enumName: string): string => {\n  const enumDef = schema.enum[enumName];\n  if (!enumDef) {\n    return \"string\";\n  }\n\n  // Get enum values and create a union type\n  const values = Object.keys(enumDef.values);\n  if (values.length === 0) {\n    return \"never\";\n  }\n\n  return values.map((v) => `\"${v}\"`).join(\" | \");\n};\n\n/**\n * Default depth limit for input object type generation.\n */\nconst DEFAULT_INPUT_DEPTH = 3;\n\n/**\n * Options for generating input object types.\n */\nexport type GenerateInputObjectTypeOptions = {\n  /**\n   * Default depth limit for recursive types.\n   * @default 3\n   */\n  readonly defaultDepth?: number;\n  /**\n   * Per-type depth overrides.\n   */\n  readonly depthOverrides?: InputDepthOverrides;\n  /**\n   * Custom formatters for type names.\n   */\n  readonly formatters?: TypeFormatters;\n};\n\n/**\n * Generate a TypeScript type string for an input object type.\n *\n * Recursively expands fields using ScalarInput for scalars.\n * Returns `unknown` if depth is exhausted or circular reference is detected.\n *\n * @param schema - The GraphQL schema\n * @param inputName - The input object type name\n * @param options - Generation options including depth limits\n * @param seen - Set of already visited input names (for circular reference detection)\n * @param currentDepth - Current recursion depth\n */\nexport const generateInputObjectType = (\n  schema: AnyGraphqlSchema,\n  inputName: string,\n  options: GenerateInputObjectTypeOptions = {},\n  seen: Set<string> = new Set(),\n  currentDepth?: number,\n): string => {\n  const inputDef = schema.input[inputName];\n  if (!inputDef) {\n    return \"unknown\";\n  }\n\n  // Get depth limit for this type\n  const depthOverrides = options.depthOverrides ?? {};\n  const defaultDepth = options.defaultDepth ?? DEFAULT_INPUT_DEPTH;\n  const maxDepth = depthOverrides[inputName] ?? defaultDepth;\n\n  // Initialize or use current depth\n  const depth = currentDepth ?? maxDepth;\n\n  // Check depth exhaustion\n  if (depth <= 0) {\n    return \"unknown\";\n  }\n\n  // Check circular reference\n  if (seen.has(inputName)) {\n    return \"unknown\";\n  }\n\n  // Add to seen set for this branch\n  const newSeen = new Set(seen);\n  newSeen.add(inputName);\n\n  const fields = inputDef.fields;\n  const fieldEntries = Object.entries(fields);\n\n  if (fieldEntries.length === 0) {\n    return \"{}\";\n  }\n\n  const fieldTypes = fieldEntries.map(([fieldName, specifier]) => {\n    const fieldType = generateInputFieldType(schema, specifier, options, newSeen, depth - 1);\n    const isOptional = specifier.modifier === \"?\" || specifier.modifier.endsWith(\"?\");\n    const hasDefault = specifier.defaultValue != null;\n\n    // Fields with defaults or nullable fields are optional\n    if (hasDefault || isOptional) {\n      return `readonly ${fieldName}?: ${fieldType}`;\n    }\n    return `readonly ${fieldName}: ${fieldType}`;\n  });\n\n  return `{ ${fieldTypes.join(\"; \")} }`;\n};\n\n/**\n * Generate a TypeScript type string for an input field based on its specifier.\n */\nconst generateInputFieldType = (\n  schema: AnyGraphqlSchema,\n  specifier: { readonly kind: string; readonly name: string; readonly modifier: TypeModifier },\n  options: GenerateInputObjectTypeOptions,\n  seen: Set<string>,\n  depth: number,\n): string => {\n  let baseType: string;\n  const { formatters } = options;\n\n  switch (specifier.kind) {\n    case \"scalar\":\n      baseType = formatters?.scalarInput?.(specifier.name) ?? getScalarInputType(schema, specifier.name);\n      break;\n    case \"enum\":\n      baseType = getEnumType(schema, specifier.name);\n      break;\n    case \"input\":\n      baseType =\n        formatters?.inputObject?.(specifier.name) ?? generateInputObjectType(schema, specifier.name, options, seen, depth);\n      break;\n    default:\n      baseType = \"unknown\";\n  }\n\n  return applyTypeModifier(baseType, specifier.modifier);\n};\n\n/**\n * Calculate the TypeScript type string for a single field selection.\n *\n * @param schema - The GraphQL schema\n * @param selection - The field selection to calculate type for\n * @param formatters - Optional formatters for customizing type names\n */\nexport const calculateFieldType = (\n  schema: AnyGraphqlSchema,\n  selection: AnyFieldSelection,\n  formatters?: TypeFormatters,\n): string => {\n  const { type } = selection;\n\n  // Handle object types (nested selection)\n  if (type.kind === \"object\" && selection.object) {\n    const nestedType = calculateFieldsType(schema, selection.object, formatters);\n    return applyTypeModifier(nestedType, type.modifier);\n  }\n\n  // Handle union types\n  if (type.kind === \"union\" && selection.union) {\n    const unionType = calculateUnionType(schema, selection.union, formatters);\n    return applyTypeModifier(unionType, type.modifier);\n  }\n\n  // Handle __typename special field\n  if (type.kind === \"typename\") {\n    // __typename returns a string literal type\n    return applyTypeModifier(`\"${type.name}\"`, type.modifier);\n  }\n\n  // Handle scalar types\n  if (type.kind === \"scalar\") {\n    const scalarType = formatters?.scalarOutput?.(type.name) ?? getScalarOutputType(schema, type.name);\n    return applyTypeModifier(scalarType, type.modifier);\n  }\n\n  // Handle enum types\n  if (type.kind === \"enum\") {\n    const enumType = getEnumType(schema, type.name);\n    return applyTypeModifier(enumType, type.modifier);\n  }\n\n  // Fallback\n  return \"unknown\";\n};\n\n/**\n * Calculate the TypeScript type string for a union type selection.\n */\nconst calculateUnionType = (schema: AnyGraphqlSchema, union: AnyNestedUnion, formatters?: TypeFormatters): string => {\n  const memberTypes: string[] = [];\n\n  for (const [_typeName, fields] of Object.entries(union)) {\n    if (fields) {\n      const memberType = calculateFieldsType(schema, fields, formatters);\n      memberTypes.push(memberType);\n    }\n  }\n\n  if (memberTypes.length === 0) {\n    return \"never\";\n  }\n\n  return memberTypes.join(\" | \");\n};\n\n/**\n * Calculate the TypeScript type string for a set of field selections.\n * This is the main entry point for type calculation.\n *\n * @param schema - The GraphQL schema\n * @param fields - The field selections to calculate types for\n * @param formatters - Optional formatters for customizing type names\n */\nexport const calculateFieldsType = (\n  schema: AnyGraphqlSchema,\n  fields: AnyFields | AnyNestedObject,\n  formatters?: TypeFormatters,\n): string => {\n  const entries = Object.entries(fields);\n\n  if (entries.length === 0) {\n    return \"{}\";\n  }\n\n  const fieldTypes = entries.map(([alias, selection]) => {\n    const fieldType = calculateFieldType(schema, selection, formatters);\n    // Use readonly for all fields to match InferFields behavior\n    return `readonly ${alias}: ${fieldType}`;\n  });\n\n  return `{ ${fieldTypes.join(\"; \")} }`;\n};\n\n/**\n * Convert a GraphQL TypeNode to a TypeScript type string for input types.\n *\n * Handles NonNullType, ListType, and NamedType recursively.\n * Uses ScalarInput for scalar types since this is used for input/variable types.\n *\n * @param schema - The GraphQL schema\n * @param typeNode - The GraphQL type node to convert\n * @param formatters - Optional formatters for customizing type names\n */\nexport const graphqlTypeToTypeScript = (schema: AnyGraphqlSchema, typeNode: TypeNode, formatters?: TypeFormatters): string => {\n  switch (typeNode.kind) {\n    case Kind.NON_NULL_TYPE:\n      return graphqlTypeToTypeScript(schema, typeNode.type, formatters);\n    case Kind.LIST_TYPE: {\n      const inner = graphqlTypeToTypeScript(schema, typeNode.type, formatters);\n      return `(${inner})[]`;\n    }\n    case Kind.NAMED_TYPE: {\n      const name = typeNode.name.value;\n      // Check if scalar - use ScalarInput for input types\n      if (schema.scalar[name]) {\n        return formatters?.scalarInput?.(name) ?? getScalarInputType(schema, name);\n      }\n      // Check if enum\n      if (schema.enum[name]) {\n        return getEnumType(schema, name);\n      }\n      // Input object - use formatter or return name directly\n      return formatters?.inputObject?.(name) ?? name;\n    }\n  }\n};\n\n/**\n * Generate a TypeScript type string for operation input variables.\n *\n * Extracts variable types from GraphQL VariableDefinitionNode AST.\n *\n * @param schema - The GraphQL schema\n * @param variableDefinitions - Variable definition nodes from the operation\n * @param formatters - Optional formatters for customizing type names\n */\nexport const generateInputType = (\n  schema: AnyGraphqlSchema,\n  variableDefinitions: readonly VariableDefinitionNode[],\n  formatters?: TypeFormatters,\n): string => {\n  if (variableDefinitions.length === 0) {\n    return \"{}\";\n  }\n\n  const fields = variableDefinitions.map((varDef) => {\n    const name = varDef.variable.name.value;\n    const isRequired = varDef.type.kind === Kind.NON_NULL_TYPE;\n    const tsType = graphqlTypeToTypeScript(schema, varDef.type, formatters);\n\n    // Apply nullability wrapper for optional fields\n    const finalType = isRequired ? tsType : `(${tsType} | null | undefined)`;\n    return `readonly ${name}${isRequired ? \"\" : \"?\"}: ${finalType}`;\n  });\n\n  return `{ ${fields.join(\"; \")} }`;\n};\n\n/**\n * Generate TypeScript type for a single input field from its specifier.\n * Used by generateInputTypeFromSpecifiers.\n */\nconst generateInputFieldTypeFromSpecifier = (\n  schema: AnyGraphqlSchema,\n  specifier: InputTypeSpecifier,\n  options: GenerateInputObjectTypeOptions,\n): string => {\n  let baseType: string;\n  const { formatters } = options;\n\n  switch (specifier.kind) {\n    case \"scalar\":\n      baseType = formatters?.scalarInput?.(specifier.name) ?? getScalarInputType(schema, specifier.name);\n      break;\n    case \"enum\":\n      baseType = getEnumType(schema, specifier.name);\n      break;\n    case \"input\":\n      baseType = formatters?.inputObject?.(specifier.name) ?? generateInputObjectType(schema, specifier.name, options);\n      break;\n    default:\n      baseType = \"unknown\";\n  }\n\n  return applyTypeModifier(baseType, specifier.modifier);\n};\n\n/**\n * Generate a TypeScript type string for input variables from InputTypeSpecifiers.\n *\n * Unlike generateInputType which works with GraphQL AST VariableDefinitionNode[],\n * this function works with soda-gql's internal InputTypeSpecifiers format.\n * Used for generating Fragment input types in prebuilt mode.\n *\n * @param schema - The GraphQL schema\n * @param specifiers - Input type specifiers (variable definitions)\n * @param options - Generation options including depth limits\n */\nexport const generateInputTypeFromSpecifiers = (\n  schema: AnyGraphqlSchema,\n  specifiers: InputTypeSpecifiers,\n  options: GenerateInputObjectTypeOptions = {},\n): string => {\n  const entries = Object.entries(specifiers);\n\n  if (entries.length === 0) {\n    return \"void\";\n  }\n\n  const fields = entries.map(([name, specifier]) => {\n    // Check if the outermost type is required\n    // \"!\" = required, \"?\" = optional\n    // \"![]!\" = required (outer), \"![]?\" = optional (outer)\n    // For arrays, check if the last character is \"!\" (required outer) or \"?\" (optional outer)\n    const isOuterRequired = specifier.modifier.endsWith(\"!\");\n    const hasDefault = specifier.defaultValue != null;\n    const baseType = generateInputFieldTypeFromSpecifier(schema, specifier, options);\n\n    // Field is optional if outer type is nullable or has default value\n    const isOptional = !isOuterRequired || hasDefault;\n\n    return `readonly ${name}${isOptional ? \"?\" : \"\"}: ${baseType}`;\n  });\n\n  return `{ ${fields.join(\"; \")} }`;\n};\n"],"mappings":"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"}
+{"version":3,"file":"index.cjs","names":["inner: VarRefInner","inner: DirectiveRefInner","Kind","fieldTypeSpecifier: InputTypeSpecifier | null","curr: Readonly<{ modifier: string; type: TypeNode }>","OperationTypeNode","cache: { value: T } | null","promise: Promise<void> | null","cache: object | null","lazyCreateEvaluationGenerator","lazyEvaluateSync","defaultMetadataAdapter: DefaultMetadataAdapter","fieldPathContext: { current: FieldPath | null }","newSegment: FieldPathSegment","cacheMap: CacheMap","factory: AnyFieldSelectionFactory","wrapByKey","fragmentUsageContext: { current: FragmentUsageRecord[] | null }","usages: FragmentUsageRecord[]","fragmentMetaInfos: FragmentMetaInfo<TFragmentMetadata>[]","fragmentMetadataResults: (TFragmentMetadata | undefined | Promise<TFragmentMetadata>)[]","aggregated","operationTypeName: TTypeName | null","proxy: T","wrapByKey","applyContextTransformer","elementComposer: GqlElementComposer<typeof context>","baseType: string","memberTypes: string[]","selection: AnyFieldSelection","Kind"],"sources":["../src/types/type-foundation/var-ref.ts","../src/types/type-foundation/directive-ref.ts","../src/composer/build-document.ts","../src/composer/colocate.ts","../src/utils/promise.ts","../src/types/element/lazy-evaluator.ts","../src/types/element/gql-element.ts","../src/types/element/define.ts","../src/types/element/fragment.ts","../src/types/element/operation.ts","../src/composer/compat.ts","../src/composer/directive-builder.ts","../src/types/metadata/adapter.ts","../src/utils/map-values.ts","../src/composer/field-path-context.ts","../src/composer/fields-builder.ts","../src/composer/fragment-usage-context.ts","../src/composer/input.ts","../src/composer/operation-core.ts","../src/composer/extend.ts","../src/composer/fragment.ts","../src/composer/operation.ts","../src/composer/var-ref-tools.ts","../src/composer/var-builder.ts","../src/composer/gql-composer.ts","../src/prebuilt/type-calculator.ts"],"sourcesContent":["import type { CreatableInputTypeKind } from \"./type-specifier\";\n\n/**\n * VarRef meta interface using typeName + kind instead of full profile.\n * This simplifies type comparison and improves error messages.\n * Uses CreatableInputTypeKind since VarRefs should never reference excluded types.\n */\nexport interface AnyVarRefBrand {\n  readonly typeName: string;\n  readonly kind: CreatableInputTypeKind;\n  readonly signature: unknown;\n}\n\n/**\n * A nested value that can contain:\n * - Primitive ConstValue (string, number, boolean, null, undefined)\n * - VarRef at any nesting level\n * - Objects with NestedValue fields\n * - Arrays of NestedValue\n */\nexport type NestedValue =\n  | string\n  | number\n  | boolean\n  | null\n  | undefined\n  | { readonly [key: string]: NestedValueElement }\n  | readonly NestedValueElement[];\n\nexport type NestedValueElement =\n  | string\n  | number\n  | boolean\n  | null\n  | undefined\n  | AnyVarRef\n  | { readonly [key: string]: NestedValueElement }\n  | readonly NestedValueElement[];\n\nexport type VarRefInner =\n  | {\n      type: \"variable\";\n      name: string;\n    }\n  | {\n      type: \"nested-value\";\n      value: NestedValue;\n    };\n\nexport type AnyVarRef = VarRef<any>;\n\ndeclare const __VAR_REF_BRAND__: unique symbol;\nexport class VarRef<TBrand extends AnyVarRefBrand> {\n  declare readonly [__VAR_REF_BRAND__]: TBrand;\n\n  constructor(private readonly inner: VarRefInner) {}\n\n  static getInner(varRef: AnyVarRef): VarRefInner {\n    return varRef.inner;\n  }\n}\n\n/**\n * Creates a VarRef from a variable name.\n * Returns AnyVarRef - type safety is enforced at assignment sites.\n */\nexport function createVarRefFromVariable(name: string): AnyVarRef {\n  return new VarRef({ type: \"variable\", name });\n}\n\n/**\n * Creates a VarRef from a nested value.\n * Returns AnyVarRef - type safety is enforced at assignment sites.\n */\nexport function createVarRefFromNestedValue(value: NestedValue): AnyVarRef {\n  return new VarRef({ type: \"nested-value\", value });\n}\n","/**\n * DirectiveRef type for representing field-level directives.\n *\n * Similar to VarRef, DirectiveRef uses a branded type pattern to carry\n * type information about the directive (name, locations, arguments) while\n * allowing relaxed type checking at the field builder level.\n *\n * @module\n */\n\n/**\n * Executable directive locations (used in operations/fragments).\n */\nexport type ExecutableDirectiveLocation =\n  | \"QUERY\"\n  | \"MUTATION\"\n  | \"SUBSCRIPTION\"\n  | \"FIELD\"\n  | \"FRAGMENT_DEFINITION\"\n  | \"FRAGMENT_SPREAD\"\n  | \"INLINE_FRAGMENT\"\n  | \"VARIABLE_DEFINITION\";\n\n/**\n * Type system directive locations (used in schema definitions).\n */\nexport type TypeSystemDirectiveLocation =\n  | \"SCHEMA\"\n  | \"SCALAR\"\n  | \"OBJECT\"\n  | \"FIELD_DEFINITION\"\n  | \"ARGUMENT_DEFINITION\"\n  | \"INTERFACE\"\n  | \"UNION\"\n  | \"ENUM\"\n  | \"ENUM_VALUE\"\n  | \"INPUT_OBJECT\"\n  | \"INPUT_FIELD_DEFINITION\";\n\n/**\n * All valid locations where a directive can be applied.\n * Matches GraphQL specification DirectiveLocation enum.\n */\nexport type DirectiveLocation = ExecutableDirectiveLocation | TypeSystemDirectiveLocation;\n\n/**\n * Brand interface for DirectiveRef type information.\n * Contains the directive name and valid locations.\n */\nexport interface AnyDirectiveRefBrand {\n  readonly directiveName: string;\n  readonly locations: readonly DirectiveLocation[];\n}\n\n/**\n * Type specifier for a directive argument.\n * Used to enable enum detection when building directive arguments.\n */\nexport type DirectiveArgumentSpecifier = {\n  readonly kind: \"scalar\" | \"enum\" | \"input\";\n  readonly name: string;\n  readonly modifier: string;\n};\n\n/**\n * Internal structure of a DirectiveRef.\n * Contains the directive name, arguments, valid locations, and optional argument specifiers.\n */\nexport type DirectiveRefInner = {\n  readonly name: string;\n  readonly arguments: Readonly<Record<string, unknown>>;\n  readonly locations: readonly DirectiveLocation[];\n  /**\n   * Type specifiers for arguments, enabling enum detection.\n   * Generated by codegen for typed directives.\n   */\n  readonly argumentSpecs?: Readonly<Record<string, DirectiveArgumentSpecifier>>;\n};\n\ndeclare const __DIRECTIVE_REF_BRAND__: unique symbol;\n\n/**\n * A reference to a directive that can be applied to fields.\n *\n * DirectiveRef carries type information about the directive via the TBrand\n * type parameter, but this information is only used for type inference,\n * not for runtime validation.\n *\n * @example\n * ```typescript\n * const skipDirective = new DirectiveRef({\n *   name: \"skip\",\n *   arguments: { if: true },\n *   locations: [\"FIELD\", \"FRAGMENT_SPREAD\", \"INLINE_FRAGMENT\"],\n * });\n * ```\n */\nexport class DirectiveRef<TBrand extends AnyDirectiveRefBrand> {\n  declare readonly [__DIRECTIVE_REF_BRAND__]: TBrand;\n\n  constructor(private readonly inner: DirectiveRefInner) {}\n\n  /**\n   * Extracts the inner structure from a DirectiveRef.\n   * Used by build-document.ts to generate DirectiveNode.\n   */\n  static getInner(ref: AnyDirectiveRef): DirectiveRefInner {\n    return ref.inner;\n  }\n}\n\n/**\n * Type-erased DirectiveRef for use in contexts where\n * the specific directive type is not needed.\n */\nexport type AnyDirectiveRef = DirectiveRef<AnyDirectiveRefBrand>;\n","/**\n * Builds GraphQL AST nodes from field selections.\n *\n * Converts the type-safe field selection DSL into GraphQL AST,\n * producing a TypedDocumentNode for use with GraphQL clients.\n *\n * @module\n */\n\nimport type { TypedDocumentNode } from \"@graphql-typed-document-node/core\";\nimport {\n  type ArgumentNode,\n  type ConstObjectFieldNode,\n  type ConstValueNode,\n  type DirectiveNode,\n  type DocumentNode,\n  type FieldNode,\n  type InlineFragmentNode,\n  Kind,\n  type NamedTypeNode,\n  type ObjectFieldNode,\n  OperationTypeNode,\n  type TypeNode,\n  type ValueNode,\n  type VariableDefinitionNode,\n} from \"graphql\";\nimport {\n  type AnyAssignableInput,\n  type AnyAssignableInputValue,\n  type AnyDirectiveAttachments,\n  type AnyFieldSelection,\n  type AnyFieldsExtended,\n  type AnyFieldValue,\n  type AnyNestedUnion,\n  type InferFieldsExtended,\n  type ScalarShorthand,\n  VarRef,\n} from \"../types/fragment\";\nimport type { AnyGraphqlSchema, ConstAssignableInput, OperationType } from \"../types/schema\";\nimport type { ConstValue, InputTypeSpecifier, InputTypeSpecifiers, TypeModifier } from \"../types/type-foundation\";\nimport { type AnyDirectiveRef, type DirectiveLocation, DirectiveRef } from \"../types/type-foundation/directive-ref\";\n\n/**\n * Context for determining if a value should be output as an enum.\n * Contains the schema for looking up nested input types and the current type specifier.\n */\nexport type EnumLookup = {\n  schema: AnyGraphqlSchema;\n  /** Type specifier for the current value. null means enum detection is skipped. */\n  typeSpecifier: InputTypeSpecifier | null;\n};\n\n/**\n * Converts an assignable input value to a GraphQL AST ValueNode.\n *\n * Handles primitives, arrays, objects, and variable references.\n * Returns null for undefined values (field is omitted).\n *\n * @param value - The value to convert\n * @param enumLookup - Context for enum detection. String values will be output\n *                     as Kind.ENUM if typeSpecifier indicates an enum type.\n */\nexport const buildArgumentValue = (value: AnyAssignableInputValue, enumLookup: EnumLookup): ValueNode | null => {\n  if (value === undefined) {\n    return null;\n  }\n\n  if (value === null) {\n    return {\n      kind: Kind.NULL,\n    };\n  }\n\n  if (value instanceof VarRef) {\n    const inner = VarRef.getInner(value);\n    if (inner.type === \"variable\") {\n      return {\n        kind: Kind.VARIABLE,\n        name: { kind: Kind.NAME, value: inner.name },\n      };\n    }\n\n    if (inner.type === \"nested-value\") {\n      // Recursively process the nested value\n      // This handles VarRefs inside the nested structure\n      return buildArgumentValue(inner.value as AnyAssignableInputValue, enumLookup);\n    }\n\n    throw new Error(`Unknown var ref type: ${inner satisfies never}`);\n  }\n\n  if (Array.isArray(value)) {\n    // For list types, the inner type specifier remains the same (e.g., [Status!]! uses Status for each item)\n    return {\n      kind: Kind.LIST,\n      values: value.map((item) => buildArgumentValue(item, enumLookup)).filter((item) => item !== null),\n    };\n  }\n\n  if (typeof value === \"object\") {\n    return {\n      kind: Kind.OBJECT,\n      fields: Object.entries(value)\n        .map(([key, fieldValue]): ObjectFieldNode | null => {\n          // Look up field type in nested InputObject for enum detection\n          let fieldTypeSpecifier: InputTypeSpecifier | null = null;\n          if (enumLookup.typeSpecifier?.kind === \"input\") {\n            const inputDef = enumLookup.schema.input[enumLookup.typeSpecifier.name];\n            fieldTypeSpecifier = inputDef?.fields[key] ?? null;\n          }\n\n          const valueNode = buildArgumentValue(fieldValue, {\n            schema: enumLookup.schema,\n            typeSpecifier: fieldTypeSpecifier,\n          });\n          return valueNode\n            ? {\n                kind: Kind.OBJECT_FIELD,\n                name: { kind: Kind.NAME, value: key },\n                value: valueNode,\n              }\n            : null;\n        })\n        .filter((item) => item !== null),\n    };\n  }\n\n  if (typeof value === \"string\") {\n    // Output as Kind.ENUM if the type specifier indicates this is an enum type\n    if (enumLookup.typeSpecifier?.kind === \"enum\") {\n      return {\n        kind: Kind.ENUM,\n        value,\n      };\n    }\n    return {\n      kind: Kind.STRING,\n      value,\n    };\n  }\n\n  if (typeof value === \"number\") {\n    // Distinguish between INT and FLOAT\n    const isFloat = !Number.isInteger(value) || value.toString().includes(\".\");\n    return {\n      kind: isFloat ? Kind.FLOAT : Kind.INT,\n      value: value.toString(),\n    };\n  }\n\n  if (typeof value === \"boolean\") {\n    return {\n      kind: Kind.BOOLEAN,\n      value,\n    };\n  }\n\n  throw new Error(`Unknown value type: ${typeof (value satisfies never)}`);\n};\n\nconst buildArguments = (\n  args: AnyAssignableInput,\n  argumentSpecifiers: InputTypeSpecifiers,\n  schema: AnyGraphqlSchema,\n): ArgumentNode[] =>\n  Object.entries(args ?? {})\n    .map(([name, value]): ArgumentNode | null => {\n      const typeSpecifier = argumentSpecifiers[name] ?? null;\n      const valueNode = buildArgumentValue(value, { schema, typeSpecifier });\n      return valueNode\n        ? {\n            kind: Kind.ARGUMENT,\n            name: { kind: Kind.NAME, value: name },\n            value: valueNode,\n          }\n        : null;\n    })\n    .filter((item) => item !== null);\n\n/**\n * Validates that a directive can be used at the specified location.\n *\n * @param directive - The directive reference to validate\n * @param expectedLocation - The location where the directive is being used\n * @throws Error if the directive is not valid at the specified location\n */\nconst validateDirectiveLocation = (directive: AnyDirectiveRef, expectedLocation: DirectiveLocation): void => {\n  const inner = DirectiveRef.getInner(directive);\n  if (!inner.locations.includes(expectedLocation)) {\n    throw new Error(\n      `Directive @${inner.name} cannot be used on ${expectedLocation}. ` + `Valid locations: ${inner.locations.join(\", \")}`,\n    );\n  }\n};\n\n/**\n * Builds DirectiveNode array from field directives.\n *\n * Filters for DirectiveRef instances, validates their locations,\n * and converts them to GraphQL AST DirectiveNode objects.\n *\n * @param directives - Array of directive references (or unknown values)\n * @param location - The location context for validation\n * @param schema - The schema for type lookups\n * @returns Array of DirectiveNode for the GraphQL AST\n *\n * Uses argument specifiers from DirectiveRef (when available via createTypedDirectiveMethod)\n * to properly output enum arguments as Kind.ENUM instead of Kind.STRING.\n */\nconst buildDirectives = (\n  directives: AnyDirectiveAttachments,\n  location: DirectiveLocation,\n  schema: AnyGraphqlSchema,\n): DirectiveNode[] => {\n  return directives\n    .filter((d): d is AnyDirectiveRef => d instanceof DirectiveRef)\n    .map((directive) => {\n      validateDirectiveLocation(directive, location);\n      const inner = DirectiveRef.getInner(directive);\n\n      // Use argument specifiers from DirectiveRef for enum detection\n      // Cast is safe because DirectiveArgumentSpecifier matches InputTypeSpecifier structure\n      const argumentSpecifiers = (inner.argumentSpecs ?? {}) as InputTypeSpecifiers;\n\n      return {\n        kind: Kind.DIRECTIVE as const,\n        name: { kind: Kind.NAME as const, value: inner.name },\n        arguments: buildArguments(inner.arguments as AnyAssignableInput, argumentSpecifiers, schema),\n      };\n    });\n};\n\n/**\n * Check if value is shorthand (true) vs factory return (AnyFieldSelection).\n * Used for field selection shorthand syntax support.\n */\nconst isShorthand = (value: AnyFieldValue): value is ScalarShorthand => {\n  return value === true;\n};\n\n/**\n * Expand shorthand to AnyFieldSelection using schema type info.\n * Used at document build time to convert `true` to full field selection.\n *\n * @param schema - The GraphQL schema\n * @param typeName - The parent object type name\n * @param fieldName - The field name to select\n */\nconst expandShorthand = (schema: AnyGraphqlSchema, typeName: string, fieldName: string): AnyFieldSelection => {\n  const typeDef = schema.object[typeName];\n  if (!typeDef) {\n    throw new Error(`Type \"${typeName}\" not found in schema`);\n  }\n\n  const fieldSpec = typeDef.fields[fieldName];\n  if (!fieldSpec) {\n    throw new Error(`Field \"${fieldName}\" not found on type \"${typeName}\"`);\n  }\n\n  return {\n    parent: typeName,\n    field: fieldName,\n    type: fieldSpec,\n    args: {},\n    directives: [],\n    object: null,\n    union: null,\n  };\n};\n\nconst buildUnionSelection = (union: AnyNestedUnion, schema: AnyGraphqlSchema): InlineFragmentNode[] =>\n  Object.entries(union)\n    .map(([typeName, object]): InlineFragmentNode | null => {\n      return object\n        ? {\n            kind: Kind.INLINE_FRAGMENT,\n            typeCondition: {\n              kind: Kind.NAMED_TYPE,\n              name: { kind: Kind.NAME, value: typeName },\n            },\n            selectionSet: {\n              kind: Kind.SELECTION_SET,\n              selections: buildField(object, schema, typeName),\n            },\n          }\n        : null;\n    })\n    .filter((item) => item !== null);\n\n/**\n * Builds field nodes from extended fields map.\n * Supports both shorthand (true) and factory (AnyFieldSelection) syntax.\n *\n * @param fields - Field selections (shorthand or factory)\n * @param schema - The GraphQL schema\n * @param typeName - Parent type name (required for shorthand expansion)\n */\nconst buildField = (fields: AnyFieldsExtended, schema: AnyGraphqlSchema, typeName?: string): FieldNode[] =>\n  Object.entries(fields).map(([alias, value]): FieldNode => {\n    // Expand shorthand to AnyFieldSelection if needed\n    const selection = isShorthand(value) ? expandShorthand(schema, typeName!, alias) : value;\n\n    const { args, field, object, union, directives, type } = selection;\n    const builtDirectives = buildDirectives(directives, \"FIELD\", schema);\n    return {\n      kind: Kind.FIELD,\n      name: { kind: Kind.NAME, value: field },\n      alias: alias !== field ? { kind: Kind.NAME, value: alias } : undefined,\n      arguments: buildArguments(args, type.arguments, schema),\n      directives: builtDirectives.length > 0 ? builtDirectives : undefined,\n      selectionSet: object\n        ? {\n            kind: Kind.SELECTION_SET,\n            selections: buildField(object, schema, type.name),\n          }\n        : union\n          ? {\n              kind: Kind.SELECTION_SET,\n              selections: buildUnionSelection(union, schema),\n            }\n          : undefined,\n    };\n  });\n\n/**\n * Converts a constant value to a GraphQL AST ConstValueNode.\n *\n * Unlike `buildArgumentValue`, this only handles literal values\n * (no variable references). Used for default values.\n *\n * @param value - The constant value to convert\n * @param enumLookup - Context for enum detection. String values will be output\n *                     as Kind.ENUM if typeSpecifier indicates an enum type.\n */\nexport const buildConstValueNode = (value: ConstValue, enumLookup: EnumLookup): ConstValueNode | null => {\n  if (value === undefined) {\n    return null;\n  }\n\n  if (value === null) {\n    return { kind: Kind.NULL };\n  }\n\n  if (Array.isArray(value)) {\n    // For list types, the inner type specifier remains the same\n    return {\n      kind: Kind.LIST,\n      values: value.map((item) => buildConstValueNode(item, enumLookup)).filter((item) => item !== null),\n    };\n  }\n\n  if (typeof value === \"object\") {\n    return {\n      kind: Kind.OBJECT,\n      fields: Object.entries(value)\n        .map(([key, fieldValue]): ConstObjectFieldNode | null => {\n          // Look up field type in nested InputObject for enum detection\n          let fieldTypeSpecifier: InputTypeSpecifier | null = null;\n          if (enumLookup.typeSpecifier?.kind === \"input\") {\n            const inputDef = enumLookup.schema.input[enumLookup.typeSpecifier.name];\n            fieldTypeSpecifier = inputDef?.fields[key] ?? null;\n          }\n\n          const valueNode = buildConstValueNode(fieldValue, {\n            schema: enumLookup.schema,\n            typeSpecifier: fieldTypeSpecifier,\n          });\n          return valueNode\n            ? {\n                kind: Kind.OBJECT_FIELD,\n                name: { kind: Kind.NAME, value: key },\n                value: valueNode,\n              }\n            : null;\n        })\n        .filter((item) => item !== null),\n    };\n  }\n\n  if (typeof value === \"string\") {\n    // Output as Kind.ENUM if the type specifier indicates this is an enum type\n    if (enumLookup.typeSpecifier?.kind === \"enum\") {\n      return { kind: Kind.ENUM, value };\n    }\n    return { kind: Kind.STRING, value };\n  }\n\n  if (typeof value === \"boolean\") {\n    return { kind: Kind.BOOLEAN, value };\n  }\n\n  if (typeof value === \"number\") {\n    // Distinguish between INT and FLOAT\n    const isFloat = !Number.isInteger(value) || value.toString().includes(\".\");\n    return { kind: isFloat ? Kind.FLOAT : Kind.INT, value: value.toString() };\n  }\n\n  throw new Error(`Unknown value type: ${typeof (value satisfies never)}`);\n};\n\n/**\n * Wraps a named type with modifiers (non-null, list).\n *\n * Modifier format: starts with `?` (nullable) or `!` (non-null),\n * followed by `[]?` or `[]!` pairs for lists.\n *\n * @example\n * - `\"!\"` → `String!`\n * - `\"?\"` → `String`\n * - `\"![]!\"` → `[String!]!`\n * - `\"?[]?\"` → `[String]`\n */\nexport const buildWithTypeModifier = (modifier: TypeModifier, buildType: () => NamedTypeNode): TypeNode => {\n  const baseType = buildType();\n\n  if (modifier === \"?\") {\n    return baseType;\n  }\n\n  if (modifier === \"!\") {\n    return { kind: Kind.NON_NULL_TYPE, type: baseType };\n  }\n\n  // Validate modifier format: must start with ? or !, followed by []? or []! pairs\n  // Valid patterns: \"?\", \"!\", \"?[]?\", \"?[]!\", \"![]?\", \"![]!\", \"?[]?[]?\", etc.\n  const validModifierPattern = /^[?!](\\[\\][?!])*$/;\n  if (!validModifierPattern.test(modifier)) {\n    throw new Error(`Unknown modifier: ${modifier}`);\n  }\n\n  // New format: starts with inner type modifier (? or !), then []? or []! pairs\n  // e.g., \"?[]?\" = nullable list of nullable, \"![]!\" = non-null list of non-null\n  let curr: Readonly<{ modifier: string; type: TypeNode }> = {\n    modifier,\n    type: baseType,\n  };\n\n  while (curr.modifier.length > 0) {\n    // Handle inner type modifier (? or !)\n    if (curr.modifier.startsWith(\"?\")) {\n      // Nullable inner type - type stays as-is\n      curr = {\n        modifier: curr.modifier.slice(1),\n        type: curr.type,\n      };\n      continue;\n    }\n\n    if (curr.modifier.startsWith(\"!\")) {\n      // Non-null inner type\n      curr = {\n        modifier: curr.modifier.slice(1),\n        type: curr.type.kind === Kind.NON_NULL_TYPE ? curr.type : { kind: Kind.NON_NULL_TYPE, type: curr.type },\n      };\n      continue;\n    }\n\n    // Handle list modifiers ([]? or []!)\n    if (curr.modifier.startsWith(\"[]?\")) {\n      // Nullable list\n      curr = {\n        modifier: curr.modifier.slice(3),\n        type: { kind: Kind.LIST_TYPE, type: curr.type },\n      };\n      continue;\n    }\n\n    if (curr.modifier.startsWith(\"[]!\")) {\n      // Non-null list\n      curr = {\n        modifier: curr.modifier.slice(3),\n        type: {\n          kind: Kind.NON_NULL_TYPE,\n          type: { kind: Kind.LIST_TYPE, type: curr.type },\n        },\n      };\n      continue;\n    }\n\n    throw new Error(`Unknown modifier: ${curr.modifier}`);\n  }\n\n  return curr.type;\n};\n\nconst buildVariables = (variables: InputTypeSpecifiers, schema: AnyGraphqlSchema): VariableDefinitionNode[] => {\n  return Object.entries(variables).map(\n    ([name, ref]): VariableDefinitionNode => ({\n      kind: Kind.VARIABLE_DEFINITION,\n      variable: { kind: Kind.VARIABLE, name: { kind: Kind.NAME, value: name } },\n      defaultValue:\n        (ref.defaultValue && buildConstValueNode(ref.defaultValue.default, { schema, typeSpecifier: ref })) || undefined,\n      type: buildWithTypeModifier(ref.modifier, () => ({\n        kind: Kind.NAMED_TYPE,\n        name: { kind: Kind.NAME, value: ref.name },\n      })),\n    }),\n  );\n};\n\n/**\n * Converts an operation type string to a GraphQL AST OperationTypeNode.\n */\nexport const buildOperationTypeNode = (operation: OperationType): OperationTypeNode => {\n  switch (operation) {\n    case \"query\":\n      return OperationTypeNode.QUERY;\n    case \"mutation\":\n      return OperationTypeNode.MUTATION;\n    case \"subscription\":\n      return OperationTypeNode.SUBSCRIPTION;\n    default:\n      throw new Error(`Unknown operation type: ${operation}`);\n  }\n};\n\n/**\n * Builds a TypedDocumentNode from operation options.\n *\n * This is the main entry point for converting field selections into\n * a GraphQL document AST. The result can be used with any GraphQL\n * client that supports TypedDocumentNode.\n *\n * @param options - Operation configuration (name, type, variables, fields, schema)\n * @returns TypedDocumentNode with inferred input/output types\n */\nexport const buildDocument = <\n  TSchema extends AnyGraphqlSchema,\n  TTypeName extends keyof TSchema[\"object\"] & string,\n  TFields extends AnyFieldsExtended,\n  TVarDefinitions extends InputTypeSpecifiers,\n>(options: {\n  operationName: string;\n  operationType: OperationType;\n  operationTypeName: TTypeName;\n  variables: TVarDefinitions;\n  fields: TFields;\n  schema: TSchema;\n}): TypedDocumentNode<InferFieldsExtended<TSchema, TTypeName, TFields>, ConstAssignableInput<TSchema, TVarDefinitions>> => {\n  const { operationName, operationType, operationTypeName, variables, fields, schema } = options;\n  return {\n    kind: Kind.DOCUMENT,\n    definitions: [\n      {\n        kind: Kind.OPERATION_DEFINITION,\n        operation: buildOperationTypeNode(operationType),\n        name: { kind: Kind.NAME, value: operationName },\n        variableDefinitions: buildVariables(variables, schema),\n        // directives: directives || [],\n        selectionSet: {\n          kind: Kind.SELECTION_SET,\n          selections: buildField(fields, schema, operationTypeName),\n        },\n      },\n    ],\n  } satisfies DocumentNode as TypedDocumentNode<\n    InferFieldsExtended<TSchema, TTypeName, TFields>,\n    ConstAssignableInput<TSchema, TVarDefinitions>\n  >;\n};\n","import type { AnyFields } from \"../types/fragment\";\nimport type { UnionToIntersection } from \"../utils/type-utils\";\n\n/**\n * Type for colocated field entries.\n * Maps labels to their corresponding field selections.\n */\nexport type ColocatedEntries = Record<string, AnyFields>;\n\n/**\n * Result type for colocated fields.\n * Merges all prefixed entries into a single object.\n */\nexport type ColocatedFields<TEntries extends ColocatedEntries> = UnionToIntersection<\n  {\n    [KPrefix in keyof TEntries]: KPrefix extends string\n      ? {\n          [KField in keyof TEntries[KPrefix] as KField extends string\n            ? `${KPrefix}_${KField}`\n            : never]: TEntries[KPrefix][KField];\n        }\n      : never;\n  }[keyof TEntries]\n>;\n\n/**\n * Creates a $colocate helper function for fragment colocation.\n *\n * $colocate takes an object of { label: fields } and applies prefix-based\n * aliasing to each entry. This mirrors the structure of createExecutionResultParser\n * from @soda-gql/colocation-tools.\n *\n * @example\n * ```typescript\n * // In operation definition\n * query.operation({\n *   name: \"GetData\",\n *   fields: ({ $ }) => $colocate({\n *     userCard: userCardFragment.spread({ userId: $.userId }),\n *     posts: postsFragment.spread({ userId: $.userId }),\n *   }),\n * });\n *\n * // In parser definition (same labels)\n * createExecutionResultParser({\n *   userCard: userCardProjection,\n *   posts: postsProjection,\n * });\n * ```\n */\nexport const createColocateHelper = () => {\n  /**\n   * Colocate multiple field selections with labeled prefixes.\n   *\n   * @param entries - Object mapping labels to field selections\n   * @returns Merged object of all prefixed field entries\n   */\n  const $colocate = <TEntries extends ColocatedEntries>(entries: TEntries): ColocatedFields<TEntries> =>\n    Object.fromEntries(\n      Object.entries(entries).flatMap(([label, fields]) =>\n        Object.entries(fields).map(([key, value]) => [`${label}_${key}`, value] as const),\n      ),\n    ) as ColocatedFields<TEntries>;\n\n  return $colocate;\n};\n\nexport type ColocateHelper = ReturnType<typeof createColocateHelper>;\n","/**\n * Promise detection utilities for cross-realm compatibility.\n * @module\n */\n\n/**\n * Check if a value is Promise-like (has .then method).\n *\n * This function uses duck typing instead of `instanceof Promise` to work across\n * VM sandbox boundaries where Promises created in a different realm have a\n * different constructor.\n *\n * @example\n * ```typescript\n * // Works with native Promises\n * isPromiseLike(Promise.resolve(42)); // true\n *\n * // Works with VM sandbox Promises (instanceof would fail)\n * const vmPromise = vm.runInContext(\"Promise.resolve(42)\", context);\n * isPromiseLike(vmPromise); // true (instanceof Promise would be false)\n *\n * // Rejects non-Promises\n * isPromiseLike({ then: \"not a function\" }); // false\n * isPromiseLike(null); // false\n * isPromiseLike(42); // false\n * ```\n */\nexport const isPromiseLike = <T>(value: unknown): value is PromiseLike<T> => {\n  return value !== null && typeof value === \"object\" && \"then\" in value && typeof value.then === \"function\";\n};\n","import { isPromiseLike } from \"../../utils/promise\";\n\n/**\n * Context passed to the definition factory during evaluation.\n */\nexport type LazyEvaluatorContext = {\n  canonicalId: string;\n};\n\n/**\n * Factory function that produces the definition value.\n * Can be sync or async.\n */\nexport type LazyDefinitionFactory<T> = (context: LazyEvaluatorContext | null) => T | Promise<T>;\n\n/**\n * Function that provides dependencies to evaluate before the main definition.\n */\nexport type LazyDependencyProvider<TDep> = () => TDep[];\n\n/**\n * Internal generator that handles the evaluation protocol.\n */\nexport type LazyEvaluatorExecutor<T> = (context: LazyEvaluatorContext | null) => Generator<Promise<void>, T, void>;\n\n/**\n * Creates a lazy evaluator with caching, async support, and dependency ordering.\n *\n * @param define - Factory function that produces the value\n * @param getDeps - Optional function returning dependencies to evaluate first\n * @param createDepGenerator - Function to create evaluation generator for a dependency\n * @returns An executor generator function\n */\nexport const createLazyEvaluator = <T, TDep>(\n  define: LazyDefinitionFactory<T>,\n  getDeps: LazyDependencyProvider<TDep> | undefined,\n  createDepGenerator: (dep: TDep) => Generator<Promise<void>, void, void>,\n): LazyEvaluatorExecutor<T> => {\n  let cache: { value: T } | null = null;\n  let promise: Promise<void> | null = null;\n\n  return function* execute(context: LazyEvaluatorContext | null): Generator<Promise<void>, T, void> {\n    if (cache) {\n      return cache.value;\n    }\n\n    if (promise) {\n      yield promise;\n      // biome-ignore lint/style/noNonNullAssertion: cache is guaranteed to be set after promise resolves\n      return cache!.value;\n    }\n\n    if (getDeps) {\n      // Need to evaluate the dependencies before the current element is evaluated.\n      //\n      // When dependencies is evaluated while the current element is being evaluated,\n      // the evaluation method will be synchronous regardless of how the current builder\n      // performs. If the dependencies need to be evaluated asynchronously, they throw an error.\n      for (const dep of getDeps()) {\n        yield* createDepGenerator(dep);\n      }\n    }\n\n    const defined = define(context);\n    // Use duck typing for VM sandbox compatibility (instanceof Promise fails for cross-realm Promises)\n    if (!isPromiseLike(defined)) {\n      return (cache = { value: defined }).value;\n    }\n\n    // Create a promise to resolve the value of the element asynchronously.\n    // Yield the promise to make the builder process handle the asynchronous operation if it supports it.\n    promise = defined.then((value) => {\n      cache = { value };\n      promise = null;\n    });\n\n    yield promise;\n    // biome-ignore lint/style/noNonNullAssertion: cache is guaranteed to be set after promise resolves\n    return cache!.value;\n  };\n};\n\n/**\n * Creates an evaluation generator from an executor.\n * Wraps the executor's generator and discards its return value.\n */\nexport function* createEvaluationGenerator<T>(\n  executor: LazyEvaluatorExecutor<T>,\n  context: LazyEvaluatorContext | null,\n): Generator<Promise<void>, void, void> {\n  yield* executor(context);\n}\n\n/**\n * Executes the evaluator synchronously.\n * Throws if async operation is encountered.\n */\nexport const evaluateSync = <T>(executor: LazyEvaluatorExecutor<T>, context: LazyEvaluatorContext | null): T => {\n  const result = executor(context).next();\n\n  if (!result.done) {\n    throw new Error(\"Async operation is not supported in sync evaluation.\");\n  }\n\n  return result.value;\n};\n","import type { AttachmentShape, AttachmentsTupleToIntersection } from \"./attachment-types\";\nimport {\n  createLazyEvaluator,\n  type LazyEvaluatorContext,\n  type LazyEvaluatorExecutor,\n  createEvaluationGenerator as lazyCreateEvaluationGenerator,\n  evaluateSync as lazyEvaluateSync,\n} from \"./lazy-evaluator\";\n\nconst GQL_ELEMENT_FACTORY = Symbol(\"GQL_ELEMENT_FACTORY\");\nconst GQL_ELEMENT_CONTEXT = Symbol(\"GQL_ELEMENT_CONTEXT\");\n\n/**\n * Context passed to element definition factories, containing the canonical ID.\n */\nexport type GqlElementContext = LazyEvaluatorContext;\n\n/**\n * Factory function that produces the element definition.\n * May be sync or async (async requires async build mode).\n */\nexport type GqlElementDefinitionFactory<T> = (context: GqlElementContext | null) => T | Promise<T>;\n\n/**\n * Configuration for attaching a computed property to an element.\n */\nexport type GqlElementAttachment<TElement extends object, TName extends string, TValue extends object> = {\n  name: TName;\n  createValue: (element: TElement) => TValue;\n};\n\n/**\n * Abstract base class for all GraphQL elements (Fragment, Operation).\n *\n * Uses lazy evaluation with caching - definition is computed on first access.\n * Subclasses should not be instantiated directly; use static `create` methods.\n *\n * @template TDefinition - The shape of the evaluated definition\n * @template TInfer - Type inference metadata (access via `$infer`)\n */\nexport abstract class GqlElement<TDefinition extends object, TInfer extends object> {\n  /**\n   * Type-only property for inference. Throws at runtime.\n   * Use with `typeof element.$infer` to extract input/output types.\n   */\n  declare readonly $infer: TInfer;\n\n  private [GQL_ELEMENT_FACTORY]: LazyEvaluatorExecutor<TDefinition>;\n  private [GQL_ELEMENT_CONTEXT]: GqlElementContext | null = null;\n\n  protected constructor(define: GqlElementDefinitionFactory<TDefinition>, getDeps?: () => GqlElement<any, any>[]) {\n    this[GQL_ELEMENT_FACTORY] = createLazyEvaluator(define, getDeps, GqlElement.createEvaluationGenerator);\n\n    Object.defineProperty(this, \"$infer\", {\n      get() {\n        throw new Error(\"This property is only for type meta. Do not access this property directly.\");\n      },\n    });\n  }\n\n  /**\n   * Attaches lazily-computed properties to this element.\n   * Properties are computed once on first access after evaluation.\n   *\n   * @example Single attachment\n   * ```typescript\n   * const fragment = gql.default(...)\n   *   .attach({ name: \"utils\", createValue: (el) => ({ ... }) });\n   * ```\n   *\n   * @example Multiple attachments (use `as const` for full type inference)\n   * ```typescript\n   * const fragment = gql.default(...)\n   *   .attach([\n   *     { name: \"a\", createValue: () => ({ x: 1 }) },\n   *     { name: \"b\", createValue: () => ({ y: 2 }) },\n   *   ] as const);\n   * ```\n   */\n  public attach<TName extends string, TValue extends object>(\n    attachment: GqlElementAttachment<this, TName, TValue>,\n  ): this & { [K in TName]: TValue };\n  public attach<const TAttachments extends readonly AttachmentShape[]>(\n    attachments: TAttachments,\n  ): this & AttachmentsTupleToIntersection<TAttachments>;\n  public attach<TName extends string, TValue extends object>(\n    attachmentOrAttachments: GqlElementAttachment<this, TName, TValue> | readonly AttachmentShape[],\n  ): this & { [K in TName]: TValue } {\n    const attachments = Array.isArray(attachmentOrAttachments) ? attachmentOrAttachments : [attachmentOrAttachments];\n\n    for (const attachment of attachments) {\n      let cache: object | null = null;\n      const self = this;\n\n      Object.defineProperty(this, attachment.name, {\n        get() {\n          if (cache) {\n            return cache;\n          }\n\n          GqlElement.evaluateInstantly(self);\n\n          return (cache = attachment.createValue(self));\n        },\n      });\n    }\n\n    return this as this & { [K in TName]: TValue };\n  }\n\n  /**\n   * Sets the canonical context for an element. Used by the builder.\n   * @internal\n   */\n  static setContext<TElement extends GqlElement<any, any>>(element: TElement, context: GqlElementContext): void {\n    element[GQL_ELEMENT_CONTEXT] = context;\n  }\n\n  /**\n   * Gets the canonical context of an element, if set.\n   * @internal\n   */\n  static getContext(element: GqlElement<any, any>): GqlElementContext | null {\n    return element[GQL_ELEMENT_CONTEXT];\n  }\n\n  /**\n   * Creates a generator for async evaluation. Used by the builder.\n   * @internal\n   */\n  static createEvaluationGenerator(element: GqlElement<any, any>): Generator<Promise<void>, void, void> {\n    return lazyCreateEvaluationGenerator(element[GQL_ELEMENT_FACTORY], element[GQL_ELEMENT_CONTEXT]);\n  }\n\n  private static evaluateInstantly<TValue extends object>(element: GqlElement<TValue, any>): TValue {\n    return lazyEvaluateSync(element[GQL_ELEMENT_FACTORY], element[GQL_ELEMENT_CONTEXT]);\n  }\n\n  /**\n   * Forces synchronous evaluation. Throws if async operation is needed.\n   * @internal\n   */\n  static evaluateSync(element: GqlElement<any, any>): void {\n    void GqlElement.evaluateInstantly(element);\n  }\n\n  /**\n   * Evaluates and returns the element's definition.\n   * Throws if async operation is needed.\n   * @internal\n   */\n  static get<TValue extends object>(element: GqlElement<TValue, any>): TValue {\n    return GqlElement.evaluateInstantly(element);\n  }\n}\n","/**\n * Define element for storing arbitrary value factories.\n * @module\n */\n\nimport { isPromiseLike } from \"../../utils/promise\";\nimport { GqlElement, type GqlElementContext } from \"./gql-element\";\n\n/**\n * Type alias for any GqlDefine instance.\n */\nexport type AnyGqlDefine = GqlDefine<unknown>;\n\n/**\n * Type inference metadata for define elements.\n * Access via `typeof defineElement.$infer`.\n */\nexport type DefineInferMeta<TValue> = {\n  readonly value: TValue;\n};\n\ndeclare const __DEFINE_BRAND__: unique symbol;\n\n/**\n * Internal artifact shape produced by define evaluation.\n * @internal\n */\ntype DefineArtifact<TValue> = {\n  readonly factoryResult: TValue;\n};\n\n/**\n * Represents a factory-based value definition.\n *\n * Define elements are created via `gql(({ define }) => define(() => value))`.\n * The factory is evaluated lazily and the result is cached.\n *\n * @template TValue - The type of value produced by the factory\n *\n * @example\n * ```typescript\n * // Store a primitive value\n * const myNumber = gql.default(({ define }) => define(() => 42));\n * console.log(myNumber.value); // 42\n *\n * // Store a plain object\n * const myConfig = gql.default(({ define }) => define(() => ({\n *   apiUrl: \"https://api.example.com\",\n *   timeout: 5000,\n * })));\n * console.log(myConfig.value.apiUrl); // \"https://api.example.com\"\n * ```\n */\nexport class GqlDefine<TValue> extends GqlElement<DefineArtifact<TValue>, DefineInferMeta<TValue>> {\n  private declare readonly [__DEFINE_BRAND__]: void;\n\n  private constructor(define: (context: GqlElementContext | null) => DefineArtifact<TValue> | Promise<DefineArtifact<TValue>>) {\n    super(define);\n  }\n\n  /**\n   * The evaluated value from the factory.\n   * Triggers lazy evaluation on first access.\n   */\n  public get value(): TValue {\n    return GqlElement.get(this).factoryResult;\n  }\n\n  /**\n   * Creates a new GqlDefine instance.\n   *\n   * Prefer using the `gql(({ define }) => define(() => value))` API instead.\n   *\n   * @param factory - Function that produces the value. Can be sync or async.\n   * @returns A new GqlDefine instance wrapping the factory result.\n   *\n   * @example\n   * ```typescript\n   * // Sync factory\n   * const syncDefine = GqlDefine.create(() => 42);\n   *\n   * // Async factory\n   * const asyncDefine = GqlDefine.create(async () => {\n   *   const data = await fetch('/api/config');\n   *   return data.json();\n   * });\n   * ```\n   */\n  static create<TValue>(factory: () => TValue | Promise<TValue>): GqlDefine<TValue> {\n    return new GqlDefine((_context) => {\n      const result = factory();\n      // Handle async factories\n      if (isPromiseLike<TValue>(result)) {\n        return result.then((value) => ({ factoryResult: value }));\n      }\n      return { factoryResult: result as TValue };\n    });\n  }\n}\n","/**\n * Fragment types for reusable field selections.\n * @module\n */\n\nimport type { OptionalArg } from \"../../utils/empty-object\";\nimport type { AnyAssignableInput, AnyFieldsExtended, AssignableInput, InferFieldsExtended } from \"../fragment\";\nimport type { AnyGraphqlSchema } from \"../schema\";\nimport type { InputTypeSpecifiers } from \"../type-foundation\";\nimport { GqlElement } from \"./gql-element\";\n\n/**\n * Type alias for any Fragment instance.\n */\nexport type AnyFragment = Fragment<string, any, AnyFieldsExtended, any>;\n\n/**\n * Type inference metadata for fragments.\n * Access via `typeof fragment.$infer`.\n */\nexport type FragmentInferMeta<TVariables, TOutput extends object> = {\n  readonly input: TVariables;\n  readonly output: TOutput;\n};\n\n/**\n * Internal artifact shape produced by fragment evaluation.\n * @internal\n */\ninterface FragmentArtifact<\n  TTypeName extends string,\n  TVariables extends Partial<AnyAssignableInput> | void,\n  TFields extends Partial<AnyFieldsExtended>,\n> {\n  readonly typename: TTypeName;\n  readonly key: string | undefined;\n  readonly schemaLabel: string;\n  readonly variableDefinitions: InputTypeSpecifiers;\n  readonly spread: (variables: TVariables) => TFields;\n}\n\ndeclare const __FRAGMENT_BRAND__: unique symbol;\n\n/**\n * Represents a reusable GraphQL field selection on a specific type.\n *\n * Fragments are created via `gql(({ fragment }) => fragment.TypeName({ ... }))`.\n * Use `spread()` to include the fragment's fields in an operation.\n *\n * @template TTypeName - The GraphQL type this fragment selects from\n * @template TVariables - Variables required when spreading\n * @template TFields - The selected fields structure\n * @template TOutput - Inferred output type from selected fields\n */\nexport class Fragment<\n    TTypeName extends string,\n    TVariables extends Partial<AnyAssignableInput> | void,\n    TFields extends Partial<AnyFieldsExtended>,\n    TOutput extends object,\n  >\n  extends GqlElement<FragmentArtifact<TTypeName, TVariables, TFields>, FragmentInferMeta<TVariables, TOutput>>\n  implements FragmentArtifact<TTypeName, TVariables, TFields>\n{\n  private declare readonly [__FRAGMENT_BRAND__]: void;\n\n  private constructor(define: () => FragmentArtifact<TTypeName, TVariables, TFields>) {\n    super(define);\n  }\n\n  /** The GraphQL type name this fragment selects from. */\n  public get typename() {\n    return GqlElement.get(this).typename;\n  }\n\n  /** Optional unique key for prebuilt type lookup. */\n  public get key() {\n    return GqlElement.get(this).key;\n  }\n\n  /** The schema label this fragment belongs to. */\n  public get schemaLabel() {\n    return GqlElement.get(this).schemaLabel;\n  }\n\n  /** Variable definitions for this fragment. */\n  public get variableDefinitions() {\n    return GqlElement.get(this).variableDefinitions;\n  }\n\n  /**\n   * Spreads this fragment's fields into a parent selection.\n   * Pass variables if the fragment defines any.\n   */\n  public get spread() {\n    return GqlElement.get(this).spread;\n  }\n\n  /**\n   * Creates a new Fragment instance.\n   * Prefer using the `gql(({ fragment }) => ...)` API instead.\n   * @internal\n   */\n  static create<\n    TSchema extends AnyGraphqlSchema,\n    TTypeName extends keyof TSchema[\"object\"] & string,\n    TVariableDefinitions extends InputTypeSpecifiers,\n    TFields extends AnyFieldsExtended,\n  >(\n    define: () => {\n      typename: TTypeName;\n      key: string | undefined;\n      schemaLabel: TSchema[\"label\"];\n      variableDefinitions: TVariableDefinitions;\n      spread: (variables: OptionalArg<AssignableInput<TSchema, TVariableDefinitions>>) => TFields;\n    },\n  ) {\n    type Fields = TFields & { [key: symbol]: never };\n    type Output = InferFieldsExtended<TSchema, TTypeName, TFields> & { [key: symbol]: never };\n    type Variables = OptionalArg<AssignableInput<TSchema, TVariableDefinitions>>;\n\n    return new Fragment<TTypeName, Variables, Fields, Output>(define as () => FragmentArtifact<TTypeName, Variables, Fields>);\n  }\n}\n","/**\n * Operation types for GraphQL queries, mutations, and subscriptions.\n * @module\n */\n\nimport type { TypedDocumentNode } from \"@graphql-typed-document-node/core\";\nimport type { AnyFieldsExtended, InferFieldsExtended } from \"../fragment\";\nimport type { AnyConstAssignableInput, AnyGraphqlSchema, ConstAssignableInput, OperationType } from \"../schema\";\nimport type { InputTypeSpecifiers } from \"../type-foundation\";\nimport { GqlElement, type GqlElementContext } from \"./gql-element\";\n\n/**\n * Type alias for any Operation instance.\n */\nexport type AnyOperation = AnyOperationOf<\"query\"> | AnyOperationOf<\"mutation\"> | AnyOperationOf<\"subscription\">;\n\n/**\n * Type alias for an Operation of a specific type.\n */\nexport type AnyOperationOf<TOperationType extends OperationType> = Operation<\n  TOperationType,\n  string,\n  string[],\n  any,\n  AnyFieldsExtended,\n  any\n>;\n\n/**\n * Type inference metadata for operations.\n * Access via `typeof operation.$infer`.\n */\nexport type OperationInferMeta<TVariables, TData extends object> = {\n  readonly input: TVariables;\n  readonly output: TData;\n};\n\ndeclare const __OPERATION_BRAND__: unique symbol;\n\n/**\n * Internal artifact shape produced by operation evaluation.\n * @internal\n */\ntype OperationArtifact<\n  TOperationType extends OperationType,\n  TOperationName extends string,\n  TVariableNames extends string[],\n  TVariables extends AnyConstAssignableInput,\n  TFields extends Partial<AnyFieldsExtended>,\n  TData extends object,\n> = {\n  readonly operationType: TOperationType;\n  readonly operationName: TOperationName;\n  readonly schemaLabel: string;\n  readonly variableNames: TVariableNames;\n  readonly documentSource: () => TFields;\n  readonly document: TypedDocumentNode<TData, TVariables>;\n  readonly metadata?: unknown;\n};\n\n/**\n * Represents a GraphQL operation (query, mutation, or subscription).\n *\n * Operations are created via `gql(({ query }) => query.operation({ ... }))`.\n * Produces a TypedDocumentNode for type-safe execution with GraphQL clients.\n *\n * @template TOperationType - 'query' | 'mutation' | 'subscription'\n * @template TOperationName - The unique operation name\n * @template TVariableNames - Tuple of variable names\n * @template TVariables - Variable types for the operation\n * @template TFields - Selected fields structure\n * @template TData - Inferred response data type\n */\nexport class Operation<\n    TOperationType extends OperationType,\n    TOperationName extends string,\n    TVariableNames extends string[],\n    TVariables extends AnyConstAssignableInput,\n    TFields extends Partial<AnyFieldsExtended>,\n    TData extends object,\n  >\n  extends GqlElement<\n    OperationArtifact<TOperationType, TOperationName, TVariableNames, TVariables, TFields, TData>,\n    OperationInferMeta<TVariables, TData>\n  >\n  implements OperationArtifact<TOperationType, TOperationName, TVariableNames, TVariables, TFields, TData>\n{\n  private declare readonly [__OPERATION_BRAND__]: void;\n\n  private constructor(\n    define: (\n      context: GqlElementContext | null,\n    ) =>\n      | OperationArtifact<TOperationType, TOperationName, TVariableNames, TVariables, TFields, TData>\n      | Promise<OperationArtifact<TOperationType, TOperationName, TVariableNames, TVariables, TFields, TData>>,\n  ) {\n    super(define);\n  }\n\n  /** The operation type: 'query', 'mutation', or 'subscription'. */\n  public get operationType() {\n    return GqlElement.get(this).operationType;\n  }\n\n  /** The unique name of this operation. */\n  public get operationName() {\n    return GqlElement.get(this).operationName;\n  }\n\n  /** The schema label this operation belongs to. */\n  public get schemaLabel() {\n    return GqlElement.get(this).schemaLabel;\n  }\n\n  /** List of variable names defined for this operation. */\n  public get variableNames() {\n    return GqlElement.get(this).variableNames;\n  }\n\n  /**\n   * Returns the field selections. Used for document reconstruction.\n   * @internal\n   */\n  public get documentSource() {\n    return GqlElement.get(this).documentSource;\n  }\n\n  /** The TypedDocumentNode for use with GraphQL clients. */\n  public get document() {\n    return GqlElement.get(this).document;\n  }\n\n  /** Custom metadata attached to this operation, if any. */\n  public get metadata() {\n    return GqlElement.get(this).metadata;\n  }\n\n  /**\n   * Creates a new Operation instance.\n   * Prefer using the `gql(({ query }) => ...)` API instead.\n   * @internal\n   */\n  static create<\n    TSchema extends AnyGraphqlSchema,\n    TOperationType extends OperationType,\n    TOperationName extends string,\n    TVariableDefinitions extends InputTypeSpecifiers,\n    TFields extends AnyFieldsExtended,\n  >(\n    define: (context: GqlElementContext | null) =>\n      | {\n          operationType: TOperationType;\n          operationName: TOperationName;\n          schemaLabel: TSchema[\"label\"];\n          variableNames: (keyof TVariableDefinitions & string)[];\n          documentSource: () => TFields;\n          document: TypedDocumentNode<\n            InferFieldsExtended<TSchema, TSchema[\"operations\"][TOperationType] & keyof TSchema[\"object\"] & string, TFields>,\n            ConstAssignableInput<TSchema, TVariableDefinitions>\n          >;\n          metadata?: unknown;\n        }\n      | Promise<{\n          operationType: TOperationType;\n          operationName: TOperationName;\n          schemaLabel: TSchema[\"label\"];\n          variableNames: (keyof TVariableDefinitions & string)[];\n          documentSource: () => TFields;\n          document: TypedDocumentNode<\n            InferFieldsExtended<TSchema, TSchema[\"operations\"][TOperationType] & keyof TSchema[\"object\"] & string, TFields>,\n            ConstAssignableInput<TSchema, TVariableDefinitions>\n          >;\n          metadata?: unknown;\n        }>,\n  ) {\n    return new Operation(define);\n  }\n}\n","/**\n * Compat composer factory for creating GraphQL operation specifications.\n * @module\n */\n\nimport { type FieldsBuilder, GqlDefine } from \"../types/element\";\nimport type { CompatSpec } from \"../types/element/compat-spec\";\nimport type { AnyFields } from \"../types/fragment\";\nimport type { AnyGraphqlSchema, OperationType } from \"../types/schema\";\nimport type { InputTypeSpecifiers } from \"../types/type-foundation\";\n\n/**\n * Options for creating a compat operation specification.\n */\nexport type CompatOptions<\n  TSchema extends AnyGraphqlSchema,\n  TTypeName extends keyof TSchema[\"object\"] & string,\n  TOperationName extends string,\n  TVarDefinitions extends InputTypeSpecifiers,\n  TFields extends AnyFields,\n> = {\n  /** The operation name */\n  name: TOperationName;\n  /** Optional variable definitions */\n  variables?: TVarDefinitions;\n  /** Field selection builder */\n  fields: FieldsBuilder<TSchema, TTypeName, TVarDefinitions, TFields>;\n};\n\n/**\n * Creates a factory for composing compat operation specifications.\n *\n * Returns a function that creates a `GqlDefine<CompatSpec<...>>` storing\n * the operation specification with unevaluated fieldsBuilder.\n *\n * @param schema - The GraphQL schema definition\n * @param operationType - The operation type ('query' | 'mutation' | 'subscription')\n * @returns Compat operation composer function\n *\n * @internal Used by `createGqlElementComposer`\n */\nexport const createCompatComposer = <TSchema extends AnyGraphqlSchema, TOperationType extends OperationType>(\n  schema: NoInfer<TSchema>,\n  operationType: TOperationType,\n) => {\n  type TTypeName = TSchema[\"operations\"][TOperationType] & keyof TSchema[\"object\"] & string;\n  const operationTypeName: TTypeName | null = schema.operations[operationType];\n  if (operationTypeName === null) {\n    throw new Error(`Operation type ${operationType} is not defined in schema roots`);\n  }\n\n  return <TOperationName extends string, TFields extends AnyFields, TVarDefinitions extends InputTypeSpecifiers = {}>(\n    options: CompatOptions<TSchema, TTypeName, TOperationName, TVarDefinitions, TFields>,\n  ): GqlDefine<CompatSpec<TSchema, TOperationType, TOperationName, TVarDefinitions, TFields>> => {\n    return GqlDefine.create(() => ({\n      schema,\n      operationType,\n      operationName: options.name,\n      variables: (options.variables ?? {}) as TVarDefinitions,\n      fieldsBuilder: options.fields,\n    }));\n  };\n};\n","/**\n * Directive builder utilities for creating field-level directives.\n *\n * Provides type-safe methods for creating directive references that can be\n * applied to field selections. The builder follows a similar pattern to\n * the variable builder ($var).\n *\n * @module\n */\n\nimport {\n  type AnyDirectiveRef,\n  type DirectiveArgumentSpecifier,\n  type DirectiveLocation,\n  DirectiveRef,\n} from \"../types/type-foundation/directive-ref\";\nimport type { AnyVarRef } from \"../types/type-foundation/var-ref\";\n\n/**\n * A method that creates a DirectiveRef with specific type information.\n * The TArgs type defines the expected argument shape for the directive.\n */\nexport type DirectiveMethod<TDirectiveName extends string, TLocations extends readonly DirectiveLocation[], TArgs> = (\n  args: TArgs,\n) => DirectiveRef<{\n  directiveName: TDirectiveName;\n  locations: TLocations;\n}>;\n\n/**\n * Type for directive arguments that can include VarRef values.\n * This allows using variables in directive arguments like `{ if: $.shouldSkip }`.\n */\nexport type DirectiveArgValue = boolean | string | number | null | AnyVarRef;\n\n/**\n * Standard GraphQL directives that are always available.\n */\nexport type StandardDirectives = {\n  /**\n   * @skip directive - conditionally skip a field.\n   * @example\n   * ```typescript\n   * f.email({}, { directives: [$dir.skip({ if: $.hideEmail })] })\n   * ```\n   */\n  skip: DirectiveMethod<\"skip\", readonly [\"FIELD\", \"FRAGMENT_SPREAD\", \"INLINE_FRAGMENT\"], { if: DirectiveArgValue }>;\n\n  /**\n   * @include directive - conditionally include a field.\n   * @example\n   * ```typescript\n   * f.email({}, { directives: [$dir.include({ if: $.showEmail })] })\n   * ```\n   */\n  include: DirectiveMethod<\"include\", readonly [\"FIELD\", \"FRAGMENT_SPREAD\", \"INLINE_FRAGMENT\"], { if: DirectiveArgValue }>;\n};\n\n/**\n * Creates a directive method factory for a specific directive.\n *\n * @param name - The directive name (without @)\n * @param locations - Valid locations where the directive can be applied\n * @returns A function that creates DirectiveRef instances\n *\n * @example\n * ```typescript\n * const skipMethod = createDirectiveMethod(\"skip\", [\"FIELD\", \"FRAGMENT_SPREAD\", \"INLINE_FRAGMENT\"] as const);\n * const skipDirective = skipMethod({ if: true });\n * ```\n */\nexport const createDirectiveMethod = <TDirectiveName extends string, const TLocations extends readonly DirectiveLocation[]>(\n  name: TDirectiveName,\n  locations: TLocations,\n): (<TArgs extends Record<string, unknown>>(\n  args: TArgs,\n) => DirectiveRef<{\n  directiveName: TDirectiveName;\n  locations: TLocations;\n}>) => {\n  return (args) =>\n    new DirectiveRef({\n      name,\n      arguments: args,\n      locations,\n    }) as DirectiveRef<{\n      directiveName: TDirectiveName;\n      locations: TLocations;\n    }>;\n};\n\n/**\n * Type for directive argument specifiers.\n * Maps argument names to their type information.\n */\nexport type DirectiveArgumentSpecifiers = {\n  readonly [argName: string]: DirectiveArgumentSpecifier;\n};\n\n/**\n * Creates a typed directive method with argument type specifiers.\n * Enables enum value output in directive arguments.\n *\n * @param name - The directive name (without @)\n * @param locations - Valid locations where the directive can be applied\n * @param argSpecs - Type specifiers for directive arguments\n * @returns A function that creates DirectiveRef instances with argument type info\n *\n * @example\n * ```typescript\n * const authMethod = createTypedDirectiveMethod(\n *   \"auth\",\n *   [\"FIELD\"] as const,\n *   { role: { kind: \"enum\", name: \"Role\", modifier: \"!\" } }\n * );\n * const authDirective = authMethod({ role: \"ADMIN\" });\n * ```\n */\nexport const createTypedDirectiveMethod = <\n  TDirectiveName extends string,\n  const TLocations extends readonly DirectiveLocation[],\n  const TArgSpecs extends DirectiveArgumentSpecifiers,\n>(\n  name: TDirectiveName,\n  locations: TLocations,\n  argSpecs: TArgSpecs,\n): (<TArgs extends Record<string, unknown>>(\n  args: TArgs,\n) => DirectiveRef<{\n  directiveName: TDirectiveName;\n  locations: TLocations;\n}>) => {\n  return (args) =>\n    new DirectiveRef({\n      name,\n      arguments: args,\n      locations,\n      argumentSpecs: argSpecs,\n    }) as DirectiveRef<{\n      directiveName: TDirectiveName;\n      locations: TLocations;\n    }>;\n};\n\n/**\n * Standard directive locations for @skip and @include.\n */\nconst CONDITIONAL_DIRECTIVE_LOCATIONS = [\"FIELD\", \"FRAGMENT_SPREAD\", \"INLINE_FRAGMENT\"] as const;\n\n/**\n * Creates the standard GraphQL directives (@skip, @include).\n * These are always available regardless of schema definition.\n *\n * @returns Object containing skip and include directive methods\n *\n * @example\n * ```typescript\n * const $dir = createStandardDirectives();\n * const skipDirective = $dir.skip({ if: true });\n * ```\n */\nexport const createStandardDirectives = (): StandardDirectives => ({\n  skip: createDirectiveMethod(\"skip\", CONDITIONAL_DIRECTIVE_LOCATIONS),\n  include: createDirectiveMethod(\"include\", CONDITIONAL_DIRECTIVE_LOCATIONS),\n});\n\n/**\n * Type for any directive method (type-erased).\n */\n// biome-ignore lint/suspicious/noExplicitAny: intentionally erased for flexibility\nexport type AnyDirectiveMethod = (args: any) => AnyDirectiveRef;\n\n/**\n * Type for the directive builder that includes standard directives\n * and can be extended with schema-specific directives.\n */\nexport type DirectiveBuilder<TCustomDirectives extends Record<string, AnyDirectiveMethod> = {}> = StandardDirectives &\n  TCustomDirectives;\n\n/**\n * Creates a directive builder with standard directives and optional custom directives.\n *\n * @param customDirectives - Additional directive methods from schema (generated by codegen)\n * @returns Combined directive builder with all available directives\n *\n * @internal Used by codegen to create schema-specific directive builders\n */\nexport const createDirectiveBuilder = <TCustomDirectives extends Record<string, AnyDirectiveMethod> = {}>(\n  customDirectives?: TCustomDirectives,\n): DirectiveBuilder<TCustomDirectives> => {\n  return {\n    ...createStandardDirectives(),\n    ...(customDirectives ?? ({} as TCustomDirectives)),\n  };\n};\n\n/**\n * Type guard to check if a value is a DirectiveRef.\n *\n * @param value - Value to check\n * @returns True if value is a DirectiveRef instance\n */\nexport const isDirectiveRef = (value: unknown): value is AnyDirectiveRef => {\n  return value instanceof DirectiveRef;\n};\n","import type { DocumentNode } from \"graphql\";\nimport type { FieldPath } from \"../../composer/field-path-context\";\nimport type { OperationType } from \"../schema\";\nimport type { OperationMetadata } from \"./metadata\";\n\n/**\n * Information about a fragment's metadata when spread in an operation.\n */\nexport type FragmentMetaInfo<TFragmentMetadata> = {\n  /** The evaluated metadata from the fragment, if defined */\n  readonly metadata: TFragmentMetadata | undefined;\n  /** Field path where the fragment was spread */\n  readonly fieldPath: FieldPath | null;\n};\n\n/**\n * Metadata adapter that defines how fragment metadata is aggregated\n * and provides schema-level configuration.\n *\n * This adapter allows complete customization of:\n * - Fragment metadata type (TFragmentMetadata)\n * - How fragment metadata is aggregated (aggregateFragmentMetadata)\n * - Schema-level fixed values available to all operation metadata builders (schemaLevel)\n *\n * Note: Operation metadata type is inferred from the operation's metadata callback return type.\n *\n * @template TFragmentMetadata - The metadata type returned by fragment metadata builders\n * @template TAggregatedFragmentMetadata - The type returned by aggregateFragmentMetadata\n * @template TSchemaLevel - The type of schema-level configuration values\n */\nexport type MetadataAdapter<TFragmentMetadata = unknown, TAggregatedFragmentMetadata = unknown, TSchemaLevel = unknown> = {\n  /**\n   * Aggregates metadata from all spread fragments in an operation.\n   * Called with the metadata from each spread fragment.\n   * The return type becomes the `fragmentMetadata` parameter in operation metadata builders.\n   */\n  readonly aggregateFragmentMetadata: (fragments: readonly FragmentMetaInfo<TFragmentMetadata>[]) => TAggregatedFragmentMetadata;\n  /**\n   * Schema-level fixed values that are passed to all operation metadata builders.\n   * Useful for configuration that should be consistent across all operations.\n   */\n  readonly schemaLevel?: TSchemaLevel;\n};\n\n/**\n * Extracts the type parameters from a MetadataAdapter.\n */\nexport type ExtractAdapterTypes<T> = T extends MetadataAdapter<infer TFragment, infer TAggregated, infer TSchemaLevel>\n  ? {\n      fragmentMetadata: TFragment;\n      aggregatedFragmentMetadata: TAggregated;\n      schemaLevel: TSchemaLevel;\n    }\n  : never;\n\n/**\n * Generic type for any metadata adapter.\n */\nexport type AnyMetadataAdapter = MetadataAdapter<any, any, any>;\n\n/**\n * Arguments passed to document transformer function.\n * Destructurable for convenient access.\n *\n * @template TSchemaLevel - Schema-level configuration type\n * @template TAggregatedFragmentMetadata - Aggregated fragment metadata type\n */\nexport type DocumentTransformArgs<TSchemaLevel = unknown, TAggregatedFragmentMetadata = unknown> = {\n  /** The GraphQL document to transform */\n  readonly document: DocumentNode;\n  /** The operation name */\n  readonly operationName: string;\n  /** The operation type (query, mutation, subscription) */\n  readonly operationType: OperationType;\n  /** Variable names defined for this operation */\n  readonly variableNames: readonly string[];\n  /** Schema-level configuration from adapter */\n  readonly schemaLevel: TSchemaLevel | undefined;\n  /** Aggregated fragment metadata */\n  readonly fragmentMetadata: TAggregatedFragmentMetadata | undefined;\n};\n\n/**\n * Document transformer function.\n * Receives the built DocumentNode and returns a transformed DocumentNode.\n *\n * @template TSchemaLevel - Schema-level configuration type\n * @template TAggregatedFragmentMetadata - Aggregated fragment metadata type\n */\nexport type DocumentTransformer<TSchemaLevel = unknown, TAggregatedFragmentMetadata = unknown> = (\n  args: DocumentTransformArgs<TSchemaLevel, TAggregatedFragmentMetadata>,\n) => DocumentNode;\n\n/**\n * Arguments passed to operation-level document transformer.\n * Receives typed operation metadata.\n *\n * @template TOperationMetadata - The operation's metadata type\n */\nexport type OperationDocumentTransformArgs<TOperationMetadata = unknown> = {\n  /** The GraphQL document to transform */\n  readonly document: DocumentNode;\n  /** The operation metadata (typed per-operation) */\n  readonly metadata: TOperationMetadata | undefined;\n};\n\n/**\n * Operation-level document transformer function.\n * Applied before the adapter-level transform.\n *\n * **Best Practice:** Define transform logic in adapter helpers for reusability,\n * then reference the helper in the operation's `transformDocument` option.\n *\n * @example\n * ```typescript\n * // Define in adapter helpers\n * const adapter = defineAdapter({\n *   helpers: {\n *     transform: {\n *       addCache: (ttl: number) => ({ document }) => visit(document, { ... }),\n *     },\n *   },\n * });\n *\n * // Use in operation\n * query.operation({\n *   transformDocument: transform.addCache(300),\n *   ...\n * });\n * ```\n *\n * @template TOperationMetadata - The operation's metadata type\n */\nexport type OperationDocumentTransformer<TOperationMetadata = unknown> = (\n  args: OperationDocumentTransformArgs<TOperationMetadata>,\n) => DocumentNode;\n\n/**\n * Unified adapter that combines helpers and metadata configuration.\n *\n * @template THelpers - Custom helper functions accessible in gql composer callbacks\n * @template TFragmentMetadata - The metadata type returned by fragment metadata builders\n * @template TAggregatedFragmentMetadata - The type returned by aggregateFragmentMetadata\n * @template TSchemaLevel - The type of schema-level configuration values\n *\n * @example\n * ```typescript\n * const adapter = defineAdapter({\n *   helpers: {\n *     auth: {\n *       requiresLogin: () => ({ requiresAuth: true }),\n *     },\n *   },\n *   metadata: {\n *     aggregateFragmentMetadata: (fragments) => fragments.map((m) => m.metadata),\n *     schemaLevel: { apiVersion: \"v2\" },\n *   },\n * });\n * ```\n */\nexport type Adapter<\n  THelpers extends object = object,\n  TFragmentMetadata = unknown,\n  TAggregatedFragmentMetadata = unknown,\n  TSchemaLevel = unknown,\n> = {\n  /** Custom helper functions accessible in gql composer callbacks */\n  readonly helpers?: THelpers;\n  /** Metadata configuration for fragments and operations */\n  readonly metadata?: MetadataAdapter<TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel>;\n  /** Optional document transformer called after document building */\n  readonly transformDocument?: DocumentTransformer<TSchemaLevel, TAggregatedFragmentMetadata>;\n};\n\n/**\n * Generic type for any unified adapter.\n */\nexport type AnyAdapter = Adapter<any, any, any, any>;\n\n/**\n * Extracts the type parameters from a unified Adapter.\n */\nexport type ExtractUnifiedAdapterTypes<T> = T extends Adapter<\n  infer THelpers,\n  infer TFragment,\n  infer TAggregated,\n  infer TSchemaLevel\n>\n  ? {\n      helpers: THelpers;\n      fragmentMetadata: TFragment;\n      aggregatedFragmentMetadata: TAggregated;\n      schemaLevel: TSchemaLevel;\n    }\n  : never;\n\n/**\n * Default adapter that maintains backwards compatibility with the original behavior.\n * Uses OperationMetadata for fragment metadata and aggregates by collecting metadata into a readonly array.\n */\nexport type DefaultMetadataAdapter = MetadataAdapter<OperationMetadata, readonly (OperationMetadata | undefined)[]>;\n\n/**\n * Default unified adapter type.\n */\nexport type DefaultAdapter = Adapter<object, OperationMetadata, readonly (OperationMetadata | undefined)[]>;\n\n/**\n * Creates the default adapter instance.\n * @internal\n */\nexport const createDefaultAdapter = (): DefaultMetadataAdapter => ({\n  aggregateFragmentMetadata: (fragments) => fragments.map((m) => m.metadata),\n});\n\n/**\n * The default adapter instance.\n */\nexport const defaultMetadataAdapter: DefaultMetadataAdapter = createDefaultAdapter();\n","type ArgEntries<T extends object> = { [K in keyof T]-?: [value: T[K], key: K] }[keyof T];\ntype Entries<T extends object> = { [K in keyof T]: [key: K, value: T[K]] }[keyof T];\n\nexport function mapValues<TObject extends object, TMappedValue>(\n  obj: TObject,\n  fn: (...args: ArgEntries<TObject>) => TMappedValue,\n): {\n  [K in keyof TObject]: TMappedValue;\n} {\n  return Object.fromEntries((Object.entries(obj) as Entries<TObject>[]).map(([key, value]) => [key, fn(value, key)])) as {\n    [K in keyof TObject]: TMappedValue;\n  };\n}\n","/**\n * Field path context using shared value container pattern.\n *\n * This module tracks the current field path during field building,\n * similar to how React tracks the current fiber.\n * No changes to field builder arguments are needed - use getCurrentFieldPath() to access.\n */\n\n/**\n * A segment in the field path.\n */\nexport type FieldPathSegment = {\n  /** The field name */\n  readonly field: string;\n  /** The parent type name */\n  readonly parent: string;\n  /** Whether this field returns a list */\n  readonly isList: boolean;\n};\n\n/**\n * Complete field path from root to current position.\n */\nexport type FieldPath = {\n  /** Full path string (e.g., \"$.user.posts[].author\") */\n  readonly full: string;\n  /** Individual path segments */\n  readonly segments: readonly FieldPathSegment[];\n};\n\n/**\n * Shared mutable container for field path context.\n * Only synchronous access is supported.\n */\nconst fieldPathContext: { current: FieldPath | null } = {\n  current: null,\n};\n\n/**\n * Get the current field path.\n * Returns null if not in a field building context.\n *\n * @example\n * ```typescript\n * import { getCurrentFieldPath } from '@soda-gql/core';\n *\n * // Inside a field builder or model spread:\n * const path = getCurrentFieldPath();\n * console.log(path?.full); // \"$.user.posts[].author\"\n * ```\n */\nexport const getCurrentFieldPath = (): FieldPath | null => fieldPathContext.current;\n\n/**\n * Run a function with a specific field path context.\n * Restores the previous path after the function completes.\n *\n * @internal\n */\nexport const withFieldPath = <T>(path: FieldPath, fn: () => T): T => {\n  const previousPath = fieldPathContext.current;\n  fieldPathContext.current = path;\n  try {\n    return fn();\n  } finally {\n    fieldPathContext.current = previousPath;\n  }\n};\n\n/**\n * Append a new segment to the current path.\n *\n * @internal\n */\nexport const appendToPath = (\n  parent: FieldPath | null,\n  segment: { field: string; parentType: string; isList: boolean },\n): FieldPath => {\n  const listSuffix = segment.isList ? \"[]\" : \"\";\n  const newSegment: FieldPathSegment = {\n    field: segment.field,\n    parent: segment.parentType,\n    isList: segment.isList,\n  };\n\n  if (!parent) {\n    return {\n      full: `$.${segment.field}${listSuffix}`,\n      segments: [newSegment],\n    };\n  }\n\n  return {\n    full: `${parent.full}.${segment.field}${listSuffix}`,\n    segments: [...parent.segments, newSegment],\n  };\n};\n\n/**\n * Check if a type specifier represents a list type.\n * Matches patterns like \"Type:![]!\", \"Type:![]?\", \"Type:?[]!\", etc.\n *\n * @internal\n */\nexport const isListType = (typeString: string): boolean => {\n  return typeString.includes(\"[]\");\n};\n","/**\n * Creates field selection factories for building GraphQL selections.\n * @module\n */\n\nimport type {\n  AnyFieldSelectionFactory,\n  AnyFieldSelectionFactoryReturn,\n  FieldSelectionFactories,\n  NestedObjectFieldsBuilder,\n  NestedUnionFieldsBuilder,\n} from \"../types/element\";\nimport type { AnyFieldSelection, AnyNestedObject, AnyNestedUnion } from \"../types/fragment\";\nimport type { AnyGraphqlSchema, UnionMemberName } from \"../types/schema\";\nimport type { OutputObjectSpecifier, OutputUnionSpecifier } from \"../types/type-foundation\";\nimport type { AnyDirectiveRef } from \"../types/type-foundation/directive-ref\";\nimport { mapValues } from \"../utils/map-values\";\nimport { wrapByKey } from \"../utils/wrap-by-key\";\nimport { appendToPath, getCurrentFieldPath, isListType, withFieldPath } from \"./field-path-context\";\n\n/**\n * Cache map type for field factories.\n * Schema-scoped to avoid cross-schema contamination.\n * @internal\n */\ntype CacheMap = Map<string, Record<string, AnyFieldSelectionFactory>>;\n\nconst cacheMapBySchema = new WeakMap<AnyGraphqlSchema, CacheMap>();\nconst ensureCacheMapBySchema = (schema: AnyGraphqlSchema) => {\n  const cachedCacheMap = cacheMapBySchema.get(schema);\n  if (cachedCacheMap) {\n    return cachedCacheMap;\n  }\n\n  const cacheMap: CacheMap = new Map();\n  cacheMapBySchema.set(schema, cacheMap);\n  return cacheMap;\n};\n\n/**\n * Creates field selection factories for a given object type.\n *\n * Returns an object with a factory for each field defined on the type.\n * Factories are cached per schema+type to avoid recreation.\n *\n * @param schema - The GraphQL schema definition\n * @param typeName - The object type name to create factories for\n * @returns Object mapping field names to their selection factories\n *\n * @internal Used by operation and fragment composers\n */\nexport const createFieldFactories = <TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema[\"object\"] & string>(\n  schema: TSchema,\n  typeName: TTypeName,\n): FieldSelectionFactories<TSchema, TTypeName> => {\n  const cacheMap = ensureCacheMapBySchema(schema);\n  const cached = cacheMap.get(typeName);\n  if (cached) {\n    return cached as unknown as FieldSelectionFactories<TSchema, TTypeName>;\n  }\n\n  const factories = createFieldFactoriesInner(schema, typeName);\n  cacheMap.set(typeName, factories as unknown as Record<string, AnyFieldSelectionFactory>);\n\n  return factories;\n};\n\nconst createFieldFactoriesInner = <TSchema extends AnyGraphqlSchema, TTypeName extends keyof TSchema[\"object\"] & string>(\n  schema: TSchema,\n  typeName: TTypeName,\n): FieldSelectionFactories<TSchema, TTypeName> => {\n  const typeDef = schema.object[typeName];\n  if (!typeDef) {\n    throw new Error(`Type ${typeName} is not defined in schema objects`);\n  }\n\n  const entries = Object.entries(typeDef.fields).map(([fieldName, type]): [string, AnyFieldSelectionFactory] => {\n    const factory: AnyFieldSelectionFactory = <TAlias extends string | null = null>(\n      fieldArgs: AnyFieldSelection[\"args\"] | null | void,\n      extras?: { alias?: TAlias; directives?: AnyDirectiveRef[] },\n    ) => {\n      const wrap = <T>(value: T) => wrapByKey((extras?.alias ?? fieldName) as TAlias extends null ? string : TAlias, value);\n      const directives = extras?.directives ?? [];\n\n      if (type.kind === \"object\") {\n        type TSelection = AnyFieldSelection & { type: OutputObjectSpecifier };\n        const factoryReturn = (<TNested extends AnyNestedObject>(\n          nest: NestedObjectFieldsBuilder<TSchema, TSelection[\"type\"][\"name\"], TNested>,\n        ) => {\n          // Build new path for this field\n          const currentPath = getCurrentFieldPath();\n          const newPath = appendToPath(currentPath, {\n            field: fieldName,\n            parentType: typeName,\n            isList: isListType(type.modifier),\n          });\n\n          // Run nested builder with updated path context\n          const nestedFields = withFieldPath(newPath, () => nest({ f: createFieldFactories(schema, type.name) }));\n\n          return wrap({\n            parent: typeName,\n            field: fieldName,\n            type: type,\n            args: fieldArgs ?? {},\n            directives,\n            object: nestedFields,\n            union: null,\n          });\n        }) as unknown as AnyFieldSelectionFactoryReturn<TAlias>;\n\n        return factoryReturn;\n      }\n\n      if (type.kind === \"union\") {\n        type TSelection = AnyFieldSelection & { type: OutputUnionSpecifier };\n        const factoryReturn = (<TNested extends AnyNestedUnion>(\n          nest: NestedUnionFieldsBuilder<TSchema, UnionMemberName<TSchema, TSelection[\"type\"]>, TNested>,\n        ) => {\n          // Build new path for this field\n          const currentPath = getCurrentFieldPath();\n          const newPath = appendToPath(currentPath, {\n            field: fieldName,\n            parentType: typeName,\n            isList: isListType(type.modifier),\n          });\n\n          // Run nested builders with updated path context\n          const nestedUnion = withFieldPath(newPath, () =>\n            mapValues(\n              nest as Record<string, NestedObjectFieldsBuilder<TSchema, string, AnyNestedObject> | undefined>,\n              (builder, memberName) => {\n                if (!builder) {\n                  throw new Error(`Builder is undefined for member name: ${memberName}`);\n                }\n                return builder({ f: createFieldFactories(schema, memberName) });\n              },\n            ),\n          ) as TNested;\n\n          return wrap({\n            parent: typeName,\n            field: fieldName,\n            type: type,\n            args: fieldArgs ?? {},\n            directives,\n            object: null,\n            union: nestedUnion,\n          });\n        }) as unknown as AnyFieldSelectionFactoryReturn<TAlias>;\n\n        return factoryReturn;\n      }\n\n      if (type.kind === \"scalar\" || type.kind === \"enum\" || type.kind === \"typename\") {\n        const factoryReturn: AnyFieldSelectionFactoryReturn<TAlias> = wrap({\n          parent: typeName,\n          field: fieldName,\n          type,\n          args: fieldArgs ?? {},\n          directives,\n          object: null,\n          union: null,\n        });\n        return factoryReturn;\n      }\n\n      // Excluded types are filtered out during codegen and should never be encountered at runtime\n      if (type.kind === \"excluded\") {\n        throw new Error(`Field \"${fieldName}\" references excluded type \"${type.name}\"`);\n      }\n\n      throw new Error(`Unsupported field type: ${type satisfies never}`);\n    };\n\n    return [fieldName, factory] as const;\n  });\n\n  const factories: Record<string, AnyFieldSelectionFactory> = Object.fromEntries(entries);\n\n  return factories as unknown as FieldSelectionFactories<TSchema, TTypeName>;\n};\n","/**\n * Fragment usage context using shared value container pattern.\n *\n * This module tracks fragment usages during operation building,\n * allowing metadata from spread fragments to be collected and aggregated.\n * Similar to field-path-context, uses a shared mutable container.\n */\n\nimport type { FieldPath } from \"./field-path-context\";\n\n/**\n * Record of a fragment being spread in an operation.\n * Stores metadata builder (not fragment reference) since fragment cannot reference itself.\n *\n * @template TFragmentMetadata - The type of metadata produced by the fragment's metadata builder\n */\nexport type FragmentUsageRecord<TFragmentMetadata = unknown> = {\n  /** Metadata builder factory from the fragment, if defined */\n  readonly metadataBuilder: (() => TFragmentMetadata | Promise<TFragmentMetadata>) | null;\n  /** Field path where the fragment was spread */\n  readonly path: FieldPath | null;\n};\n\n/**\n * Shared mutable container for collecting fragment usages.\n * Only synchronous access is supported.\n */\nconst fragmentUsageContext: { current: FragmentUsageRecord[] | null } = {\n  current: null,\n};\n\n/**\n * Run a function with fragment usage collection enabled.\n * Returns both the function result and collected fragment usages.\n *\n * @internal\n */\nexport const withFragmentUsageCollection = <T>(fn: () => T): { result: T; usages: FragmentUsageRecord[] } => {\n  const previousCollector = fragmentUsageContext.current;\n  const usages: FragmentUsageRecord[] = [];\n  fragmentUsageContext.current = usages;\n  try {\n    const result = fn();\n    return { result, usages };\n  } finally {\n    fragmentUsageContext.current = previousCollector;\n  }\n};\n\n/**\n * Record a fragment usage. Called when fragment.spread() is invoked.\n * No-op if not in a collection context.\n *\n * @internal\n */\nexport const recordFragmentUsage = (record: FragmentUsageRecord): void => {\n  if (fragmentUsageContext.current) {\n    fragmentUsageContext.current.push(record);\n  }\n};\n","/**\n * Utilities for creating variable assignments and references.\n * @module\n */\n\nimport {\n  type AnyAssignableInput,\n  createVarRefFromNestedValue,\n  createVarRefFromVariable,\n  type DeclaredVariables,\n  VarRef,\n} from \"../types/fragment\";\nimport type { AnyGraphqlSchema } from \"../types/schema\";\nimport type { AnyVarRef, InputTypeSpecifiers, NestedValue } from \"../types/type-foundation\";\nimport { mapValues } from \"../utils/map-values\";\n\n/**\n * Creates variable assignments from provided values.\n *\n * Maps variable definitions to VarRefs. If a value is provided,\n * wraps it as a nested-value VarRef. If not provided, creates\n * an undefined VarRef (field will be omitted).\n *\n * Used when spreading fragments with partial variable values.\n *\n * @internal\n */\nexport const createVarAssignments = <TSchema extends AnyGraphqlSchema, TVariableDefinitions extends InputTypeSpecifiers>(\n  definitions: TVariableDefinitions,\n  providedValues: AnyAssignableInput | void,\n): DeclaredVariables<TSchema, TVariableDefinitions> => {\n  return mapValues(definitions, (_, key): AnyVarRef => {\n    const varName = key as string;\n    if (!providedValues || providedValues[varName] === undefined) {\n      return createVarRefFromNestedValue(undefined);\n    }\n\n    const provided = providedValues[varName];\n    if (provided instanceof VarRef) {\n      return provided;\n    }\n\n    return createVarRefFromNestedValue(provided as NestedValue);\n  }) as DeclaredVariables<TSchema, TVariableDefinitions>;\n};\n\n/**\n * Creates variable references from variable definitions.\n *\n * Maps each variable definition to a VarRef pointing to that variable.\n * Used in operation builders to create the `$` context object.\n *\n * @internal\n */\nexport const createVarRefs = <TSchema extends AnyGraphqlSchema, TVarDefinitions extends InputTypeSpecifiers>(\n  definitions: TVarDefinitions,\n) =>\n  mapValues(definitions as InputTypeSpecifiers, (_, name): AnyVarRef => createVarRefFromVariable(name)) as DeclaredVariables<\n    TSchema,\n    TVarDefinitions\n  >;\n","/**\n * Core operation building logic shared by operation and extend composers.\n * @module\n * @internal\n */\n\nimport type { FieldsBuilder } from \"../types/element\";\nimport type { AnyFieldsExtended, DeclaredVariables } from \"../types/fragment\";\nimport type {\n  AnyMetadataAdapter,\n  DocumentTransformer,\n  ExtractAdapterTypes,\n  FragmentMetaInfo,\n  MetadataBuilder,\n  OperationDocumentTransformer,\n} from \"../types/metadata\";\nimport type { AnyGraphqlSchema, OperationType } from \"../types/schema\";\nimport type { InputTypeSpecifiers } from \"../types/type-foundation\";\n\nimport { isPromiseLike } from \"../utils/promise\";\nimport { buildDocument } from \"./build-document\";\nimport { createFieldFactories } from \"./fields-builder\";\nimport { withFragmentUsageCollection } from \"./fragment-usage-context\";\nimport { createVarRefs } from \"./input\";\n\n/**\n * Parameters for building an operation artifact.\n * Used by both operation and extend composers.\n */\nexport type OperationCoreParams<\n  TSchema extends AnyGraphqlSchema,\n  TOperationType extends OperationType,\n  TOperationName extends string,\n  TVarDefinitions extends InputTypeSpecifiers,\n  TFields extends AnyFieldsExtended,\n  TOperationMetadata,\n  TAdapter extends AnyMetadataAdapter,\n> = {\n  // Required\n  readonly schema: TSchema;\n  readonly operationType: TOperationType;\n  readonly operationTypeName: TSchema[\"operations\"][TOperationType] & keyof TSchema[\"object\"] & string;\n  readonly operationName: TOperationName;\n  readonly variables: TVarDefinitions;\n  readonly fieldsFactory: FieldsBuilder<\n    TSchema,\n    TSchema[\"operations\"][TOperationType] & keyof TSchema[\"object\"] & string,\n    TVarDefinitions,\n    TFields\n  >;\n\n  // Metadata handling\n  readonly adapter: TAdapter;\n  readonly metadata?: MetadataBuilder<\n    DeclaredVariables<TSchema, TVarDefinitions>,\n    TOperationMetadata,\n    ExtractAdapterTypes<TAdapter>[\"aggregatedFragmentMetadata\"],\n    ExtractAdapterTypes<TAdapter>[\"schemaLevel\"]\n  >;\n  readonly transformDocument?: OperationDocumentTransformer<TOperationMetadata>;\n  readonly adapterTransformDocument?: DocumentTransformer<\n    ExtractAdapterTypes<TAdapter>[\"schemaLevel\"],\n    ExtractAdapterTypes<TAdapter>[\"aggregatedFragmentMetadata\"]\n  >;\n};\n\n/**\n * Result type from buildOperationArtifact.\n * Matches the artifact shape expected by Operation.create().\n */\nexport type OperationArtifactResult<\n  TOperationType extends OperationType,\n  TOperationName extends string,\n  TVarDefinitions extends InputTypeSpecifiers,\n  TFields extends AnyFieldsExtended,\n  TOperationMetadata,\n> = {\n  readonly operationType: TOperationType;\n  readonly operationName: TOperationName;\n  readonly schemaLabel: string;\n  readonly variableNames: (keyof TVarDefinitions & string)[];\n  readonly documentSource: () => TFields;\n  readonly document: ReturnType<typeof buildDocument>;\n  readonly metadata: TOperationMetadata | undefined;\n};\n\n/**\n * Builds an operation artifact from the provided parameters.\n *\n * This function contains the core logic for:\n * - Creating variable refs and field factories\n * - Evaluating fields with fragment usage tracking\n * - Building the document\n * - Handling metadata (sync and async)\n * - Applying document transformations\n *\n * @param params - Operation building parameters\n * @returns Operation artifact or Promise of artifact (if async metadata)\n *\n * @internal Used by operation.ts and extend.ts\n */\nexport const buildOperationArtifact = <\n  TSchema extends AnyGraphqlSchema,\n  TOperationType extends OperationType,\n  TOperationName extends string,\n  TVarDefinitions extends InputTypeSpecifiers,\n  TFields extends AnyFieldsExtended,\n  TOperationMetadata,\n  TAdapter extends AnyMetadataAdapter,\n>(\n  params: OperationCoreParams<TSchema, TOperationType, TOperationName, TVarDefinitions, TFields, TOperationMetadata, TAdapter>,\n):\n  | OperationArtifactResult<TOperationType, TOperationName, TVarDefinitions, TFields, TOperationMetadata>\n  | Promise<OperationArtifactResult<TOperationType, TOperationName, TVarDefinitions, TFields, TOperationMetadata>> => {\n  type TFragmentMetadata = ExtractAdapterTypes<TAdapter>[\"fragmentMetadata\"];\n  type TAggregatedFragmentMetadata = ExtractAdapterTypes<TAdapter>[\"aggregatedFragmentMetadata\"];\n  type TSchemaLevel = ExtractAdapterTypes<TAdapter>[\"schemaLevel\"];\n\n  const {\n    schema,\n    operationType,\n    operationTypeName,\n    operationName,\n    variables,\n    fieldsFactory,\n    adapter,\n    metadata: metadataBuilder,\n    transformDocument: operationTransformDocument,\n    adapterTransformDocument,\n  } = params;\n\n  // 1. Create tools\n  const $ = createVarRefs<TSchema, TVarDefinitions>(variables);\n  const f = createFieldFactories(schema, operationTypeName);\n\n  // 2. Evaluate fields with fragment tracking\n  const { result: fields, usages: fragmentUsages } = withFragmentUsageCollection(() => fieldsFactory({ f, $ }));\n\n  // 3. Build document\n  const document = buildDocument<\n    TSchema,\n    TSchema[\"operations\"][TOperationType] & keyof TSchema[\"object\"] & string,\n    TFields,\n    TVarDefinitions\n  >({\n    operationName,\n    operationType,\n    operationTypeName,\n    variables,\n    fields,\n    schema,\n  });\n\n  const variableNames = Object.keys(variables) as (keyof TVarDefinitions & string)[];\n\n  // 4. Check if any fragment has a metadata builder\n  const hasFragmentMetadata = fragmentUsages.some((u) => u.metadataBuilder);\n\n  // Fast path: no metadata to evaluate and no transform\n  if (!hasFragmentMetadata && !metadataBuilder && !adapterTransformDocument && !operationTransformDocument) {\n    return {\n      operationType,\n      operationName,\n      schemaLabel: schema.label,\n      variableNames,\n      documentSource: () => fields,\n      document: document as ReturnType<typeof buildDocument>,\n      metadata: undefined,\n    };\n  }\n\n  // 5. Helper to aggregate fragment metadata\n  const aggregateFragmentMetadata = (\n    resolvedFragmentMetadata: (TFragmentMetadata | undefined)[],\n  ): TAggregatedFragmentMetadata => {\n    const fragmentMetaInfos: FragmentMetaInfo<TFragmentMetadata>[] = fragmentUsages.map((usage, index) => ({\n      metadata: resolvedFragmentMetadata[index],\n      fieldPath: usage.path,\n    }));\n    return adapter.aggregateFragmentMetadata(fragmentMetaInfos) as TAggregatedFragmentMetadata;\n  };\n\n  // 6. Evaluate fragment metadata first (sync or async)\n  const fragmentMetadataResults: (TFragmentMetadata | undefined | Promise<TFragmentMetadata>)[] = fragmentUsages.map((usage) =>\n    usage.metadataBuilder ? usage.metadataBuilder() : undefined,\n  );\n\n  // Check if any fragment metadata is async\n  const hasAsyncFragmentMetadata = fragmentMetadataResults.some((r) => isPromiseLike(r));\n\n  // 7. Helper to build operation metadata from aggregated fragment metadata\n  const buildOperationMetadata = (\n    aggregatedFragmentMetadata: TAggregatedFragmentMetadata,\n  ): TOperationMetadata | undefined | Promise<TOperationMetadata | undefined> => {\n    const schemaLevel = adapter.schemaLevel as TSchemaLevel | undefined;\n    return metadataBuilder?.({ $, document, fragmentMetadata: aggregatedFragmentMetadata, schemaLevel });\n  };\n\n  // 8. Factory that creates the final artifact\n  const makeCreateArtifact = (aggregated: TAggregatedFragmentMetadata) => {\n    return ({\n      metadata,\n    }: {\n      metadata: TOperationMetadata | undefined;\n    }): OperationArtifactResult<TOperationType, TOperationName, TVarDefinitions, TFields, TOperationMetadata> => {\n      // Step 1: Operation transform (typed metadata) - FIRST\n      let finalDocument = operationTransformDocument\n        ? (operationTransformDocument({\n            document,\n            metadata,\n          }) as typeof document)\n        : document;\n\n      // Step 2: Adapter transform (schemaLevel + fragmentMetadata) - SECOND\n      if (adapterTransformDocument) {\n        finalDocument = adapterTransformDocument({\n          document: finalDocument,\n          operationName,\n          operationType,\n          variableNames,\n          schemaLevel: adapter.schemaLevel as TSchemaLevel | undefined,\n          fragmentMetadata: aggregated,\n        }) as typeof document;\n      }\n\n      return {\n        operationType,\n        operationName,\n        schemaLabel: schema.label,\n        variableNames,\n        documentSource: () => fields,\n        document: finalDocument as ReturnType<typeof buildDocument>,\n        metadata,\n      };\n    };\n  };\n\n  // 9. Handle async fragment metadata\n  if (hasAsyncFragmentMetadata) {\n    return Promise.all(fragmentMetadataResults).then(async (resolvedFragmentMetadata) => {\n      const aggregated = aggregateFragmentMetadata(resolvedFragmentMetadata);\n      const operationMetadata = await buildOperationMetadata(aggregated);\n      return makeCreateArtifact(aggregated)({ metadata: operationMetadata });\n    });\n  }\n\n  // 10. All fragment metadata is sync\n  const syncFragmentMetadata = fragmentMetadataResults as (TFragmentMetadata | undefined)[];\n  const aggregated = aggregateFragmentMetadata(syncFragmentMetadata);\n  const createArtifact = makeCreateArtifact(aggregated);\n\n  const operationMetadataResult = buildOperationMetadata(aggregated);\n\n  // Use duck typing for VM sandbox compatibility\n  if (isPromiseLike(operationMetadataResult)) {\n    return operationMetadataResult.then((metadata) => createArtifact({ metadata }));\n  }\n\n  return createArtifact({ metadata: operationMetadataResult });\n};\n","/**\n * Extend composer factory for creating Operations from compat specs.\n * @module\n */\n\nimport { type GqlDefine, Operation } from \"../types/element\";\nimport type { CompatSpec } from \"../types/element/compat-spec\";\nimport type { AnyFields, DeclaredVariables } from \"../types/fragment\";\nimport type {\n  AnyMetadataAdapter,\n  DefaultMetadataAdapter,\n  DocumentTransformer,\n  ExtractAdapterTypes,\n  MetadataBuilder,\n  OperationDocumentTransformer,\n} from \"../types/metadata\";\nimport { defaultMetadataAdapter } from \"../types/metadata\";\nimport type { AnyGraphqlSchema, OperationType } from \"../types/schema\";\nimport type { InputTypeSpecifiers } from \"../types/type-foundation\";\n\nimport { buildOperationArtifact } from \"./operation-core\";\n\n/**\n * Options for extending a compat spec into a full operation.\n */\nexport type ExtendOptions<\n  TSchema extends AnyGraphqlSchema,\n  TVarDefinitions extends InputTypeSpecifiers,\n  TOperationMetadata,\n  TAggregatedFragmentMetadata,\n  TSchemaLevel,\n> = {\n  /** Optional metadata builder */\n  metadata?: MetadataBuilder<\n    DeclaredVariables<TSchema, TVarDefinitions>,\n    TOperationMetadata,\n    TAggregatedFragmentMetadata,\n    TSchemaLevel\n  >;\n  /** Optional document transformer */\n  transformDocument?: OperationDocumentTransformer<TOperationMetadata>;\n};\n\n/**\n * Creates a factory for extending compat specs into full operations.\n *\n * The extend function takes a compat spec (created by `query.compat()`) and\n * optional metadata/transformDocument options, then creates a full Operation.\n *\n * @param schema - The GraphQL schema definition\n * @param adapter - Optional metadata adapter for custom metadata handling\n * @param transformDocument - Optional document transformer\n * @returns Extend composer function\n *\n * @internal Used by `createGqlElementComposer`\n */\nexport const createExtendComposer = <\n  TSchema extends AnyGraphqlSchema,\n  TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter,\n>(\n  schema: NoInfer<TSchema>,\n  adapter?: TAdapter,\n  transformDocument?: DocumentTransformer<\n    ExtractAdapterTypes<TAdapter>[\"schemaLevel\"],\n    ExtractAdapterTypes<TAdapter>[\"aggregatedFragmentMetadata\"]\n  >,\n) => {\n  const resolvedAdapter = adapter ?? (defaultMetadataAdapter as TAdapter);\n\n  type TAggregatedFragmentMetadata = ExtractAdapterTypes<TAdapter>[\"aggregatedFragmentMetadata\"];\n  type TSchemaLevel = ExtractAdapterTypes<TAdapter>[\"schemaLevel\"];\n\n  return <\n    TOperationType extends OperationType,\n    TOperationName extends string,\n    TVarDefinitions extends InputTypeSpecifiers,\n    TFields extends AnyFields,\n    TOperationMetadata = unknown,\n  >(\n    compat: GqlDefine<CompatSpec<TSchema, TOperationType, TOperationName, TVarDefinitions, TFields>>,\n    options?: ExtendOptions<TSchema, TVarDefinitions, TOperationMetadata, TAggregatedFragmentMetadata, TSchemaLevel>,\n  ) => {\n    // Extract the spec from GqlDefine\n    const spec = compat.value;\n    const { operationType, operationName, variables, fieldsBuilder } = spec;\n\n    // Get the operation type name from schema\n    type TTypeName = TSchema[\"operations\"][TOperationType] & keyof TSchema[\"object\"] & string;\n    const operationTypeName = schema.operations[operationType] as TTypeName;\n\n    type DefineResult = Parameters<typeof Operation.create<TSchema, TOperationType, TOperationName, TVarDefinitions, TFields>>[0];\n    // Type assertion needed because compat spec stores fieldsBuilder with schema-specific types\n    // that are compatible at runtime but need casting for TypeScript\n    return Operation.create<TSchema, TOperationType, TOperationName, TVarDefinitions, TFields>((() =>\n      buildOperationArtifact({\n        schema,\n        operationType,\n        operationTypeName,\n        operationName,\n        variables: variables as TVarDefinitions,\n        // biome-ignore lint/suspicious/noExplicitAny: Type cast needed for compat spec fieldsBuilder\n        fieldsFactory: fieldsBuilder as any,\n        adapter: resolvedAdapter,\n        metadata: options?.metadata,\n        transformDocument: options?.transformDocument,\n        adapterTransformDocument: transformDocument,\n      })) as unknown as DefineResult);\n  };\n};\n","/**\n * Fragment composer factory for creating reusable field selections.\n * @module\n */\n\nimport { type FieldsBuilder, Fragment } from \"../types/element\";\nimport type { AnyFieldsExtended, DeclaredVariables } from \"../types/fragment\";\nimport type { AnyMetadataAdapter, DefaultMetadataAdapter, ExtractAdapterTypes, FragmentMetadataBuilder } from \"../types/metadata\";\nimport type { AnyGraphqlSchema } from \"../types/schema\";\nimport type { InputTypeSpecifiers } from \"../types/type-foundation\";\nimport { mapValues } from \"../utils/map-values\";\nimport { getCurrentFieldPath } from \"./field-path-context\";\nimport { createFieldFactories } from \"./fields-builder\";\nimport { recordFragmentUsage } from \"./fragment-usage-context\";\nimport { createVarAssignments, type createVarRefs } from \"./input\";\n\n/**\n * Type alias for a fragment builder function for a specific object type.\n *\n * Used by codegen to generate explicit fragment builder types instead of\n * expensive mapped types. This improves IDE performance for large schemas.\n */\nexport type FragmentBuilderFor<\n  TSchema extends AnyGraphqlSchema,\n  TTypeName extends keyof TSchema[\"object\"] & string,\n  TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter,\n> = <TFields extends AnyFieldsExtended, TVarDefinitions extends InputTypeSpecifiers = {}>(options: {\n  /** Optional unique key for prebuilt type lookup. */\n  key?: string;\n  variables?: TVarDefinitions;\n  metadata?: FragmentMetadataBuilder<\n    ReturnType<typeof createVarRefs<TSchema, TVarDefinitions>>,\n    ExtractAdapterTypes<TAdapter>[\"fragmentMetadata\"]\n  >;\n  fields: FieldsBuilder<TSchema, TTypeName, TVarDefinitions, TFields>;\n}) => ReturnType<typeof Fragment.create<TSchema, TTypeName, TVarDefinitions, TFields>>;\n\n/**\n * Creates fragment builder functions for all object types in the schema.\n *\n * Returns an object with a builder for each type (e.g., `fragment.User`, `fragment.Post`).\n * Each builder creates a `Fragment` that can be spread into operations.\n *\n * @param schema - The GraphQL schema definition\n * @param _adapter - Optional metadata adapter (for fragment metadata)\n * @returns Object mapping type names to fragment builder functions\n *\n * @internal Used by `createGqlElementComposer`\n */\nexport const createGqlFragmentComposers = <\n  TSchema extends AnyGraphqlSchema,\n  TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter,\n>(\n  schema: NoInfer<TSchema>,\n  _adapter?: TAdapter,\n) => {\n  type TFragmentMetadata = ExtractAdapterTypes<TAdapter>[\"fragmentMetadata\"];\n\n  type FragmentBuilder<TTypeName extends keyof TSchema[\"object\"] & string> = <\n    TFields extends AnyFieldsExtended,\n    TVarDefinitions extends InputTypeSpecifiers = {},\n  >(options: {\n    key?: string;\n    variables?: TVarDefinitions;\n    metadata?: FragmentMetadataBuilder<ReturnType<typeof createVarRefs<TSchema, TVarDefinitions>>, TFragmentMetadata>;\n    fields: FieldsBuilder<TSchema, TTypeName, TVarDefinitions, TFields>;\n  }) => ReturnType<typeof Fragment.create<TSchema, TTypeName, TVarDefinitions, TFields>>;\n\n  const createFragmentComposer = <TTypeName extends keyof TSchema[\"object\"] & string>(\n    typename: TTypeName,\n  ): FragmentBuilder<TTypeName> => {\n    return <TFields extends AnyFieldsExtended, TVarDefinitions extends InputTypeSpecifiers = {}>(options: {\n      key?: string;\n      variables?: TVarDefinitions;\n      metadata?: FragmentMetadataBuilder<DeclaredVariables<TSchema, TVarDefinitions>, TFragmentMetadata>;\n      fields: FieldsBuilder<TSchema, TTypeName, TVarDefinitions, TFields>;\n    }) => {\n      const varDefinitions = (options.variables ?? {}) as TVarDefinitions;\n      const { key, metadata, fields } = options;\n\n      return Fragment.create<TSchema, TTypeName, TVarDefinitions, TFields>(() => ({\n        typename,\n        key,\n        schemaLabel: schema.label,\n        variableDefinitions: varDefinitions,\n        spread: (variables) => {\n          const f = createFieldFactories(schema, typename);\n          const $ = createVarAssignments<TSchema, TVarDefinitions>(varDefinitions, variables);\n\n          recordFragmentUsage({\n            metadataBuilder: metadata ? () => metadata({ $ }) : null,\n            path: getCurrentFieldPath(),\n          });\n\n          return fields({ f, $ });\n        },\n      }));\n    };\n  };\n\n  type FragmentBuildersAll = {\n    readonly [TTypeName in keyof TSchema[\"object\"]]: TTypeName extends string ? FragmentBuilder<TTypeName> : never;\n  };\n\n  // Include operation roots (Query, Mutation, Subscription) for fragment colocation\n  // These allow defining reusable fragments on operation root types\n  type FragmentBuilders = FragmentBuildersAll;\n\n  return mapValues(schema.object, (_, typename) => createFragmentComposer(typename)) as FragmentBuilders;\n};\n","/**\n * Operation composer factory for creating typed GraphQL operations.\n * @module\n */\n\nimport { type FieldsBuilder, Operation } from \"../types/element\";\nimport type { AnyFieldsExtended } from \"../types/fragment\";\nimport type {\n  AnyMetadataAdapter,\n  DefaultMetadataAdapter,\n  DocumentTransformer,\n  ExtractAdapterTypes,\n  MetadataBuilder,\n  OperationDocumentTransformer,\n} from \"../types/metadata\";\nimport { defaultMetadataAdapter } from \"../types/metadata\";\nimport type { AnyGraphqlSchema, OperationType } from \"../types/schema\";\nimport type { InputTypeSpecifiers } from \"../types/type-foundation\";\nimport type { createVarRefs } from \"./input\";\nimport { buildOperationArtifact } from \"./operation-core\";\n\n/**\n * Creates a factory for composing GraphQL operations.\n *\n * Returns a curried function: first select operation type (query/mutation/subscription),\n * then define the operation with name, variables, and fields.\n *\n * Handles metadata aggregation from fragments (sync or async) and builds\n * the TypedDocumentNode automatically.\n *\n * @param schema - The GraphQL schema definition\n * @param adapter - Optional metadata adapter for custom metadata handling\n * @param transformDocument - Optional document transformer called after building\n * @returns Operation type selector function\n *\n * @internal Used by `createGqlElementComposer`\n */\nexport const createOperationComposerFactory = <\n  TSchema extends AnyGraphqlSchema,\n  TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter,\n>(\n  schema: NoInfer<TSchema>,\n  adapter?: TAdapter,\n  transformDocument?: DocumentTransformer<\n    ExtractAdapterTypes<TAdapter>[\"schemaLevel\"],\n    ExtractAdapterTypes<TAdapter>[\"aggregatedFragmentMetadata\"]\n  >,\n) => {\n  const resolvedAdapter = adapter ?? (defaultMetadataAdapter as TAdapter);\n\n  type TAggregatedFragmentMetadata = ExtractAdapterTypes<TAdapter>[\"aggregatedFragmentMetadata\"];\n  type TSchemaLevel = ExtractAdapterTypes<TAdapter>[\"schemaLevel\"];\n\n  return <TOperationType extends OperationType>(operationType: TOperationType) => {\n    type TTypeName = TSchema[\"operations\"][TOperationType] & keyof TSchema[\"object\"] & string;\n    const operationTypeName: TTypeName | null = schema.operations[operationType];\n    if (operationTypeName === null) {\n      throw new Error(`Operation type ${operationType} is not defined in schema roots`);\n    }\n\n    return <\n      TOperationName extends string,\n      TFields extends AnyFieldsExtended,\n      TVarDefinitions extends InputTypeSpecifiers = {},\n      TOperationMetadata = unknown,\n    >(options: {\n      name: TOperationName;\n      variables?: TVarDefinitions;\n      metadata?: MetadataBuilder<\n        ReturnType<typeof createVarRefs<TSchema, TVarDefinitions>>,\n        TOperationMetadata,\n        TAggregatedFragmentMetadata,\n        TSchemaLevel\n      >;\n      fields: FieldsBuilder<TSchema, TTypeName, TVarDefinitions, TFields>;\n      transformDocument?: OperationDocumentTransformer<TOperationMetadata>;\n    }) => {\n      type DefineResult = Parameters<\n        typeof Operation.create<TSchema, TOperationType, TOperationName, TVarDefinitions, TFields>\n      >[0];\n      return Operation.create<TSchema, TOperationType, TOperationName, TVarDefinitions, TFields>((() =>\n        buildOperationArtifact({\n          schema,\n          operationType,\n          operationTypeName,\n          operationName: options.name,\n          variables: (options.variables ?? {}) as TVarDefinitions,\n          fieldsFactory: options.fields,\n          adapter: resolvedAdapter,\n          metadata: options.metadata,\n          transformDocument: options.transformDocument,\n          adapterTransformDocument: transformDocument,\n        })) as DefineResult);\n    };\n  };\n};\n","/**\n * Utilities for extracting values and paths from VarRefs.\n *\n * Provides type-safe access to nested values within VarRefs,\n * supporting both variable references and literal values.\n *\n * @module\n */\n\nimport type { ConstValue } from \"../types/type-foundation/const-value\";\nimport {\n  type AnyVarRef,\n  type AnyVarRefBrand,\n  type NestedValueElement,\n  VarRef,\n  type VarRefInner,\n} from \"../types/type-foundation/var-ref\";\n\n/**\n * Recursively checks if a NestedValue contains any VarRef.\n *\n * Used by getVarRefValue to determine if it's safe to return as ConstValue.\n * @internal\n */\nexport const hasVarRefInside = (value: NestedValueElement): boolean => {\n  if (value instanceof VarRef) {\n    return true;\n  }\n\n  if (Array.isArray(value)) {\n    return value.some(hasVarRefInside);\n  }\n\n  if (typeof value === \"object\" && value !== null) {\n    return Object.values(value).some(hasVarRefInside);\n  }\n\n  return false;\n};\n\n/**\n * Get the variable name from a VarRef.\n * Throws if the VarRef contains a nested-value instead of a variable reference.\n */\nexport const getVarRefName = (varRef: AnyVarRef): string => {\n  const inner = VarRef.getInner(varRef);\n  if (inner.type !== \"variable\") {\n    throw new Error(\"Expected variable reference, got nested-value\");\n  }\n  return inner.name;\n};\n\n/**\n * Get the const value from a VarRef.\n * Throws if the VarRef contains a variable reference instead of a nested-value,\n * or if the nested-value contains any VarRef inside.\n */\nexport const getVarRefValue = (varRef: AnyVarRef): ConstValue => {\n  const inner = VarRef.getInner(varRef);\n  if (inner.type !== \"nested-value\") {\n    throw new Error(\"Expected nested-value, got variable reference\");\n  }\n  if (hasVarRefInside(inner.value)) {\n    throw new Error(\"Cannot get const value: nested-value contains VarRef\");\n  }\n  return inner.value as ConstValue;\n};\n\n// ============================================================================\n// Path Types and Utilities\n// ============================================================================\n/**\n * Path segment types for navigating nested values.\n */\nexport type PathSegment = string;\n\n// biome-ignore lint/suspicious/noExplicitAny: abstract type\ntype AnySelectableProxy = SelectableProxy<any>;\n/**\n * Proxy type that records property accesses.\n */\nexport type SelectableProxy<T> = T;\n\n/**\n * Type-safe path builder function.\n * Used with getNameAt and getValueAt helpers.\n */\nexport type Selector<T, U> = (proxy: T) => U;\ntype ProxyInner = {\n  readonly varInner: VarRefInner | { type: \"virtual\"; varName: string; varSegments: readonly PathSegment[] };\n  readonly segments: readonly PathSegment[];\n};\nconst SelectableProxyInnerRegistry = new WeakMap<AnySelectableProxy, ProxyInner>();\nconst getSelectableProxyInner = (proxy: AnySelectableProxy): ProxyInner => {\n  const inner = SelectableProxyInnerRegistry.get(proxy);\n  if (!inner) {\n    throw new Error(`Proxy inner not found`);\n  }\n  return inner;\n};\nconst createSelectableProxy = <T>(current: ProxyInner): T => {\n  const proxy: T = new Proxy(Object.create(null), {\n    get(_, property) {\n      if (typeof property === \"symbol\") {\n        throw new Error(`Prohibited property access: ${String(property)}`);\n      }\n      const nextSegments = [...current.segments, property];\n\n      if (current.varInner.type === \"virtual\") {\n        return createSelectableProxy({\n          varInner: current.varInner,\n          segments: nextSegments,\n        });\n      }\n\n      if (current.varInner.type === \"variable\") {\n        return createSelectableProxy({\n          varInner: { type: \"virtual\", varName: current.varInner.name, varSegments: nextSegments },\n          segments: nextSegments,\n        });\n      }\n\n      if (typeof current.varInner.value === \"object\" && current.varInner.value !== null) {\n        const value = (current.varInner.value as { [key: string]: NestedValueElement })[property];\n        return createSelectableProxy({\n          varInner: value instanceof VarRef ? VarRef.getInner(value) : { type: \"nested-value\", value },\n          segments: nextSegments,\n        });\n      }\n\n      throw new Error(`Cannot access children of primitive value at path [${current.segments.join(\".\")}]`);\n    },\n  });\n\n  SelectableProxyInnerRegistry.set(proxy, current);\n\n  return proxy;\n};\n\n/**\n * Get the variable name from a VarRef at a specific path.\n *\n * @param varRef - The VarRef containing a nested-value\n * @param selector - Path builder function, e.g., p => p.user.age\n * @returns The variable name at the specified path\n * @throws If path doesn't lead to a VarRef with type \"variable\"\n *\n * @example\n * const ref = createVarRefFromNestedValue({\n *   user: { age: someVariableRef }\n * });\n * getNameAt(ref, p => p.user.age); // returns the variable name\n */\nexport const getNameAt = <T, U>(varRef: VarRef<AnyVarRefBrand>, selector: (proxy: T) => U): string => {\n  const proxy = createSelectableProxy<T>({ varInner: VarRef.getInner(varRef), segments: [] });\n  const selected = selector(proxy);\n  const inner = getSelectableProxyInner(selected);\n\n  if (inner.varInner.type === \"virtual\") {\n    throw new Error(`Value at path [${inner.segments.join(\".\")}] is inside a variable`);\n  }\n\n  if (inner.varInner.type !== \"variable\") {\n    throw new Error(`Value at path [${inner.segments.join(\".\")}] is not a variable`);\n  }\n\n  return inner.varInner.name;\n};\n\n/**\n * Get the const value from a nested-value VarRef at a specific path.\n *\n * @param varRef - The VarRef containing a nested-value\n * @param pathFn - Path builder function, e.g., p => p.user.name\n * @returns The const value at the specified path\n * @throws If path leads to a VarRef or if value contains VarRef inside\n *\n * @example\n * const ref = createVarRefFromNestedValue({\n *   user: { name: \"Alice\", age: someVariableRef }\n * });\n * getValueAt(ref, p => p.user.name); // returns \"Alice\"\n */\nexport const getValueAt = <T, U>(varRef: VarRef<AnyVarRefBrand>, selector: (proxy: SelectableProxy<T>) => U): U => {\n  const proxy = createSelectableProxy<T>({ varInner: VarRef.getInner(varRef), segments: [] });\n  const selected = selector(proxy);\n  const inner = getSelectableProxyInner(selected);\n\n  if (inner.varInner.type === \"virtual\") {\n    throw new Error(`Value at path [${inner.segments.join(\".\")}] is inside a variable`);\n  }\n\n  if (inner.varInner.type !== \"nested-value\") {\n    throw new Error(`Value at path [${inner.segments.join(\".\")}] is not a nested-value`);\n  }\n\n  if (hasVarRefInside(inner.varInner.value)) {\n    throw new Error(`Value at path [${inner.segments.join(\".\")}] contains nested VarRef`);\n  }\n\n  return inner.varInner.value as U;\n};\n\n/**\n * Gets the full path to a variable within a nested structure.\n *\n * Returns path segments starting with `$variableName` followed by\n * property accesses within that variable's value.\n *\n * @example\n * ```typescript\n * getVariablePath($.filter, p => p.user.id)\n * // Returns: [\"$filter\", \"user\", \"id\"]\n * ```\n */\nexport const getVariablePath = <T, U>(\n  varRef: VarRef<AnyVarRefBrand>,\n  selector: (proxy: SelectableProxy<T>) => U,\n): readonly PathSegment[] => {\n  const proxy = createSelectableProxy<T>({ varInner: VarRef.getInner(varRef), segments: [] });\n  const selected = selector(proxy);\n  const inner = getSelectableProxyInner(selected);\n\n  if (inner.varInner.type === \"virtual\") {\n    return [`$${inner.varInner.varName}`, ...inner.segments.slice(inner.varInner.varSegments.length)];\n  }\n\n  if (inner.varInner.type === \"variable\") {\n    return [`$${inner.varInner.name}`];\n  }\n\n  throw new Error(`Value at path [${inner.segments.join(\".\")}] is not a variable or inside a variable`);\n};\n","/**\n * Variable builder utilities for defining operation variables.\n *\n * Provides type-safe methods for creating variable definitions with\n * proper type inference for all input types in the schema.\n *\n * @module\n */\n\nimport type {\n  AllInputTypeNames,\n  AnyConstDirectiveAttachments,\n  AnyGraphqlSchema,\n  ConstAssignableInputValue,\n  InferInputKind,\n  ResolveInputProfileFromMeta,\n} from \"../types/schema\";\nimport type { CreatableInputTypeKind, TypeModifier, TypeProfile } from \"../types/type-foundation\";\nimport type { AnyVarRefBrand, VarRef } from \"../types/type-foundation/var-ref\";\nimport { wrapByKey } from \"../utils/wrap-by-key\";\nimport type { SelectableProxy } from \"./var-ref-tools\";\nimport { getNameAt, getValueAt, getVariablePath, getVarRefName, getVarRefValue } from \"./var-ref-tools\";\n\n/**\n * Type for the default value function for a variable.\n */\ntype AssignableDefaultValue<\n  TSchema extends AnyGraphqlSchema,\n  TKind extends CreatableInputTypeKind,\n  TName extends string,\n  TModifier extends TypeModifier,\n> = ConstAssignableInputValue<\n  TSchema,\n  {\n    scalar: { kind: \"scalar\"; name: TName; modifier: TModifier; directives: {}; defaultValue: null };\n    enum: { kind: \"enum\"; name: TName; modifier: TModifier; directives: {}; defaultValue: null };\n    input: { kind: \"input\"; name: TName; modifier: TModifier; directives: {}; defaultValue: null };\n  }[TKind]\n>;\n\n/**\n * Represents a variable definition with its type, modifier, and optional default.\n *\n * Created by `$var.TypeName(\"modifier\", { default?: ... })` calls.\n */\nexport type VarSpecifier<\n  TKind extends CreatableInputTypeKind,\n  TTypeName extends string,\n  TModifier extends TypeModifier,\n  TDefaultFn extends (() => unknown) | null,\n  TDirectives extends AnyConstDirectiveAttachments,\n> = {\n  kind: TKind;\n  name: TTypeName;\n  modifier: TModifier;\n  defaultValue: TDefaultFn extends null\n    ? null\n    : {\n        default: ReturnType<NonNullable<TDefaultFn>>;\n      };\n  directives: TDirectives;\n};\n\n/**\n * Creates a variable method for a specific input type.\n * This is used by codegen to generate type-specific variable methods.\n *\n * @deprecated Use createVarMethodFactory instead for proper type inference with nested input objects.\n */\nexport const createVarMethod = <TKind extends CreatableInputTypeKind, TTypeName extends string>(\n  kind: TKind,\n  typeName: TTypeName,\n) => {\n  return <\n    TSchema extends AnyGraphqlSchema,\n    const TModifier extends TypeModifier,\n    const TDefaultFn extends (() => AssignableDefaultValue<TSchema, TKind, TTypeName, TModifier>) | null = null,\n    const TDirectives extends AnyConstDirectiveAttachments = {},\n  >(\n    modifier: TModifier,\n    extras?: {\n      default?: TDefaultFn & (() => AssignableDefaultValue<TSchema, TKind, TTypeName, TModifier>);\n      directives?: TDirectives;\n    },\n  ): VarSpecifier<TKind, TTypeName, TModifier, TDefaultFn, TDirectives> =>\n    ({\n      kind,\n      name: typeName,\n      modifier,\n      defaultValue: extras?.default ? { default: extras.default() } : null,\n      directives: extras?.directives ?? {},\n    }) as VarSpecifier<TKind, TTypeName, TModifier, TDefaultFn, TDirectives>;\n};\n\n/**\n * Creates a factory function for generating schema-scoped variable methods.\n * This ensures proper type inference for nested input objects by binding the schema type upfront.\n *\n * @example\n * ```typescript\n * const createMethod = createVarMethodFactory<typeof schema>();\n * const inputTypeMethods = {\n *   Boolean: createMethod(\"scalar\", \"Boolean\"),\n *   user_bool_exp: createMethod(\"input\", \"user_bool_exp\"),\n * } satisfies InputTypeMethods<typeof schema>;\n * ```\n */\nexport const createVarMethodFactory = <TSchema extends AnyGraphqlSchema>() => {\n  return <TKind extends CreatableInputTypeKind, TTypeName extends AllInputTypeNames<TSchema>>(\n    kind: TKind,\n    typeName: TTypeName,\n  ): InputTypeMethod<TSchema, TKind, TTypeName> => {\n    return ((modifier, extras) => ({\n      kind,\n      name: typeName,\n      modifier,\n      defaultValue: extras?.default ? { default: extras.default() } : null,\n      directives: extras?.directives ?? {},\n    })) as InputTypeMethod<TSchema, TKind, TTypeName>;\n  };\n};\n\n/**\n * Type for a single input type method.\n */\nexport type InputTypeMethod<TSchema extends AnyGraphqlSchema, TKind extends CreatableInputTypeKind, TTypeName extends string> = <\n  const TModifier extends TypeModifier,\n  const TDefaultFn extends (() => AssignableDefaultValue<TSchema, TKind, TTypeName, TModifier>) | null = null,\n  const TDirectives extends AnyConstDirectiveAttachments = {},\n>(\n  modifier: TModifier,\n  extras?: {\n    default?: TDefaultFn & (() => AssignableDefaultValue<TSchema, TKind, TTypeName, TModifier>);\n    directives?: TDirectives;\n  },\n) => VarSpecifier<TKind, TTypeName, TModifier, TDefaultFn, TDirectives>;\n\n/**\n * Type for all input type methods in a schema.\n */\nexport type InputTypeMethods<TSchema extends AnyGraphqlSchema> = {\n  [TName in AllInputTypeNames<TSchema>]: InputTypeMethod<TSchema, InferInputKind<TSchema, TName>, TName>;\n};\n\n/**\n * Type for a wrapped variable method that includes the variable name in the result.\n */\ntype WrappedVarMethod<\n  TVarName extends string,\n  TSchema extends AnyGraphqlSchema,\n  TKind extends CreatableInputTypeKind,\n  TTypeName extends string,\n> = <\n  const TModifier extends TypeModifier,\n  const TDefaultFn extends (() => AssignableDefaultValue<TSchema, TKind, TTypeName, TModifier>) | null = null,\n  const TDirectives extends AnyConstDirectiveAttachments = {},\n>(\n  modifier: TModifier,\n  extras?: {\n    default?: TDefaultFn & (() => AssignableDefaultValue<TSchema, TKind, TTypeName, TModifier>);\n    directives?: TDirectives;\n  },\n) => { [K in TVarName]: VarSpecifier<TKind, TTypeName, TModifier, TDefaultFn, TDirectives> };\n\n/**\n * Type for the variable builder methods for a specific variable name.\n */\nexport type VarBuilderMethods<TVarName extends string, TSchema extends AnyGraphqlSchema> = {\n  [TName in AllInputTypeNames<TSchema>]: WrappedVarMethod<TVarName, TSchema, InferInputKind<TSchema, TName>, TName>;\n};\n\n/**\n * Variable builder function type.\n *\n * Call with a variable name to get type-specific methods.\n * Also provides utilities for extracting values from VarRefs.\n *\n * @example\n * ```typescript\n * // In operation definition:\n * variables: { userId: $var(\"userId\").ID(\"!\") }\n *\n * // In metadata builder:\n * $var.getValueAt($.userId, p => p)\n * ```\n */\nexport type VarBuilder<TSchema extends AnyGraphqlSchema> = {\n  <TVarName extends string>(varName: TVarName): VarBuilderMethods<TVarName, TSchema>;\n  getName: typeof getVarRefName;\n  getValue: typeof getVarRefValue;\n  getNameAt: SchemaAwareGetNameAt<TSchema>;\n  getValueAt: SchemaAwareGetValueAt<TSchema>;\n  getVariablePath: typeof getVariablePath;\n};\n\n// ============================================================================\n// Schema-aware Type Resolution for VarRef Meta\n// ============================================================================\n\n/**\n * Resolves the TypeScript type from VarRef meta using schema.\n * This is used for getValueAt/getNameAt with type structure resolution.\n */\nexport type ResolveTypeFromMeta<TSchema extends AnyGraphqlSchema, TMeta extends AnyVarRefBrand> = TypeProfile.Type<\n  ResolveInputProfileFromMeta<TSchema, TMeta[\"typeName\"], TMeta[\"kind\"], \"!\">\n>;\n\n/**\n * Schema-aware getValueAt type.\n * Resolves type structure from schema using typeName + kind.\n */\nexport type SchemaAwareGetValueAt<TSchema extends AnyGraphqlSchema> = <T extends AnyVarRefBrand, U>(\n  varRef: VarRef<T>,\n  selector: (proxy: SelectableProxy<ResolveTypeFromMeta<TSchema, T>>) => U,\n) => U;\n\n/**\n * Schema-aware getNameAt type.\n * Resolves type structure from schema using typeName + kind.\n */\nexport type SchemaAwareGetNameAt<TSchema extends AnyGraphqlSchema> = <T extends AnyVarRefBrand, U>(\n  varRef: VarRef<T>,\n  selector: (proxy: ResolveTypeFromMeta<TSchema, T>) => U,\n) => string;\n\n/**\n * Generic input type method that can be called with any modifier.\n */\ntype AnyInputTypeMethod = (\n  modifier: TypeModifier,\n  extras?: { default?: () => unknown; directives?: AnyConstDirectiveAttachments },\n) => unknown;\n\n/**\n * Creates a variable builder using injected input type methods.\n *\n * The returned builder provides type-safe variable definition methods\n * for all input types in the schema. Also includes utilities for\n * extracting variable names and values from VarRefs.\n *\n * @param inputTypeMethods - Methods for each input type (from codegen)\n * @returns Variable builder with methods for all input types\n *\n * @internal Used by `createGqlElementComposer`\n */\nexport const createVarBuilder = <TSchema extends AnyGraphqlSchema>(\n  inputTypeMethods: InputTypeMethods<TSchema>,\n): VarBuilder<TSchema> => {\n  const varBuilder = <TVarName extends string>(varName: TVarName): VarBuilderMethods<TVarName, TSchema> => {\n    const wrappedMethods = {} as VarBuilderMethods<TVarName, TSchema>;\n\n    for (const [typeName, method] of Object.entries(inputTypeMethods) as [string, AnyInputTypeMethod][]) {\n      Object.defineProperty(wrappedMethods, typeName, {\n        value: ((modifier, extras) => wrapByKey(varName, method(modifier, extras))) satisfies AnyInputTypeMethod,\n        writable: false,\n        configurable: true,\n      });\n    }\n\n    return wrappedMethods;\n  };\n\n  varBuilder.getName = getVarRefName;\n  varBuilder.getValue = getVarRefValue;\n  varBuilder.getNameAt = getNameAt;\n  varBuilder.getValueAt = getValueAt;\n  varBuilder.getVariablePath = getVariablePath;\n\n  return varBuilder as VarBuilder<TSchema>;\n};\n","/**\n * Main entry point for composing GraphQL elements.\n * @module\n */\n\nimport type { AnyFragment, AnyGqlDefine, AnyOperation } from \"../types/element\";\nimport { GqlDefine } from \"../types/element\";\nimport type { Adapter, AnyAdapter, AnyMetadataAdapter, DefaultAdapter, DefaultMetadataAdapter } from \"../types/metadata\";\nimport type { AnyGraphqlSchema } from \"../types/schema\";\nimport { createColocateHelper } from \"./colocate\";\nimport { createCompatComposer } from \"./compat\";\nimport { applyContextTransformer } from \"./context-transformer\";\nimport { createStandardDirectives, type StandardDirectives } from \"./directive-builder\";\nimport { createExtendComposer } from \"./extend\";\nimport { createGqlFragmentComposers, type FragmentBuilderFor } from \"./fragment\";\nimport { createOperationComposerFactory } from \"./operation\";\nimport { createVarBuilder, type InputTypeMethods } from \"./var-builder\";\n\n/**\n * Function signature for composing GraphQL elements (fragments or operations).\n *\n * The composer provides a context with builders for fragments, operations,\n * variables, and colocation helpers.\n */\nexport type GqlElementComposer<TContext> = <TResult extends AnyFragment | AnyOperation | AnyGqlDefine>(\n  composeElement: (context: TContext) => TResult,\n) => TResult;\n\n/**\n * GQL element composer with schema access.\n *\n * Extends the base composer function with a `$schema` property that provides\n * runtime access to the schema definition. This is useful for:\n * - Type generation tools (typegen)\n * - Runtime schema introspection\n * - Debugging and tooling\n */\nexport type GqlElementComposerWithSchema<TContext, TSchema extends AnyGraphqlSchema> = GqlElementComposer<TContext> & {\n  /**\n   * The GraphQL schema definition used by this composer.\n   * Provides runtime access to schema types, operations, and metadata.\n   */\n  readonly $schema: TSchema;\n};\n\n/**\n * Extracts the helpers type from an adapter.\n * Uses `any` for non-target type parameters to avoid contravariance issues\n * with the `aggregateFragmentMetadata` function parameter type.\n */\n// biome-ignore lint/suspicious/noExplicitAny: Required to avoid contravariance issues in conditional type matching\ntype ExtractHelpers<TAdapter extends AnyAdapter> = TAdapter extends Adapter<infer THelpers, any, any, any> ? THelpers : object;\n\n/**\n * Extracts the metadata adapter type from an adapter.\n * Handles optional metadata property correctly.\n */\nexport type ExtractMetadataAdapter<TAdapter extends AnyAdapter> = TAdapter extends { metadata?: infer M }\n  ? NonNullable<M> extends AnyMetadataAdapter\n    ? NonNullable<M>\n    : DefaultMetadataAdapter\n  : DefaultMetadataAdapter;\n\n/**\n * Default fragment builders type computed from schema.\n * This is the mapped type that's expensive to compute for large schemas.\n */\nexport type FragmentBuildersAll<\n  TSchema extends AnyGraphqlSchema,\n  TAdapter extends AnyMetadataAdapter = DefaultMetadataAdapter,\n> = {\n  readonly [TTypeName in keyof TSchema[\"object\"]]: TTypeName extends string\n    ? FragmentBuilderFor<TSchema, TTypeName, TAdapter>\n    : never;\n};\n\n/**\n * Configuration options for `createGqlElementComposer`.\n */\nexport type GqlElementComposerOptions<\n  TSchema extends AnyGraphqlSchema,\n  TDirectiveMethods extends StandardDirectives,\n  TAdapter extends AnyAdapter = DefaultAdapter,\n> = {\n  /** Optional adapter for custom helpers and metadata handling. */\n  adapter?: TAdapter;\n  /** Methods for building variable type specifiers. */\n  inputTypeMethods: InputTypeMethods<TSchema>;\n  /** Optional custom directive methods (including schema-defined directives). */\n  directiveMethods?: TDirectiveMethods;\n};\n\n/**\n * Creates a GQL element composer for a given schema.\n *\n * This is the main entry point for defining GraphQL operations and fragments.\n * The returned function provides a context with:\n * - `fragment`: Builders for each object type\n * - `query/mutation/subscription`: Operation builders\n * - `$var`: Variable definition helpers\n * - `$dir`: Field directive helpers (@skip, @include)\n * - `$colocate`: Fragment colocation utilities\n *\n * @param schema - The GraphQL schema definition\n * @param options - Configuration including input type methods and optional adapter\n * @returns Element composer function\n *\n * @example\n * ```typescript\n * const gql = createGqlElementComposer(schema, { inputTypeMethods });\n *\n * const GetUser = gql(({ query, $var, $dir }) =>\n *   query.operation({\n *     name: \"GetUser\",\n *     variables: { showEmail: $var(\"showEmail\").Boolean(\"!\") },\n *     fields: ({ f, $ }) => ({\n *       ...f.user({ id: \"1\" })(({ f }) => ({\n *         ...f.name(),\n *         ...f.email({}, { directives: [$dir.skip({ if: $.showEmail })] }),\n *       })),\n *     }),\n *   })\n * );\n * ```\n */\nexport const createGqlElementComposer = <\n  TSchema extends AnyGraphqlSchema,\n  TFragmentBuilders,\n  TDirectiveMethods extends StandardDirectives,\n  TAdapter extends AnyAdapter = DefaultAdapter,\n>(\n  schema: NoInfer<TSchema>,\n  options: GqlElementComposerOptions<NoInfer<TSchema>, NoInfer<TDirectiveMethods>, NoInfer<TAdapter>>,\n) => {\n  type THelpers = ExtractHelpers<TAdapter>;\n  type TMetadataAdapter = ExtractMetadataAdapter<TAdapter>;\n  const { adapter, inputTypeMethods, directiveMethods } = options;\n  const helpers = adapter?.helpers as THelpers | undefined;\n  const metadataAdapter = adapter?.metadata as TMetadataAdapter | undefined;\n  const transformDocument = adapter?.transformDocument;\n  const fragment = createGqlFragmentComposers<TSchema, TMetadataAdapter>(schema, metadataAdapter) as TFragmentBuilders;\n  const createOperationComposer = createOperationComposerFactory<TSchema, TMetadataAdapter>(\n    schema,\n    metadataAdapter,\n    transformDocument,\n  );\n\n  // Wrap operation composers in objects with an `operation` method for extensibility\n  // This allows adding more factories (e.g., query.compat, mutation.compat) in the future\n  const context = {\n    fragment,\n    query: {\n      operation: createOperationComposer(\"query\"),\n      compat: createCompatComposer<TSchema, \"query\">(schema, \"query\"),\n    },\n    mutation: {\n      operation: createOperationComposer(\"mutation\"),\n      compat: createCompatComposer<TSchema, \"mutation\">(schema, \"mutation\"),\n    },\n    subscription: {\n      operation: createOperationComposer(\"subscription\"),\n      compat: createCompatComposer<TSchema, \"subscription\">(schema, \"subscription\"),\n    },\n    define: <TValue>(factory: () => TValue | Promise<TValue>) => GqlDefine.create(factory),\n    extend: createExtendComposer<TSchema, TMetadataAdapter>(schema, metadataAdapter, transformDocument),\n    $var: createVarBuilder<TSchema>(inputTypeMethods),\n    $dir: directiveMethods ?? (createStandardDirectives() as TDirectiveMethods),\n    $colocate: createColocateHelper(),\n    ...(helpers ?? ({} as THelpers)),\n  };\n\n  // Apply context transformer if set (for programmatic API like @soda-gql/sdk)\n  const transformedContext = applyContextTransformer(context);\n\n  const elementComposer: GqlElementComposer<typeof context> = (composeElement) => composeElement(transformedContext);\n\n  // Attach schema as readonly property for runtime access\n  const composerWithSchema = elementComposer as GqlElementComposerWithSchema<typeof context, TSchema>;\n  Object.defineProperty(composerWithSchema, \"$schema\", {\n    value: schema,\n    writable: false,\n    enumerable: true,\n    configurable: false,\n  });\n\n  return composerWithSchema;\n};\n\n/**\n * Abstract Context type for prebuilt composers.\n *\n * Provides minimal structure while allowing PrebuiltTypeRegistry to resolve\n * actual types. Used by prebuilt module to avoid heavy schema type inference.\n *\n * Type safety in prebuilt comes from `ResolvePrebuiltElement`, not from\n * the Context type.\n */\nexport type AnyGqlContext = {\n  readonly fragment: Record<string, unknown>;\n  readonly query: { operation: (...args: unknown[]) => AnyOperation; compat: (...args: unknown[]) => AnyGqlDefine };\n  readonly mutation: { operation: (...args: unknown[]) => AnyOperation; compat: (...args: unknown[]) => AnyGqlDefine };\n  readonly subscription: { operation: (...args: unknown[]) => AnyOperation; compat: (...args: unknown[]) => AnyGqlDefine };\n  readonly define: <TValue>(factory: () => TValue | Promise<TValue>) => GqlDefine<TValue>;\n  readonly extend: (...args: unknown[]) => AnyOperation;\n  readonly $var: unknown;\n  readonly $dir: StandardDirectives;\n  readonly $colocate: unknown;\n  readonly [key: string]: unknown;\n};\n","/**\n * Type calculator for generating TypeScript type strings from field selections.\n *\n * This is a runtime reimplementation of the InferFields type-level computation,\n * used for generating prebuilt types that can be bundled without losing type information.\n *\n * @module\n */\n\nimport { Kind, type TypeNode, type VariableDefinitionNode } from \"graphql\";\nimport type { AnyFieldSelection, AnyFieldsExtended, AnyFieldValue, AnyNestedUnion } from \"../types/fragment\";\nimport type { AnyGraphqlSchema } from \"../types/schema\";\nimport type { InputDepthOverrides, InputTypeSpecifier, InputTypeSpecifiers, TypeModifier } from \"../types/type-foundation\";\n\n/**\n * Formatters for customizing type name output.\n *\n * Used by type generation functions to format scalar and input object type names\n * with custom prefixes or patterns (e.g., schema-specific prefixes).\n */\nexport type TypeFormatters = {\n  /**\n   * Format a scalar input type name.\n   * Default: `ScalarInput<\"Name\">`\n   */\n  readonly scalarInput?: (name: string) => string;\n  /**\n   * Format a scalar output type name.\n   * Default: `ScalarOutput<\"Name\">`\n   */\n  readonly scalarOutput?: (name: string) => string;\n  /**\n   * Format an input object type name.\n   * Default: returns the name unchanged\n   */\n  readonly inputObject?: (name: string) => string;\n};\n\n/**\n * Apply a type modifier to a base type string.\n *\n * Modifier format:\n * - \"!\" = required (T)\n * - \"?\" = optional (T | null | undefined)\n * - \"![]!\" = required array of required items (T[])\n * - \"![]?\" = optional array of required items (T[] | null | undefined)\n * - \"?[]!\" = required array of optional items ((T | null | undefined)[])\n * - \"?[]?\" = optional array of optional items ((T | null | undefined)[] | null | undefined)\n * - Deeper nesting follows the same pattern\n */\nexport const applyTypeModifier = (baseType: string, modifier: TypeModifier): string => {\n  // Parse modifier from inside out\n  // Modifier format: innerNullability[]outerNullability[]...\n  // e.g., \"?[]!\" means: inner is nullable, wrapped in non-null array\n\n  if (modifier === \"!\") {\n    return baseType;\n  }\n  if (modifier === \"?\") {\n    return `(${baseType} | null | undefined)`;\n  }\n\n  // For array types, parse the modifier pattern\n  // Pattern: (innerNullability)([]outerNullability)*\n  const parts = modifier.split(\"[]\");\n  if (parts.length < 2) {\n    // Fallback for unexpected modifier format\n    return baseType;\n  }\n\n  // Build type from inside out\n  let result = baseType;\n\n  // First part is the innermost nullability\n  const innerNullability = parts[0];\n  if (innerNullability === \"?\") {\n    result = `(${result} | null | undefined)`;\n  }\n\n  // Remaining parts are array wrappings with their nullability\n  for (let i = 1; i < parts.length; i++) {\n    const arrayNullability = parts[i];\n    result = `(${result})[]`;\n    if (arrayNullability === \"?\") {\n      result = `(${result} | null | undefined)`;\n    }\n  }\n\n  return result;\n};\n\n/**\n * Get the TypeScript type string for a scalar output type from the schema.\n *\n * Returns a `ScalarOutput<\"Name\">` reference for all scalars in the schema.\n * The actual type is resolved at compile time from the inject file's scalar definitions.\n * This allows users to customize even built-in scalars (ID, String, etc.).\n */\nexport const getScalarOutputType = (schema: AnyGraphqlSchema, scalarName: string): string => {\n  // ALL scalars use ScalarOutput reference - inject file is the source of truth\n  if (schema.scalar[scalarName]) {\n    return `ScalarOutput<\"${scalarName}\">`;\n  }\n  // Unknown scalar not in schema\n  return \"unknown\";\n};\n\n/**\n * Get the TypeScript type string for a scalar input type from the schema.\n *\n * Returns a `ScalarInput<\"Name\">` reference for all scalars in the schema.\n * Used for input/variable types in operations.\n */\nexport const getScalarInputType = (schema: AnyGraphqlSchema, scalarName: string): string => {\n  if (schema.scalar[scalarName]) {\n    return `ScalarInput<\"${scalarName}\">`;\n  }\n  return \"unknown\";\n};\n\n/**\n * Get the TypeScript type string for an enum type from the schema.\n */\nexport const getEnumType = (schema: AnyGraphqlSchema, enumName: string): string => {\n  const enumDef = schema.enum[enumName];\n  if (!enumDef) {\n    return \"string\";\n  }\n\n  // Get enum values and create a union type\n  const values = Object.keys(enumDef.values);\n  if (values.length === 0) {\n    return \"never\";\n  }\n\n  return values.map((v) => `\"${v}\"`).join(\" | \");\n};\n\n/**\n * Default depth limit for input object type generation.\n */\nconst DEFAULT_INPUT_DEPTH = 3;\n\n/**\n * Options for generating input object types.\n */\nexport type GenerateInputObjectTypeOptions = {\n  /**\n   * Default depth limit for recursive types.\n   * @default 3\n   */\n  readonly defaultDepth?: number;\n  /**\n   * Per-type depth overrides.\n   */\n  readonly depthOverrides?: InputDepthOverrides;\n  /**\n   * Custom formatters for type names.\n   */\n  readonly formatters?: TypeFormatters;\n};\n\n/**\n * Generate a TypeScript type string for an input object type.\n *\n * Recursively expands fields using ScalarInput for scalars.\n * Returns `unknown` if depth is exhausted or circular reference is detected.\n *\n * @param schema - The GraphQL schema\n * @param inputName - The input object type name\n * @param options - Generation options including depth limits\n * @param seen - Set of already visited input names (for circular reference detection)\n * @param currentDepth - Current recursion depth\n */\nexport const generateInputObjectType = (\n  schema: AnyGraphqlSchema,\n  inputName: string,\n  options: GenerateInputObjectTypeOptions = {},\n  seen: Set<string> = new Set(),\n  currentDepth?: number,\n): string => {\n  const inputDef = schema.input[inputName];\n  if (!inputDef) {\n    return \"unknown\";\n  }\n\n  // Get depth limit for this type\n  const depthOverrides = options.depthOverrides ?? {};\n  const defaultDepth = options.defaultDepth ?? DEFAULT_INPUT_DEPTH;\n  const maxDepth = depthOverrides[inputName] ?? defaultDepth;\n\n  // Initialize or use current depth\n  const depth = currentDepth ?? maxDepth;\n\n  // Check depth exhaustion\n  if (depth <= 0) {\n    return \"unknown\";\n  }\n\n  // Check circular reference\n  if (seen.has(inputName)) {\n    return \"unknown\";\n  }\n\n  // Add to seen set for this branch\n  const newSeen = new Set(seen);\n  newSeen.add(inputName);\n\n  const fields = inputDef.fields;\n  const fieldEntries = Object.entries(fields);\n\n  if (fieldEntries.length === 0) {\n    return \"{}\";\n  }\n\n  const fieldTypes = fieldEntries.map(([fieldName, specifier]) => {\n    const fieldType = generateInputFieldType(schema, specifier, options, newSeen, depth - 1);\n    const isOptional = specifier.modifier === \"?\" || specifier.modifier.endsWith(\"?\");\n    const hasDefault = specifier.defaultValue != null;\n\n    // Fields with defaults or nullable fields are optional\n    if (hasDefault || isOptional) {\n      return `readonly ${fieldName}?: ${fieldType}`;\n    }\n    return `readonly ${fieldName}: ${fieldType}`;\n  });\n\n  return `{ ${fieldTypes.join(\"; \")} }`;\n};\n\n/**\n * Generate a TypeScript type string for an input field based on its specifier.\n */\nconst generateInputFieldType = (\n  schema: AnyGraphqlSchema,\n  specifier: { readonly kind: string; readonly name: string; readonly modifier: TypeModifier },\n  options: GenerateInputObjectTypeOptions,\n  seen: Set<string>,\n  depth: number,\n): string => {\n  let baseType: string;\n  const { formatters } = options;\n\n  switch (specifier.kind) {\n    case \"scalar\":\n      baseType = formatters?.scalarInput?.(specifier.name) ?? getScalarInputType(schema, specifier.name);\n      break;\n    case \"enum\":\n      baseType = getEnumType(schema, specifier.name);\n      break;\n    case \"input\":\n      baseType =\n        formatters?.inputObject?.(specifier.name) ?? generateInputObjectType(schema, specifier.name, options, seen, depth);\n      break;\n    default:\n      baseType = \"unknown\";\n  }\n\n  return applyTypeModifier(baseType, specifier.modifier);\n};\n\n/**\n * Calculate the TypeScript type string for a single field selection.\n *\n * @param schema - The GraphQL schema\n * @param selection - The field selection to calculate type for\n * @param formatters - Optional formatters for customizing type names\n */\nexport const calculateFieldType = (\n  schema: AnyGraphqlSchema,\n  selection: AnyFieldSelection,\n  formatters?: TypeFormatters,\n): string => {\n  const { type } = selection;\n\n  // Handle object types (nested selection)\n  if (type.kind === \"object\" && selection.object) {\n    const nestedType = calculateFieldsType(schema, selection.object, formatters, type.name);\n    return applyTypeModifier(nestedType, type.modifier);\n  }\n\n  // Handle union types\n  if (type.kind === \"union\" && selection.union) {\n    const unionType = calculateUnionType(schema, selection.union, formatters);\n    return applyTypeModifier(unionType, type.modifier);\n  }\n\n  // Handle __typename special field\n  if (type.kind === \"typename\") {\n    // __typename returns a string literal type\n    return applyTypeModifier(`\"${type.name}\"`, type.modifier);\n  }\n\n  // Handle scalar types\n  if (type.kind === \"scalar\") {\n    const scalarType = formatters?.scalarOutput?.(type.name) ?? getScalarOutputType(schema, type.name);\n    return applyTypeModifier(scalarType, type.modifier);\n  }\n\n  // Handle enum types\n  if (type.kind === \"enum\") {\n    const enumType = getEnumType(schema, type.name);\n    return applyTypeModifier(enumType, type.modifier);\n  }\n\n  // Fallback\n  return \"unknown\";\n};\n\n/**\n * Calculate the TypeScript type string for a union type selection.\n */\nconst calculateUnionType = (schema: AnyGraphqlSchema, union: AnyNestedUnion, formatters?: TypeFormatters): string => {\n  const memberTypes: string[] = [];\n\n  for (const [typeName, fields] of Object.entries(union)) {\n    if (fields) {\n      const memberType = calculateFieldsType(schema, fields, formatters, typeName);\n      memberTypes.push(memberType);\n    }\n  }\n\n  if (memberTypes.length === 0) {\n    return \"never\";\n  }\n\n  return memberTypes.join(\" | \");\n};\n\n/**\n * Check if a field value is shorthand (true) vs factory return (AnyFieldSelection).\n */\nconst isShorthandValue = (value: AnyFieldValue): value is true => value === true;\n\n/**\n * Expand shorthand to AnyFieldSelection using schema type info.\n * Used at prebuilt type generation time to convert `true` to full field selection.\n *\n * @param schema - The GraphQL schema\n * @param typeName - The parent object type name\n * @param fieldName - The field name to select\n */\nconst expandShorthandForType = (schema: AnyGraphqlSchema, typeName: string, fieldName: string): AnyFieldSelection => {\n  const typeDef = schema.object[typeName];\n  if (!typeDef) {\n    throw new Error(`Type \"${typeName}\" not found in schema`);\n  }\n\n  const fieldSpec = typeDef.fields[fieldName];\n  if (!fieldSpec) {\n    throw new Error(`Field \"${fieldName}\" not found on type \"${typeName}\"`);\n  }\n\n  return {\n    parent: typeName,\n    field: fieldName,\n    type: fieldSpec,\n    args: {},\n    directives: [],\n    object: null,\n    union: null,\n  };\n};\n\n/**\n * Calculate the TypeScript type string for a set of field selections.\n * This is the main entry point for type calculation.\n *\n * @param schema - The GraphQL schema\n * @param fields - The field selections to calculate types for\n * @param formatters - Optional formatters for customizing type names\n * @param typeName - Parent type name for shorthand expansion\n */\nexport const calculateFieldsType = (\n  schema: AnyGraphqlSchema,\n  fields: AnyFieldsExtended,\n  formatters?: TypeFormatters,\n  typeName?: string,\n): string => {\n  const entries = Object.entries(fields);\n\n  if (entries.length === 0) {\n    return \"{}\";\n  }\n\n  const fieldTypes = entries.map(([alias, value]) => {\n    let selection: AnyFieldSelection;\n    if (isShorthandValue(value)) {\n      if (!typeName) {\n        throw new Error(\n          `Shorthand syntax (${alias}: true) requires type context. ` +\n            `This is an internal error - type name should be provided.`,\n        );\n      }\n      selection = expandShorthandForType(schema, typeName, alias);\n    } else {\n      selection = value;\n    }\n    const fieldType = calculateFieldType(schema, selection, formatters);\n    // Use readonly for all fields to match InferFields behavior\n    return `readonly ${alias}: ${fieldType}`;\n  });\n\n  return `{ ${fieldTypes.join(\"; \")} }`;\n};\n\n/**\n * Convert a GraphQL TypeNode to a TypeScript type string for input types.\n *\n * Handles NonNullType, ListType, and NamedType recursively.\n * Uses ScalarInput for scalar types since this is used for input/variable types.\n *\n * @param schema - The GraphQL schema\n * @param typeNode - The GraphQL type node to convert\n * @param formatters - Optional formatters for customizing type names\n */\nexport const graphqlTypeToTypeScript = (schema: AnyGraphqlSchema, typeNode: TypeNode, formatters?: TypeFormatters): string => {\n  switch (typeNode.kind) {\n    case Kind.NON_NULL_TYPE:\n      return graphqlTypeToTypeScript(schema, typeNode.type, formatters);\n    case Kind.LIST_TYPE: {\n      const inner = graphqlTypeToTypeScript(schema, typeNode.type, formatters);\n      return `(${inner})[]`;\n    }\n    case Kind.NAMED_TYPE: {\n      const name = typeNode.name.value;\n      // Check if scalar - use ScalarInput for input types\n      if (schema.scalar[name]) {\n        return formatters?.scalarInput?.(name) ?? getScalarInputType(schema, name);\n      }\n      // Check if enum\n      if (schema.enum[name]) {\n        return getEnumType(schema, name);\n      }\n      // Input object - use formatter or return name directly\n      return formatters?.inputObject?.(name) ?? name;\n    }\n  }\n};\n\n/**\n * Generate a TypeScript type string for operation input variables.\n *\n * Extracts variable types from GraphQL VariableDefinitionNode AST.\n *\n * @param schema - The GraphQL schema\n * @param variableDefinitions - Variable definition nodes from the operation\n * @param formatters - Optional formatters for customizing type names\n */\nexport const generateInputType = (\n  schema: AnyGraphqlSchema,\n  variableDefinitions: readonly VariableDefinitionNode[],\n  formatters?: TypeFormatters,\n): string => {\n  if (variableDefinitions.length === 0) {\n    return \"{}\";\n  }\n\n  const fields = variableDefinitions.map((varDef) => {\n    const name = varDef.variable.name.value;\n    const isRequired = varDef.type.kind === Kind.NON_NULL_TYPE;\n    const tsType = graphqlTypeToTypeScript(schema, varDef.type, formatters);\n\n    // Apply nullability wrapper for optional fields\n    const finalType = isRequired ? tsType : `(${tsType} | null | undefined)`;\n    return `readonly ${name}${isRequired ? \"\" : \"?\"}: ${finalType}`;\n  });\n\n  return `{ ${fields.join(\"; \")} }`;\n};\n\n/**\n * Generate TypeScript type for a single input field from its specifier.\n * Used by generateInputTypeFromSpecifiers.\n */\nconst generateInputFieldTypeFromSpecifier = (\n  schema: AnyGraphqlSchema,\n  specifier: InputTypeSpecifier,\n  options: GenerateInputObjectTypeOptions,\n): string => {\n  let baseType: string;\n  const { formatters } = options;\n\n  switch (specifier.kind) {\n    case \"scalar\":\n      baseType = formatters?.scalarInput?.(specifier.name) ?? getScalarInputType(schema, specifier.name);\n      break;\n    case \"enum\":\n      baseType = getEnumType(schema, specifier.name);\n      break;\n    case \"input\":\n      baseType = formatters?.inputObject?.(specifier.name) ?? generateInputObjectType(schema, specifier.name, options);\n      break;\n    default:\n      baseType = \"unknown\";\n  }\n\n  return applyTypeModifier(baseType, specifier.modifier);\n};\n\n/**\n * Generate a TypeScript type string for input variables from InputTypeSpecifiers.\n *\n * Unlike generateInputType which works with GraphQL AST VariableDefinitionNode[],\n * this function works with soda-gql's internal InputTypeSpecifiers format.\n * Used for generating Fragment input types in prebuilt mode.\n *\n * @param schema - The GraphQL schema\n * @param specifiers - Input type specifiers (variable definitions)\n * @param options - Generation options including depth limits\n */\nexport const generateInputTypeFromSpecifiers = (\n  schema: AnyGraphqlSchema,\n  specifiers: InputTypeSpecifiers,\n  options: GenerateInputObjectTypeOptions = {},\n): string => {\n  const entries = Object.entries(specifiers);\n\n  if (entries.length === 0) {\n    return \"void\";\n  }\n\n  const fields = entries.map(([name, specifier]) => {\n    // Check if the outermost type is required\n    // \"!\" = required, \"?\" = optional\n    // \"![]!\" = required (outer), \"![]?\" = optional (outer)\n    // For arrays, check if the last character is \"!\" (required outer) or \"?\" (optional outer)\n    const isOuterRequired = specifier.modifier.endsWith(\"!\");\n    const hasDefault = specifier.defaultValue != null;\n    const baseType = generateInputFieldTypeFromSpecifier(schema, specifier, options);\n\n    // Field is optional if outer type is nullable or has default value\n    const isOptional = !isOuterRequired || hasDefault;\n\n    return `readonly ${name}${isOptional ? \"?\" : \"\"}: ${baseType}`;\n  });\n\n  return `{ ${fields.join(\"; \")} }`;\n};\n"],"mappings":"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"}