@astroscope/node 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 entwico GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,286 @@
+# @astroscope/node
+
+Opinionated, cloud-friendly Node adapter for Astro: boot lifecycle, health probes, request logging, telemetry, CSRF and static serving run as plain code around `server.listen()`.
+
+## What it does
+
+- **Boot lifecycle** — `onStartup` runs before the port opens, `onShutdown` after in-flight requests drain (`src/boot.ts`)
+- **Warmup** — pages, middleware and actions are loaded in parallel with startup and awaited before `listen()`
+- **Health probes** — Kubernetes-style liveness/readiness on a separate port, with registrable checks
+- **Request logging** — pino at the native handler: real status code, response size, ttfb, aborted connections, static responses included
+- **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
+- **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
+- **Dev restart machinery** — changes to the boot file or entry seams restart the dev server behind a holding page
+
+## What it does NOT do — beware
+
+The adapter assumes a container behind a load balancer / reverse proxy (Kubernetes, Docker + ingress). Outside that setup, several defaults are wrong for you:
+
+- **No TLS.** Plain HTTP only — terminate TLS at the ingress.
+- **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'`).
+- **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`.
+
+## Usage
+
+```typescript
+// astro.config.ts
+import node from '@astroscope/node';
+import { defineConfig } from 'astro/config';
+
+export default defineConfig({
+  output: 'server',
+  adapter: node(),
+});
+```
+
+```typescript
+// src/boot.ts — picked up automatically (or src/boot/index.ts)
+import type { BootContext } from '@astroscope/node';
+
+export async function onStartup(context: BootContext) {
+  // connect to databases, warm caches, schedule timers
+}
+
+export async function onShutdown() {
+  // close connections, clear timers
+}
+```
+
+`astro preview` runs the full production path (boot, warmup, health, static serving).
+
+In dev, the boot file and the entry files below run through the adapter's own watch/restart machinery: changes to the boot file, its dependency graph, or the config/log files restart the dev server behind a holding page that releases when the new generation is ready.
+
+### Boot context access
+
+Anywhere in server code (including libraries), `getBootContext()` returns the running server's `BootContext` — or `undefined` when no @astroscope/node server has booted in the process (unit tests, one-off scripts). Libraries can use it to adapt to dev mode without making consumers thread the flag through:
+
+```typescript
+import { getBootContext } from '@astroscope/node/boot';
+
+const dev = getBootContext()?.dev ?? false;
+```
+
+It is stamped before the platform entry files and the boot lifecycle run, in both prod and dev (re-stamped per dev restart generation).
+
+## Platform entry files
+
+Besides `src/boot.ts`, three more files are picked up automatically when they exist. In production they run in this order inside `startServer()`, before anything else; in dev they re-run per restart generation (instrumentation only once per process):
+
+```
+env loading → src/config.ts → src/instrumentation.ts → src/log.ts → boot → warmup → listen
+```
+
+**Env loading** (platform, position −1): `CONFIG_PATH` env var → `./.env` → none. Existing process env vars win; each outcome is logged.
+
+**`src/config.ts`** — schema + load (e.g. @entwico/zod-conf), nothing else; validation runs at import. On failure: in production the buffered logs are dumped to the console with the error and the process exits 1; in dev the boot gate keeps the holding page up with the error.
+
+```typescript
+// src/config.ts
+import { conf } from '@entwico/zod-conf';
+import { z } from 'zod';
+
+export const config = conf(z.object({ MONGO_URL: z.string() }));
+```
+
+**`src/instrumentation.ts`** — extra instrumentation only (the standard bundle is a platform default, see Telemetry). Loaded once per process — dev restarts are in-process, so changes here need a full dev-server restart.
+
+```typescript
+// src/instrumentation.ts
+import type { InstrumentationContext } from '@astroscope/node';
+
+export function register(ctx: InstrumentationContext) {
+  // register additional instrumentations, processors, exporters
+}
+```
+
+**`src/log.ts`** — pino logger *options* (or a factory), never a logger instance. The platform constructs the logger itself, after instrumentation, and adds a mixin that stamps `trace_id`/`span_id`/`trace_flags` onto every entry when a span is active.
+
+```typescript
+// src/log.ts
+import type { LoggerOptionsFactory } from '@astroscope/node/log';
+
+const factory: LoggerOptionsFactory = ({ dev }) => ({
+  level: dev ? 'debug' : 'info',
+});
+
+export default factory;
+```
+
+## Logging
+
+The `log` proxy is request-aware: inside a request its entries carry the request bindings (`reqId`, `req`), outside they go to the root logger.
+
+```typescript
+import { log } from '@astroscope/node/log';
+
+log.info('handling request');
+log.info({ userId: 123 }, 'user logged in');
+log.error(err, 'operation failed');
+
+const dbLog = log.child({ component: 'db' });
+```
+
+Entries logged before the logger is constructed (env loading, config, instrumentation) are buffered (cap 100) and replayed once construction completes — the original timestamp is kept as a `bufferedTime` field. If startup dies before the logger exists, the buffer is dumped to the console together with the error.
+
+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.
+
+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
+
+`node({ telemetry })` ships the standard bundle: NodeSDK, fetch instrumentation via undici (diagnostics-channel based — no `--import` needed), Node runtime + host metrics, and a Prometheus reader on `0.0.0.0:9464`. **Prod: on by default. Dev: off by default** (opt in with `telemetry: { dev: true }`).
+
+- server spans start at the native handler with W3C context extraction; the route pattern and span name are enriched by the internal middleware
+- request metrics: `http.server.request.duration`, `http.server.active_requests`, `astro.action.duration`; fetch metrics come from the undici instrumentation
+- the boot lifecycle gets `startup` (with `boot`/`warmup`/`listen` children) and `shutdown` (with `drain`/`onShutdown`) spans
+- trace exporters are driven by the standard `OTEL_*` env vars; without a configured OTLP endpoint, trace exporting defaults to `none` (no failing localhost exports)
+- `OTEL_SDK_DISABLED=true` turns the SDK off entirely
+
+There is no helper for tracing server-render sections: measuring a subtree's render would require buffering it, which disables streaming. Wrap frontmatter awaits with `tracer.startActiveSpan()` instead — that's where the time lives, and it nests under the request span without touching the stream.
+
+## Health checks
+
+Register checks from anywhere in server code — typically `onStartup`:
+
+```typescript
+import { registerHealthCheck } from '@astroscope/node/health';
+
+export async function onStartup() {
+  const db = await connectMongo();
+
+  registerHealthCheck({ name: 'mongo', check: () => db.ping() });
+}
+```
+
+- probes flip in order: live during startup, ready only after `listen()`, draining begins the moment a shutdown signal arrives
+- a check fails by throwing or returning `{ status: 'unhealthy' }`; failing required checks turn `readyz` unhealthy (`optional: true` checks don't affect it, `timeout` defaults to 5s)
+- `registerHealthCheck` returns an unregister function, but cleanup is optional: checks still registered after `onShutdown` are removed automatically
+- when no health runtime is active (dev mode, `health: false`), registration is a no-op — no dev/prod branching needed in boot files
+
+## Native mounts
+
+For Node libraries that need the real `(req, res)` — `oidc-provider`'s `callback()`, ACME challenge handlers — mount them on the adapter's server instead of faking Node objects inside astro middleware:
+
+```typescript
+// src/boot.ts
+import { mountNativeHandler } from '@astroscope/node/native';
+
+export function onStartup() {
+  mountNativeHandler({ prefix: '/oidc', name: 'oidc' }, getOidcProvider().callback());
+}
+```
+
+- the handler owns the response completely: matched requests are dispatched before static serving and never reach astro middleware or rendering — machine endpoints (`/token`, `/introspection`) need no csrf exclusions because they never meet the csrf middleware
+- the handler gets the real request and response: streaming bodies, `socket.remoteAddress`, set-cookie arrays
+- requests stay inside request logging and tracing; `name` becomes the route label for logs, metrics and span names
+- identical in dev — the same registry is dispatched at the connect level, so there is no fake-host-header or dev/prod drift
+- matching: `prefix` (segment-aware, longest wins) or a `match(req)` predicate consulted after prefixes, in registration order
+- returns an unregister function; mounts are cleared automatically after `onShutdown` (and between dev restart generations)
+- handler errors are logged and answered with a 500 (unless the handler already sent headers)
+
+## Exclude patterns
+
+`@astroscope/node/excludes` ships the shared exclude-pattern vocabulary for middlewares. Matching itself comes from [`@entwico/dash/match`](https://github.com/entwico/dash); `ExcludePattern` is the serializable subset of dash's `StringPattern` (`exact` / `prefix` / `suffix` / `includes` / `pattern` — no matcher functions, since adapter options cross a virtual-module boundary).
+
+```typescript
+import { RECOMMENDED_EXCLUDES, shouldExclude, withExcluded } from '@astroscope/node/excludes';
+
+// pre-defined sets: DEV_EXCLUDES (vite dev paths), ASTRO_STATIC_EXCLUDES (/_astro/, /_image),
+// STATIC_EXCLUDES (favicon, robots.txt, ...), RECOMMENDED_EXCLUDES (dev + astro internals)
+
+// in your own middleware
+if (shouldExclude(ctx, [...RECOMMENDED_EXCLUDES, { exact: '/health' }])) return next();
+
+// or wrap a third-party middleware without built-in exclude support
+export const onRequest = withExcluded(someExternalMiddleware(), RECOMMENDED_EXCLUDES);
+```
+
+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).
+
+## 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.
+
+## Embedded build tweaks
+
+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
+
+## Options
+
+```typescript
+node({
+  // boot lifecycle; false disables it. Skipped automatically when no boot file exists.
+  boot: {
+    entry: 'src/boot.ts', // default: src/boot.ts or src/boot/index.ts
+    watch: true,          // dev: restart the dev server on boot-dependency changes
+  },
+
+  // Kubernetes-style probes on a separate port. Enabled by default in
+  // production (never active in dev); false disables.
+  health: {
+    host: '0.0.0.0', // falls back to HEALTH_HOST env, then 0.0.0.0 (kubelet probes hit the pod IP)
+    port: 9090,      // falls back to HEALTH_PORT env, then 9090
+  },
+
+  // CSRF protection (origin check for POST/PUT/PATCH/DELETE with exclusions).
+  // Enabled by default; false keeps astro's built-in checkOrigin instead.
+  csrf: {
+    exclude: [{ exact: '/api/auth/backchannel-logout' }],
+  },
+
+  // request logging at the native handler. Enabled by default in production;
+  // false disables it (the log proxy keeps working).
+  logging: {
+    exclude: [{ prefix: '/internal/' }], // replaces RECOMMENDED_EXCLUDES + STATIC_EXCLUDES
+    extended: false,                     // query/headers/client address (may capture sensitive data)
+    dev: false,                          // also log requests in dev (astro narrates them already)
+  },
+
+  // platform telemetry. Enabled by default in production, off in dev; false disables.
+  telemetry: {
+    exclude: [{ prefix: '/internal/' }], // replaces RECOMMENDED_EXCLUDES + STATIC_EXCLUDES
+    prometheus: { host: '0.0.0.0', port: 9464 }, // false disables the reader
+    dev: false,                          // start the SDK in dev too (once per process)
+  },
+
+  bodySizeLimit: 1024 * 1024 * 1024, // request body limit in bytes
+  shutdownTimeout: 10_000,           // ms to wait for in-flight requests on shutdown
+});
+```
+
+## Environment variables
+
+| Variable | Effect |
+|----------|--------|
+| `HOST` / `PORT` | Override the listen address at runtime |
+| `HEALTH_HOST` / `HEALTH_PORT` | Override the health probe address (when not set in options) |
+| `CONFIG_PATH` | Env file to load at startup (falls back to `./.env`) |
+| `OTEL_EXPORTER_PROMETHEUS_HOST` / `OTEL_EXPORTER_PROMETHEUS_PORT` | Override the Prometheus reader address |
+| `OTEL_SDK_DISABLED=true` | Disable the telemetry SDK entirely |
+| standard `OTEL_*` | Exporter/resource configuration (e.g. `OTEL_EXPORTER_OTLP_ENDPOINT`, `OTEL_SERVICE_NAME`) |
+| `ASTROSCOPE_NODE_AUTOSTART=disabled` | Build the entry without starting the server (exports `startServer()`) |
+
+## Shutdown sequence
+
+On SIGTERM/SIGINT:
+
+1. readiness probe starts failing, `draining` is logged
+2. the server stops accepting connections and waits up to `shutdownTimeout` for in-flight requests
+3. `onShutdown` runs
+4. `shutdown complete { drainMs }` is logged, the health server stops, telemetry flushes, the process exits with code 0
+
+## License
+
+MIT

package/dist/boot.d.ts

@@ -0,0 +1,15 @@
+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
+ * no @astroscope/node server has booted (unit tests, one-off scripts).
+ *
+ * Available from the platform seams (`src/config.ts` and later) onwards;
+ * libraries can use it to adapt behavior to dev mode without requiring
+ * consumers to thread the flag through.
+ */
+declare function getBootContext(): BootContext | undefined;
+//#endregion
+export { type BootContext, getBootContext };
+//# sourceMappingURL=boot.d.ts.map

package/dist/boot.d.ts.map

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

package/dist/boot.js

@@ -0,0 +1,2 @@
+import { t as getBootContext } from "./context-Bkg-FnnQ.js";
+export { getBootContext };

package/dist/compress-B11aeRHQ.js

@@ -0,0 +1,58 @@
+import { t as COMPRESSIBLE } from "./mime-C_GwZovh.js";
+import path from "node:path";
+import { readFile, readdir, writeFile } from "node:fs/promises";
+import { promisify } from "node:util";
+import { brotliCompress, constants, gzip } from "node:zlib";
+//#region src/compress/compress.ts
+const brotli = promisify(brotliCompress);
+const gzip$1 = promisify(gzip);
+/**
+* Pre-compress every compressible file in the client build dir at maximum
+* quality, writing `.br`/`.gz` variants next to the originals. Variants that
+* don't shrink the file are skipped. The static handler negotiates
+* `Accept-Encoding` against these at request time.
+*/
+async function compressClientDir(clientDir, logger) {
+	const files = await walkDir(clientDir);
+	let compressed = 0;
+	let savedBytes = 0;
+	let totalRaw = 0;
+	await Promise.all(files.map(async (filePath) => {
+		if (!COMPRESSIBLE.has(path.extname(filePath))) return;
+		const raw = await readFile(filePath);
+		if (!raw.byteLength) return;
+		const [brBuf, gzBuf] = await Promise.all([brotli(raw, { params: { [constants.BROTLI_PARAM_QUALITY]: constants.BROTLI_MAX_QUALITY } }), gzip$1(raw, { level: 9 })]);
+		if (brBuf.byteLength < raw.byteLength) await writeFile(`${filePath}.br`, brBuf);
+		if (gzBuf.byteLength < raw.byteLength) await writeFile(`${filePath}.gz`, gzBuf);
+		compressed++;
+		totalRaw += raw.byteLength;
+		const best = Math.min(brBuf.byteLength < raw.byteLength ? brBuf.byteLength : raw.byteLength, gzBuf.byteLength < raw.byteLength ? gzBuf.byteLength : raw.byteLength);
+		savedBytes += raw.byteLength - best;
+	}));
+	const savedPercent = totalRaw > 0 ? Math.round(savedBytes / totalRaw * 100) : 0;
+	logger.info(`${compressed} files compressed, saved up to ${formatBytes(savedBytes)} (${savedPercent}%)`);
+}
+async function walkDir(dir) {
+	return (await readdir(dir, {
+		withFileTypes: true,
+		recursive: true
+	})).filter((e) => e.isFile()).map((e) => path.join(e.parentPath, e.name));
+}
+const UNITS = [
+	"B",
+	"KB",
+	"MB",
+	"GB"
+];
+function formatBytes(bytes) {
+	let value = bytes;
+	for (const unit of UNITS) {
+		if (value < 1024 || unit === UNITS[UNITS.length - 1]) return unit === "B" ? `${value} ${unit}` : `${value.toFixed(1)} ${unit}`;
+		value /= 1024;
+	}
+	return `${value.toFixed(1)} GB`;
+}
+//#endregion
+export { compressClientDir };
+
+//# sourceMappingURL=compress-B11aeRHQ.js.map

package/dist/compress-B11aeRHQ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compress-B11aeRHQ.js","names":["gzip","_gzip"],"sources":["../src/compress/compress.ts"],"sourcesContent":["import { readFile, readdir, writeFile } from 'node:fs/promises';\nimport path from 'node:path';\nimport { promisify } from 'node:util';\nimport { gzip as _gzip, brotliCompress, constants } from 'node:zlib';\nimport type { AstroIntegrationLogger } from 'astro';\nimport { COMPRESSIBLE } from '../server/mime.js';\n\nconst brotli = promisify(brotliCompress);\nconst gzip = promisify(_gzip);\n\n/**\n * Pre-compress every compressible file in the client build dir at maximum\n * quality, writing `.br`/`.gz` variants next to the originals. Variants that\n * don't shrink the file are skipped. The static handler negotiates\n * `Accept-Encoding` against these at request time.\n */\nexport async function compressClientDir(clientDir: string, logger: AstroIntegrationLogger): Promise<void> {\n  const files = await walkDir(clientDir);\n\n  let compressed = 0;\n  let savedBytes = 0;\n  let totalRaw = 0;\n\n  await Promise.all(\n    files.map(async (filePath) => {\n      if (!COMPRESSIBLE.has(path.extname(filePath))) return;\n\n      const raw = await readFile(filePath);\n\n      if (!raw.byteLength) return;\n\n      const [brBuf, gzBuf] = await Promise.all([\n        brotli(raw, { params: { [constants.BROTLI_PARAM_QUALITY]: constants.BROTLI_MAX_QUALITY } }),\n        gzip(raw, { level: 9 }),\n      ]);\n\n      if (brBuf.byteLength < raw.byteLength) {\n        await writeFile(`${filePath}.br`, brBuf);\n      }\n\n      if (gzBuf.byteLength < raw.byteLength) {\n        await writeFile(`${filePath}.gz`, gzBuf);\n      }\n\n      compressed++;\n      totalRaw += raw.byteLength;\n\n      const best = Math.min(\n        brBuf.byteLength < raw.byteLength ? brBuf.byteLength : raw.byteLength,\n        gzBuf.byteLength < raw.byteLength ? gzBuf.byteLength : raw.byteLength,\n      );\n\n      savedBytes += raw.byteLength - best;\n    }),\n  );\n\n  const savedPercent = totalRaw > 0 ? Math.round((savedBytes / totalRaw) * 100) : 0;\n\n  logger.info(`${compressed} files compressed, saved up to ${formatBytes(savedBytes)} (${savedPercent}%)`);\n}\n\nasync function walkDir(dir: string): Promise<string[]> {\n  const entries = await readdir(dir, { withFileTypes: true, recursive: true });\n\n  return entries.filter((e) => e.isFile()).map((e) => path.join(e.parentPath, e.name));\n}\n\nconst UNITS = ['B', 'KB', 'MB', 'GB'];\n\nfunction formatBytes(bytes: number): string {\n  let value = bytes;\n\n  for (const unit of UNITS) {\n    if (value < 1024 || unit === UNITS[UNITS.length - 1]) {\n      return unit === 'B' ? `${value} ${unit}` : `${value.toFixed(1)} ${unit}`;\n    }\n\n    value /= 1024;\n  }\n\n  return `${value.toFixed(1)} GB`;\n}\n"],"mappings":";;;;;;AAOA,MAAM,SAAS,UAAU,cAAc;AACvC,MAAMA,SAAO,UAAUC,IAAK;;;;;;;AAQ5B,eAAsB,kBAAkB,WAAmB,QAA+C;CACxG,MAAM,QAAQ,MAAM,QAAQ,SAAS;CAErC,IAAI,aAAa;CACjB,IAAI,aAAa;CACjB,IAAI,WAAW;CAEf,MAAM,QAAQ,IACZ,MAAM,IAAI,OAAO,aAAa;EAC5B,IAAI,CAAC,aAAa,IAAI,KAAK,QAAQ,QAAQ,CAAC,GAAG;EAE/C,MAAM,MAAM,MAAM,SAAS,QAAQ;EAEnC,IAAI,CAAC,IAAI,YAAY;EAErB,MAAM,CAAC,OAAO,SAAS,MAAM,QAAQ,IAAI,CACvC,OAAO,KAAK,EAAE,QAAQ,GAAG,UAAU,uBAAuB,UAAU,mBAAmB,EAAE,CAAC,GAC1FD,OAAK,KAAK,EAAE,OAAO,EAAE,CAAC,CACxB,CAAC;EAED,IAAI,MAAM,aAAa,IAAI,YACzB,MAAM,UAAU,GAAG,SAAS,MAAM,KAAK;EAGzC,IAAI,MAAM,aAAa,IAAI,YACzB,MAAM,UAAU,GAAG,SAAS,MAAM,KAAK;EAGzC;EACA,YAAY,IAAI;EAEhB,MAAM,OAAO,KAAK,IAChB,MAAM,aAAa,IAAI,aAAa,MAAM,aAAa,IAAI,YAC3D,MAAM,aAAa,IAAI,aAAa,MAAM,aAAa,IAAI,UAC7D;EAEA,cAAc,IAAI,aAAa;CACjC,CAAC,CACH;CAEA,MAAM,eAAe,WAAW,IAAI,KAAK,MAAO,aAAa,WAAY,GAAG,IAAI;CAEhF,OAAO,KAAK,GAAG,WAAW,iCAAiC,YAAY,UAAU,EAAE,IAAI,aAAa,GAAG;AACzG;AAEA,eAAe,QAAQ,KAAgC;CAGrD,QAAO,MAFe,QAAQ,KAAK;EAAE,eAAe;EAAM,WAAW;CAAK,CAAC,EAAA,CAE5D,QAAQ,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,MAAM,KAAK,KAAK,EAAE,YAAY,EAAE,IAAI,CAAC;AACrF;AAEA,MAAM,QAAQ;CAAC;CAAK;CAAM;CAAM;AAAI;AAEpC,SAAS,YAAY,OAAuB;CAC1C,IAAI,QAAQ;CAEZ,KAAK,MAAM,QAAQ,OAAO;EACxB,IAAI,QAAQ,QAAQ,SAAS,MAAM,MAAM,SAAS,IAChD,OAAO,SAAS,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,QAAQ,CAAC,EAAE,GAAG;EAGpE,SAAS;CACX;CAEA,OAAO,GAAG,MAAM,QAAQ,CAAC,EAAE;AAC7B"}

package/dist/construct-DgB-jR0a.d.ts

@@ -0,0 +1,14 @@
+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
+ * producing them. Never a logger instance — the platform constructs the
+ * logger itself (after instrumentation, so trace correlation works).
+ */
+type LoggerOptionsFactory = LoggerOptions | ((ctx: {
+  dev: boolean;
+}) => LoggerOptions | Promise<LoggerOptions>);
+//#endregion
+export { LoggerOptionsFactory as t };
+//# sourceMappingURL=construct-DgB-jR0a.d.ts.map

package/dist/construct-DgB-jR0a.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"construct-DgB-jR0a.d.ts","names":[],"sources":["../src/observability/log/construct.ts"],"mappings":";;;;;AASA;;;KAAY,oBAAA,GAAuB,aAAA,KAAkB,GAAA;EAAO,GAAA;AAAA,MAAmB,aAAA,GAAgB,OAAA,CAAQ,aAAA"}

package/dist/context-Bkg-FnnQ.js

@@ -0,0 +1,20 @@
+//#region src/lifecycle/context.ts
+const STORE_KEY = Symbol.for("@astroscope/node/boot-context");
+function setBootContext(context) {
+	globalThis[STORE_KEY] = context;
+}
+/**
+* The boot context of the server running in this process, or `undefined` when
+* no @astroscope/node server has booted (unit tests, one-off scripts).
+*
+* Available from the platform seams (`src/config.ts` and later) onwards;
+* libraries can use it to adapt behavior to dev mode without requiring
+* consumers to thread the flag through.
+*/
+function getBootContext() {
+	return globalThis[STORE_KEY];
+}
+//#endregion
+export { setBootContext as n, getBootContext as t };
+
+//# sourceMappingURL=context-Bkg-FnnQ.js.map

package/dist/context-Bkg-FnnQ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-Bkg-FnnQ.js","names":[],"sources":["../src/lifecycle/context.ts"],"sourcesContent":["import type { BootContext } from './types.js';\n\n// keyed on globalThis via Symbol.for so the vite-runner and native module instances share it\nconst STORE_KEY = Symbol.for('@astroscope/node/boot-context');\n\nexport function setBootContext(context: BootContext): void {\n  (globalThis as Record<symbol, BootContext | undefined>)[STORE_KEY] = context;\n}\n\n/**\n * The boot context of the server running in this process, or `undefined` when\n * no @astroscope/node server has booted (unit tests, one-off scripts).\n *\n * Available from the platform seams (`src/config.ts` and later) onwards;\n * libraries can use it to adapt behavior to dev mode without requiring\n * consumers to thread the flag through.\n */\nexport function getBootContext(): BootContext | undefined {\n  return (globalThis as Record<symbol, BootContext | undefined>)[STORE_KEY];\n}\n"],"mappings":";AAGA,MAAM,YAAY,OAAO,IAAI,+BAA+B;AAE5D,SAAgB,eAAe,SAA4B;CACzD,WAAwD,aAAa;AACvE;;;;;;;;;AAUA,SAAgB,iBAA0C;CACxD,OAAQ,WAAuD;AACjE"}

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

@@ -0,0 +1,5 @@
+//#region src/csrf/middleware-entrypoint.d.ts
+declare const onRequest: import("astro").MiddlewareHandler;
+//#endregion
+export { onRequest };
+//# sourceMappingURL=csrf-middleware-entrypoint.d.ts.map

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

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

package/dist/csrf-middleware-entrypoint.js

@@ -0,0 +1,30 @@
+import { a as shouldExclude } from "./excludes-pE23EbmQ.js";
+import { excludePatterns } from "virtual:@astroscope/node/csrf";
+//#region src/csrf/middleware.ts
+const FORBIDDEN_METHODS = /* @__PURE__ */ new Set([
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE"
+]);
+/**
+* CSRF protection middleware: compares the request's Origin header against
+* `context.url.origin` for state-changing methods. Replaces Astro's built-in
+* `security.checkOrigin`, adding path exclusions.
+*/
+function createCsrfMiddleware(exclude) {
+	return (context, next) => {
+		if (shouldExclude(context, exclude)) return next();
+		if (!FORBIDDEN_METHODS.has(context.request.method)) return next();
+		const origin = context.request.headers.get("origin");
+		if (!origin || origin !== context.url.origin) return new Response(`Cross-site ${context.request.method} request forbidden`, { status: 403 });
+		return next();
+	};
+}
+//#endregion
+//#region src/csrf/middleware-entrypoint.ts
+const onRequest = createCsrfMiddleware(excludePatterns);
+//#endregion
+export { onRequest };
+
+//# sourceMappingURL=csrf-middleware-entrypoint.js.map

package/dist/csrf-middleware-entrypoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"csrf-middleware-entrypoint.js","names":[],"sources":["../src/csrf/middleware.ts","../src/csrf/middleware-entrypoint.ts"],"sourcesContent":["import type { MiddlewareHandler } from 'astro';\nimport { type ExcludePattern, shouldExclude } from '../excludes/excludes.js';\n\nconst FORBIDDEN_METHODS = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);\n\n/**\n * CSRF protection middleware: compares the request's Origin header against\n * `context.url.origin` for state-changing methods. Replaces Astro's built-in\n * `security.checkOrigin`, adding path exclusions.\n */\nexport function createCsrfMiddleware(exclude: ExcludePattern[]): MiddlewareHandler {\n  return (context, next) => {\n    if (shouldExclude(context, exclude)) {\n      return next();\n    }\n\n    if (!FORBIDDEN_METHODS.has(context.request.method)) {\n      return next();\n    }\n\n    const origin = context.request.headers.get('origin');\n\n    if (!origin || origin !== context.url.origin) {\n      return new Response(`Cross-site ${context.request.method} request forbidden`, { status: 403 });\n    }\n\n    return next();\n  };\n}\n","// @ts-expect-error virtual module provided by the integration\nimport { excludePatterns } from 'virtual:@astroscope/node/csrf';\nimport type { ExcludePattern } from '../excludes/excludes.js';\nimport { createCsrfMiddleware } from './middleware.js';\n\nexport const onRequest = createCsrfMiddleware(excludePatterns as ExcludePattern[]);\n"],"mappings":";;;AAGA,MAAM,oCAAoB,IAAI,IAAI;CAAC;CAAQ;CAAO;CAAS;AAAQ,CAAC;;;;;;AAOpE,SAAgB,qBAAqB,SAA8C;CACjF,QAAQ,SAAS,SAAS;EACxB,IAAI,cAAc,SAAS,OAAO,GAChC,OAAO,KAAK;EAGd,IAAI,CAAC,kBAAkB,IAAI,QAAQ,QAAQ,MAAM,GAC/C,OAAO,KAAK;EAGd,MAAM,SAAS,QAAQ,QAAQ,QAAQ,IAAI,QAAQ;EAEnD,IAAI,CAAC,UAAU,WAAW,QAAQ,IAAI,QACpC,OAAO,IAAI,SAAS,cAAc,QAAQ,QAAQ,OAAO,qBAAqB,EAAE,QAAQ,IAAI,CAAC;EAG/F,OAAO,KAAK;CACd;AACF;;;ACvBA,MAAa,YAAY,qBAAqB,eAAmC"}

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

@@ -0,0 +1,15 @@
+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
+ * singletons were torn down mid-render by a dev-server restart) are swallowed
+ * instead of polluting the logs. The request was stamped with the generation
+ * it entered under by the integration's connect middleware; if that doesn't
+ * match the current generation, the error is recorded for an aggregated log
+ * line and a 503 is returned (the client socket is usually gone too).
+ */
+declare const onRequest: MiddlewareHandler;
+//#endregion
+export { onRequest };
+//# sourceMappingURL=dev-middleware-entrypoint.d.ts.map

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

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

package/dist/dev-middleware-entrypoint.js

@@ -0,0 +1,26 @@
+import { i as recordStaleError, n as getCurrentGeneration, t as GEN_HEADER } from "./generation-Bp2IA0jf.js";
+//#region src/dev-mode/middleware-entrypoint.ts
+/**
+* Wrap every request so errors thrown by a stale render (one whose user
+* singletons were torn down mid-render by a dev-server restart) are swallowed
+* instead of polluting the logs. The request was stamped with the generation
+* it entered under by the integration's connect middleware; if that doesn't
+* match the current generation, the error is recorded for an aggregated log
+* line and a 503 is returned (the client socket is usually gone too).
+*/
+const onRequest = async (context, next) => {
+	const stamp = context.request.headers.get(GEN_HEADER);
+	try {
+		return await next();
+	} catch (err) {
+		if (stamp != null && Number(stamp) !== getCurrentGeneration()) {
+			recordStaleError();
+			return new Response(null, { status: 503 });
+		}
+		throw err;
+	}
+};
+//#endregion
+export { onRequest };
+
+//# sourceMappingURL=dev-middleware-entrypoint.js.map

package/dist/dev-middleware-entrypoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-middleware-entrypoint.js","names":[],"sources":["../src/dev-mode/middleware-entrypoint.ts"],"sourcesContent":["import type { MiddlewareHandler } from 'astro';\nimport { GEN_HEADER, getCurrentGeneration, recordStaleError } from './generation.js';\n\n/**\n * Wrap every request so errors thrown by a stale render (one whose user\n * singletons were torn down mid-render by a dev-server restart) are swallowed\n * instead of polluting the logs. The request was stamped with the generation\n * it entered under by the integration's connect middleware; if that doesn't\n * match the current generation, the error is recorded for an aggregated log\n * line and a 503 is returned (the client socket is usually gone too).\n */\nexport const onRequest: MiddlewareHandler = async (context, next) => {\n  const stamp = context.request.headers.get(GEN_HEADER);\n\n  try {\n    return await next();\n  } catch (err) {\n    if (stamp != null && Number(stamp) !== getCurrentGeneration()) {\n      recordStaleError();\n\n      return new Response(null, { status: 503 });\n    }\n\n    throw err;\n  }\n};\n"],"mappings":";;;;;;;;;;AAWA,MAAa,YAA+B,OAAO,SAAS,SAAS;CACnE,MAAM,QAAQ,QAAQ,QAAQ,QAAQ,IAAI,UAAU;CAEpD,IAAI;EACF,OAAO,MAAM,KAAK;CACpB,SAAS,KAAK;EACZ,IAAI,SAAS,QAAQ,OAAO,KAAK,MAAM,qBAAqB,GAAG;GAC7D,iBAAiB;GAEjB,OAAO,IAAI,SAAS,MAAM,EAAE,QAAQ,IAAI,CAAC;EAC3C;EAEA,MAAM;CACR;AACF"}

package/dist/events-CUzQ2_cp.d.ts

@@ -0,0 +1,20 @@
+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;
+/**
+ * Register a handler for a boot lifecycle event.
+ */
+declare function on(event: BootEventName, handler: BootEventHandler): void;
+/**
+ * Remove a previously registered handler.
+ */
+declare function off(event: BootEventName, handler: BootEventHandler): void;
+/**
+ * Emit a boot lifecycle event, running all registered handlers sequentially.
+ */
+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

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

@@ -0,0 +1 @@
+{"version":3,"file":"events-CUzQ2_cp.d.ts","names":[],"sources":["../src/lifecycle/events.ts"],"mappings":";;;KAEY,aAAA;AAAA,KAEA,gBAAA,IAAoB,OAAA,EAAS,WAAA,KAAgB,OAAO;AAFhE;;;AAAA,iBAyBgB,EAAA,CAAG,KAAA,EAAO,aAAA,EAAe,OAAA,EAAS,gBAAgB;AAzBzC;AAEzB;;AAFyB,iBAwCT,GAAA,CAAI,KAAA,EAAO,aAAA,EAAe,OAAA,EAAS,gBAAgB;;;;iBAS7C,IAAA,CAAK,KAAA,EAAO,aAAA,EAAe,OAAA,EAAS,WAAA,GAAc,OAAA"}

package/dist/events-CgoM3Fvu.js

@@ -0,0 +1,39 @@
+//#region src/lifecycle/events.ts
+const STORE_KEY = Symbol.for("@astroscope/node/boot-events");
+function getStore() {
+	const existing = globalThis[STORE_KEY];
+	if (existing) return existing;
+	const store = { listeners: /* @__PURE__ */ new Map() };
+	globalThis[STORE_KEY] = store;
+	return store;
+}
+/**
+* Register a handler for a boot lifecycle event.
+*/
+function on(event, handler) {
+	const store = getStore();
+	let handlers = store.listeners.get(event);
+	if (!handlers) {
+		handlers = /* @__PURE__ */ new Set();
+		store.listeners.set(event, handlers);
+	}
+	handlers.add(handler);
+}
+/**
+* Remove a previously registered handler.
+*/
+function off(event, handler) {
+	getStore().listeners.get(event)?.delete(handler);
+}
+/**
+* Emit a boot lifecycle event, running all registered handlers sequentially.
+*/
+async function emit(event, context) {
+	const handlers = getStore().listeners.get(event);
+	if (!handlers) return;
+	for (const handler of handlers) await handler(context);
+}
+//#endregion
+export { off as n, on as r, emit as t };
+
+//# sourceMappingURL=events-CgoM3Fvu.js.map

package/dist/events-CgoM3Fvu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events-CgoM3Fvu.js","names":[],"sources":["../src/lifecycle/events.ts"],"sourcesContent":["import type { BootContext } from './types.js';\n\nexport type BootEventName = 'beforeOnStartup' | 'afterOnStartup' | 'beforeOnShutdown' | 'afterOnShutdown';\n\nexport type BootEventHandler = (context: BootContext) => Promise<void> | void;\n\nconst STORE_KEY = Symbol.for('@astroscope/node/boot-events');\n\ninterface EventStore {\n  listeners: Map<BootEventName, Set<BootEventHandler>>;\n}\n\nfunction getStore(): EventStore {\n  const existing = (globalThis as Record<symbol, EventStore | undefined>)[STORE_KEY];\n\n  if (existing) return existing;\n\n  const store: EventStore = { listeners: new Map() };\n\n  (globalThis as Record<symbol, EventStore>)[STORE_KEY] = store;\n\n  return store;\n}\n\n/**\n * Register a handler for a boot lifecycle event.\n */\nexport function on(event: BootEventName, handler: BootEventHandler): void {\n  const store = getStore();\n  let handlers = store.listeners.get(event);\n\n  if (!handlers) {\n    handlers = new Set();\n    store.listeners.set(event, handlers);\n  }\n\n  handlers.add(handler);\n}\n\n/**\n * Remove a previously registered handler.\n */\nexport function off(event: BootEventName, handler: BootEventHandler): void {\n  const store = getStore();\n\n  store.listeners.get(event)?.delete(handler);\n}\n\n/**\n * Emit a boot lifecycle event, running all registered handlers sequentially.\n */\nexport async function emit(event: BootEventName, context: BootContext): Promise<void> {\n  const store = getStore();\n  const handlers = store.listeners.get(event);\n\n  if (!handlers) return;\n\n  for (const handler of handlers) {\n    await handler(context);\n  }\n}\n"],"mappings":";AAMA,MAAM,YAAY,OAAO,IAAI,8BAA8B;AAM3D,SAAS,WAAuB;CAC9B,MAAM,WAAY,WAAsD;CAExE,IAAI,UAAU,OAAO;CAErB,MAAM,QAAoB,EAAE,2BAAW,IAAI,IAAI,EAAE;CAEjD,WAA2C,aAAa;CAExD,OAAO;AACT;;;;AAKA,SAAgB,GAAG,OAAsB,SAAiC;CACxE,MAAM,QAAQ,SAAS;CACvB,IAAI,WAAW,MAAM,UAAU,IAAI,KAAK;CAExC,IAAI,CAAC,UAAU;EACb,2BAAW,IAAI,IAAI;EACnB,MAAM,UAAU,IAAI,OAAO,QAAQ;CACrC;CAEA,SAAS,IAAI,OAAO;AACtB;;;;AAKA,SAAgB,IAAI,OAAsB,SAAiC;CAGzE,SAAI,CAAC,CAAC,UAAU,IAAI,KAAK,CAAC,EAAE,OAAO,OAAO;AAC5C;;;;AAKA,eAAsB,KAAK,OAAsB,SAAqC;CAEpF,MAAM,WADQ,SACO,CAAC,CAAC,UAAU,IAAI,KAAK;CAE1C,IAAI,CAAC,UAAU;CAEf,KAAK,MAAM,WAAW,UACpB,MAAM,QAAQ,OAAO;AAEzB"}