@astroscope/node 1.2.2 → 1.4.0

package/README.md

@@ -15,6 +15,7 @@ Opinionated, cloud-friendly Node adapter for Astro: boot lifecycle, health probe
 - **Native mounts** — http-native handlers (`oidc-provider`, ACME) mounted on the adapter's server
 - **Build tweaks** — SSR sourcemaps, SSR effect stripping
 - **Dev restart machinery** — changes to the boot file or entry seams restart the dev server behind a holding page
+- **Dev island warmup** — `.astro` sources are scanned for `client:*` components; their deps are pre-optimized and their module graphs warmed at server start, preventing "504 Outdated Optimize Dep" hydration failures from vite's lazy dep discovery
 - **HTTPS for development** — `SERVER_CERT_PATH` / `SERVER_KEY_PATH` serve TLS directly for local runs of the built server ([HTTPS](#https)); in production, terminate TLS at the ingress
 
 ## What it does NOT do — beware
@@ -144,6 +145,26 @@ Entries logged before the logger is constructed (env loading, config, instrument
 
 Request logging happens at the native handler on `finish`/`close`: real status code, response size, `ttfb`, aborted-vs-completed, and the route pattern (fed back by an internal astro middleware). An incoming `x-request-id` header is passed through (and echoed on the response); otherwise a short id is generated.
 
+### Reporting the route yourself
+
+The route comes from the route astro matched, which is wrong for a middleware that serves a request astro has no page for — one that rewrites via `next(url)`, or answers itself. Astro matches `/404` there, so the request is logged as `/404` despite its `200`, and every such request collapses into one `/404` bucket in the request duration metric. `overrideRequestRoute` lets the middleware report what it actually served:
+
+```typescript
+import { overrideRequestRoute } from '@astroscope/node/log';
+
+export const onRequest: MiddlewareHandler = (ctx, next) => {
+  const page = lookupPage(ctx.url.pathname);
+
+  if (!page) return next();
+
+  overrideRequestRoute('/cms/pages/[id]');
+
+  return next(`/cms/pages/${page.id}`);
+};
+```
+
+This fixes the log line, the metric and the server span name together. Pass a templated label, not a concrete path, so metric cardinality stays bounded. An overridden route always wins over the one astro matched, regardless of middleware order.
+
 The adapter itself emits exactly one info line on startup — `server ready { host, port, health, bootMs, warmupMs, totalMs }` — and `draining` / `shutdown complete { drainMs }` on the way down. Everything else is debug or error level.
 
 ## Telemetry

package/dist/boot.d.ts

@@ -1,5 +1,4 @@
 import { t as BootContext } from "./types-D0uMBi2M.js";
-
 //#region src/lifecycle/context.d.ts
 /**
  * The boot context of the server running in this process, or `undefined` when

package/dist/boot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"boot.d.ts","names":[],"sources":["../src/lifecycle/context.ts"],"mappings":";;;;AAiBA;;;;AAA6C;;;iBAA7B,cAAA,IAAkB,WAAW"}
+{"version":3,"file":"boot.d.ts","names":[],"sources":["../src/lifecycle/context.ts"],"mappings":";;;;;;;;;;iBAiBgB,kBAAkB"}

package/dist/{construct-DgB-jR0a.d.ts → construct-BGlPfWMF.d.ts}

@@ -1,5 +1,4 @@
 import { Logger, LoggerOptions } from "pino";
-
 //#region src/observability/log/construct.d.ts
 /**
  * Contract of the `src/log.ts` entry seam: pino logger options, or a factory
@@ -11,4 +10,4 @@ type LoggerOptionsFactory = LoggerOptions | ((ctx: {
 }) => LoggerOptions | Promise<LoggerOptions>);
 //#endregion
 export { LoggerOptionsFactory as t };
-//# sourceMappingURL=construct-DgB-jR0a.d.ts.map
+//# sourceMappingURL=construct-BGlPfWMF.d.ts.map

package/dist/construct-BGlPfWMF.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"construct-BGlPfWMF.d.ts","names":[],"sources":["../src/observability/log/construct.ts"],"mappings":";;;;;;;KASY,uBAAuB,kBAAkB;EAAO;MAAmB,gBAAgB,QAAQ"}

package/dist/csrf-middleware-entrypoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"csrf-middleware-entrypoint.d.ts","names":[],"sources":["../src/csrf/middleware-entrypoint.ts"],"mappings":";cAKa,SAAA,kBAAS,iBAA4D"}
+{"version":3,"file":"csrf-middleware-entrypoint.d.ts","names":[],"sources":["../src/csrf/middleware-entrypoint.ts"],"mappings":";cAKa,2BAAS"}

package/dist/dev-middleware-entrypoint.d.ts

@@ -1,5 +1,4 @@
 import { MiddlewareHandler } from "astro";
-
 //#region src/dev-mode/middleware-entrypoint.d.ts
 /**
  * Wrap every request so errors thrown by a stale render (one whose user

package/dist/dev-middleware-entrypoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev-middleware-entrypoint.d.ts","names":[],"sources":["../src/dev-mode/middleware-entrypoint.ts"],"mappings":";;;;;AAWA;;;;AAcC;;cAdY,SAAA,EAAW,iBAcvB"}
+{"version":3,"file":"dev-middleware-entrypoint.d.ts","names":[],"sources":["../src/dev-mode/middleware-entrypoint.ts"],"mappings":";;;;;;;;;;cAWa,WAAW"}

package/dist/{events-CUzQ2_cp.d.ts → events-u7J3ezJR.d.ts}

@@ -1,5 +1,4 @@
 import { t as BootContext } from "./types-D0uMBi2M.js";
-
 //#region src/lifecycle/events.d.ts
 type BootEventName = 'beforeOnStartup' | 'afterOnStartup' | 'beforeOnShutdown' | 'afterOnShutdown';
 type BootEventHandler = (context: BootContext) => Promise<void> | void;
@@ -17,4 +16,4 @@ declare function off(event: BootEventName, handler: BootEventHandler): void;
 declare function emit(event: BootEventName, context: BootContext): Promise<void>;
 //#endregion
 export { on as a, off as i, BootEventName as n, emit as r, BootEventHandler as t };
-//# sourceMappingURL=events-CUzQ2_cp.d.ts.map
+//# sourceMappingURL=events-u7J3ezJR.d.ts.map

package/dist/events-u7J3ezJR.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events-u7J3ezJR.d.ts","names":[],"sources":["../src/lifecycle/events.ts"],"mappings":";;KAEY;KAEA,oBAAoB,SAAS,gBAAgB;;;;iBAuBzC,GAAG,OAAO,eAAe,SAAS;;;;iBAelC,IAAI,OAAO,eAAe,SAAS;;;;iBAS7B,KAAK,OAAO,eAAe,SAAS,cAAc"}

package/dist/{excludes-DLF3A_Cf.d.ts → excludes-BDiE3eyp.d.ts}

@@ -1,6 +1,5 @@
 import { StringPattern } from "@entwico/dash/match";
 import { APIContext, MiddlewareHandler } from "astro";
-
 //#region src/excludes/excludes.d.ts
 /**
  * Patterns accepted by @astroscope/node exclude options. The serializable
@@ -60,4 +59,4 @@ declare function shouldExclude(ctx: APIContext, exclude: readonly StringPattern[
 declare function withExcluded(middleware: MiddlewareHandler, exclude: readonly StringPattern[] | ((context: APIContext) => boolean)): MiddlewareHandler;
 //#endregion
 export { STATIC_EXCLUDES as a, RECOMMENDED_EXCLUDES as i, DEV_EXCLUDES as n, shouldExclude as o, ExcludePattern as r, withExcluded as s, ASTRO_STATIC_EXCLUDES as t };
-//# sourceMappingURL=excludes-DLF3A_Cf.d.ts.map
+//# sourceMappingURL=excludes-BDiE3eyp.d.ts.map

package/dist/excludes-BDiE3eyp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"excludes-BDiE3eyp.d.ts","names":[],"sources":["../src/excludes/excludes.ts"],"mappings":";;;;;;;;KAQY,iBAAiB,QAAQ,gBAAgB;;;;cAKxC,cAAc;;;;cAWd,uBAAuB;;;;cAKvB,iBAAiB;;;;;;;;;;;;;;;;cAwBjB,sBAAsB;;;;iBAKnB,cACd,KAAK,YACL,kBAAkB,oBAAoB,SAAS;;;;;;;;;;;;;;;;;;iBA4BjC,aACd,YAAY,mBACZ,kBAAkB,oBAAoB,SAAS,0BAC9C"}

package/dist/excludes.d.ts

@@ -1,2 +1,2 @@
-import { a as STATIC_EXCLUDES, i as RECOMMENDED_EXCLUDES, n as DEV_EXCLUDES, o as shouldExclude, r as ExcludePattern, s as withExcluded, t as ASTRO_STATIC_EXCLUDES } from "./excludes-DLF3A_Cf.js";
+import { a as STATIC_EXCLUDES, i as RECOMMENDED_EXCLUDES, n as DEV_EXCLUDES, o as shouldExclude, r as ExcludePattern, s as withExcluded, t as ASTRO_STATIC_EXCLUDES } from "./excludes-BDiE3eyp.js";
 export { ASTRO_STATIC_EXCLUDES, DEV_EXCLUDES, ExcludePattern, RECOMMENDED_EXCLUDES, STATIC_EXCLUDES, shouldExclude, withExcluded };

package/dist/health.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"health.d.ts","names":[],"sources":["../src/health/health.ts"],"mappings":";UAEiB,iBAAA;EACf,MAAA;EACA,OAAA;EACA,KAAA;AAAA;AAAA,UAGe,qBAAA;EAJf;;;EAQA,IAAA;EAJe;;;;EAUf,KAAA,QAAa,OAAA,CAAQ,iBAAA,WAA4B,iBAAA;EAAA;;;;EAMjD,QAAA;EANa;;;;EAYb,OAAA;AAAA;AAAO;AAUT;;;;AAAqE;;AAV5D,iBAUO,mBAAA,CAAoB,UAAiC,EAArB,qBAAqB"}
+{"version":3,"file":"health.d.ts","names":[],"sources":["../src/health/health.ts"],"mappings":";UAEiB;EACf;EACA;EACA;;UAGe;;;;EAIf;;;;;EAMA,aAAa,QAAQ,4BAA4B;;;;;EAMjD;;;;;EAMA;;;;;;;;;iBAUc,oBAAoB,YAAY"}

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { r as ExcludePattern } from "./excludes-DLF3A_Cf.js";
+import { r as ExcludePattern } from "./excludes-BDiE3eyp.js";
+import "./construct-BGlPfWMF.js";
 import { t as BootContext } from "./types-D0uMBi2M.js";
-import { n as BootEventName, t as BootEventHandler } from "./events-CUzQ2_cp.js";
+import { n as BootEventName, t as BootEventHandler } from "./events-u7J3ezJR.js";
 import { AstroIntegration } from "astro";
-
 //#region src/types.d.ts
 interface NodeBootOptions {
   /**

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/integration/integration.ts","../src/platform/prepare.ts","../src/lifecycle/lifecycle.ts"],"mappings":";;;;;;UAEiB,eAAA;;;;;EAKf,KAAA;EALe;;;;AAYV;EAAL,KAAK;AAAA;;;;UAMU,gBAAA;EACf,IAAA;EACA,OAAA;EACA,KAAA;EACA,MAAA;AAAA;AAAA,UAGe,iBAAA;;;;;EAKf,IAAA;EAYQ;;AAAgB;AAG1B;EATE,IAAA;;;;;EAMA,KAAA,GAAQ,gBAAgB;AAAA;AAAA,UAGT,kBAAA;EAmBZ;AAGL;;;EAjBE,OAAA,GAAU,cAAc;EA4BpB;AAGN;;;;EAxBE,QAAA;EA6BU;;;;;EAtBV,GAAA;AAAA;AAAA,UAGe,qBAAA;;;;;EAKf,IAAA;EAqEmB;;;;EA/DnB,IAAI;AAAA;AAAA,UAGW,oBAAA;EA6Cf;;;;EAxCA,OAAA,GAAU,cAAA;EAuDD;;;;EAjDT,UAAA,GAAa,qBAAqB;EA8DnB;;;;ACzI+D;EDkF9E,GAAA;AAAA;AAAA,UAGe,WAAA;ECnCqB;;;;AAAmC;;;ED2CvE,IAAA,GAAO,eAAA;EE1GQ;;;;AACZ;;EFiHH,OAAA,GAAU,kBAAA;;AGrHZ;;;;;EH6HE,SAAA,GAAY,oBAAA;EG3H4B;;;;;EHkIxC,MAAA,GAAS,iBAAA;EGnI8B;;;;;;EH2IvC,IAAA;IAAS,OAAA,GAAU,cAAA;EAAA;;;;;EAMnB,aAAA;;;;;;EAOA,eAAA;AAAA;;;;;;AA9IK;AAMP;;iBCiDwB,IAAA,CAAK,OAAA,GAAS,WAAA,GAAmB,gBAAgB;;;UC/DxD,sBAAA;EACf,GAAG;AAAA;;;UCJY,UAAA;EACf,SAAA,KAAc,OAAA,EAAS,WAAA,KAAgB,OAAA;EACvC,UAAA,KAAe,OAAA,EAAS,WAAA,KAAgB,OAAA;AAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/integration/integration.ts","../src/platform/prepare.ts","../src/lifecycle/lifecycle.ts"],"mappings":";;;;;;UAEiB;;;;;EAKf;;;;;;EAOA;;;;;UAMe;EACf;EACA;EACA;EACA;;UAGe;;;;;EAKf;;;;;EAMA;;;;;EAMA,QAAQ;;UAGO;;;;;EAKf,UAAU;;;;;;EAOV;;;;;;EAOA;;UAGe;;;;;EAKf;;;;;EAMA;;UAGe;;;;;EAKf,UAAU;;;;;EAMV,aAAa;;;;;;EAOb;;UAGe;;;;;;;;EAQf,OAAO;;;;;;;EAQP,UAAU;;;;;;;EAQV,YAAY;;;;;;EAOZ,SAAS;;;;;;;EAQT;IAAS,UAAU;;;;;;EAMnB;;;;;;EAOA;;;;;;;;;;iBCtFsB,KAAK,UAAS,cAAmB;;;UChExC;EACf;;;;UCJe;EACf,cAAc,SAAS,gBAAgB;EACvC,eAAe,SAAS,gBAAgB"}

package/dist/index.js

@@ -1,13 +1,175 @@
 import { n as setBootContext } from "./context-Bkg-FnnQ.js";
-import { a as runShutdown, i as createRequestInstrumentation, o as runStartup, t as preparePlatform } from "./prepare-DQEf2Bnt.js";
-import { n as dispatchNativeMount, t as clearNativeMounts } from "./native-mount-hhwWdLtL.js";
+import { a as runShutdown, i as createRequestInstrumentation, o as runStartup, t as preparePlatform } from "./prepare-CXZsyAVk.js";
+import { n as dispatchNativeMount, t as clearNativeMounts } from "./native-mount-DjYEnO4X.js";
 import { n as getCurrentGeneration, r as incrementGeneration, t as GEN_HEADER } from "./generation-Bp2IA0jf.js";
 import { 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 { parse } from "@astrojs/compiler-rs";
 import { Parser } from "acorn";
 import MagicString from "magic-string";
+//#region src/dev-mode/island-warmup.ts
+function isAstNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function walk$1(node, visit) {
+	if (Array.isArray(node)) {
+		for (const item of node) walk$1(item, visit);
+		return;
+	}
+	if (typeof node !== "object" || node === null) return;
+	if (isAstNode(node)) visit(node);
+	for (const value of Object.values(node)) walk$1(value, visit);
+}
+/** local binding name → import specifier, from the frontmatter program */
+function collectImports(program) {
+	const imports = /* @__PURE__ */ new Map();
+	walk$1(program, (node) => {
+		if (node.type !== "ImportDeclaration") return;
+		const decl = node;
+		if (decl.importKind === "type") return;
+		const specifier = typeof decl.source?.value === "string" ? decl.source.value : void 0;
+		if (!specifier) return;
+		for (const spec of decl.specifiers ?? []) {
+			if (spec.importKind === "type") continue;
+			if (typeof spec.local?.name === "string") imports.set(spec.local.name, specifier);
+		}
+	});
+	return imports;
+}
+/** the root identifier of a JSX tag: `Foo` → Foo, `Ns.Chart` → Ns */
+function tagRootIdentifier(name) {
+	let current = name;
+	while (isAstNode(current) && current.type === "JSXMemberExpression") current = current.object;
+	if (isAstNode(current) && current.type === "JSXIdentifier") {
+		const identifier = current;
+		return typeof identifier.name === "string" ? identifier.name : void 0;
+	}
+}
+function hasClientDirective(attributes) {
+	if (!Array.isArray(attributes)) return false;
+	return attributes.some((attr) => {
+		if (!isAstNode(attr) || attr.type !== "JSXAttribute") return false;
+		const name = attr.name;
+		return typeof name?.name === "string" && name.name.startsWith("client:");
+	});
+}
+/**
+* Extract the import specifiers of all hydrated (`client:*`) components from
+* raw `.astro` source. Astro components can't hydrate, so `.astro` specifiers
+* are skipped; dynamic tags without a frontmatter import are invisible here.
+*/
+function scanAstroSource(source) {
+	const { ast } = parse(source);
+	const root = ast;
+	const imports = collectImports(root.frontmatter?.program);
+	if (imports.size === 0) return [];
+	const specifiers = /* @__PURE__ */ new Set();
+	walk$1(root.body, (node) => {
+		if (node.type !== "JSXOpeningElement") return;
+		const element = node;
+		if (!hasClientDirective(element.attributes)) return;
+		const rootName = tagRootIdentifier(element.name);
+		if (!rootName || /^[a-z]/.test(rootName)) return;
+		const specifier = imports.get(rootName);
+		if (specifier && !specifier.endsWith(".astro")) specifiers.add(specifier);
+	});
+	return [...specifiers];
+}
+/** scan all `.astro` files under `srcDir` for hydrated components */
+async function scanProjectIslands(srcDir, logger) {
+	const islands = [];
+	let entries;
+	try {
+		entries = await fs.promises.readdir(srcDir, {
+			recursive: true,
+			withFileTypes: true
+		});
+	} catch {
+		return islands;
+	}
+	const files = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".astro")).map((entry) => path.join(entry.parentPath, entry.name));
+	await Promise.all(files.map(async (file) => {
+		try {
+			const source = await fs.promises.readFile(file, "utf8");
+			for (const specifier of scanAstroSource(source)) islands.push({
+				importer: file,
+				specifier
+			});
+		} catch (error) {
+			logger.debug(`island scan skipped ${file}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}));
+	return islands;
+}
+function packageNameOf(specifier) {
+	const segments = specifier.split("/");
+	return specifier.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0] ?? specifier;
+}
+/**
+* Bare package specifiers resolvable from the project's `node_modules` — these
+* go into `optimizeDeps.include`. Anything else (relative paths, tsconfig
+* aliases, hoisted workspace deps) is resolved through vite at server start;
+* misclassification is harmless, just slightly later discovery.
+*/
+function selectBareSpecifiers(islands, root) {
+	const bare = /* @__PURE__ */ new Set();
+	for (const { specifier } of islands) {
+		if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("#")) continue;
+		if (fs.existsSync(path.join(root, "node_modules", packageNameOf(specifier)))) bare.add(specifier);
+	}
+	return [...bare];
+}
+function toRequestUrl(id, root) {
+	const normalized = id.split(path.sep).join("/");
+	const normalizedRoot = root.split(path.sep).join("/");
+	return normalized.startsWith(`${normalizedRoot}/`) ? normalized.slice(normalizedRoot.length) : `/@fs/${normalized}`;
+}
+function createIslandWarmup(options) {
+	const { root, srcDir, logger } = options;
+	let islands = [];
+	const warmIslands = async (server, batch, warmed) => {
+		const env = server.environments.client;
+		await Promise.all(batch.map(async ({ importer, specifier }) => {
+			try {
+				const resolved = await env.pluginContainer.resolveId(specifier, importer);
+				if (!resolved || resolved.external) return;
+				if (resolved.id.startsWith("\0") || resolved.id.includes("node_modules")) return;
+				if (warmed.has(resolved.id)) return;
+				warmed.add(resolved.id);
+				await env.warmupRequest(toRequestUrl(resolved.id, root));
+			} catch {}
+		}));
+	};
+	return {
+		name: "@astroscope/node/island-warmup",
+		async config() {
+			islands = await scanProjectIslands(srcDir, logger);
+			const include = selectBareSpecifiers(islands, root);
+			if (islands.length > 0) logger.info(`warming ${islands.length} island(s), pre-optimizing ${include.length} dependenc(ies)`);
+			return include.length > 0 ? { optimizeDeps: { include } } : void 0;
+		},
+		configureServer(server) {
+			const warmed = /* @__PURE__ */ new Set();
+			if (server.httpServer) server.httpServer.once("listening", () => void warmIslands(server, islands, warmed));
+			else warmIslands(server, islands, warmed);
+			const onWatcherEvent = (file) => {
+				if (!file.endsWith(".astro") || !file.startsWith(srcDir)) return;
+				fs.promises.readFile(file, "utf8").then((source) => {
+					const batch = scanAstroSource(source).map((specifier) => ({
+						importer: file,
+						specifier
+					}));
+					return warmIslands(server, batch, warmed);
+				}).catch(() => {});
+			};
+			server.watcher.on("add", onWatcherEvent);
+			server.watcher.on("change", onWatcherEvent);
+		}
+	};
+}
+//#endregion
 //#region src/dev-mode/serialize-error.ts
 function serializeError(error) {
 	if (error instanceof Error) return error.stack ?? error.message;
@@ -620,6 +782,11 @@ function node(options = {}) {
 					entrypoint: "@astroscope/node/dev-middleware",
 					order: "pre"
 				});
+				const islandWarmup = command === "dev" ? [createIslandWarmup({
+					root,
+					srcDir: fileURLToPath(config.srcDir),
+					logger
+				})] : [];
 				updateConfig({
 					build: { redirects: false },
 					...config.trailingSlash === "ignore" && { trailingSlash: "never" },
@@ -633,6 +800,7 @@ function node(options = {}) {
 					} },
 					vite: { plugins: [
 						...devMachinery,
+						...islandWarmup,
 						ssrSourcemapPlugin(),
 						stripSsrEffectsPlugin(),
 						{