nitro-graphql 2.0.0-beta.70 → 2.0.0-beta.73

package/dist/nitro/routes/health.mjs

@@ -1,37 +1,34 @@
+import { createMergedSchema } from "../../core/schema/builder.mjs";
+import { execute, parse } from "graphql";
 import { defineEventHandler } from "nitro/h3";
-import { useRuntimeConfig } from "nitro/runtime-config";
-import { $fetch } from "ofetch";
-
+import { moduleConfig } from "#nitro-graphql/module-config";
+import { directives } from "#nitro-graphql/server-directives";
+import { resolvers } from "#nitro-graphql/server-resolvers";
+import { schemas } from "#nitro-graphql/server-schemas";
 //#region src/nitro/routes/health.ts
+let schema = null;
+async function getSchema() {
+	if (!schema) schema = await createMergedSchema({
+		schemas,
+		resolvers,
+		directives,
+		moduleConfig
+	});
+	return schema;
+}
+const HEALTH_QUERY = parse("query Health { __typename }");
 var health_default = defineEventHandler(async (event) => {
-	const runtime = useRuntimeConfig();
-	if (!runtime.graphql || !runtime.graphql.endpoint?.graphql) {
-		event.res.status = 404;
-		event.res.statusText = "Not Found";
-		return {
-			status: "error",
-			message: "GraphQL health check endpoint is not configured",
-			timestamp: (/* @__PURE__ */ new Date()).toISOString()
-		};
-	}
 	try {
-		const response = await $fetch(runtime.graphql.endpoint?.graphql, {
-			method: "POST",
-			body: {
-				query: "query Health { __typename }",
-				operationName: "Health"
-			},
-			headers: {
-				"Content-Type": "application/json",
-				"Accept": "application/json"
-			}
+		const result = await execute({
+			schema: await getSchema(),
+			document: HEALTH_QUERY
 		});
-		if (response && typeof response === "object" && "data" in response) return {
+		if (result.data) return {
 			status: "healthy",
 			message: "GraphQL server is running",
 			timestamp: (/* @__PURE__ */ new Date()).toISOString()
 		};
-		throw new Error("Invalid response from GraphQL server");
+		throw new Error(result.errors?.map((e) => e.message).join(", ") || "Invalid response from GraphQL server");
 	} catch (error) {
 		event.res.status = 503;
 		event.res.statusText = "Service Unavailable";
@@ -42,6 +39,5 @@ var health_default = defineEventHandler(async (event) => {
 		};
 	}
 });
-
 //#endregion
-export { health_default as default };
+export { health_default as default };

package/dist/nitro/setup/extend-loader.d.mts

@@ -1,3 +1,4 @@
+import { GraphQLScanState } from "../types/augmentation.mjs";
 import { Nitro } from "nitro/types";
 
 //#region src/nitro/setup/extend-loader.d.ts
@@ -5,12 +6,12 @@ import { Nitro } from "nitro/types";
  * Resolve extend directories for file watching
  */
 declare function resolveExtendDirs(nitro: Nitro): Promise<string[]>;
-interface ResolveExtendOptions {
-  silent?: boolean;
-}
 /**
- * Resolve extend configuration and add files to Nitro scan results
+ * Resolve extend configuration and merge into scan state.
+ * Returns a new frozen state — does NOT mutate nitro.
  */
-declare function resolveExtendConfig(nitro: Nitro, options?: ResolveExtendOptions): Promise<void>;
+declare function resolveExtendConfig(nitro: Nitro, state: GraphQLScanState, options?: {
+  silent?: boolean;
+}): Promise<GraphQLScanState>;
 //#endregion
 export { resolveExtendConfig, resolveExtendDirs };

package/dist/nitro/setup/extend-loader.mjs

@@ -1,8 +1,8 @@
 import { LOG_TAG } from "../../core/constants.mjs";
 import { generateDirectiveSchemas } from "../../core/utils/directive-parser.mjs";
 import { resolveExtendDirs as resolveExtendDirs$1, scanAllExtendSources } from "../../core/extend/loader.mjs";
+import { mergeScanState } from "../state.mjs";
 import consola from "consola";
-
 //#region src/nitro/setup/extend-loader.ts
 const logger = consola.withTag(LOG_TAG);
 /**
@@ -13,70 +13,40 @@ async function resolveExtendDirs(nitro) {
 	return resolveExtendDirs$1(extend, nitro.options.rootDir);
 }
 /**
-* Resolve extend configuration and add files to Nitro scan results
+* Resolve extend configuration and merge into scan state.
+* Returns a new frozen state — does NOT mutate nitro.
 */
-async function resolveExtendConfig(nitro, options = {}) {
+async function resolveExtendConfig(nitro, state, options = {}) {
 	const extend = nitro.options.graphql?.extend;
-	if (!extend || !Array.isArray(extend) || extend.length === 0) return;
-	const stats = applyExtendResult(nitro, await scanAllExtendSources(extend, nitro.options.rootDir));
-	if (stats.directives > 0) {
-		const directiveSchemas = await generateDirectiveSchemas(nitro.scanDirectives, nitro.graphql.buildDir);
-		nitro.graphql.directiveSchemas = directiveSchemas;
-	}
-	if (!options.silent && (stats.schemas > 0 || stats.resolvers > 0 || stats.directives > 0 || stats.documents > 0)) {
+	if (!extend || !Array.isArray(extend) || extend.length === 0) return state;
+	const result = await scanAllExtendSources(extend, nitro.options.rootDir);
+	let newState = mergeScanState(state, result);
+	if (result.directives.length > 0) {
+		const directiveSchemas = await generateDirectiveSchemas([...newState.directives], nitro.graphql.buildDir);
+		newState = Object.freeze({
+			...newState,
+			directiveSchemas
+		});
+	}
+	const added = {
+		schemas: newState.schemas.length - state.schemas.length,
+		resolvers: newState.resolvers.length - state.resolvers.length,
+		directives: newState.directives.length - state.directives.length,
+		documents: newState.documents.length - state.documents.length,
+		configs: newState.extendConfigs.length - state.extendConfigs.length,
+		programmaticSchemas: newState.extendSchemas.length - state.extendSchemas.length
+	};
+	if (!options.silent && Object.values(added).some((v) => v > 0)) {
 		const parts = [];
-		if (stats.schemas > 0) parts.push(`${stats.schemas} schema(s)`);
-		if (stats.resolvers > 0) parts.push(`${stats.resolvers} resolver(s)`);
-		if (stats.directives > 0) parts.push(`${stats.directives} directive(s)`);
-		if (stats.documents > 0) parts.push(`${stats.documents} document(s)`);
-		if (stats.configs > 0) parts.push(`${stats.configs} config(s)`);
-		if (stats.programmaticSchemas > 0) parts.push(`${stats.programmaticSchemas} programmatic schema(s)`);
+		if (added.schemas > 0) parts.push(`${added.schemas} schema(s)`);
+		if (added.resolvers > 0) parts.push(`${added.resolvers} resolver(s)`);
+		if (added.directives > 0) parts.push(`${added.directives} directive(s)`);
+		if (added.documents > 0) parts.push(`${added.documents} document(s)`);
+		if (added.configs > 0) parts.push(`${added.configs} config(s)`);
+		if (added.programmaticSchemas > 0) parts.push(`${added.programmaticSchemas} programmatic schema(s)`);
 		logger.info(`Extended with ${parts.join(", ")}`);
 	}
+	return newState;
 }
-/**
-* Apply extend scan result to Nitro state
-*/
-function applyExtendResult(nitro, result) {
-	let schemasAdded = 0;
-	let resolversAdded = 0;
-	let directivesAdded = 0;
-	let documentsAdded = 0;
-	let configsAdded = 0;
-	let programmaticSchemasAdded = 0;
-	for (const schemaPath of result.schemas) if (!nitro.scanSchemas.includes(schemaPath)) {
-		nitro.scanSchemas.push(schemaPath);
-		schemasAdded++;
-	}
-	for (const resolver of result.resolvers) if (!nitro.scanResolvers.some((r) => r.specifier === resolver.specifier)) {
-		nitro.scanResolvers.push(resolver);
-		resolversAdded++;
-	}
-	for (const directive of result.directives) if (!nitro.scanDirectives.some((d) => d.specifier === directive.specifier)) {
-		nitro.scanDirectives.push(directive);
-		directivesAdded++;
-	}
-	for (const docPath of result.documents) if (!nitro.scanDocuments.includes(docPath)) {
-		nitro.scanDocuments.push(docPath);
-		documentsAdded++;
-	}
-	if (result.configPath && !nitro.graphql.extendConfigs.includes(result.configPath)) {
-		nitro.graphql.extendConfigs.push(result.configPath);
-		configsAdded++;
-	}
-	if (result.schemaPath && !nitro.graphql.extendSchemas.includes(result.schemaPath)) {
-		nitro.graphql.extendSchemas.push(result.schemaPath);
-		programmaticSchemasAdded++;
-	}
-	return {
-		schemas: schemasAdded,
-		resolvers: resolversAdded,
-		directives: directivesAdded,
-		documents: documentsAdded,
-		configs: configsAdded,
-		programmaticSchemas: programmaticSchemasAdded
-	};
-}
-
 //#endregion
-export { resolveExtendConfig, resolveExtendDirs };
+export { resolveExtendConfig, resolveExtendDirs };

package/dist/nitro/setup/file-watcher.mjs

@@ -1,11 +1,13 @@
 import { LOG_TAG } from "../../core/constants.mjs";
-import { generateClientTypes, generateServerTypes } from "../codegen.mjs";
-import { createCoreWatcher } from "../../core/watcher/index.mjs";
+import { refreshVirtualModules } from "../virtual/index.mjs";
+import { createCoreWatcher } from "../../core/watcher/create-watcher.mjs";
+import { generateClientTypes } from "../codegen/client-types.mjs";
 import { performGraphQLScan, shouldScanLocalFiles } from "./scanner.mjs";
+import { regenerateTypes } from "./type-generation.mjs";
 import consola from "consola";
 import { join } from "pathe";
-
 //#region src/nitro/setup/file-watcher.ts
+const TRAILING_SLASH_RE = /\/$/;
 const logger = consola.withTag(LOG_TAG);
 /**
 * Setup file watcher for GraphQL files (schemas, resolvers, directives, documents)
@@ -24,8 +26,8 @@ function setupFileWatcher(nitro, watchDirs) {
 				silent: true,
 				isRescan: true
 			});
-			await generateServerTypes(nitro, { silent: true });
-			await generateClientTypes(nitro, { silent: true });
+			refreshVirtualModules(nitro);
+			await regenerateTypes(nitro, { silent: true });
 			logger.success("Types regenerated");
 			await nitro.hooks.callHook("dev:reload");
 		},
@@ -51,13 +53,12 @@ function getWatchDirectories(nitro, extendDirs = []) {
 	if (nitro.options.graphql?.externalServices?.length) {
 		for (const service of nitro.options.graphql.externalServices) if (service.documents?.length) for (const pattern of service.documents) {
 			if (!pattern) continue;
-			const baseDir = pattern.split("**")[0]?.replace(/\/$/, "") || ".";
+			const baseDir = pattern.split("**")[0]?.replace(TRAILING_SLASH_RE, "") || ".";
 			const resolvedDir = join(nitro.options.rootDir, baseDir);
 			if (!watchDirs.includes(resolvedDir)) watchDirs.push(resolvedDir);
 		}
 	}
 	return watchDirs;
 }
-
 //#endregion
-export { getWatchDirectories, setupFileWatcher };
+export { getWatchDirectories, setupFileWatcher };

package/dist/nitro/setup/logging.d.mts

@@ -1,16 +1,9 @@
-import { SecurityConfig } from "../types.mjs";
 import { Nitro } from "nitro/types";
 
 //#region src/nitro/setup/logging.d.ts
-/**
- * Resolves security configuration with environment-aware defaults
- * In production: introspection off, playground off, errors masked, suggestions disabled
- * In development: introspection on, playground on, errors shown, suggestions enabled
- */
-declare function resolveSecurityConfig(config?: SecurityConfig): Required<SecurityConfig>;
 /**
  * Log startup information
  */
 declare function logStartupInfo(nitro: Nitro, serverEnabled: boolean): void;
 //#endregion
-export { logStartupInfo, resolveSecurityConfig };
+export { logStartupInfo };

package/dist/nitro/setup/logging.mjs

@@ -1,41 +1,25 @@
+import { resolveSecurityConfig } from "./security.mjs";
 import consola from "consola";
-
 //#region src/nitro/setup/logging.ts
 /**
-* Resolves security configuration with environment-aware defaults
-* In production: introspection off, playground off, errors masked, suggestions disabled
-* In development: introspection on, playground on, errors shown, suggestions enabled
-*/
-function resolveSecurityConfig(config) {
-	const isProd = process.env.NODE_ENV === "production";
-	return {
-		introspection: config?.introspection ?? !isProd,
-		playground: config?.playground ?? !isProd,
-		maskErrors: config?.maskErrors ?? isProd,
-		disableSuggestions: config?.disableSuggestions ?? isProd
-	};
-}
-/**
 * Log startup information
 */
 function logStartupInfo(nitro, serverEnabled) {
+	const { state } = nitro.graphql;
 	const externalServicesCount = nitro.options.graphql?.externalServices?.length || 0;
-	const docs = nitro.scanDocuments || [];
 	const isProd = process.env.NODE_ENV === "production";
 	if (serverEnabled) {
 		const securityConfig = resolveSecurityConfig(nitro.options.graphql?.security);
 		const framework = nitro.options.graphql?.framework || "unknown";
-		const schemas = nitro.scanSchemas?.length || 0;
-		const resolvers = nitro.scanResolvers?.length || 0;
 		consola.box({
 			title: "Nitro GraphQL",
 			message: [
 				`Framework: ${framework}`,
 				`Environment: ${isProd ? "production" : "development"}`,
-				`Schemas: ${schemas}`,
-				`Resolvers: ${resolvers}`,
+				`Schemas: ${state.schemas.length}`,
+				`Resolvers: ${state.resolvers.length}`,
 				externalServicesCount > 0 ? `External Services: ${externalServicesCount}` : "",
-				docs.length > 0 ? `Documents: ${docs.length}` : "",
+				state.documents.length > 0 ? `Documents: ${state.documents.length}` : "",
 				"",
 				"Security:",
 				`├─ Introspection: ${securityConfig.introspection ? "enabled" : "disabled"}`,
@@ -53,7 +37,7 @@ function logStartupInfo(nitro, serverEnabled) {
 		message: [
 			"Server mode: disabled",
 			`External Services: ${externalServicesCount}`,
-			`Documents: ${docs.length}`
+			`Documents: ${state.documents.length}`
 		].join("\n"),
 		style: {
 			borderColor: "blue",
@@ -61,6 +45,5 @@ function logStartupInfo(nitro, serverEnabled) {
 		}
 	});
 }
-
 //#endregion
-export { logStartupInfo, resolveSecurityConfig };
+export { logStartupInfo };

package/dist/nitro/setup/rollup-integration.mjs

@@ -1,11 +1,14 @@
+import { CHUNK_NAME_RESOLVERS, CHUNK_NAME_SCHEMAS, CHUNK_PATH_UNKNOWN, GRAPHQL_EXTENSIONS, RESOLVER_EXTENSIONS } from "../../core/constants.mjs";
 //#region src/nitro/setup/rollup-integration.ts
+const NITRO_GRAPHQL_ROUTES_RE = /nitro-graphql[/\\]dist[/\\]nitro[/\\]routes/;
+const NITRO_GRAPHQL_SCHEMA_RE = /nitro-graphql[/\\]dist[/\\]core[/\\]schema/;
 /**
 * Configure noExternals to ensure nitro-graphql route handlers are bundled
 * This is critical for Nuxt integration where node_modules are externalized by default.
 * Without this, the #nitro-graphql/* virtual imports in handlers would fail at runtime.
 */
 function setupNoExternals(nitro) {
-	const routePatterns = [/nitro-graphql[/\\]dist[/\\]nitro[/\\]routes/, /nitro-graphql[/\\]dist[/\\]core[/\\]schema/];
+	const routePatterns = [NITRO_GRAPHQL_ROUTES_RE, NITRO_GRAPHQL_SCHEMA_RE];
 	if (nitro.options.noExternals === true) return;
 	if (!Array.isArray(nitro.options.noExternals)) nitro.options.noExternals = [];
 	nitro.options.noExternals.push(...routePatterns);
@@ -18,7 +21,37 @@ function setupNoExternals(nitro) {
 * interfering with Nitro's node_modules chunking which uses advancedChunks.
 */
 function setupRollupChunking(nitro) {
-	nitro.hooks.hook("rollup:before", (_, rollupConfig) => {});
+	nitro.hooks.hook("rollup:before", (_, rollupConfig) => {
+		if (rollupConfig.output.inlineDynamicImports) return;
+		const output = rollupConfig.output;
+		if (output.advancedChunks || "codeSplitting" in output) return;
+		const existingManualChunks = rollupConfig.output?.manualChunks;
+		rollupConfig.output.manualChunks = (id, meta) => {
+			if (isGraphQLFile(id)) return `graphql/${CHUNK_NAME_SCHEMAS}`;
+			if (isResolverFile(id)) return `graphql/${CHUNK_NAME_RESOLVERS}`;
+			if (typeof existingManualChunks === "function") return existingManualChunks(id, meta);
+		};
+		const existingChunkFileNames = rollupConfig.output.chunkFileNames;
+		rollupConfig.output.chunkFileNames = (chunkInfo) => {
+			const name = chunkInfo.name || "";
+			if (name.startsWith("graphql/")) return `chunks/${name}.mjs`;
+			if (typeof existingChunkFileNames === "function") return existingChunkFileNames(chunkInfo);
+			if (typeof existingChunkFileNames === "string") return existingChunkFileNames;
+			return CHUNK_PATH_UNKNOWN;
+		};
+	});
+}
+/**
+* Check if a file is a GraphQL schema file
+*/
+function isGraphQLFile(id) {
+	return GRAPHQL_EXTENSIONS.some((ext) => id.endsWith(ext));
+}
+/**
+* Check if a file is a resolver file
+*/
+function isResolverFile(id) {
+	return RESOLVER_EXTENSIONS.some((ext) => id.endsWith(ext));
 }
 /**
 * Configure external dependencies for Rollup
@@ -58,6 +91,5 @@ function setupRollupExternals(nitro) {
 		}
 	});
 }
-
 //#endregion
-export { setupNoExternals, setupRollupChunking, setupRollupExternals };
+export { setupNoExternals, setupRollupChunking, setupRollupExternals };

package/dist/nitro/setup/routes.mjs

@@ -1,6 +1,5 @@
 import { ENDPOINT_DEBUG, GRAPHQL_HTTP_METHODS } from "../../core/constants.mjs";
 import { fileURLToPath } from "node:url";
-
 //#region src/nitro/setup/routes.ts
 /**
 * Resolve a module specifier to an absolute filesystem path.
@@ -66,6 +65,5 @@ function registerRouteHandlers(nitro) {
 		method: "GET"
 	});
 }
-
 //#endregion
-export { registerRouteHandlers };
+export { registerRouteHandlers };

package/dist/nitro/setup/scanner.d.mts

@@ -1,59 +1,24 @@
-import { ExtendSource } from "../types.mjs";
+import { ExtendSource } from "../types/config.mjs";
 import { Nitro } from "nitro/types";
 
 //#region src/nitro/setup/scanner.d.ts
 interface ScanOptions {
-  /** Silent mode - suppress logging */
   silent?: boolean;
-  /** Is this a rescan (dev mode hot reload) */
   isRescan?: boolean;
 }
-interface ScanResult {
-  schemas: number;
-  resolvers: number;
-  directives: number;
-  documents: number;
-}
-/**
- * Check if local file scanning should be performed
- * Centralized helper to avoid scattered skipLocalScan checks
- */
 declare function shouldScanLocalFiles(nitro: Nitro): boolean;
-/**
- * Check if server-side GraphQL is enabled
- */
 declare function isServerEnabled(nitro: Nitro): boolean;
-/**
- * Get extend sources from config
- */
 declare function getExtendSources(nitro: Nitro): ExtendSource[] | undefined;
 /**
- * Scan local GraphQL files (schemas, resolvers, directives, documents)
- * This is the low-level scan function - use performGraphQLScan for full workflow
- */
-declare function scanLocalFiles(nitro: Nitro): Promise<ScanResult>;
-/**
- * Scan only client documents (for external services or client-only mode)
- */
-declare function scanDocumentsOnly(nitro: Nitro): Promise<number>;
-/**
- * Initialize empty scan results (for skipLocalScan mode)
- */
-declare function initializeEmptyScanResults(nitro: Nitro): void;
-/**
- * Perform complete GraphQL scan workflow
- * This is the main entry point for both initial setup and dev mode rescan
+ * Perform complete GraphQL scan workflow.
+ * Builds an immutable state snapshot and assigns it to nitro.graphql.state atomically.
  *
- * Workflow:
- * 1. Check skipLocalScan flag
- * 2. Scan local files if enabled
- * 3. Resolve extend config (append to results)
- * 4. Log diagnostics if needed
+ * Flow:
+ * 1. Scan local files (or skip if skipLocalScan)
+ * 2. Merge extend sources into state
+ * 3. Assign frozen state to nitro.graphql.state (single atomic write)
  */
 declare function performGraphQLScan(nitro: Nitro, options?: ScanOptions): Promise<void>;
-/**
- * Log resolver diagnostics for development
- */
 declare function logResolverDiagnostics(nitro: Nitro): void;
 //#endregion
-export { ScanOptions, ScanResult, getExtendSources, initializeEmptyScanResults, isServerEnabled, logResolverDiagnostics, performGraphQLScan, scanDocumentsOnly, scanLocalFiles, shouldScanLocalFiles };
+export { ScanOptions, getExtendSources, isServerEnabled, logResolverDiagnostics, performGraphQLScan, shouldScanLocalFiles };

package/dist/nitro/setup/scanner.mjs

@@ -1,99 +1,96 @@
 import { LOG_TAG } from "../../core/constants.mjs";
+import { scanDirectivesCore } from "../../core/scanning/directives.mjs";
+import { scanDocumentsCore } from "../../core/scanning/documents.mjs";
+import { scanResolversCore } from "../../core/scanning/resolvers.mjs";
+import { scanSchemasCore } from "../../core/scanning/schemas.mjs";
 import { generateDirectiveSchemas } from "../../core/utils/directive-parser.mjs";
-import { NitroAdapter } from "../adapter.mjs";
+import { createScanContextFromNitro } from "../adapter.mjs";
+import { createScanState } from "../state.mjs";
 import { resolveExtendConfig } from "./extend-loader.mjs";
 import consola from "consola";
-
+import { relative } from "pathe";
 //#region src/nitro/setup/scanner.ts
 const logger = consola.withTag(LOG_TAG);
-/**
-* Check if local file scanning should be performed
-* Centralized helper to avoid scattered skipLocalScan checks
-*/
 function shouldScanLocalFiles(nitro) {
 	return nitro.options.graphql?.skipLocalScan !== true;
 }
-/**
-* Check if server-side GraphQL is enabled
-*/
 function isServerEnabled(nitro) {
 	return nitro.options.graphql?.server !== false;
 }
-/**
-* Get extend sources from config
-*/
 function getExtendSources(nitro) {
 	const extend = nitro.options.graphql?.extend;
 	return Array.isArray(extend) ? extend : void 0;
 }
 /**
-* Scan local GraphQL files (schemas, resolvers, directives, documents)
-* This is the low-level scan function - use performGraphQLScan for full workflow
+* Scan local GraphQL files and return an immutable state snapshot.
+* Does NOT mutate nitro — caller is responsible for assigning the state.
 */
 async function scanLocalFiles(nitro) {
-	const directivesResult = await NitroAdapter.scanDirectives(nitro);
-	nitro.scanDirectives = directivesResult.items;
+	const ctx = createScanContextFromNitro(nitro);
+	const directivesResult = await scanDirectivesCore(ctx);
 	const directiveSchemas = await generateDirectiveSchemas(directivesResult.items, nitro.graphql.buildDir);
-	nitro.graphql.directiveSchemas = directiveSchemas;
-	const schemasResult = await NitroAdapter.scanSchemas(nitro);
-	nitro.scanSchemas = schemasResult.items;
-	const docsResult = await NitroAdapter.scanDocuments(nitro);
-	nitro.scanDocuments = docsResult.items;
-	const resolversResult = await NitroAdapter.scanResolvers(nitro);
-	nitro.scanResolvers = resolversResult.items;
-	return {
-		schemas: schemasResult.items.length,
-		resolvers: resolversResult.items.length,
-		directives: directivesResult.items.length,
-		documents: docsResult.items.length
-	};
+	const schemasResult = await scanSchemasCore(ctx);
+	const [docsResult, resolversResult] = await Promise.all([scanDocumentsCore(ctx, {
+		externalServices: nitro.options.graphql?.externalServices,
+		clientDirRelative: relative(nitro.options.rootDir, nitro.graphql.clientDir)
+	}), scanResolversCore(ctx)]);
+	return createScanState({
+		schemas: schemasResult.items,
+		resolvers: resolversResult.items,
+		directives: directivesResult.items,
+		documents: docsResult.items,
+		directiveSchemas
+	});
 }
 /**
-* Scan only client documents (for external services or client-only mode)
+* Scan only client documents, preserving existing state for other fields
 */
 async function scanDocumentsOnly(nitro) {
-	const result = await NitroAdapter.scanDocuments(nitro);
-	nitro.scanDocuments = result.items;
-	return result.items.length;
+	return createScanState({
+		schemas: [],
+		resolvers: [],
+		directives: [],
+		documents: (await scanDocumentsCore(createScanContextFromNitro(nitro), {
+			externalServices: nitro.options.graphql?.externalServices,
+			clientDirRelative: relative(nitro.options.rootDir, nitro.graphql.clientDir)
+		})).items,
+		directiveSchemas: null
+	});
 }
 /**
-* Initialize empty scan results (for skipLocalScan mode)
-*/
-function initializeEmptyScanResults(nitro) {
-	nitro.scanSchemas = [];
-	nitro.scanResolvers = [];
-	nitro.scanDirectives = [];
-}
-/**
-* Perform complete GraphQL scan workflow
-* This is the main entry point for both initial setup and dev mode rescan
+* Perform complete GraphQL scan workflow.
+* Builds an immutable state snapshot and assigns it to nitro.graphql.state atomically.
 *
-* Workflow:
-* 1. Check skipLocalScan flag
-* 2. Scan local files if enabled
-* 3. Resolve extend config (append to results)
-* 4. Log diagnostics if needed
+* Flow:
+* 1. Scan local files (or skip if skipLocalScan)
+* 2. Merge extend sources into state
+* 3. Assign frozen state to nitro.graphql.state (single atomic write)
 */
 async function performGraphQLScan(nitro, options = {}) {
 	const { silent = false, isRescan = false } = options;
 	const serverEnabled = isServerEnabled(nitro);
 	const scanLocal = shouldScanLocalFiles(nitro);
 	const extendSources = getExtendSources(nitro);
-	if (isRescan && !scanLocal && extendSources?.length) return;
+	if (isRescan && extendSources?.length) return;
+	let state;
 	if (!scanLocal) {
 		if (!isRescan && !silent) if (extendSources?.length) logger.info(`Using ${extendSources.length} extend source(s), skipping local scanning`);
 		else logger.info("Skipping local scanning (skipLocalScan: true)");
-		initializeEmptyScanResults(nitro);
-		await scanDocumentsOnly(nitro);
-	} else if (serverEnabled) await scanLocalFiles(nitro);
-	else await scanDocumentsOnly(nitro);
-	await resolveExtendConfig(nitro, { silent: silent || isRescan });
+		state = await scanDocumentsOnly(nitro);
+	} else if (serverEnabled) state = await scanLocalFiles(nitro);
+	else state = await scanDocumentsOnly(nitro);
+	state = await resolveExtendConfig(nitro, state, { silent: silent || isRescan });
+	nitro.graphql.state = state;
+	nitro.scanSchemas = [...state.schemas];
+	nitro.scanResolvers = [...state.resolvers];
+	nitro.scanDirectives = [...state.directives];
+	nitro.scanDocuments = [...state.documents];
+	nitro.graphql.directiveSchemas = state.directiveSchemas;
+	nitro.graphql.extendConfigs = [...state.extendConfigs];
+	nitro.graphql.extendSchemas = [...state.extendSchemas];
 }
-/**
-* Log resolver diagnostics for development
-*/
 function logResolverDiagnostics(nitro) {
-	const resolvers = nitro.scanResolvers || [];
+	const resolvers = nitro.graphql.state.resolvers;
 	if (resolvers.length > 0) {
 		const totalExports = resolvers.reduce((sum, r) => sum + r.imports.length, 0);
 		const typeCount = {
@@ -115,6 +112,5 @@ function logResolverDiagnostics(nitro) {
 		if (breakdown.length > 0) logger.success(`${totalExports} resolver export(s): ${breakdown.join(", ")}`);
 	} else logger.warn("No resolvers found. Check /_nitro/graphql/debug for details.");
 }
-
 //#endregion
-export { getExtendSources, initializeEmptyScanResults, isServerEnabled, logResolverDiagnostics, performGraphQLScan, scanDocumentsOnly, scanLocalFiles, shouldScanLocalFiles };
+export { getExtendSources, isServerEnabled, logResolverDiagnostics, performGraphQLScan, shouldScanLocalFiles };

package/dist/nitro/setup/security.d.mts

@@ -0,0 +1,10 @@
+import { CoreSecurityConfig } from "../../core/types/config.mjs";
+//#region src/nitro/setup/security.d.ts
+/**
+ * Resolves security configuration with environment-aware defaults
+ * In production: introspection off, playground off, errors masked, suggestions disabled
+ * In development: introspection on, playground on, errors shown, suggestions enabled
+ */
+declare function resolveSecurityConfig(config?: CoreSecurityConfig): Required<CoreSecurityConfig>;
+//#endregion
+export { resolveSecurityConfig };