@soda-gql/builder 0.10.2 → 0.11.1

package/dist/service-nHDX5qIj.cjs

@@ -0,0 +1,4384 @@
+//#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
+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 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
+/**
+* Load a pre-built artifact from a JSON file asynchronously.
+*
+* @param path - Absolute path to the artifact JSON file
+* @returns Result with the parsed artifact or an error
+*
+* @example
+* ```ts
+* const result = await loadArtifact("/path/to/artifact.json");
+* if (result.isOk()) {
+*   const artifact = result.value;
+*   // Use artifact...
+* }
+* ```
+*/
+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
+		});
+	}
+	return parseAndValidateArtifact(content, path);
+};
+/**
+* Load a pre-built artifact from a JSON file synchronously.
+*
+* @param path - Absolute path to the artifact JSON file
+* @returns Result with the parsed artifact or an error
+*
+* @example
+* ```ts
+* const result = loadArtifactSync("/path/to/artifact.json");
+* if (result.isOk()) {
+*   const artifact = result.value;
+*   // Use artifact...
+* }
+* ```
+*/
+const loadArtifactSync = (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 = (0, node_fs.readFileSync)(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
+		});
+	}
+	return parseAndValidateArtifact(content, path);
+};
+/**
+* Parse JSON content and validate against BuilderArtifactSchema.
+*/
+function parseAndValidateArtifact(content, filePath) {
+	let parsed;
+	try {
+		parsed = JSON.parse(content);
+	} catch (error) {
+		return (0, neverthrow.err)({
+			code: "ARTIFACT_PARSE_ERROR",
+			message: `Invalid JSON in artifact file: ${error instanceof Error ? error.message : String(error)}`,
+			filePath
+		});
+	}
+	const validated = BuilderArtifactSchema.safeParse(parsed);
+	if (!validated.success) {
+		return (0, neverthrow.err)({
+			code: "ARTIFACT_VALIDATION_ERROR",
+			message: `Invalid artifact structure: ${validated.error.message}`,
+			filePath
+		});
+	}
+	return (0, neverthrow.ok)(validated.data);
+}
+
+//#endregion
+//#region packages/builder/src/ast/common/detection.ts
+/**
+* Create a diagnostic with appropriate severity
+*/
+const createDiagnostic = (config) => ({
+	code: config.code,
+	severity: getSeverity(config.code),
+	message: config.message,
+	location: config.location,
+	context: config.context
+});
+/**
+* Get severity for a diagnostic code.
+* - "error": Code will definitely not work
+* - "warning": Code might work but is unsupported/unreliable
+*/
+const getSeverity = (code) => {
+	switch (code) {
+		case "MISSING_ARGUMENT":
+		case "INVALID_ARGUMENT_TYPE":
+		case "NON_MEMBER_CALLEE":
+		case "OPTIONAL_CHAINING":
+		case "SPREAD_ARGUMENT": return "error";
+		case "RENAMED_IMPORT":
+		case "STAR_IMPORT":
+		case "DEFAULT_IMPORT":
+		case "COMPUTED_PROPERTY":
+		case "DYNAMIC_CALLEE":
+		case "CLASS_PROPERTY":
+		case "EXTRA_ARGUMENTS": return "warning";
+	}
+};
+/**
+* Diagnostic message templates for each code
+*/
+const diagnosticMessages = {
+	RENAMED_IMPORT: (ctx) => `Import alias "${ctx?.importedAs ?? "?"}" not recognized - use "import { gql } from ..."`,
+	STAR_IMPORT: (ctx) => `Namespace import "${ctx?.namespaceAlias ?? "?"}" not fully supported - use named import`,
+	DEFAULT_IMPORT: () => `Default import not supported - use "import { gql } from ..."`,
+	MISSING_ARGUMENT: () => `gql definition requires a factory function argument`,
+	INVALID_ARGUMENT_TYPE: (ctx) => `Expected arrow function, got ${ctx?.actualType ?? "unknown"}`,
+	NON_MEMBER_CALLEE: () => `Cannot call gql directly - use gql.schemaName(...)`,
+	COMPUTED_PROPERTY: () => `Computed property access not supported - use gql.schemaName(...)`,
+	DYNAMIC_CALLEE: () => `Dynamic callee expression not supported`,
+	OPTIONAL_CHAINING: () => `Optional chaining on gql not supported - use gql.schemaName(...) directly`,
+	EXTRA_ARGUMENTS: (ctx) => `gql definition only accepts one argument, ${ctx?.extraCount ?? "extra"} additional argument(s) ignored`,
+	SPREAD_ARGUMENT: () => `Spread arguments not supported - use arrow function directly`,
+	CLASS_PROPERTY: () => `Class property definitions may have inconsistent scope tracking`
+};
+/**
+* Create a diagnostic with a standard message
+*/
+const createStandardDiagnostic = (code, location, context) => {
+	return createDiagnostic({
+		code,
+		message: diagnosticMessages[code](context),
+		location,
+		context
+	});
+};
+
+//#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);
+		}
+	}
+	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);
+		}
+	}
+};
+/**
+* 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/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" && !specifier.imported) {
+					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 isInClassProperty = (stack) => stack.some((frame, i) => frame.kind === "property" && stack[i - 1]?.kind === "class");
+	const visit = (node, stack) => {
+		if (!node || typeof node !== "object") {
+			return;
+		}
+		if (node.type === "CallExpression") {
+			const gqlCall = unwrapMethodChains$1(gqlIdentifiers, node);
+			if (gqlCall && !isInClassProperty(stack)) {
+				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
+	};
+};
+/**
+* Get location from an SWC node span
+*/
+const getLocation$1 = (module$1, span) => {
+	const start = span.start - module$1.__spanOffset;
+	const end = span.end - module$1.__spanOffset;
+	return {
+		start,
+		end
+	};
+};
+/**
+* Collect diagnostics for invalid import patterns from graphql-system
+*/
+const collectImportDiagnostics$1 = (module$1, helper) => {
+	const diagnostics = [];
+	module$1.body.forEach((item) => {
+		const declaration = item.type === "ImportDeclaration" ? item : "declaration" in item && item.declaration && "type" in 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 === "ImportDefaultSpecifier") {
+				diagnostics.push(createStandardDiagnostic("DEFAULT_IMPORT", getLocation$1(module$1, specifier.span), undefined));
+				return;
+			}
+			if (specifier.type === "ImportNamespaceSpecifier") {
+				diagnostics.push(createStandardDiagnostic("STAR_IMPORT", getLocation$1(module$1, specifier.span), { namespaceAlias: specifier.local.value }));
+				return;
+			}
+			if (specifier.type === "ImportSpecifier") {
+				const imported = specifier.imported ? specifier.imported.value : specifier.local.value;
+				if (imported === "gql" && specifier.imported) {
+					diagnostics.push(createStandardDiagnostic("RENAMED_IMPORT", getLocation$1(module$1, specifier.span), { importedAs: specifier.local.value }));
+				}
+			}
+		});
+	});
+	return diagnostics;
+};
+/**
+* Check if a node contains a reference to any gql identifier
+*/
+const containsGqlIdentifier$1 = (node, identifiers) => {
+	if (!node || typeof node !== "object") {
+		return false;
+	}
+	if (node.type === "Identifier" && identifiers.has(node.value)) {
+		return true;
+	}
+	for (const value of Object.values(node)) {
+		if (Array.isArray(value)) {
+			for (const child of value) {
+				if (containsGqlIdentifier$1(child, identifiers)) {
+					return true;
+				}
+			}
+		} else if (value && typeof value === "object") {
+			if (containsGqlIdentifier$1(value, identifiers)) {
+				return true;
+			}
+		}
+	}
+	return false;
+};
+/**
+* Get the type name of an argument for error messages
+*/
+const getArgumentType$1 = (node) => {
+	if (!node) return "undefined";
+	switch (node.type) {
+		case "StringLiteral": return "string";
+		case "NumericLiteral": return "number";
+		case "ObjectExpression": return "object";
+		case "ArrayExpression": return "array";
+		case "FunctionExpression": return "function";
+		case "NullLiteral": return "null";
+		case "BooleanLiteral": return "boolean";
+		default: return "unknown";
+	}
+};
+/**
+* Collect diagnostics for invalid gql call patterns
+*/
+const collectCallDiagnostics$1 = (module$1, gqlIdentifiers) => {
+	const diagnostics = [];
+	const visit = (node) => {
+		if (!node || typeof node !== "object") {
+			return;
+		}
+		if (node.type === "CallExpression") {
+			const diagnostic = checkCallExpression$1(module$1, node, gqlIdentifiers);
+			if (diagnostic) {
+				diagnostics.push(diagnostic);
+			}
+		}
+		for (const value of Object.values(node)) {
+			if (Array.isArray(value)) {
+				for (const child of value) {
+					visit(child);
+				}
+			} else if (value && typeof value === "object") {
+				visit(value);
+			}
+		}
+	};
+	module$1.body.forEach(visit);
+	return diagnostics;
+};
+/**
+* Check a call expression for invalid gql patterns
+*/
+const checkCallExpression$1 = (module$1, call, gqlIdentifiers) => {
+	const callee = call.callee;
+	if (callee.type === "Identifier" && gqlIdentifiers.has(callee.value)) {
+		return createStandardDiagnostic("NON_MEMBER_CALLEE", getLocation$1(module$1, call.span), undefined);
+	}
+	if (callee.type === "OptionalChainingExpression") {
+		const base = callee.base;
+		if (base?.type === "MemberExpression") {
+			const object$1 = base.object;
+			if (object$1?.type === "Identifier" && gqlIdentifiers.has(object$1.value)) {
+				return createStandardDiagnostic("OPTIONAL_CHAINING", getLocation$1(module$1, call.span), undefined);
+			}
+		}
+		return null;
+	}
+	if (callee.type !== "MemberExpression") {
+		return null;
+	}
+	const object = callee.object;
+	const property = callee.property;
+	if (property?.type === "Computed" && object?.type === "Identifier" && gqlIdentifiers.has(object.value)) {
+		return createStandardDiagnostic("COMPUTED_PROPERTY", getLocation$1(module$1, call.span), undefined);
+	}
+	if (object?.type !== "Identifier") {
+		if (containsGqlIdentifier$1(object, gqlIdentifiers)) {
+			return createStandardDiagnostic("DYNAMIC_CALLEE", getLocation$1(module$1, call.span), undefined);
+		}
+		return null;
+	}
+	if (!gqlIdentifiers.has(object.value)) {
+		return null;
+	}
+	if (!call.arguments || call.arguments.length === 0) {
+		return createStandardDiagnostic("MISSING_ARGUMENT", getLocation$1(module$1, call.span), undefined);
+	}
+	const firstArg = call.arguments[0];
+	const firstArgAny = firstArg;
+	if (firstArgAny?.spread) {
+		return createStandardDiagnostic("SPREAD_ARGUMENT", getLocation$1(module$1, call.span), undefined);
+	}
+	const expression = firstArgAny?.expression;
+	if (expression && expression.type !== "ArrowFunctionExpression") {
+		const actualType = getArgumentType$1(expression);
+		return createStandardDiagnostic("INVALID_ARGUMENT_TYPE", getLocation$1(module$1, call.span), { actualType });
+	}
+	if (call.arguments.length > 1) {
+		const extraCount = call.arguments.length - 1;
+		return createStandardDiagnostic("EXTRA_ARGUMENTS", getLocation$1(module$1, call.span), { extraCount: String(extraCount) });
+	}
+	return null;
+};
+/**
+* Collect diagnostics for gql calls in class properties
+*/
+const collectClassPropertyDiagnostics$1 = (module$1, gqlIdentifiers) => {
+	const diagnostics = [];
+	const containsGqlCall = (node) => {
+		if (!node || typeof node !== "object") {
+			return false;
+		}
+		if (node.type === "CallExpression" && isGqlCall(gqlIdentifiers, node)) {
+			return true;
+		}
+		for (const value of Object.values(node)) {
+			if (Array.isArray(value)) {
+				for (const child of value) {
+					if (containsGqlCall(child)) {
+						return true;
+					}
+				}
+			} else if (value && typeof value === "object") {
+				if (containsGqlCall(value)) {
+					return true;
+				}
+			}
+		}
+		return false;
+	};
+	const visit = (node) => {
+		if (!node || typeof node !== "object") {
+			return;
+		}
+		if (node.type === "ClassDeclaration") {
+			node.body?.forEach((member) => {
+				if (member.type === "ClassProperty" && member.value) {
+					if (containsGqlCall(member.value)) {
+						diagnostics.push(createStandardDiagnostic("CLASS_PROPERTY", getLocation$1(module$1, member.span), undefined));
+					}
+				}
+			});
+		}
+		for (const value of Object.values(node)) {
+			if (Array.isArray(value)) {
+				for (const child of value) {
+					visit(child);
+				}
+			} else if (value && typeof value === "object") {
+				visit(value);
+			}
+		}
+	};
+	module$1.body.forEach(visit);
+	return diagnostics;
+};
+/**
+* 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
+	});
+	const diagnostics = [
+		...collectImportDiagnostics$1(swcModule, helper),
+		...collectCallDiagnostics$1(swcModule, gqlIdentifiers),
+		...collectClassPropertyDiagnostics$1(swcModule, gqlIdentifiers)
+	];
+	return {
+		imports,
+		exports: exports$1,
+		definitions,
+		diagnostics
+	};
+} };
+
+//#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" && !element.propertyName) {
+					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;
+};
+/**
+* Unwrap NonNullExpression nodes to get the underlying expression.
+* Handles cases like `gql!` or `gql!!` by recursively unwrapping.
+*/
+const unwrapNonNullExpression = (node) => {
+	if (typescript.default.isNonNullExpression(node)) {
+		return unwrapNonNullExpression(node.expression);
+	}
+	return node;
+};
+const isGqlDefinitionCall = (identifiers, callExpression) => {
+	const expression = callExpression.expression;
+	if (!typescript.default.isPropertyAccessExpression(expression)) {
+		return false;
+	}
+	const baseExpr = unwrapNonNullExpression(expression.expression);
+	if (!typescript.default.isIdentifier(baseExpr) || !identifiers.has(baseExpr.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 isInClassProperty = (stack) => stack.some((frame, i) => frame.kind === "property" && stack[i - 1]?.kind === "class");
+	const visit = (node, stack) => {
+		if (typescript.default.isCallExpression(node)) {
+			const gqlCall = unwrapMethodChains(identifiers, node);
+			if (gqlCall && !isInClassProperty(stack)) {
+				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
+	};
+};
+/**
+* Get location from a TypeScript node
+*/
+const getLocation = (sourceFile, node) => {
+	const start = node.getStart(sourceFile);
+	const { line, character } = sourceFile.getLineAndCharacterOfPosition(start);
+	return {
+		start,
+		end: node.getEnd(),
+		line: line + 1,
+		column: character + 1
+	};
+};
+/**
+* Collect diagnostics for invalid import patterns from graphql-system
+*/
+const collectImportDiagnostics = (sourceFile, helper) => {
+	const diagnostics = [];
+	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;
+		}
+		const { importClause } = statement;
+		if (importClause.name) {
+			diagnostics.push(createStandardDiagnostic("DEFAULT_IMPORT", getLocation(sourceFile, importClause.name), undefined));
+		}
+		const { namedBindings } = importClause;
+		if (!namedBindings) {
+			return;
+		}
+		if (typescript.default.isNamespaceImport(namedBindings)) {
+			diagnostics.push(createStandardDiagnostic("STAR_IMPORT", getLocation(sourceFile, namedBindings), { namespaceAlias: namedBindings.name.text }));
+			return;
+		}
+		namedBindings.elements.forEach((element) => {
+			const imported = element.propertyName ? element.propertyName.text : element.name.text;
+			if (imported === "gql" && element.propertyName) {
+				diagnostics.push(createStandardDiagnostic("RENAMED_IMPORT", getLocation(sourceFile, element), { importedAs: element.name.text }));
+			}
+		});
+	});
+	return diagnostics;
+};
+/**
+* Check if a node contains a reference to any gql identifier
+*/
+const containsGqlIdentifier = (node, identifiers) => {
+	if (typescript.default.isIdentifier(node) && identifiers.has(node.text)) {
+		return true;
+	}
+	let found = false;
+	typescript.default.forEachChild(node, (child) => {
+		if (containsGqlIdentifier(child, identifiers)) {
+			found = true;
+		}
+	});
+	return found;
+};
+/**
+* Get the type name of an argument for error messages
+*/
+const getArgumentType = (node) => {
+	if (typescript.default.isStringLiteral(node)) return "string";
+	if (typescript.default.isNumericLiteral(node)) return "number";
+	if (typescript.default.isObjectLiteralExpression(node)) return "object";
+	if (typescript.default.isArrayLiteralExpression(node)) return "array";
+	if (typescript.default.isFunctionExpression(node)) return "function";
+	if (node.kind === typescript.default.SyntaxKind.NullKeyword) return "null";
+	if (node.kind === typescript.default.SyntaxKind.UndefinedKeyword) return "undefined";
+	if (node.kind === typescript.default.SyntaxKind.TrueKeyword || node.kind === typescript.default.SyntaxKind.FalseKeyword) return "boolean";
+	return "unknown";
+};
+/**
+* Collect diagnostics for invalid gql call patterns
+*/
+const collectCallDiagnostics = (sourceFile, gqlIdentifiers) => {
+	const diagnostics = [];
+	const visit = (node) => {
+		if (typescript.default.isCallExpression(node)) {
+			const diagnostic = checkCallExpression(sourceFile, node, gqlIdentifiers);
+			if (diagnostic) {
+				diagnostics.push(diagnostic);
+			}
+		}
+		typescript.default.forEachChild(node, visit);
+	};
+	sourceFile.statements.forEach(visit);
+	return diagnostics;
+};
+/**
+* Check a call expression for invalid gql patterns
+*/
+const checkCallExpression = (sourceFile, call, gqlIdentifiers) => {
+	const { expression } = call;
+	if (typescript.default.isIdentifier(expression) && gqlIdentifiers.has(expression.text)) {
+		return createStandardDiagnostic("NON_MEMBER_CALLEE", getLocation(sourceFile, call), undefined);
+	}
+	if (typescript.default.isElementAccessExpression(expression)) {
+		const baseExpr$1 = unwrapNonNullExpression(expression.expression);
+		if (typescript.default.isIdentifier(baseExpr$1) && gqlIdentifiers.has(baseExpr$1.text)) {
+			return createStandardDiagnostic("COMPUTED_PROPERTY", getLocation(sourceFile, call), undefined);
+		}
+		return null;
+	}
+	if (!typescript.default.isPropertyAccessExpression(expression)) {
+		return null;
+	}
+	const baseExpr = unwrapNonNullExpression(expression.expression);
+	if (expression.questionDotToken) {
+		if (typescript.default.isIdentifier(baseExpr) && gqlIdentifiers.has(baseExpr.text)) {
+			return createStandardDiagnostic("OPTIONAL_CHAINING", getLocation(sourceFile, call), undefined);
+		}
+		return null;
+	}
+	if (!typescript.default.isIdentifier(baseExpr)) {
+		if (containsGqlIdentifier(expression.expression, gqlIdentifiers)) {
+			return createStandardDiagnostic("DYNAMIC_CALLEE", getLocation(sourceFile, call), undefined);
+		}
+		return null;
+	}
+	if (!gqlIdentifiers.has(baseExpr.text)) {
+		return null;
+	}
+	if (call.arguments.length === 0) {
+		return createStandardDiagnostic("MISSING_ARGUMENT", getLocation(sourceFile, call), undefined);
+	}
+	const firstArg = call.arguments[0];
+	if (firstArg && typescript.default.isSpreadElement(firstArg)) {
+		return createStandardDiagnostic("SPREAD_ARGUMENT", getLocation(sourceFile, call), undefined);
+	}
+	if (firstArg && !typescript.default.isArrowFunction(firstArg)) {
+		const actualType = getArgumentType(firstArg);
+		return createStandardDiagnostic("INVALID_ARGUMENT_TYPE", getLocation(sourceFile, call), { actualType });
+	}
+	if (call.arguments.length > 1) {
+		const extraCount = call.arguments.length - 1;
+		return createStandardDiagnostic("EXTRA_ARGUMENTS", getLocation(sourceFile, call), { extraCount: String(extraCount) });
+	}
+	return null;
+};
+/**
+* Collect diagnostics for gql calls in class properties
+*/
+const collectClassPropertyDiagnostics = (sourceFile, gqlIdentifiers) => {
+	const diagnostics = [];
+	const containsGqlCall = (node) => {
+		if (typescript.default.isCallExpression(node) && isGqlDefinitionCall(gqlIdentifiers, node)) {
+			return true;
+		}
+		let found = false;
+		typescript.default.forEachChild(node, (child) => {
+			if (containsGqlCall(child)) {
+				found = true;
+			}
+		});
+		return found;
+	};
+	const visit = (node) => {
+		if (typescript.default.isClassDeclaration(node)) {
+			node.members.forEach((member) => {
+				if (typescript.default.isPropertyDeclaration(member) && member.initializer) {
+					if (containsGqlCall(member.initializer)) {
+						diagnostics.push(createStandardDiagnostic("CLASS_PROPERTY", getLocation(sourceFile, member), undefined));
+					}
+				}
+			});
+		}
+		typescript.default.forEachChild(node, visit);
+	};
+	sourceFile.statements.forEach(visit);
+	return diagnostics;
+};
+/**
+* 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
+	});
+	const diagnostics = [
+		...collectImportDiagnostics(sourceFile, helper),
+		...collectCallDiagnostics(sourceFile, gqlIdentifiers),
+		...collectClassPropertyDiagnostics(sourceFile, gqlIdentifiers)
+	];
+	return {
+		imports,
+		exports: exports$1,
+		definitions,
+		diagnostics
+	};
+} };
+
+//#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: [],
+			diagnostics: []
+		};
+	}
+	return {
+		filePath: input.filePath,
+		signature,
+		definitions: result.definitions,
+		imports: result.imports,
+		exports: result.exports,
+		diagnostics: result.diagnostics
+	};
+};
+
+//#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 DiagnosticCodeSchema = zod.z.enum([
+	"RENAMED_IMPORT",
+	"STAR_IMPORT",
+	"DEFAULT_IMPORT",
+	"MISSING_ARGUMENT",
+	"INVALID_ARGUMENT_TYPE",
+	"NON_MEMBER_CALLEE",
+	"COMPUTED_PROPERTY",
+	"DYNAMIC_CALLEE",
+	"OPTIONAL_CHAINING",
+	"EXTRA_ARGUMENTS",
+	"SPREAD_ARGUMENT",
+	"CLASS_PROPERTY"
+]);
+const DiagnosticLocationSchema = zod.z.object({
+	start: zod.z.number(),
+	end: zod.z.number(),
+	line: zod.z.number().optional(),
+	column: zod.z.number().optional()
+});
+const ModuleDiagnosticSchema = zod.z.object({
+	code: DiagnosticCodeSchema,
+	severity: zod.z.enum(["error", "warning"]),
+	message: zod.z.string(),
+	location: DiagnosticLocationSchema,
+	context: zod.z.record(zod.z.string(), zod.z.string()).readonly().optional()
+});
+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(),
+	diagnostics: zod.z.array(ModuleDiagnosticSchema).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 glob patterns from the given directory.
+* Supports negation patterns (e.g., "!**\/excluded.ts") when using fast-glob.
+*
+* @param patterns - Glob pattern(s). Can be a single pattern or array of patterns.
+* @param cwd - Working directory (defaults to process.cwd())
+* @returns Array of matched file paths (relative to cwd)
+*/
+const scanGlob = (patterns, cwd = process.cwd()) => {
+	const patternArray = Array.isArray(patterns) ? patterns : [patterns];
+	const hasNegation = patternArray.some((p) => p.startsWith("!"));
+	if (typeof Bun !== "undefined" && Bun.Glob && !hasNegation) {
+		const { Glob } = Bun;
+		const results = new Set();
+		for (const pattern of patternArray) {
+			const glob = new Glob(pattern);
+			for (const match of glob.scanSync(cwd)) {
+				results.add(match);
+			}
+		}
+		return Array.from(results);
+	}
+	return fast_glob.default.sync(patternArray, {
+		cwd,
+		dot: true,
+		onlyFiles: true
+	});
+};
+
+//#endregion
+//#region packages/builder/src/discovery/entry-paths.ts
+/**
+* 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.
+*
+* @param entries - Include patterns (glob or direct paths). Supports negation patterns (e.g., "!./path/to/exclude.ts")
+*/
+const resolveEntryPaths = (entries) => {
+	const directPaths = [];
+	const globPatterns = [];
+	for (const entry of entries) {
+		if (entry.startsWith("!")) {
+			globPatterns.push(entry);
+			continue;
+		}
+		const absolute = (0, node_path.resolve)(entry);
+		if ((0, node_fs.existsSync)(absolute)) {
+			directPaths.push((0, node_path.normalize)(absolute).replace(/\\/g, "/"));
+		} else {
+			globPatterns.push(entry);
+		}
+	}
+	const globMatches = globPatterns.length > 0 ? scanGlob(globPatterns, process.cwd()).map((match) => {
+		return (0, node_path.normalize)((0, node_path.resolve)(match)).replace(/\\/g, "/");
+	}) : [];
+	const resolvedPaths = [...directPaths, ...globMatches];
+	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()
+	};
+};
+
+//#endregion
+Object.defineProperty(exports, 'BuilderArtifactSchema', {
+  enumerable: true,
+  get: function () {
+    return BuilderArtifactSchema;
+  }
+});
+Object.defineProperty(exports, 'BuilderEffects', {
+  enumerable: true,
+  get: function () {
+    return BuilderEffects;
+  }
+});
+Object.defineProperty(exports, 'FileReadEffect', {
+  enumerable: true,
+  get: function () {
+    return FileReadEffect;
+  }
+});
+Object.defineProperty(exports, 'FileStatEffect', {
+  enumerable: true,
+  get: function () {
+    return FileStatEffect;
+  }
+});
+Object.defineProperty(exports, '__clearGqlCache', {
+  enumerable: true,
+  get: function () {
+    return __clearGqlCache;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'builderErrors', {
+  enumerable: true,
+  get: function () {
+    return builderErrors;
+  }
+});
+Object.defineProperty(exports, 'collectAffectedFiles', {
+  enumerable: true,
+  get: function () {
+    return collectAffectedFiles;
+  }
+});
+Object.defineProperty(exports, 'createBuilderService', {
+  enumerable: true,
+  get: function () {
+    return createBuilderService;
+  }
+});
+Object.defineProperty(exports, 'createBuilderSession', {
+  enumerable: true,
+  get: function () {
+    return createBuilderSession;
+  }
+});
+Object.defineProperty(exports, 'createDiagnostic', {
+  enumerable: true,
+  get: function () {
+    return createDiagnostic;
+  }
+});
+Object.defineProperty(exports, 'createGraphqlSystemIdentifyHelper', {
+  enumerable: true,
+  get: function () {
+    return createGraphqlSystemIdentifyHelper;
+  }
+});
+Object.defineProperty(exports, 'createStandardDiagnostic', {
+  enumerable: true,
+  get: function () {
+    return createStandardDiagnostic;
+  }
+});
+Object.defineProperty(exports, 'diagnosticMessages', {
+  enumerable: true,
+  get: function () {
+    return diagnosticMessages;
+  }
+});
+Object.defineProperty(exports, 'executeSandbox', {
+  enumerable: true,
+  get: function () {
+    return executeSandbox;
+  }
+});
+Object.defineProperty(exports, 'extractModuleAdjacency', {
+  enumerable: true,
+  get: function () {
+    return extractModuleAdjacency;
+  }
+});
+Object.defineProperty(exports, 'formatBuilderErrorForCLI', {
+  enumerable: true,
+  get: function () {
+    return formatBuilderErrorForCLI;
+  }
+});
+Object.defineProperty(exports, 'formatBuilderErrorStructured', {
+  enumerable: true,
+  get: function () {
+    return formatBuilderErrorStructured;
+  }
+});
+Object.defineProperty(exports, 'getSeverity', {
+  enumerable: true,
+  get: function () {
+    return getSeverity;
+  }
+});
+Object.defineProperty(exports, 'loadArtifact', {
+  enumerable: true,
+  get: function () {
+    return loadArtifact;
+  }
+});
+Object.defineProperty(exports, 'loadArtifactSync', {
+  enumerable: true,
+  get: function () {
+    return loadArtifactSync;
+  }
+});
+//# sourceMappingURL=service-nHDX5qIj.cjs.map