@soda-gql/builder 0.0.1

package/dist/index.js

@@ -0,0 +1,2870 @@
+import { CanonicalIdSchema, buildAstPath, cachedFn, createCanonicalId, createCanonicalId as createCanonicalId$1, createCanonicalTracker, createCanonicalTracker as createCanonicalTracker$1, createOccurrenceTracker, createPathTracker, getPortableHasher, isExternalSpecifier, isRelativeSpecifier, normalizePath, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences } from "@soda-gql/common";
+import { z } from "zod";
+import { extname, join, normalize, resolve } from "node:path";
+import { err, ok } from "neverthrow";
+import { createHash } from "node:crypto";
+import { parseSync, transformSync } from "@swc/core";
+import ts from "typescript";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import fg from "fast-glob";
+import { Script, createContext } from "node:vm";
+import * as sandboxCore from "@soda-gql/core";
+import { ComposedOperation, GqlElement, InlineOperation, Model, Slice } from "@soda-gql/core";
+import * as sandboxRuntime from "@soda-gql/runtime";
+
+//#region packages/builder/src/schemas/artifact.ts
+const BuilderArtifactElementMetadataSchema = z.object({
+	sourcePath: z.string(),
+	sourceHash: z.string(),
+	contentHash: z.string()
+});
+const BuilderArtifactOperationSchema = z.object({
+	id: z.string(),
+	type: z.literal("operation"),
+	metadata: BuilderArtifactElementMetadataSchema,
+	prebuild: z.object({
+		operationType: z.enum([
+			"query",
+			"mutation",
+			"subscription"
+		]),
+		operationName: z.string(),
+		document: z.unknown(),
+		variableNames: z.array(z.string()),
+		projectionPathGraph: z.unknown()
+	})
+});
+const BuilderArtifactSliceSchema = z.object({
+	id: z.string(),
+	type: z.literal("slice"),
+	metadata: BuilderArtifactElementMetadataSchema,
+	prebuild: z.object({ operationType: z.enum([
+		"query",
+		"mutation",
+		"subscription"
+	]) })
+});
+const BuilderArtifactModelSchema = z.object({
+	id: z.string(),
+	type: z.literal("model"),
+	metadata: BuilderArtifactElementMetadataSchema,
+	prebuild: z.object({ typename: z.string() })
+});
+const BuilderArtifactElementSchema = z.discriminatedUnion("type", [
+	BuilderArtifactOperationSchema,
+	BuilderArtifactSliceSchema,
+	BuilderArtifactModelSchema
+]);
+const BuilderArtifactSchema = z.object({
+	elements: z.record(z.string(), BuilderArtifactElementSchema),
+	report: z.object({
+		durationMs: z.number(),
+		warnings: z.array(z.string()),
+		stats: z.object({
+			hits: z.number(),
+			misses: z.number(),
+			skips: z.number()
+		})
+	})
+});
+
+//#endregion
+//#region packages/builder/src/artifact/aggregate.ts
+const canonicalToFilePath$1 = (canonicalId) => canonicalId.split("::")[0] ?? canonicalId;
+const computeContentHash = (prebuild) => {
+	const hash = 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 err(emitRegistrationError(definition, message));
+			}
+			if (registry.has(definition.canonicalId)) {
+				return err(emitRegistrationError(definition, `ARTIFACT_ALREADY_REGISTERED`));
+			}
+			const metadata = {
+				sourcePath: analysis.filePath ?? canonicalToFilePath$1(definition.canonicalId),
+				sourceHash: analysis.signature,
+				contentHash: ""
+			};
+			if (element.type === "model") {
+				const prebuild = { typename: element.element.typename };
+				registry.set(definition.canonicalId, {
+					id: definition.canonicalId,
+					type: "model",
+					prebuild,
+					metadata: {
+						...metadata,
+						contentHash: computeContentHash(prebuild)
+					}
+				});
+				continue;
+			}
+			if (element.type === "slice") {
+				const prebuild = { operationType: element.element.operationType };
+				registry.set(definition.canonicalId, {
+					id: definition.canonicalId,
+					type: "slice",
+					prebuild,
+					metadata: {
+						...metadata,
+						contentHash: computeContentHash(prebuild)
+					}
+				});
+				continue;
+			}
+			if (element.type === "operation") {
+				const prebuild = {
+					operationType: element.element.operationType,
+					operationName: element.element.operationName,
+					document: element.element.document,
+					variableNames: element.element.variableNames,
+					projectionPathGraph: element.element.projectionPathGraph
+				};
+				registry.set(definition.canonicalId, {
+					id: definition.canonicalId,
+					type: "operation",
+					prebuild,
+					metadata: {
+						...metadata,
+						contentHash: computeContentHash(prebuild)
+					}
+				});
+				continue;
+			}
+			if (element.type === "inlineOperation") {
+				const prebuild = {
+					operationType: element.element.operationType,
+					operationName: element.element.operationName,
+					document: element.element.document,
+					variableNames: element.element.variableNames
+				};
+				registry.set(definition.canonicalId, {
+					id: definition.canonicalId,
+					type: "inlineOperation",
+					prebuild,
+					metadata: {
+						...metadata,
+						contentHash: computeContentHash(prebuild)
+					}
+				});
+				continue;
+			}
+			return err(emitRegistrationError(definition, "UNKNOWN_ARTIFACT_KIND"));
+		}
+	}
+	return 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 err({
+				code: "DOC_DUPLICATE",
+				message: `Duplicate document name: ${element.operationName}`,
+				name: element.operationName,
+				sources
+			});
+		}
+		operationNames.add(element.operationName);
+	}
+	return ok([]);
+};
+
+//#endregion
+//#region packages/builder/src/artifact/builder.ts
+const buildArtifact = ({ elements, analyses, stats: cache }) => {
+	const issuesResult = checkIssues({ elements });
+	if (issuesResult.isErr()) {
+		return err(issuesResult.error);
+	}
+	const warnings = issuesResult.value;
+	const aggregationResult = aggregate({
+		analyses,
+		elements
+	});
+	if (aggregationResult.isErr()) {
+		return err(aggregationResult.error);
+	}
+	return ok({
+		elements: Object.fromEntries(aggregationResult.value.entries()),
+		report: {
+			durationMs: 0,
+			warnings,
+			stats: cache
+		}
+	});
+};
+
+//#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
+	}),
+	internalInvariant: (message, context, cause) => ({
+		code: "INTERNAL_INVARIANT",
+		message: `Internal invariant violated: ${message}`,
+		context,
+		cause
+	})
+};
+/**
+* Convenience helper to create an err Result from BuilderError.
+*/
+const builderErr = (error) => 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 "INTERNAL_INVARIANT":
+			if (error.context) {
+				lines.push(`  Context: ${error.context}`);
+			}
+			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/ast/common/scope.ts
+/**
+* Build AST path from scope stack
+*/
+const buildAstPath$1 = (stack) => {
+	return stack.map((frame) => frame.nameSegment).join(".");
+};
+/**
+* Create an occurrence tracker for disambiguating anonymous/duplicate scopes.
+*/
+const createOccurrenceTracker$1 = () => {
+	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$1 = () => {
+	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) => {
+	const exportBindings = new Map();
+	exports.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
+const getLineStarts = (source) => {
+	const starts = [0];
+	for (let index = 0; index < source.length; index += 1) {
+		if (source[index] === "\n") {
+			starts.push(index + 1);
+		}
+	}
+	return starts;
+};
+const toPositionResolver = (source) => {
+	const lineStarts = getLineStarts(source);
+	return (offset) => {
+		let low = 0;
+		let high = lineStarts.length - 1;
+		while (low <= high) {
+			const mid = Math.floor((low + high) / 2);
+			const start = lineStarts[mid];
+			const next = mid + 1 < lineStarts.length ? lineStarts[mid + 1] : source.length + 1;
+			if (start == null || next == null) {
+				break;
+			}
+			if (offset < start) {
+				high = mid - 1;
+			} else if (offset >= next) {
+				low = mid + 1;
+			} else {
+				return {
+					line: mid + 1,
+					column: offset - start + 1
+				};
+			}
+		}
+		return {
+			line: lineStarts.length,
+			column: offset - lineStarts[lineStarts.length - 1] + 1
+		};
+	};
+};
+const toLocation$1 = (resolvePosition, span) => ({
+	start: resolvePosition(span.start),
+	end: resolvePosition(span.end)
+});
+const collectImports$1 = (module) => {
+	const imports = [];
+	const handle = (declaration) => {
+		const source = declaration.source.value;
+		declaration.specifiers?.forEach((specifier) => {
+			if (specifier.type === "ImportSpecifier") {
+				const imported = specifier.imported ? specifier.imported.value : specifier.local.value;
+				imports.push({
+					source,
+					imported,
+					local: specifier.local.value,
+					kind: "named",
+					isTypeOnly: Boolean(specifier.isTypeOnly)
+				});
+				return;
+			}
+			if (specifier.type === "ImportNamespaceSpecifier") {
+				imports.push({
+					source,
+					imported: "*",
+					local: specifier.local.value,
+					kind: "namespace",
+					isTypeOnly: false
+				});
+				return;
+			}
+			if (specifier.type === "ImportDefaultSpecifier") {
+				imports.push({
+					source,
+					imported: "default",
+					local: specifier.local.value,
+					kind: "default",
+					isTypeOnly: false
+				});
+			}
+		});
+	};
+	module.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) => {
+	const exports = [];
+	const handle = (declaration) => {
+		if (declaration.type === "ExportDeclaration") {
+			if (declaration.declaration.type === "VariableDeclaration") {
+				declaration.declaration.declarations.forEach((decl) => {
+					if (decl.id.type === "Identifier") {
+						exports.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.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.push({
+						kind: "reexport",
+						exported,
+						local,
+						source,
+						isTypeOnly: Boolean(specifier.isTypeOnly)
+					});
+					return;
+				}
+				exports.push({
+					kind: "named",
+					exported,
+					local,
+					isTypeOnly: Boolean(specifier.isTypeOnly)
+				});
+			});
+			return;
+		}
+		if (declaration.type === "ExportAllDeclaration") {
+			exports.push({
+				kind: "reexport",
+				exported: "*",
+				source: declaration.source.value,
+				isTypeOnly: false
+			});
+			return;
+		}
+		if (declaration.type === "ExportDefaultDeclaration" || declaration.type === "ExportDefaultExpression") {
+			exports.push({
+				kind: "named",
+				exported: "default",
+				local: "default",
+				isTypeOnly: false
+			});
+		}
+	};
+	module.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;
+};
+const collectGqlIdentifiers = (module, helper) => {
+	const identifiers = new Set();
+	module.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.__filePath,
+			specifier: declaration.source.value
+		})) {
+			return;
+		}
+		declaration.specifiers?.forEach((specifier) => {
+			if (specifier.type === "ImportSpecifier") {
+				const imported = specifier.imported ? specifier.imported.value : specifier.local.value;
+				if (imported === "gql") {
+					identifiers.add(specifier.local.value);
+				}
+			}
+		});
+	});
+	return identifiers;
+};
+const isGqlCall = (identifiers, call) => {
+	const callee = call.callee;
+	if (callee.type !== "MemberExpression") {
+		return false;
+	}
+	if (callee.object.type !== "Identifier") {
+		return false;
+	}
+	if (!identifiers.has(callee.object.value)) {
+		return false;
+	}
+	if (callee.property.type !== "Identifier") {
+		return false;
+	}
+	const firstArg = call.arguments[0];
+	if (!firstArg?.expression || firstArg.expression.type !== "ArrowFunctionExpression") {
+		return false;
+	}
+	return true;
+};
+const collectAllDefinitions$1 = ({ module, gqlIdentifiers, imports: _imports, exports, resolvePosition, 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);
+	const tracker = createCanonicalTracker$1({
+		filePath: module.__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) => {
+		let start = call.span.start;
+		if (start > 0 && source[start] === "q" && source[start - 1] === "g" && source.slice(start, start + 3) === "ql.") {
+			start -= 1;
+		}
+		const raw = source.slice(start, call.span.end);
+		const marker = raw.indexOf("gql");
+		if (marker >= 0) {
+			return raw.slice(marker);
+		}
+		return raw;
+	};
+	const visit = (node, stack) => {
+		if (!node || typeof node !== "object") {
+			return;
+		}
+		if (node.type === "CallExpression" && isGqlCall(gqlIdentifiers, node)) {
+			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,
+				loc: toLocation$1(resolvePosition, node.span),
+				expression: expressionFromCall(node)
+			});
+			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);
+						});
+					}
+				}
+			});
+			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 === "MethodProperty" || member.type === "ClassProperty") {
+						const memberName = member.key?.value ?? null;
+						if (memberName) {
+							const memberKind = member.type === "MethodProperty" ? "method" : "property";
+							withScope(classStack, memberName, memberKind, `member:${className}.${memberName}`, (memberStack) => {
+								if (member.type === "MethodProperty" && member.body) {
+									visit(member.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.body.forEach((statement) => {
+		visit(statement, []);
+	});
+	const definitions = pending.map((item) => ({
+		canonicalId: createCanonicalId$1(module.__filePath, item.astPath),
+		astPath: item.astPath,
+		isTopLevel: item.isTopLevel,
+		isExported: item.isExported,
+		exportBinding: item.exportBinding,
+		loc: item.loc,
+		expression: item.expression
+	}));
+	return {
+		definitions,
+		handledCalls
+	};
+};
+/**
+* Collect diagnostics (now empty since we support all definition types)
+*/
+const collectDiagnostics$1 = () => {
+	return [];
+};
+/**
+* SWC adapter implementation
+*/
+const swcAdapter = {
+	parse(input) {
+		const program = parseSync(input.source, {
+			syntax: "typescript",
+			tsx: input.filePath.endsWith(".tsx"),
+			target: "es2022",
+			decorators: false,
+			dynamicImport: true
+		});
+		if (program.type !== "Module") {
+			return null;
+		}
+		const swcModule = program;
+		swcModule.__filePath = input.filePath;
+		return swcModule;
+	},
+	collectGqlIdentifiers(file, helper) {
+		return collectGqlIdentifiers(file, helper);
+	},
+	collectImports(file) {
+		return collectImports$1(file);
+	},
+	collectExports(file) {
+		return collectExports$1(file);
+	},
+	collectDefinitions(file, context) {
+		const resolvePosition = toPositionResolver(context.source);
+		const { definitions, handledCalls } = collectAllDefinitions$1({
+			module: file,
+			gqlIdentifiers: context.gqlIdentifiers,
+			imports: context.imports,
+			exports: context.exports,
+			resolvePosition,
+			source: context.source
+		});
+		return {
+			definitions,
+			handles: handledCalls
+		};
+	},
+	collectDiagnostics(_file, _context) {
+		return collectDiagnostics$1();
+	}
+};
+
+//#endregion
+//#region packages/builder/src/ast/adapters/typescript.ts
+const createSourceFile = (filePath, source) => {
+	const scriptKind = extname(filePath) === ".tsx" ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+	return ts.createSourceFile(filePath, source, ts.ScriptTarget.ES2022, true, scriptKind);
+};
+const toLocation = (sourceFile, node) => {
+	const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+	const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+	return {
+		start: {
+			line: start.line + 1,
+			column: start.character + 1
+		},
+		end: {
+			line: end.line + 1,
+			column: end.character + 1
+		}
+	};
+};
+const collectGqlImports = (sourceFile, helper) => {
+	const identifiers = new Set();
+	sourceFile.statements.forEach((statement) => {
+		if (!ts.isImportDeclaration(statement) || !statement.importClause) {
+			return;
+		}
+		const moduleText = statement.moduleSpecifier.text;
+		if (!helper.isGraphqlSystemImportSpecifier({
+			filePath: sourceFile.fileName,
+			specifier: moduleText
+		})) {
+			return;
+		}
+		if (statement.importClause.namedBindings && ts.isNamedImports(statement.importClause.namedBindings)) {
+			statement.importClause.namedBindings.elements.forEach((element) => {
+				const imported = element.propertyName ? element.propertyName.text : element.name.text;
+				if (imported === "gql") {
+					identifiers.add(element.name.text);
+				}
+			});
+		}
+	});
+	return identifiers;
+};
+const collectImports = (sourceFile) => {
+	const imports = [];
+	sourceFile.statements.forEach((statement) => {
+		if (!ts.isImportDeclaration(statement) || !statement.importClause) {
+			return;
+		}
+		const moduleText = statement.moduleSpecifier.text;
+		const { importClause } = statement;
+		if (importClause.name) {
+			imports.push({
+				source: moduleText,
+				imported: "default",
+				local: importClause.name.text,
+				kind: "default",
+				isTypeOnly: Boolean(importClause.isTypeOnly)
+			});
+		}
+		const { namedBindings } = importClause;
+		if (!namedBindings) {
+			return;
+		}
+		if (ts.isNamespaceImport(namedBindings)) {
+			imports.push({
+				source: moduleText,
+				imported: "*",
+				local: namedBindings.name.text,
+				kind: "namespace",
+				isTypeOnly: Boolean(importClause.isTypeOnly)
+			});
+			return;
+		}
+		namedBindings.elements.forEach((element) => {
+			imports.push({
+				source: moduleText,
+				imported: element.propertyName ? element.propertyName.text : element.name.text,
+				local: element.name.text,
+				kind: "named",
+				isTypeOnly: Boolean(importClause.isTypeOnly || element.isTypeOnly)
+			});
+		});
+	});
+	return imports;
+};
+const collectExports = (sourceFile) => {
+	const exports = [];
+	sourceFile.statements.forEach((statement) => {
+		if (ts.isExportDeclaration(statement)) {
+			const moduleSpecifier = statement.moduleSpecifier ? statement.moduleSpecifier.text : undefined;
+			if (statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+				statement.exportClause.elements.forEach((element) => {
+					if (moduleSpecifier) {
+						exports.push({
+							kind: "reexport",
+							exported: element.name.text,
+							local: element.propertyName ? element.propertyName.text : undefined,
+							source: moduleSpecifier,
+							isTypeOnly: Boolean(statement.isTypeOnly || element.isTypeOnly)
+						});
+					} else {
+						exports.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.push({
+					kind: "reexport",
+					exported: "*",
+					source: moduleSpecifier,
+					isTypeOnly: Boolean(statement.isTypeOnly)
+				});
+			}
+			return;
+		}
+		if (ts.isExportAssignment(statement)) {
+			exports.push({
+				kind: "named",
+				exported: "default",
+				local: "default",
+				isTypeOnly: false
+			});
+		}
+		if (ts.isVariableStatement(statement) && statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
+			statement.declarationList.declarations.forEach((declaration) => {
+				if (ts.isIdentifier(declaration.name)) {
+					exports.push({
+						kind: "named",
+						exported: declaration.name.text,
+						local: declaration.name.text,
+						isTypeOnly: false
+					});
+				}
+			});
+		}
+		if (ts.isFunctionDeclaration(statement) && statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) && statement.name) {
+			exports.push({
+				kind: "named",
+				exported: statement.name.text,
+				local: statement.name.text,
+				isTypeOnly: false
+			});
+		}
+	});
+	return exports;
+};
+const isGqlDefinitionCall = (identifiers, callExpression) => {
+	const expression = callExpression.expression;
+	if (!ts.isPropertyAccessExpression(expression)) {
+		return false;
+	}
+	if (!ts.isIdentifier(expression.expression) || !identifiers.has(expression.expression.text)) {
+		return false;
+	}
+	const [factory] = callExpression.arguments;
+	if (!factory || !ts.isArrowFunction(factory)) {
+		return false;
+	}
+	return true;
+};
+/**
+* Get property name from AST node
+*/
+const getPropertyName = (name) => {
+	if (ts.isIdentifier(name)) {
+		return name.text;
+	}
+	if (ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+		return name.text;
+	}
+	return null;
+};
+/**
+* Collect all gql definitions (exported, non-exported, top-level, nested)
+*/
+const collectAllDefinitions = ({ sourceFile, identifiers, exports }) => {
+	const pending = [];
+	const handledCalls = [];
+	const exportBindings = createExportBindingsMap(exports);
+	const tracker = createCanonicalTracker$1({
+		filePath: sourceFile.fileName,
+		getExportName: (localName) => exportBindings.get(localName)
+	});
+	const anonymousCounters = new Map();
+	const getAnonymousName = (kind) => {
+		const count = anonymousCounters.get(kind) ?? 0;
+		anonymousCounters.set(kind, count + 1);
+		return `${kind}#${count}`;
+	};
+	const withScope = (stack, segment, kind, stableKey, callback) => {
+		const handle = tracker.enterScope({
+			segment,
+			kind,
+			stableKey
+		});
+		try {
+			const frame = {
+				nameSegment: segment,
+				kind
+			};
+			return callback([...stack, frame]);
+		} finally {
+			tracker.exitScope(handle);
+		}
+	};
+	const visit = (node, stack) => {
+		if (ts.isCallExpression(node) && isGqlDefinitionCall(identifiers, node)) {
+			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,
+				loc: toLocation(sourceFile, node),
+				expression: node.getText(sourceFile)
+			});
+			return;
+		}
+		if (ts.isVariableDeclaration(node) && node.name && ts.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 (ts.isFunctionDeclaration(node)) {
+			const funcName = node.name?.text ?? getAnonymousName("function");
+			if (node.body) {
+				const next = node.body;
+				withScope(stack, funcName, "function", `func:${funcName}`, (newStack) => {
+					ts.forEachChild(next, (child) => visit(child, newStack));
+				});
+			}
+			return;
+		}
+		if (ts.isArrowFunction(node)) {
+			const arrowName = getAnonymousName("arrow");
+			withScope(stack, arrowName, "function", "arrow", (newStack) => {
+				if (ts.isBlock(node.body)) {
+					ts.forEachChild(node.body, (child) => visit(child, newStack));
+				} else {
+					visit(node.body, newStack);
+				}
+			});
+			return;
+		}
+		if (ts.isFunctionExpression(node)) {
+			const funcName = node.name?.text ?? getAnonymousName("function");
+			if (node.body) {
+				withScope(stack, funcName, "function", `func:${funcName}`, (newStack) => {
+					ts.forEachChild(node.body, (child) => visit(child, newStack));
+				});
+			}
+			return;
+		}
+		if (ts.isClassDeclaration(node)) {
+			const className = node.name?.text ?? getAnonymousName("class");
+			withScope(stack, className, "class", `class:${className}`, (classStack) => {
+				node.members.forEach((member) => {
+					if (ts.isMethodDeclaration(member) || ts.isPropertyDeclaration(member)) {
+						const memberName = member.name && ts.isIdentifier(member.name) ? member.name.text : null;
+						if (memberName) {
+							const memberKind = ts.isMethodDeclaration(member) ? "method" : "property";
+							withScope(classStack, memberName, memberKind, `member:${className}.${memberName}`, (memberStack) => {
+								if (ts.isMethodDeclaration(member) && member.body) {
+									ts.forEachChild(member.body, (child) => visit(child, memberStack));
+								} else if (ts.isPropertyDeclaration(member) && member.initializer) {
+									visit(member.initializer, memberStack);
+								}
+							});
+						}
+					}
+				});
+			});
+			return;
+		}
+		if (ts.isPropertyAssignment(node)) {
+			const propName = getPropertyName(node.name);
+			if (propName) {
+				withScope(stack, propName, "property", `prop:${propName}`, (newStack) => {
+					visit(node.initializer, newStack);
+				});
+			}
+			return;
+		}
+		ts.forEachChild(node, (child) => visit(child, stack));
+	};
+	sourceFile.statements.forEach((statement) => {
+		visit(statement, []);
+	});
+	const definitions = pending.map((item) => ({
+		canonicalId: createCanonicalId$1(sourceFile.fileName, item.astPath),
+		astPath: item.astPath,
+		isTopLevel: item.isTopLevel,
+		isExported: item.isExported,
+		exportBinding: item.exportBinding,
+		loc: item.loc,
+		expression: item.expression
+	}));
+	return {
+		definitions,
+		handledCalls
+	};
+};
+/**
+* Collect diagnostics (now empty since we support all definition types)
+*/
+const collectDiagnostics = (_sourceFile, _identifiers, _handledCalls) => {
+	return [];
+};
+/**
+* TypeScript adapter implementation
+*/
+const typescriptAdapter = {
+	parse(input) {
+		return createSourceFile(input.filePath, input.source);
+	},
+	collectGqlIdentifiers(file, helper) {
+		return collectGqlImports(file, helper);
+	},
+	collectImports(file) {
+		return collectImports(file);
+	},
+	collectExports(file) {
+		return collectExports(file);
+	},
+	collectDefinitions(file, context) {
+		const { definitions, handledCalls } = collectAllDefinitions({
+			sourceFile: file,
+			identifiers: context.gqlIdentifiers,
+			exports: context.exports
+		});
+		return {
+			definitions,
+			handles: handledCalls
+		};
+	},
+	collectDiagnostics(file, context) {
+		return collectDiagnostics(file, context.gqlIdentifiers, context.handledCalls);
+	}
+};
+
+//#endregion
+//#region packages/builder/src/ast/core.ts
+/**
+* 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 = getPortableHasher();
+	const signature = hasher.hash(input.source, "xxhash");
+	const file = adapter.parse(input);
+	if (!file) {
+		return {
+			filePath: input.filePath,
+			signature,
+			definitions: [],
+			diagnostics: [],
+			imports: [],
+			exports: []
+		};
+	}
+	const gqlIdentifiers = adapter.collectGqlIdentifiers(file, graphqlHelper);
+	const imports = adapter.collectImports(file);
+	const exports = adapter.collectExports(file);
+	const { definitions, handles } = adapter.collectDefinitions(file, {
+		gqlIdentifiers,
+		imports,
+		exports,
+		source: input.source
+	});
+	const diagnostics = adapter.collectDiagnostics(file, {
+		gqlIdentifiers,
+		handledCalls: handles,
+		source: input.source
+	});
+	return {
+		filePath: input.filePath,
+		signature,
+		definitions,
+		diagnostics,
+		imports,
+		exports
+	};
+};
+
+//#endregion
+//#region packages/builder/src/ast/index.ts
+const createAstAnalyzer = ({ analyzer, graphqlHelper }) => {
+	const analyze = (input) => {
+		if (analyzer === "ts") {
+			return analyzeModuleCore(input, typescriptAdapter, graphqlHelper);
+		}
+		if (analyzer === "swc") {
+			return analyzeModuleCore(input, swcAdapter, graphqlHelper);
+		}
+		return assertUnreachable(analyzer, "createAstAnalyzer");
+	};
+	return {
+		type: analyzer,
+		analyze
+	};
+};
+const getAstAnalyzer = (analyzer) => {
+	throw new Error("getAstAnalyzer is deprecated. Use createAstAnalyzer with graphqlHelper parameter instead.");
+};
+
+//#endregion
+//#region packages/builder/src/cache/json-cache.ts
+const JSON_EXT = ".json";
+const sanitizeSegment = (segment) => segment.replace(/[\\/]/g, "_");
+const ensureDirectory = (directory) => {
+	if (!existsSync(directory)) {
+		mkdirSync(directory, { recursive: true });
+	}
+};
+const toNamespacePath = (root, segments) => join(root, ...segments.map(sanitizeSegment));
+const toEntryFilename = (key) => {
+	const hasher = getPortableHasher();
+	return `${hasher.hash(key, "xxhash")}${JSON_EXT}`;
+};
+const createJsonCache = ({ rootDir, prefix = [] }) => {
+	const basePath = toNamespacePath(rootDir, prefix);
+	ensureDirectory(basePath);
+	const enumerateFiles = (directory) => {
+		if (!existsSync(directory)) {
+			return [];
+		}
+		return readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(JSON_EXT)).map((entry) => join(directory, entry.name));
+	};
+	return {
+		createStore: ({ namespace, schema, version = "v1" }) => {
+			const storeRoot = toNamespacePath(basePath, namespace);
+			ensureDirectory(storeRoot);
+			const envelopeSchema = z.object({
+				key: z.string(),
+				version: z.string(),
+				value: schema
+			});
+			const resolveEntryPath = (key) => join(storeRoot, toEntryFilename(key));
+			const readEnvelope = (filePath) => {
+				try {
+					const raw = readFileSync(filePath, "utf8");
+					const parsed = envelopeSchema.safeParse(JSON.parse(raw));
+					if (!parsed.success) {
+						unlinkSync(filePath);
+						return null;
+					}
+					if (parsed.data.version !== version) {
+						unlinkSync(filePath);
+						return null;
+					}
+					return parsed.data;
+				} catch {
+					unlinkSync(filePath);
+					return null;
+				}
+			};
+			const load = (key) => {
+				const filePath = resolveEntryPath(key);
+				if (!existsSync(filePath)) {
+					return null;
+				}
+				const envelope = readEnvelope(filePath);
+				if (!envelope || envelope.key !== key) {
+					return null;
+				}
+				return envelope.value;
+			};
+			const store = (key, value) => {
+				const filePath = resolveEntryPath(key);
+				ensureDirectory(storeRoot);
+				const envelope = {
+					key,
+					version,
+					value
+				};
+				writeFileSync(filePath, JSON.stringify(envelope));
+			};
+			const deleteEntry = (key) => {
+				const filePath = resolveEntryPath(key);
+				if (existsSync(filePath)) {
+					unlinkSync(filePath);
+				}
+			};
+			function* iterateEntries() {
+				for (const filePath of enumerateFiles(storeRoot)) {
+					const envelope = readEnvelope(filePath);
+					if (!envelope) {
+						continue;
+					}
+					yield [envelope.key, envelope.value];
+				}
+			}
+			const clear = () => {
+				for (const filePath of enumerateFiles(storeRoot)) {
+					unlinkSync(filePath);
+				}
+			};
+			const size = () => {
+				let count = 0;
+				for (const _ of iterateEntries()) {
+					count += 1;
+				}
+				return count;
+			};
+			return {
+				load,
+				store,
+				delete: deleteEntry,
+				entries: iterateEntries,
+				clear,
+				size
+			};
+		},
+		clearAll: () => {
+			if (existsSync(basePath)) {
+				rmSync(basePath, {
+					recursive: true,
+					force: true
+				});
+			}
+			ensureDirectory(basePath);
+		}
+	};
+};
+
+//#endregion
+//#region packages/builder/src/cache/json-entity-cache.ts
+/**
+* Abstract base class for JSON-based entity caches.
+* Provides common caching functionality with signature-based eviction.
+*/
+var JsonEntityCache = class {
+	cacheStore;
+	keyNormalizer;
+	constructor(options) {
+		this.cacheStore = options.factory.createStore({
+			namespace: [...options.namespace],
+			schema: options.schema,
+			version: options.version
+		});
+		this.keyNormalizer = options.keyNormalizer ?? 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 SourcePositionSchema = z.object({
+	line: z.number(),
+	column: z.number()
+});
+const SourceLocationSchema = z.object({
+	start: SourcePositionSchema,
+	end: SourcePositionSchema
+});
+const ModuleDefinitionSchema = z.object({
+	canonicalId: CanonicalIdSchema,
+	astPath: z.string(),
+	isTopLevel: z.boolean(),
+	isExported: z.boolean(),
+	exportBinding: z.string().optional(),
+	loc: SourceLocationSchema,
+	expression: z.string()
+});
+const ModuleDiagnosticSchema = z.object({
+	code: z.literal("NON_TOP_LEVEL_DEFINITION"),
+	message: z.string(),
+	loc: SourceLocationSchema
+});
+const ModuleImportSchema = z.object({
+	source: z.string(),
+	imported: z.string(),
+	local: z.string(),
+	kind: z.enum([
+		"named",
+		"namespace",
+		"default"
+	]),
+	isTypeOnly: z.boolean()
+});
+const ModuleExportSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("named"),
+	exported: z.string(),
+	local: z.string(),
+	source: z.undefined().optional(),
+	isTypeOnly: z.boolean()
+}), z.object({
+	kind: z.literal("reexport"),
+	exported: z.string(),
+	source: z.string(),
+	local: z.string().optional(),
+	isTypeOnly: z.boolean()
+})]);
+const ModuleAnalysisSchema = z.object({
+	filePath: z.string(),
+	signature: z.string(),
+	definitions: z.array(ModuleDefinitionSchema).readonly(),
+	diagnostics: z.array(ModuleDiagnosticSchema).readonly(),
+	imports: z.array(ModuleImportSchema).readonly(),
+	exports: z.array(ModuleExportSchema).readonly()
+});
+
+//#endregion
+//#region packages/builder/src/schemas/discovery.ts
+const FileFingerprintSchema = z.object({
+	hash: z.string(),
+	sizeBytes: z.number(),
+	mtimeMs: z.number()
+});
+const DiscoveredDependencySchema = z.object({
+	specifier: z.string(),
+	resolvedPath: z.string().nullable(),
+	isExternal: z.boolean()
+});
+const DiscoverySnapshotSchema = z.object({
+	filePath: z.string(),
+	normalizedFilePath: z.string(),
+	signature: z.string(),
+	fingerprint: FileFingerprintSchema,
+	analyzer: z.string(),
+	createdAtMs: z.number(),
+	analysis: ModuleAnalysisSchema,
+	dependencies: z.array(DiscoveredDependencySchema).readonly()
+});
+
+//#endregion
+//#region packages/builder/src/discovery/cache.ts
+const DISCOVERY_CACHE_VERSION = "discovery-cache/v3";
+var JsonDiscoveryCache = class extends JsonEntityCache {
+	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 = isExternalSpecifier(specifier);
+		const resolvedPath = isExternal ? null : 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 = 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 = statSync(path);
+		if (!stats.isFile()) {
+			return 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 ok(cached);
+		}
+		const contents = readFileSync(path);
+		const sizeBytes = stats.size;
+		const hash = computeHashSync(contents);
+		const fingerprint = {
+			hash,
+			sizeBytes,
+			mtimeMs
+		};
+		fingerprintCache.set(path, fingerprint);
+		return ok(fingerprint);
+	} catch (error) {
+		if (error.code === "ENOENT") {
+			return err({
+				code: "FILE_NOT_FOUND",
+				path,
+				message: `File not found: ${path}`
+			});
+		}
+		return 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);
+}
+/**
+* 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
+/**
+* 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.
+*/
+const discoverModules = ({ 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 = normalizePath(rawFilePath);
+		if (snapshots.has(filePath)) {
+			continue;
+		}
+		if (invalidatedSet.has(filePath)) {
+			invalidateFingerprint(filePath);
+			cacheSkips++;
+		} else if (incremental) {
+			const cached = incremental.cache.peek(filePath);
+			if (cached) {
+				try {
+					const stats = statSync(filePath);
+					const mtimeMs = stats.mtimeMs;
+					const sizeBytes = stats.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);
+							}
+						}
+						continue;
+					}
+				} catch {}
+			}
+		}
+		let source;
+		try {
+			source = readFileSync(filePath, "utf8");
+		} catch (error) {
+			if (error.code === "ENOENT") {
+				incremental?.cache.delete(filePath);
+				invalidateFingerprint(filePath);
+				continue;
+			}
+			return err(builderErrors.discoveryIOError(filePath, error instanceof Error ? error.message : String(error)));
+		}
+		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 fingerprintResult = computeFingerprint(filePath);
+		if (fingerprintResult.isErr()) {
+			return err(builderErrors.discoveryIOError(filePath, `Failed to compute fingerprint: ${fingerprintResult.error.message}`));
+		}
+		const fingerprint = fingerprintResult.value;
+		const snapshot = {
+			filePath,
+			normalizedFilePath: normalizePath(filePath),
+			signature,
+			fingerprint,
+			analyzer: astAnalyzer.type,
+			createdAtMs: Date.now(),
+			analysis,
+			dependencies
+		};
+		snapshots.set(filePath, snapshot);
+		if (incremental) {
+			incremental.cache.store(snapshot);
+		}
+	}
+	return ok({
+		snapshots: Array.from(snapshots.values()),
+		cacheHits,
+		cacheMisses,
+		cacheSkips
+	});
+};
+
+//#endregion
+//#region packages/builder/src/utils/glob.ts
+/**
+* Scan files matching a glob pattern from the given directory
+* @param pattern - Glob pattern (e.g., "src/**\/*.ts")
+* @param cwd - Working directory (defaults to process.cwd())
+* @returns Array of matched file paths (relative to cwd)
+*/
+const scanGlob = (pattern, cwd = process.cwd()) => {
+	if (typeof Bun !== "undefined" && Bun.Glob) {
+		const { Glob } = Bun;
+		const glob = new Glob(pattern);
+		return Array.from(glob.scanSync(cwd));
+	}
+	return fg.sync(pattern, {
+		cwd,
+		dot: true,
+		onlyFiles: true
+	});
+};
+
+//#endregion
+//#region packages/builder/src/discovery/entry-paths.ts
+const scanEntries = (pattern) => {
+	return scanGlob(pattern, process.cwd());
+};
+/**
+* Resolve entry file paths from glob patterns or direct paths.
+* Used by the discovery system to find entry points for module traversal.
+* All paths are normalized to POSIX format for consistent cache key matching.
+* Uses Node.js normalize() + backslash replacement to match normalizePath from @soda-gql/common.
+*/
+const resolveEntryPaths = (entries) => {
+	const resolvedPaths = entries.flatMap((entry) => {
+		const absolute = resolve(entry);
+		if (existsSync(absolute)) {
+			return [normalize(absolute).replace(/\\/g, "/")];
+		}
+		const matches = scanEntries(entry).map((match) => {
+			return normalize(resolve(match)).replace(/\\/g, "/");
+		});
+		return matches;
+	});
+	if (resolvedPaths.length === 0) {
+		return err({
+			code: "ENTRY_NOT_FOUND",
+			message: `No entry files matched ${entries.join(", ")}`,
+			entry: entries.join(", ")
+		});
+	}
+	return ok(resolvedPaths);
+};
+
+//#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 }) => {
+	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 = resolveRelativeImportWithReferences({
+			filePath,
+			specifier: imp.source,
+			references: analyses
+		});
+		if (!resolvedPath) {
+			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} = registry.importModule("${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} } = registry.importModule("${filePath$1}");`);
+			}
+		}
+	});
+	return {
+		imports: importLines.length > 0 ? `${importLines.join("\n")}` : "",
+		importedRootNames,
+		namespaceImports
+	};
+};
+const renderRegistryBlock = ({ filePath, analysis, analyses }) => {
+	const { imports } = renderImportStatements({
+		filePath,
+		analysis,
+		analyses
+	});
+	return [
+		`registry.setModule("${filePath}", () => {`,
+		imports,
+		"",
+		buildNestedObject(analysis.definitions),
+		"});"
+	].join("\n");
+};
+
+//#endregion
+//#region packages/builder/src/intermediate-module/registry.ts
+const createIntermediateRegistry = () => {
+	const modules = new Map();
+	const elements = new Map();
+	const setModule = (filePath, factory) => {
+		let cached;
+		modules.set(filePath, () => cached ??= factory());
+	};
+	const importModule = (filePath) => {
+		const factory = modules.get(filePath);
+		if (!factory) {
+			throw new Error(`Module not found or yet to be registered: ${filePath}`);
+		}
+		return factory();
+	};
+	const addElement = (canonicalId, factory) => {
+		const builder = factory();
+		GqlElement.setContext(builder, { canonicalId });
+		elements.set(canonicalId, builder);
+		return builder;
+	};
+	const evaluate = () => {
+		for (const mod of modules.values()) {
+			mod();
+		}
+		for (const element of elements.values()) {
+			GqlElement.evaluate(element);
+		}
+		const artifacts = {};
+		for (const [canonicalId, element] of elements.entries()) {
+			if (element instanceof Model) {
+				artifacts[canonicalId] = {
+					type: "model",
+					element
+				};
+			} else if (element instanceof Slice) {
+				artifacts[canonicalId] = {
+					type: "slice",
+					element
+				};
+			} else if (element instanceof ComposedOperation) {
+				artifacts[canonicalId] = {
+					type: "operation",
+					element
+				};
+			} else if (element instanceof InlineOperation) {
+				artifacts[canonicalId] = {
+					type: "inlineOperation",
+					element
+				};
+			}
+		}
+		return artifacts;
+	};
+	const clear = () => {
+		modules.clear();
+		elements.clear();
+	};
+	return {
+		setModule,
+		importModule,
+		addElement,
+		evaluate,
+		clear
+	};
+};
+
+//#endregion
+//#region packages/builder/src/intermediate-module/evaluation.ts
+const transpile = ({ filePath, sourceCode }) => {
+	try {
+		const result = transformSync(sourceCode, {
+			filename: `${filePath}.ts`,
+			jsc: {
+				parser: {
+					syntax: "typescript",
+					tsx: false
+				},
+				target: "es2022"
+			},
+			module: { type: "es6" },
+			sourceMaps: false,
+			minify: false
+		});
+		return ok(result.code);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return 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 = extname(configPath);
+	if (ext === ".cjs") {
+		return resolve(process.cwd(), configPath);
+	}
+	if (ext === ".ts") {
+		const basePath = configPath.slice(0, -3);
+		const cjsPath = `${basePath}.cjs`;
+		const resolvedCjsPath = resolve(process.cwd(), cjsPath);
+		if (existsSync(resolvedCjsPath)) {
+			return resolvedCjsPath;
+		}
+		return resolve(process.cwd(), configPath);
+	}
+	return 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;
+function executeGraphqlSystemModule(modulePath) {
+	if (cachedModulePath === modulePath && cachedGql !== null) {
+		return { gql: cachedGql };
+	}
+	const bundledCode = readFileSync(modulePath, "utf-8");
+	const moduleExports = {};
+	const sandbox = {
+		require: (path) => {
+			if (path === "@soda-gql/core") {
+				return sandboxCore;
+			}
+			if (path === "@soda-gql/runtime") {
+				return sandboxRuntime;
+			}
+			throw new Error(`Unknown module: ${path}`);
+		},
+		module: { exports: moduleExports },
+		exports: moduleExports,
+		__dirname: resolve(modulePath, ".."),
+		__filename: modulePath,
+		global: undefined,
+		globalThis: undefined
+	};
+	sandbox.global = sandbox;
+	sandbox.globalThis = sandbox;
+	new Script(bundledCode, { filename: modulePath }).runInNewContext(sandbox);
+	const exportedGql = moduleExports.gql ?? moduleExports.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 }) {
+	for (const filePath of targetFiles) {
+		const analysis = analyses.get(filePath);
+		if (!analysis) {
+			continue;
+		}
+		const sourceCode = renderRegistryBlock({
+			filePath,
+			analysis,
+			analyses
+		});
+		const transpiledCodeResult = transpile({
+			filePath,
+			sourceCode
+		});
+		if (transpiledCodeResult.isErr()) {
+			continue;
+		}
+		const transpiledCode = transpiledCodeResult.value;
+		const script = new Script(transpiledCode);
+		const hash = 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
+		};
+	}
+};
+const evaluateIntermediateModules = ({ intermediateModules, graphqlSystemPath }) => {
+	const registry = createIntermediateRegistry();
+	const gqlImportPath = resolveGraphqlSystemPath(graphqlSystemPath);
+	const { gql } = executeGraphqlSystemModule(gqlImportPath);
+	const vmContext = 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;
+		}
+	}
+	const elements = registry.evaluate();
+	registry.clear();
+	return elements;
+};
+
+//#endregion
+//#region packages/builder/src/internal/graphql-system.ts
+/**
+* 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 = resolve(file);
+		return getCanonicalFileName(resolved);
+	};
+	const graphqlSystemPath = 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 = resolveRelativeImportWithExistenceCheck({
+				filePath,
+				specifier
+			});
+			if (!resolved) {
+				return false;
+			}
+			return toCanonical(resolved) === canonicalGraphqlSystemPath;
+		}
+	};
+};
+
+//#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 = normalizePath(path);
+				const stats = statSync(normalized);
+				files.set(normalized, {
+					mtimeMs: stats.mtimeMs,
+					size: stats.size
+				});
+			} catch {}
+		}
+		nextScan = { files };
+		return 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 }) => {
+	for (const analysis of analyses.values()) {
+		for (const { source, isTypeOnly } of analysis.imports) {
+			if (isTypeOnly) {
+				continue;
+			}
+			if (isRelativeSpecifier(source)) {
+				const resolvedModule = resolveRelativeImportWithReferences({
+					filePath: analysis.filePath,
+					specifier: source,
+					references: analyses
+				});
+				if (!resolvedModule) {
+					return err({
+						code: "MISSING_IMPORT",
+						chain: [analysis.filePath, source]
+					});
+				}
+			}
+		}
+	}
+	return 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 = 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
+/**
+* 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
+	};
+	const cacheFactory = createJsonCache({
+		rootDir: join(process.cwd(), ".cache", "soda-gql", "builder"),
+		prefix: ["builder"]
+	});
+	const graphqlHelper = createGraphqlSystemIdentifyHelper(config);
+	const ensureAstAnalyzer = cachedFn(() => createAstAnalyzer({
+		analyzer: config.analyzer,
+		graphqlHelper
+	}));
+	const ensureDiscoveryCache = cachedFn(() => createDiscoveryCache({
+		factory: cacheFactory,
+		analyzer: config.analyzer,
+		evaluatorId
+	}));
+	const ensureFileTracker = cachedFn(() => createFileTracker());
+	const build = (options$1) => {
+		const force = options$1?.force ?? false;
+		const entryPathsResult = resolveEntryPaths(Array.from(entrypoints));
+		if (entryPathsResult.isErr()) {
+			return err(entryPathsResult.error);
+		}
+		const entryPaths = entryPathsResult.value;
+		const tracker = ensureFileTracker();
+		const scanResult = tracker.scan(entryPaths);
+		if (scanResult.isErr()) {
+			const trackerError = scanResult.error;
+			return 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 err(prepareResult.error);
+		}
+		if (prepareResult.value.type === "should-skip") {
+			return ok(prepareResult.value.data.artifact);
+		}
+		const { changedFiles, removedFiles } = prepareResult.value.data;
+		const discoveryCache = ensureDiscoveryCache();
+		const astAnalyzer = ensureAstAnalyzer();
+		const discoveryResult = discover({
+			discoveryCache,
+			astAnalyzer,
+			removedFiles,
+			changedFiles,
+			entryPaths,
+			previousModuleAdjacency: state.moduleAdjacency
+		});
+		if (discoveryResult.isErr()) {
+			return err(discoveryResult.error);
+		}
+		const { snapshots, analyses, currentModuleAdjacency, affectedFiles, stats } = discoveryResult.value;
+		const buildResult = buildDiscovered({
+			analyses,
+			affectedFiles,
+			stats,
+			previousIntermediateModules: state.intermediateModules,
+			graphqlSystemPath: resolve(config.outdir, "index.ts")
+		});
+		if (buildResult.isErr()) {
+			return err(buildResult.error);
+		}
+		const { intermediateModules, artifact } = buildResult.value;
+		state.gen++;
+		state.snapshots = snapshots;
+		state.moduleAdjacency = currentModuleAdjacency;
+		state.lastArtifact = artifact;
+		state.intermediateModules = intermediateModules;
+		tracker.update(currentScan);
+		return ok(artifact);
+	};
+	return {
+		build,
+		getGeneration: () => state.gen,
+		getCurrentArtifact: () => state.lastArtifact
+	};
+};
+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 ok({
+			type: "should-skip",
+			data: { artifact: lastArtifact }
+		});
+	}
+	return ok({
+		type: "should-build",
+		data: {
+			changedFiles,
+			removedFiles
+		}
+	});
+};
+const discover = ({ discoveryCache, astAnalyzer, removedFiles, changedFiles, entryPaths, previousModuleAdjacency }) => {
+	const affectedFiles = collectAffectedFiles({
+		changedFiles,
+		removedFiles,
+		previousModuleAdjacency
+	});
+	const discoveryResult = discoverModules({
+		entryPaths,
+		astAnalyzer,
+		incremental: {
+			cache: discoveryCache,
+			changedFiles,
+			removedFiles,
+			affectedFiles
+		}
+	});
+	if (discoveryResult.isErr()) {
+		return err(discoveryResult.error);
+	}
+	const { cacheHits, cacheMisses, cacheSkips } = discoveryResult.value;
+	const snapshots = new Map(discoveryResult.value.snapshots.map((snapshot) => [snapshot.normalizedFilePath, snapshot]));
+	const analyses = new Map(discoveryResult.value.snapshots.map((snapshot) => [snapshot.normalizedFilePath, snapshot.analysis]));
+	const dependenciesValidationResult = validateModuleDependencies({ analyses });
+	if (dependenciesValidationResult.isErr()) {
+		const error = dependenciesValidationResult.error;
+		return err(builderErrors.graphMissingImport(error.chain[0], error.chain[1]));
+	}
+	const currentModuleAdjacency = extractModuleAdjacency({ snapshots });
+	const stats = {
+		hits: cacheHits,
+		misses: cacheMisses,
+		skips: cacheSkips
+	};
+	return ok({
+		snapshots,
+		analyses,
+		currentModuleAdjacency,
+		affectedFiles,
+		stats
+	});
+};
+const buildDiscovered = ({ analyses, affectedFiles, stats, previousIntermediateModules, graphqlSystemPath }) => {
+	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
+	})) {
+		intermediateModules.set(intermediateModule.filePath, intermediateModule);
+	}
+	const elements = evaluateIntermediateModules({
+		intermediateModules,
+		graphqlSystemPath
+	});
+	const artifactResult = buildArtifact({
+		analyses,
+		elements,
+		stats
+	});
+	if (artifactResult.isErr()) {
+		return err(artifactResult.error);
+	}
+	return ok({
+		intermediateModules,
+		artifact: artifactResult.value
+	});
+};
+
+//#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),
+		getGeneration: () => session.getGeneration(),
+		getCurrentArtifact: () => session.getCurrentArtifact()
+	};
+};
+
+//#endregion
+export { BuilderArtifactSchema, buildAstPath, createBuilderService, createBuilderSession, createCanonicalId, createCanonicalTracker, createOccurrenceTracker, createPathTracker };
+//# sourceMappingURL=index.js.map