@openelement/ssg 0.41.0-alpha.1

package/src/route-type-generator.js

@@ -0,0 +1,99 @@
+/**
+ * @openelement/adapter-vite - Route Type Generator
+ *
+ * Generates `.openElement/routes.d.ts` with type-safe route parameter definitions
+ * for the `virtual:open-routes` module. Only routes that have dynamic [param]
+ * segments are included in the output.
+ *
+ * v0.25.0: Initial implementation for build-time route type code generation.
+ */ /**
+ * Convert a file path to a route path, preserving [param] bracket syntax.
+ * Unlike `filePathToRoutePath()` in route-scanner (which converts to `:param`
+ * for Hono/URLPattern), this preserves `[param]` to match the file-system
+ * convention that developers see in their route files.
+ *
+ * e.g., 'blog/[slug].ts' → '/blog/[slug]'
+ * e.g., 'index.ts' → '/'
+ */ function filePathToBracketRoute(filePath) {
+  let p = filePath.replace(/\.[^.]+$/, '');
+  if (p === 'index') return '/';
+  if (p.endsWith('/index')) {
+    p = p.slice(0, -6);
+    if (p === '') return '/';
+  }
+  if (!p.startsWith('/')) p = '/' + p;
+  return p;
+}
+/**
+ * Generate TypeScript type literal for route params.
+ * Converts param names to a Record<string, string> type.
+ *
+ * Example: ['slug'] → `{ slug: string }`
+ * Example: ['package', 'component'] → `{ package: string; component: string }`
+ */ function generateParamsType(params) {
+  if (params.length === 0) {
+    return 'Record<string, never>';
+  }
+  const fields = params.map((p)=>`${p}: string`);
+  return `{ ${fields.join('; ')} }`;
+}
+/**
+ * Generate the `.openElement/routes.d.ts` declaration file content.
+ *
+ * Only routes that have dynamic parameters (non-empty `params` array)
+ * are included in the generated output. Static routes with no params
+ * are excluded since they don't need type-safe parameter access.
+ *
+ * Example output:
+ * ```typescript
+ * declare module 'virtual:open-routes' {
+ *   interface RouteParams {
+ *     '/blog/[slug]': { slug: string };
+ *     '/registry/[package]/[component]': { package: string; component: string };
+ *   }
+ * }
+ * ```
+ *
+ * @param routes - Array of route entries from the route scanner
+ * @returns TypeScript declaration file content as a string
+ */ export function generateRouteTypes(routes) {
+  // Filter for page routes that have dynamic params
+  const paramRoutes = routes.filter((r)=>r.type === 'page' && r.params && r.params.length > 0);
+  if (paramRoutes.length === 0) {
+    // No routes with params - generate a placeholder interface
+    return [
+      '/**',
+      ' * Auto-generated by @openelement/adapter-vite (v0.25.0)',
+      ' * DO NOT EDIT MANUALLY',
+      ' */',
+      '',
+      "declare module 'virtual:open-routes' {",
+      '  // eslint-disable-next-line @typescript-eslint/no-empty-interface',
+      '  export interface RouteParams {',
+      '  }',
+      '}',
+      ''
+    ].join('\n');
+  }
+  // Generate entries for each route with params
+  const paramEntries = paramRoutes.map((r)=>{
+    const bracketPath = filePathToBracketRoute(r.filePath);
+    const path = JSON.stringify(bracketPath);
+    const type = generateParamsType(r.params);
+    return `    ${path}: ${type};`;
+  });
+  return [
+    '/**',
+    ' * Auto-generated by @openelement/adapter-vite (v0.25.0)',
+    ' * DO NOT EDIT MANUALLY',
+    ' */',
+    '',
+    "declare module 'virtual:open-routes' {",
+    '  export interface RouteParams {',
+    ...paramEntries,
+    '  }',
+    '}',
+    ''
+  ].join('\n');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/ssg-dynamic.js

@@ -0,0 +1,66 @@
+/**
+ * @openelement/ssg - Dynamic route expansion
+ *
+ * Handles dynamic route rendering using getStaticPaths() + renderRoute()
+ * from the SSR bundle.
+ */ import { join } from 'node:path';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { createLogger } from '@openelement/core/logger';
+import { formatError } from '@openelement/core/errors';
+import { collectPageOutput, resolveDynamicRoutePath } from './ssg-helpers.js';
+const log = createLogger('ssg');
+/**
+ * Expand dynamic routes by calling getStaticPaths() and renderRoute()
+ * for each parameter set.
+ *
+ * Returns a map of static path params keyed by route path, which is
+ * consumed later when building the ISR manifest.
+ */ export async function expandDynamicRoutes(dynamicRoutes, renderRoute, getStaticPaths, options, root, outDir, pageDiagnostics) {
+  const staticPathParamsByRoute = new Map();
+  if (dynamicRoutes.length > 0 && renderRoute && getStaticPaths) {
+    for (const route of dynamicRoutes){
+      const paramNames = route.paramNames;
+      let paramsList;
+      try {
+        paramsList = await getStaticPaths(route.path);
+      } catch (e) {
+        log.warn(`Failed to get static paths for ${route.path}: ${formatError(e)}`);
+        continue;
+      }
+      staticPathParamsByRoute.set(route.path, paramsList);
+      if (paramsList.length === 0) {
+        log.info(`Dynamic route ${route.path} has no static paths - skipping`);
+        continue;
+      }
+      for (const params of paramsList){
+        let resolvedPath;
+        try {
+          resolvedPath = resolveDynamicRoutePath(route.path, paramNames, params);
+        } catch (e) {
+          log.warn(`Skipping unsafe dynamic route ${route.path}: ${formatError(e)}`);
+          continue;
+        }
+        try {
+          const output = await renderRoute(route.path, {
+            params,
+            title: options.html?.title,
+            lang: options.html?.lang,
+            headExtras: options.headExtras
+          });
+          const html = collectPageOutput(resolvedPath, output, pageDiagnostics);
+          const outputDir = join(root, outDir);
+          const pageDir = join(outputDir, resolvedPath);
+          mkdirSync(pageDir, {
+            recursive: true
+          });
+          writeFileSync(join(pageDir, 'index.html'), html, 'utf-8');
+          log.info(`Dynamic route: ${resolvedPath} -> ${resolvedPath}/index.html`);
+        } catch (e) {
+          log.warn(`Failed to render dynamic route ${resolvedPath}: ${formatError(e)}`);
+        }
+      }
+    }
+  }
+  return staticPathParamsByRoute;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/ssg-helpers.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Resolve a dynamic route path by substituting param values.
+ * Validates param values to prevent path traversal and control characters.
+ */ export declare function resolveDynamicRoutePath(routePath: string, paramNames: string[], params: Record<string, string>): string;
+/**
+ * Stable SHA-256 hash for SSG-generated asset names.
+ * Returns a deterministic lowercase hex string.
+ */ export declare function stableHash(str: string): Promise<string>;

package/src/ssg-helpers.js

@@ -0,0 +1,96 @@
+/**
+ * @openelement/ssg - SSG helper utilities
+ *
+ * Pure utility functions used by the SSG render pipeline.
+ * This module sits at the bottom of the dependency graph.
+ */ import { join } from 'node:path';
+import { readdirSync } from 'node:fs';
+import { createIsrCacheKey } from '@openelement/core/isr';
+// ─── Path / URL helpers ────────────────────────────────────────
+/** Recursively find all .html files under a directory. */ export function findHtmlFiles(dir) {
+  const results = [];
+  try {
+    const entries = readdirSync(dir, {
+      withFileTypes: true
+    });
+    for (const entry of entries){
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...findHtmlFiles(fullPath));
+      } else if (entry.name.endsWith('.html')) {
+        results.push(fullPath);
+      }
+    }
+  } catch  {
+  // Directory may not exist yet
+  }
+  return results;
+}
+// ─── Route helpers ─────────────────────────────────────────────
+/**
+ * Resolve a dynamic route path by substituting param values.
+ * Validates param values to prevent path traversal and control characters.
+ */ export function resolveDynamicRoutePath(routePath, paramNames, params) {
+  let resolvedPath = routePath;
+  for (const name of paramNames){
+    const raw = params[name];
+    if (raw === undefined || raw === null || raw === '') {
+      throw new Error(`Missing value for route parameter "${name}" in ${routePath}`);
+    }
+    const value = String(raw);
+    if (value === '.' || value === '..' || /[\\/]/.test(value)) {
+      throw new Error(`Unsafe value for route parameter "${name}" in ${routePath}: ${value}`);
+    }
+    // Encode spaces and other URL-unsafe chars, but preserve @ for scoped packages.
+    // Full encodeURIComponent would encode @ -> %40, breaking file-to-URL matching.
+    const safeValue = value.replace(/ /g, '%20');
+    resolvedPath = resolvedPath.replace(`:${name}`, safeValue);
+  }
+  return resolvedPath;
+}
+// ─── Hash helpers ──────────────────────────────────────────────
+/**
+ * Stable SHA-256 hash for SSG-generated asset names.
+ * Returns a deterministic lowercase hex string.
+ */ export async function stableHash(str) {
+  const encoder = new TextEncoder();
+  const digest = await crypto.subtle.digest('SHA-256', encoder.encode(str));
+  return Array.from(new Uint8Array(digest)).map((b)=>b.toString(16).padStart(2, '0')).join('');
+}
+// ─── ISR manifest builder ──────────────────────────────────────
+export function buildIsrManifestEntries(routeInfo, staticPathParamsByRoute) {
+  const entries = [];
+  for (const route of routeInfo){
+    const revalidate = typeof route.revalidate === 'number' && route.revalidate > 0 ? route.revalidate : undefined;
+    if (!revalidate) continue;
+    const paramsList = route.isDynamic ? staticPathParamsByRoute.get(route.path) ?? [] : [
+      route.params ?? {}
+    ];
+    for (const params of paramsList){
+      entries.push({
+        path: route.path,
+        revalidate,
+        cacheKey: createIsrCacheKey(route.path, params),
+        params
+      });
+    }
+  }
+  return entries;
+}
+/**
+ * Collect per-page render diagnostics (backward-compat with string output).
+ * Returns the rendered HTML string.
+ */ export function collectPageOutput(routePath, output, pageDiagnostics) {
+  const html = typeof output === 'string' ? output : output.html;
+  if (typeof output !== 'string') {
+    pageDiagnostics.push({
+      path: routePath,
+      errors: output.errors,
+      hydrationHints: output.hydrationHints,
+      componentCount: output.componentCount,
+      renderTimeMs: output.renderTimeMs
+    });
+  }
+  return html;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/ssg/src/ssg-helpers.ts"],"sourcesContent":["/**\n * @openelement/ssg - SSG helper utilities\n *\n * Pure utility functions used by the SSG render pipeline.\n * This module sits at the bottom of the dependency graph.\n */\n\nimport { join } from 'node:path';\nimport { readdirSync } from 'node:fs';\nimport type { HydrationHint, RenderError } from '@openelement/protocol/render';\nimport type { IsrManifestEntry } from '@openelement/protocol/framework';\nimport { createIsrCacheKey } from '@openelement/core/isr';\n\n// ─── Path / URL helpers ────────────────────────────────────────\n\n/** Recursively find all .html files under a directory. */\nexport function findHtmlFiles(dir: string): string[] {\n  const results: string[] = [];\n  try {\n    const entries = readdirSync(dir, { withFileTypes: true });\n    for (const entry of entries) {\n      const fullPath = join(dir, entry.name);\n      if (entry.isDirectory()) {\n        results.push(...findHtmlFiles(fullPath));\n      } else if (entry.name.endsWith('.html')) {\n        results.push(fullPath);\n      }\n    }\n  } catch {\n    // Directory may not exist yet\n  }\n  return results;\n}\n\n// ─── Route helpers ─────────────────────────────────────────────\n\n/**\n * Resolve a dynamic route path by substituting param values.\n * Validates param values to prevent path traversal and control characters.\n */\nexport function resolveDynamicRoutePath(\n  routePath: string,\n  paramNames: string[],\n  params: Record<string, string>,\n): string {\n  let resolvedPath = routePath;\n  for (const name of paramNames) {\n    const raw = params[name];\n    if (raw === undefined || raw === null || raw === '') {\n      throw new Error(\n        `Missing value for route parameter \"${name}\" in ${routePath}`,\n      );\n    }\n\n    const value = String(raw);\n    if (\n      value === '.' ||\n      value === '..' ||\n      /[\\\\/]/.test(value)\n    ) {\n      throw new Error(\n        `Unsafe value for route parameter \"${name}\" in ${routePath}: ${value}`,\n      );\n    }\n\n    // Encode spaces and other URL-unsafe chars, but preserve @ for scoped packages.\n    // Full encodeURIComponent would encode @ -> %40, breaking file-to-URL matching.\n    const safeValue = value.replace(/ /g, '%20');\n    resolvedPath = resolvedPath.replace(`:${name}`, safeValue);\n  }\n  return resolvedPath;\n}\n\n// ─── Hash helpers ──────────────────────────────────────────────\n\n/**\n * Stable SHA-256 hash for SSG-generated asset names.\n * Returns a deterministic lowercase hex string.\n */\nexport async function stableHash(str: string): Promise<string> {\n  const encoder = new TextEncoder();\n  const digest = await crypto.subtle.digest('SHA-256', encoder.encode(str));\n  return Array.from(new Uint8Array(digest))\n    .map((b) => b.toString(16).padStart(2, '0'))\n    .join('');\n}\n\n// ─── ISR manifest builder ──────────────────────────────────────\n\nexport function buildIsrManifestEntries(\n  routeInfo: Array<{\n    path: string;\n    isDynamic: boolean;\n    revalidate?: number;\n    params?: Record<string, string>;\n  }>,\n  staticPathParamsByRoute: Map<string, Array<Record<string, string>>>,\n): IsrManifestEntry[] {\n  const entries: IsrManifestEntry[] = [];\n  for (const route of routeInfo) {\n    const revalidate = typeof route.revalidate === 'number' && route.revalidate > 0\n      ? route.revalidate\n      : undefined;\n    if (!revalidate) continue;\n\n    const paramsList = route.isDynamic\n      ? staticPathParamsByRoute.get(route.path) ?? []\n      : [route.params ?? {}];\n\n    for (const params of paramsList) {\n      entries.push({\n        path: route.path,\n        revalidate,\n        cacheKey: createIsrCacheKey(route.path, params),\n        params,\n      });\n    }\n  }\n  return entries;\n}\n\n// ─── Per-page diagnostic collector ─────────────────────────────\n\n/** Page-level render diagnostic entry used during SSG render. */\nexport interface PageDiagnostic {\n  path: string;\n  errors: RenderError[];\n  hydrationHints: HydrationHint[];\n  componentCount: number;\n  renderTimeMs: number;\n}\n\n/**\n * Collect per-page render diagnostics (backward-compat with string output).\n * Returns the rendered HTML string.\n */\nexport function collectPageOutput(\n  routePath: string,\n  output: {\n    html: string;\n    errors: RenderError[];\n    hydrationHints: HydrationHint[];\n    componentCount: number;\n    renderTimeMs: number;\n  } | string,\n  pageDiagnostics: PageDiagnostic[],\n): string {\n  const html = typeof output === 'string' ? output : output.html;\n  if (typeof output !== 'string') {\n    pageDiagnostics.push({\n      path: routePath,\n      errors: output.errors,\n      hydrationHints: output.hydrationHints,\n      componentCount: output.componentCount,\n      renderTimeMs: output.renderTimeMs,\n    });\n  }\n  return html;\n}\n"],"names":[],"mappings":"AAAA;;;;;CAKC,GAED,SAAS,IAAI,QAAQ,YAAY;AACjC,SAAS,WAAW,QAAQ,UAAU;AAGtC,SAAS,iBAAiB,QAAQ,wBAAwB;AAE1D,kEAAkE;AAElE,wDAAwD,GACxD,OAAO,SAAS,cAAc,GAAW;EACvC,MAAM,UAAoB,EAAE;EAC5B,IAAI;IACF,MAAM,UAAU,YAAY,KAAK;MAAE,eAAe;IAAK;IACvD,KAAK,MAAM,SAAS,QAAS;MAC3B,MAAM,WAAW,KAAK,KAAK,MAAM,IAAI;MACrC,IAAI,MAAM,WAAW,IAAI;QACvB,QAAQ,IAAI,IAAI,cAAc;MAChC,OAAO,IAAI,MAAM,IAAI,CAAC,QAAQ,CAAC,UAAU;QACvC,QAAQ,IAAI,CAAC;MACf;IACF;EACF,EAAE,OAAM;EACN,8BAA8B;EAChC;EACA,OAAO;AACT;AAEA,kEAAkE;AAElE;;;CAGC,GACD,OAAO,SAAS,wBACd,SAAiB,EACjB,UAAoB,EACpB,MAA8B;EAE9B,IAAI,eAAe;EACnB,KAAK,MAAM,QAAQ,WAAY;IAC7B,MAAM,MAAM,MAAM,CAAC,KAAK;IACxB,IAAI,QAAQ,aAAa,QAAQ,QAAQ,QAAQ,IAAI;MACnD,MAAM,IAAI,MACR,CAAC,mCAAmC,EAAE,KAAK,KAAK,EAAE,WAAW;IAEjE;IAEA,MAAM,QAAQ,OAAO;IACrB,IACE,UAAU,OACV,UAAU,QACV,QAAQ,IAAI,CAAC,QACb;MACA,MAAM,IAAI,MACR,CAAC,kCAAkC,EAAE,KAAK,KAAK,EAAE,UAAU,EAAE,EAAE,OAAO;IAE1E;IAEA,gFAAgF;IAChF,gFAAgF;IAChF,MAAM,YAAY,MAAM,OAAO,CAAC,MAAM;IACtC,eAAe,aAAa,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE;EAClD;EACA,OAAO;AACT;AAEA,kEAAkE;AAElE;;;CAGC,GACD,OAAO,eAAe,WAAW,GAAW;EAC1C,MAAM,UAAU,IAAI;EACpB,MAAM,SAAS,MAAM,OAAO,MAAM,CAAC,MAAM,CAAC,WAAW,QAAQ,MAAM,CAAC;EACpE,OAAO,MAAM,IAAI,CAAC,IAAI,WAAW,SAC9B,GAAG,CAAC,CAAC,IAAM,EAAE,QAAQ,CAAC,IAAI,QAAQ,CAAC,GAAG,MACtC,IAAI,CAAC;AACV;AAEA,kEAAkE;AAElE,OAAO,SAAS,wBACd,SAKE,EACF,uBAAmE;EAEnE,MAAM,UAA8B,EAAE;EACtC,KAAK,MAAM,SAAS,UAAW;IAC7B,MAAM,aAAa,OAAO,MAAM,UAAU,KAAK,YAAY,MAAM,UAAU,GAAG,IAC1E,MAAM,UAAU,GAChB;IACJ,IAAI,CAAC,YAAY;IAEjB,MAAM,aAAa,MAAM,SAAS,GAC9B,wBAAwB,GAAG,CAAC,MAAM,IAAI,KAAK,EAAE,GAC7C;MAAC,MAAM,MAAM,IAAI,CAAC;KAAE;IAExB,KAAK,MAAM,UAAU,WAAY;MAC/B,QAAQ,IAAI,CAAC;QACX,MAAM,MAAM,IAAI;QAChB;QACA,UAAU,kBAAkB,MAAM,IAAI,EAAE;QACxC;MACF;IACF;EACF;EACA,OAAO;AACT;AAaA;;;CAGC,GACD,OAAO,SAAS,kBACd,SAAiB,EACjB,MAMU,EACV,eAAiC;EAEjC,MAAM,OAAO,OAAO,WAAW,WAAW,SAAS,OAAO,IAAI;EAC9D,IAAI,OAAO,WAAW,UAAU;IAC9B,gBAAgB,IAAI,CAAC;MACnB,MAAM;MACN,QAAQ,OAAO,MAAM;MACrB,gBAAgB,OAAO,cAAc;MACrC,gBAAgB,OAAO,cAAc;MACrC,cAAc,OAAO,YAAY;IACnC;EACF;EACA,OAAO;AACT"}

package/src/ssg-i18n.js

@@ -0,0 +1,78 @@
+/**
+ * @openelement/ssg - i18n locale expansion
+ *
+ * Expands SSG output for each locale when i18n options are provided.
+ * Renders each route for every locale and writes locale-prefixed output.
+ */ import { join } from 'node:path';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { createLogger } from '@openelement/core/logger';
+import { formatError } from '@openelement/core/errors';
+import { collectPageOutput, resolveDynamicRoutePath } from './ssg-helpers.js';
+const log = createLogger('ssg');
+/**
+ * Expand rendered pages for each locale when i18n is configured.
+ *
+ * For each locale and each route, re-renders the route with the locale
+ * parameter and writes output under /{locale}/{path}/index.html.
+ */ export async function expandI18nLocales(evidence, renderRoute, routeInfo, getStaticPaths, options, root, outDir, pageDiagnostics) {
+  const i18nOpts = evidence.i18nOptions || null;
+  if (!i18nOpts || !renderRoute) return;
+  const locales = i18nOpts.locales || [];
+  if (locales.length <= 1) return;
+  log.info(`i18n: expanding for locales: ${locales.join(', ')}`);
+  for (const locale of locales){
+    for (const route of routeInfo){
+      let paramsList;
+      if (!route.isDynamic) {
+        paramsList = [
+          {}
+        ];
+      } else if (getStaticPaths) {
+        try {
+          paramsList = await getStaticPaths(route.path);
+        } catch  {
+          log.warn(`i18n: getStaticPaths failed for ${route.path}, skipping`);
+          continue;
+        }
+      } else {
+        continue;
+      }
+      if (paramsList.length === 0) continue;
+      const paramNames = route.paramNames;
+      for (const params of paramsList){
+        let resolvedPath;
+        try {
+          resolvedPath = resolveDynamicRoutePath(route.path, paramNames, params);
+        } catch (e) {
+          log.warn(`i18n: skipping unsafe dynamic route ${route.path}: ${formatError(e)}`);
+          continue;
+        }
+        const pathSegment = resolvedPath.split('/')[1] || '';
+        if (locales.includes(pathSegment)) {
+          continue;
+        }
+        const localePath = '/' + locale + '/' + resolvedPath.replace(/^\//, '');
+        try {
+          const output = await renderRoute(route.path, {
+            params,
+            locale,
+            title: options.html?.title,
+            lang: locale,
+            headExtras: options.headExtras
+          });
+          const html = collectPageOutput(localePath, output, pageDiagnostics);
+          const outputDir = join(root, outDir);
+          const pageDir = join(outputDir, localePath);
+          mkdirSync(pageDir, {
+            recursive: true
+          });
+          writeFileSync(join(pageDir, 'index.html'), html, 'utf-8');
+          log.info(`i18n: ${localePath}/index.html`);
+        } catch (e) {
+          log.warn(`i18n: failed for locale ${locale} on ${resolvedPath}: ${formatError(e)}`);
+        }
+      }
+    }
+  }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/ssg-render.d.ts

@@ -0,0 +1,3 @@
+import type { SsgRenderEvidence, SsgRenderOptions, SsrBundle } from '@openelement/protocol/ssg';
+export declare function ssgRender(module: SsrBundle, options: SsgRenderOptions, evidence?: SsgRenderEvidence): Promise<void>;
+export { resolveDynamicRoutePath } from "./ssg-helpers.js";

package/src/ssg-render.js

@@ -0,0 +1,162 @@
+/**
+ * adapter-vite internal SSG render pipeline (ADR 0022).
+ *
+ * Shared SSG rendering logic used by both:
+ *   - build-ssg.ts (Vite inline mode, called from closeBundle)
+ *   - ssg.ts (standalone CLI, loads SSR bundle via importmap)
+ *
+ * This module has zero Vite dependency - it only needs the SSR bundle module.
+ *
+ * Thin orchestrator that imports focused sub-modules for:
+ *   - Dynamic route expansion (ssg-dynamic.ts)
+ *   - i18n locale expansion (ssg-i18n.ts)
+ *   - DSD report assembly (ssg-report.ts)
+ *   - Utility helpers (ssg-helpers.ts)
+ */ import { join } from 'node:path';
+import process from 'node:process';
+import { existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { createLogger } from '@openelement/core/logger';
+import { expandDynamicRoutes } from './ssg-dynamic.js';
+import { expandI18nLocales } from './ssg-i18n.js';
+import { assembleDsdReport, writeDsdReport } from './ssg-report.js';
+import { buildIsrManifestEntries, findHtmlFiles } from './ssg-helpers.js';
+import { writeJson } from '@openelement/content/write-json';
+const log = createLogger('ssg');
+// ─── Core render pipeline ──────────────────────────────────────
+export async function ssgRender(module, options, evidence = {}) {
+  const root = options.root || process.cwd();
+  const outDir = options.outDir || 'dist';
+  const basePath = options.base || '/';
+  // ── Report collection (v0.15.3: dsd-report.json) ──────────────
+  const pageDiagnostics = [];
+  // ── Dynamic route expansion via bundle.getStaticPaths() ──────
+  const routeInfo = module.routeInfo ?? [];
+  const renderRoute = module.renderRoute;
+  const getStaticPaths = module.getStaticPaths;
+  const dynamicRoutes = routeInfo.filter((r)=>r.isDynamic);
+  log.info(`Routes: ${routeInfo.length} total` + (dynamicRoutes.length > 0 ? ` (${dynamicRoutes.length} dynamic: ${dynamicRoutes.map((r)=>r.path).join(', ')})` : ''));
+  const staticPathParamsByRoute = await expandDynamicRoutes(dynamicRoutes, renderRoute, getStaticPaths, options, root, outDir, pageDiagnostics);
+  // ── Main SSG via Hono's toSSG() ────────────────────────────
+  const { toSSG } = await import('hono/ssg');
+  const nodeFs = await import('node:fs/promises');
+  const nodePath = await import('node:path');
+  const fsModule = {
+    writeFile: async (path, data)=>{
+      const dir = nodePath.dirname(path);
+      await nodeFs.mkdir(dir, {
+        recursive: true
+      }).catch(()=>{});
+      await nodeFs.writeFile(path, data);
+    },
+    mkdir: async (path)=>{
+      await nodeFs.mkdir(path, {
+        recursive: true
+      }).catch(()=>{});
+    },
+    isDirectory: async (path)=>{
+      try {
+        return (await nodeFs.stat(path)).isDirectory();
+      } catch  {
+        return false;
+      }
+    }
+  };
+  const outputDir = join(root, outDir);
+  const app = module.default;
+  if (!app) {
+    throw new Error('SSR bundle loaded but no Hono app found (no default export)');
+  }
+  const result = await toSSG(app, fsModule, {
+    dir: outputDir
+  });
+  if (!result.success) throw result.error;
+  const isrRoutes = buildIsrManifestEntries(routeInfo, staticPathParamsByRoute);
+  if (isrRoutes.length > 0) {
+    writeFileSync(join(outputDir, 'isr-manifest.json'), writeJson(isrRoutes), 'utf-8');
+    log.info(`ISR manifest -> ${join(outputDir, 'isr-manifest.json')} (${isrRoutes.length} route(s))`);
+  }
+  // ── Post-processing ─────────────────────────────────────────
+  // Rename 404/index.html -> 404.html for GitHub Pages
+  const _404Dir = join(outputDir, '404');
+  const _404Html = join(outputDir, '404.html');
+  const _404Index = join(_404Dir, 'index.html');
+  if (existsSync(_404Index)) {
+    if (existsSync(_404Html)) {
+      log.warn('404.html already exists in output dir - removing before rename');
+      rmSync(_404Html, {
+        force: true
+      });
+    }
+    renameSync(_404Index, _404Html);
+    if (existsSync(_404Dir)) {
+      rmSync(_404Dir, {
+        recursive: true,
+        force: true
+      });
+    }
+    log.info('404 page -> dist/404.html (GitHub Pages)');
+  }
+  // Convert flat HTML files to clean URLs: about.html -> about/index.html
+  const allHtmlFiles = findHtmlFiles(outputDir);
+  for (const filePath of allHtmlFiles){
+    const rel = nodePath.relative(outputDir, filePath);
+    if (rel.endsWith('index.html') || rel === '404.html') continue;
+    const baseName = rel.replace(/\.html$/, '');
+    const urlBaseName = baseName.replace(/\\/g, '/');
+    const dirPath = join(outputDir, baseName);
+    const indexPath = join(dirPath, 'index.html');
+    if (existsSync(dirPath)) continue;
+    mkdirSync(dirPath, {
+      recursive: true
+    });
+    renameSync(filePath, indexPath);
+    log.info(`Clean URL: /${urlBaseName} -> ${urlBaseName}/index.html`);
+  }
+  log.info(`Static site generated -> ${outputDir}`);
+  // ── i18n locale expansion (if ctx available) ────────────────
+  await expandI18nLocales(evidence, renderRoute, routeInfo, getStaticPaths, options, root, outDir, pageDiagnostics);
+  // ── Post-processing modules ─────────────────────────────────
+  const { buildIslandChunkMap, injectCspMeta, injectDsdPolyfill, injectViewTransitionMeta, injectSpeculationRules, buildSpeculationRulesJson } = await import('./postprocess.js');
+  const islandTagNames = options.islandTagNames || [];
+  const _islandChunkMap = buildIslandChunkMap(root, outDir, islandTagNames, basePath);
+  if (options.viewTransition !== false) {
+    injectViewTransitionMeta(outputDir);
+    log.info('View Transitions meta tag injected');
+  }
+  if (options.speculation) {
+    const specOpts = typeof options.speculation === 'boolean' ? {} : options.speculation;
+    const rulesJson = buildSpeculationRulesJson(specOpts, routeInfo.map((r)=>({
+        path: r.path,
+        type: 'page'
+      })));
+    if (rulesJson) {
+      injectSpeculationRules(outputDir, rulesJson);
+      log.info('Speculation Rules injected');
+    }
+  }
+  const cspPolicy = options.middleware?.csp?.policy;
+  if (cspPolicy) {
+    injectCspMeta(outputDir, cspPolicy, options.middleware?.csp?.reportOnly || false, options.middleware?.csp?.nonce || false);
+    log.info('CSP meta tag injected');
+  }
+  injectDsdPolyfill(outputDir);
+  log.info('DSD polyfill injected');
+  // ── Sitemap (via ctx) ──────────────────────────────────────
+  await evidence.onPrintBuildManifest?.({
+    root,
+    outDir,
+    phase: 3,
+    headExtras: options.headExtras
+  });
+  try {
+    await evidence.onGenerateSitemap?.(join(root, outDir));
+  } catch  {
+    log.debug('Sitemap generation skipped or failed');
+  }
+  // ── dsd-report.json (v0.15.3) ──────────────────────────────────
+  const report = assembleDsdReport(pageDiagnostics, evidence);
+  writeDsdReport(outputDir, report);
+}
+// Re-export resolveDynamicRoutePath for consumers who import from ssg-render.ts
+export { resolveDynamicRoutePath } from './ssg-helpers.js';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/ssg/src/ssg-render.ts"],"sourcesContent":["/**\n * adapter-vite internal SSG render pipeline (ADR 0022).\n *\n * Shared SSG rendering logic used by both:\n *   - build-ssg.ts (Vite inline mode, called from closeBundle)\n *   - ssg.ts (standalone CLI, loads SSR bundle via importmap)\n *\n * This module has zero Vite dependency - it only needs the SSR bundle module.\n *\n * Thin orchestrator that imports focused sub-modules for:\n *   - Dynamic route expansion (ssg-dynamic.ts)\n *   - i18n locale expansion (ssg-i18n.ts)\n *   - DSD report assembly (ssg-report.ts)\n *   - Utility helpers (ssg-helpers.ts)\n */\n\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport { existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';\nimport type {\n  SsgPageOutput,\n  SsgRenderEvidence,\n  SsgRenderOptions,\n  SsrBundle,\n} from '@openelement/protocol/ssg';\nimport { createLogger } from '@openelement/core/logger';\nimport { expandDynamicRoutes } from './ssg-dynamic.js';\nimport { expandI18nLocales } from './ssg-i18n.js';\nimport { assembleDsdReport, writeDsdReport } from './ssg-report.js';\nimport { buildIsrManifestEntries, findHtmlFiles, type PageDiagnostic } from './ssg-helpers.js';\nimport { writeJson } from '@openelement/content/write-json';\n\nconst log = createLogger('ssg');\n\n// ─── Core render pipeline ──────────────────────────────────────\n\nexport async function ssgRender(\n  module: SsrBundle,\n  options: SsgRenderOptions,\n  evidence: SsgRenderEvidence = {},\n): Promise<void> {\n  const root = options.root || process.cwd();\n  const outDir = options.outDir || 'dist';\n  const basePath = options.base || '/';\n\n  // ── Report collection (v0.15.3: dsd-report.json) ──────────────\n  const pageDiagnostics: PageDiagnostic[] = [];\n\n  // ── Dynamic route expansion via bundle.getStaticPaths() ──────\n  const routeInfo = (module.routeInfo ?? []) as Array<{\n    path: string;\n    tagName: string;\n    isDynamic: boolean;\n    paramNames: string[];\n    revalidate?: number;\n  }>;\n  const renderRoute = module.renderRoute as\n    | ((path: string, opts?: Record<string, unknown>) => Promise<SsgPageOutput>)\n    | undefined;\n  const getStaticPaths = module.getStaticPaths as\n    | ((path: string) => Promise<Array<Record<string, string>>>)\n    | undefined;\n\n  const dynamicRoutes = routeInfo.filter((r) => r.isDynamic);\n  log.info(\n    `Routes: ${routeInfo.length} total` +\n      (dynamicRoutes.length > 0\n        ? ` (${dynamicRoutes.length} dynamic: ${dynamicRoutes.map((r) => r.path).join(', ')})`\n        : ''),\n  );\n\n  const staticPathParamsByRoute = await expandDynamicRoutes(\n    dynamicRoutes,\n    renderRoute,\n    getStaticPaths,\n    options,\n    root,\n    outDir,\n    pageDiagnostics,\n  );\n\n  // ── Main SSG via Hono's toSSG() ────────────────────────────\n  const { toSSG } = await import('hono/ssg');\n  const nodeFs = await import('node:fs/promises');\n  const nodePath = await import('node:path');\n\n  const fsModule = {\n    writeFile: async (path: string, data: string | Uint8Array) => {\n      const dir = nodePath.dirname(path);\n      await nodeFs.mkdir(dir, { recursive: true }).catch(() => {});\n      await nodeFs.writeFile(path, data);\n    },\n    mkdir: async (path: string) => {\n      await nodeFs.mkdir(path, { recursive: true }).catch(() => {});\n    },\n    isDirectory: async (path: string) => {\n      try {\n        return (await nodeFs.stat(path)).isDirectory();\n      } catch {\n        return false;\n      }\n    },\n  };\n\n  const outputDir = join(root, outDir);\n  const app = module.default as\n    | { fetch: (req: Request, ...args: unknown[]) => Promise<Response> }\n    | undefined;\n  if (!app) {\n    throw new Error(\n      'SSR bundle loaded but no Hono app found (no default export)',\n    );\n  }\n\n  const result = await toSSG(app as never, fsModule, { dir: outputDir });\n\n  if (!result.success) throw result.error;\n\n  const isrRoutes = buildIsrManifestEntries(routeInfo, staticPathParamsByRoute);\n  if (isrRoutes.length > 0) {\n    writeFileSync(\n      join(outputDir, 'isr-manifest.json'),\n      writeJson(isrRoutes),\n      'utf-8',\n    );\n    log.info(\n      `ISR manifest -> ${join(outputDir, 'isr-manifest.json')} (${isrRoutes.length} route(s))`,\n    );\n  }\n\n  // ── Post-processing ─────────────────────────────────────────\n\n  // Rename 404/index.html -> 404.html for GitHub Pages\n  const _404Dir = join(outputDir, '404');\n  const _404Html = join(outputDir, '404.html');\n  const _404Index = join(_404Dir, 'index.html');\n  if (existsSync(_404Index)) {\n    if (existsSync(_404Html)) {\n      log.warn(\n        '404.html already exists in output dir - removing before rename',\n      );\n      rmSync(_404Html, { force: true });\n    }\n    renameSync(_404Index, _404Html);\n    if (existsSync(_404Dir)) {\n      rmSync(_404Dir, { recursive: true, force: true });\n    }\n    log.info('404 page -> dist/404.html (GitHub Pages)');\n  }\n\n  // Convert flat HTML files to clean URLs: about.html -> about/index.html\n  const allHtmlFiles = findHtmlFiles(outputDir);\n  for (const filePath of allHtmlFiles) {\n    const rel = nodePath.relative(outputDir, filePath);\n    if (rel.endsWith('index.html') || rel === '404.html') continue;\n    const baseName = rel.replace(/\\.html$/, '');\n    const urlBaseName = baseName.replace(/\\\\/g, '/');\n    const dirPath = join(outputDir, baseName);\n    const indexPath = join(dirPath, 'index.html');\n    if (existsSync(dirPath)) continue;\n    mkdirSync(dirPath, { recursive: true });\n    renameSync(filePath, indexPath);\n    log.info(`Clean URL: /${urlBaseName} -> ${urlBaseName}/index.html`);\n  }\n\n  log.info(`Static site generated -> ${outputDir}`);\n\n  // ── i18n locale expansion (if ctx available) ────────────────\n  await expandI18nLocales(\n    evidence,\n    renderRoute,\n    routeInfo,\n    getStaticPaths,\n    options,\n    root,\n    outDir,\n    pageDiagnostics,\n  );\n\n  // ── Post-processing modules ─────────────────────────────────\n  const {\n    buildIslandChunkMap,\n    injectCspMeta,\n    injectDsdPolyfill,\n    injectViewTransitionMeta,\n    injectSpeculationRules,\n    buildSpeculationRulesJson,\n  } = await import('./postprocess.js');\n\n  const islandTagNames = options.islandTagNames || [];\n  const _islandChunkMap = buildIslandChunkMap(\n    root,\n    outDir,\n    islandTagNames,\n    basePath,\n  );\n\n  if (options.viewTransition !== false) {\n    injectViewTransitionMeta(outputDir);\n    log.info('View Transitions meta tag injected');\n  }\n\n  if (options.speculation) {\n    const specOpts = typeof options.speculation === 'boolean'\n      ? {}\n      : (options.speculation as Record<string, unknown>);\n    const rulesJson = buildSpeculationRulesJson(\n      specOpts,\n      routeInfo.map((r) => ({ path: r.path, type: 'page' as const })),\n    );\n    if (rulesJson) {\n      injectSpeculationRules(outputDir, rulesJson);\n      log.info('Speculation Rules injected');\n    }\n  }\n\n  const cspPolicy = options.middleware?.csp?.policy;\n  if (cspPolicy) {\n    injectCspMeta(\n      outputDir,\n      cspPolicy,\n      options.middleware?.csp?.reportOnly || false,\n      options.middleware?.csp?.nonce || false,\n    );\n    log.info('CSP meta tag injected');\n  }\n\n  injectDsdPolyfill(outputDir);\n  log.info('DSD polyfill injected');\n\n  // ── Sitemap (via ctx) ──────────────────────────────────────\n  await evidence.onPrintBuildManifest?.({\n    root,\n    outDir,\n    phase: 3,\n    headExtras: options.headExtras,\n  });\n\n  try {\n    await evidence.onGenerateSitemap?.(join(root, outDir));\n  } catch {\n    log.debug('Sitemap generation skipped or failed');\n  }\n\n  // ── dsd-report.json (v0.15.3) ──────────────────────────────────\n  const report = assembleDsdReport(pageDiagnostics, evidence);\n  writeDsdReport(outputDir, report);\n}\n\n// Re-export resolveDynamicRoutePath for consumers who import from ssg-render.ts\nexport { resolveDynamicRoutePath } from './ssg-helpers.js';\n"],"names":[],"mappings":"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"}