@ng-doc/builder 22.0.0-beta.2 → 22.0.0

package/generator/vite/ssr-renderer-entry.js

@@ -0,0 +1,444 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// libs/builder/generator/vite/ssr-renderer-protocol.ts
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function tagged(value) {
+  return record(value) && value.version === SSR_RENDER_PROTOCOL_VERSION && typeof value.epoch === "string" && value.epoch.length > 0;
+}
+function positiveInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+function hotPayload(value, childToServer = false) {
+  if (!record(value) || typeof value.type !== "string") return false;
+  if (childToServer) {
+    return value.type === "custom" && typeof value.event === "string";
+  }
+  switch (value.type) {
+    case "connected":
+    case "ping":
+      return true;
+    case "custom":
+      return typeof value.event === "string";
+    case "full-reload":
+      return (value.path === void 0 || typeof value.path === "string") && (value.triggeredBy === void 0 || typeof value.triggeredBy === "string");
+    case "prune":
+      return Array.isArray(value.paths) && value.paths.every((path) => typeof path === "string");
+    case "update":
+      return Array.isArray(value.updates) && value.updates.every(
+        (update) => record(update) && (update.type === "js-update" || update.type === "css-update") && typeof update.path === "string" && typeof update.acceptedPath === "string" && Number.isFinite(update.timestamp)
+      );
+    case "error":
+      return record(value.err) && typeof value.err.message === "string";
+    default:
+      return false;
+  }
+}
+function limits(value) {
+  return record(value) && [
+    "maxActive",
+    "maxQueued",
+    "maxDepth",
+    "maxMessageBytes",
+    "requestDeadlineMs",
+    "startupDeadlineMs",
+    "fenceDeadlineMs",
+    "closeDeadlineMs"
+  ].every((key) => Number.isSafeInteger(value[key]) && value[key] > 0);
+}
+function isParentToRendererMessage(value) {
+  if (!tagged(value) || typeof value.type !== "string") return false;
+  switch (value.type) {
+    case "start":
+      return typeof value.entry === "string" && typeof value.controlId === "string" && limits(value.limits);
+    case "hot":
+      return hotPayload(value.payload);
+    case "render":
+      if (!positiveInteger(value.id)) return false;
+      try {
+        validateRequest(value.request);
+        return true;
+      } catch {
+        return false;
+      }
+    case "cancel":
+      return positiveInteger(value.id);
+    case "fence":
+      return positiveInteger(value.id) && positiveInteger(value.sequence);
+    case "close":
+      return true;
+    default:
+      return false;
+  }
+}
+function messageBytes(value) {
+  try {
+    return Buffer.byteLength(JSON.stringify(value));
+  } catch {
+    return Number.POSITIVE_INFINITY;
+  }
+}
+function validateEntry(entry) {
+  if (typeof entry !== "string" || !entry || entry.includes("\0")) {
+    throw new TypeError(
+      "[NGDOC_SSR_RENDER_ENTRY] entry must be a non-empty module ID without NUL."
+    );
+  }
+}
+function validateRequest(value, maxDepth = SSR_RENDER_MAX_JSON_DEPTH) {
+  if (!record(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+    throw new TypeError(
+      "[NGDOC_SSR_RENDER_REQUEST] document and absolute HTTP(S) url are required."
+    );
+  }
+  const keys = Reflect.ownKeys(value);
+  if (keys.some((key) => typeof key !== "string" || !["document", "url", "data"].includes(key))) {
+    throw new TypeError("[NGDOC_SSR_RENDER_REQUEST] request contains unsupported properties.");
+  }
+  for (const key of ["document", "url", ...keys.includes("data") ? ["data"] : []]) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor || !descriptor.enumerable || !("value" in descriptor)) {
+      throw new TypeError("[NGDOC_SSR_RENDER_REQUEST] request properties must be enumerable data.");
+    }
+  }
+  if (typeof value.document !== "string" || typeof value.url !== "string") {
+    throw new TypeError(
+      "[NGDOC_SSR_RENDER_REQUEST] document and absolute HTTP(S) url are required."
+    );
+  }
+  let parsed;
+  try {
+    parsed = new URL(value.url);
+  } catch {
+    throw new TypeError("[NGDOC_SSR_RENDER_REQUEST] url must be absolute HTTP(S).");
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new TypeError("[NGDOC_SSR_RENDER_REQUEST] url must be absolute HTTP(S).");
+  }
+  if (value.data !== void 0) validateJson(value.data, maxDepth);
+}
+function validateJson(value, maxDepth = SSR_RENDER_MAX_JSON_DEPTH) {
+  const ancestors = /* @__PURE__ */ new Set();
+  const visit = (item, depth) => {
+    if (depth > maxDepth)
+      throw new TypeError("[NGDOC_SSR_RENDER_JSON] maximum JSON depth exceeded.");
+    if (item === null || typeof item === "string" || typeof item === "boolean") return;
+    if (typeof item === "number") {
+      if (!Number.isFinite(item))
+        throw new TypeError("[NGDOC_SSR_RENDER_JSON] numbers must be finite.");
+      return;
+    }
+    if (typeof item !== "object") {
+      throw new TypeError("[NGDOC_SSR_RENDER_JSON] data contains a non-JSON value.");
+    }
+    if (ancestors.has(item)) throw new TypeError("[NGDOC_SSR_RENDER_JSON] data contains a cycle.");
+    const prototype = Object.getPrototypeOf(item);
+    if (Array.isArray(item) && prototype !== Array.prototype || !Array.isArray(item) && prototype !== Object.prototype && prototype !== null) {
+      throw new TypeError("[NGDOC_SSR_RENDER_JSON] data contains an unsupported object prototype.");
+    }
+    ancestors.add(item);
+    const keys = Reflect.ownKeys(item);
+    for (const key of keys) {
+      if (typeof key !== "string") {
+        throw new TypeError("[NGDOC_SSR_RENDER_JSON] symbol keys are unsupported.");
+      }
+      if (Array.isArray(item) && key === "length") continue;
+      const descriptor = Object.getOwnPropertyDescriptor(item, key);
+      if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) {
+        throw new TypeError(
+          "[NGDOC_SSR_RENDER_JSON] accessors and non-enumerable properties are unsupported."
+        );
+      }
+      if (Array.isArray(item)) {
+        if (!/^(?:0|[1-9]\d*)$/.test(key) || Number(key) >= item.length) {
+          throw new TypeError("[NGDOC_SSR_RENDER_JSON] named array properties are unsupported.");
+        }
+      }
+      visit(descriptor.value, depth + 1);
+    }
+    if (Array.isArray(item) && keys.length !== item.length + 1) {
+      throw new TypeError("[NGDOC_SSR_RENDER_JSON] sparse arrays are unsupported.");
+    }
+    ancestors.delete(item);
+  };
+  visit(value, 0);
+}
+function serializeError(error) {
+  const source = error instanceof Error ? error : new Error(String(error));
+  const code = "code" in source && typeof source.code === "string" ? source.code : void 0;
+  return {
+    name: source.name.slice(0, 256),
+    message: source.message.slice(0, 64 * 1024),
+    ...source.stack ? { stack: source.stack.slice(0, 256 * 1024) } : {},
+    ...code ? { code } : {}
+  };
+}
+var SSR_RENDER_PROTOCOL_VERSION, SSR_RENDER_MAX_ACTIVE, SSR_RENDER_MAX_QUEUED, SSR_RENDER_MAX_JSON_DEPTH, SSR_RENDER_MAX_MESSAGE_BYTES, SSR_RENDER_DEADLINE_MS, SSR_RENDER_CLOSE_DEADLINE_MS, SSR_RENDER_CONTROL_ID, DEFAULT_SSR_RENDER_LIMITS;
+var init_ssr_renderer_protocol = __esm({
+  "libs/builder/generator/vite/ssr-renderer-protocol.ts"() {
+    "use strict";
+    SSR_RENDER_PROTOCOL_VERSION = 1;
+    SSR_RENDER_MAX_ACTIVE = 8;
+    SSR_RENDER_MAX_QUEUED = 32;
+    SSR_RENDER_MAX_JSON_DEPTH = 64;
+    SSR_RENDER_MAX_MESSAGE_BYTES = 16 * 1024 * 1024;
+    SSR_RENDER_DEADLINE_MS = 12e4;
+    SSR_RENDER_CLOSE_DEADLINE_MS = 5e3;
+    SSR_RENDER_CONTROL_ID = "/@ng-doc/ssr-render-control";
+    DEFAULT_SSR_RENDER_LIMITS = Object.freeze({
+      maxActive: SSR_RENDER_MAX_ACTIVE,
+      maxQueued: SSR_RENDER_MAX_QUEUED,
+      maxDepth: SSR_RENDER_MAX_JSON_DEPTH,
+      maxMessageBytes: SSR_RENDER_MAX_MESSAGE_BYTES,
+      requestDeadlineMs: SSR_RENDER_DEADLINE_MS,
+      startupDeadlineMs: SSR_RENDER_DEADLINE_MS,
+      fenceDeadlineMs: SSR_RENDER_DEADLINE_MS,
+      closeDeadlineMs: SSR_RENDER_CLOSE_DEADLINE_MS
+    });
+  }
+});
+
+// libs/builder/generator/vite/ssr-renderer-runtime.ts
+import {
+  createNodeImportMeta,
+  ModuleRunner
+} from "vite/module-runner";
+function deadline(promise, milliseconds, message) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(message)), milliseconds);
+    timer.unref();
+    void promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+function runSsrRendererRuntime(port) {
+  let epoch;
+  let entry;
+  let limits2;
+  let runner;
+  let transportHandlers;
+  let closingAdmission = false;
+  let transportClosed = false;
+  let fatal = false;
+  let closing;
+  const renders = /* @__PURE__ */ new Map();
+  const send = (message) => {
+    if (messageBytes(message) > (limits2?.maxMessageBytes ?? SSR_RENDER_MAX_MESSAGE_BYTES)) {
+      return Promise.reject(new Error("[NGDOC_SSR_RENDER_MESSAGE] Child response is oversized."));
+    }
+    return new Promise((resolve, reject) => {
+      if (!port.send) {
+        reject(new Error("[NGDOC_SSR_RENDER_IPC] Parent IPC channel is unavailable."));
+        return;
+      }
+      try {
+        port.send(message, (error) => error ? reject(error) : resolve());
+      } catch (error) {
+        reject(error);
+      }
+    });
+  };
+  const tagged2 = (message) => ({
+    ...message,
+    version: SSR_RENDER_PROTOCOL_VERSION,
+    epoch: epoch ?? "uninitialized"
+  });
+  const fail = (error) => {
+    if (transportClosed || fatal) return;
+    fatal = true;
+    const disconnect = () => {
+      try {
+        port.disconnect?.();
+      } catch {
+      }
+    };
+    void send(tagged2({ type: "fatal", error: serializeError(error) })).then(disconnect, disconnect);
+  };
+  const start = async (message) => {
+    if (runner || epoch) throw new Error("[NGDOC_SSR_RENDER_PROTOCOL] Duplicate start message.");
+    validateEntry(message.entry);
+    if (message.controlId !== SSR_RENDER_CONTROL_ID) {
+      throw new Error("[NGDOC_SSR_RENDER_PROTOCOL] Unsupported control module ID.");
+    }
+    epoch = message.epoch;
+    entry = message.entry;
+    limits2 = message.limits;
+    const transport = {
+      connect(handlers) {
+        transportHandlers = handlers;
+      },
+      disconnect() {
+        transportHandlers = void 0;
+      },
+      send(payload) {
+        return send(tagged2({ type: "transport", payload }));
+      }
+    };
+    runner = new ModuleRunner({
+      transport,
+      hmr: true,
+      createImportMeta: createNodeImportMeta,
+      sourcemapInterceptor: "node"
+    });
+    await deadline(
+      runner.import(message.controlId),
+      limits2.startupDeadlineMs,
+      "[NGDOC_SSR_RENDER_STARTUP_TIMEOUT] Control module startup deadline exceeded."
+    );
+    await send(tagged2({ type: "ready" }));
+  };
+  const render = (message) => {
+    if (!runner || !entry || !limits2) {
+      throw new Error("[NGDOC_SSR_RENDER_PROTOCOL] Render received before startup.");
+    }
+    if (renders.has(message.id)) {
+      throw new Error("[NGDOC_SSR_RENDER_PROTOCOL] Duplicate render request ID.");
+    }
+    validateRequest(message.request, limits2.maxDepth);
+    const controller = new AbortController();
+    const settlement = (async () => {
+      try {
+        const module = await runner.import(entry);
+        if (controller.signal.aborted || closingAdmission) {
+          throw controller.signal.reason ?? new Error("[NGDOC_SSR_RENDER_ABORTED] Render aborted.");
+        }
+        if (typeof module.render !== "function") {
+          throw new TypeError(
+            `[NGDOC_SSR_RENDER_EXPORT] ${entry} must export a named render(request, { signal }) function.`
+          );
+        }
+        const result = await module.render(message.request, { signal: controller.signal });
+        if (typeof result !== "string") {
+          throw new TypeError("[NGDOC_SSR_RENDER_RESULT] render() must resolve to an HTML string.");
+        }
+        await send(tagged2({ type: "rendered", id: message.id, html: result }));
+      } catch (error) {
+        await send(tagged2({ type: "render-error", id: message.id, error: serializeError(error) }));
+      } finally {
+        renders.delete(message.id);
+      }
+    })();
+    void settlement.catch(() => {
+    });
+    renders.set(message.id, { controller, settlement });
+  };
+  const fence = async (message) => {
+    if (!runner || !limits2) {
+      throw new Error("[NGDOC_SSR_RENDER_PROTOCOL] Fence received before startup.");
+    }
+    try {
+      const control = await runner.import(SSR_RENDER_CONTROL_ID);
+      const controller = new AbortController();
+      const waiting = control.waitForNgDocSsrFence(message.sequence, controller.signal);
+      void waiting.catch(() => {
+      });
+      try {
+        await send(tagged2({ type: "fence-ready", id: message.id, sequence: message.sequence }));
+        await deadline(
+          waiting,
+          limits2.fenceDeadlineMs,
+          `[NGDOC_SSR_RENDER_FENCE_TIMEOUT] Fence ${message.sequence} deadline exceeded.`
+        );
+      } finally {
+        controller.abort(new Error("Fence waiter settled."));
+      }
+      await send(tagged2({ type: "fenced", id: message.id, sequence: message.sequence }));
+    } catch (error) {
+      await send(tagged2({ type: "fence-error", id: message.id, error: serializeError(error) }));
+    }
+  };
+  const close = () => {
+    if (closing) return closing;
+    closingAdmission = true;
+    closing = (async () => {
+      for (const operation of renders.values()) operation.controller.abort();
+      await Promise.allSettled([...renders.values()].map(({ settlement }) => settlement));
+      await runner?.close();
+      await send(tagged2({ type: "closed" }));
+      transportClosed = true;
+      port.disconnect?.();
+    })();
+    return closing;
+  };
+  const receive = async (raw) => {
+    if (transportClosed || fatal) return;
+    if (messageBytes(raw) > (limits2?.maxMessageBytes ?? SSR_RENDER_MAX_MESSAGE_BYTES)) {
+      throw new Error("[NGDOC_SSR_RENDER_MESSAGE] Parent message is oversized.");
+    }
+    if (!isParentToRendererMessage(raw)) {
+      throw new Error("[NGDOC_SSR_RENDER_PROTOCOL] Invalid parent message.");
+    }
+    if (epoch && raw.epoch !== epoch) return;
+    if (!epoch && raw.type !== "start") {
+      throw new Error("[NGDOC_SSR_RENDER_PROTOCOL] First message must start the runtime.");
+    }
+    switch (raw.type) {
+      case "start":
+        if (closingAdmission) return;
+        await start(raw);
+        return;
+      case "hot":
+        transportHandlers?.onMessage(raw.payload);
+        return;
+      case "render":
+        if (closingAdmission) {
+          await send(
+            tagged2({
+              type: "render-error",
+              id: raw.id,
+              error: serializeError(new Error("[NGDOC_SSR_RENDER_DISPOSED] Runtime is closing."))
+            })
+          );
+          return;
+        }
+        render(raw);
+        return;
+      case "cancel":
+        renders.get(raw.id)?.controller.abort();
+        return;
+      case "fence":
+        if (closingAdmission) return;
+        await fence(raw);
+        return;
+      case "close":
+        await close();
+    }
+  };
+  port.on("message", (message) => {
+    void receive(message).catch(fail);
+  });
+  port.on("disconnect", () => {
+    if (!transportClosed) void close().catch(() => {
+    });
+  });
+}
+var init_ssr_renderer_runtime = __esm({
+  "libs/builder/generator/vite/ssr-renderer-runtime.ts"() {
+    "use strict";
+    init_ssr_renderer_protocol();
+  }
+});
+
+// libs/builder/generator/vite/ssr-renderer-entry.ts
+var require_ssr_renderer_entry = __commonJS({
+  "libs/builder/generator/vite/ssr-renderer-entry.ts"() {
+    init_ssr_renderer_runtime();
+    runSsrRendererRuntime(process);
+  }
+});
+export default require_ssr_renderer_entry();

package/generator/vite/ssr-renderer-protocol.d.ts

@@ -0,0 +1,101 @@
+import type { HotPayload } from 'vite';
+export type NgDocSsrJsonValue = null | boolean | number | string | readonly NgDocSsrJsonValue[] | {
+    readonly [key: string]: NgDocSsrJsonValue;
+};
+export interface NgDocSsrRequest {
+    readonly document: string;
+    readonly url: string;
+    readonly data?: NgDocSsrJsonValue;
+}
+export declare const SSR_RENDER_PROTOCOL_VERSION = 1;
+export declare const SSR_RENDER_MAX_ACTIVE = 8;
+export declare const SSR_RENDER_MAX_QUEUED = 32;
+export declare const SSR_RENDER_MAX_JSON_DEPTH = 64;
+export declare const SSR_RENDER_MAX_MESSAGE_BYTES: number;
+export declare const SSR_RENDER_DEADLINE_MS = 120000;
+export declare const SSR_RENDER_CLOSE_DEADLINE_MS = 5000;
+export declare const SSR_RENDER_CONTROL_ID = "/@ng-doc/ssr-render-control";
+export declare const SSR_RENDER_CONTROL_EVENT = "ngdoc:ssr-render-fence";
+export interface SsrRenderLimits {
+    readonly maxActive: number;
+    readonly maxQueued: number;
+    readonly maxDepth: number;
+    readonly maxMessageBytes: number;
+    readonly requestDeadlineMs: number;
+    readonly startupDeadlineMs: number;
+    readonly fenceDeadlineMs: number;
+    readonly closeDeadlineMs: number;
+}
+export declare const DEFAULT_SSR_RENDER_LIMITS: SsrRenderLimits;
+export interface SerializedSsrError {
+    readonly name: string;
+    readonly message: string;
+    readonly stack?: string;
+    readonly code?: string;
+}
+interface Tagged {
+    readonly version: typeof SSR_RENDER_PROTOCOL_VERSION;
+    readonly epoch: string;
+}
+export type ParentToRendererMessage = (Tagged & {
+    readonly type: 'start';
+    readonly entry: string;
+    readonly controlId: string;
+    readonly limits: SsrRenderLimits;
+}) | (Tagged & {
+    readonly type: 'hot';
+    readonly payload: HotPayload;
+}) | (Tagged & {
+    readonly type: 'render';
+    readonly id: number;
+    readonly request: NgDocSsrRequest;
+}) | (Tagged & {
+    readonly type: 'cancel';
+    readonly id: number;
+}) | (Tagged & {
+    readonly type: 'fence';
+    readonly id: number;
+    readonly sequence: number;
+}) | (Tagged & {
+    readonly type: 'close';
+});
+export type RendererToParentMessage = (Tagged & {
+    readonly type: 'ready';
+}) | (Tagged & {
+    readonly type: 'transport';
+    readonly payload: HotPayload;
+}) | (Tagged & {
+    readonly type: 'rendered';
+    readonly id: number;
+    readonly html: string;
+}) | (Tagged & {
+    readonly type: 'render-error';
+    readonly id: number;
+    readonly error: SerializedSsrError;
+}) | (Tagged & {
+    readonly type: 'fence-ready';
+    readonly id: number;
+    readonly sequence: number;
+}) | (Tagged & {
+    readonly type: 'fenced';
+    readonly id: number;
+    readonly sequence: number;
+}) | (Tagged & {
+    readonly type: 'fence-error';
+    readonly id: number;
+    readonly error: SerializedSsrError;
+}) | (Tagged & {
+    readonly type: 'closed';
+}) | (Tagged & {
+    readonly type: 'fatal';
+    readonly error: SerializedSsrError;
+});
+export declare function isParentToRendererMessage(value: unknown): value is ParentToRendererMessage;
+export declare function isRendererToParentMessage(value: unknown): value is RendererToParentMessage;
+export declare function messageBytes(value: unknown): number;
+export declare function validateEntry(entry: unknown): asserts entry is string;
+export declare function validateRequest(value: unknown, maxDepth?: number): asserts value is NgDocSsrRequest;
+export declare function validateJson(value: unknown, maxDepth?: number): void;
+export declare function serializeError(error: unknown): SerializedSsrError;
+export declare function reviveError(error: SerializedSsrError, prefix?: string): Error;
+export {};

package/generator/vite/ssr-renderer.d.ts

@@ -0,0 +1,74 @@
+import { type Plugin, type ViteDevServer } from 'vite';
+import { type NgDocSsrRequest, type SsrRenderLimits } from './ssr-renderer-protocol.js';
+export type { NgDocSsrJsonValue, NgDocSsrRequest } from './ssr-renderer-protocol.js';
+export interface NgDocViteSsrRenderer {
+    render(request: NgDocSsrRequest, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<string>;
+    close(): Promise<void>;
+}
+export interface SsrRendererOwnerOptions {
+    readonly limits?: SsrRenderLimits;
+    readonly entryUrl?: URL;
+    readonly epoch?: () => string;
+    /** @internal Test port: the platform whose process supervision the owner uses. */
+    readonly platform?: NodeJS.Platform;
+    /** @internal Test port: ends a Windows process tree (`taskkill /T /F`). */
+    readonly killTree?: (pid: number) => void;
+}
+/** One process-isolated SSR renderer owned by one NgDoc Vite plugin. */
+export declare class OwnedSsrRenderer implements NgDocViteSsrRenderer {
+    private readonly limits;
+    private readonly entryUrl;
+    private readonly createEpoch;
+    /**
+     * Windows has no process groups: the renderer is not detached (a detached child gets a console
+     * of its own there) and is ended together with everything it started while it is alive.
+     */
+    private readonly windows;
+    private readonly killTree;
+    private server?;
+    private entry?;
+    private runtime?;
+    private serverTransport?;
+    private starting?;
+    private terminating?;
+    private failure?;
+    private disposed;
+    private disposal?;
+    private sequence;
+    private observedHotSequence;
+    private fencedHotSequence;
+    private fenceChain;
+    private readonly fences;
+    private readonly active;
+    private readonly queue;
+    constructor(options?: SsrRendererOwnerOptions);
+    select(entry: string): NgDocViteSsrRenderer;
+    attach(server: ViteDevServer): void;
+    controlModule(id: string): string | undefined;
+    render(request: NgDocSsrRequest, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<string>;
+    close(): Promise<void>;
+    private pump;
+    private start;
+    private abort;
+    private finish;
+    private ensureRuntime;
+    private ensureFenced;
+    private receive;
+    private send;
+    private fail;
+    private closeOwnedRuntime;
+    private terminateRuntime;
+    private kill;
+    /** Our child itself, as Node tracks it: never a probe of a pid that may have been reused. */
+    private running;
+    private groupAlive;
+    private waitForGroupExit;
+}
+/** Pass the complete array returned by one createNgDocVitePlugin call. */
+export declare function getNgDocViteSsrRenderer(plugins: readonly Plugin[], options: {
+    readonly entry: string;
+}): NgDocViteSsrRenderer;

package/generator/vite/theme-index.d.ts

@@ -0,0 +1,13 @@
+/** Transforms the application's index.html. */
+export type ThemeIndexTransformer = (content: string) => Promise<string>;
+/**
+ * Loads the theme restore script once and returns a transformer that inlines it at the start of
+ * the document head, so the reader's theme applies before the application starts. A document that
+ * already carries the script is returned unchanged.
+ */
+export declare function createThemeIndexTransformer(scriptUrl?: URL): Promise<ThemeIndexTransformer>;
+/**
+ * The plugin's `transformIndexHtml` handler. The script is a sibling of the bundled Vite entries
+ * (the build copies it to `vite/restore-theme.js`), so the default URL resolves from every entry.
+ */
+export declare function transformNgDocIndex(html: string): Promise<string>;