@astroscope/node 1.0.0

package/dist/excludes-DLF3A_Cf.d.ts

@@ -0,0 +1,63 @@
+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
+ * subset of dash's `StringPattern` — no matcher functions, since integration
+ * options cross a virtual-module boundary.
+ */
+type ExcludePattern = Exclude<StringPattern, (value: string) => boolean>;
+/**
+ * Vite/Astro dev server paths - only relevant in development.
+ */
+declare const DEV_EXCLUDES: ExcludePattern[];
+/**
+ * Astro internal paths for static assets and image optimization.
+ */
+declare const ASTRO_STATIC_EXCLUDES: ExcludePattern[];
+/**
+ * Common static asset paths.
+ */
+declare const STATIC_EXCLUDES: ExcludePattern[];
+/**
+ * Recommended excludes for middleware.
+ * Includes dev paths and Astro internals.
+ *
+ * @example
+ * ```ts
+ * createI18nMiddleware({
+ *   locale: (ctx) => ctx.locals.session?.locale ?? 'en',
+ *   exclude: [
+ *     ...RECOMMENDED_EXCLUDES,
+ *     { exact: "/health" }, // your health endpoint
+ *   ],
+ * })
+ * ```
+ */
+declare const RECOMMENDED_EXCLUDES: ExcludePattern[];
+/**
+ * Check if a request should be excluded based on patterns or a function.
+ */
+declare function shouldExclude(ctx: APIContext, exclude: readonly StringPattern[] | ((context: APIContext) => boolean) | undefined): boolean;
+/**
+ * Wraps a middleware to skip execution for excluded paths.
+ * Useful for third-party middlewares that don't have built-in exclude support.
+ *
+ * @example
+ * ```ts
+ * import { RECOMMENDED_EXCLUDES, withExcluded } from '@astroscope/node/excludes';
+ * import { someExternalMiddleware } from 'some-package';
+ *
+ * export const onRequest = sequence(
+ *   withExcluded(someExternalMiddleware(), [
+ *     ...RECOMMENDED_EXCLUDES,
+ *     { prefix: '/api/webhooks/' },
+ *   ]),
+ * );
+ * ```
+ */
+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

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

@@ -0,0 +1 @@
+{"version":3,"file":"excludes-DLF3A_Cf.d.ts","names":[],"sources":["../src/excludes/excludes.ts"],"mappings":";;;;;;AAQA;;;KAAY,cAAA,GAAiB,OAAO,CAAC,aAAA,GAAgB,KAAA;;;;cAKxC,YAAA,EAAc,cAAc;AALyB;AAKlE;;AALkE,cAgBrD,qBAAA,EAAuB,cAAc;;AAXT;AAWzC;cAKa,eAAA,EAAiB,cAAc;;;AALM;AAKlD;;;;AAA4C;AAwB5C;;;;AAAiD;AAKjD;;cALa,oBAAA,EAAsB,cAAc;;;;iBAKjC,aAAA,CACd,GAAA,EAAK,UAAA,EACL,OAAA,WAAkB,aAAA,OAAoB,OAAA,EAAS,UAAA;;;;;;;;;AAAmC;AA4BpF;;;;;;;;iBAAgB,YAAA,CACd,UAAA,EAAY,iBAAA,EACZ,OAAA,WAAkB,aAAA,OAAoB,OAAA,EAAS,UAAA,gBAC9C,iBAAA"}

package/dist/excludes-pE23EbmQ.js

@@ -0,0 +1,78 @@
+import { matchesAny } from "@entwico/dash/match";
+//#region src/excludes/excludes.ts
+/**
+* Vite/Astro dev server paths - only relevant in development.
+*/
+const DEV_EXCLUDES = [
+	{ prefix: "/@id/" },
+	{ prefix: "/@fs/" },
+	{ prefix: "/@vite/" },
+	{ prefix: "/src/" },
+	{ prefix: "/node_modules/" }
+];
+/**
+* Astro internal paths for static assets and image optimization.
+*/
+const ASTRO_STATIC_EXCLUDES = [{ prefix: "/_astro/" }, { prefix: "/_image" }];
+/**
+* Common static asset paths.
+*/
+const STATIC_EXCLUDES = [
+	{ exact: "/favicon.ico" },
+	{ exact: "/robots.txt" },
+	{ exact: "/sitemap.xml" },
+	{ exact: "/browserconfig.xml" },
+	{ exact: "/manifest.json" },
+	{ exact: "/manifest.webmanifest" }
+];
+/**
+* Recommended excludes for middleware.
+* Includes dev paths and Astro internals.
+*
+* @example
+* ```ts
+* createI18nMiddleware({
+*   locale: (ctx) => ctx.locals.session?.locale ?? 'en',
+*   exclude: [
+*     ...RECOMMENDED_EXCLUDES,
+*     { exact: "/health" }, // your health endpoint
+*   ],
+* })
+* ```
+*/
+const RECOMMENDED_EXCLUDES = [...DEV_EXCLUDES, ...ASTRO_STATIC_EXCLUDES];
+/**
+* Check if a request should be excluded based on patterns or a function.
+*/
+function shouldExclude(ctx, exclude) {
+	if (!exclude) return false;
+	if (typeof exclude === "function") return exclude(ctx);
+	return matchesAny(ctx.url.pathname, exclude);
+}
+/**
+* Wraps a middleware to skip execution for excluded paths.
+* Useful for third-party middlewares that don't have built-in exclude support.
+*
+* @example
+* ```ts
+* import { RECOMMENDED_EXCLUDES, withExcluded } from '@astroscope/node/excludes';
+* import { someExternalMiddleware } from 'some-package';
+*
+* export const onRequest = sequence(
+*   withExcluded(someExternalMiddleware(), [
+*     ...RECOMMENDED_EXCLUDES,
+*     { prefix: '/api/webhooks/' },
+*   ]),
+* );
+* ```
+*/
+function withExcluded(middleware, exclude) {
+	return (ctx, next) => {
+		if (shouldExclude(ctx, exclude)) return next();
+		return middleware(ctx, next);
+	};
+}
+//#endregion
+export { shouldExclude as a, STATIC_EXCLUDES as i, DEV_EXCLUDES as n, withExcluded as o, RECOMMENDED_EXCLUDES as r, ASTRO_STATIC_EXCLUDES as t };
+
+//# sourceMappingURL=excludes-pE23EbmQ.js.map

package/dist/excludes-pE23EbmQ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"excludes-pE23EbmQ.js","names":[],"sources":["../src/excludes/excludes.ts"],"sourcesContent":["import { type StringPattern, matchesAny } from '@entwico/dash/match';\nimport type { APIContext, MiddlewareHandler } from 'astro';\n\n/**\n * Patterns accepted by @astroscope/node exclude options. The serializable\n * subset of dash's `StringPattern` — no matcher functions, since integration\n * options cross a virtual-module boundary.\n */\nexport type ExcludePattern = Exclude<StringPattern, (value: string) => boolean>;\n\n/**\n * Vite/Astro dev server paths - only relevant in development.\n */\nexport const DEV_EXCLUDES: ExcludePattern[] = [\n  { prefix: '/@id/' },\n  { prefix: '/@fs/' },\n  { prefix: '/@vite/' },\n  { prefix: '/src/' },\n  { prefix: '/node_modules/' },\n];\n\n/**\n * Astro internal paths for static assets and image optimization.\n */\nexport const ASTRO_STATIC_EXCLUDES: ExcludePattern[] = [{ prefix: '/_astro/' }, { prefix: '/_image' }];\n\n/**\n * Common static asset paths.\n */\nexport const STATIC_EXCLUDES: ExcludePattern[] = [\n  { exact: '/favicon.ico' },\n  { exact: '/robots.txt' },\n  { exact: '/sitemap.xml' },\n  { exact: '/browserconfig.xml' },\n  { exact: '/manifest.json' },\n  { exact: '/manifest.webmanifest' },\n];\n\n/**\n * Recommended excludes for middleware.\n * Includes dev paths and Astro internals.\n *\n * @example\n * ```ts\n * createI18nMiddleware({\n *   locale: (ctx) => ctx.locals.session?.locale ?? 'en',\n *   exclude: [\n *     ...RECOMMENDED_EXCLUDES,\n *     { exact: \"/health\" }, // your health endpoint\n *   ],\n * })\n * ```\n */\nexport const RECOMMENDED_EXCLUDES: ExcludePattern[] = [...DEV_EXCLUDES, ...ASTRO_STATIC_EXCLUDES];\n\n/**\n * Check if a request should be excluded based on patterns or a function.\n */\nexport function shouldExclude(\n  ctx: APIContext,\n  exclude: readonly StringPattern[] | ((context: APIContext) => boolean) | undefined,\n): boolean {\n  if (!exclude) return false;\n\n  if (typeof exclude === 'function') {\n    return exclude(ctx);\n  }\n\n  return matchesAny(ctx.url.pathname, exclude);\n}\n\n/**\n * Wraps a middleware to skip execution for excluded paths.\n * Useful for third-party middlewares that don't have built-in exclude support.\n *\n * @example\n * ```ts\n * import { RECOMMENDED_EXCLUDES, withExcluded } from '@astroscope/node/excludes';\n * import { someExternalMiddleware } from 'some-package';\n *\n * export const onRequest = sequence(\n *   withExcluded(someExternalMiddleware(), [\n *     ...RECOMMENDED_EXCLUDES,\n *     { prefix: '/api/webhooks/' },\n *   ]),\n * );\n * ```\n */\nexport function withExcluded(\n  middleware: MiddlewareHandler,\n  exclude: readonly StringPattern[] | ((context: APIContext) => boolean),\n): MiddlewareHandler {\n  return (ctx, next) => {\n    if (shouldExclude(ctx, exclude)) {\n      return next();\n    }\n\n    return middleware(ctx, next);\n  };\n}\n"],"mappings":";;;;;AAaA,MAAa,eAAiC;CAC5C,EAAE,QAAQ,QAAQ;CAClB,EAAE,QAAQ,QAAQ;CAClB,EAAE,QAAQ,UAAU;CACpB,EAAE,QAAQ,QAAQ;CAClB,EAAE,QAAQ,iBAAiB;AAC7B;;;;AAKA,MAAa,wBAA0C,CAAC,EAAE,QAAQ,WAAW,GAAG,EAAE,QAAQ,UAAU,CAAC;;;;AAKrG,MAAa,kBAAoC;CAC/C,EAAE,OAAO,eAAe;CACxB,EAAE,OAAO,cAAc;CACvB,EAAE,OAAO,eAAe;CACxB,EAAE,OAAO,qBAAqB;CAC9B,EAAE,OAAO,iBAAiB;CAC1B,EAAE,OAAO,wBAAwB;AACnC;;;;;;;;;;;;;;;;AAiBA,MAAa,uBAAyC,CAAC,GAAG,cAAc,GAAG,qBAAqB;;;;AAKhG,SAAgB,cACd,KACA,SACS;CACT,IAAI,CAAC,SAAS,OAAO;CAErB,IAAI,OAAO,YAAY,YACrB,OAAO,QAAQ,GAAG;CAGpB,OAAO,WAAW,IAAI,IAAI,UAAU,OAAO;AAC7C;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,aACd,YACA,SACmB;CACnB,QAAQ,KAAK,SAAS;EACpB,IAAI,cAAc,KAAK,OAAO,GAC5B,OAAO,KAAK;EAGd,OAAO,WAAW,KAAK,IAAI;CAC7B;AACF"}

package/dist/excludes.d.ts

@@ -0,0 +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";
+export { ASTRO_STATIC_EXCLUDES, DEV_EXCLUDES, ExcludePattern, RECOMMENDED_EXCLUDES, STATIC_EXCLUDES, shouldExclude, withExcluded };

package/dist/excludes.js

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

package/dist/generation-Bp2IA0jf.js

@@ -0,0 +1,45 @@
+//#region src/dev-mode/generation.ts
+/**
+* Per-process generation state shared between the integration's connect-level
+* stamp and the runtime Astro middleware.
+*/
+const GEN_HEADER = "x-astroscope-node-gen";
+const STATE_KEY = Symbol.for("@astroscope/node/generation");
+function getState() {
+	const g = globalThis;
+	let s = g[STATE_KEY];
+	if (!s) {
+		s = {
+			generation: 0,
+			staleCount: 0,
+			flushTimer: void 0
+		};
+		g[STATE_KEY] = s;
+	}
+	return s;
+}
+function getCurrentGeneration() {
+	return getState().generation;
+}
+function incrementGeneration() {
+	getState().generation++;
+}
+/**
+* Buffer a swallowed stale-request error and flush a single concise line per
+* burst — replaces the multi-line stack traces astro otherwise emits.
+*/
+function recordStaleError() {
+	const s = getState();
+	s.staleCount++;
+	if (s.flushTimer) return;
+	s.flushTimer = setTimeout(() => {
+		const n = s.staleCount;
+		s.staleCount = 0;
+		s.flushTimer = void 0;
+		console.log(`[@astroscope/node] suppressed ${n} stale request error${n === 1 ? "" : "s"} from a previous app generation`);
+	}, 50);
+}
+//#endregion
+export { recordStaleError as i, getCurrentGeneration as n, incrementGeneration as r, GEN_HEADER as t };
+
+//# sourceMappingURL=generation-Bp2IA0jf.js.map

package/dist/generation-Bp2IA0jf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generation-Bp2IA0jf.js","names":[],"sources":["../src/dev-mode/generation.ts"],"sourcesContent":["/**\n * Per-process generation state shared between the integration's connect-level\n * stamp and the runtime Astro middleware.\n */\n\nexport const GEN_HEADER = 'x-astroscope-node-gen';\n\nconst STATE_KEY = Symbol.for('@astroscope/node/generation');\n\ninterface State {\n  generation: number;\n  staleCount: number;\n  flushTimer: ReturnType<typeof setTimeout> | undefined;\n}\n\nfunction getState(): State {\n  const g = globalThis as Record<symbol, unknown>;\n  let s = g[STATE_KEY] as State | undefined;\n\n  if (!s) {\n    s = { generation: 0, staleCount: 0, flushTimer: undefined };\n    g[STATE_KEY] = s;\n  }\n\n  return s;\n}\n\nexport function getCurrentGeneration(): number {\n  return getState().generation;\n}\n\nexport function incrementGeneration(): void {\n  getState().generation++;\n}\n\n/**\n * Buffer a swallowed stale-request error and flush a single concise line per\n * burst — replaces the multi-line stack traces astro otherwise emits.\n */\nexport function recordStaleError(): void {\n  const s = getState();\n\n  s.staleCount++;\n\n  if (s.flushTimer) return;\n\n  s.flushTimer = setTimeout(() => {\n    const n = s.staleCount;\n\n    s.staleCount = 0;\n    s.flushTimer = undefined;\n\n    console.log(\n      `[@astroscope/node] suppressed ${n} stale request error${n === 1 ? '' : 's'} from a previous app generation`,\n    );\n  }, 50);\n}\n"],"mappings":";;;;;AAKA,MAAa,aAAa;AAE1B,MAAM,YAAY,OAAO,IAAI,6BAA6B;AAQ1D,SAAS,WAAkB;CACzB,MAAM,IAAI;CACV,IAAI,IAAI,EAAE;CAEV,IAAI,CAAC,GAAG;EACN,IAAI;GAAE,YAAY;GAAG,YAAY;GAAG,YAAY,KAAA;EAAU;EAC1D,EAAE,aAAa;CACjB;CAEA,OAAO;AACT;AAEA,SAAgB,uBAA+B;CAC7C,OAAO,SAAS,CAAC,CAAC;AACpB;AAEA,SAAgB,sBAA4B;CAC1C,SAAS,CAAC,CAAC;AACb;;;;;AAMA,SAAgB,mBAAyB;CACvC,MAAM,IAAI,SAAS;CAEnB,EAAE;CAEF,IAAI,EAAE,YAAY;CAElB,EAAE,aAAa,iBAAiB;EAC9B,MAAM,IAAI,EAAE;EAEZ,EAAE,aAAa;EACf,EAAE,aAAa,KAAA;EAEf,QAAQ,IACN,iCAAiC,EAAE,sBAAsB,MAAM,IAAI,KAAK,IAAI,gCAC9E;CACF,GAAG,EAAE;AACP"}

package/dist/health.d.ts

@@ -0,0 +1,38 @@
+//#region src/health/health.d.ts
+interface HealthCheckResult {
+  status: 'healthy' | 'unhealthy';
+  latency?: number | undefined;
+  error?: string | undefined;
+}
+interface HealthCheckDefinition {
+  /**
+   * Unique name for this health check.
+   */
+  name: string;
+  /**
+   * Performs the check. Throw or return an unhealthy result to fail;
+   * returning void or completing without error means healthy.
+   */
+  check: () => Promise<HealthCheckResult | void> | HealthCheckResult | void;
+  /**
+   * Optional checks don't affect the ready probe.
+   * @default false
+   */
+  optional?: boolean | undefined;
+  /**
+   * Maximum time in ms for the check to complete.
+   * @default 5000
+   */
+  timeout?: number | undefined;
+}
+/**
+ * Register a health check against the adapter's health server.
+ *
+ * No-op when no health runtime is active (dev mode, `health: false`), so boot
+ * files can call it unconditionally. Returns an unregister function; checks
+ * still registered after `onShutdown` are removed automatically.
+ */
+declare function registerHealthCheck(definition: HealthCheckDefinition): () => void;
+//#endregion
+export { HealthCheckDefinition, HealthCheckResult, registerHealthCheck };
+//# sourceMappingURL=health.d.ts.map

package/dist/health.d.ts.map

@@ -0,0 +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"}

package/dist/health.js

@@ -0,0 +1,31 @@
+import { r as getHealthStore } from "./store-8pnTxM1x.js";
+//#region src/health/health.ts
+/**
+* Register a health check against the adapter's health server.
+*
+* No-op when no health runtime is active (dev mode, `health: false`), so boot
+* files can call it unconditionally. Returns an unregister function; checks
+* still registered after `onShutdown` are removed automatically.
+*/
+function registerHealthCheck(definition) {
+	const store = getHealthStore();
+	if (!store.registry) return () => {};
+	const unregister = store.registry.register({
+		name: definition.name,
+		check: definition.check,
+		...definition.optional !== void 0 && { optional: definition.optional },
+		...definition.timeout !== void 0 && { timeout: definition.timeout }
+	});
+	store.unregisters.set(definition.name, unregister);
+	return () => {
+		const current = store.unregisters.get(definition.name);
+		if (current) {
+			store.unregisters.delete(definition.name);
+			current();
+		}
+	};
+}
+//#endregion
+export { registerHealthCheck };
+
+//# sourceMappingURL=health.js.map

package/dist/health.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.js","names":[],"sources":["../src/health/health.ts"],"sourcesContent":["import { getHealthStore } from './store.js';\n\nexport interface HealthCheckResult {\n  status: 'healthy' | 'unhealthy';\n  latency?: number | undefined;\n  error?: string | undefined;\n}\n\nexport interface HealthCheckDefinition {\n  /**\n   * Unique name for this health check.\n   */\n  name: string;\n\n  /**\n   * Performs the check. Throw or return an unhealthy result to fail;\n   * returning void or completing without error means healthy.\n   */\n  check: () => Promise<HealthCheckResult | void> | HealthCheckResult | void;\n\n  /**\n   * Optional checks don't affect the ready probe.\n   * @default false\n   */\n  optional?: boolean | undefined;\n\n  /**\n   * Maximum time in ms for the check to complete.\n   * @default 5000\n   */\n  timeout?: number | undefined;\n}\n\n/**\n * Register a health check against the adapter's health server.\n *\n * No-op when no health runtime is active (dev mode, `health: false`), so boot\n * files can call it unconditionally. Returns an unregister function; checks\n * still registered after `onShutdown` are removed automatically.\n */\nexport function registerHealthCheck(definition: HealthCheckDefinition): () => void {\n  const store = getHealthStore();\n\n  if (!store.registry) {\n    return () => {};\n  }\n\n  const unregister = store.registry.register({\n    name: definition.name,\n    check: definition.check,\n    ...(definition.optional !== undefined && { optional: definition.optional }),\n    ...(definition.timeout !== undefined && { timeout: definition.timeout }),\n  });\n\n  store.unregisters.set(definition.name, unregister);\n\n  return () => {\n    const current = store.unregisters.get(definition.name);\n\n    if (current) {\n      store.unregisters.delete(definition.name);\n      current();\n    }\n  };\n}\n"],"mappings":";;;;;;;;;AAwCA,SAAgB,oBAAoB,YAA+C;CACjF,MAAM,QAAQ,eAAe;CAE7B,IAAI,CAAC,MAAM,UACT,aAAa,CAAC;CAGhB,MAAM,aAAa,MAAM,SAAS,SAAS;EACzC,MAAM,WAAW;EACjB,OAAO,WAAW;EAClB,GAAI,WAAW,aAAa,KAAA,KAAa,EAAE,UAAU,WAAW,SAAS;EACzE,GAAI,WAAW,YAAY,KAAA,KAAa,EAAE,SAAS,WAAW,QAAQ;CACxE,CAAC;CAED,MAAM,YAAY,IAAI,WAAW,MAAM,UAAU;CAEjD,aAAa;EACX,MAAM,UAAU,MAAM,YAAY,IAAI,WAAW,IAAI;EAErD,IAAI,SAAS;GACX,MAAM,YAAY,OAAO,WAAW,IAAI;GACxC,QAAQ;EACV;CACF;AACF"}

package/dist/index.d.ts

@@ -0,0 +1,167 @@
+import { r as ExcludePattern } from "./excludes-DLF3A_Cf.js";
+import { t as BootContext } from "./types-D0uMBi2M.js";
+import { n as BootEventName, t as BootEventHandler } from "./events-CUzQ2_cp.js";
+import { AstroIntegration } from "astro";
+
+//#region src/types.d.ts
+interface NodeBootOptions {
+  /**
+   * Path to the boot file relative to the project root.
+   * @default "src/boot.ts" (or "src/boot/index.ts" if present)
+   */
+  entry?: string | undefined;
+  /**
+   * Restart the dev server when the boot file (or any of its dependencies) changes.
+   * Dev-only — has no effect in production.
+   * @default true
+   */
+  watch?: boolean | undefined;
+}
+/**
+ * Structurally compatible with `ProbePaths` from `health-probes`.
+ */
+interface HealthProbePaths {
+  live?: string | undefined;
+  startup?: string | undefined;
+  ready?: string | undefined;
+  health?: string | undefined;
+}
+interface NodeHealthOptions {
+  /**
+   * Host to bind the health server to.
+   * Falls back to the `HEALTH_HOST` env var, then `'0.0.0.0'` for kubelet probes
+   */
+  host?: string | undefined;
+  /**
+   * Port to bind the health server to.
+   * Falls back to the `HEALTH_PORT` env var, then `9090`.
+   */
+  port?: number | undefined;
+  /**
+   * Custom paths for probe endpoints.
+   * @default K8sPaths (from health-probes)
+   */
+  paths?: HealthProbePaths | undefined;
+}
+interface NodeLoggingOptions {
+  /**
+   * Paths excluded from request logging. Replaces the default
+   * (`RECOMMENDED_EXCLUDES` + `STATIC_EXCLUDES`) entirely when provided.
+   */
+  exclude?: ExcludePattern[] | undefined;
+  /**
+   * Extended request logging: query string, headers, client address.
+   * May capture sensitive data (auth tokens, PII in query strings).
+   * @default false
+   */
+  extended?: boolean | undefined;
+  /**
+   * Also log requests in dev at the connect level. Off by default — astro's
+   * dev server already narrates requests; the `log` proxy works regardless.
+   * @default false
+   */
+  dev?: boolean | undefined;
+}
+interface NodePrometheusOptions {
+  /**
+   * Host to bind the Prometheus reader to.
+   * Falls back to the `OTEL_EXPORTER_PROMETHEUS_HOST` env var, then `'0.0.0.0'`.
+   */
+  host?: string | undefined;
+  /**
+   * Port for the Prometheus reader.
+   * Falls back to the `OTEL_EXPORTER_PROMETHEUS_PORT` env var, then `9464`.
+   */
+  port?: number | undefined;
+}
+interface NodeTelemetryOptions {
+  /**
+   * Paths excluded from request tracing and metrics. Replaces the default
+   * (`RECOMMENDED_EXCLUDES` + `STATIC_EXCLUDES`) entirely when provided.
+   */
+  exclude?: ExcludePattern[] | undefined;
+  /**
+   * Prometheus metrics reader on its own port; `false` disables it.
+   * @default { host: '0.0.0.0', port: 9464 }
+   */
+  prometheus?: NodePrometheusOptions | false | undefined;
+  /**
+   * Also start the telemetry SDK in dev (once per process). Off by default —
+   * several apps share localhost and would fight over the Prometheus port.
+   * @default false
+   */
+  dev?: boolean | undefined;
+}
+interface NodeOptions {
+  /**
+   * Boot lifecycle configuration. The boot file's `onStartup` runs before the
+   * server starts listening; `onShutdown` runs on SIGTERM/SIGINT after in-flight
+   * requests drained. Set to `false` to disable the lifecycle entirely.
+   *
+   * When left at the default and no boot file exists, the lifecycle is skipped.
+   */
+  boot?: NodeBootOptions | false | undefined;
+  /**
+   * Request logging at the native handler (real status, response size,
+   * aborted-vs-completed) plus the request-scoped `log` proxy exported from
+   * `@astroscope/node/log`. Enabled by default in production; `false` disables
+   * request logging (the `log` proxy keeps working).
+   */
+  logging?: NodeLoggingOptions | false | undefined;
+  /**
+   * Platform telemetry: server spans and request metrics at the native
+   * handler, fetch instrumentation via undici, runtime + host metrics, and a
+   * Prometheus reader. Trace exporters are driven by standard `OTEL_*` env
+   * vars. Enabled by default in production, off in dev; `false` disables.
+   */
+  telemetry?: NodeTelemetryOptions | false | undefined;
+  /**
+   * Kubernetes-style health probes served on a separate port, driven around the
+   * boot lifecycle (live before startup, ready after listen, draining on shutdown).
+   * Enabled by default in production (never active in dev); set to `false` to disable.
+   */
+  health?: NodeHealthOptions | false | undefined;
+  /**
+   * CSRF protection: rejects cross-origin POST/PUT/PATCH/DELETE requests by
+   * comparing the Origin header against the request origin. Replaces Astro's
+   * built-in `security.checkOrigin` (which supports no exclusions).
+   * Enabled by default; set to `false` to keep Astro's built-in behavior.
+   */
+  csrf?: {
+    exclude?: ExcludePattern[] | undefined;
+  } | false | undefined;
+  /**
+   * Maximum request body size in bytes. `0` or `Infinity` disables the limit.
+   * @default 1073741824 (1 GiB)
+   */
+  bodySizeLimit?: number | undefined;
+  /**
+   * How long to wait (ms) for in-flight requests to finish on shutdown before
+   * remaining connections are closed forcefully.
+   * @default 10000
+   */
+  shutdownTimeout?: number | undefined;
+}
+//#endregion
+//#region src/integration/integration.d.ts
+/**
+ * Node adapter for Astro with a first-class server entrypoint: the boot
+ * lifecycle, module warmup, health probes, request logging and telemetry run
+ * as plain code around `server.listen()` instead of being injected into the
+ * build output.
+ */
+declare function node(options?: NodeOptions): AstroIntegration;
+//#endregion
+//#region src/platform/prepare.d.ts
+interface InstrumentationContext {
+  dev: boolean;
+}
+//#endregion
+//#region src/lifecycle/lifecycle.d.ts
+interface BootModule {
+  onStartup?: ((context: BootContext) => Promise<void> | void) | undefined;
+  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 };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +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;EClCqB;;;;AAAmC;;;ED0CvE,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;;iBCkDwB,IAAA,CAAK,OAAA,GAAS,WAAA,GAAmB,gBAAgB;;;UChExD,sBAAA;EACf,GAAG;AAAA;;;UCJY,UAAA;EACf,SAAA,KAAc,OAAA,EAAS,WAAA,KAAgB,OAAA;EACvC,UAAA,KAAe,OAAA,EAAS,WAAA,KAAgB,OAAA;AAAA"}