@st-h/vite-ember-ssr 0.2.0-alpha.1 → 0.3.1

package/src/server.ts

@@ -39,6 +39,27 @@ export interface BootOptions {
   _renderMode?: 'serialize' | 'rehydrate' | undefined;
 }
 
+/**
+ * Configures forwarding of the incoming request's `Cookie` header to
+ * fetch() calls made during SSR rendering.
+ *
+ * `allowedHosts` is required: forwarding the session cookie to every
+ * outbound fetch would leak credentials to third-party APIs the route
+ * happens to call. Each entry is matched against the request URL's
+ * `host` (hostname plus port) using exact equality — suffix wildcards
+ * are not supported.
+ */
+export interface ForwardedCookie {
+  /** Cookie header value from the incoming request. */
+  value: string;
+  /**
+   * Hosts (`URL.host`) the cookie may be sent to. Exact match, no wildcards.
+   *
+   * @example ['api.example.com', 'auth.example.com:8080']
+   */
+  allowedHosts: string[];
+}
+
 export interface RenderRouteOptions {
   /**
    * When true, intercepts all fetch() calls during SSR rendering and
@@ -46,16 +67,6 @@ export interface RenderRouteOptions {
    */
   shoebox?: boolean;
 
-  /**
-   * Enable Glimmer VM rehydration mode.
-   *
-   * When true, the server renders with `_renderMode: 'serialize'`,
-   * annotating the DOM with markers Glimmer can reuse on the client.
-   *
-   * @default false
-   */
-  rehydrate?: boolean;
-
   /**
    * CSS manifest mapping route names to their associated CSS asset paths.
    *
@@ -65,21 +76,35 @@ export interface RenderRouteOptions {
   cssManifest?: CssManifest;
 
   /**
-   * HTTP headers from the incoming request to forward to fetch() calls
-   * made during SSR rendering.
+   * Maximum time (in milliseconds) to wait for `settled()` to resolve after
+   * `app.visit()`. Only applies when the SSR bundle exports a `settled`
+   * function (typically re-exported from `@ember/test-helpers`).
    *
-   * Use this to forward authentication cookies, authorization tokens,
-   * or other request-scoped headers so the SSR render can make
-   * authenticated API calls on behalf of the user.
+   * If the timeout is exceeded, a warning is logged and the DOM is captured
+   * regardless. Use this to bound render time when a route registers a
+   * waiter that never resolves.
    *
-   * Only the specified headers are forwarded. Common usage:
+   * @default 10000
+   */
+  settledTimeout?: number;
+
+  /**
+   * Forward the incoming request's `Cookie` header to fetch() calls made
+   * during SSR rendering. The cookie is only sent to hosts listed in
+   * `allowedHosts`, so credentials never leak to third-party APIs the
+   * route may also call.
+   *
+   * @example
    * ```js
-   * const rendered = await app.renderRoute(req.url, {
-   *   headers: { cookie: req.headers.cookie },
+   * await app.renderRoute(req.url, {
+   *   forwardCookie: {
+   *     value: req.headers.cookie ?? '',
+   *     allowedHosts: ['api.example.com'],
+   *   },
    * });
    * ```
    */
-  headers?: Record<string, string>;
+  forwardCookie?: ForwardedCookie;
 }
 
 export interface RenderResult {
@@ -218,7 +243,7 @@ export interface EmberApp {
  *
  * @example Production
  * ```js
- * import { createEmberApp, assembleHTML } from '@st-h/vite-ember-ssr/server';
+ * import { createEmberApp, assembleHTML } from 'vite-ember-ssr/server';
  * import { resolve } from 'node:path';
  *
  * const app = await createEmberApp(resolve('dist/server/app-ssr.mjs'));
@@ -234,7 +259,7 @@ export interface EmberApp {
  * @example Development
  * ```js
  * import { createServer } from 'vite';
- * import { createEmberApp, assembleHTML } from '@st-h/vite-ember-ssr/server';
+ * import { createEmberApp, assembleHTML } from 'vite-ember-ssr/server';
  *
  * const vite = await createServer({ server: { middlewareMode: true }, appType: 'custom' });
  * const app = await createEmberApp('app/app-ssr.ts', {
@@ -293,9 +318,9 @@ export async function createEmberApp(
         ssrBundlePath: bundleURL,
         url,
         shoebox: renderOptions.shoebox ?? false,
-        rehydrate: renderOptions.rehydrate ?? false,
         cssManifest: renderOptions.cssManifest ?? null,
-        headers: renderOptions.headers ?? null,
+        settledTimeout: renderOptions.settledTimeout ?? 10_000,
+        forwardCookie: renderOptions.forwardCookie ?? null,
       })) as {
         head: string;
         body: string;

package/src/vite-plugin.ts

@@ -457,22 +457,6 @@ export interface EmberSsgPluginOptions {
    * @default 'dist'
    */
   outDir?: string;
-
-  /**
-   * Enable Glimmer rehydration for prerendered pages.
-   *
-   * When `true`, the server renders with `_renderMode: 'serialize'`,
-   * annotating the DOM with Glimmer markers. The client boots with
-   * `app.visit(url, { _renderMode: 'rehydrate' })` to reuse the
-   * static DOM instead of replacing it.
-   *
-   * When `false` (default), boundary markers are emitted and the
-   * client uses `cleanupSSRContent()` in the application template
-   * to remove the SSR content before Ember renders fresh.
-   *
-   * @default false
-   */
-  rehydrate?: boolean;
 }
 
 /**
@@ -494,7 +478,7 @@ export interface EmberSsgPluginOptions {
  * @example
  * ```js
  * // vite.config.mjs
- * import { emberSsg } from '@st-h/vite-ember-ssr/vite-plugin';
+ * import { emberSsg } from 'vite-ember-ssr/vite-plugin';
  *
  * export default defineConfig({
  *   plugins: [
@@ -508,12 +492,7 @@ export interface EmberSsgPluginOptions {
  * ```
  */
 export function emberSsg(options: EmberSsgPluginOptions): Plugin {
-  const {
-    routes,
-    ssrEntry = 'app/app-ssr.ts',
-    shoebox = false,
-    rehydrate = false,
-  } = options;
+  const { routes, ssrEntry = 'app/app-ssr.ts', shoebox = false } = options;
 
   // Track whether the user explicitly provided outDir
   const explicitOutDir = options.outDir;
@@ -712,7 +691,6 @@ export function emberSsg(options: EmberSsgPluginOptions): Plugin {
               try {
                 const result = await app.renderRoute(url, {
                   shoebox,
-                  rehydrate,
                   cssManifest,
                 });
 

package/src/worker.ts

@@ -6,9 +6,12 @@
  * every render. Renders are serialised by tinypool (concurrentTasksPerWorker:1),
  * so there is no concurrency concern within a single worker.
  *
- * app.visit() fully owns document.head/body between calls, so DOM state does
- * not bleed across renders. A fresh ApplicationInstance is created per visit
- * and destroyed after the DOM is read, keeping container singletons clean.
+ * A fresh ApplicationInstance is created per visit and destroyed after the
+ * DOM is read, keeping container singletons clean. Because the Window is
+ * long-lived, every render resets the mutable per-request window state in a
+ * finally block: document.body (content + attributes), document.head/title,
+ * and local/session storage. Without this, one request's DOM or storage
+ * writes would bleed into the next request served by this worker.
  *
  * The shoebox fetch interceptor is installed once at startup. Each render
  * assigns a fresh entries Map before visiting, so entries never bleed between
@@ -23,7 +26,14 @@ import type {
   EmberApplicationInstance,
   BootOptions,
   ShoeboxEntry,
+  ForwardedCookie,
 } from './server.js';
+import {
+  abortSignalMiddleware,
+  compose,
+  forwardCookieMiddleware,
+  shoeboxMiddleware,
+} from './fetch-middleware.js';
 
 // ─── Types ────────────────────────────────────────────────────────────
 
@@ -31,9 +41,9 @@ export interface WorkerRenderOptions {
   ssrBundlePath: string;
   url: string;
   shoebox: boolean;
-  rehydrate: boolean;
   cssManifest: CssManifest | null;
-  headers: Record<string, string> | null;
+  settledTimeout: number;
+  forwardCookie: ForwardedCookie | null;
 }
 
 export interface WorkerRenderResult {
@@ -113,6 +123,7 @@ const { ssrBundlePath: startupBundlePath } = (
 
 const startupMod = (await import(startupBundlePath)) as {
   createSsrApp?: () => EmberApplication;
+  settled?: () => Promise<void>;
 };
 if (typeof startupMod.createSsrApp !== 'function') {
   throw new Error(
@@ -123,75 +134,37 @@ if (typeof startupMod.createSsrApp !== 'function') {
 
 const app: EmberApplication = startupMod.createSsrApp();
 
-// ─── Shoebox ──────────────────────────────────────────────────────────
+// Optional: the SSR bundle may re-export `settled` from `@ember/test-helpers`.
+// When present, the renderer awaits it after `app.visit()` so any registered
+// `@ember/test-waiters` (used by WarpDrive, ember-concurrency, etc.) drain
+// before the DOM is captured. When absent, we fall back to a single
+// Backburner autorun drain via `setTimeout(0)`.
+const appSettled: (() => Promise<void>) | null =
+  typeof startupMod.settled === 'function' ? startupMod.settled : null;
+
+// ─── Fetch middleware pipeline ────────────────────────────────────────
 
 const SHOEBOX_SCRIPT_ID = 'vite-ember-ssr-shoebox';
 
-// The fetch interceptor is installed once at startup. globalThis.fetch
-// never changes. Each render passes fresh per-render state so there is
-// no bleed between requests.
+// The fetch pipeline is installed once at startup. globalThis.fetch never
+// changes. Per-render state (shoebox entries, forwarded cookie) lives in
+// module-level variables that the middlewares read via getters.
 const realFetch = globalThis.fetch;
-let shoeboxEntries: Map<string, ShoeboxEntry> | null = null;
-let requestHeaders: Record<string, string> | null = null;
-
-const interceptedFetch: typeof fetch = async (input, init) => {
-  const request = new Request(input, init);
-
-  // Inject forwarded request headers (e.g., cookies) into outgoing fetches.
-  // Only applies to requests without an existing cookie/authorization header,
-  // so explicit headers in app code are not overwritten.
-  if (requestHeaders) {
-    const mergedInit = { ...init };
-    const existingHeaders = new Headers(mergedInit.headers);
-    for (const [key, value] of Object.entries(requestHeaders)) {
-      if (!existingHeaders.has(key)) {
-        existingHeaders.set(key, value);
-      }
-    }
-    mergedInit.headers = existingHeaders;
-    const mergedRequest = new Request(input, mergedInit);
-
-    if (mergedRequest.method.toUpperCase() !== 'GET') return realFetch(mergedRequest);
-    const response = await realFetch(mergedRequest);
-    if (shoeboxEntries) {
-      captureShoeboxEntry(mergedRequest, response);
-    }
-    return response;
-  }
-
-  if (request.method.toUpperCase() !== 'GET') return realFetch(input, init);
-  const response = await realFetch(input, init);
-  if (shoeboxEntries) {
-    captureShoeboxEntry(request, response);
-  }
-  return response;
-};
-
-async function captureShoeboxEntry(
-  request: Request,
-  response: Response,
-): Promise<void> {
-  try {
-    const clone = response.clone();
-    const body = await clone.text();
-    const headers: Record<string, string> = {};
-    clone.headers.forEach((v, k) => {
-      headers[k] = v;
-    });
-    shoeboxEntries?.set(request.url, {
-      url: request.url,
-      status: clone.status,
-      statusText: clone.statusText,
-      headers,
-      body,
-    });
-  } catch {
-    /* skip */
-  }
-}
+let activeShoebox: Map<string, ShoeboxEntry> | null = null;
+let activeCookie: ForwardedCookie | null = null;
+let activeAbort: AbortController | null = null;
+
+const fetchWithMiddleware = compose(
+  [
+    forwardCookieMiddleware(() => activeCookie),
+    shoeboxMiddleware(() => activeShoebox),
+    abortSignalMiddleware(() => activeAbort?.signal ?? null),
+  ],
+  (request) => realFetch(request),
+);
 
 // Install once — never needs to be restored.
-globalThis.fetch = interceptedFetch;
+globalThis.fetch = fetchWithMiddleware;
 
 function serializeShoebox(entries: ShoeboxEntry[]): string {
   if (entries.length === 0) return '';
@@ -237,27 +210,73 @@ function buildRouteCssLinks(
   return links.join('');
 }
 
+let warnedMissingSettled = false;
+
+async function awaitSettled(timeoutMs: number): Promise<void> {
+  if (!appSettled) {
+    if (timeoutMs > 0 && !warnedMissingSettled) {
+      warnedMissingSettled = true;
+      console.warn(
+        '[vite-ember-ssr] settledTimeout is set but the SSR bundle does not ' +
+          'export `settled` — renders will NOT wait for the app to settle ' +
+          'and may capture incomplete HTML. Add ' +
+          "`export { settled } from '@ember/test-helpers';` to your SSR entry.",
+      );
+    }
+    // Fallback: drain Backburner's autorun microtask before reading the DOM.
+    await new Promise<void>((resolve) => setTimeout(resolve, 0));
+    return;
+  }
+
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    await Promise.race([
+      appSettled(),
+      new Promise<never>((_, reject) => {
+        timer = setTimeout(
+          () => reject(new Error(`settled() timed out after ${timeoutMs}ms`)),
+          timeoutMs,
+        );
+      }),
+    ]);
+  } catch (e) {
+    console.warn(
+      `[vite-ember-ssr] settled() did not resolve within ${timeoutMs}ms, ` +
+        `capturing DOM anyway:`,
+      e instanceof Error ? e.message : e,
+    );
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
 export default async function render(
   options: WorkerRenderOptions,
 ): Promise<WorkerRenderResult> {
-  const { url, shoebox, rehydrate, cssManifest, headers } = options;
+  const { url, shoebox, cssManifest, settledTimeout, forwardCookie } = options;
 
   // Use the long-lived document directly — no new Window, no globalThis swap.
   const document = win.document;
 
-  // Give the interceptor a fresh Map for this render, or null if shoebox
-  // is disabled, so entries never bleed between requests.
-  shoeboxEntries = shoebox ? new Map() : null;
+  // Set per-render state. The middlewares read these via getters, so a
+  // single shared pipeline can serve every render without re-installation.
+  activeShoebox = shoebox ? new Map() : null;
+  activeCookie = forwardCookie;
+  activeAbort = new AbortController();
 
-  // Forward request headers (e.g., cookies) to outgoing fetch calls
-  // for this render only. Cleared after the render completes.
-  requestHeaders = headers;
+  // Snapshot the pre-render <head> state so the finally below can restore
+  // it. ember-page-title and similar addons write into <head> during the
+  // render; without a reset, one request's document title (which may contain
+  // private data) bleeds into every later render served by this worker.
+  const preRenderTitle = document.title;
+  const preRenderHead = document.head?.innerHTML ?? '';
 
   let head = '';
   let body = '';
   let bodyAttrs: Record<string, string> = {};
   let cssLinks = '';
   let error: Error | undefined;
+  let instance: EmberApplicationInstance | undefined;
 
   try {
     const bootOptions: BootOptions = {
@@ -266,13 +285,15 @@ export default async function render(
       document: document as unknown as Document,
       rootElement: document.body as unknown as Element,
       shouldRender: true,
-      ...(rehydrate ? { _renderMode: 'serialize' as const } : {}),
+      _renderMode: 'serialize',
     };
 
-    const instance = await app.visit(url, bootOptions);
+    instance = await app.visit(url, bootOptions);
 
-    // Drain Backburner's autorun microtask before reading the DOM.
-    await new Promise<void>((resolve) => setTimeout(resolve, 0));
+    // Wait for the app to settle (test waiters, run loop, pending timers, etc.)
+    // before reading the DOM. Falls back to a microtask drain when the SSR
+    // bundle doesn't export `settled`.
+    await awaitSettled(settledTimeout);
 
     if (cssManifest) cssLinks = buildRouteCssLinks(cssManifest, instance);
     head = document.head?.innerHTML ?? '';
@@ -284,47 +305,74 @@ export default async function render(
         bodyAttrs[attr.name] = attr.value;
       }
     }
-
-    // Destroy the instance so its container is torn down cleanly.
-    // app.visit() creates a fresh ApplicationInstance per call; without
-    // destroying it the container's singletons (including location:none)
-    // remain live and can corrupt the next visit.
-    instance.destroy();
-
-    // rehydrate mode causes left over rehydration markers to remain in the DOM, so
-    // we clear the body to ensure a clean slate for the next render.
-    if (rehydrate) {
-      document.body.innerHTML = '';
+  } catch (e) {
+    error = e instanceof Error ? e : new Error(String(e));
+  } finally {
+    // Destroy the instance so its container is torn down cleanly. app.visit()
+    // creates a fresh ApplicationInstance per call; without destroying it the
+    // container's singletons (including location:none) remain live and can
+    // corrupt the next visit. This MUST run even when the render above throws
+    // (settle timeout, CSS build, DOM read) — otherwise the leaked instance
+    // accumulates in the long-lived worker. `instance` is undefined when
+    // app.visit() itself threw before assigning it. Guard the call: a destroy
+    // that throws inside this finally would skip the DOM reset below and mask
+    // the render's own error.
+    try {
+      instance?.destroy();
+    } catch {
+      /* instance teardown failed — the DOM reset below must still run */
     }
 
-    // Clear body attributes so they don't bleed into the next render.
+    // Serialize mode leaves rehydration markers in the DOM; reset the body so
+    // the next render starts from a clean slate regardless of success/failure.
     if (document.body) {
+      document.body.innerHTML = '';
+
+      // Clear body attributes so they don't bleed into the next render.
       for (const attr of Array.from(document.body.attributes)) {
         document.body.removeAttribute(attr.name);
       }
     }
-  } catch (e) {
-    error = e instanceof Error ? e : new Error(String(e));
-  }
 
-  // Clear per-render state to prevent bleed between requests.
-  requestHeaders = null;
+    // Restore <head> (and the title) to its pre-render state. The rendered
+    // head HTML was already captured above, so anything the render added —
+    // <title> via ember-page-title, meta tags, etc. — must not survive into
+    // the next request's document.
+    if (document.head) document.head.innerHTML = preRenderHead;
+    if (document.title !== preRenderTitle) document.title = preRenderTitle;
+
+    // Clear web storage so values written during the render (user
+    // preferences, cached tokens) don't bleed into the next request.
+    try {
+      win.localStorage.clear();
+      win.sessionStorage.clear();
+    } catch {
+      /* storage unavailable in this happy-dom configuration */
+    }
+
+    // Abort any fetches this render left in flight (e.g. after a settled()
+    // timeout) so they stop consuming the connection instead of lingering
+    // into later renders. Their shoebox entries — if a response still
+    // arrives — go to this render's already-dead map (see shoeboxMiddleware).
+    activeAbort?.abort();
+    activeAbort = null;
+  }
 
   const shoeboxHTML =
-    shoeboxEntries && shoeboxEntries.size > 0
-      ? serializeShoebox(Array.from(shoeboxEntries.values()))
+    activeShoebox && activeShoebox.size > 0
+      ? serializeShoebox(Array.from(activeShoebox.values()))
       : '';
-  const rehydrateHTML = rehydrate
-    ? '<script>window.__vite_ember_ssr_rehydrate__=true</script>'
-    : '';
+
+  // Clear per-render state so a stray late fetch can't see stale config.
+  activeShoebox = null;
+  activeCookie = null;
+  const rehydrateHTML =
+    '<script>window.__vite_ember_ssr_rehydrate__=true</script>';
   const fullHead = cssLinks + rehydrateHTML + shoeboxHTML + head;
-  const wrappedBody = rehydrate
-    ? body
-    : `<script type="x/boundary" id="ssr-body-start"></script>${body}<script type="x/boundary" id="ssr-body-end"></script>`;
 
   return {
     head: fullHead,
-    body: wrappedBody,
+    body,
     bodyAttrs,
     statusCode: error ? 500 : 200,
     ...(error

package/dist/server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"server.d.ts","names":[],"sources":["../src/server.ts"],"mappings":";;;;;AAmBA;;;;UAAiB,gBAAA;EACf,KAAA,CAAM,GAAA,UAAa,OAAA,GAAU,WAAA,GAAc,OAAA,CAAQ,wBAAA;EACnD,OAAA;AAAA;AAAA,UAGe,wBAAA;EACf,OAAA;EACA,MAAA;EACA,OAAA;EACA,MAAA,EAAQ,QAAA;AAAA;AAAA,UAGO,WAAA;EACf,SAAA;EACA,aAAA;EACA,QAAA,EAAU,QAAA;EACV,WAAA,EAAa,OAAA;EACb,YAAA;EACA,QAAA;EACA,WAAA;AAAA;AAAA,UAGe,kBAAA;EAbf;;;;EAkBA,OAAA;EAf0B;;;;;;;;EAyB1B,SAAA;EApBA;;;;;AAKF;EAuBE,WAAA,GAAc,WAAA;;;;;;;;;;;AAoBhB;;;;;EAHE,OAAA,GAAU,MAAA;AAAA;AAAA,UAGK,YAAA;EAQf;EANA,IAAA;EAQQ;EANR,IAAA;EAMa;EAJb,SAAA,EAAW,MAAA;EAYgB;EAV3B,UAAA;EAce;EAZf,KAAA,GAAQ,KAAA;AAAA;;;;UAQO,YAAA;EACf,GAAA;EACA,MAAA;EACA,UAAA;EACA,OAAA,EAAS,MAAA;EACT,IAAA;AAAA;AAAA,UAKe,kBAAA;EAgBC;;;;;AAGlB;;;;;;;;;;EAHE,aAAA,GAAgB,IAAA,aAAiB,OAAA,CAAQ,MAAA;AAAA;AAAA,UAG1B,eAAA;;;;;;;;;;;;EAYf,OAAA;EAqDgE;;;;;AAgDlE;;;;;;;;;;;EAnFE,qBAAA;EAsFS;;;AAyFX;;;;;;;;;;AAkCA;;;;;EA7LE,cAAA;EA6L4D;;;AAe9D;EAtME,GAAA,GAAM,kBAAA;AAAA;AAAA,UAGS,QAAA;EAoMf;;;;;EA9LA,WAAA,CAAY,GAAA,UAAa,OAAA,GAAU,kBAAA,GAAqB,OAAA,CAAQ,YAAA;;;;;EAMhE,OAAA,IAAW,OAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0CS,cAAA,CACpB,aAAA,UACA,OAAA,GAAS,eAAA,GACR,OAAA,CAAQ,QAAA;;;;;;;;;iBAyFK,YAAA,CACd,QAAA,UACA,QAAA,EAAU,IAAA,CAAK,YAAA;;;;iBAgCD,aAAA,CAAc,IAAA;EAAiB,IAAA;EAAe,IAAA;AAAA;;;;iBAexC,eAAA,CACpB,SAAA,WACC,OAAA,CAAQ,WAAA"}

package/dist/vite-plugin-CQou_tr5.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vite-plugin-CQou_tr5.d.ts","names":[],"sources":["../src/vite-plugin.ts"],"mappings":";;;cAaa,eAAA;AAAA,cACA,eAAA;AADb;;;;AAAA,cAOa,qBAAA;AANb;;;;;AAMA;;;;;AAoBA;;;;;AAkQA;;;AA5RA,KA0BY,WAAA,GAAc,MAAA;AAAA,UAkQT,qBAAA;EA2BD;;;;EAtBd,YAAA;EAsBuB;;;;EAhBvB,YAAA;AAAA;;;;;;;;;;AAwMF;;;;iBAxLgB,QAAA,CAAS,OAAA,GAAS,qBAAA,GAA6B,MAAA;AAAA,UA6F9C,qBAAA;EA2FyC;;;;;;;;;;;;;;EA5ExD,MAAA;;;;;;EAOA,QAAA;;;;;;;;;;;EAYA,OAAA;;;;;EAMA,MAAA;;;;;;;;;;;;;;;EAgBA,SAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCc,QAAA,CAAS,OAAA,EAAS,qBAAA,GAAwB,MAAA"}

package/dist/vite-plugin-D-W5WQWe.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"vite-plugin-D-W5WQWe.js","names":[],"sources":["../src/vite-plugin.ts"],"sourcesContent":["import type { Plugin, PluginOption, ResolvedConfig, UserConfig } from 'vite';\nimport { join, dirname } from 'node:path';\nimport {\n  mkdir,\n  writeFile,\n  readFile,\n  rm,\n  copyFile,\n  access,\n} from 'node:fs/promises';\nimport { pathToFileURL } from 'node:url';\nimport { cpus } from 'node:os';\n\nexport const SSR_HEAD_MARKER = '<!-- VITE_EMBER_SSR_HEAD -->';\nexport const SSR_BODY_MARKER = '<!-- VITE_EMBER_SSR_BODY -->';\n\n/**\n * Name of the CSS manifest file generated during the client build.\n * Maps dynamic entry source modules to their associated CSS asset paths.\n */\nexport const CSS_MANIFEST_FILENAME = 'css-manifest.json';\n\n/**\n * The CSS manifest maps Ember route names to the CSS files that Vite\n * extracted from their lazy-loaded template chunks during the client build.\n *\n * Route names use Ember's dot-separated convention for nested routes:\n * - `about` for `app/templates/about.gts`\n * - `blog.post` for `app/templates/blog/post.gts`\n *\n * Example:\n * ```json\n * {\n *   \"about\": [\"/assets/about-VWk4xp3e.css\"]\n * }\n * ```\n *\n * During SSR, the renderer queries the active route name from Ember's\n * router service and looks up CSS files to inject as `<link>` tags.\n */\nexport type CssManifest = Record<string, string[]>;\n\n/**\n * Derives an Ember route name from a source module path following\n * Ember's conventional file layout.\n *\n * `app/templates/about.gts` → `about`\n * `app/templates/blog/post.gts` → `blog.post`\n * `app/templates/index.gts` → `index`\n *\n * Returns undefined if the path doesn't match the convention.\n */\nfunction sourcePathToRouteName(\n  facadeModuleId: string,\n  root: string,\n): string | undefined {\n  // Make the path relative to the project root\n  let relativePath = facadeModuleId;\n  if (relativePath.startsWith(root)) {\n    relativePath = relativePath.slice(root.length);\n  }\n  // Strip leading slash\n  if (relativePath.startsWith('/')) {\n    relativePath = relativePath.slice(1);\n  }\n\n  // Match app/templates/<route-path>.<ext>\n  const match = relativePath.match(\n    /^app\\/templates\\/(.+)\\.(gts|gjs|hbs|ts|js)$/,\n  );\n  if (!match) return undefined;\n\n  // Convert path separators to dots for nested routes\n  return match[1].replace(/\\//g, '.');\n}\n\n/**\n * Minimal type for a Rollup output chunk with Vite metadata.\n * We define this locally to avoid a direct dependency on the 'rollup' package.\n */\ninterface OutputChunkWithMeta {\n  type: 'chunk';\n  isDynamicEntry: boolean;\n  isEntry: boolean;\n  facadeModuleId: string | null;\n  name: string;\n  fileName: string;\n  imports: string[];\n  viteMetadata?: {\n    importedCss?: Set<string>;\n  };\n}\n\n/**\n * Walks the Rollup output bundle and collects CSS files associated\n * with dynamic entry chunks. These are CSS imports that Vite extracted\n * from code-split chunks (e.g., lazy-loaded route templates).\n *\n * The main entry's CSS is already linked in the HTML template by Vite,\n * so we only collect CSS from `isDynamicEntry` chunks.\n *\n * When a component with CSS is shared across multiple lazy routes,\n * Vite extracts the shared CSS into a separate chunk. We walk each\n * dynamic entry's static `imports` graph to collect CSS from those\n * shared chunks too, skipping the main entry chunk (whose CSS is\n * already in the HTML template).\n *\n * Keys are Ember route names derived from the source file path using\n * Ember's conventional `app/templates/` directory structure.\n */\nfunction buildCssManifest(\n  bundle: Record<string, { type: string }>,\n  base: string,\n  root: string,\n): CssManifest {\n  const manifest: CssManifest = {};\n\n  // Build a lookup of fileName → chunk for walking the import graph.\n  const chunksByFile = new Map<string, OutputChunkWithMeta>();\n  const mainEntryFiles = new Set<string>();\n\n  for (const [, output] of Object.entries(bundle)) {\n    if (output.type !== 'chunk') continue;\n    const chunk = output as unknown as OutputChunkWithMeta;\n    chunksByFile.set(chunk.fileName, chunk);\n\n    // Track main entry chunks so we can exclude their CSS.\n    // Main entry CSS is already linked in the HTML template by Vite.\n    if (chunk.isEntry && !chunk.isDynamicEntry) {\n      mainEntryFiles.add(chunk.fileName);\n    }\n  }\n\n  /**\n   * Recursively collect all CSS from a chunk and its static imports,\n   * excluding main entry chunks (whose CSS is already in the template).\n   */\n  function collectCss(\n    fileName: string,\n    seen: Set<string>,\n    css: Set<string>,\n  ): void {\n    if (seen.has(fileName)) return;\n    seen.add(fileName);\n\n    // Don't collect CSS from the main entry — it's already in the HTML.\n    if (mainEntryFiles.has(fileName)) return;\n\n    const chunk = chunksByFile.get(fileName);\n    if (!chunk) return;\n\n    const importedCss = chunk.viteMetadata?.importedCss;\n    if (importedCss) {\n      for (const cssFile of importedCss) {\n        css.add(cssFile);\n      }\n    }\n\n    // Walk static imports (shared chunks extracted by Vite).\n    for (const imp of chunk.imports) {\n      collectCss(imp, seen, css);\n    }\n  }\n\n  for (const [, output] of Object.entries(bundle)) {\n    if (output.type !== 'chunk') continue;\n\n    const chunk = output as unknown as OutputChunkWithMeta;\n\n    // Only collect CSS from dynamic entries (code-split chunks).\n    if (!chunk.isDynamicEntry) continue;\n\n    // Collect CSS from this chunk and all its static imports.\n    const css = new Set<string>();\n    collectCss(chunk.fileName, new Set(), css);\n\n    if (css.size === 0) continue;\n\n    // Derive the Ember route name from the source module path.\n    // If the path doesn't match Ember conventions, fall back to\n    // the chunk name (e.g., 'about' from 'about-B5EiMzMx.js').\n    const routeName = chunk.facadeModuleId\n      ? (sourcePathToRouteName(chunk.facadeModuleId, root) ?? chunk.name)\n      : chunk.name;\n\n    if (!routeName) continue;\n\n    // Prefix CSS paths with the base URL so they work as href values.\n    const cssFiles = Array.from(css).map((c) => `${base}${c}`);\n\n    if (cssFiles.length > 0) {\n      manifest[routeName] = cssFiles;\n    }\n  }\n\n  return manifest;\n}\n\n/**\n * Returns SSR config appropriate for the current Vite command.\n *\n * Ember's virtual packages (`@glimmer/tracking`, `@ember/*`, etc.) are\n * provided by `ember-source` and not published as real npm packages.\n * When Vite externalizes a dependency that transitively imports one of\n * these virtual packages, Node's runtime module resolution fails under\n * pnpm's strict `node_modules` layout.\n *\n * For both production builds and dev mode:\n *   - Clears any user-specified `ssr.external` (explicit string entries\n *     take precedence over `noExternal` patterns in Vite, so we must\n *     remove them to ensure `noExternal: [/./]` applies).\n *   - Sets `ssr: { noExternal: [/./] }` so all deps go through Vite's\n *     transform pipeline. This lets `@embroider/vite`'s resolver handle\n *     virtual Ember/Glimmer packages that don't exist outside `ember-source`\n *     under pnpm's strict `node_modules` layout.\n *\n * In dev mode, `ssrLoadModule` uses `SSRCompatModuleRunner` +\n * `ESModulesEvaluator`. Without bundling, this evaluates all module code\n * inline. CJS/UMD packages (e.g. `@warp-drive/utilities/string`,\n * `json-to-ast`) reference `module`, `exports`, or `global` which are not\n * available in the evaluator's context.\n *\n * The `cjsSsrShimTransform` hook (applied by `emberSsr()` and `emberSsg()`)\n * intercepts those files before they reach `ssrTransform` and wraps them\n * with a lightweight CommonJS shim, providing the missing `module`,\n * `exports`, and `global` bindings.\n *\n * See: https://github.com/evoactivity/vite-ember-ssr/issues/4\n */\nfunction ssrDepsConfig(\n  userConfig: UserConfig,\n  _command: 'build' | 'serve',\n): { ssr?: UserConfig['ssr'] } {\n  if (userConfig.ssr) {\n    delete userConfig.ssr.external;\n  }\n  return { ssr: { noExternal: [/./] } };\n}\n\n/**\n * Returns a Vite `transform` hook that wraps CJS/UMD modules encountered\n * during SSR transforms.\n *\n * When `noExternal: [/./]` is set, every dependency goes through Vite's\n * `ssrTransform` → `ESModulesEvaluator` pipeline. CJS/UMD files that use\n * `module`, `exports`, or `global` fail because those globals are not\n * available inside `ESModulesEvaluator`'s `AsyncFunction` context.\n *\n * This transform detects CJS/UMD content (no top-level `import`/`export`\n * statements, but contains `exports.xxx` or `module.exports`) and wraps\n * the code so that:\n *   1. `module`, `exports`, and `global` are available as local variables.\n *   2. The module's exports are re-exported as the ES default export.\n *\n * The heuristic is intentionally simple and conservative — it only fires\n * on files that have no ESM syntax at all, which covers the CJS/UMD\n * packages that appear in the Ember + WarpDrive dependency tree without\n * misidentifying genuine ESM files.\n */\nfunction cjsSsrShimTransform(\n  code: string,\n  _id: string,\n  options?: { ssr?: boolean },\n): { code: string; map: null } | null {\n  // Only apply during SSR transforms\n  if (!options?.ssr) return null;\n\n  // Skip if the file contains any top-level import/export → it's ESM\n  if (/^(?:import\\s|export\\s|export\\{|export default)/m.test(code)) return null;\n\n  // Only wrap files that use CommonJS exports or module.exports\n  if (!/\\bexports\\s*[.[=]|\\bmodule\\s*\\.\\s*exports\\b/.test(code)) return null;\n\n  const wrapped = `\\\nconst __cjs_module__ = { exports: {} };\nconst __cjs_exports__ = __cjs_module__.exports;\nconst __cjs_global__ = typeof globalThis !== 'undefined' ? globalThis : typeof global !== 'undefined' ? global : {};\n(function(module, exports, global) {\n${code}\n})(__cjs_module__, __cjs_exports__, __cjs_global__);\nexport default __cjs_module__.exports;\n`;\n  return { code: wrapped, map: null };\n}\n\n/**\n * Flatten and filter a Vite plugins array, which may contain nested arrays,\n * falsy values, and Promise-wrapped entries.\n */\nfunction flatPlugins(plugins: PluginOption[] | undefined): Plugin[] {\n  if (!plugins) return [];\n  return (plugins as unknown[])\n    .flat(Infinity)\n    .filter(\n      (p): p is Plugin => p != null && typeof p === 'object' && 'name' in p,\n    );\n}\n\nexport interface EmberSsrPluginOptions {\n  /**\n   * Output directory for the client build.\n   * @default 'dist/client'\n   */\n  clientOutDir?: string;\n\n  /**\n   * Output directory for the SSR build.\n   * @default 'dist/server'\n   */\n  serverOutDir?: string;\n}\n\n/**\n * Vite plugin that configures SSR support for Ember applications.\n *\n * Handles all SSR-related Vite configuration automatically:\n *\n * - Bundles all dependencies into SSR builds (`ssr.noExternal: [/./]`)\n *   to avoid runtime resolution failures under pnpm's strict\n *   node_modules layout (see issue #4)\n * - Sets build defaults: `dist/client` for client builds,\n *   `dist/server` with `target: 'node22'` for SSR builds\n * - Writes a `package.json` with `\"type\": \"module\"` to the SSR\n *   build output directory (needed for Node ESM compatibility)\n */\nexport function emberSsr(options: EmberSsrPluginOptions = {}): Plugin {\n  let resolvedConfig: ResolvedConfig;\n\n  return {\n    name: 'vite-ember-ssr',\n\n    config(userConfig, env): UserConfig {\n      // Bundle all dependencies for SSR builds and dev mode to avoid runtime\n      // failures under pnpm's strict node_modules layout when external packages\n      // transitively import virtual Ember/Glimmer packages (e.g.\n      // @glimmer/tracking) that only exist inside ember-source.\n      // In dev mode, the `transform: cjsSsrShimTransform` hook wraps\n      // CJS/UMD packages so they work with ESModulesEvaluator.\n      // See: https://github.com/evoactivity/vite-ember-ssr/issues/4\n      const ssrConfig = ssrDepsConfig(userConfig, env.command);\n\n      // During the SSG child build, only set ssr config — don't\n      // override build.outDir (the SSG plugin sets it explicitly\n      // via inline config to a temp directory).\n      if (process.env.__VITE_EMBER_SSG_CHILD__) {\n        return ssrConfig;\n      }\n\n      if (env.isSsrBuild) {\n        return {\n          ...ssrConfig,\n          build: {\n            outDir: options.serverOutDir ?? 'dist/server',\n            target: 'node22',\n            sourcemap: true,\n            minify: false,\n          },\n        };\n      }\n\n      return {\n        ...ssrConfig,\n        build: {\n          outDir: options.clientOutDir ?? 'dist/client',\n        },\n      };\n    },\n\n    configResolved(config) {\n      resolvedConfig = config;\n    },\n\n    transform: cjsSsrShimTransform,\n\n    generateBundle(_outputOptions, bundle) {\n      // Only generate the CSS manifest for client builds.\n      // SSR builds strip CSS imports, so they have nothing to map.\n      if (resolvedConfig.build.ssr) return;\n\n      // Don't generate during the SSG child build (it's an SSR build)\n      if (process.env.__VITE_EMBER_SSG_CHILD__) return;\n\n      const base = resolvedConfig.base ?? '/';\n      const root = resolvedConfig.root;\n      const manifest = buildCssManifest(bundle, base, root);\n\n      // Only emit the manifest if there are dynamic entries with CSS.\n      // Apps without lazy-loaded CSS don't need this file.\n      if (Object.keys(manifest).length === 0) return;\n\n      this.emitFile({\n        type: 'asset',\n        fileName: CSS_MANIFEST_FILENAME,\n        source: JSON.stringify(manifest, null, 2),\n      });\n    },\n\n    async closeBundle() {\n      // Only write package.json for SSR builds\n      if (!resolvedConfig.build.ssr) return;\n\n      // Don't interfere with the SSG child build's temp directory\n      if (process.env.__VITE_EMBER_SSG_CHILD__) return;\n\n      const outDir = join(resolvedConfig.root, resolvedConfig.build.outDir);\n      const targetPath = join(outDir, 'package.json');\n      await mkdir(outDir, { recursive: true });\n      await writeFile(\n        targetPath,\n        JSON.stringify({ type: 'module' }, null, 2),\n        'utf-8',\n      );\n    },\n  };\n}\n\n// ─── SSG Plugin ──────────────────────────────────────────────────────\n\nexport interface EmberSsgPluginOptions {\n  /**\n   * Routes to prerender as static HTML files.\n   *\n   * Each entry is a route path (without leading slash).\n   * 'index' produces `index.html` at the root, other routes produce\n   * `<route>/index.html` (e.g., 'about' → `about/index.html`).\n   *\n   * @example\n   * ```js\n   * emberSsg({\n   *   routes: ['index', 'about', 'pokemon', 'pokemon/charmander'],\n   * })\n   * ```\n   */\n  routes: string[];\n\n  /**\n   * The SSR entry module path, relative to the project root.\n   * This file must export a `createSsrApp` function.\n   * @default 'app/app-ssr.ts'\n   */\n  ssrEntry?: string;\n\n  /**\n   * Enable shoebox (fetch replay) for prerendered pages.\n   *\n   * When true, fetch responses from route model hooks are captured during\n   * prerendering and serialized into the HTML. The client calls\n   * `installShoebox()` before boot to replay those responses and avoid\n   * duplicate API requests.\n   *\n   * @default false\n   */\n  shoebox?: boolean;\n\n  /**\n   * Output directory for the client build.\n   * @default 'dist'\n   */\n  outDir?: string;\n\n  /**\n   * Enable Glimmer rehydration for prerendered pages.\n   *\n   * When `true`, the server renders with `_renderMode: 'serialize'`,\n   * annotating the DOM with Glimmer markers. The client boots with\n   * `app.visit(url, { _renderMode: 'rehydrate' })` to reuse the\n   * static DOM instead of replacing it.\n   *\n   * When `false` (default), boundary markers are emitted and the\n   * client uses `cleanupSSRContent()` in the application template\n   * to remove the SSR content before Ember renders fresh.\n   *\n   * @default false\n   */\n  rehydrate?: boolean;\n}\n\n/**\n * Vite plugin for Static Site Generation (SSG) of Ember applications.\n *\n * Prerenders the specified routes to static HTML files at build time.\n * Fully self-contained — only a single `vite build` is needed.\n *\n * After the client build completes, the plugin runs a second SSR build\n * via `vite.build()` to produce a bundled SSR entry module, imports it,\n * renders each route using HappyDOM, and writes the resulting HTML files\n * into the client output directory. The temporary SSR bundle is cleaned\n * up automatically.\n *\n * All dependencies are bundled into the SSR output (no externals) to\n * avoid runtime resolution failures under pnpm's strict node_modules\n * layout. See issue #4.\n *\n * @example\n * ```js\n * // vite.config.mjs\n * import { emberSsg } from '@st-h/vite-ember-ssr/vite-plugin';\n *\n * export default defineConfig({\n *   plugins: [\n *     ember(),\n *     babel({ babelHelpers: 'runtime', extensions }),\n *     emberSsg({\n *       routes: ['index', 'about', 'pokemon', 'pokemon/charmander'],\n *     }),\n *   ],\n * });\n * ```\n */\nexport function emberSsg(options: EmberSsgPluginOptions): Plugin {\n  const {\n    routes,\n    ssrEntry = 'app/app-ssr.ts',\n    shoebox = false,\n    rehydrate = false,\n  } = options;\n\n  // Track whether the user explicitly provided outDir\n  const explicitOutDir = options.outDir;\n\n  let resolvedConfig: ResolvedConfig;\n\n  // Whether emberSsr is also registered — detected in config() hook\n  let isCombined = false;\n\n  return {\n    name: 'vite-ember-ssg',\n\n    config(userConfig, env): UserConfig {\n      // Bundle all dependencies for SSR builds — see ssrDepsConfig().\n      const ssrConfig = ssrDepsConfig(userConfig, env.command);\n\n      // During the SSG child build, only set ssr config — don't touch\n      // build.outDir or detect isCombined (irrelevant for child build).\n      if (process.env.__VITE_EMBER_SSG_CHILD__) {\n        return ssrConfig;\n      }\n\n      // Detect if emberSsr is also registered in this config.\n      // When combined, defer build.outDir to emberSsr so that\n      // prerendered files land in the SSR client directory.\n      isCombined = flatPlugins(userConfig.plugins).some(\n        (p) => p.name === 'vite-ember-ssr',\n      );\n\n      // Only set outDir when:\n      // - the user explicitly passed outDir to emberSsg, OR\n      // - emberSsr is NOT present (standalone SSG mode, default 'dist')\n      const outDir = explicitOutDir ?? (isCombined ? undefined : 'dist');\n\n      return {\n        ...ssrConfig,\n        ...(outDir != null ? { build: { outDir } } : {}),\n      };\n    },\n\n    configResolved(config) {\n      resolvedConfig = config;\n    },\n\n    transform: cjsSsrShimTransform,\n\n    generateBundle(_outputOptions, bundle) {\n      // When combined with emberSsr, the SSR plugin already emits\n      // the CSS manifest — skip to avoid duplicate emission.\n      if (isCombined) return;\n\n      // Only generate the CSS manifest for client builds.\n      if (resolvedConfig.build.ssr) return;\n\n      // Don't generate during the SSG child build (it's an SSR build)\n      if (process.env.__VITE_EMBER_SSG_CHILD__) return;\n\n      const base = resolvedConfig.base ?? '/';\n      const root = resolvedConfig.root;\n      const manifest = buildCssManifest(bundle, base, root);\n\n      if (Object.keys(manifest).length === 0) return;\n\n      this.emitFile({\n        type: 'asset',\n        fileName: CSS_MANIFEST_FILENAME,\n        source: JSON.stringify(manifest, null, 2),\n      });\n    },\n\n    async closeBundle() {\n      // Don't prerender during SSR builds (if the user also has emberSsr)\n      if (resolvedConfig.build.ssr) return;\n\n      // Prevent recursive prerendering when the child build\n      // loads the same config file and re-registers this plugin.\n      if (process.env.__VITE_EMBER_SSG_CHILD__) return;\n\n      const { build: viteBuild } = await import('vite');\n      const { assembleHTML, createEmberApp } = await import('./server.js');\n\n      const root = resolvedConfig.root;\n      const clientDir = join(root, resolvedConfig.build.outDir);\n      const ssrOutDir = join(root, '.ssg-tmp');\n\n      console.log('\\n[vite-ember-ssg] Prerendering routes...');\n\n      // Read the built client index.html as template\n      const templatePath = join(clientDir, 'index.html');\n      let template: string;\n      try {\n        template = await readFile(templatePath, 'utf-8');\n      } catch (e) {\n        console.error(\n          `[vite-ember-ssg] Failed to read template at ${templatePath}.`,\n        );\n        throw e;\n      }\n\n      // Read the CSS manifest (if it exists) so we can inject\n      // lazy-loaded CSS into prerendered pages.\n      let cssManifest: CssManifest | undefined;\n      const cssManifestPath = join(clientDir, CSS_MANIFEST_FILENAME);\n      try {\n        const raw = await readFile(cssManifestPath, 'utf-8');\n        cssManifest = JSON.parse(raw) as CssManifest;\n      } catch {\n        // No CSS manifest — app has no lazy-loaded CSS\n      }\n\n      // When combined with emberSsr, preserve the original index.html\n      // as _template.html before prerendering overwrites it. The\n      // production server reads _template.html for dynamic SSR rendering.\n      if (isCombined) {\n        const savedTemplatePath = join(clientDir, '_template.html');\n        await copyFile(templatePath, savedTemplatePath);\n        console.log(\n          `  [vite-ember-ssg] Saved SSR template → ${savedTemplatePath.replace(root + '/', '')}`,\n        );\n      }\n\n      // ── Step 1: Build the SSR bundle ────────────────────────────\n      // Run vite.build() with ssr entry to produce a fully bundled\n      // ESM module. This handles all CJS→ESM transforms, Babel,\n      // Glimmer template compilation, etc. at build time.\n      process.env.__VITE_EMBER_SSG_CHILD__ = '1';\n\n      try {\n        await viteBuild({\n          root,\n          configFile: resolvedConfig.configFile || undefined,\n          logLevel: 'warn',\n          build: {\n            ssr: ssrEntry,\n            outDir: ssrOutDir,\n            target: 'node22',\n            minify: false,\n            sourcemap: false,\n          },\n          ssr: {\n            // Belt-and-suspenders: the config hooks already call\n            // ssrDepsConfig() for the child build, but setting it here\n            // in inline config guarantees it even if the user's config\n            // file doesn't register the SSR/SSG plugins for some reason.\n            noExternal: [/./],\n          },\n        });\n      } catch (e) {\n        console.error('[vite-ember-ssg] SSR build failed:', e);\n        throw e;\n      } finally {\n        delete process.env.__VITE_EMBER_SSG_CHILD__;\n      }\n\n      // Write package.json so Node loads the bundle as ESM\n      await writeFile(\n        join(ssrOutDir, 'package.json'),\n        JSON.stringify({ type: 'module' }, null, 2),\n        'utf-8',\n      );\n\n      // ── Step 2: Import the SSR bundle and prerender ─────────────\n      let successCount = 0;\n      let errorCount = 0;\n\n      try {\n        // Determine the output filename — Vite names SSR output\n        // after the entry: 'app/app-ssr.ts' → 'app-ssr.mjs'.\n        // Some Vite versions using Rolldown output '.js' instead of '.mjs',\n        // so we try both extensions.\n        const entryBasename = ssrEntry\n          .split('/')\n          .pop()!\n          .replace(/\\.[^.]+$/, '');\n\n        let ssrBundlePath = join(ssrOutDir, `${entryBasename}.mjs`);\n        try {\n          await access(ssrBundlePath);\n        } catch {\n          ssrBundlePath = join(ssrOutDir, `${entryBasename}.js`);\n        }\n        const ssrBundleURL = pathToFileURL(ssrBundlePath).href;\n\n        // Prerender all routes in parallel using a long-lived worker pool.\n        // Workers import the SSR bundle once and reuse it across renders,\n        // making per-render cost ~4ms vs ~200ms for a fresh-worker approach.\n        const app = await createEmberApp(ssrBundleURL, {\n          workers: cpus().length,\n        });\n\n        try {\n          await Promise.all(\n            routes.map(async (route) => {\n              const url = route === 'index' ? '/' : `/${route}`;\n\n              try {\n                const result = await app.renderRoute(url, {\n                  shoebox,\n                  rehydrate,\n                  cssManifest,\n                });\n\n                if (result.error) {\n                  console.error(\n                    `  [vite-ember-ssg] Error rendering ${url}:\\n` +\n                      (result.error.stack ?? result.error.message),\n                  );\n                  errorCount++;\n                  return;\n                }\n\n                const html = assembleHTML(template, result);\n\n                // 'index' → index.html (overwrite the shell)\n                // 'about' → about/index.html\n                // 'pokemon/charmander' → pokemon/charmander/index.html\n                const outputPath =\n                  route === 'index'\n                    ? join(clientDir, 'index.html')\n                    : join(clientDir, route, 'index.html');\n\n                await mkdir(dirname(outputPath), { recursive: true });\n                await writeFile(outputPath, html, 'utf-8');\n\n                console.log(\n                  `  [vite-ember-ssg] ${url} → ${outputPath.replace(root + '/', '')}`,\n                );\n                successCount++;\n              } catch (e) {\n                console.error(\n                  `  [vite-ember-ssg] Failed to prerender ${url}:\\n` +\n                    (e instanceof Error ? (e.stack ?? e.message) : String(e)),\n                );\n                errorCount++;\n              }\n            }),\n          );\n        } finally {\n          await app.destroy();\n        }\n      } finally {\n        // ── Step 3: Clean up the temporary SSR bundle ─────────────\n        await rm(ssrOutDir, { recursive: true, force: true });\n      }\n\n      console.log(\n        `[vite-ember-ssg] Done. ${successCount} pages generated` +\n          (errorCount > 0 ? `, ${errorCount} errors` : '') +\n          '.',\n      );\n\n      if (errorCount > 0 && successCount === 0) {\n        throw new Error('[vite-ember-ssg] All routes failed to prerender.');\n      }\n    },\n  };\n}\n\nexport default emberSsr;\n"],"mappings":"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"}