@astroscope/node 1.3.0 → 2.0.0

package/dist/index.js

@@ -3,11 +3,176 @@ import { a as runShutdown, i as createRequestInstrumentation, o as runStartup, t
 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 { i as registerIslandEmitter } from "./emitters-C20tjKLp.js";
+import { t as getRequestRouteData } from "./route-store-DdxGePj2.js";
 import fs, { readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { parse } from "@astrojs/compiler-rs";
+import { createHash } from "node:crypto";
 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;
@@ -413,6 +578,81 @@ function createDevMachinery(options) {
 function serializeExcludePatterns(patterns) {
 	return `[${patterns.map((p) => "pattern" in p ? `{ pattern: ${p.pattern.toString()} }` : JSON.stringify(p)).join(", ")}]`;
 }
+const RESOLVED_ISLANDS_VIRTUAL_MODULE_ID = `\0virtual:@astroscope/node/islands-manifest`;
+const MANIFEST_FILE_NAME = "islands-manifest.json";
+/**
+* Client-build side of island preloading: records the chunk import graph (direct
+* static and dynamic edges per chunk), writes the content-hashed gate runtime into
+* the client assets dir, and drops the manifest next to the server chunks — where
+* the virtual module reads it back at runtime, mirroring the i18n manifest.
+*
+* The client build runs after the server build, so the SSR bundle can only carry
+* code that reads the file lazily; in dev there is no manifest and the middleware
+* stays inert.
+*/
+function createIslandsManifestPlugin(options) {
+	let isBuild = false;
+	return {
+		name: "@astroscope/node/islands-manifest",
+		configResolved(config) {
+			isBuild = config.command === "build";
+		},
+		resolveId(id) {
+			if (id === "virtual:@astroscope/node/islands-manifest") return RESOLVED_ISLANDS_VIRTUAL_MODULE_ID;
+		},
+		load(id) {
+			if (id !== RESOLVED_ISLANDS_VIRTUAL_MODULE_ID) return;
+			if (!isBuild || !options.enabled) return "export const manifest = null;";
+			return `
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const dir = dirname(fileURLToPath(import.meta.url));
+
+let manifest = null;
+
+for (const candidate of [
+  join(dir, '${MANIFEST_FILE_NAME}'),
+  join(dir, 'chunks', '${MANIFEST_FILE_NAME}'),
+  join(dir, '..', 'chunks', '${MANIFEST_FILE_NAME}'),
+]) {
+  try {
+    manifest = JSON.parse(readFileSync(candidate, 'utf-8'));
+    break;
+  } catch {
+    manifest = null;
+  }
+}
+
+export { manifest };
+`;
+		},
+		writeBundle(outputOptions, bundle) {
+			if (!options.enabled || this.environment.name !== "client" || !outputOptions.dir) return;
+			const chunks = {};
+			for (const chunk of Object.values(bundle)) {
+				if (chunk.type !== "chunk") continue;
+				chunks[chunk.fileName] = {
+					...chunk.imports.length > 0 && { i: chunk.imports },
+					...chunk.dynamicImports.length > 0 && { d: chunk.dynamicImports }
+				};
+			}
+			const runtimeSource = fs.readFileSync(new URL("./islands-runtime.js", import.meta.url), "utf-8").replace(/^\/\/# sourceMappingURL=.*$/m, "").trimEnd();
+			const hash = createHash("sha256").update(runtimeSource).digest("hex").slice(0, 8);
+			const runtime = `${options.assetsDir}/islands-runtime.${hash}.js`;
+			fs.mkdirSync(path.join(outputOptions.dir, options.assetsDir), { recursive: true });
+			fs.writeFileSync(path.join(outputOptions.dir, options.assetsDir, `islands-runtime.${hash}.js`), runtimeSource);
+			const manifest = {
+				runtime,
+				chunks
+			};
+			const chunksDir = path.resolve(outputOptions.dir, "..", "server", "chunks");
+			if (fs.existsSync(chunksDir)) fs.writeFileSync(path.join(chunksDir, MANIFEST_FILE_NAME), JSON.stringify(manifest));
+			else options.logger.warn(`server chunks directory not found, cannot write manifest to ${chunksDir}`);
+		}
+	};
+}
 //#endregion
 //#region src/tweaks/sourcemap.ts
 /**
@@ -507,7 +747,7 @@ function stripSsrEffectsPlugin() {
 			for (const { start, end } of replacements) s.overwrite(start, end, EMPTY_FN);
 			return {
 				code: s.toString(),
-				map: s.generateMap({ hires: true })
+				map: s.generateMap({ hires: true }).toString()
 			};
 		}
 	};
@@ -570,6 +810,7 @@ function node(options = {}) {
 	const bootOptions = options.boot ?? {};
 	const healthOptions = options.health ?? {};
 	const csrfOptions = options.csrf ?? {};
+	const islandsEnabled = options.islands !== false;
 	const loggingOptions = options.logging ?? {};
 	const telemetryOptions = options.telemetry ?? {};
 	const loggingExclude = loggingOptions ? loggingOptions.exclude ?? DEFAULT_REQUEST_EXCLUDES : [];
@@ -593,6 +834,10 @@ function node(options = {}) {
 					order: "pre",
 					entrypoint: "@astroscope/node/csrf-middleware"
 				});
+				addMiddleware({
+					order: "pre",
+					entrypoint: "@astroscope/node/islands-middleware"
+				});
 				const root = fileURLToPath(config.root);
 				const watch = bootOptions === false ? false : bootOptions.watch ?? true;
 				bootEntry = bootOptions === false ? void 0 : resolveBootEntry(root, bootOptions.entry);
@@ -620,6 +865,13 @@ function node(options = {}) {
 					entrypoint: "@astroscope/node/dev-middleware",
 					order: "pre"
 				});
+				const islandWarmup = command === "dev" ? [createIslandWarmup({
+					root,
+					srcDir: fileURLToPath(config.srcDir),
+					logger
+				})] : [];
+				const imageService = options.imageService ?? "auto";
+				const imageOff = imageService === "off" || imageService === "auto" && config.image.service.entrypoint === "astro/assets/services/sharp";
 				updateConfig({
 					build: { redirects: false },
 					...config.trailingSlash === "ignore" && { trailingSlash: "never" },
@@ -627,12 +879,24 @@ function node(options = {}) {
 						...!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")
-					} },
+					image: {
+						...imageOff && { service: {
+							entrypoint: "@astroscope/node/image-service",
+							config: {}
+						} },
+						endpoint: {
+							route: config.image.endpoint.route ?? "_image",
+							entrypoint: imageOff ? "@astroscope/node/image-endpoint" : config.image.endpoint.entrypoint ?? (command === "dev" ? "astro/assets/endpoint/dev" : "astro/assets/endpoint/node")
+						}
+					},
 					vite: { plugins: [
 						...devMachinery,
+						...islandWarmup,
+						createIslandsManifestPlugin({
+							assetsDir: config.build.assets,
+							logger,
+							enabled: islandsEnabled
+						}),
 						ssrSourcemapPlugin(),
 						stripSsrEffectsPlugin(),
 						{
@@ -656,7 +920,7 @@ function node(options = {}) {
 										port: astroConfig.server.port ?? 4321,
 										client: astroConfig.build.client.toString(),
 										server: astroConfig.build.server.toString(),
-										bodySizeLimit: options.bodySizeLimit ?? 1024 * 1024 * 1024,
+										bodySizeLimit: options.bodySizeLimit ?? 1073741824,
 										shutdownTimeout: options.shutdownTimeout ?? 1e4,
 										health: healthOptions ? {
 											...healthOptions.host !== void 0 && { host: healthOptions.host },
@@ -720,6 +984,15 @@ function node(options = {}) {
 			},
 			"astro:build:done": async ({ logger }) => {
 				if (!astroConfig) return;
+				if (islandsEnabled) {
+					const manifestPath = path.join(fileURLToPath(astroConfig.build.server), "chunks", "islands-manifest.json");
+					if (fs.existsSync(manifestPath)) {
+						const { transformPrerenderedHtml } = await import("./prerendered-CpEAJN_q.js");
+						const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+						const transformed = await transformPrerenderedHtml(fileURLToPath(astroConfig.build.client), manifest);
+						if (transformed > 0) logger.info(`island preloading applied to ${transformed} prerendered page(s)`);
+					}
+				}
 				const { compressClientDir } = await import("./compress-B11aeRHQ.js");
 				await compressClientDir(fileURLToPath(astroConfig.build.client), logger);
 			}
@@ -727,6 +1000,6 @@ function node(options = {}) {
 	};
 }
 //#endregion
-export { node as default };
+export { node as default, getRequestRouteData, registerIslandEmitter };
 
 //# sourceMappingURL=index.js.map