@soda-gql/builder 0.10.0 → 0.10.2

package/dist/index.cjs

@@ -33,6 +33,7 @@ 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");
@@ -41,7 +42,6 @@ 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 __swc_core = require("@swc/core");
 let graphql = require("graphql");
 let typescript = require("typescript");
 typescript = __toESM(typescript);
@@ -195,98 +195,6 @@ function parseAndValidateArtifact(content, filePath) {
 	return (0, neverthrow.ok)(validated.data);
 }
 
-//#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/errors.ts
 /**
@@ -503,6 +411,98 @@ 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
 /**
@@ -687,6 +687,74 @@ const BuilderEffects = {
 	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) => {
@@ -1186,32 +1254,7 @@ function executeGraphqlSystemModule(modulePath) {
 		return { gql: cachedGql };
 	}
 	const bundledCode = (0, node_fs.readFileSync)(modulePath, "utf-8");
-	const moduleExports = {};
-	const sandbox = {
-		require: (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}`);
-		},
-		module: { exports: moduleExports },
-		exports: moduleExports,
-		__dirname: (0, node_path.resolve)(modulePath, ".."),
-		__filename: modulePath,
-		global: undefined,
-		globalThis: undefined
-	};
-	sandbox.global = sandbox;
-	sandbox.globalThis = sandbox;
+	const sandbox = createSandbox(modulePath);
 	new node_vm.Script(bundledCode, { filename: modulePath }).runInNewContext(sandbox);
 	const finalExports = sandbox.module.exports;
 	const exportedGql = finalExports.gql ?? finalExports.default;
@@ -1394,310 +1437,6 @@ const createGraphqlSystemIdentifyHelper = (config) => {
 	};
 };
 
-//#endregion
-//#region packages/builder/src/prebuilt/emitter.ts
-/**
-* Prebuilt types emitter.
-*
-* Generates TypeScript type definitions for PrebuiltTypes registry
-* from field selection data and schema.
-*
-* ## Error Handling Strategy
-*
-* The emitter uses a partial failure approach for type calculation errors:
-*
-* **Recoverable errors** (result in warnings, element skipped):
-* - Type calculation failures (e.g., `calculateFieldsType` throws)
-* - Input type generation failures (e.g., `generateInputType` throws)
-* - These are caught per-element, logged as warnings, and the element is omitted
-*
-* **Fatal errors** (result in error result):
-* - `SCHEMA_NOT_FOUND`: Selection references non-existent schema
-* - `WRITE_FAILED`: Cannot write output file to disk
-*
-* This allows builds to succeed with partial type coverage when some elements
-* have issues, while providing visibility into problems via warnings.
-*
-* @module
-*/
-/**
-* Group field selections by schema.
-* Uses the schemaLabel from each selection to group them correctly.
-*
-* @returns Result containing grouped selections and warnings, or error if schema not found
-*/
-const groupBySchema = (fieldSelections, schemas) => {
-	const grouped = new Map();
-	const warnings = [];
-	for (const schemaName of Object.keys(schemas)) {
-		grouped.set(schemaName, {
-			fragments: [],
-			operations: [],
-			inputObjects: new Set()
-		});
-	}
-	for (const [canonicalId, selection] of fieldSelections) {
-		const schemaName = selection.schemaLabel;
-		const schema = schemas[schemaName];
-		const group = grouped.get(schemaName);
-		if (!schema || !group) {
-			return (0, neverthrow.err)(builderErrors.schemaNotFound(schemaName, canonicalId));
-		}
-		const outputFormatters = { scalarOutput: (name) => `ScalarOutput_${schemaName}<"${name}">` };
-		const inputFormatters = {
-			scalarInput: (name) => `ScalarInput_${schemaName}<"${name}">`,
-			inputObject: (name) => `Input_${schemaName}_${name}`
-		};
-		if (selection.type === "fragment") {
-			if (!selection.key) {
-				continue;
-			}
-			try {
-				const usedInputObjects = collectUsedInputObjectsFromSpecifiers(schema, selection.variableDefinitions);
-				for (const inputName of usedInputObjects) {
-					group.inputObjects.add(inputName);
-				}
-				const outputType = (0, __soda_gql_core.calculateFieldsType)(schema, selection.fields, outputFormatters);
-				const hasVariables = Object.keys(selection.variableDefinitions).length > 0;
-				const inputType = hasVariables ? (0, __soda_gql_core.generateInputTypeFromSpecifiers)(schema, selection.variableDefinitions, { formatters: inputFormatters }) : "void";
-				group.fragments.push({
-					key: selection.key,
-					inputType,
-					outputType
-				});
-			} catch (error) {
-				warnings.push(`[prebuilt] Failed to calculate type for fragment "${selection.key}": ${error instanceof Error ? error.message : String(error)}`);
-			}
-		} else if (selection.type === "operation") {
-			try {
-				const usedInputObjects = collectUsedInputObjects(schema, selection.variableDefinitions);
-				for (const inputName of usedInputObjects) {
-					group.inputObjects.add(inputName);
-				}
-				const outputType = (0, __soda_gql_core.calculateFieldsType)(schema, selection.fields, outputFormatters);
-				const inputType = (0, __soda_gql_core.generateInputType)(schema, selection.variableDefinitions, inputFormatters);
-				group.operations.push({
-					key: selection.operationName,
-					inputType,
-					outputType
-				});
-			} catch (error) {
-				warnings.push(`[prebuilt] Failed to calculate type for operation "${selection.operationName}": ${error instanceof Error ? error.message : String(error)}`);
-			}
-		}
-	}
-	return (0, neverthrow.ok)({
-		grouped,
-		warnings
-	});
-};
-/**
-* Calculate relative import path from one file to another.
-*/
-const toImportSpecifier = (from, to) => {
-	const fromDir = (0, node_path.dirname)(from);
-	let relativePath = (0, node_path.relative)(fromDir, to);
-	if (!relativePath.startsWith(".")) {
-		relativePath = `./${relativePath}`;
-	}
-	return relativePath.replace(/\.ts$/, "");
-};
-/**
-* Extract input object names from a GraphQL TypeNode.
-*/
-const extractInputObjectsFromType = (schema, typeNode, inputObjects) => {
-	switch (typeNode.kind) {
-		case graphql.Kind.NON_NULL_TYPE:
-			extractInputObjectsFromType(schema, typeNode.type, inputObjects);
-			break;
-		case graphql.Kind.LIST_TYPE:
-			extractInputObjectsFromType(schema, typeNode.type, inputObjects);
-			break;
-		case graphql.Kind.NAMED_TYPE: {
-			const name = typeNode.name.value;
-			if (!schema.scalar[name] && !schema.enum[name] && schema.input[name]) {
-				inputObjects.add(name);
-			}
-			break;
-		}
-	}
-};
-/**
-* Recursively collect nested input objects from schema definitions.
-* Takes a set of initial input names and expands to include all nested inputs.
-*/
-const collectNestedInputObjects = (schema, initialInputNames) => {
-	const inputObjects = new Set(initialInputNames);
-	const collectNested = (inputName, seen) => {
-		if (seen.has(inputName)) {
-			return;
-		}
-		seen.add(inputName);
-		const inputDef = schema.input[inputName];
-		if (!inputDef) {
-			return;
-		}
-		for (const field of Object.values(inputDef.fields)) {
-			if (field.kind === "input" && !inputObjects.has(field.name)) {
-				inputObjects.add(field.name);
-				collectNested(field.name, seen);
-			}
-		}
-	};
-	for (const inputName of Array.from(initialInputNames)) {
-		collectNested(inputName, new Set());
-	}
-	return inputObjects;
-};
-/**
-* Collect all input object types used in variable definitions.
-* Recursively collects nested input objects from the schema.
-*/
-const collectUsedInputObjects = (schema, variableDefinitions) => {
-	const directInputs = new Set();
-	for (const varDef of variableDefinitions) {
-		extractInputObjectsFromType(schema, varDef.type, directInputs);
-	}
-	return collectNestedInputObjects(schema, directInputs);
-};
-/**
-* Collect all input object types used in InputTypeSpecifiers.
-* Recursively collects nested input objects from the schema.
-*/
-const collectUsedInputObjectsFromSpecifiers = (schema, specifiers) => {
-	const directInputs = new Set();
-	for (const specifier of Object.values(specifiers)) {
-		if (specifier.kind === "input" && schema.input[specifier.name]) {
-			directInputs.add(specifier.name);
-		}
-	}
-	return collectNestedInputObjects(schema, directInputs);
-};
-/**
-* Generate type definitions for input objects.
-*/
-const generateInputObjectTypeDefinitions = (schema, schemaName, inputNames) => {
-	const lines = [];
-	const defaultDepth = schema.__defaultInputDepth ?? 3;
-	const depthOverrides = schema.__inputDepthOverrides ?? {};
-	const formatters = {
-		scalarInput: (name) => `ScalarInput_${schemaName}<"${name}">`,
-		inputObject: (name) => `Input_${schemaName}_${name}`
-	};
-	const sortedNames = Array.from(inputNames).sort();
-	for (const inputName of sortedNames) {
-		const typeString = (0, __soda_gql_core.generateInputObjectType)(schema, inputName, {
-			defaultDepth,
-			depthOverrides,
-			formatters
-		});
-		lines.push(`type Input_${schemaName}_${inputName} = ${typeString};`);
-	}
-	return lines;
-};
-/**
-* Generate the TypeScript code for prebuilt types.
-*/
-const generateTypesCode = (grouped, schemas, injects, outdir) => {
-	const typesFilePath = (0, node_path.join)(outdir, "prebuilt", "types.ts");
-	const lines = [
-		"/**",
-		" * Prebuilt type registry.",
-		" *",
-		" * This file is auto-generated by @soda-gql/builder.",
-		" * Do not edit manually.",
-		" *",
-		" * @module",
-		" * @generated",
-		" */",
-		"",
-		"import type { PrebuiltTypeRegistry } from \"@soda-gql/core\";"
-	];
-	for (const [schemaName, inject] of Object.entries(injects)) {
-		const relativePath = toImportSpecifier(typesFilePath, inject.scalars);
-		lines.push(`import type { scalar as scalar_${schemaName} } from "${relativePath}";`);
-	}
-	lines.push("");
-	for (const schemaName of Object.keys(injects)) {
-		lines.push(`type ScalarInput_${schemaName}<T extends keyof typeof scalar_${schemaName}> = ` + `typeof scalar_${schemaName}[T]["$type"]["input"];`);
-		lines.push(`type ScalarOutput_${schemaName}<T extends keyof typeof scalar_${schemaName}> = ` + `typeof scalar_${schemaName}[T]["$type"]["output"];`);
-	}
-	lines.push("");
-	for (const [schemaName, { fragments, operations, inputObjects }] of grouped) {
-		const schema = schemas[schemaName];
-		if (inputObjects.size > 0 && schema) {
-			lines.push("// Input object types");
-			const inputTypeLines = generateInputObjectTypeDefinitions(schema, schemaName, inputObjects);
-			lines.push(...inputTypeLines);
-			lines.push("");
-		}
-		const fragmentEntries = fragments.sort((a, b) => a.key.localeCompare(b.key)).map((f) => `    readonly "${f.key}": { readonly input: ${f.inputType}; readonly output: ${f.outputType} };`);
-		const operationEntries = operations.sort((a, b) => a.key.localeCompare(b.key)).map((o) => `    readonly "${o.key}": { readonly input: ${o.inputType}; readonly output: ${o.outputType} };`);
-		lines.push(`export type PrebuiltTypes_${schemaName} = {`);
-		lines.push("  readonly fragments: {");
-		if (fragmentEntries.length > 0) {
-			lines.push(...fragmentEntries);
-		}
-		lines.push("  };");
-		lines.push("  readonly operations: {");
-		if (operationEntries.length > 0) {
-			lines.push(...operationEntries);
-		}
-		lines.push("  };");
-		lines.push("} satisfies PrebuiltTypeRegistry;");
-		lines.push("");
-	}
-	return lines.join("\n");
-};
-/**
-* Emit prebuilt types to the prebuilt/types.ts file.
-*
-* This function uses a partial failure strategy: if type calculation fails for
-* individual elements (e.g., due to invalid field selections or missing schema
-* types), those elements are skipped and warnings are collected rather than
-* failing the entire emission. This allows builds to succeed even when some
-* elements have issues, while still reporting problems via warnings.
-*
-* @param options - Emitter options including schemas, field selections, and output directory
-* @returns Result containing output path and warnings, or error if a hard failure occurs
-*
-* @example
-* ```typescript
-* const result = await emitPrebuiltTypes({
-*   schemas: { mySchema: schema },
-*   fieldSelections,
-*   outdir: "./generated",
-*   injects: { mySchema: { scalars: "./scalars.ts" } },
-* });
-*
-* if (result.isOk()) {
-*   console.log(`Generated: ${result.value.path}`);
-*   if (result.value.warnings.length > 0) {
-*     console.warn("Warnings:", result.value.warnings);
-*   }
-* }
-* ```
-*/
-const emitPrebuiltTypes = async (options) => {
-	const { schemas, fieldSelections, outdir, injects } = options;
-	const groupResult = groupBySchema(fieldSelections, schemas);
-	if (groupResult.isErr()) {
-		return (0, neverthrow.err)(groupResult.error);
-	}
-	const { grouped, warnings } = groupResult.value;
-	const code = generateTypesCode(grouped, schemas, injects, outdir);
-	const typesPath = (0, node_path.join)(outdir, "prebuilt", "types.ts");
-	try {
-		await (0, node_fs_promises.writeFile)(typesPath, code, "utf-8");
-		return (0, neverthrow.ok)({
-			path: typesPath,
-			warnings
-		});
-	} catch (error) {
-		return (0, neverthrow.err)(builderErrors.writeFailed(typesPath, `Failed to write prebuilt types: ${error instanceof Error ? error.message : String(error)}`, error));
-	}
-};
-
 //#endregion
 //#region packages/builder/src/prebuilt/extractor.ts
 /**
@@ -1751,6 +1490,106 @@ const extractFieldSelections = (elements) => {
 	};
 };
 
+//#endregion
+//#region packages/builder/src/schema-loader.ts
+/**
+* Schema loader for CJS bundle evaluation.
+*
+* Loads AnyGraphqlSchema from the generated CJS bundle by accessing
+* the `$schema` property on each gql composer.
+*
+* @module
+*/
+/**
+* Load AnyGraphqlSchema from a generated CJS bundle.
+*
+* The generated CJS bundle exports a `gql` object where each property
+* is a GQL element composer with a `$schema` property containing the
+* schema definition. This function executes the bundle in a VM context
+* and extracts those schemas.
+*
+* @param cjsPath - Absolute path to the CJS bundle file
+* @param schemaNames - Names of schemas to load (e.g., ["default", "admin"])
+* @returns Record mapping schema names to AnyGraphqlSchema objects
+*
+* @example
+* ```typescript
+* const result = loadSchemasFromBundle(
+*   "/path/to/generated/index.cjs",
+*   ["default"]
+* );
+*
+* if (result.isOk()) {
+*   const schemas = result.value;
+*   console.log(schemas.default); // AnyGraphqlSchema
+* }
+* ```
+*/
+const loadSchemasFromBundle = (cjsPath, schemaNames) => {
+	const resolvedPath = (0, node_path.resolve)(cjsPath);
+	if (!(0, node_fs.existsSync)(resolvedPath)) {
+		return (0, neverthrow.err)({
+			code: "CONFIG_NOT_FOUND",
+			message: `CJS bundle not found: ${resolvedPath}. Run 'soda-gql codegen' first.`,
+			path: resolvedPath
+		});
+	}
+	let bundledCode;
+	try {
+		bundledCode = (0, node_fs.readFileSync)(resolvedPath, "utf-8");
+	} catch (error) {
+		return (0, neverthrow.err)({
+			code: "DISCOVERY_IO_ERROR",
+			message: `Failed to read CJS bundle: ${error instanceof Error ? error.message : String(error)}`,
+			path: resolvedPath,
+			cause: error
+		});
+	}
+	let finalExports;
+	try {
+		finalExports = executeSandbox(bundledCode, resolvedPath);
+	} catch (error) {
+		return (0, neverthrow.err)({
+			code: "RUNTIME_MODULE_LOAD_FAILED",
+			message: `Failed to execute CJS bundle: ${error instanceof Error ? error.message : String(error)}`,
+			filePath: resolvedPath,
+			astPath: "",
+			cause: error
+		});
+	}
+	const gql = finalExports.gql;
+	if (!gql || typeof gql !== "object") {
+		return (0, neverthrow.err)({
+			code: "CONFIG_INVALID",
+			message: "CJS bundle does not export 'gql' object. Ensure codegen was run successfully.",
+			path: resolvedPath
+		});
+	}
+	const schemas = {};
+	for (const name of schemaNames) {
+		const composer = gql[name];
+		if (!composer) {
+			const availableSchemas = Object.keys(gql).join(", ");
+			return (0, neverthrow.err)({
+				code: "SCHEMA_NOT_FOUND",
+				message: `Schema '${name}' not found in gql exports. Available: ${availableSchemas || "(none)"}`,
+				schemaLabel: name,
+				canonicalId: `gql.${name}`
+			});
+		}
+		const schema = composer.$schema;
+		if (!schema || typeof schema !== "object") {
+			return (0, neverthrow.err)({
+				code: "CONFIG_INVALID",
+				message: `gql.${name}.$schema is not a valid schema object. Ensure codegen version is up to date.`,
+				path: resolvedPath
+			});
+		}
+		schemas[name] = schema;
+	}
+	return (0, neverthrow.ok)(schemas);
+};
+
 //#endregion
 //#region packages/builder/src/artifact/aggregate.ts
 const canonicalToFilePath$1 = (canonicalId) => canonicalId.split("::")[0] ?? canonicalId;
@@ -3741,7 +3580,8 @@ const createBuilderSession = (options) => {
 		snapshots: new Map(),
 		moduleAdjacency: new Map(),
 		intermediateModules: new Map(),
-		lastArtifact: null
+		lastArtifact: null,
+		lastIntermediateElements: null
 	};
 	const cacheFactory = createMemoryCache({
 		prefix: ["builder"],
@@ -3830,6 +3670,7 @@ const createBuilderSession = (options) => {
 		state.moduleAdjacency = currentModuleAdjacency;
 		state.lastArtifact = artifactResult.value;
 		state.intermediateModules = intermediateModules;
+		state.lastIntermediateElements = elements;
 		ensureFileTracker().update(currentScan);
 		return (0, neverthrow.ok)(artifactResult.value);
 	};
@@ -3892,6 +3733,7 @@ const createBuilderSession = (options) => {
 		buildAsync,
 		getGeneration: () => state.gen,
 		getCurrentArtifact: () => state.lastArtifact,
+		getIntermediateElements: () => state.lastIntermediateElements,
 		dispose: () => {
 			cacheFactory.save();
 			unregisterExitHandler(cacheFactory);
@@ -4026,6 +3868,7 @@ const createBuilderService = ({ config, entrypointsOverride }) => {
 		buildAsync: (options) => session.buildAsync(options),
 		getGeneration: () => session.getGeneration(),
 		getCurrentArtifact: () => session.getCurrentArtifact(),
+		getIntermediateElements: () => session.getIntermediateElements(),
 		dispose: () => session.dispose()
 	};
 };
@@ -4036,15 +3879,16 @@ exports.BuilderEffects = BuilderEffects;
 exports.FileReadEffect = FileReadEffect;
 exports.FileStatEffect = FileStatEffect;
 exports.__clearGqlCache = __clearGqlCache;
+exports.builderErrors = builderErrors;
 exports.collectAffectedFiles = collectAffectedFiles;
 exports.createBuilderService = createBuilderService;
 exports.createBuilderSession = createBuilderSession;
 exports.createGraphqlSystemIdentifyHelper = createGraphqlSystemIdentifyHelper;
-exports.emitPrebuiltTypes = emitPrebuiltTypes;
 exports.extractFieldSelections = extractFieldSelections;
 exports.extractModuleAdjacency = extractModuleAdjacency;
 exports.formatBuilderErrorForCLI = formatBuilderErrorForCLI;
 exports.formatBuilderErrorStructured = formatBuilderErrorStructured;
 exports.loadArtifact = loadArtifact;
 exports.loadArtifactSync = loadArtifactSync;
+exports.loadSchemasFromBundle = loadSchemasFromBundle;
 //# sourceMappingURL=index.cjs.map