@astroscope/node 1.4.0 → 2.0.1

package/README.md

@@ -11,9 +11,11 @@ Opinionated, cloud-friendly Node adapter for Astro: boot lifecycle, health probe
 - **Telemetry** — OpenTelemetry NodeSDK, undici fetch instrumentation, runtime + host metrics, Prometheus reader
 - **CSRF protection** — origin check for unsafe methods, with path exclusions
 - **Platform entry files** — env loading → `src/config.ts` → `src/instrumentation.ts` → `src/log.ts` → boot, each picked up automatically when the file exists
+- **Island preloading** — each island's JS is preloaded in parallel instead of being discovered module by module, removing the hydration request waterfall ([Island preloading](#island-preloading))
 - **Pre-compressed static serving** — build-time brotli/gzip variants, negotiated per `Accept-Encoding`
 - **Native mounts** — http-native handlers (`oidc-provider`, ACME) mounted on the adapter's server
 - **Build tweaks** — SSR sourcemaps, SSR effect stripping
+- **Image processing off unless configured** — without an explicit `image.service`, any `astro:assets` use fails loudly instead of opening astro's on-demand sharp endpoint ([Image processing](#image-processing))
 - **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
@@ -25,7 +27,7 @@ The adapter assumes a container behind a load balancer / reverse proxy (Kubernet
 - **Opens `0.0.0.0:9090` in production** — the health probe server. Meant for the kubelet; do not expose it publicly.
 - **Opens `0.0.0.0:9464` in production** — the Prometheus metrics reader. Same: cluster-internal only.
 - **Trusts any `Host` / `X-Forwarded-Host`** — sets `security.allowedDomains: [{}]` (unless you set it yourself), because the reverse proxy is expected to control these headers. Without one, host header injection is possible.
-- **Overrides Astro security and config defaults** — `security.checkOrigin: false` (the embedded CSRF middleware replaces it; `csrf: false` restores Astro's check), `build.redirects: false` (redirects handled at runtime), `trailingSlash: 'never'` (only when yours is at the default `'ignore'`).
+- **Overrides Astro security and config defaults** — `security.checkOrigin: false` (the embedded CSRF middleware replaces it; `csrf: false` restores Astro's check), `build.redirects: false` (redirects handled at runtime), `trailingSlash: 'never'` (only when yours is at the default `'ignore'`), `astro:assets` disabled when `image.service` is at its default ([Image processing](#image-processing)).
 - **Standalone only.** No middleware mode — the adapter always owns the server.
 - **No session driver.** Astro sessions are unsupported unless you configure `session.driver` yourself.
 - **No health probes in dev.** The health server only exists in production and `astro preview`.
@@ -238,6 +240,12 @@ export const onRequest = withExcluded(someExternalMiddleware(), RECOMMENDED_EXCL
 
 For hot paths, compile the set once with `createMatcher` from `@entwico/dash/match` instead of scanning per request (the adapter's own request instrumentation does exactly that).
 
+## Island preloading
+
+Without it, an island's JS loads as a chain: the browser fetches the component module, parses it, discovers its imports, fetches those, and so on. In production the adapter knows each island's chunks from the build and emits preload tags next to the island, so the browser fetches everything in parallel. Deferred islands (`client:visible`, `client:idle`, `client:media`) are preloaded just ahead of their hydration.
+
+Always on in production; `islands: false` disables it.
+
 ## Pre-compressed static serving
 
 At build time, every compressible file in `dist/client` gets max-quality `.br` (brotli 11) and `.gz` (gzip 9) variants written next to it — variants that don't shrink the file are skipped. At request time the static handler negotiates `Accept-Encoding` and serves the best variant with the original's content-type, `content-encoding`, `vary: accept-encoding` and per-variant etags (304s included). Behind a caching proxy with per-encoding cache keys, the origin serves each asset once per encoding.
@@ -249,6 +257,22 @@ Always on, no configuration:
 - **SSR sourcemaps** — the server bundle gets sourcemaps for readable stack traces; client bundles stay unmapped so browsers can't fetch source
 - **SSR effect stripping** — `useEffect`/`useLayoutEffect`/`useInsertionEffect` callbacks are emptied in the SSR bundle (effects never run on the server), letting the bundler drop client-only dynamic imports (maplibre-gl, hls.js, …) from the server build and the docker image
 
+## Image processing
+
+In SSR, astro's default sharp service makes `/_image` an on-demand decode+encode endpoint whose transform space is attacker-controlled: every distinct query string (`w`, `h`, `q`, `fit`, `position`, `background`) costs a full sharp run and is a distinct cache key, so no fronting cache can absorb it. Most SSR apps serve pre-generated variants from a CMS/CDN anyway, so the adapter keeps processing off unless you ask for it — governed by one option:
+
+```typescript
+node({
+  imageService: 'auto', // 'on' | 'off' | 'auto'
+});
+```
+
+- `'auto'` (default) — on when the astro config sets `image.service` itself, off otherwise
+- `'on'` — astro's default sharp service, no further config needed
+- `'off'` — off even over an explicit `image.service`
+
+Off is loud, not silent: the adapter installs a service whose every method throws with an explanation, so any `astro:assets` use — `<Image>`, `<Picture>`, `getImage()`, markdown or content-collection images — fails at render/build time instead of quietly serving unoptimized bytes. The `/_image` endpoint is replaced with a 404 responder — to clients the endpoint simply doesn't exist. Apps without images never load any of it.
+
 ## Options
 
 ```typescript
@@ -287,6 +311,13 @@ node({
     dev: false, // start the SDK in dev too (once per process)
   },
 
+  // island dependency preloading (production-only); false disables it
+  islands: false,
+
+  // on-demand image processing: 'auto' = on only when image.service is set
+  // in the astro config (see the Image processing section)
+  imageService: 'auto',
+
   bodySizeLimit: 1024 * 1024 * 1024, // request body limit in bytes
   shutdownTimeout: 10_000, // ms to wait for in-flight requests on shutdown
 });

package/dist/emitters-C20tjKLp.js

@@ -0,0 +1,43 @@
+//#region src/islands/emitters.ts
+/**
+* Emitters registered by other packages (e.g. `@astroscope/i18n`). Keyed on
+* `globalThis` via `Symbol.for` so the vite-runner and native module instances share
+* one registry — same pattern as the log store.
+*/
+const ISLAND_REGISTRY = Symbol.for("@astroscope/node.islandEmitters");
+const DOCUMENT_REGISTRY = Symbol.for("@astroscope/node.documentEmitters");
+function islandRegistry() {
+	const scope = globalThis;
+	return scope[ISLAND_REGISTRY] ??= [];
+}
+function documentRegistry() {
+	const scope = globalThis;
+	return scope[DOCUMENT_REGISTRY] ??= [];
+}
+/**
+* Register an emitter that contributes preload links and/or attributes for every
+* island the islands middleware sees. Registration is process-wide — call it once
+* during boot or module initialization, not per request.
+*/
+function registerIslandEmitter(emitter) {
+	islandRegistry().push(emitter);
+}
+function getIslandEmitters() {
+	return islandRegistry();
+}
+/**
+* Register an emitter that contributes document-level content (a head bootstrap
+* script, a stream-end script) for every html page response the islands middleware
+* streams. Registration is process-wide — call it once during boot or module
+* initialization, not per request.
+*/
+function registerDocumentEmitter(emitter) {
+	documentRegistry().push(emitter);
+}
+function getDocumentEmitters() {
+	return documentRegistry();
+}
+//#endregion
+export { registerIslandEmitter as i, getIslandEmitters as n, registerDocumentEmitter as r, getDocumentEmitters as t };
+
+//# sourceMappingURL=emitters-C20tjKLp.js.map

package/dist/emitters-C20tjKLp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitters-C20tjKLp.js","names":[],"sources":["../src/islands/emitters.ts"],"sourcesContent":["import type { DocumentEmitter, IslandEmitter } from './types.js';\n\n/**\n * Emitters registered by other packages (e.g. `@astroscope/i18n`). Keyed on\n * `globalThis` via `Symbol.for` so the vite-runner and native module instances share\n * one registry — same pattern as the log store.\n */\nconst ISLAND_REGISTRY = Symbol.for('@astroscope/node.islandEmitters');\nconst DOCUMENT_REGISTRY = Symbol.for('@astroscope/node.documentEmitters');\n\ntype Scope = { [ISLAND_REGISTRY]?: IslandEmitter[]; [DOCUMENT_REGISTRY]?: DocumentEmitter[] };\n\nfunction islandRegistry(): IslandEmitter[] {\n  const scope = globalThis as Scope;\n\n  return (scope[ISLAND_REGISTRY] ??= []);\n}\n\nfunction documentRegistry(): DocumentEmitter[] {\n  const scope = globalThis as Scope;\n\n  return (scope[DOCUMENT_REGISTRY] ??= []);\n}\n\n/**\n * Register an emitter that contributes preload links and/or attributes for every\n * island the islands middleware sees. Registration is process-wide — call it once\n * during boot or module initialization, not per request.\n */\nexport function registerIslandEmitter(emitter: IslandEmitter): void {\n  islandRegistry().push(emitter);\n}\n\nexport function getIslandEmitters(): readonly IslandEmitter[] {\n  return islandRegistry();\n}\n\n/**\n * Register an emitter that contributes document-level content (a head bootstrap\n * script, a stream-end script) for every html page response the islands middleware\n * streams. Registration is process-wide — call it once during boot or module\n * initialization, not per request.\n */\nexport function registerDocumentEmitter(emitter: DocumentEmitter): void {\n  documentRegistry().push(emitter);\n}\n\nexport function getDocumentEmitters(): readonly DocumentEmitter[] {\n  return documentRegistry();\n}\n"],"mappings":";;;;;;AAOA,MAAM,kBAAkB,OAAO,IAAI,iCAAiC;AACpE,MAAM,oBAAoB,OAAO,IAAI,mCAAmC;AAIxE,SAAS,iBAAkC;CACzC,MAAM,QAAQ;CAEd,OAAQ,MAAM,qBAAqB,CAAC;AACtC;AAEA,SAAS,mBAAsC;CAC7C,MAAM,QAAQ;CAEd,OAAQ,MAAM,uBAAuB,CAAC;AACxC;;;;;;AAOA,SAAgB,sBAAsB,SAA8B;CAClE,eAAe,CAAC,CAAC,KAAK,OAAO;AAC/B;AAEA,SAAgB,oBAA8C;CAC5D,OAAO,eAAe;AACxB;;;;;;;AAQA,SAAgB,wBAAwB,SAAgC;CACtE,iBAAiB,CAAC,CAAC,KAAK,OAAO;AACjC;AAEA,SAAgB,sBAAkD;CAChE,OAAO,iBAAiB;AAC1B"}

package/dist/image-endpoint.d.ts

@@ -0,0 +1,11 @@
+import { APIRoute } from "astro";
+//#region src/image/endpoint-disabled.d.ts
+/**
+ * Replaces the `/_image` endpoint when image processing is disabled. As far as
+ * clients are concerned the endpoint does not exist, so requests answer 404 —
+ * a 400 would advertise a live processing surface behind the route.
+ */
+declare const GET: APIRoute;
+//#endregion
+export { GET };
+//# sourceMappingURL=image-endpoint.d.ts.map

package/dist/image-endpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-endpoint.d.ts","names":[],"sources":["../src/image/endpoint-disabled.ts"],"mappings":";;;;;;;cAOa,KAAK"}

package/dist/image-endpoint.js

@@ -0,0 +1,11 @@
+//#region src/image/endpoint-disabled.ts
+/**
+* Replaces the `/_image` endpoint when image processing is disabled. As far as
+* clients are concerned the endpoint does not exist, so requests answer 404 —
+* a 400 would advertise a live processing surface behind the route.
+*/
+const GET = () => new Response(null, { status: 404 });
+//#endregion
+export { GET };
+
+//# sourceMappingURL=image-endpoint.js.map

package/dist/image-endpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-endpoint.js","names":[],"sources":["../src/image/endpoint-disabled.ts"],"sourcesContent":["import type { APIRoute } from 'astro';\n\n/**\n * Replaces the `/_image` endpoint when image processing is disabled. As far as\n * clients are concerned the endpoint does not exist, so requests answer 404 —\n * a 400 would advertise a live processing surface behind the route.\n */\nexport const GET: APIRoute = () => new Response(null, { status: 404 });\n"],"mappings":";;;;;;AAOA,MAAa,YAAsB,IAAI,SAAS,MAAM,EAAE,QAAQ,IAAI,CAAC"}

package/dist/image-service.d.ts

@@ -0,0 +1,15 @@
+import { LocalImageService } from "astro";
+//#region src/image/no-image-service.d.ts
+/**
+ * The service injected for `imageService: 'off'` (and `'auto'` without a
+ * configured `image.service`). Any `astro:assets` use — `<Image>`,
+ * `<Picture>`, `getImage()`, markdown or content-collection images — throws
+ * the explanation above at render/build time, so disabled processing fails
+ * loudly instead of silently serving unoptimized bytes. `/_image` itself is
+ * replaced by the 404 endpoint in `endpoint-disabled.ts`. The module is only
+ * ever imported on first `astro:assets` use.
+ */
+declare const service: LocalImageService;
+//#endregion
+export { service as default };
+//# sourceMappingURL=image-service.d.ts.map

package/dist/image-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-service.d.ts","names":[],"sources":["../src/image/no-image-service.ts"],"mappings":";;;;;;;;;;;cAqBM,SAAS"}

package/dist/image-service.js

@@ -0,0 +1,28 @@
+//#region src/image/no-image-service.ts
+const MESSAGE = "[@astroscope/node] image processing is disabled: astro's on-demand `/_image` endpoint is a decode+encode amplification surface, so the adapter turns it off unless a service is configured. Serve pre-generated variants with a plain <img>, or opt in via the adapter option `imageService: 'on'` (astro's sharp service) or an explicit `image.service` in the astro config.";
+function disabled() {
+	throw new Error(MESSAGE);
+}
+/**
+* The service injected for `imageService: 'off'` (and `'auto'` without a
+* configured `image.service`). Any `astro:assets` use — `<Image>`,
+* `<Picture>`, `getImage()`, markdown or content-collection images — throws
+* the explanation above at render/build time, so disabled processing fails
+* loudly instead of silently serving unoptimized bytes. `/_image` itself is
+* replaced by the 404 endpoint in `endpoint-disabled.ts`. The module is only
+* ever imported on first `astro:assets` use.
+*/
+const service = {
+	propertiesToHash: ["src"],
+	validateOptions: disabled,
+	getHTMLAttributes: disabled,
+	getSrcSet: disabled,
+	getURL: disabled,
+	getRemoteSize: disabled,
+	parseURL: () => void 0,
+	transform: disabled
+};
+//#endregion
+export { service as default };
+
+//# sourceMappingURL=image-service.js.map

package/dist/image-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-service.js","names":[],"sources":["../src/image/no-image-service.ts"],"sourcesContent":["import type { LocalImageService } from 'astro';\n\nconst MESSAGE =\n  \"[@astroscope/node] image processing is disabled: astro's on-demand `/_image` endpoint is a decode+encode \" +\n  'amplification surface, so the adapter turns it off unless a service is configured. Serve pre-generated ' +\n  \"variants with a plain <img>, or opt in via the adapter option `imageService: 'on'` (astro's sharp service) \" +\n  'or an explicit `image.service` in the astro config.';\n\nfunction disabled(): never {\n  throw new Error(MESSAGE);\n}\n\n/**\n * The service injected for `imageService: 'off'` (and `'auto'` without a\n * configured `image.service`). Any `astro:assets` use — `<Image>`,\n * `<Picture>`, `getImage()`, markdown or content-collection images — throws\n * the explanation above at render/build time, so disabled processing fails\n * loudly instead of silently serving unoptimized bytes. `/_image` itself is\n * replaced by the 404 endpoint in `endpoint-disabled.ts`. The module is only\n * ever imported on first `astro:assets` use.\n */\nconst service: LocalImageService = {\n  propertiesToHash: ['src'],\n  validateOptions: disabled,\n  getHTMLAttributes: disabled,\n  getSrcSet: disabled,\n  getURL: disabled,\n  getRemoteSize: disabled,\n  parseURL: () => undefined,\n  transform: disabled,\n};\n\nexport default service;\n"],"mappings":";AAEA,MAAM,UACJ;AAKF,SAAS,WAAkB;CACzB,MAAM,IAAI,MAAM,OAAO;AACzB;;;;;;;;;;AAWA,MAAM,UAA6B;CACjC,kBAAkB,CAAC,KAAK;CACxB,iBAAiB;CACjB,mBAAmB;CACnB,WAAW;CACX,QAAQ;CACR,eAAe;CACf,gBAAgB,KAAA;CAChB,WAAW;AACb"}

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { r as ExcludePattern } from "./excludes-BDiE3eyp.js";
 import "./construct-BGlPfWMF.js";
+import { c as IslandEmitter, i as registerIslandEmitter, l as IslandInfo, s as IslandEmission, t as getRequestRouteData } from "./route-store-DtY3uvLf.js";
 import { t as BootContext } from "./types-D0uMBi2M.js";
 import { n as BootEventName, t as BootEventHandler } from "./events-u7J3ezJR.js";
 import { AstroIntegration } from "astro";
@@ -130,6 +131,28 @@ interface NodeOptions {
   csrf?: {
     exclude?: ExcludePattern[] | undefined;
   } | false | undefined;
+  /**
+   * Island dependency preloading: streams html responses through a rewriter that
+   * emits `modulepreload` links (and preload data for deferred islands, fired by a
+   * small gate runtime with the directive's own scheduling) for each island's
+   * chunk closure, removing the hydration request waterfall. Production-only —
+   * dev has no chunk graph. Set to `false` to disable the preloading; the islands
+   * middleware itself stays active for packages that registered island or document
+   * emitters (e.g. `@astroscope/i18n`, `@astroscope/wormhole`).
+   */
+  islands?: false | undefined;
+  /**
+   * On-demand image processing (`astro:assets` through the `/_image`
+   * endpoint). `'auto'`: enabled only when the astro config sets
+   * `image.service` itself; otherwise processing is disabled — any
+   * `<Image>`/`getImage()` use throws with an explanation and `/_image`
+   * answers 404, as if the endpoint did not exist. `'on'` keeps astro's default sharp service; `'off'` disables
+   * even over an explicit `image.service`. Off unless configured because the
+   * sharp endpoint is an on-demand decode+encode amplification surface most
+   * SSR apps (serving pre-generated variants) don't need.
+   * @default 'auto'
+   */
+  imageService?: 'on' | 'off' | 'auto' | undefined;
   /**
    * Maximum request body size in bytes. `0` or `Infinity` disables the limit.
    * @default 1073741824 (1 GiB)
@@ -163,5 +186,5 @@ interface BootModule {
   onShutdown?: ((context: BootContext) => Promise<void> | void) | undefined;
 }
 //#endregion
-export { type BootContext, type BootEventHandler, type BootEventName, type BootModule, type HealthProbePaths, type InstrumentationContext, type NodeBootOptions, type NodeHealthOptions, type NodeLoggingOptions, type NodeOptions, type NodePrometheusOptions, type NodeTelemetryOptions, node as default };
+export { type BootContext, type BootEventHandler, type BootEventName, type BootModule, type HealthProbePaths, type InstrumentationContext, type IslandEmission, type IslandEmitter, type IslandInfo, type NodeBootOptions, type NodeHealthOptions, type NodeLoggingOptions, type NodeOptions, type NodePrometheusOptions, type NodeTelemetryOptions, node as default, getRequestRouteData, registerIslandEmitter };
 //# sourceMappingURL=index.d.ts.map

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;;;;;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"}
+{"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;;;;;;;;;;;EAWnB;;;;;;;;;;;;EAaA;;;;;EAMA;;;;;;EAOA;;;;;;;;;;iBC5GsB,KAAK,UAAS,cAAmB;;;UClExC;EACf;;;;UCJe;EACf,cAAc,SAAS,gBAAgB;EACvC,eAAe,SAAS,gBAAgB"}

package/dist/index.js

@@ -3,10 +3,13 @@ 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
@@ -575,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
 /**
@@ -669,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()
 			};
 		}
 	};
@@ -732,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 : [];
@@ -755,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);
@@ -787,6 +870,8 @@ function node(options = {}) {
 					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" },
@@ -794,13 +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(),
 						{
@@ -824,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 },
@@ -888,6 +984,18 @@ 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 { stripBuildPaths } = await import("./strip-build-paths-C6eb1QdG.js");
+				const stripped = stripBuildPaths(fileURLToPath(astroConfig.build.server), fileURLToPath(astroConfig.root));
+				if (stripped > 0) logger.info(`build machine paths stripped from ${stripped} server file(s)`);
 				const { compressClientDir } = await import("./compress-B11aeRHQ.js");
 				await compressClientDir(fileURLToPath(astroConfig.build.client), logger);
 			}
@@ -895,6 +1003,6 @@ function node(options = {}) {
 	};
 }
 //#endregion
-export { node as default };
+export { node as default, getRequestRouteData, registerIslandEmitter };
 
 //# sourceMappingURL=index.js.map