@astroscope/node 1.0.0

package/dist/index.js

@@ -0,0 +1,732 @@
+import { n as setBootContext } from "./context-Bkg-FnnQ.js";
+import { a as runShutdown, i as createRequestInstrumentation, o as runStartup, t as preparePlatform } from "./prepare-Be2GgRyf.js";
+import { n as dispatchNativeMount, t as clearNativeMounts } from "./native-mount-hhwWdLtL.js";
+import { n as getCurrentGeneration, r as incrementGeneration, t as GEN_HEADER } from "./generation-Bp2IA0jf.js";
+import { i as STATIC_EXCLUDES, r as RECOMMENDED_EXCLUDES } from "./excludes-pE23EbmQ.js";
+import fs, { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Parser } from "acorn";
+import MagicString from "magic-string";
+//#region src/dev-mode/serialize-error.ts
+function serializeError(error) {
+	if (error instanceof Error) return error.stack ?? error.message;
+	return JSON.stringify(error);
+}
+//#endregion
+//#region src/dev-mode/scheduler.ts
+const FULL_RELOAD_UNKNOWN = "<unknown>";
+/**
+* Coordinates dev-server restarts: debounces bursts, chains a follow-up if
+* changes arrive mid-restart (vite's `ssrImport` reads disk at import time,
+* so changes during a restart would otherwise be missed), and logs once per
+* restart with what triggered it.
+*
+* One instance per integration, shared across restart-induced configureServer
+* reruns — chain coordination would be lost if recreated each time.
+*/
+var RestartScheduler = class {
+	debounceMs;
+	logger;
+	_inFlight = false;
+	_pending = false;
+	_debounceTimer;
+	_pendingBootDeps = /* @__PURE__ */ new Set();
+	_pendingFullReloads = /* @__PURE__ */ new Set();
+	_runPromise;
+	_lastFailure;
+	constructor(debounceMs, logger) {
+		this.debounceMs = debounceMs;
+		this.logger = logger;
+	}
+	isRestartPending() {
+		return !!this._runPromise || !!this._debounceTimer || !!this._lastFailure;
+	}
+	getLastFailure() {
+		return this._lastFailure;
+	}
+	recordFailure(message) {
+		this._lastFailure = { message };
+	}
+	clearFailure() {
+		this._lastFailure = void 0;
+	}
+	schedule(server, changedPath) {
+		this._pendingBootDeps.add(changedPath);
+		this._scheduleRun(server);
+	}
+	scheduleFullReload(server, triggeredBy) {
+		this._pendingFullReloads.add(triggeredBy ?? FULL_RELOAD_UNKNOWN);
+		this._scheduleRun(server);
+	}
+	/**
+	* Resolves when no restart is running. Loops to handle back-to-back restarts
+	* (e.g. one chain ends and a queued debounce timer immediately fires a new
+	* one). Never rejects, so a failed restart still releases the gate — caller
+	* proceeds against the broken state rather than hanging forever.
+	*/
+	async waitForRestart() {
+		while (this._runPromise) try {
+			await this._runPromise;
+		} catch {}
+	}
+	_scheduleRun(server) {
+		clearTimeout(this._debounceTimer);
+		this._debounceTimer = setTimeout(() => {
+			this._debounceTimer = void 0;
+			this._run(server);
+		}, this.debounceMs);
+	}
+	async _run(server) {
+		if (this._inFlight) {
+			this._pending = true;
+			return;
+		}
+		this._inFlight = true;
+		let resolveRun;
+		this._runPromise = new Promise((resolve) => {
+			resolveRun = resolve;
+		});
+		try {
+			do {
+				this._pending = false;
+				const bootDeps = [...this._pendingBootDeps].sort();
+				const fullReloads = [...this._pendingFullReloads].sort();
+				this._pendingBootDeps.clear();
+				this._pendingFullReloads.clear();
+				if (bootDeps.length > 0 || fullReloads.length > 0) this.logger.info(this._formatReason(server, bootDeps, fullReloads));
+				try {
+					await server.restart();
+				} catch (error) {
+					this.logger.error(`error during dev server restart: ${serializeError(error)}`);
+				}
+			} while (this._pending);
+		} finally {
+			this._inFlight = false;
+			this._runPromise = void 0;
+			resolveRun();
+		}
+	}
+	_formatReason(server, bootDeps, fullReloads) {
+		const root = server.config.root;
+		const rel = (p) => path.relative(root, p) || p;
+		const parts = [];
+		if (bootDeps.length === 1) parts.push(`boot dep changed: ${rel(bootDeps[0])}`);
+		else if (bootDeps.length > 1) parts.push(`boot deps changed (${bootDeps.length}): ${bootDeps.map(rel).join(", ")}`);
+		if (fullReloads.length > 0) {
+			const named = fullReloads.filter((p) => p !== FULL_RELOAD_UNKNOWN);
+			if (named.length === 0) parts.push("vite SSR full-reload");
+			else parts.push(`vite SSR full-reload (triggered by ${named.map(rel).join(", ")})`);
+		}
+		return `${parts.join(" + ")} — restarting dev server`;
+	}
+};
+//#endregion
+//#region src/dev-mode/vite-env.ts
+/**
+* duck-typed runnable-env check. avoids `isRunnableDevEnvironment` which relies on
+* `instanceof RunnableDevEnvironment` — that breaks when the consumer and vite host
+* resolve to different vite installs (e.g. linked packages outside the workspace).
+*/
+function isRunnable(env) {
+	return !!env && typeof env.runner === "object" && typeof env.runner.import === "function";
+}
+/**
+* resolve a runnable dev environment — prefers `ssr`, falls back to `astro`.
+* astro 6 exposes a separate `astro` environment when `ssr` isn't runnable
+* (see astro/core/constants.ts ASTRO_VITE_ENVIRONMENT_NAMES).
+*/
+function getRunnableEnv(server) {
+	const ssr = server.environments["ssr"];
+	if (isRunnable(ssr)) return ssr;
+	const astro = server.environments["astro"];
+	if (isRunnable(astro)) return astro;
+	const names = Object.keys(server.environments);
+	throw new Error(`no runnable dev environment found — available: ${names.join(", ")}`);
+}
+/**
+* load a module via the Vite Environment API.
+*/
+async function ssrImport(server, moduleId) {
+	return getRunnableEnv(server).runner.import(moduleId);
+}
+/**
+* return the env whose `hot` channel should receive astro-targeted events.
+* astro listens on the env that backs its middleware runner.
+*/
+function getAstroHotEnv(server) {
+	const ssr = server.environments["ssr"];
+	if (isRunnable(ssr)) return ssr;
+	const astro = server.environments["astro"];
+	if (isRunnable(astro)) return astro;
+}
+//#endregion
+//#region src/dev-mode/ignored.ts
+const ignoredSuffixes = [
+	".d.ts",
+	".d.mts",
+	".d.cts",
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".svg",
+	".webp",
+	".avif",
+	".ico",
+	".woff",
+	".woff2",
+	".ttf",
+	".otf",
+	".eot",
+	".pdf",
+	".mp3",
+	".mp4",
+	".webm",
+	".ogg",
+	".wav",
+	".json",
+	".yaml",
+	".yml",
+	".toml",
+	".md",
+	".mdx",
+	".txt",
+	".css",
+	".scss",
+	".sass",
+	".less"
+];
+//#endregion
+//#region src/dev-mode/watch.ts
+const RESTART_HTML = readFileSync(fileURLToPath(new URL("./restart-page.html", import.meta.url)), "utf8");
+function setupBootWatch(server, entries, scheduler) {
+	const entryFilePaths = entries.map((entry) => path.resolve(server.config.root, entry));
+	const runnableEnv = getAstroHotEnv(server);
+	const bootModuleGraph = runnableEnv?.moduleGraph;
+	const collectBootDependencies = () => {
+		const deps = /* @__PURE__ */ new Set();
+		const seen = /* @__PURE__ */ new Set();
+		for (const entryFilePath of entryFilePaths) {
+			const entryModules = bootModuleGraph?.getModulesByFile(entryFilePath);
+			const entryModule = entryModules ? [...entryModules][0] : void 0;
+			if (!entryModule) continue;
+			const visit = (mod) => {
+				if (!mod?.file || seen.has(mod.file)) return;
+				seen.add(mod.file);
+				deps.add(mod.file);
+				for (const imp of mod.importedModules) visit(imp);
+			};
+			visit(entryModule);
+		}
+		return deps;
+	};
+	const shouldIgnore = (filePath) => {
+		const p = filePath.toLowerCase();
+		return ignoredSuffixes.some((suffix) => p.endsWith(suffix));
+	};
+	const onWatcherEvent = (changedPath) => {
+		if (shouldIgnore(changedPath)) return;
+		if (!collectBootDependencies().has(changedPath)) return;
+		scheduler.schedule(server, changedPath);
+	};
+	server.watcher.on("change", onWatcherEvent);
+	server.watcher.on("add", onWatcherEvent);
+	server.watcher.on("unlink", onWatcherEvent);
+	let handleFullReloads = false;
+	if (server.httpServer) server.httpServer.once("listening", () => {
+		handleFullReloads = true;
+	});
+	else handleFullReloads = true;
+	const outsideEmitter = (runnableEnv?.hot)?.api?.outsideEmitter;
+	if (outsideEmitter) outsideEmitter.on("send", (payload) => {
+		if (!handleFullReloads) return;
+		if (payload.type !== "full-reload") return;
+		const triggeredBy = "triggeredBy" in payload ? payload.triggeredBy : void 0;
+		scheduler.scheduleFullReload(server, triggeredBy);
+	});
+}
+const READINESS_PATH = "/__astroscope_boot_ready";
+/**
+* Gate requests: show 503 holding page during restart, readiness probe for the reload.
+*/
+function installBootGate(server, scheduler) {
+	server.middlewares.stack.unshift({
+		route: "",
+		handle: (async (req, res, next) => {
+			if (req.url === READINESS_PATH) {
+				await scheduler.waitForRestart();
+				if (res.headersSent) return;
+				const failure = scheduler.getLastFailure();
+				if (failure) {
+					res.writeHead(503, {
+						"cache-control": "no-store",
+						"content-type": "application/json"
+					});
+					res.end(JSON.stringify({ error: failure.message }));
+					return;
+				}
+				res.writeHead(204, { "cache-control": "no-store" });
+				res.end();
+				return;
+			}
+			if (isDevInternalPath(req.url)) {
+				next();
+				return;
+			}
+			if (scheduler.isRestartPending()) {
+				res.writeHead(503, {
+					"content-type": "text/html; charset=utf-8",
+					"cache-control": "no-store",
+					"retry-after": "1"
+				});
+				res.end(RESTART_HTML);
+				return;
+			}
+			next();
+		})
+	});
+}
+function isDevInternalPath(url) {
+	if (!url) return false;
+	return url.startsWith("/@") || url.startsWith("/__") || url.includes("/node_modules/");
+}
+/**
+* Stamp the current generation onto every incoming request so the runtime
+* Astro middleware can later detect whether the request belongs to a previous
+* (now torn-down) generation
+*/
+function installGenStamp(server) {
+	server.middlewares.stack.unshift({
+		route: "",
+		handle: ((req, _res, next) => {
+			req.headers[GEN_HEADER] = String(getCurrentGeneration());
+			next();
+		})
+	});
+}
+//#endregion
+//#region src/dev-mode/machinery.ts
+/**
+* Resolve the default host and port from the Astro server config.
+* Falls back to `localhost:4321` when no config is provided.
+*/
+function getServerDefaults(config) {
+	return {
+		host: typeof config?.server?.host === "string" ? config.server.host : config?.server?.host === true ? "0.0.0.0" : "localhost",
+		port: config?.server?.port ?? 4321
+	};
+}
+/**
+* Build a dev-mode boot context from the running server's address,
+* falling back to Astro config defaults if the server isn't listening yet.
+*/
+function resolveBootContext(server, config) {
+	const addr = server.httpServer?.address();
+	if (addr && typeof addr === "object" && "address" in addr && "port" in addr) return {
+		dev: true,
+		host: addr.address === "::" || addr.address === "0.0.0.0" ? "localhost" : addr.address,
+		port: addr.port
+	};
+	const { host, port } = getServerDefaults(config);
+	return {
+		dev: true,
+		host,
+		port
+	};
+}
+/**
+* The dev-mode boot machinery: runs the platform seams and the boot lifecycle
+* per restart generation, restarts the dev server when watched dependencies
+* change, and gates requests behind a holding page during restarts.
+*/
+function createDevMachinery(options) {
+	const { entry, logger } = options;
+	let hasStartupSucceededOnce = false;
+	let priorShutdown;
+	const scheduler = options.watch ? new RestartScheduler(100, logger) : void 0;
+	return [{
+		name: "@astroscope/node/dev-gate",
+		enforce: "post",
+		configureServer(server) {
+			if (!scheduler) return;
+			return () => {
+				installBootGate(server, scheduler);
+				installGenStamp(server);
+			};
+		}
+	}, {
+		name: "@astroscope/node/dev-startup",
+		enforce: "post",
+		async configureServer(server) {
+			incrementGeneration();
+			if (priorShutdown) {
+				await priorShutdown();
+				priorShutdown = void 0;
+			}
+			const bootContext = resolveBootContext(server, options.getConfig());
+			let bootModule;
+			setBootContext(bootContext);
+			try {
+				await options.prepare((id) => ssrImport(server, id));
+				bootModule = entry ? await ssrImport(server, `/${entry}`) : {};
+				await runStartup(bootModule, bootContext);
+			} catch (error) {
+				logger.error(`Error running startup script: ${serializeError(error)}`);
+				if (bootModule) try {
+					await runShutdown(bootModule, bootContext);
+				} catch {}
+				if (hasStartupSucceededOnce) {
+					scheduler?.recordFailure(serializeError(error));
+					throw error;
+				}
+				process.exit(1);
+			}
+			hasStartupSucceededOnce = true;
+			scheduler?.clearFailure();
+			const startedModule = bootModule;
+			let shutdownDone = false;
+			const shutdown = async () => {
+				if (shutdownDone) return;
+				shutdownDone = true;
+				try {
+					await runShutdown(startedModule, resolveBootContext(server, options.getConfig()));
+				} catch (error) {
+					logger.error(`Error running shutdown script: ${serializeError(error)}`);
+				}
+				clearNativeMounts();
+			};
+			priorShutdown = shutdown;
+			server.httpServer?.once("close", () => {
+				shutdown();
+			});
+			if (scheduler) setupBootWatch(server, [...entry ? [entry] : [], ...options.watchEntries], scheduler);
+		}
+	}];
+}
+//#endregion
+//#region src/excludes/serialize.ts
+/**
+* Serialize exclude patterns to JavaScript code for use in virtual modules.
+* Handles RegExp objects which JSON.stringify cannot serialize.
+*/
+function serializeExcludePatterns(patterns) {
+	return `[${patterns.map((p) => "pattern" in p ? `{ pattern: ${p.pattern.toString()} }` : JSON.stringify(p)).join(", ")}]`;
+}
+//#endregion
+//#region src/tweaks/sourcemap.ts
+/**
+* emit sourcemaps only for the SSR build. client bundles are left unmapped
+* so browsers can't fetch source via `//# sourceMappingURL=`.
+*
+* vite 7's `environments.ssr.build.sourcemap` looks cleaner but wholesale
+* replaces astro's SSR build defaults (including entry file naming), which
+* breaks the embedded dev boot machinery. using `isSsrBuild` keeps the
+* rest of astro's SSR config intact.
+*/
+function ssrSourcemapPlugin() {
+	return {
+		name: "@astroscope/node/tweaks/sourcemap",
+		config(_config, { isSsrBuild }) {
+			if (isSsrBuild) return { build: { sourcemap: true } };
+			return {};
+		}
+	};
+}
+//#endregion
+//#region src/tweaks/strip-effects.ts
+const HOOK_NAMES = /* @__PURE__ */ new Set([
+	"useEffect",
+	"useLayoutEffect",
+	"useInsertionEffect"
+]);
+const REACT_SOURCE = /^react(\/.*)?$/;
+const TRANSFORMABLE = /\.(?:[mc]?[jt]sx?)$/;
+const EMPTY_FN = "(()=>{})";
+/**
+* in SSR builds, react effect hooks never execute. emptying their callbacks
+* lets rolldown drop dead branches — including dynamic imports of client-only
+* libs (maplibre-gl, hls.js, etc.) — from the server bundle, which in turn
+* stops nft from tracing them at docker-image time.
+*
+* scope is deliberately narrow: first-party code only (no node_modules), only
+* in the SSR pass, and binding-aware (the React import must resolve to the
+* real react package). raw chunks where bundling has erased the binding are
+* left alone — that's NFT's domain, not ours.
+*/
+function stripSsrEffectsPlugin() {
+	return {
+		name: "@astroscope/node/tweaks/strip-effects",
+		enforce: "post",
+		transform(code, id, options) {
+			if (!options?.ssr) return null;
+			if (id.includes("/node_modules/")) return null;
+			const cleanId = id.split("?")[0] ?? id;
+			if (!TRANSFORMABLE.test(cleanId)) return null;
+			if (!code.includes("useEffect") && !code.includes("useLayoutEffect") && !code.includes("useInsertionEffect")) return null;
+			let ast;
+			try {
+				ast = Parser.parse(code, {
+					ecmaVersion: "latest",
+					sourceType: "module",
+					allowReturnOutsideFunction: true,
+					allowAwaitOutsideFunction: true,
+					allowImportExportEverywhere: true,
+					allowHashBang: true
+				});
+			} catch {
+				return null;
+			}
+			const directHooks = /* @__PURE__ */ new Set();
+			const namespaceHooks = /* @__PURE__ */ new Set();
+			walk(ast, (node) => {
+				if (node.type !== "ImportDeclaration") return;
+				const src = node.source?.value;
+				if (typeof src !== "string" || !REACT_SOURCE.test(src)) return;
+				for (const spec of node.specifiers ?? []) if (spec.type === "ImportSpecifier") {
+					const imported = spec.imported?.name ?? spec.imported?.value;
+					if (HOOK_NAMES.has(imported)) directHooks.add(spec.local.name);
+				} else if (spec.type === "ImportDefaultSpecifier" || spec.type === "ImportNamespaceSpecifier") namespaceHooks.add(spec.local.name);
+			});
+			if (directHooks.size === 0 && namespaceHooks.size === 0) return null;
+			const replacements = [];
+			walk(ast, (node) => {
+				if (node.type !== "CallExpression" || !node.arguments?.length) return;
+				const callee = node.callee;
+				const isDirect = callee.type === "Identifier" && directHooks.has(callee.name);
+				const isMember = callee.type === "MemberExpression" && !callee.computed && callee.object?.type === "Identifier" && namespaceHooks.has(callee.object.name) && callee.property?.type === "Identifier" && HOOK_NAMES.has(callee.property.name);
+				if (!isDirect && !isMember) return;
+				const arg = node.arguments[0];
+				replacements.push({
+					start: arg.start,
+					end: arg.end
+				});
+			});
+			if (replacements.length === 0) return null;
+			const s = new MagicString(code);
+			for (const { start, end } of replacements) s.overwrite(start, end, EMPTY_FN);
+			return {
+				code: s.toString(),
+				map: s.generateMap({ hires: true })
+			};
+		}
+	};
+}
+function walk(node, visit) {
+	if (!node || typeof node !== "object") return;
+	if (typeof node.type === "string") visit(node);
+	for (const key of Object.keys(node)) {
+		const v = node[key];
+		if (Array.isArray(v)) for (const item of v) walk(item, visit);
+		else if (v && typeof v === "object") walk(v, visit);
+	}
+}
+//#endregion
+//#region src/integration/integration.ts
+const CONFIG_VIRTUAL_MODULE_ID = "virtual:@astroscope/node/config";
+const BOOT_VIRTUAL_MODULE_ID = "virtual:@astroscope/node/boot";
+const CSRF_VIRTUAL_MODULE_ID = "virtual:@astroscope/node/csrf";
+const CONFIG_ENTRY_VIRTUAL_MODULE_ID = "virtual:@astroscope/node/config-entry";
+const INSTRUMENTATION_ENTRY_VIRTUAL_MODULE_ID = "virtual:@astroscope/node/instrumentation-entry";
+const LOG_ENTRY_VIRTUAL_MODULE_ID = "virtual:@astroscope/node/log-entry";
+const RESOLVED_CONFIG_VIRTUAL_MODULE_ID = `\0${CONFIG_VIRTUAL_MODULE_ID}`;
+const RESOLVED_BOOT_VIRTUAL_MODULE_ID = `\0${BOOT_VIRTUAL_MODULE_ID}`;
+const RESOLVED_CSRF_VIRTUAL_MODULE_ID = `\0${CSRF_VIRTUAL_MODULE_ID}`;
+const RESOLVED_CONFIG_ENTRY_VIRTUAL_MODULE_ID = `\0${CONFIG_ENTRY_VIRTUAL_MODULE_ID}`;
+const RESOLVED_INSTRUMENTATION_ENTRY_VIRTUAL_MODULE_ID = `\0${INSTRUMENTATION_ENTRY_VIRTUAL_MODULE_ID}`;
+const RESOLVED_LOG_ENTRY_VIRTUAL_MODULE_ID = `\0${LOG_ENTRY_VIRTUAL_MODULE_ID}`;
+const SERVER_ENVIRONMENTS = [
+	"ssr",
+	"prerender",
+	"astro"
+];
+const DEFAULT_REQUEST_EXCLUDES = [...RECOMMENDED_EXCLUDES, ...STATIC_EXCLUDES];
+function resolveHost(host) {
+	if (typeof host === "string") return host;
+	return host === true ? "0.0.0.0" : "localhost";
+}
+function resolveBootEntry(root, entry) {
+	if (entry) {
+		const abs = path.resolve(root, entry);
+		if (!fs.existsSync(abs)) throw new Error(`[@astroscope/node] boot entry not found: ${entry}`);
+		return abs;
+	}
+	for (const candidate of ["src/boot/index.ts", "src/boot.ts"]) {
+		const abs = path.resolve(root, candidate);
+		if (fs.existsSync(abs)) return abs;
+	}
+}
+function resolveSeam(root, candidate) {
+	const abs = path.resolve(root, candidate);
+	return fs.existsSync(abs) ? abs : void 0;
+}
+/**
+* Node adapter for Astro with a first-class server entrypoint: the boot
+* lifecycle, module warmup, health probes, request logging and telemetry run
+* as plain code around `server.listen()` instead of being injected into the
+* build output.
+*/
+function node(options = {}) {
+	const bootOptions = options.boot ?? {};
+	const healthOptions = options.health ?? {};
+	const csrfOptions = options.csrf ?? {};
+	const loggingOptions = options.logging ?? {};
+	const telemetryOptions = options.telemetry ?? {};
+	const loggingExclude = loggingOptions ? loggingOptions.exclude ?? DEFAULT_REQUEST_EXCLUDES : [];
+	const telemetryExclude = telemetryOptions ? telemetryOptions.exclude ?? DEFAULT_REQUEST_EXCLUDES : [];
+	let astroConfig = null;
+	let bootEntry;
+	let configSeam;
+	let instrumentationSeam;
+	let logSeam;
+	let isDev = false;
+	return {
+		name: "@astroscope/node",
+		hooks: {
+			"astro:config:setup": ({ command, config, updateConfig, addMiddleware, logger }) => {
+				isDev = command === "dev";
+				if (loggingOptions || telemetryOptions) addMiddleware({
+					order: "pre",
+					entrypoint: "@astroscope/node/route-middleware"
+				});
+				if (csrfOptions) addMiddleware({
+					order: "pre",
+					entrypoint: "@astroscope/node/csrf-middleware"
+				});
+				const root = fileURLToPath(config.root);
+				const watch = bootOptions === false ? false : bootOptions.watch ?? true;
+				bootEntry = bootOptions === false ? void 0 : resolveBootEntry(root, bootOptions.entry);
+				configSeam = resolveSeam(root, "src/config.ts");
+				instrumentationSeam = resolveSeam(root, "src/instrumentation.ts");
+				logSeam = resolveSeam(root, "src/log.ts");
+				const relativeSeam = (abs) => abs ? path.relative(root, abs).split(path.sep).join("/") : void 0;
+				const devMachinery = command === "dev" && bootOptions !== false ? createDevMachinery({
+					entry: bootEntry ? path.relative(root, bootEntry) : void 0,
+					watch,
+					watchEntries: [relativeSeam(configSeam), relativeSeam(logSeam)].filter((entry) => !!entry),
+					prepare: (importModule) => preparePlatform({
+						dev: true,
+						telemetry: telemetryOptions && telemetryOptions.dev ? { prometheus: telemetryOptions.prometheus ?? {} } : false,
+						seams: {
+							...configSeam && { config: () => importModule(`/${relativeSeam(configSeam)}`) },
+							...instrumentationSeam && { instrumentation: () => importModule(`/${relativeSeam(instrumentationSeam)}`) },
+							...logSeam && { log: () => importModule(`/${relativeSeam(logSeam)}`) }
+						}
+					}),
+					logger,
+					getConfig: () => astroConfig
+				}) : [];
+				if (command === "dev" && bootOptions !== false && watch) addMiddleware({
+					entrypoint: "@astroscope/node/dev-middleware",
+					order: "pre"
+				});
+				updateConfig({
+					build: { redirects: false },
+					...config.trailingSlash === "ignore" && { trailingSlash: "never" },
+					security: {
+						...!config.security.allowedDomains?.length && { allowedDomains: [{}] },
+						...csrfOptions && { checkOrigin: false }
+					},
+					image: { endpoint: {
+						route: config.image.endpoint.route ?? "_image",
+						entrypoint: config.image.endpoint.entrypoint ?? (command === "dev" ? "astro/assets/endpoint/dev" : "astro/assets/endpoint/node")
+					} },
+					vite: { plugins: [
+						...devMachinery,
+						ssrSourcemapPlugin(),
+						stripSsrEffectsPlugin(),
+						{
+							name: "@astroscope/node",
+							configEnvironment(environmentName) {
+								if (SERVER_ENVIRONMENTS.includes(environmentName)) return { resolve: { noExternal: ["@astroscope/node"] } };
+							},
+							resolveId(id) {
+								if (id === "virtual:@astroscope/node/config") return RESOLVED_CONFIG_VIRTUAL_MODULE_ID;
+								if (id === "virtual:@astroscope/node/boot") return RESOLVED_BOOT_VIRTUAL_MODULE_ID;
+								if (id === "virtual:@astroscope/node/csrf") return RESOLVED_CSRF_VIRTUAL_MODULE_ID;
+								if (id === "virtual:@astroscope/node/config-entry") return RESOLVED_CONFIG_ENTRY_VIRTUAL_MODULE_ID;
+								if (id === "virtual:@astroscope/node/instrumentation-entry") return RESOLVED_INSTRUMENTATION_ENTRY_VIRTUAL_MODULE_ID;
+								if (id === "virtual:@astroscope/node/log-entry") return RESOLVED_LOG_ENTRY_VIRTUAL_MODULE_ID;
+							},
+							load(id) {
+								if (id === RESOLVED_CONFIG_VIRTUAL_MODULE_ID) {
+									if (!astroConfig) throw new Error("[@astroscope/node] astro config not resolved yet");
+									const runtimeOptions = {
+										host: resolveHost(astroConfig.server.host),
+										port: astroConfig.server.port ?? 4321,
+										client: astroConfig.build.client.toString(),
+										server: astroConfig.build.server.toString(),
+										bodySizeLimit: options.bodySizeLimit ?? 1024 * 1024 * 1024,
+										shutdownTimeout: options.shutdownTimeout ?? 1e4,
+										health: healthOptions ? {
+											...healthOptions.host !== void 0 && { host: healthOptions.host },
+											...healthOptions.port !== void 0 && { port: healthOptions.port },
+											...healthOptions.paths && { paths: healthOptions.paths }
+										} : false
+									};
+									const logging = loggingOptions ? `{ exclude: ${serializeExcludePatterns(loggingExclude)}, extended: ${JSON.stringify(loggingOptions.extended ?? false)} }` : "false";
+									const telemetry = telemetryOptions ? `{ exclude: ${serializeExcludePatterns(telemetryExclude)}, prometheus: ${JSON.stringify(telemetryOptions.prometheus ?? {})} }` : "false";
+									return `export const options = { ...${JSON.stringify(runtimeOptions)}, logging: ${logging}, telemetry: ${telemetry} };`;
+								}
+								if (id === RESOLVED_BOOT_VIRTUAL_MODULE_ID) return bootEntry ? `export * from ${JSON.stringify(bootEntry)};` : "export {};";
+								if (id === RESOLVED_CSRF_VIRTUAL_MODULE_ID) return `export const excludePatterns = ${serializeExcludePatterns(csrfOptions ? csrfOptions.exclude ?? [] : [])};`;
+								if (id === RESOLVED_CONFIG_ENTRY_VIRTUAL_MODULE_ID) return configSeam ? `import ${JSON.stringify(configSeam)};\nexport {};` : "export {};";
+								if (id === RESOLVED_INSTRUMENTATION_ENTRY_VIRTUAL_MODULE_ID) return instrumentationSeam ? `export * from ${JSON.stringify(instrumentationSeam)};` : "export {};";
+								if (id === RESOLVED_LOG_ENTRY_VIRTUAL_MODULE_ID) return logSeam ? `export { default } from ${JSON.stringify(logSeam)};` : "export default undefined;";
+							}
+						}
+					] }
+				});
+			},
+			"astro:server:setup": ({ server }) => {
+				if (!isDev) return;
+				const devLogging = loggingOptions && loggingOptions.dev;
+				const devTelemetry = telemetryOptions && telemetryOptions.dev;
+				const instrument = devLogging || devTelemetry ? createRequestInstrumentation({
+					logging: devLogging ? {
+						exclude: loggingExclude,
+						extended: loggingOptions.extended ?? false
+					} : false,
+					telemetry: devTelemetry ? { exclude: telemetryExclude } : false
+				}) : void 0;
+				server.middlewares.use((req, res, next) => {
+					const inner = () => {
+						if (!dispatchNativeMount(req, res)) next();
+					};
+					if (instrument) instrument(req, res, inner);
+					else inner();
+				});
+			},
+			"astro:config:done": ({ config, setAdapter }) => {
+				astroConfig = config;
+				setAdapter({
+					name: "@astroscope/node",
+					entrypointResolution: "auto",
+					serverEntrypoint: "@astroscope/node/server",
+					previewEntrypoint: "@astroscope/node/preview",
+					adapterFeatures: {
+						buildOutput: "server",
+						middlewareMode: "classic"
+					},
+					supportedAstroFeatures: {
+						hybridOutput: "stable",
+						staticOutput: "stable",
+						serverOutput: "stable",
+						sharpImageService: "stable",
+						i18nDomains: "experimental",
+						envGetSecret: "stable"
+					}
+				});
+			},
+			"astro:build:done": async ({ logger }) => {
+				if (!astroConfig) return;
+				const { compressClientDir } = await import("./compress-B11aeRHQ.js");
+				await compressClientDir(fileURLToPath(astroConfig.build.client), logger);
+			}
+		}
+	};
+}
+//#endregion
+export { node as default };
+
+//# sourceMappingURL=index.js.map