@soda-gql/builder 0.10.2 → 0.11.1

package/dist/index.cjs

@@ -1,3894 +1,182 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
+const require_service = require('./service-nHDX5qIj.cjs');
 let node_fs = require("node:fs");
-let node_fs_promises = require("node:fs/promises");
 let neverthrow = require("neverthrow");
-let zod = require("zod");
-let node_crypto = require("node:crypto");
 let node_path = require("node:path");
-let node_vm = require("node:vm");
-let __soda_gql_common = require("@soda-gql/common");
-let __swc_core = require("@swc/core");
 let __soda_gql_core = require("@soda-gql/core");
-__soda_gql_core = __toESM(__soda_gql_core);
-let __soda_gql_core_adapter = require("@soda-gql/core/adapter");
-__soda_gql_core_adapter = __toESM(__soda_gql_core_adapter);
-let __soda_gql_core_runtime = require("@soda-gql/core/runtime");
-__soda_gql_core_runtime = __toESM(__soda_gql_core_runtime);
-let __soda_gql_runtime = require("@soda-gql/runtime");
-__soda_gql_runtime = __toESM(__soda_gql_runtime);
 let graphql = require("graphql");
-let typescript = require("typescript");
-typescript = __toESM(typescript);
-let fast_glob = require("fast-glob");
-fast_glob = __toESM(fast_glob);
-
-//#region packages/builder/src/schemas/artifact.ts
-const BuilderArtifactElementMetadataSchema = zod.z.object({
-	sourcePath: zod.z.string(),
-	contentHash: zod.z.string()
-});
-const BuilderArtifactOperationSchema = zod.z.object({
-	id: zod.z.string(),
-	type: zod.z.literal("operation"),
-	metadata: BuilderArtifactElementMetadataSchema,
-	prebuild: zod.z.object({
-		operationType: zod.z.enum([
-			"query",
-			"mutation",
-			"subscription"
-		]),
-		operationName: zod.z.string(),
-		schemaLabel: zod.z.string(),
-		document: zod.z.unknown(),
-		variableNames: zod.z.array(zod.z.string())
-	})
-});
-const BuilderArtifactFragmentSchema = zod.z.object({
-	id: zod.z.string(),
-	type: zod.z.literal("fragment"),
-	metadata: BuilderArtifactElementMetadataSchema,
-	prebuild: zod.z.object({
-		typename: zod.z.string(),
-		key: zod.z.string().optional(),
-		schemaLabel: zod.z.string()
-	})
-});
-const BuilderArtifactElementSchema = zod.z.discriminatedUnion("type", [BuilderArtifactOperationSchema, BuilderArtifactFragmentSchema]);
-const BuilderArtifactMetaSchema = zod.z.object({
-	version: zod.z.string(),
-	createdAt: zod.z.string()
-});
-const BuilderArtifactSchema = zod.z.object({
-	meta: BuilderArtifactMetaSchema.optional(),
-	elements: zod.z.record(zod.z.string(), BuilderArtifactElementSchema),
-	report: zod.z.object({
-		durationMs: zod.z.number(),
-		warnings: zod.z.array(zod.z.string()),
-		stats: zod.z.object({
-			hits: zod.z.number(),
-			misses: zod.z.number(),
-			skips: zod.z.number()
-		})
-	})
-});
 
-//#endregion
-//#region packages/builder/src/artifact/loader.ts
+//#region packages/builder/src/prebuilt/extractor.ts
 /**
-* Load a pre-built artifact from a JSON file asynchronously.
+* Extract field selections from evaluated intermediate elements.
 *
-* @param path - Absolute path to the artifact JSON file
-* @returns Result with the parsed artifact or an error
+* For fragments, calls `spread()` with empty/default variables to get field selections.
+* For operations, calls `documentSource()` to get field selections.
 *
-* @example
-* ```ts
-* const result = await loadArtifact("/path/to/artifact.json");
-* if (result.isOk()) {
-*   const artifact = result.value;
-*   // Use artifact...
-* }
-* ```
+* @param elements - Record of canonical ID to intermediate artifact element
+* @returns Object containing selections map and any warnings encountered
 */
-const loadArtifact = async (path) => {
-	if (!(0, node_fs.existsSync)(path)) {
-		return (0, neverthrow.err)({
-			code: "ARTIFACT_NOT_FOUND",
-			message: `Artifact file not found: ${path}`,
-			filePath: path
-		});
-	}
-	let content;
-	try {
-		content = await (0, node_fs_promises.readFile)(path, "utf-8");
-	} catch (error) {
-		return (0, neverthrow.err)({
-			code: "ARTIFACT_NOT_FOUND",
-			message: `Failed to read artifact file: ${error instanceof Error ? error.message : String(error)}`,
-			filePath: path
-		});
+const extractFieldSelections = (elements) => {
+	const selections = new Map();
+	const warnings = [];
+	for (const [id, element] of Object.entries(elements)) {
+		const canonicalId = id;
+		try {
+			if (element.type === "fragment") {
+				const variableDefinitions = element.element.variableDefinitions;
+				const varRefs = Object.fromEntries(Object.keys(variableDefinitions).map((k) => [k, (0, __soda_gql_core.createVarRefFromVariable)(k)]));
+				const fields = element.element.spread(varRefs);
+				selections.set(canonicalId, {
+					type: "fragment",
+					schemaLabel: element.element.schemaLabel,
+					key: element.element.key,
+					typename: element.element.typename,
+					fields,
+					variableDefinitions
+				});
+			} else if (element.type === "operation") {
+				const fields = element.element.documentSource();
+				const document = element.element.document;
+				const operationDef = document.definitions.find((def) => def.kind === graphql.Kind.OPERATION_DEFINITION);
+				const variableDefinitions = operationDef?.variableDefinitions ?? [];
+				selections.set(canonicalId, {
+					type: "operation",
+					schemaLabel: element.element.schemaLabel,
+					operationName: element.element.operationName,
+					operationType: element.element.operationType,
+					fields,
+					variableDefinitions
+				});
+			}
+		} catch (error) {
+			warnings.push(`[prebuilt] Failed to extract field selections for ${canonicalId}: ${error instanceof Error ? error.message : String(error)}`);
+		}
 	}
-	return parseAndValidateArtifact(content, path);
+	return {
+		selections,
+		warnings
+	};
 };
+
+//#endregion
+//#region packages/builder/src/schema-loader.ts
+/**
+* Schema loader for CJS bundle evaluation.
+*
+* Loads AnyGraphqlSchema from the generated CJS bundle by accessing
+* the `$schema` property on each gql composer.
+*
+* @module
+*/
 /**
-* Load a pre-built artifact from a JSON file synchronously.
+* Load AnyGraphqlSchema from a generated CJS bundle.
+*
+* The generated CJS bundle exports a `gql` object where each property
+* is a GQL element composer with a `$schema` property containing the
+* schema definition. This function executes the bundle in a VM context
+* and extracts those schemas.
 *
-* @param path - Absolute path to the artifact JSON file
-* @returns Result with the parsed artifact or an error
+* @param cjsPath - Absolute path to the CJS bundle file
+* @param schemaNames - Names of schemas to load (e.g., ["default", "admin"])
+* @returns Record mapping schema names to AnyGraphqlSchema objects
 *
 * @example
-* ```ts
-* const result = loadArtifactSync("/path/to/artifact.json");
+* ```typescript
+* const result = loadSchemasFromBundle(
+*   "/path/to/generated/index.cjs",
+*   ["default"]
+* );
+*
 * if (result.isOk()) {
-*   const artifact = result.value;
-*   // Use artifact...
+*   const schemas = result.value;
+*   console.log(schemas.default); // AnyGraphqlSchema
 * }
 * ```
 */
-const loadArtifactSync = (path) => {
-	if (!(0, node_fs.existsSync)(path)) {
+const loadSchemasFromBundle = (cjsPath, schemaNames) => {
+	const resolvedPath = (0, node_path.resolve)(cjsPath);
+	if (!(0, node_fs.existsSync)(resolvedPath)) {
 		return (0, neverthrow.err)({
-			code: "ARTIFACT_NOT_FOUND",
-			message: `Artifact file not found: ${path}`,
-			filePath: path
+			code: "CONFIG_NOT_FOUND",
+			message: `CJS bundle not found: ${resolvedPath}. Run 'soda-gql codegen' first.`,
+			path: resolvedPath
 		});
 	}
-	let content;
+	let bundledCode;
 	try {
-		content = (0, node_fs.readFileSync)(path, "utf-8");
+		bundledCode = (0, node_fs.readFileSync)(resolvedPath, "utf-8");
 	} catch (error) {
 		return (0, neverthrow.err)({
-			code: "ARTIFACT_NOT_FOUND",
-			message: `Failed to read artifact file: ${error instanceof Error ? error.message : String(error)}`,
-			filePath: path
+			code: "DISCOVERY_IO_ERROR",
+			message: `Failed to read CJS bundle: ${error instanceof Error ? error.message : String(error)}`,
+			path: resolvedPath,
+			cause: error
 		});
 	}
-	return parseAndValidateArtifact(content, path);
-};
-/**
-* Parse JSON content and validate against BuilderArtifactSchema.
-*/
-function parseAndValidateArtifact(content, filePath) {
-	let parsed;
+	let finalExports;
 	try {
-		parsed = JSON.parse(content);
+		finalExports = require_service.executeSandbox(bundledCode, resolvedPath);
 	} catch (error) {
 		return (0, neverthrow.err)({
-			code: "ARTIFACT_PARSE_ERROR",
-			message: `Invalid JSON in artifact file: ${error instanceof Error ? error.message : String(error)}`,
-			filePath
+			code: "RUNTIME_MODULE_LOAD_FAILED",
+			message: `Failed to execute CJS bundle: ${error instanceof Error ? error.message : String(error)}`,
+			filePath: resolvedPath,
+			astPath: "",
+			cause: error
 		});
 	}
-	const validated = BuilderArtifactSchema.safeParse(parsed);
-	if (!validated.success) {
+	const gql = finalExports.gql;
+	if (!gql || typeof gql !== "object") {
 		return (0, neverthrow.err)({
-			code: "ARTIFACT_VALIDATION_ERROR",
-			message: `Invalid artifact structure: ${validated.error.message}`,
-			filePath
+			code: "CONFIG_INVALID",
+			message: "CJS bundle does not export 'gql' object. Ensure codegen was run successfully.",
+			path: resolvedPath
 		});
 	}
-	return (0, neverthrow.ok)(validated.data);
-}
-
-//#endregion
-//#region packages/builder/src/errors.ts
-/**
-* Error constructor helpers for concise error creation.
-*/
-const builderErrors = {
-	entryNotFound: (entry, message) => ({
-		code: "ENTRY_NOT_FOUND",
-		message: message ?? `Entry not found: ${entry}`,
-		entry
-	}),
-	configNotFound: (path, message) => ({
-		code: "CONFIG_NOT_FOUND",
-		message: message ?? `Config file not found: ${path}`,
-		path
-	}),
-	configInvalid: (path, message, cause) => ({
-		code: "CONFIG_INVALID",
-		message,
-		path,
-		cause
-	}),
-	discoveryIOError: (path, message, errno, cause) => ({
-		code: "DISCOVERY_IO_ERROR",
-		message,
-		path,
-		errno,
-		cause
-	}),
-	fingerprintFailed: (filePath, message, cause) => ({
-		code: "FINGERPRINT_FAILED",
-		message,
-		filePath,
-		cause
-	}),
-	unsupportedAnalyzer: (analyzer, message) => ({
-		code: "UNSUPPORTED_ANALYZER",
-		message: message ?? `Unsupported analyzer: ${analyzer}`,
-		analyzer
-	}),
-	canonicalPathInvalid: (path, reason) => ({
-		code: "CANONICAL_PATH_INVALID",
-		message: `Invalid canonical path: ${path}${reason ? ` (${reason})` : ""}`,
-		path,
-		reason
-	}),
-	canonicalScopeMismatch: (expected, actual) => ({
-		code: "CANONICAL_SCOPE_MISMATCH",
-		message: `Scope mismatch: expected ${expected}, got ${actual}`,
-		expected,
-		actual
-	}),
-	graphCircularDependency: (chain) => ({
-		code: "GRAPH_CIRCULAR_DEPENDENCY",
-		message: `Circular dependency detected: ${chain.join(" → ")}`,
-		chain
-	}),
-	graphMissingImport: (importer, importee) => ({
-		code: "GRAPH_MISSING_IMPORT",
-		message: `Missing import: "${importer}" imports "${importee}" but it's not in the graph`,
-		importer,
-		importee
-	}),
-	docDuplicate: (name, sources) => ({
-		code: "DOC_DUPLICATE",
-		message: `Duplicate document name: ${name} found in ${sources.length} files`,
-		name,
-		sources
-	}),
-	writeFailed: (outPath, message, cause) => ({
-		code: "WRITE_FAILED",
-		message,
-		outPath,
-		cause
-	}),
-	cacheCorrupted: (message, cachePath, cause) => ({
-		code: "CACHE_CORRUPTED",
-		message,
-		cachePath,
-		cause
-	}),
-	runtimeModuleLoadFailed: (filePath, astPath, message, cause) => ({
-		code: "RUNTIME_MODULE_LOAD_FAILED",
-		message,
-		filePath,
-		astPath,
-		cause
-	}),
-	artifactRegistrationFailed: (elementId, reason) => ({
-		code: "ARTIFACT_REGISTRATION_FAILED",
-		message: `Failed to register artifact element ${elementId}: ${reason}`,
-		elementId,
-		reason
-	}),
-	elementEvaluationFailed: (modulePath, astPath, message, cause) => ({
-		code: "ELEMENT_EVALUATION_FAILED",
-		message,
-		modulePath,
-		astPath,
-		cause
-	}),
-	internalInvariant: (message, context, cause) => ({
-		code: "INTERNAL_INVARIANT",
-		message: `Internal invariant violated: ${message}`,
-		context,
-		cause
-	}),
-	schemaNotFound: (schemaLabel, canonicalId) => ({
-		code: "SCHEMA_NOT_FOUND",
-		message: `Schema not found for label "${schemaLabel}" (element: ${canonicalId})`,
-		schemaLabel,
-		canonicalId
-	})
-};
-/**
-* Convenience helper to create an err Result from BuilderError.
-*/
-const builderErr = (error) => (0, neverthrow.err)(error);
-/**
-* Type guard for BuilderError.
-*/
-const isBuilderError = (error) => {
-	return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" && "message" in error && typeof error.message === "string";
-};
-/**
-* Format BuilderError for console output (human-readable).
-*/
-const formatBuilderError = (error) => {
-	const lines = [];
-	lines.push(`Error [${error.code}]: ${error.message}`);
-	switch (error.code) {
-		case "ENTRY_NOT_FOUND":
-			lines.push(`  Entry: ${error.entry}`);
-			break;
-		case "CONFIG_NOT_FOUND":
-		case "CONFIG_INVALID":
-			lines.push(`  Path: ${error.path}`);
-			if (error.code === "CONFIG_INVALID" && error.cause) {
-				lines.push(`  Cause: ${error.cause}`);
-			}
-			break;
-		case "DISCOVERY_IO_ERROR":
-			lines.push(`  Path: ${error.path}`);
-			if (error.errno !== undefined) {
-				lines.push(`  Errno: ${error.errno}`);
-			}
-			break;
-		case "FINGERPRINT_FAILED":
-			lines.push(`  File: ${error.filePath}`);
-			break;
-		case "CANONICAL_PATH_INVALID":
-			lines.push(`  Path: ${error.path}`);
-			if (error.reason) {
-				lines.push(`  Reason: ${error.reason}`);
-			}
-			break;
-		case "CANONICAL_SCOPE_MISMATCH":
-			lines.push(`  Expected: ${error.expected}`);
-			lines.push(`  Actual: ${error.actual}`);
-			break;
-		case "GRAPH_CIRCULAR_DEPENDENCY":
-			lines.push(`  Chain: ${error.chain.join(" → ")}`);
-			break;
-		case "GRAPH_MISSING_IMPORT":
-			lines.push(`  Importer: ${error.importer}`);
-			lines.push(`  Importee: ${error.importee}`);
-			break;
-		case "DOC_DUPLICATE":
-			lines.push(`  Name: ${error.name}`);
-			lines.push(`  Sources:\n    ${error.sources.join("\n    ")}`);
-			break;
-		case "WRITE_FAILED":
-			lines.push(`  Output path: ${error.outPath}`);
-			break;
-		case "CACHE_CORRUPTED":
-			if (error.cachePath) {
-				lines.push(`  Cache path: ${error.cachePath}`);
-			}
-			break;
-		case "RUNTIME_MODULE_LOAD_FAILED":
-			lines.push(`  File: ${error.filePath}`);
-			lines.push(`  AST path: ${error.astPath}`);
-			break;
-		case "ARTIFACT_REGISTRATION_FAILED":
-			lines.push(`  Element ID: ${error.elementId}`);
-			lines.push(`  Reason: ${error.reason}`);
-			break;
-		case "ELEMENT_EVALUATION_FAILED":
-			lines.push(`  at ${error.modulePath}`);
-			if (error.astPath) {
-				lines.push(`  in ${error.astPath}`);
-			}
-			break;
-		case "INTERNAL_INVARIANT":
-			if (error.context) {
-				lines.push(`  Context: ${error.context}`);
-			}
-			break;
-		case "SCHEMA_NOT_FOUND":
-			lines.push(`  Schema label: ${error.schemaLabel}`);
-			lines.push(`  Element: ${error.canonicalId}`);
-			break;
-	}
-	if ("cause" in error && error.cause && !["CONFIG_INVALID"].includes(error.code)) {
-		lines.push(`  Caused by: ${error.cause}`);
-	}
-	return lines.join("\n");
-};
-/**
-* Assert unreachable code path (for exhaustiveness checks).
-* This is the ONLY acceptable throw in builder code.
-*/
-const assertUnreachable = (value, context) => {
-	throw new Error(`Unreachable code path${context ? ` in ${context}` : ""}: received ${JSON.stringify(value)}`);
-};
-
-//#endregion
-//#region packages/builder/src/errors/formatter.ts
-/**
-* Hints for each error code to help users understand and fix issues.
-*/
-const errorHints = {
-	ELEMENT_EVALUATION_FAILED: "Check if all imported fragments are properly exported and included in entry patterns.",
-	GRAPH_CIRCULAR_DEPENDENCY: "Break the circular import by extracting shared types to a common module.",
-	GRAPH_MISSING_IMPORT: "Verify the import path exists and the module is included in entry patterns.",
-	RUNTIME_MODULE_LOAD_FAILED: "Ensure the module can be imported and all dependencies are installed.",
-	CONFIG_NOT_FOUND: "Create a soda-gql.config.ts file in your project root.",
-	CONFIG_INVALID: "Check your configuration file for syntax errors or invalid options.",
-	ENTRY_NOT_FOUND: "Verify the entry pattern matches your file structure.",
-	INTERNAL_INVARIANT: "This is an internal error. Please report it at https://github.com/soda-gql/soda-gql/issues"
-};
-/**
-* Format a BuilderError into a structured FormattedError object.
-*/
-const formatBuilderErrorStructured = (error) => {
-	const base = {
-		code: error.code,
-		message: error.message,
-		hint: errorHints[error.code],
-		cause: "cause" in error ? error.cause : undefined
-	};
-	switch (error.code) {
-		case "ELEMENT_EVALUATION_FAILED": return {
-			...base,
-			location: {
-				modulePath: error.modulePath,
-				astPath: error.astPath || undefined
-			}
-		};
-		case "RUNTIME_MODULE_LOAD_FAILED": return {
-			...base,
-			location: {
-				modulePath: error.filePath,
-				astPath: error.astPath
-			}
-		};
-		case "GRAPH_MISSING_IMPORT": return {
-			...base,
-			relatedFiles: [error.importer, error.importee]
-		};
-		case "GRAPH_CIRCULAR_DEPENDENCY": return {
-			...base,
-			relatedFiles: error.chain
-		};
-		case "CONFIG_NOT_FOUND":
-		case "CONFIG_INVALID": return {
-			...base,
-			location: { modulePath: error.path }
-		};
-		case "FINGERPRINT_FAILED": return {
-			...base,
-			location: { modulePath: error.filePath }
-		};
-		case "DISCOVERY_IO_ERROR": return {
-			...base,
-			location: { modulePath: error.path }
-		};
-		default: return base;
-	}
-};
-/**
-* Format a BuilderError for CLI/stderr output with human-readable formatting.
-* Includes location, hint, and related files when available.
-*/
-const formatBuilderErrorForCLI = (error) => {
-	const formatted = formatBuilderErrorStructured(error);
-	const lines = [];
-	lines.push(`Error [${formatted.code}]: ${formatted.message}`);
-	if (formatted.location) {
-		lines.push(`  at ${formatted.location.modulePath}`);
-		if (formatted.location.astPath) {
-			lines.push(`  in ${formatted.location.astPath}`);
-		}
-	}
-	if (formatted.hint) {
-		lines.push("");
-		lines.push(`  Hint: ${formatted.hint}`);
-	}
-	if (formatted.relatedFiles && formatted.relatedFiles.length > 0) {
-		lines.push("");
-		lines.push("  Related files:");
-		for (const file of formatted.relatedFiles) {
-			lines.push(`    - ${file}`);
-		}
-	}
-	return lines.join("\n");
-};
-
-//#endregion
-//#region packages/builder/src/scheduler/effects.ts
-/**
-* File read effect - reads a file from the filesystem.
-* Works in both sync and async schedulers.
-*
-* @example
-* const content = yield* new FileReadEffect("/path/to/file").run();
-*/
-var FileReadEffect = class extends __soda_gql_common.Effect {
-	constructor(path) {
-		super();
-		this.path = path;
-	}
-	_executeSync() {
-		return (0, node_fs.readFileSync)(this.path, "utf-8");
-	}
-	_executeAsync() {
-		return (0, node_fs_promises.readFile)(this.path, "utf-8");
-	}
-};
-/**
-* File stat effect - gets file stats from the filesystem.
-* Works in both sync and async schedulers.
-*
-* @example
-* const stats = yield* new FileStatEffect("/path/to/file").run();
-*/
-var FileStatEffect = class extends __soda_gql_common.Effect {
-	constructor(path) {
-		super();
-		this.path = path;
-	}
-	_executeSync() {
-		const stats = (0, node_fs.statSync)(this.path);
-		return {
-			mtimeMs: stats.mtimeMs,
-			size: stats.size,
-			isFile: stats.isFile()
-		};
-	}
-	async _executeAsync() {
-		const stats = await (0, node_fs_promises.stat)(this.path);
-		return {
-			mtimeMs: stats.mtimeMs,
-			size: stats.size,
-			isFile: stats.isFile()
-		};
-	}
-};
-/**
-* File read effect that returns null if file doesn't exist.
-* Useful for discovery where missing files are expected.
-*/
-var OptionalFileReadEffect = class extends __soda_gql_common.Effect {
-	constructor(path) {
-		super();
-		this.path = path;
-	}
-	_executeSync() {
-		try {
-			return (0, node_fs.readFileSync)(this.path, "utf-8");
-		} catch (error) {
-			if (error.code === "ENOENT") {
-				return null;
-			}
-			throw error;
-		}
-	}
-	async _executeAsync() {
-		try {
-			return await (0, node_fs_promises.readFile)(this.path, "utf-8");
-		} catch (error) {
-			if (error.code === "ENOENT") {
-				return null;
-			}
-			throw error;
-		}
-	}
-};
-/**
-* File stat effect that returns null if file doesn't exist.
-* Useful for discovery where missing files are expected.
-*/
-var OptionalFileStatEffect = class extends __soda_gql_common.Effect {
-	constructor(path) {
-		super();
-		this.path = path;
-	}
-	_executeSync() {
-		try {
-			const stats = (0, node_fs.statSync)(this.path);
-			return {
-				mtimeMs: stats.mtimeMs,
-				size: stats.size,
-				isFile: stats.isFile()
-			};
-		} catch (error) {
-			if (error.code === "ENOENT") {
-				return null;
-			}
-			throw error;
-		}
-	}
-	async _executeAsync() {
-		try {
-			const stats = await (0, node_fs_promises.stat)(this.path);
-			return {
-				mtimeMs: stats.mtimeMs,
-				size: stats.size,
-				isFile: stats.isFile()
-			};
-		} catch (error) {
-			if (error.code === "ENOENT") {
-				return null;
-			}
-			throw error;
-		}
-	}
-};
-/**
-* Element evaluation effect - evaluates a GqlElement using its generator.
-* Supports both sync and async schedulers, enabling parallel element evaluation
-* when using async scheduler.
-*
-* Wraps errors with module context for better debugging.
-*
-* @example
-* yield* new ElementEvaluationEffect(element).run();
-*/
-var ElementEvaluationEffect = class extends __soda_gql_common.Effect {
-	constructor(element) {
-		super();
-		this.element = element;
-	}
-	/**
-	* Wrap an error with element context for better debugging.
-	*/
-	wrapError(error) {
-		const context = __soda_gql_core.GqlElement.getContext(this.element);
-		if (context) {
-			const { filePath, astPath } = (0, __soda_gql_common.parseCanonicalId)(context.canonicalId);
-			const message = error instanceof Error ? error.message : String(error);
-			throw builderErrors.elementEvaluationFailed(filePath, astPath, message, error);
-		}
-		throw error;
-	}
-	_executeSync() {
-		try {
-			const generator = __soda_gql_core.GqlElement.createEvaluationGenerator(this.element);
-			const result = generator.next();
-			while (!result.done) {
-				throw new Error("Async operation required during sync element evaluation");
-			}
-		} catch (error) {
-			this.wrapError(error);
+	const schemas = {};
+	for (const name of schemaNames) {
+		const composer = gql[name];
+		if (!composer) {
+			const availableSchemas = Object.keys(gql).join(", ");
+			return (0, neverthrow.err)({
+				code: "SCHEMA_NOT_FOUND",
+				message: `Schema '${name}' not found in gql exports. Available: ${availableSchemas || "(none)"}`,
+				schemaLabel: name,
+				canonicalId: `gql.${name}`
+			});
 		}
-	}
-	async _executeAsync() {
-		try {
-			const generator = __soda_gql_core.GqlElement.createEvaluationGenerator(this.element);
-			let result = generator.next();
-			while (!result.done) {
-				await result.value;
-				result = generator.next();
-			}
-		} catch (error) {
-			this.wrapError(error);
+		const schema = composer.$schema;
+		if (!schema || typeof schema !== "object") {
+			return (0, neverthrow.err)({
+				code: "CONFIG_INVALID",
+				message: `gql.${name}.$schema is not a valid schema object. Ensure codegen version is up to date.`,
+				path: resolvedPath
+			});
 		}
+		schemas[name] = schema;
 	}
-};
-/**
-* Builder effect constructors.
-* Extends the base Effects with file I/O operations and element evaluation.
-*/
-const BuilderEffects = {
-	...__soda_gql_common.Effects,
-	readFile: (path) => new FileReadEffect(path),
-	stat: (path) => new FileStatEffect(path),
-	readFileOptional: (path) => new OptionalFileReadEffect(path),
-	statOptional: (path) => new OptionalFileStatEffect(path),
-	evaluateElement: (element) => new ElementEvaluationEffect(element)
-};
-
-//#endregion
-//#region packages/builder/src/vm/sandbox.ts
-/**
-* VM sandbox utilities for CJS bundle evaluation.
-*
-* Provides shared infrastructure for executing CommonJS modules
-* in a sandboxed VM context with @soda-gql package mocking.
-*
-* @module
-*/
-/**
-* Create a require function for the sandbox.
-* Maps @soda-gql package imports to their actual modules.
-*/
-const createSandboxRequire = () => (path) => {
-	if (path === "@soda-gql/core") return __soda_gql_core;
-	if (path === "@soda-gql/core/adapter") return __soda_gql_core_adapter;
-	if (path === "@soda-gql/core/runtime") return __soda_gql_core_runtime;
-	if (path === "@soda-gql/runtime") return __soda_gql_runtime;
-	throw new Error(`Unknown module: ${path}`);
-};
-/**
-* Create a VM sandbox for executing CJS bundles.
-*
-* Sets up:
-* - require() handler for @soda-gql packages
-* - module.exports and exports pointing to the same object
-* - __dirname, __filename for path resolution
-* - global and globalThis pointing to the sandbox itself
-*
-* @param modulePath - Absolute path to the module being executed
-* @param additionalContext - Optional additional context properties
-* @returns Configured sandbox object
-*/
-const createSandbox = (modulePath, additionalContext) => {
-	const moduleExports = {};
-	const sandbox = {
-		require: createSandboxRequire(),
-		module: { exports: moduleExports },
-		exports: moduleExports,
-		__dirname: (0, node_path.resolve)(modulePath, ".."),
-		__filename: modulePath,
-		global: undefined,
-		globalThis: undefined,
-		...additionalContext
-	};
-	sandbox.global = sandbox;
-	sandbox.globalThis = sandbox;
-	return sandbox;
-};
-/**
-* Execute CJS code in a sandbox and return the exports.
-*
-* Note: Reads from sandbox.module.exports because esbuild CJS output
-* reassigns module.exports via __toCommonJS(), replacing the original object.
-*
-* @param code - The CJS code to execute
-* @param modulePath - Absolute path to the module (for error messages)
-* @param additionalContext - Optional additional context properties
-* @returns The module's exports object
-*/
-const executeSandbox = (code, modulePath, additionalContext) => {
-	const sandbox = createSandbox(modulePath, additionalContext);
-	const context = (0, node_vm.createContext)(sandbox);
-	new node_vm.Script(code, { filename: modulePath }).runInContext(context);
-	return sandbox.module.exports;
-};
-
-//#endregion
-//#region packages/builder/src/intermediate-module/codegen.ts
-const formatFactory = (expression) => {
-	const trimmed = expression.trim();
-	if (!trimmed.includes("\n")) {
-		return trimmed;
-	}
-	const lines = trimmed.split("\n").map((line) => line.trimEnd());
-	const indented = lines.map((line, index) => index === 0 ? line : `    ${line}`).join("\n");
-	return `(\n    ${indented}\n  )`;
-};
-const buildTree = (definitions) => {
-	const roots = new Map();
-	definitions.forEach((definition) => {
-		const parts = definition.astPath.split(".");
-		const expressionText = definition.expression.trim();
-		if (parts.length === 1) {
-			const rootName = parts[0];
-			if (rootName) {
-				roots.set(rootName, {
-					expression: expressionText,
-					canonicalId: definition.canonicalId,
-					children: new Map()
-				});
-			}
-		} else {
-			const rootName = parts[0];
-			if (!rootName) return;
-			let root = roots.get(rootName);
-			if (!root) {
-				root = { children: new Map() };
-				roots.set(rootName, root);
-			}
-			let current = root;
-			for (let i = 1; i < parts.length - 1; i++) {
-				const part = parts[i];
-				if (!part) continue;
-				let child = current.children.get(part);
-				if (!child) {
-					child = { children: new Map() };
-					current.children.set(part, child);
-				}
-				current = child;
-			}
-			const leafName = parts[parts.length - 1];
-			if (leafName) {
-				current.children.set(leafName, {
-					expression: expressionText,
-					canonicalId: definition.canonicalId,
-					children: new Map()
-				});
-			}
-		}
-	});
-	return roots;
-};
-/**
-* Check if a string is a valid JavaScript identifier
-*/
-const isValidIdentifier = (name) => {
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) && !isReservedWord(name);
-};
-/**
-* Check if a string is a JavaScript reserved word
-*/
-const isReservedWord = (name) => {
-	const reserved = new Set([
-		"break",
-		"case",
-		"catch",
-		"class",
-		"const",
-		"continue",
-		"debugger",
-		"default",
-		"delete",
-		"do",
-		"else",
-		"export",
-		"extends",
-		"finally",
-		"for",
-		"function",
-		"if",
-		"import",
-		"in",
-		"instanceof",
-		"new",
-		"return",
-		"super",
-		"switch",
-		"this",
-		"throw",
-		"try",
-		"typeof",
-		"var",
-		"void",
-		"while",
-		"with",
-		"yield",
-		"let",
-		"static",
-		"enum",
-		"await",
-		"implements",
-		"interface",
-		"package",
-		"private",
-		"protected",
-		"public"
-	]);
-	return reserved.has(name);
-};
-/**
-* Format a key for use in an object literal
-* Invalid identifiers are quoted, valid ones are not
-*/
-const formatObjectKey = (key) => {
-	return isValidIdentifier(key) ? key : `"${key}"`;
-};
-const renderTreeNode = (node, indent) => {
-	if (node.expression && node.children.size === 0 && node.canonicalId) {
-		const expr = formatFactory(node.expression);
-		return `registry.addElement("${node.canonicalId}", () => ${expr})`;
-	}
-	const indentStr = "  ".repeat(indent);
-	const entries = Array.from(node.children.entries()).map(([key, child]) => {
-		const value = renderTreeNode(child, indent + 1);
-		const formattedKey = formatObjectKey(key);
-		return `${indentStr}  ${formattedKey}: ${value},`;
-	});
-	if (entries.length === 0) {
-		return "{}";
-	}
-	return `{\n${entries.join("\n")}\n${indentStr}}`;
-};
-const buildNestedObject = (definition) => {
-	const tree = buildTree(definition);
-	const declarations = [];
-	const returnEntries = [];
-	tree.forEach((node, rootName) => {
-		if (node.children.size > 0) {
-			const objectLiteral = renderTreeNode(node, 2);
-			declarations.push(`    const ${rootName} = ${objectLiteral};`);
-			returnEntries.push(rootName);
-		} else if (node.expression && node.canonicalId) {
-			const expr = formatFactory(node.expression);
-			declarations.push(`    const ${rootName} = registry.addElement("${node.canonicalId}", () => ${expr});`);
-			returnEntries.push(rootName);
-		}
-	});
-	const returnStatement = returnEntries.length > 0 ? `    return {\n${returnEntries.map((name) => `        ${name},`).join("\n")}\n    };` : "    return {};";
-	if (declarations.length === 0) {
-		return returnStatement;
-	}
-	return `${declarations.join("\n")}\n${returnStatement}`;
-};
-/**
-* Render import statements for the intermediate module using ModuleSummary.
-* Only includes imports from modules that have gql exports.
-*/
-const renderImportStatements = ({ filePath, analysis, analyses, graphqlSystemPath }) => {
-	const importLines = [];
-	const importedRootNames = new Set();
-	const namespaceImports = new Set();
-	const importsByFile = new Map();
-	analysis.imports.forEach((imp) => {
-		if (imp.isTypeOnly) {
-			return;
-		}
-		if (!imp.source.startsWith(".")) {
-			return;
-		}
-		const resolvedPath = (0, __soda_gql_common.resolveRelativeImportWithReferences)({
-			filePath,
-			specifier: imp.source,
-			references: analyses
-		});
-		if (!resolvedPath) {
-			return;
-		}
-		if (resolvedPath === graphqlSystemPath) {
-			return;
-		}
-		const imports = importsByFile.get(resolvedPath) ?? [];
-		imports.push(imp);
-		importsByFile.set(resolvedPath, imports);
-	});
-	importsByFile.forEach((imports, filePath$1) => {
-		const namespaceImport = imports.find((imp) => imp.kind === "namespace");
-		if (namespaceImport) {
-			importLines.push(`    const ${namespaceImport.local} = yield registry.requestImport("${filePath$1}");`);
-			namespaceImports.add(namespaceImport.local);
-			importedRootNames.add(namespaceImport.local);
-		} else {
-			const rootNames = new Set();
-			imports.forEach((imp) => {
-				if (imp.kind === "named" || imp.kind === "default") {
-					rootNames.add(imp.local);
-					importedRootNames.add(imp.local);
-				}
-			});
-			if (rootNames.size > 0) {
-				const destructured = Array.from(rootNames).sort().join(", ");
-				importLines.push(`    const { ${destructured} } = yield registry.requestImport("${filePath$1}");`);
-			}
-		}
-	});
-	return {
-		imports: importLines.length > 0 ? `${importLines.join("\n")}` : "",
-		importedRootNames,
-		namespaceImports
-	};
-};
-const renderRegistryBlock = ({ filePath, analysis, analyses, graphqlSystemPath }) => {
-	const { imports } = renderImportStatements({
-		filePath,
-		analysis,
-		analyses,
-		graphqlSystemPath
-	});
-	return [
-		`registry.setModule("${filePath}", function*() {`,
-		imports,
-		"",
-		buildNestedObject(analysis.definitions),
-		"});"
-	].join("\n");
-};
-
-//#endregion
-//#region packages/builder/src/intermediate-module/registry.ts
-const createIntermediateRegistry = ({ analyses } = {}) => {
-	const modules = new Map();
-	const elements = new Map();
-	const setModule = (filePath, factory) => {
-		modules.set(filePath, factory);
-	};
-	/**
-	* Creates an import request to be yielded by module generators.
-	* Usage: `const { foo } = yield registry.requestImport("/path/to/module");`
-	*/
-	const requestImport = (filePath) => ({
-		kind: "import",
-		filePath
-	});
-	const addElement = (canonicalId, factory) => {
-		const builder = factory();
-		__soda_gql_core.GqlElement.setContext(builder, { canonicalId });
-		elements.set(canonicalId, builder);
-		return builder;
-	};
-	/**
-	* Evaluate a single module and its dependencies using trampoline.
-	* Returns the cached result or evaluates and caches if not yet evaluated.
-	*/
-	const evaluateModule = (filePath, evaluated, inProgress) => {
-		const cached = evaluated.get(filePath);
-		if (cached) {
-			return cached;
-		}
-		const stack = [];
-		const factory = modules.get(filePath);
-		if (!factory) {
-			throw new Error(`Module not found or yet to be registered: ${filePath}`);
-		}
-		stack.push({
-			filePath,
-			generator: factory()
-		});
-		let frame;
-		while (frame = stack[stack.length - 1]) {
-			inProgress.add(frame.filePath);
-			const result$1 = frame.resolvedDependency !== undefined ? frame.generator.next(frame.resolvedDependency) : frame.generator.next();
-			frame.resolvedDependency = undefined;
-			if (result$1.done) {
-				evaluated.set(frame.filePath, result$1.value);
-				inProgress.delete(frame.filePath);
-				stack.pop();
-				const parentFrame = stack[stack.length - 1];
-				if (parentFrame) {
-					parentFrame.resolvedDependency = result$1.value;
-				}
-			} else {
-				const request = result$1.value;
-				if (request.kind === "import") {
-					const depPath = request.filePath;
-					const depCached = evaluated.get(depPath);
-					if (depCached) {
-						frame.resolvedDependency = depCached;
-					} else {
-						if (inProgress.has(depPath)) {
-							if (analyses) {
-								const currentAnalysis = analyses.get(frame.filePath);
-								const targetAnalysis = analyses.get(depPath);
-								const currentHasGql = currentAnalysis && currentAnalysis.definitions.length > 0;
-								const targetHasGql = targetAnalysis && targetAnalysis.definitions.length > 0;
-								if (!currentHasGql || !targetHasGql) {
-									frame.resolvedDependency = {};
-									continue;
-								}
-							}
-							throw new Error(`Circular dependency detected: ${depPath}`);
-						}
-						const depFactory = modules.get(depPath);
-						if (!depFactory) {
-							throw new Error(`Module not found or yet to be registered: ${depPath}`);
-						}
-						stack.push({
-							filePath: depPath,
-							generator: depFactory()
-						});
-					}
-				}
-			}
-		}
-		const result = evaluated.get(filePath);
-		if (!result) {
-			throw new Error(`Module evaluation failed: ${filePath}`);
-		}
-		return result;
-	};
-	/**
-	* Build artifacts record from evaluated elements.
-	*/
-	const buildArtifacts = () => {
-		const artifacts = {};
-		for (const [canonicalId, element] of elements.entries()) {
-			if (element instanceof __soda_gql_core.Fragment) {
-				artifacts[canonicalId] = {
-					type: "fragment",
-					element
-				};
-			} else if (element instanceof __soda_gql_core.Operation) {
-				artifacts[canonicalId] = {
-					type: "operation",
-					element
-				};
-			}
-		}
-		return artifacts;
-	};
-	/**
-	* Generator that evaluates all elements using the effect system.
-	* Uses ParallelEffect to enable parallel evaluation in async mode.
-	* In sync mode, ParallelEffect executes effects sequentially.
-	*/
-	function* evaluateElementsGen() {
-		const effects = Array.from(elements.values(), (element) => new ElementEvaluationEffect(element));
-		if (effects.length > 0) {
-			yield* new __soda_gql_common.ParallelEffect(effects).run();
-		}
-	}
-	/**
-	* Synchronous evaluation - evaluates all modules and elements synchronously.
-	* Throws if any element requires async operations (e.g., async metadata factory).
-	*/
-	const evaluate = () => {
-		const evaluated = new Map();
-		const inProgress = new Set();
-		for (const filePath of modules.keys()) {
-			if (!evaluated.has(filePath)) {
-				evaluateModule(filePath, evaluated, inProgress);
-			}
-		}
-		const scheduler = (0, __soda_gql_common.createSyncScheduler)();
-		const result = scheduler.run(() => evaluateElementsGen());
-		if (result.isErr()) {
-			throw new Error(`Element evaluation failed: ${result.error.message}`);
-		}
-		return buildArtifacts();
-	};
-	/**
-	* Asynchronous evaluation - evaluates all modules and elements with async support.
-	* Supports async metadata factories and other async operations.
-	*/
-	const evaluateAsync = async () => {
-		const evaluated = new Map();
-		const inProgress = new Set();
-		for (const filePath of modules.keys()) {
-			if (!evaluated.has(filePath)) {
-				evaluateModule(filePath, evaluated, inProgress);
-			}
-		}
-		const scheduler = (0, __soda_gql_common.createAsyncScheduler)();
-		const result = await scheduler.run(() => evaluateElementsGen());
-		if (result.isErr()) {
-			throw new Error(`Element evaluation failed: ${result.error.message}`);
-		}
-		return buildArtifacts();
-	};
-	/**
-	* Evaluate all modules synchronously using trampoline.
-	* This runs the module dependency resolution without element evaluation.
-	* Call this before getElements() when using external scheduler control.
-	*/
-	const evaluateModules = () => {
-		const evaluated = new Map();
-		const inProgress = new Set();
-		for (const filePath of modules.keys()) {
-			if (!evaluated.has(filePath)) {
-				evaluateModule(filePath, evaluated, inProgress);
-			}
-		}
-	};
-	/**
-	* Get all registered elements for external effect creation.
-	* Call evaluateModules() first to ensure all modules have been evaluated.
-	*/
-	const getElements = () => {
-		return Array.from(elements.values());
-	};
-	const clear = () => {
-		modules.clear();
-		elements.clear();
-	};
-	return {
-		setModule,
-		requestImport,
-		addElement,
-		evaluate,
-		evaluateAsync,
-		evaluateModules,
-		getElements,
-		buildArtifacts,
-		clear
-	};
-};
-
-//#endregion
-//#region packages/builder/src/intermediate-module/evaluation.ts
-const transpile = ({ filePath, sourceCode }) => {
-	try {
-		const result = (0, __swc_core.transformSync)(sourceCode, {
-			filename: `${filePath}.ts`,
-			jsc: {
-				parser: {
-					syntax: "typescript",
-					tsx: false
-				},
-				target: "es2022"
-			},
-			module: { type: "es6" },
-			sourceMaps: false,
-			minify: false
-		});
-		return (0, neverthrow.ok)(result.code);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		return (0, neverthrow.err)({
-			code: "RUNTIME_MODULE_LOAD_FAILED",
-			filePath,
-			astPath: "",
-			message: `SWC transpilation failed: ${message}`
-		});
-	}
-};
-/**
-* Resolve graphql system path to the bundled CJS file.
-* Accepts both .ts (for backward compatibility) and .cjs paths.
-* Maps .ts to sibling .cjs file if it exists.
-*/
-function resolveGraphqlSystemPath(configPath) {
-	const ext = (0, node_path.extname)(configPath);
-	if (ext === ".cjs") {
-		return (0, node_path.resolve)(process.cwd(), configPath);
-	}
-	if (ext === ".ts") {
-		const basePath = configPath.slice(0, -3);
-		const cjsPath = `${basePath}.cjs`;
-		const resolvedCjsPath = (0, node_path.resolve)(process.cwd(), cjsPath);
-		if ((0, node_fs.existsSync)(resolvedCjsPath)) {
-			return resolvedCjsPath;
-		}
-		return (0, node_path.resolve)(process.cwd(), configPath);
-	}
-	return (0, node_path.resolve)(process.cwd(), configPath);
-}
-/**
-* Bundle and execute GraphQL system module using rspack + memfs.
-* Creates a self-contained bundle that can run in VM context.
-* This is cached per session to avoid re-bundling.
-*/
-let cachedGql = null;
-let cachedModulePath = null;
-/**
-* Clear the cached gql module.
-* Call this between test runs to ensure clean state.
-* @internal - exported for testing purposes only
-*/
-const __clearGqlCache = () => {
-	cachedGql = null;
-	cachedModulePath = null;
-};
-function executeGraphqlSystemModule(modulePath) {
-	if (cachedModulePath === modulePath && cachedGql !== null) {
-		return { gql: cachedGql };
-	}
-	const bundledCode = (0, node_fs.readFileSync)(modulePath, "utf-8");
-	const sandbox = createSandbox(modulePath);
-	new node_vm.Script(bundledCode, { filename: modulePath }).runInNewContext(sandbox);
-	const finalExports = sandbox.module.exports;
-	const exportedGql = finalExports.gql ?? finalExports.default;
-	if (exportedGql === undefined) {
-		throw new Error(`No 'gql' export found in GraphQL system module: ${modulePath}`);
-	}
-	cachedGql = exportedGql;
-	cachedModulePath = modulePath;
-	return { gql: cachedGql };
-}
-/**
-* Build intermediate modules from dependency graph.
-* Each intermediate module corresponds to one source file.
-*/
-const generateIntermediateModules = function* ({ analyses, targetFiles, graphqlSystemPath }) {
-	for (const filePath of targetFiles) {
-		const analysis = analyses.get(filePath);
-		if (!analysis) {
-			continue;
-		}
-		const sourceCode = renderRegistryBlock({
-			filePath,
-			analysis,
-			analyses,
-			graphqlSystemPath
-		});
-		if (process.env.DEBUG_INTERMEDIATE_MODULE) {
-			console.log("=== Intermediate module source ===");
-			console.log("FilePath:", filePath);
-			console.log("Definitions:", analysis.definitions.map((d) => d.astPath));
-			console.log("Source code:\n", sourceCode);
-			console.log("=================================");
-		}
-		const transpiledCodeResult = transpile({
-			filePath,
-			sourceCode
-		});
-		if (transpiledCodeResult.isErr()) {
-			continue;
-		}
-		const transpiledCode = transpiledCodeResult.value;
-		const script = new node_vm.Script(transpiledCode);
-		const hash = (0, node_crypto.createHash)("sha1");
-		hash.update(transpiledCode);
-		const contentHash = hash.digest("hex");
-		const canonicalIds = analysis.definitions.map((definition) => definition.canonicalId);
-		yield {
-			filePath,
-			canonicalIds,
-			sourceCode,
-			transpiledCode,
-			contentHash,
-			script
-		};
-	}
-};
-/**
-* Set up VM context and run intermediate module scripts.
-* Returns the registry for evaluation.
-*/
-const setupIntermediateModulesContext = ({ intermediateModules, graphqlSystemPath, analyses }) => {
-	const registry = createIntermediateRegistry({ analyses });
-	const gqlImportPath = resolveGraphqlSystemPath(graphqlSystemPath);
-	const { gql } = executeGraphqlSystemModule(gqlImportPath);
-	const vmContext = (0, node_vm.createContext)({
-		gql,
-		registry
-	});
-	for (const { script, filePath } of intermediateModules.values()) {
-		try {
-			script.runInContext(vmContext);
-		} catch (error) {
-			console.error(`Error evaluating intermediate module ${filePath}:`, error);
-			throw error;
-		}
-	}
-	return registry;
-};
-/**
-* Synchronous evaluation of intermediate modules.
-* Throws if any element requires async operations (e.g., async metadata factory).
-*/
-const evaluateIntermediateModules = (input) => {
-	const registry = setupIntermediateModulesContext(input);
-	const elements = registry.evaluate();
-	registry.clear();
-	return elements;
-};
-/**
-* Asynchronous evaluation of intermediate modules.
-* Supports async metadata factories and other async operations.
-*/
-const evaluateIntermediateModulesAsync = async (input) => {
-	const registry = setupIntermediateModulesContext(input);
-	const elements = await registry.evaluateAsync();
-	registry.clear();
-	return elements;
-};
-/**
-* Generator version of evaluateIntermediateModules for external scheduler control.
-* Yields effects for element evaluation, enabling unified scheduler at the root level.
-*
-* This function:
-* 1. Sets up the VM context and runs intermediate module scripts
-* 2. Runs synchronous module evaluation (trampoline - no I/O)
-* 3. Yields element evaluation effects via ParallelEffect
-* 4. Returns the artifacts record
-*/
-function* evaluateIntermediateModulesGen(input) {
-	const registry = setupIntermediateModulesContext(input);
-	registry.evaluateModules();
-	const elements = registry.getElements();
-	const effects = elements.map((element) => new ElementEvaluationEffect(element));
-	if (effects.length > 0) {
-		yield* new __soda_gql_common.ParallelEffect(effects).run();
-	}
-	const artifacts = registry.buildArtifacts();
-	registry.clear();
-	return artifacts;
-}
-
-//#endregion
-//#region packages/builder/src/internal/graphql-system.ts
-/**
-* Helper for identifying graphql-system files and import specifiers.
-* Provides robust detection across symlinks, case-insensitive filesystems, and user-defined aliases.
-*/
-/**
-* Create a canonical file name getter based on platform.
-* On case-sensitive filesystems, paths are returned as-is.
-* On case-insensitive filesystems, paths are lowercased for comparison.
-*/
-const createGetCanonicalFileName = (useCaseSensitiveFileNames) => {
-	return useCaseSensitiveFileNames ? (path) => path : (path) => path.toLowerCase();
-};
-/**
-* Detect if the filesystem is case-sensitive.
-* We assume Unix-like systems are case-sensitive, and Windows is not.
-*/
-const getUseCaseSensitiveFileNames = () => {
-	return process.platform !== "win32";
-};
-/**
-* Create a GraphqlSystemIdentifyHelper from the resolved config.
-* Uses canonical path comparison to handle casing, symlinks, and aliases.
-*/
-const createGraphqlSystemIdentifyHelper = (config) => {
-	const getCanonicalFileName = createGetCanonicalFileName(getUseCaseSensitiveFileNames());
-	const toCanonical = (file) => {
-		const resolved = (0, node_path.resolve)(file);
-		try {
-			return getCanonicalFileName((0, node_fs.realpathSync)(resolved));
-		} catch {
-			return getCanonicalFileName(resolved);
-		}
-	};
-	const graphqlSystemPath = (0, node_path.resolve)(config.outdir, "index.ts");
-	const canonicalGraphqlSystemPath = toCanonical(graphqlSystemPath);
-	const canonicalAliases = new Set(config.graphqlSystemAliases.map((alias) => alias));
-	return {
-		isGraphqlSystemFile: ({ filePath }) => {
-			return toCanonical(filePath) === canonicalGraphqlSystemPath;
-		},
-		isGraphqlSystemImportSpecifier: ({ filePath, specifier }) => {
-			if (canonicalAliases.has(specifier)) {
-				return true;
-			}
-			if (!specifier.startsWith(".")) {
-				return false;
-			}
-			const resolved = (0, __soda_gql_common.resolveRelativeImportWithExistenceCheck)({
-				filePath,
-				specifier
-			});
-			if (!resolved) {
-				return false;
-			}
-			return toCanonical(resolved) === canonicalGraphqlSystemPath;
-		}
-	};
-};
-
-//#endregion
-//#region packages/builder/src/prebuilt/extractor.ts
-/**
-* Extract field selections from evaluated intermediate elements.
-*
-* For fragments, calls `spread()` with empty/default variables to get field selections.
-* For operations, calls `documentSource()` to get field selections.
-*
-* @param elements - Record of canonical ID to intermediate artifact element
-* @returns Object containing selections map and any warnings encountered
-*/
-const extractFieldSelections = (elements) => {
-	const selections = new Map();
-	const warnings = [];
-	for (const [id, element] of Object.entries(elements)) {
-		const canonicalId = id;
-		try {
-			if (element.type === "fragment") {
-				const variableDefinitions = element.element.variableDefinitions;
-				const varRefs = Object.fromEntries(Object.keys(variableDefinitions).map((k) => [k, (0, __soda_gql_core.createVarRefFromVariable)(k)]));
-				const fields = element.element.spread(varRefs);
-				selections.set(canonicalId, {
-					type: "fragment",
-					schemaLabel: element.element.schemaLabel,
-					key: element.element.key,
-					typename: element.element.typename,
-					fields,
-					variableDefinitions
-				});
-			} else if (element.type === "operation") {
-				const fields = element.element.documentSource();
-				const document = element.element.document;
-				const operationDef = document.definitions.find((def) => def.kind === graphql.Kind.OPERATION_DEFINITION);
-				const variableDefinitions = operationDef?.variableDefinitions ?? [];
-				selections.set(canonicalId, {
-					type: "operation",
-					schemaLabel: element.element.schemaLabel,
-					operationName: element.element.operationName,
-					operationType: element.element.operationType,
-					fields,
-					variableDefinitions
-				});
-			}
-		} catch (error) {
-			warnings.push(`[prebuilt] Failed to extract field selections for ${canonicalId}: ${error instanceof Error ? error.message : String(error)}`);
-		}
-	}
-	return {
-		selections,
-		warnings
-	};
-};
-
-//#endregion
-//#region packages/builder/src/schema-loader.ts
-/**
-* Schema loader for CJS bundle evaluation.
-*
-* Loads AnyGraphqlSchema from the generated CJS bundle by accessing
-* the `$schema` property on each gql composer.
-*
-* @module
-*/
-/**
-* Load AnyGraphqlSchema from a generated CJS bundle.
-*
-* The generated CJS bundle exports a `gql` object where each property
-* is a GQL element composer with a `$schema` property containing the
-* schema definition. This function executes the bundle in a VM context
-* and extracts those schemas.
-*
-* @param cjsPath - Absolute path to the CJS bundle file
-* @param schemaNames - Names of schemas to load (e.g., ["default", "admin"])
-* @returns Record mapping schema names to AnyGraphqlSchema objects
-*
-* @example
-* ```typescript
-* const result = loadSchemasFromBundle(
-*   "/path/to/generated/index.cjs",
-*   ["default"]
-* );
-*
-* if (result.isOk()) {
-*   const schemas = result.value;
-*   console.log(schemas.default); // AnyGraphqlSchema
-* }
-* ```
-*/
-const loadSchemasFromBundle = (cjsPath, schemaNames) => {
-	const resolvedPath = (0, node_path.resolve)(cjsPath);
-	if (!(0, node_fs.existsSync)(resolvedPath)) {
-		return (0, neverthrow.err)({
-			code: "CONFIG_NOT_FOUND",
-			message: `CJS bundle not found: ${resolvedPath}. Run 'soda-gql codegen' first.`,
-			path: resolvedPath
-		});
-	}
-	let bundledCode;
-	try {
-		bundledCode = (0, node_fs.readFileSync)(resolvedPath, "utf-8");
-	} catch (error) {
-		return (0, neverthrow.err)({
-			code: "DISCOVERY_IO_ERROR",
-			message: `Failed to read CJS bundle: ${error instanceof Error ? error.message : String(error)}`,
-			path: resolvedPath,
-			cause: error
-		});
-	}
-	let finalExports;
-	try {
-		finalExports = executeSandbox(bundledCode, resolvedPath);
-	} catch (error) {
-		return (0, neverthrow.err)({
-			code: "RUNTIME_MODULE_LOAD_FAILED",
-			message: `Failed to execute CJS bundle: ${error instanceof Error ? error.message : String(error)}`,
-			filePath: resolvedPath,
-			astPath: "",
-			cause: error
-		});
-	}
-	const gql = finalExports.gql;
-	if (!gql || typeof gql !== "object") {
-		return (0, neverthrow.err)({
-			code: "CONFIG_INVALID",
-			message: "CJS bundle does not export 'gql' object. Ensure codegen was run successfully.",
-			path: resolvedPath
-		});
-	}
-	const schemas = {};
-	for (const name of schemaNames) {
-		const composer = gql[name];
-		if (!composer) {
-			const availableSchemas = Object.keys(gql).join(", ");
-			return (0, neverthrow.err)({
-				code: "SCHEMA_NOT_FOUND",
-				message: `Schema '${name}' not found in gql exports. Available: ${availableSchemas || "(none)"}`,
-				schemaLabel: name,
-				canonicalId: `gql.${name}`
-			});
-		}
-		const schema = composer.$schema;
-		if (!schema || typeof schema !== "object") {
-			return (0, neverthrow.err)({
-				code: "CONFIG_INVALID",
-				message: `gql.${name}.$schema is not a valid schema object. Ensure codegen version is up to date.`,
-				path: resolvedPath
-			});
-		}
-		schemas[name] = schema;
-	}
-	return (0, neverthrow.ok)(schemas);
-};
-
-//#endregion
-//#region packages/builder/src/artifact/aggregate.ts
-const canonicalToFilePath$1 = (canonicalId) => canonicalId.split("::")[0] ?? canonicalId;
-const computeContentHash = (prebuild) => {
-	const hash = (0, node_crypto.createHash)("sha1");
-	hash.update(JSON.stringify(prebuild));
-	return hash.digest("hex");
-};
-const emitRegistrationError = (definition, message) => ({
-	code: "RUNTIME_MODULE_LOAD_FAILED",
-	filePath: canonicalToFilePath$1(definition.canonicalId),
-	astPath: definition.astPath,
-	message
-});
-const aggregate = ({ analyses, elements }) => {
-	const registry = new Map();
-	for (const analysis of analyses.values()) {
-		for (const definition of analysis.definitions) {
-			const element = elements[definition.canonicalId];
-			if (!element) {
-				const availableIds = Object.keys(elements).join(", ");
-				const message = `ARTIFACT_NOT_FOUND_IN_RUNTIME_MODULE: ${definition.canonicalId}\nAvailable: ${availableIds}`;
-				return (0, neverthrow.err)(emitRegistrationError(definition, message));
-			}
-			if (registry.has(definition.canonicalId)) {
-				return (0, neverthrow.err)(emitRegistrationError(definition, `ARTIFACT_ALREADY_REGISTERED`));
-			}
-			const metadata = {
-				sourcePath: analysis.filePath ?? canonicalToFilePath$1(definition.canonicalId),
-				contentHash: ""
-			};
-			if (element.type === "fragment") {
-				const prebuild = {
-					typename: element.element.typename,
-					key: element.element.key,
-					schemaLabel: element.element.schemaLabel
-				};
-				registry.set(definition.canonicalId, {
-					id: definition.canonicalId,
-					type: "fragment",
-					prebuild,
-					metadata: {
-						...metadata,
-						contentHash: computeContentHash(prebuild)
-					}
-				});
-				continue;
-			}
-			if (element.type === "operation") {
-				const prebuild = {
-					operationType: element.element.operationType,
-					operationName: element.element.operationName,
-					schemaLabel: element.element.schemaLabel,
-					document: element.element.document,
-					variableNames: element.element.variableNames,
-					metadata: element.element.metadata
-				};
-				registry.set(definition.canonicalId, {
-					id: definition.canonicalId,
-					type: "operation",
-					prebuild,
-					metadata: {
-						...metadata,
-						contentHash: computeContentHash(prebuild)
-					}
-				});
-				continue;
-			}
-			return (0, neverthrow.err)(emitRegistrationError(definition, "UNKNOWN_ARTIFACT_KIND"));
-		}
-	}
-	return (0, neverthrow.ok)(registry);
-};
-
-//#endregion
-//#region packages/builder/src/artifact/issue-handler.ts
-const canonicalToFilePath = (canonicalId) => canonicalId.split("::")[0] ?? canonicalId;
-const checkIssues = ({ elements }) => {
-	const operationNames = new Set();
-	for (const [canonicalId, { type, element }] of Object.entries(elements)) {
-		if (type !== "operation") {
-			continue;
-		}
-		if (operationNames.has(element.operationName)) {
-			const sources = [canonicalToFilePath(canonicalId)];
-			return (0, neverthrow.err)({
-				code: "DOC_DUPLICATE",
-				message: `Duplicate document name: ${element.operationName}`,
-				name: element.operationName,
-				sources
-			});
-		}
-		operationNames.add(element.operationName);
-	}
-	return (0, neverthrow.ok)([]);
-};
-
-//#endregion
-//#region packages/builder/src/artifact/builder.ts
-const buildArtifact = ({ elements, analyses, stats: cache }) => {
-	const issuesResult = checkIssues({ elements });
-	if (issuesResult.isErr()) {
-		return (0, neverthrow.err)(issuesResult.error);
-	}
-	const warnings = issuesResult.value;
-	const aggregationResult = aggregate({
-		analyses,
-		elements
-	});
-	if (aggregationResult.isErr()) {
-		return (0, neverthrow.err)(aggregationResult.error);
-	}
-	return (0, neverthrow.ok)({
-		elements: Object.fromEntries(aggregationResult.value.entries()),
-		report: {
-			durationMs: 0,
-			warnings,
-			stats: cache
-		}
-	});
-};
-
-//#endregion
-//#region packages/builder/src/ast/common/scope.ts
-/**
-* Build AST path from scope stack
-*/
-const buildAstPath = (stack) => {
-	return stack.map((frame) => frame.nameSegment).join(".");
-};
-/**
-* Create an occurrence tracker for disambiguating anonymous/duplicate scopes.
-*/
-const createOccurrenceTracker = () => {
-	const occurrenceCounters = new Map();
-	return { getNextOccurrence(key) {
-		const current = occurrenceCounters.get(key) ?? 0;
-		occurrenceCounters.set(key, current + 1);
-		return current;
-	} };
-};
-/**
-* Create a path uniqueness tracker to ensure AST paths are unique.
-*/
-const createPathTracker = () => {
-	const usedPaths = new Set();
-	return { ensureUniquePath(basePath) {
-		let path = basePath;
-		let suffix = 0;
-		while (usedPaths.has(path)) {
-			suffix++;
-			path = `${basePath}$${suffix}`;
-		}
-		usedPaths.add(path);
-		return path;
-	} };
-};
-/**
-* Create an export bindings map from module exports.
-* Maps local variable names to their exported names.
-*/
-const createExportBindingsMap = (exports$1) => {
-	const exportBindings = new Map();
-	exports$1.forEach((exp) => {
-		if (exp.kind === "named" && exp.local && !exp.isTypeOnly) {
-			exportBindings.set(exp.local, exp.exported);
-		}
-	});
-	return exportBindings;
-};
-
-//#endregion
-//#region packages/builder/src/ast/adapters/swc.ts
-/**
-* SWC adapter for the analyzer core.
-* Implements parser-specific logic using the SWC parser.
-*/
-const collectImports$1 = (module$1) => {
-	const imports = [];
-	const handle = (declaration) => {
-		const source = declaration.source.value;
-		declaration.specifiers?.forEach((specifier) => {
-			if (specifier.type === "ImportSpecifier") {
-				imports.push({
-					source,
-					local: specifier.local.value,
-					kind: "named",
-					isTypeOnly: Boolean(specifier.isTypeOnly)
-				});
-				return;
-			}
-			if (specifier.type === "ImportNamespaceSpecifier") {
-				imports.push({
-					source,
-					local: specifier.local.value,
-					kind: "namespace",
-					isTypeOnly: false
-				});
-				return;
-			}
-			if (specifier.type === "ImportDefaultSpecifier") {
-				imports.push({
-					source,
-					local: specifier.local.value,
-					kind: "default",
-					isTypeOnly: false
-				});
-			}
-		});
-	};
-	module$1.body.forEach((item) => {
-		if (item.type === "ImportDeclaration") {
-			handle(item);
-			return;
-		}
-		if ("declaration" in item && item.declaration && "type" in item.declaration && item.declaration.type === "ImportDeclaration") {
-			handle(item.declaration);
-		}
-	});
-	return imports;
-};
-const collectExports$1 = (module$1) => {
-	const exports$1 = [];
-	const handle = (declaration) => {
-		if (declaration.type === "ExportDeclaration") {
-			if (declaration.declaration.type === "VariableDeclaration") {
-				declaration.declaration.declarations.forEach((decl) => {
-					if (decl.id.type === "Identifier") {
-						exports$1.push({
-							kind: "named",
-							exported: decl.id.value,
-							local: decl.id.value,
-							isTypeOnly: false
-						});
-					}
-				});
-			}
-			if (declaration.declaration.type === "FunctionDeclaration") {
-				const ident = declaration.declaration.identifier;
-				if (ident) {
-					exports$1.push({
-						kind: "named",
-						exported: ident.value,
-						local: ident.value,
-						isTypeOnly: false
-					});
-				}
-			}
-			return;
-		}
-		if (declaration.type === "ExportNamedDeclaration") {
-			const source = declaration.source?.value;
-			declaration.specifiers?.forEach((specifier) => {
-				if (specifier.type !== "ExportSpecifier") {
-					return;
-				}
-				const exported = specifier.exported ? specifier.exported.value : specifier.orig.value;
-				const local = specifier.orig.value;
-				if (source) {
-					exports$1.push({
-						kind: "reexport",
-						exported,
-						local,
-						source,
-						isTypeOnly: Boolean(specifier.isTypeOnly)
-					});
-					return;
-				}
-				exports$1.push({
-					kind: "named",
-					exported,
-					local,
-					isTypeOnly: Boolean(specifier.isTypeOnly)
-				});
-			});
-			return;
-		}
-		if (declaration.type === "ExportAllDeclaration") {
-			exports$1.push({
-				kind: "reexport",
-				exported: "*",
-				source: declaration.source.value,
-				isTypeOnly: false
-			});
-			return;
-		}
-		if (declaration.type === "ExportDefaultDeclaration" || declaration.type === "ExportDefaultExpression") {
-			exports$1.push({
-				kind: "named",
-				exported: "default",
-				local: "default",
-				isTypeOnly: false
-			});
-		}
-	};
-	module$1.body.forEach((item) => {
-		if (item.type === "ExportDeclaration" || item.type === "ExportNamedDeclaration" || item.type === "ExportAllDeclaration" || item.type === "ExportDefaultDeclaration" || item.type === "ExportDefaultExpression") {
-			handle(item);
-			return;
-		}
-		if ("declaration" in item && item.declaration) {
-			const declaration = item.declaration;
-			if (declaration.type === "ExportDeclaration" || declaration.type === "ExportNamedDeclaration" || declaration.type === "ExportAllDeclaration" || declaration.type === "ExportDefaultDeclaration" || declaration.type === "ExportDefaultExpression") {
-				handle(declaration);
-			}
-		}
-	});
-	return exports$1;
-};
-const collectGqlIdentifiers = (module$1, helper) => {
-	const identifiers = new Set();
-	module$1.body.forEach((item) => {
-		const declaration = item.type === "ImportDeclaration" ? item : "declaration" in item && item.declaration && item.declaration.type === "ImportDeclaration" ? item.declaration : null;
-		if (!declaration) {
-			return;
-		}
-		if (!helper.isGraphqlSystemImportSpecifier({
-			filePath: module$1.__filePath,
-			specifier: declaration.source.value
-		})) {
-			return;
-		}
-		declaration.specifiers?.forEach((specifier) => {
-			if (specifier.type === "ImportSpecifier") {
-				const imported = specifier.imported ? specifier.imported.value : specifier.local.value;
-				if (imported === "gql") {
-					identifiers.add(specifier.local.value);
-				}
-			}
-		});
-	});
-	return identifiers;
-};
-const isGqlCall = (identifiers, call) => {
-	const callee = call.callee;
-	if (callee.type !== "MemberExpression") {
-		return false;
-	}
-	if (callee.object.type !== "Identifier") {
-		return false;
-	}
-	if (!identifiers.has(callee.object.value)) {
-		return false;
-	}
-	if (callee.property.type !== "Identifier") {
-		return false;
-	}
-	const firstArg = call.arguments[0];
-	if (!firstArg?.expression || firstArg.expression.type !== "ArrowFunctionExpression") {
-		return false;
-	}
-	return true;
-};
-/**
-* Unwrap method chains (like .attach()) to find the underlying gql call.
-* Returns the innermost CallExpression that is a valid gql definition call.
-*/
-const unwrapMethodChains$1 = (identifiers, node) => {
-	if (!node || node.type !== "CallExpression") {
-		return null;
-	}
-	if (isGqlCall(identifiers, node)) {
-		return node;
-	}
-	const callee = node.callee;
-	if (callee.type !== "MemberExpression") {
-		return null;
-	}
-	return unwrapMethodChains$1(identifiers, callee.object);
-};
-const collectAllDefinitions$1 = ({ module: module$1, gqlIdentifiers, imports: _imports, exports: exports$1, source }) => {
-	const getPropertyName$1 = (property) => {
-		if (!property) {
-			return null;
-		}
-		if (property.type === "Identifier") {
-			return property.value;
-		}
-		if (property.type === "StringLiteral" || property.type === "NumericLiteral") {
-			return property.value;
-		}
-		return null;
-	};
-	const pending = [];
-	const handledCalls = [];
-	const exportBindings = createExportBindingsMap(exports$1);
-	const tracker = (0, __soda_gql_common.createCanonicalTracker)({
-		filePath: module$1.__filePath,
-		getExportName: (localName) => exportBindings.get(localName)
-	});
-	const anonymousCounters = new Map();
-	const getAnonymousName = (kind) => {
-		const count = anonymousCounters.get(kind) ?? 0;
-		anonymousCounters.set(kind, count + 1);
-		return `_${kind}_${count}`;
-	};
-	const withScope = (stack, segment, kind, stableKey, callback) => {
-		const handle = tracker.enterScope({
-			segment,
-			kind,
-			stableKey
-		});
-		try {
-			const frame = {
-				nameSegment: segment,
-				kind
-			};
-			return callback([...stack, frame]);
-		} finally {
-			tracker.exitScope(handle);
-		}
-	};
-	const expressionFromCall = (call) => {
-		const spanOffset = module$1.__spanOffset;
-		let start = call.span.start - spanOffset;
-		const end = call.span.end - spanOffset;
-		if (start > 0 && source[start] === "q" && source[start - 1] === "g" && source.slice(start, start + 3) === "ql.") {
-			start -= 1;
-		}
-		const raw = source.slice(start, end);
-		const marker = raw.indexOf("gql");
-		const expression = marker >= 0 ? raw.slice(marker) : raw;
-		return expression.replace(/\s*;\s*$/, "");
-	};
-	const visit = (node, stack) => {
-		if (!node || typeof node !== "object") {
-			return;
-		}
-		if (node.type === "CallExpression") {
-			const gqlCall = unwrapMethodChains$1(gqlIdentifiers, node);
-			if (gqlCall) {
-				const needsAnonymousScope = tracker.currentDepth() === 0;
-				let anonymousScopeHandle;
-				if (needsAnonymousScope) {
-					const anonymousName = getAnonymousName("anonymous");
-					anonymousScopeHandle = tracker.enterScope({
-						segment: anonymousName,
-						kind: "expression",
-						stableKey: "anonymous"
-					});
-				}
-				try {
-					const { astPath } = tracker.registerDefinition();
-					const isTopLevel = stack.length === 1;
-					let isExported = false;
-					let exportBinding;
-					if (isTopLevel && stack[0]) {
-						const topLevelName = stack[0].nameSegment;
-						if (exportBindings.has(topLevelName)) {
-							isExported = true;
-							exportBinding = exportBindings.get(topLevelName);
-						}
-					}
-					handledCalls.push(node);
-					pending.push({
-						astPath,
-						isTopLevel,
-						isExported,
-						exportBinding,
-						expression: expressionFromCall(gqlCall)
-					});
-				} finally {
-					if (anonymousScopeHandle) {
-						tracker.exitScope(anonymousScopeHandle);
-					}
-				}
-				return;
-			}
-		}
-		if (node.type === "VariableDeclaration") {
-			node.declarations?.forEach((decl) => {
-				if (decl.id?.type === "Identifier") {
-					const varName = decl.id.value;
-					if (decl.init) {
-						withScope(stack, varName, "variable", `var:${varName}`, (newStack) => {
-							visit(decl.init, newStack);
-						});
-					}
-				} else if (decl.init) {
-					visit(decl.init, stack);
-				}
-			});
-			return;
-		}
-		if (node.type === "FunctionDeclaration") {
-			const funcName = node.identifier?.value ?? getAnonymousName("function");
-			if (node.body) {
-				withScope(stack, funcName, "function", `func:${funcName}`, (newStack) => {
-					visit(node.body, newStack);
-				});
-			}
-			return;
-		}
-		if (node.type === "ArrowFunctionExpression") {
-			const arrowName = getAnonymousName("arrow");
-			if (node.body) {
-				withScope(stack, arrowName, "function", "arrow", (newStack) => {
-					visit(node.body, newStack);
-				});
-			}
-			return;
-		}
-		if (node.type === "FunctionExpression") {
-			const funcName = node.identifier?.value ?? getAnonymousName("function");
-			if (node.body) {
-				withScope(stack, funcName, "function", `func:${funcName}`, (newStack) => {
-					visit(node.body, newStack);
-				});
-			}
-			return;
-		}
-		if (node.type === "ClassDeclaration") {
-			const className = node.identifier?.value ?? getAnonymousName("class");
-			withScope(stack, className, "class", `class:${className}`, (classStack) => {
-				node.body?.forEach((member) => {
-					if (member.type === "ClassMethod" || member.type === "ClassProperty") {
-						const memberName = member.key?.value ?? null;
-						if (memberName) {
-							const memberKind = member.type === "ClassMethod" ? "method" : "property";
-							withScope(classStack, memberName, memberKind, `member:${className}.${memberName}`, (memberStack) => {
-								if (member.type === "ClassMethod" && member.function?.body) {
-									visit(member.function.body, memberStack);
-								} else if (member.type === "ClassProperty" && member.value) {
-									visit(member.value, memberStack);
-								}
-							});
-						}
-					}
-				});
-			});
-			return;
-		}
-		if (node.type === "KeyValueProperty") {
-			const propName = getPropertyName$1(node.key);
-			if (propName) {
-				withScope(stack, propName, "property", `prop:${propName}`, (newStack) => {
-					visit(node.value, newStack);
-				});
-			}
-			return;
-		}
-		if (Array.isArray(node)) {
-			for (const child of node) {
-				visit(child, stack);
-			}
-		} else {
-			for (const value of Object.values(node)) {
-				if (Array.isArray(value)) {
-					for (const child of value) {
-						visit(child, stack);
-					}
-				} else if (value && typeof value === "object") {
-					visit(value, stack);
-				}
-			}
-		}
-	};
-	module$1.body.forEach((statement) => {
-		visit(statement, []);
-	});
-	const definitions = pending.map((item) => ({
-		canonicalId: (0, __soda_gql_common.createCanonicalId)(module$1.__filePath, item.astPath),
-		astPath: item.astPath,
-		isTopLevel: item.isTopLevel,
-		isExported: item.isExported,
-		exportBinding: item.exportBinding,
-		expression: item.expression
-	}));
-	return {
-		definitions,
-		handledCalls
-	};
-};
-/**
-* SWC adapter implementation.
-* The analyze method parses and collects all data in one pass,
-* ensuring the AST (Module) is released after analysis.
-*/
-const swcAdapter = { analyze(input, helper) {
-	const program = (0, __swc_core.parseSync)(input.source, {
-		syntax: "typescript",
-		tsx: input.filePath.endsWith(".tsx"),
-		target: "es2022",
-		decorators: false,
-		dynamicImport: true
-	});
-	if (program.type !== "Module") {
-		return null;
-	}
-	const spanOffset = program.span.end - input.source.length + 1;
-	const swcModule = program;
-	swcModule.__filePath = input.filePath;
-	swcModule.__spanOffset = spanOffset;
-	const gqlIdentifiers = collectGqlIdentifiers(swcModule, helper);
-	const imports = collectImports$1(swcModule);
-	const exports$1 = collectExports$1(swcModule);
-	const { definitions } = collectAllDefinitions$1({
-		module: swcModule,
-		gqlIdentifiers,
-		imports,
-		exports: exports$1,
-		source: input.source
-	});
-	return {
-		imports,
-		exports: exports$1,
-		definitions
-	};
-} };
-
-//#endregion
-//#region packages/builder/src/ast/adapters/typescript.ts
-/**
-* TypeScript adapter for the analyzer core.
-* Implements parser-specific logic using the TypeScript compiler API.
-*/
-const createSourceFile = (filePath, source) => {
-	const scriptKind = (0, node_path.extname)(filePath) === ".tsx" ? typescript.default.ScriptKind.TSX : typescript.default.ScriptKind.TS;
-	return typescript.default.createSourceFile(filePath, source, typescript.default.ScriptTarget.ES2022, true, scriptKind);
-};
-const collectGqlImports = (sourceFile, helper) => {
-	const identifiers = new Set();
-	sourceFile.statements.forEach((statement) => {
-		if (!typescript.default.isImportDeclaration(statement) || !statement.importClause) {
-			return;
-		}
-		const moduleText = statement.moduleSpecifier.text;
-		if (!helper.isGraphqlSystemImportSpecifier({
-			filePath: sourceFile.fileName,
-			specifier: moduleText
-		})) {
-			return;
-		}
-		if (statement.importClause.namedBindings && typescript.default.isNamedImports(statement.importClause.namedBindings)) {
-			statement.importClause.namedBindings.elements.forEach((element) => {
-				const imported = element.propertyName ? element.propertyName.text : element.name.text;
-				if (imported === "gql") {
-					identifiers.add(element.name.text);
-				}
-			});
-		}
-	});
-	return identifiers;
-};
-const collectImports = (sourceFile) => {
-	const imports = [];
-	sourceFile.statements.forEach((statement) => {
-		if (!typescript.default.isImportDeclaration(statement) || !statement.importClause) {
-			return;
-		}
-		const moduleText = statement.moduleSpecifier.text;
-		const { importClause } = statement;
-		if (importClause.name) {
-			imports.push({
-				source: moduleText,
-				local: importClause.name.text,
-				kind: "default",
-				isTypeOnly: Boolean(importClause.isTypeOnly)
-			});
-		}
-		const { namedBindings } = importClause;
-		if (!namedBindings) {
-			return;
-		}
-		if (typescript.default.isNamespaceImport(namedBindings)) {
-			imports.push({
-				source: moduleText,
-				local: namedBindings.name.text,
-				kind: "namespace",
-				isTypeOnly: Boolean(importClause.isTypeOnly)
-			});
-			return;
-		}
-		namedBindings.elements.forEach((element) => {
-			imports.push({
-				source: moduleText,
-				local: element.name.text,
-				kind: "named",
-				isTypeOnly: Boolean(importClause.isTypeOnly || element.isTypeOnly)
-			});
-		});
-	});
-	return imports;
-};
-const collectExports = (sourceFile) => {
-	const exports$1 = [];
-	sourceFile.statements.forEach((statement) => {
-		if (typescript.default.isExportDeclaration(statement)) {
-			const moduleSpecifier = statement.moduleSpecifier ? statement.moduleSpecifier.text : undefined;
-			if (statement.exportClause && typescript.default.isNamedExports(statement.exportClause)) {
-				statement.exportClause.elements.forEach((element) => {
-					if (moduleSpecifier) {
-						exports$1.push({
-							kind: "reexport",
-							exported: element.name.text,
-							local: element.propertyName ? element.propertyName.text : undefined,
-							source: moduleSpecifier,
-							isTypeOnly: Boolean(statement.isTypeOnly || element.isTypeOnly)
-						});
-					} else {
-						exports$1.push({
-							kind: "named",
-							exported: element.name.text,
-							local: element.propertyName ? element.propertyName.text : element.name.text,
-							isTypeOnly: Boolean(statement.isTypeOnly || element.isTypeOnly)
-						});
-					}
-				});
-				return;
-			}
-			if (moduleSpecifier) {
-				exports$1.push({
-					kind: "reexport",
-					exported: "*",
-					source: moduleSpecifier,
-					isTypeOnly: Boolean(statement.isTypeOnly)
-				});
-			}
-			return;
-		}
-		if (typescript.default.isExportAssignment(statement)) {
-			exports$1.push({
-				kind: "named",
-				exported: "default",
-				local: "default",
-				isTypeOnly: false
-			});
-		}
-		if (typescript.default.isVariableStatement(statement) && statement.modifiers?.some((modifier) => modifier.kind === typescript.default.SyntaxKind.ExportKeyword)) {
-			statement.declarationList.declarations.forEach((declaration) => {
-				if (typescript.default.isIdentifier(declaration.name)) {
-					exports$1.push({
-						kind: "named",
-						exported: declaration.name.text,
-						local: declaration.name.text,
-						isTypeOnly: false
-					});
-				}
-			});
-		}
-		if (typescript.default.isFunctionDeclaration(statement) && statement.modifiers?.some((modifier) => modifier.kind === typescript.default.SyntaxKind.ExportKeyword) && statement.name) {
-			exports$1.push({
-				kind: "named",
-				exported: statement.name.text,
-				local: statement.name.text,
-				isTypeOnly: false
-			});
-		}
-	});
-	return exports$1;
-};
-const isGqlDefinitionCall = (identifiers, callExpression) => {
-	const expression = callExpression.expression;
-	if (!typescript.default.isPropertyAccessExpression(expression)) {
-		return false;
-	}
-	if (!typescript.default.isIdentifier(expression.expression) || !identifiers.has(expression.expression.text)) {
-		return false;
-	}
-	const [factory] = callExpression.arguments;
-	if (!factory || !typescript.default.isArrowFunction(factory)) {
-		return false;
-	}
-	return true;
-};
-/**
-* Unwrap method chains (like .attach()) to find the underlying gql call.
-* Returns the innermost CallExpression that is a valid gql definition call.
-*/
-const unwrapMethodChains = (identifiers, node) => {
-	if (!typescript.default.isCallExpression(node)) {
-		return null;
-	}
-	if (isGqlDefinitionCall(identifiers, node)) {
-		return node;
-	}
-	const expression = node.expression;
-	if (!typescript.default.isPropertyAccessExpression(expression)) {
-		return null;
-	}
-	return unwrapMethodChains(identifiers, expression.expression);
-};
-/**
-* Get property name from AST node
-*/
-const getPropertyName = (name) => {
-	if (typescript.default.isIdentifier(name)) {
-		return name.text;
-	}
-	if (typescript.default.isStringLiteral(name) || typescript.default.isNumericLiteral(name)) {
-		return name.text;
-	}
-	return null;
-};
-/**
-* Collect all gql definitions (exported, non-exported, top-level, nested)
-*/
-const collectAllDefinitions = ({ sourceFile, identifiers, exports: exports$1 }) => {
-	const pending = [];
-	const handledCalls = [];
-	const exportBindings = createExportBindingsMap(exports$1);
-	const tracker = (0, __soda_gql_common.createCanonicalTracker)({
-		filePath: sourceFile.fileName,
-		getExportName: (localName) => exportBindings.get(localName)
-	});
-	const anonymousCounters = new Map();
-	const getAnonymousName = (kind) => {
-		const count = anonymousCounters.get(kind) ?? 0;
-		anonymousCounters.set(kind, count + 1);
-		return `_${kind}_${count}`;
-	};
-	const withScope = (stack, segment, kind, stableKey, callback) => {
-		const handle = tracker.enterScope({
-			segment,
-			kind,
-			stableKey
-		});
-		try {
-			const frame = {
-				nameSegment: segment,
-				kind
-			};
-			return callback([...stack, frame]);
-		} finally {
-			tracker.exitScope(handle);
-		}
-	};
-	const visit = (node, stack) => {
-		if (typescript.default.isCallExpression(node)) {
-			const gqlCall = unwrapMethodChains(identifiers, node);
-			if (gqlCall) {
-				const needsAnonymousScope = tracker.currentDepth() === 0;
-				let anonymousScopeHandle;
-				if (needsAnonymousScope) {
-					const anonymousName = getAnonymousName("anonymous");
-					anonymousScopeHandle = tracker.enterScope({
-						segment: anonymousName,
-						kind: "expression",
-						stableKey: "anonymous"
-					});
-				}
-				try {
-					const { astPath } = tracker.registerDefinition();
-					const isTopLevel = stack.length === 1;
-					let isExported = false;
-					let exportBinding;
-					if (isTopLevel && stack[0]) {
-						const topLevelName = stack[0].nameSegment;
-						if (exportBindings.has(topLevelName)) {
-							isExported = true;
-							exportBinding = exportBindings.get(topLevelName);
-						}
-					}
-					handledCalls.push(node);
-					pending.push({
-						astPath,
-						isTopLevel,
-						isExported,
-						exportBinding,
-						expression: gqlCall.getText(sourceFile)
-					});
-				} finally {
-					if (anonymousScopeHandle) {
-						tracker.exitScope(anonymousScopeHandle);
-					}
-				}
-				return;
-			}
-		}
-		if (typescript.default.isVariableDeclaration(node) && node.name && typescript.default.isIdentifier(node.name)) {
-			const varName = node.name.text;
-			if (node.initializer) {
-				const next = node.initializer;
-				withScope(stack, varName, "variable", `var:${varName}`, (newStack) => {
-					visit(next, newStack);
-				});
-			}
-			return;
-		}
-		if (typescript.default.isFunctionDeclaration(node)) {
-			const funcName = node.name?.text ?? getAnonymousName("function");
-			if (node.body) {
-				const next = node.body;
-				withScope(stack, funcName, "function", `func:${funcName}`, (newStack) => {
-					typescript.default.forEachChild(next, (child) => visit(child, newStack));
-				});
-			}
-			return;
-		}
-		if (typescript.default.isArrowFunction(node)) {
-			const arrowName = getAnonymousName("arrow");
-			withScope(stack, arrowName, "function", "arrow", (newStack) => {
-				if (typescript.default.isBlock(node.body)) {
-					typescript.default.forEachChild(node.body, (child) => visit(child, newStack));
-				} else {
-					visit(node.body, newStack);
-				}
-			});
-			return;
-		}
-		if (typescript.default.isFunctionExpression(node)) {
-			const funcName = node.name?.text ?? getAnonymousName("function");
-			if (node.body) {
-				withScope(stack, funcName, "function", `func:${funcName}`, (newStack) => {
-					typescript.default.forEachChild(node.body, (child) => visit(child, newStack));
-				});
-			}
-			return;
-		}
-		if (typescript.default.isClassDeclaration(node)) {
-			const className = node.name?.text ?? getAnonymousName("class");
-			withScope(stack, className, "class", `class:${className}`, (classStack) => {
-				node.members.forEach((member) => {
-					if (typescript.default.isMethodDeclaration(member) || typescript.default.isPropertyDeclaration(member)) {
-						const memberName = member.name && typescript.default.isIdentifier(member.name) ? member.name.text : null;
-						if (memberName) {
-							const memberKind = typescript.default.isMethodDeclaration(member) ? "method" : "property";
-							withScope(classStack, memberName, memberKind, `member:${className}.${memberName}`, (memberStack) => {
-								if (typescript.default.isMethodDeclaration(member) && member.body) {
-									typescript.default.forEachChild(member.body, (child) => visit(child, memberStack));
-								} else if (typescript.default.isPropertyDeclaration(member) && member.initializer) {
-									visit(member.initializer, memberStack);
-								}
-							});
-						}
-					}
-				});
-			});
-			return;
-		}
-		if (typescript.default.isPropertyAssignment(node)) {
-			const propName = getPropertyName(node.name);
-			if (propName) {
-				withScope(stack, propName, "property", `prop:${propName}`, (newStack) => {
-					visit(node.initializer, newStack);
-				});
-			}
-			return;
-		}
-		typescript.default.forEachChild(node, (child) => visit(child, stack));
-	};
-	sourceFile.statements.forEach((statement) => {
-		visit(statement, []);
-	});
-	const definitions = pending.map((item) => ({
-		canonicalId: (0, __soda_gql_common.createCanonicalId)(sourceFile.fileName, item.astPath),
-		astPath: item.astPath,
-		isTopLevel: item.isTopLevel,
-		isExported: item.isExported,
-		exportBinding: item.exportBinding,
-		expression: item.expression
-	}));
-	return {
-		definitions,
-		handledCalls
-	};
-};
-/**
-* TypeScript adapter implementation.
-* The analyze method parses and collects all data in one pass,
-* ensuring the AST (ts.SourceFile) is released after analysis.
-*/
-const typescriptAdapter = { analyze(input, helper) {
-	const sourceFile = createSourceFile(input.filePath, input.source);
-	const gqlIdentifiers = collectGqlImports(sourceFile, helper);
-	const imports = collectImports(sourceFile);
-	const exports$1 = collectExports(sourceFile);
-	const { definitions } = collectAllDefinitions({
-		sourceFile,
-		identifiers: gqlIdentifiers,
-		exports: exports$1
-	});
-	return {
-		imports,
-		exports: exports$1,
-		definitions
-	};
-} };
-
-//#endregion
-//#region packages/builder/src/ast/core.ts
-/**
-* Core analyzer logic that orchestrates the analysis pipeline.
-* Adapters (TypeScript, SWC, etc.) implement the adapter interface to plug into this pipeline.
-*/
-/**
-* Core analyzer function that orchestrates the analysis pipeline.
-* Adapters implement the AnalyzerAdapter interface to provide parser-specific logic.
-*/
-const analyzeModuleCore = (input, adapter, graphqlHelper) => {
-	const hasher = (0, __soda_gql_common.getPortableHasher)();
-	const signature = hasher.hash(input.source, "xxhash");
-	const result = adapter.analyze(input, graphqlHelper);
-	if (!result) {
-		return {
-			filePath: input.filePath,
-			signature,
-			definitions: [],
-			imports: [],
-			exports: []
-		};
-	}
-	return {
-		filePath: input.filePath,
-		signature,
-		definitions: result.definitions,
-		imports: result.imports,
-		exports: result.exports
-	};
-};
-
-//#endregion
-//#region packages/builder/src/ast/index.ts
-const createAstAnalyzer = ({ analyzer, graphqlHelper }) => {
-	const analyze = (input) => {
-		if (analyzer === "ts") {
-			return analyzeModuleCore(input, typescriptAdapter, graphqlHelper);
-		}
-		if (analyzer === "swc") {
-			return analyzeModuleCore(input, swcAdapter, graphqlHelper);
-		}
-		return assertUnreachable(analyzer, "createAstAnalyzer");
-	};
-	return {
-		type: analyzer,
-		analyze
-	};
-};
-
-//#endregion
-//#region packages/builder/src/cache/memory-cache.ts
-const sanitizeSegment = (segment) => segment.replace(/[\\/]/g, "_");
-const toNamespaceKey = (segments) => segments.map(sanitizeSegment).join("/");
-const toEntryKey = (key) => {
-	const hasher = (0, __soda_gql_common.getPortableHasher)();
-	return hasher.hash(key, "xxhash");
-};
-const PERSISTENCE_VERSION = "v1";
-/**
-* Validate persisted data structure.
-* Uses simple validation to detect corruption without strict schema.
-*/
-const isValidPersistedData = (data) => {
-	if (typeof data !== "object" || data === null) return false;
-	const record = data;
-	if (typeof record.version !== "string") return false;
-	if (typeof record.storage !== "object" || record.storage === null) return false;
-	for (const value of Object.values(record.storage)) {
-		if (!Array.isArray(value)) return false;
-		for (const entry of value) {
-			if (!Array.isArray(entry) || entry.length !== 2) return false;
-			if (typeof entry[0] !== "string") return false;
-			const envelope = entry[1];
-			if (typeof envelope !== "object" || envelope === null) return false;
-			const env = envelope;
-			if (typeof env.key !== "string" || typeof env.version !== "string") return false;
-		}
-	}
-	return true;
-};
-const createMemoryCache = ({ prefix = [], persistence } = {}) => {
-	const storage = new Map();
-	if (persistence?.enabled) {
-		try {
-			if ((0, node_fs.existsSync)(persistence.filePath)) {
-				const content = (0, node_fs.readFileSync)(persistence.filePath, "utf-8");
-				let parsed;
-				try {
-					parsed = JSON.parse(content);
-				} catch {
-					console.warn(`[cache] Corrupt cache file (invalid JSON), starting fresh: ${persistence.filePath}`);
-					try {
-						(0, node_fs.unlinkSync)(persistence.filePath);
-					} catch {}
-					parsed = null;
-				}
-				if (parsed) {
-					if (!isValidPersistedData(parsed)) {
-						console.warn(`[cache] Corrupt cache file (invalid structure), starting fresh: ${persistence.filePath}`);
-						try {
-							(0, node_fs.unlinkSync)(persistence.filePath);
-						} catch {}
-					} else if (parsed.version === PERSISTENCE_VERSION) {
-						for (const [namespaceKey, entries] of Object.entries(parsed.storage)) {
-							const namespaceMap = new Map();
-							for (const [hashedKey, envelope] of entries) {
-								namespaceMap.set(hashedKey, envelope);
-							}
-							storage.set(namespaceKey, namespaceMap);
-						}
-					}
-				}
-			}
-		} catch (error) {
-			console.warn(`[cache] Failed to load cache from ${persistence.filePath}:`, error);
-		}
-	}
-	const getOrCreateNamespace = (namespaceKey) => {
-		let namespace = storage.get(namespaceKey);
-		if (!namespace) {
-			namespace = new Map();
-			storage.set(namespaceKey, namespace);
-		}
-		return namespace;
-	};
-	return {
-		createStore: ({ namespace, schema, version = "v1" }) => {
-			const namespaceKey = toNamespaceKey([...prefix, ...namespace]);
-			const envelopeSchema = zod.z.object({
-				key: zod.z.string(),
-				version: zod.z.string(),
-				value: schema
-			});
-			const resolveEntryKey = (key) => toEntryKey(key);
-			const validateEnvelope = (raw) => {
-				const parsed = envelopeSchema.safeParse(raw);
-				if (!parsed.success) {
-					return null;
-				}
-				if (parsed.data.version !== version) {
-					return null;
-				}
-				return parsed.data;
-			};
-			const load = (key) => {
-				const namespaceStore = storage.get(namespaceKey);
-				if (!namespaceStore) {
-					return null;
-				}
-				const entryKey = resolveEntryKey(key);
-				const raw = namespaceStore.get(entryKey);
-				if (!raw) {
-					return null;
-				}
-				const envelope = validateEnvelope(raw);
-				if (!envelope || envelope.key !== key) {
-					namespaceStore.delete(entryKey);
-					return null;
-				}
-				return envelope.value;
-			};
-			const store = (key, value) => {
-				const namespaceStore = getOrCreateNamespace(namespaceKey);
-				const entryKey = resolveEntryKey(key);
-				const envelope = {
-					key,
-					version,
-					value
-				};
-				namespaceStore.set(entryKey, envelope);
-			};
-			const deleteEntry = (key) => {
-				const namespaceStore = storage.get(namespaceKey);
-				if (!namespaceStore) {
-					return;
-				}
-				const entryKey = resolveEntryKey(key);
-				namespaceStore.delete(entryKey);
-			};
-			function* iterateEntries() {
-				const namespaceStore = storage.get(namespaceKey);
-				if (!namespaceStore) {
-					return;
-				}
-				for (const raw of namespaceStore.values()) {
-					const envelope = validateEnvelope(raw);
-					if (!envelope) {
-						continue;
-					}
-					yield [envelope.key, envelope.value];
-				}
-			}
-			const clear = () => {
-				const namespaceStore = storage.get(namespaceKey);
-				if (namespaceStore) {
-					namespaceStore.clear();
-				}
-			};
-			const size = () => {
-				let count = 0;
-				for (const _ of iterateEntries()) {
-					count += 1;
-				}
-				return count;
-			};
-			return {
-				load,
-				store,
-				delete: deleteEntry,
-				entries: iterateEntries,
-				clear,
-				size
-			};
-		},
-		clearAll: () => {
-			storage.clear();
-		},
-		save: () => {
-			if (!persistence?.enabled) {
-				return;
-			}
-			try {
-				const serialized = {};
-				for (const [namespaceKey, namespaceMap] of storage.entries()) {
-					serialized[namespaceKey] = Array.from(namespaceMap.entries());
-				}
-				const data = {
-					version: PERSISTENCE_VERSION,
-					storage: serialized
-				};
-				const fs = (0, __soda_gql_common.getPortableFS)();
-				fs.writeFileSyncAtomic(persistence.filePath, JSON.stringify(data));
-			} catch (error) {
-				console.warn(`[cache] Failed to save cache to ${persistence.filePath}:`, error);
-			}
-		}
-	};
-};
-
-//#endregion
-//#region packages/builder/src/cache/entity-cache.ts
-/**
-* Abstract base class for entity caches.
-* Provides common caching functionality with signature-based eviction.
-*/
-var EntityCache = class {
-	cacheStore;
-	keyNormalizer;
-	constructor(options) {
-		this.cacheStore = options.factory.createStore({
-			namespace: [...options.namespace],
-			schema: options.schema,
-			version: options.version
-		});
-		this.keyNormalizer = options.keyNormalizer ?? __soda_gql_common.normalizePath;
-	}
-	/**
-	* Normalize a key for consistent cache lookups.
-	*/
-	normalizeKey(key) {
-		return this.keyNormalizer(key);
-	}
-	/**
-	* Load raw value from cache without signature validation.
-	*/
-	loadRaw(key) {
-		return this.cacheStore.load(key);
-	}
-	/**
-	* Store raw value to cache.
-	*/
-	storeRaw(key, value) {
-		this.cacheStore.store(key, value);
-	}
-	/**
-	* Delete an entry from the cache.
-	*/
-	delete(key) {
-		const normalizedKey = this.normalizeKey(key);
-		this.cacheStore.delete(normalizedKey);
-	}
-	/**
-	* Get all cached entries.
-	* Subclasses should override this to provide custom iteration.
-	*/
-	*baseEntries() {
-		for (const [, value] of this.cacheStore.entries()) {
-			yield value;
-		}
-	}
-	/**
-	* Clear all entries from the cache.
-	*/
-	clear() {
-		this.cacheStore.clear();
-	}
-	/**
-	* Get the number of entries in the cache.
-	*/
-	size() {
-		return this.cacheStore.size();
-	}
-};
-
-//#endregion
-//#region packages/builder/src/schemas/cache.ts
-const ModuleDefinitionSchema = zod.z.object({
-	canonicalId: __soda_gql_common.CanonicalIdSchema,
-	astPath: zod.z.string(),
-	isTopLevel: zod.z.boolean(),
-	isExported: zod.z.boolean(),
-	exportBinding: zod.z.string().optional(),
-	expression: zod.z.string()
-});
-const ModuleImportSchema = zod.z.object({
-	source: zod.z.string(),
-	local: zod.z.string(),
-	kind: zod.z.enum([
-		"named",
-		"namespace",
-		"default"
-	]),
-	isTypeOnly: zod.z.boolean()
-});
-const ModuleExportSchema = zod.z.discriminatedUnion("kind", [zod.z.object({
-	kind: zod.z.literal("named"),
-	exported: zod.z.string(),
-	local: zod.z.string(),
-	source: zod.z.undefined().optional(),
-	isTypeOnly: zod.z.boolean()
-}), zod.z.object({
-	kind: zod.z.literal("reexport"),
-	exported: zod.z.string(),
-	source: zod.z.string(),
-	local: zod.z.string().optional(),
-	isTypeOnly: zod.z.boolean()
-})]);
-const ModuleAnalysisSchema = zod.z.object({
-	filePath: zod.z.string(),
-	signature: zod.z.string(),
-	definitions: zod.z.array(ModuleDefinitionSchema).readonly(),
-	imports: zod.z.array(ModuleImportSchema).readonly(),
-	exports: zod.z.array(ModuleExportSchema).readonly()
-});
-
-//#endregion
-//#region packages/builder/src/schemas/discovery.ts
-const FileFingerprintSchema = zod.z.object({
-	hash: zod.z.string(),
-	sizeBytes: zod.z.number(),
-	mtimeMs: zod.z.number()
-});
-const DiscoveredDependencySchema = zod.z.object({
-	specifier: zod.z.string(),
-	resolvedPath: zod.z.string().nullable(),
-	isExternal: zod.z.boolean()
-});
-const DiscoverySnapshotSchema = zod.z.object({
-	filePath: zod.z.string(),
-	normalizedFilePath: zod.z.string(),
-	signature: zod.z.string(),
-	fingerprint: FileFingerprintSchema,
-	analyzer: zod.z.string(),
-	createdAtMs: zod.z.number(),
-	analysis: ModuleAnalysisSchema,
-	dependencies: zod.z.array(DiscoveredDependencySchema).readonly()
-});
-
-//#endregion
-//#region packages/builder/src/discovery/cache.ts
-const DISCOVERY_CACHE_VERSION = "discovery-cache/v3";
-var JsonDiscoveryCache = class extends EntityCache {
-	constructor(options) {
-		const namespace = [
-			...options.namespacePrefix ?? ["discovery"],
-			options.analyzer,
-			options.evaluatorId
-		];
-		super({
-			factory: options.factory,
-			namespace,
-			schema: DiscoverySnapshotSchema,
-			version: options.version ?? DISCOVERY_CACHE_VERSION
-		});
-	}
-	load(filePath, expectedSignature) {
-		const key = this.normalizeKey(filePath);
-		const snapshot = this.loadRaw(key);
-		if (!snapshot) {
-			return null;
-		}
-		if (snapshot.signature !== expectedSignature) {
-			this.delete(filePath);
-			return null;
-		}
-		return snapshot;
-	}
-	peek(filePath) {
-		const key = this.normalizeKey(filePath);
-		return this.loadRaw(key);
-	}
-	store(snapshot) {
-		const key = this.normalizeKey(snapshot.filePath);
-		this.storeRaw(key, snapshot);
-	}
-	entries() {
-		return this.baseEntries();
-	}
-};
-const createDiscoveryCache = (options) => new JsonDiscoveryCache(options);
-
-//#endregion
-//#region packages/builder/src/discovery/common.ts
-/**
-* Extract all unique dependencies (relative + external) from the analysis.
-* Resolves local specifiers immediately so discovery only traverses once.
-*/
-const extractModuleDependencies = (analysis) => {
-	const dependencies = new Map();
-	const addDependency = (specifier) => {
-		if (dependencies.has(specifier)) {
-			return;
-		}
-		const isExternal = (0, __soda_gql_common.isExternalSpecifier)(specifier);
-		const resolvedPath = isExternal ? null : (0, __soda_gql_common.resolveRelativeImportWithExistenceCheck)({
-			filePath: analysis.filePath,
-			specifier
-		});
-		dependencies.set(specifier, {
-			specifier,
-			resolvedPath,
-			isExternal
-		});
-	};
-	for (const imp of analysis.imports) {
-		addDependency(imp.source);
-	}
-	for (const exp of analysis.exports) {
-		if (exp.kind === "reexport") {
-			addDependency(exp.source);
-		}
-	}
-	return Array.from(dependencies.values());
-};
-const createSourceHash = (source) => {
-	const hasher = (0, __soda_gql_common.getPortableHasher)();
-	return hasher.hash(source, "xxhash");
-};
-
-//#endregion
-//#region packages/builder/src/discovery/fingerprint.ts
-/**
-* In-memory fingerprint cache keyed by absolute path
-*/
-const fingerprintCache = new Map();
-/**
-* Lazy-loaded xxhash instance
-*/
-let xxhashInstance = null;
-/**
-* Lazily load xxhash-wasm instance
-*/
-async function getXXHash() {
-	if (xxhashInstance === null) {
-		const { default: xxhash } = await import("xxhash-wasm");
-		xxhashInstance = await xxhash();
-	}
-	return xxhashInstance;
-}
-/**
-* Compute file fingerprint with memoization.
-* Uses mtime to short-circuit re-hashing unchanged files.
-*
-* @param path - Absolute path to file
-* @returns Result containing FileFingerprint or FingerprintError
-*/
-function computeFingerprint(path) {
-	try {
-		const stats = (0, node_fs.statSync)(path);
-		if (!stats.isFile()) {
-			return (0, neverthrow.err)({
-				code: "NOT_A_FILE",
-				path,
-				message: `Path is not a file: ${path}`
-			});
-		}
-		const mtimeMs = stats.mtimeMs;
-		const cached = fingerprintCache.get(path);
-		if (cached && cached.mtimeMs === mtimeMs) {
-			return (0, neverthrow.ok)(cached);
-		}
-		const contents = (0, node_fs.readFileSync)(path);
-		const sizeBytes = stats.size;
-		const hash = computeHashSync(contents);
-		const fingerprint = {
-			hash,
-			sizeBytes,
-			mtimeMs
-		};
-		fingerprintCache.set(path, fingerprint);
-		return (0, neverthrow.ok)(fingerprint);
-	} catch (error) {
-		if (error.code === "ENOENT") {
-			return (0, neverthrow.err)({
-				code: "FILE_NOT_FOUND",
-				path,
-				message: `File not found: ${path}`
-			});
-		}
-		return (0, neverthrow.err)({
-			code: "READ_ERROR",
-			path,
-			message: `Failed to read file: ${error}`
-		});
-	}
-}
-/**
-* Compute hash synchronously.
-* For first call, uses simple string hash as fallback.
-* Subsequent calls will use xxhash after async initialization.
-*/
-function computeHashSync(contents) {
-	if (xxhashInstance !== null) {
-		const hash = xxhashInstance.h64Raw(new Uint8Array(contents));
-		return hash.toString(16);
-	}
-	void getXXHash();
-	return simpleHash(contents);
-}
-/**
-* Simple hash function for initial calls before xxhash loads
-*/
-function simpleHash(buffer) {
-	let hash = 0;
-	for (let i = 0; i < buffer.length; i++) {
-		const byte = buffer[i];
-		if (byte !== undefined) {
-			hash = (hash << 5) - hash + byte;
-			hash = hash & hash;
-		}
-	}
-	return hash.toString(16);
-}
-/**
-* Compute fingerprint from pre-read file content and stats.
-* This is used by the generator-based discoverer which already has the content.
-*
-* @param path - Absolute path to file (for caching)
-* @param stats - File stats (mtimeMs, size)
-* @param content - File content as string
-* @returns FileFingerprint
-*/
-function computeFingerprintFromContent(path, stats, content) {
-	const cached = fingerprintCache.get(path);
-	if (cached && cached.mtimeMs === stats.mtimeMs) {
-		return cached;
-	}
-	const buffer = Buffer.from(content, "utf-8");
-	const hash = computeHashSync(buffer);
-	const fingerprint = {
-		hash,
-		sizeBytes: stats.size,
-		mtimeMs: stats.mtimeMs
-	};
-	fingerprintCache.set(path, fingerprint);
-	return fingerprint;
-}
-/**
-* Invalidate cached fingerprint for a specific path
-*
-* @param path - Absolute path to invalidate
-*/
-function invalidateFingerprint(path) {
-	fingerprintCache.delete(path);
-}
-/**
-* Clear all cached fingerprints
-*/
-function clearFingerprintCache() {
-	fingerprintCache.clear();
-}
-
-//#endregion
-//#region packages/builder/src/discovery/discoverer.ts
-/**
-* Generator-based module discovery that yields effects for file I/O.
-* This allows the discovery process to be executed with either sync or async schedulers.
-*/
-function* discoverModulesGen({ entryPaths, astAnalyzer, incremental }) {
-	const snapshots = new Map();
-	const stack = [...entryPaths];
-	const changedFiles = incremental?.changedFiles ?? new Set();
-	const removedFiles = incremental?.removedFiles ?? new Set();
-	const affectedFiles = incremental?.affectedFiles ?? new Set();
-	const invalidatedSet = new Set([
-		...changedFiles,
-		...removedFiles,
-		...affectedFiles
-	]);
-	let cacheHits = 0;
-	let cacheMisses = 0;
-	let cacheSkips = 0;
-	if (incremental) {
-		for (const filePath of removedFiles) {
-			incremental.cache.delete(filePath);
-			invalidateFingerprint(filePath);
-		}
-	}
-	while (stack.length > 0) {
-		const rawFilePath = stack.pop();
-		if (!rawFilePath) {
-			continue;
-		}
-		const filePath = (0, __soda_gql_common.normalizePath)(rawFilePath);
-		if (snapshots.has(filePath)) {
-			continue;
-		}
-		let shouldReadFile = true;
-		if (invalidatedSet.has(filePath)) {
-			invalidateFingerprint(filePath);
-			cacheSkips++;
-		} else if (incremental) {
-			const cached = incremental.cache.peek(filePath);
-			if (cached) {
-				const stats$1 = yield* new OptionalFileStatEffect(filePath).run();
-				if (stats$1) {
-					const mtimeMs = stats$1.mtimeMs;
-					const sizeBytes = stats$1.size;
-					if (cached.fingerprint.mtimeMs === mtimeMs && cached.fingerprint.sizeBytes === sizeBytes) {
-						snapshots.set(filePath, cached);
-						cacheHits++;
-						for (const dep of cached.dependencies) {
-							if (dep.resolvedPath && !snapshots.has(dep.resolvedPath)) {
-								stack.push(dep.resolvedPath);
-							}
-						}
-						shouldReadFile = false;
-					}
-				}
-			}
-		}
-		if (!shouldReadFile) {
-			continue;
-		}
-		const source = yield* new OptionalFileReadEffect(filePath).run();
-		if (source === null) {
-			incremental?.cache.delete(filePath);
-			invalidateFingerprint(filePath);
-			continue;
-		}
-		const signature = createSourceHash(source);
-		const analysis = astAnalyzer.analyze({
-			filePath,
-			source
-		});
-		cacheMisses++;
-		const dependencies = extractModuleDependencies(analysis);
-		for (const dep of dependencies) {
-			if (!dep.isExternal && dep.resolvedPath && !snapshots.has(dep.resolvedPath)) {
-				stack.push(dep.resolvedPath);
-			}
-		}
-		const stats = yield* new OptionalFileStatEffect(filePath).run();
-		const fingerprint = computeFingerprintFromContent(filePath, stats, source);
-		const snapshot = {
-			filePath,
-			normalizedFilePath: (0, __soda_gql_common.normalizePath)(filePath),
-			signature,
-			fingerprint,
-			analyzer: astAnalyzer.type,
-			createdAtMs: Date.now(),
-			analysis,
-			dependencies
-		};
-		snapshots.set(filePath, snapshot);
-		if (incremental) {
-			incremental.cache.store(snapshot);
-		}
-	}
-	return {
-		snapshots: Array.from(snapshots.values()),
-		cacheHits,
-		cacheMisses,
-		cacheSkips
-	};
-}
-/**
-* Discover and analyze all modules starting from entry points.
-* Uses AST parsing instead of RegExp for reliable dependency extraction.
-* Supports caching with fingerprint-based invalidation to skip re-parsing unchanged files.
-*
-* This function uses the synchronous scheduler internally for backward compatibility.
-* For async execution with parallel file I/O, use discoverModulesGen with an async scheduler.
-*/
-const discoverModules = (options) => {
-	const scheduler = (0, __soda_gql_common.createSyncScheduler)();
-	const result = scheduler.run(() => discoverModulesGen(options));
-	if (result.isErr()) {
-		const error = result.error;
-		return (0, neverthrow.err)(builderErrors.discoveryIOError("unknown", error.message));
-	}
-	return (0, neverthrow.ok)(result.value);
-};
-/**
-* Asynchronous version of discoverModules.
-* Uses async scheduler for parallel file I/O operations.
-*
-* This is useful for large codebases where parallel file operations can improve performance.
-*/
-const discoverModulesAsync = async (options) => {
-	const scheduler = (0, __soda_gql_common.createAsyncScheduler)();
-	const result = await scheduler.run(() => discoverModulesGen(options));
-	if (result.isErr()) {
-		const error = result.error;
-		return (0, neverthrow.err)(builderErrors.discoveryIOError("unknown", error.message));
-	}
-	return (0, neverthrow.ok)(result.value);
-};
-
-//#endregion
-//#region packages/builder/src/utils/glob.ts
-/**
-* Cross-runtime glob pattern matching abstraction
-* Provides a unified interface for glob operations across Bun and Node.js
-*/
-/**
-* Scan files matching a glob pattern from the given directory
-* @param pattern - Glob pattern (e.g., "src/**\/*.ts")
-* @param cwd - Working directory (defaults to process.cwd())
-* @returns Array of matched file paths (relative to cwd)
-*/
-const scanGlob = (pattern, cwd = process.cwd()) => {
-	if (typeof Bun !== "undefined" && Bun.Glob) {
-		const { Glob } = Bun;
-		const glob = new Glob(pattern);
-		return Array.from(glob.scanSync(cwd));
-	}
-	return fast_glob.default.sync(pattern, {
-		cwd,
-		dot: true,
-		onlyFiles: true
-	});
-};
-
-//#endregion
-//#region packages/builder/src/discovery/entry-paths.ts
-const scanEntries = (pattern) => {
-	return scanGlob(pattern, process.cwd());
-};
-/**
-* Resolve entry file paths from glob patterns or direct paths.
-* Used by the discovery system to find entry points for module traversal.
-* All paths are normalized to POSIX format for consistent cache key matching.
-* Uses Node.js normalize() + backslash replacement to match normalizePath from @soda-gql/common.
-*/
-const resolveEntryPaths = (entries) => {
-	const resolvedPaths = entries.flatMap((entry) => {
-		const absolute = (0, node_path.resolve)(entry);
-		if ((0, node_fs.existsSync)(absolute)) {
-			return [(0, node_path.normalize)(absolute).replace(/\\/g, "/")];
-		}
-		const matches = scanEntries(entry).map((match) => {
-			return (0, node_path.normalize)((0, node_path.resolve)(match)).replace(/\\/g, "/");
-		});
-		return matches;
-	});
-	if (resolvedPaths.length === 0) {
-		return (0, neverthrow.err)({
-			code: "ENTRY_NOT_FOUND",
-			message: `No entry files matched ${entries.join(", ")}`,
-			entry: entries.join(", ")
-		});
-	}
-	return (0, neverthrow.ok)(resolvedPaths);
-};
-
-//#endregion
-//#region packages/builder/src/tracker/file-tracker.ts
-/**
-* Create a file tracker that maintains in-memory state for change detection.
-*
-* The tracker keeps file metadata (mtime, size) in memory during the process lifetime
-* and detects which files have been added, updated, or removed. State is scoped to
-* the process and does not persist across restarts.
-*/
-const createFileTracker = () => {
-	let currentScan = { files: new Map() };
-	let nextScan = null;
-	const scan = (extraPaths) => {
-		const allPathsToScan = new Set([...extraPaths, ...currentScan.files.keys()]);
-		const files = new Map();
-		for (const path of allPathsToScan) {
-			try {
-				const normalized = (0, __soda_gql_common.normalizePath)(path);
-				const stats = (0, node_fs.statSync)(normalized);
-				files.set(normalized, {
-					mtimeMs: stats.mtimeMs,
-					size: stats.size
-				});
-			} catch {}
-		}
-		nextScan = { files };
-		return (0, neverthrow.ok)(nextScan);
-	};
-	const detectChanges = () => {
-		const previous = currentScan;
-		const current = nextScan ?? currentScan;
-		const added = new Set();
-		const updated = new Set();
-		const removed = new Set();
-		for (const [path, currentMetadata] of current.files) {
-			const previousMetadata = previous.files.get(path);
-			if (!previousMetadata) {
-				added.add(path);
-			} else if (previousMetadata.mtimeMs !== currentMetadata.mtimeMs || previousMetadata.size !== currentMetadata.size) {
-				updated.add(path);
-			}
-		}
-		for (const path of previous.files.keys()) {
-			if (!current.files.has(path)) {
-				removed.add(path);
-			}
-		}
-		return {
-			added,
-			updated,
-			removed
-		};
-	};
-	const update = (scan$1) => {
-		currentScan = scan$1;
-		nextScan = null;
-	};
-	return {
-		scan,
-		detectChanges,
-		update
-	};
-};
-/**
-* Check if a file diff is empty (no changes detected).
-*/
-const isEmptyDiff = (diff) => {
-	return diff.added.size === 0 && diff.updated.size === 0 && diff.removed.size === 0;
-};
-
-//#endregion
-//#region packages/builder/src/session/dependency-validation.ts
-const validateModuleDependencies = ({ analyses, graphqlSystemHelper }) => {
-	for (const analysis of analyses.values()) {
-		for (const { source, isTypeOnly } of analysis.imports) {
-			if (isTypeOnly) {
-				continue;
-			}
-			if ((0, __soda_gql_common.isRelativeSpecifier)(source)) {
-				if (graphqlSystemHelper.isGraphqlSystemImportSpecifier({
-					filePath: analysis.filePath,
-					specifier: source
-				})) {
-					continue;
-				}
-				const resolvedModule = (0, __soda_gql_common.resolveRelativeImportWithReferences)({
-					filePath: analysis.filePath,
-					specifier: source,
-					references: analyses
-				});
-				if (!resolvedModule) {
-					return (0, neverthrow.err)({
-						code: "MISSING_IMPORT",
-						chain: [analysis.filePath, source]
-					});
-				}
-			}
-		}
-	}
-	return (0, neverthrow.ok)(null);
-};
-
-//#endregion
-//#region packages/builder/src/session/module-adjacency.ts
-/**
-* Extract module-level adjacency from dependency graph.
-* Returns Map of file path -> set of files that import it.
-* All paths are normalized to POSIX format for consistent cache key matching.
-*/
-const extractModuleAdjacency = ({ snapshots }) => {
-	const importsByModule = new Map();
-	for (const snapshot of snapshots.values()) {
-		const { normalizedFilePath, dependencies, analysis } = snapshot;
-		const imports = new Set();
-		for (const { resolvedPath } of dependencies) {
-			if (resolvedPath && resolvedPath !== normalizedFilePath && snapshots.has(resolvedPath)) {
-				imports.add(resolvedPath);
-			}
-		}
-		if (dependencies.length === 0 && analysis.imports.length > 0) {
-			for (const imp of analysis.imports) {
-				if (imp.isTypeOnly) {
-					continue;
-				}
-				const resolved = (0, __soda_gql_common.resolveRelativeImportWithReferences)({
-					filePath: normalizedFilePath,
-					specifier: imp.source,
-					references: snapshots
-				});
-				if (resolved) {
-					imports.add(resolved);
-				}
-			}
-		}
-		if (imports.size > 0) {
-			importsByModule.set(normalizedFilePath, imports);
-		}
-	}
-	const adjacency = new Map();
-	for (const [importer, imports] of importsByModule) {
-		for (const imported of imports) {
-			if (!adjacency.has(imported)) {
-				adjacency.set(imported, new Set());
-			}
-			adjacency.get(imported)?.add(importer);
-		}
-	}
-	for (const modulePath of snapshots.keys()) {
-		if (!adjacency.has(modulePath)) {
-			adjacency.set(modulePath, new Set());
-		}
-	}
-	return adjacency;
-};
-/**
-* Collect all modules affected by changes, including transitive dependents.
-* Uses BFS to traverse module adjacency graph.
-* All paths are already normalized from extractModuleAdjacency.
-*/
-const collectAffectedFiles = (input) => {
-	const { changedFiles, removedFiles, previousModuleAdjacency } = input;
-	const affected = new Set([...changedFiles, ...removedFiles]);
-	const queue = [...changedFiles];
-	const visited = new Set(changedFiles);
-	while (queue.length > 0) {
-		const current = queue.shift();
-		if (!current) break;
-		const dependents = previousModuleAdjacency.get(current);
-		if (dependents) {
-			for (const dependent of dependents) {
-				if (!visited.has(dependent)) {
-					visited.add(dependent);
-					affected.add(dependent);
-					queue.push(dependent);
-				}
-			}
-		}
-	}
-	return affected;
-};
-
-//#endregion
-//#region packages/builder/src/session/builder-session.ts
-/**
-* Singleton state for beforeExit handler registration.
-* Ensures only one handler is registered regardless of how many sessions are created.
-*/
-const exitHandlerState = {
-	registered: false,
-	factories: new Set()
-};
-/**
-* Register a cache factory for save on process exit.
-* Uses singleton pattern to prevent multiple handler registrations.
-*/
-const registerExitHandler = (cacheFactory) => {
-	exitHandlerState.factories.add(cacheFactory);
-	if (!exitHandlerState.registered) {
-		exitHandlerState.registered = true;
-		process.on("beforeExit", () => {
-			for (const factory of exitHandlerState.factories) {
-				factory.save();
-			}
-		});
-	}
-};
-/**
-* Unregister a cache factory from the exit handler.
-*/
-const unregisterExitHandler = (cacheFactory) => {
-	exitHandlerState.factories.delete(cacheFactory);
-};
-/**
-* Reset exit handler state for testing.
-* @internal
-*/
-const __resetExitHandlerForTests = () => {
-	exitHandlerState.registered = false;
-	exitHandlerState.factories.clear();
-};
-/**
-* Create a new builder session.
-*
-* The session maintains in-memory state across builds to enable incremental processing.
-*/
-const createBuilderSession = (options) => {
-	const config = options.config;
-	const evaluatorId = options.evaluatorId ?? "default";
-	const entrypoints = new Set(options.entrypointsOverride ?? config.include);
-	const state = {
-		gen: 0,
-		snapshots: new Map(),
-		moduleAdjacency: new Map(),
-		intermediateModules: new Map(),
-		lastArtifact: null,
-		lastIntermediateElements: null
-	};
-	const cacheFactory = createMemoryCache({
-		prefix: ["builder"],
-		persistence: {
-			enabled: true,
-			filePath: (0, node_path.join)(process.cwd(), "node_modules", ".cache", "soda-gql", "builder", "cache.json")
-		}
-	});
-	registerExitHandler(cacheFactory);
-	const graphqlHelper = createGraphqlSystemIdentifyHelper(config);
-	const ensureAstAnalyzer = (0, __soda_gql_common.cachedFn)(() => createAstAnalyzer({
-		analyzer: config.analyzer,
-		graphqlHelper
-	}));
-	const ensureDiscoveryCache = (0, __soda_gql_common.cachedFn)(() => createDiscoveryCache({
-		factory: cacheFactory,
-		analyzer: config.analyzer,
-		evaluatorId
-	}));
-	const ensureFileTracker = (0, __soda_gql_common.cachedFn)(() => createFileTracker());
-	/**
-	* Prepare build input. Shared between sync and async builds.
-	* Returns either a skip result or the input for buildGen.
-	*/
-	const prepareBuildInput = (force) => {
-		const entryPathsResult = resolveEntryPaths(Array.from(entrypoints));
-		if (entryPathsResult.isErr()) {
-			return (0, neverthrow.err)(entryPathsResult.error);
-		}
-		const entryPaths = entryPathsResult.value;
-		const tracker = ensureFileTracker();
-		const scanResult = tracker.scan(entryPaths);
-		if (scanResult.isErr()) {
-			const trackerError = scanResult.error;
-			return (0, neverthrow.err)(builderErrors.discoveryIOError(trackerError.type === "scan-failed" ? trackerError.path : "unknown", `Failed to scan files: ${trackerError.message}`));
-		}
-		const currentScan = scanResult.value;
-		const diff = tracker.detectChanges();
-		const prepareResult = prepare({
-			diff,
-			entryPaths,
-			lastArtifact: state.lastArtifact,
-			force
-		});
-		if (prepareResult.isErr()) {
-			return (0, neverthrow.err)(prepareResult.error);
-		}
-		if (prepareResult.value.type === "should-skip") {
-			return (0, neverthrow.ok)({
-				type: "skip",
-				artifact: prepareResult.value.data.artifact
-			});
-		}
-		const { changedFiles, removedFiles } = prepareResult.value.data;
-		return (0, neverthrow.ok)({
-			type: "build",
-			input: {
-				entryPaths,
-				astAnalyzer: ensureAstAnalyzer(),
-				discoveryCache: ensureDiscoveryCache(),
-				changedFiles,
-				removedFiles,
-				previousModuleAdjacency: state.moduleAdjacency,
-				previousIntermediateModules: state.intermediateModules,
-				graphqlSystemPath: (0, node_path.resolve)(config.outdir, "index.ts"),
-				graphqlHelper
-			},
-			currentScan
-		});
-	};
-	/**
-	* Finalize build and update session state.
-	*/
-	const finalizeBuild = (genResult, currentScan) => {
-		const { snapshots, analyses, currentModuleAdjacency, intermediateModules, elements, stats } = genResult;
-		const artifactResult = buildArtifact({
-			analyses,
-			elements,
-			stats
-		});
-		if (artifactResult.isErr()) {
-			return (0, neverthrow.err)(artifactResult.error);
-		}
-		state.gen++;
-		state.snapshots = snapshots;
-		state.moduleAdjacency = currentModuleAdjacency;
-		state.lastArtifact = artifactResult.value;
-		state.intermediateModules = intermediateModules;
-		state.lastIntermediateElements = elements;
-		ensureFileTracker().update(currentScan);
-		return (0, neverthrow.ok)(artifactResult.value);
-	};
-	/**
-	* Synchronous build using SyncScheduler.
-	* Throws if any element requires async operations.
-	*/
-	const build = (options$1) => {
-		const prepResult = prepareBuildInput(options$1?.force ?? false);
-		if (prepResult.isErr()) {
-			return (0, neverthrow.err)(prepResult.error);
-		}
-		if (prepResult.value.type === "skip") {
-			return (0, neverthrow.ok)(prepResult.value.artifact);
-		}
-		const { input, currentScan } = prepResult.value;
-		const scheduler = (0, __soda_gql_common.createSyncScheduler)();
-		try {
-			const result = scheduler.run(() => buildGen(input));
-			if (result.isErr()) {
-				return (0, neverthrow.err)(convertSchedulerError(result.error));
-			}
-			return finalizeBuild(result.value, currentScan);
-		} catch (error) {
-			if (error && typeof error === "object" && "code" in error) {
-				return (0, neverthrow.err)(error);
-			}
-			throw error;
-		}
-	};
-	/**
-	* Asynchronous build using AsyncScheduler.
-	* Supports async metadata factories and parallel element evaluation.
-	*/
-	const buildAsync = async (options$1) => {
-		const prepResult = prepareBuildInput(options$1?.force ?? false);
-		if (prepResult.isErr()) {
-			return (0, neverthrow.err)(prepResult.error);
-		}
-		if (prepResult.value.type === "skip") {
-			return (0, neverthrow.ok)(prepResult.value.artifact);
-		}
-		const { input, currentScan } = prepResult.value;
-		const scheduler = (0, __soda_gql_common.createAsyncScheduler)();
-		try {
-			const result = await scheduler.run(() => buildGen(input));
-			if (result.isErr()) {
-				return (0, neverthrow.err)(convertSchedulerError(result.error));
-			}
-			return finalizeBuild(result.value, currentScan);
-		} catch (error) {
-			if (error && typeof error === "object" && "code" in error) {
-				return (0, neverthrow.err)(error);
-			}
-			throw error;
-		}
-	};
-	return {
-		build,
-		buildAsync,
-		getGeneration: () => state.gen,
-		getCurrentArtifact: () => state.lastArtifact,
-		getIntermediateElements: () => state.lastIntermediateElements,
-		dispose: () => {
-			cacheFactory.save();
-			unregisterExitHandler(cacheFactory);
-		}
-	};
-};
-const prepare = (input) => {
-	const { diff, lastArtifact, force } = input;
-	const changedFiles = new Set([...diff.added, ...diff.updated]);
-	const removedFiles = diff.removed;
-	if (!force && isEmptyDiff(diff) && lastArtifact) {
-		return (0, neverthrow.ok)({
-			type: "should-skip",
-			data: { artifact: lastArtifact }
-		});
-	}
-	return (0, neverthrow.ok)({
-		type: "should-build",
-		data: {
-			changedFiles,
-			removedFiles
-		}
-	});
-};
-/**
-* Unified build generator that yields effects for file I/O and element evaluation.
-* This enables single scheduler control at the root level for both sync and async execution.
-*/
-function* buildGen(input) {
-	const { entryPaths, astAnalyzer, discoveryCache, changedFiles, removedFiles, previousModuleAdjacency, previousIntermediateModules, graphqlSystemPath, graphqlHelper } = input;
-	const affectedFiles = collectAffectedFiles({
-		changedFiles,
-		removedFiles,
-		previousModuleAdjacency
-	});
-	const discoveryResult = yield* discoverModulesGen({
-		entryPaths,
-		astAnalyzer,
-		incremental: {
-			cache: discoveryCache,
-			changedFiles,
-			removedFiles,
-			affectedFiles
-		}
-	});
-	const { cacheHits, cacheMisses, cacheSkips } = discoveryResult;
-	const snapshots = new Map(discoveryResult.snapshots.map((snapshot) => [snapshot.normalizedFilePath, snapshot]));
-	const analyses = new Map(discoveryResult.snapshots.map((snapshot) => [snapshot.normalizedFilePath, snapshot.analysis]));
-	const dependenciesValidationResult = validateModuleDependencies({
-		analyses,
-		graphqlSystemHelper: graphqlHelper
-	});
-	if (dependenciesValidationResult.isErr()) {
-		const error = dependenciesValidationResult.error;
-		throw builderErrors.graphMissingImport(error.chain[0], error.chain[1]);
-	}
-	const currentModuleAdjacency = extractModuleAdjacency({ snapshots });
-	const stats = {
-		hits: cacheHits,
-		misses: cacheMisses,
-		skips: cacheSkips
-	};
-	const intermediateModules = new Map(previousIntermediateModules);
-	const targetFiles = new Set(affectedFiles);
-	for (const filePath of analyses.keys()) {
-		if (!previousIntermediateModules.has(filePath)) {
-			targetFiles.add(filePath);
-		}
-	}
-	if (targetFiles.size === 0) {
-		for (const filePath of analyses.keys()) {
-			targetFiles.add(filePath);
-		}
-	}
-	for (const targetFilePath of targetFiles) {
-		intermediateModules.delete(targetFilePath);
-	}
-	for (const intermediateModule of generateIntermediateModules({
-		analyses,
-		targetFiles,
-		graphqlSystemPath
-	})) {
-		intermediateModules.set(intermediateModule.filePath, intermediateModule);
-	}
-	const elements = yield* evaluateIntermediateModulesGen({
-		intermediateModules,
-		graphqlSystemPath,
-		analyses
-	});
-	return {
-		snapshots,
-		analyses,
-		currentModuleAdjacency,
-		intermediateModules,
-		elements,
-		stats
-	};
-}
-/**
-* Convert scheduler error to builder error.
-* If the cause is already a BuilderError, return it directly to preserve error codes.
-*/
-const convertSchedulerError = (error) => {
-	if (error.cause && typeof error.cause === "object" && "code" in error.cause) {
-		return error.cause;
-	}
-	return builderErrors.internalInvariant(error.message, "scheduler", error.cause);
-};
-
-//#endregion
-//#region packages/builder/src/service.ts
-/**
-* Create a builder service instance with session support.
-*
-* The service maintains a long-lived session for incremental builds.
-* File changes are automatically detected using an internal file tracker.
-* First build() call initializes the session, subsequent calls perform
-* incremental builds based on detected file changes.
-*
-* Note: Empty entry arrays will produce ENTRY_NOT_FOUND errors at build time.
-*
-* @param config - Builder configuration including entry patterns, analyzer, mode, and optional debugDir
-* @returns BuilderService instance
-*/
-const createBuilderService = ({ config, entrypointsOverride }) => {
-	const session = createBuilderSession({
-		config,
-		entrypointsOverride
-	});
-	return {
-		build: (options) => session.build(options),
-		buildAsync: (options) => session.buildAsync(options),
-		getGeneration: () => session.getGeneration(),
-		getCurrentArtifact: () => session.getCurrentArtifact(),
-		getIntermediateElements: () => session.getIntermediateElements(),
-		dispose: () => session.dispose()
-	};
+	return (0, neverthrow.ok)(schemas);
 };
 
 //#endregion
-exports.BuilderArtifactSchema = BuilderArtifactSchema;
-exports.BuilderEffects = BuilderEffects;
-exports.FileReadEffect = FileReadEffect;
-exports.FileStatEffect = FileStatEffect;
-exports.__clearGqlCache = __clearGqlCache;
-exports.builderErrors = builderErrors;
-exports.collectAffectedFiles = collectAffectedFiles;
-exports.createBuilderService = createBuilderService;
-exports.createBuilderSession = createBuilderSession;
-exports.createGraphqlSystemIdentifyHelper = createGraphqlSystemIdentifyHelper;
+exports.BuilderArtifactSchema = require_service.BuilderArtifactSchema;
+exports.BuilderEffects = require_service.BuilderEffects;
+exports.FileReadEffect = require_service.FileReadEffect;
+exports.FileStatEffect = require_service.FileStatEffect;
+exports.__clearGqlCache = require_service.__clearGqlCache;
+exports.builderErrors = require_service.builderErrors;
+exports.collectAffectedFiles = require_service.collectAffectedFiles;
+exports.createBuilderService = require_service.createBuilderService;
+exports.createBuilderSession = require_service.createBuilderSession;
+exports.createDiagnostic = require_service.createDiagnostic;
+exports.createGraphqlSystemIdentifyHelper = require_service.createGraphqlSystemIdentifyHelper;
+exports.createStandardDiagnostic = require_service.createStandardDiagnostic;
+exports.diagnosticMessages = require_service.diagnosticMessages;
 exports.extractFieldSelections = extractFieldSelections;
-exports.extractModuleAdjacency = extractModuleAdjacency;
-exports.formatBuilderErrorForCLI = formatBuilderErrorForCLI;
-exports.formatBuilderErrorStructured = formatBuilderErrorStructured;
-exports.loadArtifact = loadArtifact;
-exports.loadArtifactSync = loadArtifactSync;
+exports.extractModuleAdjacency = require_service.extractModuleAdjacency;
+exports.formatBuilderErrorForCLI = require_service.formatBuilderErrorForCLI;
+exports.formatBuilderErrorStructured = require_service.formatBuilderErrorStructured;
+exports.getSeverity = require_service.getSeverity;
+exports.loadArtifact = require_service.loadArtifact;
+exports.loadArtifactSync = require_service.loadArtifactSync;
 exports.loadSchemasFromBundle = loadSchemasFromBundle;
 //# sourceMappingURL=index.cjs.map