@openelement/ssg 0.41.0-alpha.1

package/src/entry-renderer.js

@@ -0,0 +1,555 @@
+/**
+ * @openelement/core - Entry Renderer
+ *
+ * Pure function: routes + options -> Hono entry virtual module code.
+ *
+ * openElement Architecture (v0.5.0):
+ * - API routes use Hono standard app.route() (not app.all + fetch transform)
+ * - Island upgrade is handled by the client entry (built by Vite in Phase 2).
+ *   No inline script in SSG HTML; the client entry is a Vite-built module
+ *   referenced via <script type="module" src="..."> and imports island modules
+ *   for side-effect custom element registration.
+ * - HTML document wrapping delegates to wrapInDocument from html-escape.ts
+ *   (imported at runtime - single source of truth, no duplicate HTML logic)
+ * - DSD output must remain plain HTML, without Lit SSR marker comments.
+ *
+ * H-16 KNOWN ISSUE: Circular dependency between adapter-vite <-> content
+ *   adapter-vite generates code that imports @openelement/content/sitemap
+ *   content package imports @openelement/adapter-vite/build-context
+ * Shared contracts now live in @openelement/core, @openelement/ssg, @openelement/router,
+ * and @openelement/signal. Generated optional package imports are still emitted explicitly
+ * so consumer import maps can be checked.
+ *
+ * Thin orchestrator: delegates code generation to focused sub-modules:
+ *   - entry-render-helpers.ts  — individual code fragment generators
+ *   - entry-render-runtime.ts  — runtime helper function code generation
+ *   - entry-render-ssg.ts      — SSG re-export & routeInfo/renderRoute/getStaticPaths
+ *
+ * v0.41.0-alpha.1: The intermediate EntryDescriptor data model was collapsed
+ * into this file. `generateHonoEntryCode()` builds descriptor-shaped data and
+ * passes it directly to `renderEntry()` without a separate public descriptor
+ * builder or file.
+ */ import { fileToTagName } from './route-scanner.js';
+import { renderActionRoute, renderApiRoute, renderDataEndpoint, renderDataRouteMap, renderImport, renderMiddleware, renderPageRoute, routeTagNameExpr } from './entry-render-helpers.js';
+import { renderRuntimeHelpers } from './entry-render-runtime.js';
+import { renderSsgSection } from './entry-render-ssg.js';
+/**
+ * Render an EntryDescriptor into a complete virtual module string.
+ *
+ * Pure function - deterministic, testable, side-effect-free.
+ */ export function renderEntry(desc) {
+  const lines = [];
+  const ssrAdmissionPlan = desc.ssrAdmissionPlan;
+  // --- Imports ---
+  for (const imp of desc.imports){
+    lines.push(renderImport(imp));
+  }
+  // --- Island lookup (build-time known list) ---
+  const islandLookup = {};
+  for (const island of desc.islands){
+    islandLookup[island.tagName] = island.modulePath;
+  }
+  const appShellImports = new Set();
+  const collectShellImport = (shell)=>{
+    if (shell) appShellImports.add(shell.importPath);
+  };
+  collectShellImport(desc.appShell.default);
+  for (const shell of Object.values(desc.appShell.layouts))collectShellImport(shell);
+  lines.push(`// Known islands (determined at build time by scanning islandsDir)`);
+  lines.push(`const __islandMap = ${JSON.stringify(islandLookup)}`);
+  lines.push('');
+  // --- Document wrapper ---
+  lines.push(`import { wrapInDocument } from '@openelement/core';`);
+  lines.push(`import { jsx } from '@openelement/core/jsx-runtime';`);
+  lines.push(`import { createLogger } from '@openelement/core/logger';`);
+  lines.push(`import { createRuntimeAdapter } from '@openelement/core/runtime';`);
+  lines.push(`import { headerNav as __headerNav, navSections as __navSections } from '@openelement/generated/nav';`);
+  lines.push(`import { getDefaultLocale as __getDefaultLocale, locales as __locales } from '@openelement/generated/i18n';`);
+  for (const importPath of appShellImports){
+    lines.push(`import '${importPath}';`);
+  }
+  lines.push(`const log = createLogger('core');`);
+  lines.push('');
+  // --- Route module imports ---
+  for (const route of [
+    ...desc.apiRoutes,
+    ...desc.pageRoutes
+  ]){
+    lines.push(`import * as ${route.varName} from '${route.importPath}'`);
+  }
+  for (const renderer of desc.renderers){
+    lines.push(`import * as ${renderer.varName} from '${renderer.importPath}'`);
+  }
+  for (const mwScope of desc.middlewareScopes){
+    lines.push(`import * as ${mwScope.varName} from '${mwScope.importPath}'`);
+  }
+  lines.push('');
+  // --- Register page components in SSR customElements registry ---
+  {
+    lines.push('// ADR 0014: Idempotent customElements.define for SSR (dev + SSG)');
+    lines.push('// Island modules call customElements.define() as a side-effect.');
+    lines.push('// The SSR dom-shim does not make define() idempotent, so we patch it.');
+    lines.push('const _origDefine = customElements.define.bind(customElements);');
+    lines.push('customElements.define = (name, ctor, options) => {');
+    lines.push('  if (customElements.get(name)) return;');
+    lines.push('  try { _origDefine(name, ctor, options); } catch { /* already defined */ }');
+    lines.push('};');
+    lines.push('');
+  }
+  for (const route of desc.pageRoutes){
+    const tagNameExpr = routeTagNameExpr(route.varName, route.tagName);
+    lines.push(`if (!customElements.get(${tagNameExpr})) {`);
+    lines.push(`  customElements.define(${tagNameExpr}, ${route.varName}.default)`);
+    lines.push(`}`);
+  }
+  lines.push('');
+  // --- Register island components in SSR customElements registry ---
+  const ssrRenderableTags = new Set(ssrAdmissionPlan.renderableTags);
+  const ssrIslands = desc.islands.filter((island)=>ssrRenderableTags.has(island.tagName));
+  for (const island of ssrIslands){
+    const varName = `__island_${island.tagName.replace(/-/g, '_')}`;
+    lines.push(`import * as ${varName} from '${island.modulePath}'`);
+  }
+  for (const island of ssrIslands){
+    const varName = `__island_${island.tagName.replace(/-/g, '_')}`;
+    const componentVar = `__island_component_${island.tagName.replace(/-/g, '_')}`;
+    lines.push(`const ${componentVar} = ${varName}?.default`);
+    lines.push(`if (${componentVar} && !customElements.get('${island.tagName}')) {`);
+    lines.push(`  customElements.define('${island.tagName}', ${componentVar})`);
+    lines.push(`}`);
+  }
+  lines.push('');
+  lines.push('// v0.17.4: SSR admission plan');
+  lines.push(`(globalThis).__CLIENT_ONLY_TAGS__ = new Set(${JSON.stringify(ssrAdmissionPlan.clientOnlyTags)})`);
+  lines.push(`export const ssrAdmissionPlan = ${JSON.stringify(ssrAdmissionPlan, null, 2)};`);
+  lines.push('');
+  // --- SSG: headExtras via define injection ---
+  if (desc.isSSG && desc.document.headExtras) {
+    lines.push('// SSG: headExtras injected via Vite define (ADR 0008 Phase A)');
+    lines.push('// Replaces the old .openElement/head-extras.html runtime file read');
+    lines.push('const __headExtras = __HEAD_EXTRAS__ || "";');
+    lines.push('');
+  }
+  // --- Runtime helpers ---
+  lines.push(renderRuntimeHelpers(desc.appShell));
+  lines.push('');
+  // --- App creation + Middleware ---
+  lines.push('const app = new Hono()');
+  lines.push('');
+  for (const mw of desc.middleware){
+    renderMiddleware(lines, mw);
+  }
+  // --- Middleware scopes (v0.3.0: _middleware.ts files) ---
+  for (const mwScope of desc.middlewareScopes){
+    lines.push(`// Middleware scope: ${mwScope.scope} (${mwScope.importPath})`);
+    lines.push(`app.use('${mwScope.scope === '/' ? '' : mwScope.scope}/*', ${mwScope.varName}.default)`);
+    lines.push('');
+  }
+  // --- API routes ---
+  for (const route of desc.apiRoutes){
+    renderApiRoute(lines, route);
+  }
+  // --- Page routes ---
+  const docConfig = {
+    title: desc.document.title,
+    lang: desc.document.lang,
+    headExtras: desc.document.headExtras,
+    allowHeadExtrasScripts: desc.document.allowHeadExtrasScripts
+  };
+  for (const route of desc.pageRoutes){
+    renderPageRoute(lines, route, desc.renderers, docConfig, desc.isSSG);
+  }
+  // --- Action POST handlers ---
+  for (const route of desc.pageRoutes){
+    renderActionRoute(lines, route, desc.renderers, docConfig, desc.isSSG);
+  }
+  // --- /_data endpoint for SPA navigation ---
+  renderDataRouteMap(lines, desc.pageRoutes);
+  renderDataEndpoint(lines);
+  // --- Export ---
+  lines.push('export const openElementHandler = (request, context = {}) => {');
+  lines.push('  return app.fetch(request, context.env || {}, context.platform)');
+  lines.push('}');
+  lines.push('');
+  lines.push('export const openElementRuntimeAdapter = {');
+  lines.push("  ...createRuntimeAdapter({ name: 'openelement-hono', fetch: openElementHandler }),");
+  lines.push('}');
+  lines.push('');
+  lines.push('export default app');
+  // --- SSG section ---
+  const ssgSection = renderSsgSection(desc);
+  if (ssgSection) {
+    lines.push(ssgSection);
+  }
+  return lines.join('\n');
+}
+function normalizeAppShellImport(importPath) {
+  if (importPath.startsWith('./')) return `/${importPath.slice(2)}`;
+  if (importPath.startsWith('../')) return importPath;
+  return importPath;
+}
+function normalizeAppShell(config) {
+  if (config === false) return false;
+  if (config === undefined || config === 'default') {
+    return {
+      tagName: 'open-layout',
+      importPath: '@openelement/ui/open-layout',
+      props: {}
+    };
+  }
+  return {
+    tagName: config.tagName,
+    importPath: normalizeAppShellImport(config.import),
+    props: config.props ?? {}
+  };
+}
+function buildAppShellPlan(options) {
+  const defaultShell = normalizeAppShell(options.layouts?.default ?? options.appShell);
+  const layouts = {};
+  for (const [name, config] of Object.entries(options.layouts ?? {})){
+    if (name === 'default' || config === undefined) continue;
+    layouts[name] = normalizeAppShell(config);
+  }
+  return {
+    default: defaultShell,
+    layouts
+  };
+}
+export function buildEntryDescriptor(routes, options = {}) {
+  const routesDir = options.routesDir || 'app/routes';
+  const islandsDir = options.islandsDir || 'app/islands';
+  const isSSG = options.ssg === true;
+  // --- Imports ---
+  const imports = [];
+  // Always needed
+  imports.push({
+    from: 'hono',
+    names: [
+      'Hono'
+    ]
+  });
+  imports.push({
+    from: '@openelement/core',
+    names: [
+      'renderDsd',
+      'renderDsdTree',
+      'escapeHtml'
+    ]
+  });
+  // Conditional middleware imports
+  const mw = options.middleware;
+  if (mw?.requestId !== false) {
+    imports.push({
+      from: 'hono/request-id',
+      names: [
+        'requestId'
+      ]
+    });
+  }
+  if (mw?.logger !== false) {
+    imports.push({
+      from: 'hono/logger',
+      names: [
+        'logger'
+      ],
+      alias: 'honoLogger'
+    });
+  }
+  if (mw?.cors !== false) {
+    imports.push({
+      from: 'hono/cors',
+      names: [
+        'cors'
+      ]
+    });
+  }
+  if (mw?.securityHeaders !== false) {
+    imports.push({
+      from: 'hono/secure-headers',
+      names: [
+        'secureHeaders'
+      ]
+    });
+  }
+  // --- Middleware ---
+  const middleware = [];
+  if (mw?.requestId !== false) {
+    middleware.push({
+      kind: 'requestId',
+      comment: '1. Request ID - base for logging and error tracking'
+    });
+  }
+  if (mw?.logger !== false) {
+    middleware.push({
+      kind: 'logger',
+      comment: '2. Logger - structured request logging'
+    });
+  }
+  if (mw?.cors !== false) {
+    let corsOrigin;
+    if (mw?.corsOrigin !== undefined) {
+      if (typeof mw.corsOrigin === 'string') {
+        corsOrigin = mw.corsOrigin;
+      } else if (Array.isArray(mw.corsOrigin)) {
+        corsOrigin = mw.corsOrigin;
+      } else {
+        corsOrigin = {
+          type: 'function',
+          body: mw.corsOrigin.toString()
+        };
+      }
+    }
+    middleware.push({
+      kind: 'cors',
+      comment: '3. CORS - Web Standards (no process.env)',
+      config: {
+        corsOrigin
+      }
+    });
+  }
+  if (mw?.securityHeaders !== false) {
+    middleware.push({
+      kind: 'securityHeaders',
+      comment: '4. Security headers'
+    });
+  }
+  if (mw?.csp) {
+    middleware.push({
+      kind: 'csp',
+      comment: '5. Content Security Policy',
+      config: {
+        csp: mw.csp
+      }
+    });
+  }
+  // --- Routes ---
+  const apiRoutes = routes.filter((r)=>r.type === 'api' && !r.special).map((r)=>({
+      kind: 'api',
+      path: r.path,
+      varName: `$${r.varName}`,
+      filePath: r.filePath,
+      importPath: `/${routesDir}/${r.filePath}`
+    }));
+  const pageRoutes = routes.filter((r)=>r.type === 'page' && !r.special).map((r)=>{
+    const isDynamic = r.path.includes(':');
+    const paramNames = isDynamic ? [
+      ...r.path.matchAll(/:([^/]+)/g)
+    ].map((m)=>m[1]) : [];
+    return {
+      kind: 'page',
+      path: r.path,
+      varName: `$${r.varName}`,
+      filePath: r.filePath,
+      defaultTagName: fileToTagName(r.filePath),
+      tagName: r.tagName || fileToTagName(r.filePath),
+      importPath: `/${routesDir}/${r.filePath}`,
+      isDynamic,
+      paramNames
+    };
+  });
+  // --- Special files: _renderer.ts / _middleware.ts (v0.3.0) ---
+  const specialRoutes = routes.filter((r)=>r.type === 'special');
+  const renderers = specialRoutes.filter((r)=>r.special === 'renderer').map((r)=>{
+    const scope = r.path.replace(/\/?_renderer$/, '') || '/';
+    const depth = scope === '/' ? 0 : scope.split('/').filter(Boolean).length;
+    return {
+      varName: `$${r.varName}`,
+      scope,
+      importPath: `/${routesDir}/${r.filePath}`,
+      depth
+    };
+  }).sort((a, b)=>b.depth - a.depth);
+  const middlewareScopes = specialRoutes.filter((r)=>r.special === 'middleware').map((r)=>({
+      varName: `$${r.varName}`,
+      scope: r.path.replace(/\/?_middleware$/, '') || '/',
+      importPath: `/${routesDir}/${r.filePath}`
+    }));
+  // --- Islands ---
+  const islandTagNames = options.islandTagNames || [];
+  const islandFiles = options.islandFiles || [];
+  const islandMeta = options.islandMeta || {};
+  const packageManifests = options.packageManifests || [];
+  const localIslands = islandTagNames.map((tagName, i)=>({
+      tagName,
+      modulePath: islandFiles[i] ? `/${islandsDir}/${islandFiles[i]}` : `/${islandsDir}/${tagName}.ts`,
+      source: 'local',
+      ssr: islandMeta[tagName]?.hydrate === 'only' ? false : islandMeta[tagName]?.ssr,
+      dsd: islandMeta[tagName]?.hydrate === 'only' ? false : islandMeta[tagName]?.dsd,
+      hydrate: islandMeta[tagName]?.hydrate || options.upgradeStrategy || 'idle',
+      reason: islandMeta[tagName]?.reason
+    }));
+  const packageIslandDecls = packageManifests.flatMap((pkg)=>pkg.declarations.filter((d)=>d.openElement?.module).map((d)=>{
+      const modulePath = d.openElement?.module;
+      if (!modulePath) {
+        throw new Error(`Package manifest declaration "${d.tagName}" is missing openElement.module`);
+      }
+      return {
+        tagName: d.tagName,
+        modulePath,
+        isPackage: true,
+        source: 'package',
+        hydrate: d.openElement?.hydrate || options.upgradeStrategy || 'idle',
+        ssr: d.openElement?.hydrate === 'only' ? false : d.openElement?.ssr,
+        dsd: d.openElement?.hydrate === 'only' ? false : d.openElement?.dsd
+      };
+    }));
+  const islands = [
+    ...localIslands,
+    ...packageIslandDecls
+  ];
+  const cemClassifications = options.cemClassifications || [];
+  const ssrAdmissionPlan = buildSsrAdmissionPlan(islands, cemClassifications, options.clientOnlyTags || []);
+  // --- Document ---
+  const document = {
+    lang: options.html?.lang || 'en',
+    title: options.html?.title || 'openElement',
+    headExtras: options.headExtras || '',
+    allowHeadExtrasScripts: options.allowHeadExtrasScripts || false
+  };
+  const appShell = buildAppShellPlan({
+    appShell: options.appShell,
+    layouts: options.layouts
+  });
+  // --- Debug routes (dev only) ---
+  const debugRoutes = isSSG ? undefined : routes.filter((r)=>!r.special).map((r)=>({
+      path: r.path,
+      type: r.type
+    }));
+  return {
+    isSSG,
+    imports,
+    middleware,
+    apiRoutes,
+    pageRoutes,
+    islands,
+    ssrAdmissionPlan,
+    cemClassifications,
+    clientOnlyTags: options.clientOnlyTags,
+    renderers,
+    middlewareScopes,
+    document,
+    appShell,
+    upgradeStrategy: options.upgradeStrategy || 'idle',
+    debugRoutes
+  };
+}
+export function buildSsrAdmissionPlan(islands, cemClassifications = [], clientOnlyTags = []) {
+  const renderableTags = [];
+  const mergedClientOnlyTags = [];
+  const rejectedTags = [];
+  const reasons = {};
+  const decisions = [];
+  const seen = new Set();
+  const admittedTags = new Set();
+  const cemMap = new Map();
+  for (const classification of cemClassifications){
+    cemMap.set(classification.tagName, classification);
+  }
+  for (const island of islands){
+    const source = island.source || (island.isPackage ? 'package' : 'local');
+    if (seen.has(island.tagName)) {
+      const reason = 'duplicate custom element tag';
+      rejectedTags.push(island.tagName);
+      reasons[island.tagName] = reason;
+      if (admittedTags.has(island.tagName)) {
+        const rIdx = renderableTags.indexOf(island.tagName);
+        if (rIdx !== -1) renderableTags.splice(rIdx, 1);
+        const cIdx = mergedClientOnlyTags.indexOf(island.tagName);
+        if (cIdx !== -1) mergedClientOnlyTags.splice(cIdx, 1);
+        admittedTags.delete(island.tagName);
+      }
+      decisions.push({
+        tagName: island.tagName,
+        modulePath: island.modulePath,
+        source,
+        renderPath: 'rejected',
+        reason
+      });
+      continue;
+    }
+    seen.add(island.tagName);
+    let renderPath;
+    let reason;
+    const cemClassification = cemMap.get(island.tagName);
+    if (cemClassification) {
+      const TIER_RENDER_PATH = {
+        'ssr-capable': 'ssr+client',
+        'client-only': 'client-only',
+        'experimental-dom': 'client-only',
+        rejected: 'rejected'
+      };
+      const knownTier = cemClassification.tier in TIER_RENDER_PATH;
+      renderPath = TIER_RENDER_PATH[cemClassification.tier] ?? 'client-only';
+      reason = knownTier ? `CEM ${cemClassification.tier}: ${cemClassification.reason}` : `Unknown CEM tier (${cemClassification.tier}) - conservative default to client-only`;
+    } else if (island.hydrate === 'only') {
+      renderPath = 'client-only';
+      reason = island.reason || 'client:only island is excluded from SSR';
+    } else if (island.ssr === false) {
+      renderPath = 'client-only';
+      reason = island.reason || 'openElement.ssr is false';
+    } else if (source === 'package') {
+      if (island.ssr === true) {
+        renderPath = 'ssr+client';
+        reason = 'package island with openElement.ssr=true';
+      } else {
+        renderPath = 'client-only';
+        reason = 'package island has no validated SSR capability (conservative default)';
+      }
+    } else {
+      renderPath = 'ssr+client';
+      reason = island.ssr === true ? 'openElement.ssr is true' : 'local island default SSR path';
+    }
+    if (renderPath === 'ssr+client') {
+      renderableTags.push(island.tagName);
+      admittedTags.add(island.tagName);
+    }
+    if (renderPath === 'client-only') {
+      mergedClientOnlyTags.push(island.tagName);
+      admittedTags.add(island.tagName);
+    }
+    if (renderPath === 'rejected') {
+      rejectedTags.push(island.tagName);
+      admittedTags.delete(island.tagName);
+    }
+    reasons[island.tagName] = reason;
+    decisions.push({
+      tagName: island.tagName,
+      modulePath: island.modulePath,
+      source,
+      renderPath,
+      reason
+    });
+  }
+  for (const tag of clientOnlyTags){
+    if (!seen.has(tag) && !admittedTags.has(tag)) {
+      mergedClientOnlyTags.push(tag);
+      admittedTags.add(tag);
+      seen.add(tag);
+      reasons[tag] = 'Registry client-only component (ADR-0035)';
+      decisions.push({
+        tagName: tag,
+        modulePath: '',
+        source: 'nested',
+        renderPath: 'client-only',
+        reason: 'Registry client-only component (ADR-0035)'
+      });
+    }
+  }
+  return {
+    renderableTags,
+    clientOnlyTags: mergedClientOnlyTags,
+    rejectedTags,
+    reasons,
+    decisions,
+    cemClassifications
+  };
+}
+/**
+ * Generate the Hono entry module code from scanned routes.
+ *
+ * Internally builds a descriptor-shaped object and renders it directly.
+ */ export function generateHonoEntryCode(routes, options = {}) {
+  const descriptor = buildEntryDescriptor(routes, options);
+  return renderEntry(descriptor);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/ssg/src/entry-renderer.ts"],"sourcesContent":["/**\n * @openelement/core - Entry Renderer\n *\n * Pure function: routes + options -> Hono entry virtual module code.\n *\n * openElement Architecture (v0.5.0):\n * - API routes use Hono standard app.route() (not app.all + fetch transform)\n * - Island upgrade is handled by the client entry (built by Vite in Phase 2).\n *   No inline script in SSG HTML; the client entry is a Vite-built module\n *   referenced via <script type=\"module\" src=\"...\"> and imports island modules\n *   for side-effect custom element registration.\n * - HTML document wrapping delegates to wrapInDocument from html-escape.ts\n *   (imported at runtime - single source of truth, no duplicate HTML logic)\n * - DSD output must remain plain HTML, without Lit SSR marker comments.\n *\n * H-16 KNOWN ISSUE: Circular dependency between adapter-vite <-> content\n *   adapter-vite generates code that imports @openelement/content/sitemap\n *   content package imports @openelement/adapter-vite/build-context\n * Shared contracts now live in @openelement/core, @openelement/ssg, @openelement/router,\n * and @openelement/signal. Generated optional package imports are still emitted explicitly\n * so consumer import maps can be checked.\n *\n * Thin orchestrator: delegates code generation to focused sub-modules:\n *   - entry-render-helpers.ts  — individual code fragment generators\n *   - entry-render-runtime.ts  — runtime helper function code generation\n *   - entry-render-ssg.ts      — SSG re-export & routeInfo/renderRoute/getStaticPaths\n *\n * v0.41.0-alpha.1: The intermediate EntryDescriptor data model was collapsed\n * into this file. `generateHonoEntryCode()` builds descriptor-shaped data and\n * passes it directly to `renderEntry()` without a separate public descriptor\n * builder or file.\n */\n\nimport type {\n  ApiRouteDecl,\n  AppShellPlan,\n  CorsOriginConfig,\n  DocumentConfig,\n  EntryDescriptor,\n  ImportDecl,\n  IslandDecl,\n  MiddlewareDecl,\n  PageRouteDecl,\n  RendererDecl,\n  ResolvedAppShell,\n  SsrAdmissionPlan,\n} from '@openelement/protocol/ssg';\nimport type {\n  AppShellConfig,\n  CompatibilityClassification,\n  FrameworkOptions,\n  HydrationStrategy,\n  RouteEntry,\n} from '@openelement/protocol/framework';\nimport type { OpenElementPackageManifest } from '@openelement/protocol/manifest';\nimport type { SsrAdmissionDecision } from '@openelement/protocol/render';\nimport { fileToTagName } from './route-scanner.js';\nimport {\n  renderActionRoute,\n  renderApiRoute,\n  renderDataEndpoint,\n  renderDataRouteMap,\n  renderImport,\n  renderMiddleware,\n  renderPageRoute,\n  routeTagNameExpr,\n} from './entry-render-helpers.js';\nimport { renderRuntimeHelpers } from './entry-render-runtime.js';\nimport { renderSsgSection } from './entry-render-ssg.js';\n\n// Re-export the canonical descriptor type for consumers that need it.\nexport type { EntryDescriptor } from '@openelement/protocol/ssg';\n\n/**\n * Render an EntryDescriptor into a complete virtual module string.\n *\n * Pure function - deterministic, testable, side-effect-free.\n */\nexport function renderEntry(desc: EntryDescriptor): string {\n  const lines: string[] = [];\n  const ssrAdmissionPlan = desc.ssrAdmissionPlan;\n\n  // --- Imports ---\n  for (const imp of desc.imports) {\n    lines.push(renderImport(imp));\n  }\n\n  // --- Island lookup (build-time known list) ---\n  const islandLookup: Record<string, string> = {};\n  for (const island of desc.islands) {\n    islandLookup[island.tagName] = island.modulePath;\n  }\n  const appShellImports = new Set<string>();\n  const collectShellImport = (shell: typeof desc.appShell.default) => {\n    if (shell) appShellImports.add(shell.importPath);\n  };\n  collectShellImport(desc.appShell.default);\n  for (const shell of Object.values(desc.appShell.layouts)) collectShellImport(shell);\n\n  lines.push(\n    `// Known islands (determined at build time by scanning islandsDir)`,\n  );\n  lines.push(`const __islandMap = ${JSON.stringify(islandLookup)}`);\n  lines.push('');\n\n  // --- Document wrapper ---\n  lines.push(`import { wrapInDocument } from '@openelement/core';`);\n  lines.push(`import { jsx } from '@openelement/core/jsx-runtime';`);\n  lines.push(`import { createLogger } from '@openelement/core/logger';`);\n  lines.push(`import { createRuntimeAdapter } from '@openelement/core/runtime';`);\n  lines.push(\n    `import { headerNav as __headerNav, navSections as __navSections } from '@openelement/generated/nav';`,\n  );\n  lines.push(\n    `import { getDefaultLocale as __getDefaultLocale, locales as __locales } from '@openelement/generated/i18n';`,\n  );\n  for (const importPath of appShellImports) {\n    lines.push(`import '${importPath}';`);\n  }\n  lines.push(`const log = createLogger('core');`);\n  lines.push('');\n\n  // --- Route module imports ---\n  for (const route of [...desc.apiRoutes, ...desc.pageRoutes]) {\n    lines.push(`import * as ${route.varName} from '${route.importPath}'`);\n  }\n  for (const renderer of desc.renderers) {\n    lines.push(`import * as ${renderer.varName} from '${renderer.importPath}'`);\n  }\n  for (const mwScope of desc.middlewareScopes) {\n    lines.push(`import * as ${mwScope.varName} from '${mwScope.importPath}'`);\n  }\n  lines.push('');\n\n  // --- Register page components in SSR customElements registry ---\n  {\n    lines.push('// ADR 0014: Idempotent customElements.define for SSR (dev + SSG)');\n    lines.push(\n      '// Island modules call customElements.define() as a side-effect.',\n    );\n    lines.push(\n      '// The SSR dom-shim does not make define() idempotent, so we patch it.',\n    );\n    lines.push(\n      'const _origDefine = customElements.define.bind(customElements);',\n    );\n    lines.push('customElements.define = (name, ctor, options) => {');\n    lines.push('  if (customElements.get(name)) return;');\n    lines.push(\n      '  try { _origDefine(name, ctor, options); } catch { /* already defined */ }',\n    );\n    lines.push('};');\n    lines.push('');\n  }\n  for (const route of desc.pageRoutes) {\n    const tagNameExpr = routeTagNameExpr(route.varName, route.tagName);\n    lines.push(\n      `if (!customElements.get(${tagNameExpr})) {`,\n    );\n    lines.push(\n      `  customElements.define(${tagNameExpr}, ${route.varName}.default)`,\n    );\n    lines.push(`}`);\n  }\n  lines.push('');\n\n  // --- Register island components in SSR customElements registry ---\n  const ssrRenderableTags = new Set(ssrAdmissionPlan.renderableTags);\n  const ssrIslands = desc.islands.filter((island) => ssrRenderableTags.has(island.tagName));\n  for (const island of ssrIslands) {\n    const varName = `__island_${island.tagName.replace(/-/g, '_')}`;\n    lines.push(`import * as ${varName} from '${island.modulePath}'`);\n  }\n  for (const island of ssrIslands) {\n    const varName = `__island_${island.tagName.replace(/-/g, '_')}`;\n    const componentVar = `__island_component_${island.tagName.replace(/-/g, '_')}`;\n    lines.push(`const ${componentVar} = ${varName}?.default`);\n    lines.push(\n      `if (${componentVar} && !customElements.get('${island.tagName}')) {`,\n    );\n    lines.push(`  customElements.define('${island.tagName}', ${componentVar})`);\n    lines.push(`}`);\n  }\n  lines.push('');\n\n  lines.push('// v0.17.4: SSR admission plan');\n  lines.push(\n    `(globalThis).__CLIENT_ONLY_TAGS__ = new Set(${\n      JSON.stringify(ssrAdmissionPlan.clientOnlyTags)\n    })`,\n  );\n  lines.push(\n    `export const ssrAdmissionPlan = ${JSON.stringify(ssrAdmissionPlan, null, 2)};`,\n  );\n  lines.push('');\n\n  // --- SSG: headExtras via define injection ---\n  if (desc.isSSG && desc.document.headExtras) {\n    lines.push(\n      '// SSG: headExtras injected via Vite define (ADR 0008 Phase A)',\n    );\n    lines.push('// Replaces the old .openElement/head-extras.html runtime file read');\n    lines.push('const __headExtras = __HEAD_EXTRAS__ || \"\";');\n    lines.push('');\n  }\n\n  // --- Runtime helpers ---\n  lines.push(renderRuntimeHelpers(desc.appShell));\n  lines.push('');\n\n  // --- App creation + Middleware ---\n  lines.push('const app = new Hono()');\n  lines.push('');\n\n  for (const mw of desc.middleware) {\n    renderMiddleware(lines, mw);\n  }\n\n  // --- Middleware scopes (v0.3.0: _middleware.ts files) ---\n  for (const mwScope of desc.middlewareScopes) {\n    lines.push(`// Middleware scope: ${mwScope.scope} (${mwScope.importPath})`);\n    lines.push(\n      `app.use('${mwScope.scope === '/' ? '' : mwScope.scope}/*', ${mwScope.varName}.default)`,\n    );\n    lines.push('');\n  }\n\n  // --- API routes ---\n  for (const route of desc.apiRoutes) {\n    renderApiRoute(lines, route);\n  }\n\n  // --- Page routes ---\n  const docConfig = {\n    title: desc.document.title,\n    lang: desc.document.lang,\n    headExtras: desc.document.headExtras,\n    allowHeadExtrasScripts: desc.document.allowHeadExtrasScripts,\n  };\n  for (const route of desc.pageRoutes) {\n    renderPageRoute(lines, route, desc.renderers, docConfig, desc.isSSG);\n  }\n\n  // --- Action POST handlers ---\n  for (const route of desc.pageRoutes) {\n    renderActionRoute(lines, route, desc.renderers, docConfig, desc.isSSG);\n  }\n\n  // --- /_data endpoint for SPA navigation ---\n  renderDataRouteMap(lines, desc.pageRoutes);\n  renderDataEndpoint(lines);\n\n  // --- Export ---\n  lines.push('export const openElementHandler = (request, context = {}) => {');\n  lines.push('  return app.fetch(request, context.env || {}, context.platform)');\n  lines.push('}');\n  lines.push('');\n  lines.push('export const openElementRuntimeAdapter = {');\n  lines.push(\"  ...createRuntimeAdapter({ name: 'openelement-hono', fetch: openElementHandler }),\");\n  lines.push('}');\n  lines.push('');\n  lines.push('export default app');\n\n  // --- SSG section ---\n  const ssgSection = renderSsgSection(desc);\n  if (ssgSection) {\n    lines.push(ssgSection);\n  }\n\n  return lines.join('\\n');\n}\n\nfunction normalizeAppShellImport(importPath: string): string {\n  if (importPath.startsWith('./')) return `/${importPath.slice(2)}`;\n  if (importPath.startsWith('../')) return importPath;\n  return importPath;\n}\n\nfunction normalizeAppShell(config: AppShellConfig | undefined): ResolvedAppShell {\n  if (config === false) return false;\n  if (config === undefined || config === 'default') {\n    return {\n      tagName: 'open-layout',\n      importPath: '@openelement/ui/open-layout',\n      props: {},\n    };\n  }\n  return {\n    tagName: config.tagName,\n    importPath: normalizeAppShellImport(config.import),\n    props: config.props ?? {},\n  };\n}\n\nfunction buildAppShellPlan(options: {\n  appShell?: FrameworkOptions['appShell'];\n  layouts?: FrameworkOptions['layouts'];\n}): AppShellPlan {\n  const defaultShell = normalizeAppShell(options.layouts?.default ?? options.appShell);\n  const layouts: Record<string, ResolvedAppShell> = {};\n  for (const [name, config] of Object.entries(options.layouts ?? {})) {\n    if (name === 'default' || config === undefined) continue;\n    layouts[name] = normalizeAppShell(config);\n  }\n  return { default: defaultShell, layouts };\n}\n\nexport function buildEntryDescriptor(\n  routes: RouteEntry[],\n  options: {\n    routesDir?: string;\n    islandsDir?: string;\n    middleware?: FrameworkOptions['middleware'];\n    ssg?: boolean;\n    islandTagNames?: string[];\n    /** Relative file paths for local islands (preserves subdirectory structure) */\n    islandFiles?: string[];\n    /** Local island metadata indexed by tag name. */\n    islandMeta?: Record<string, Partial<IslandDecl>>;\n    /** Package manifests discovered from npm/JSR packages */\n    packageManifests?: OpenElementPackageManifest[];\n    /** CEM-derived compatibility classifications (from compatibility classifier) */\n    cemClassifications?: CompatibilityClassification[];\n    /** @security Injected as raw HTML without sanitization */\n    headExtras?: string;\n    allowHeadExtrasScripts?: boolean;\n    html?: { lang?: string; title?: string };\n    upgradeStrategy?: HydrationStrategy;\n    /** Additional client-only tag names from external registries (ADR-0035 A1) */\n    clientOnlyTags?: string[];\n    appShell?: FrameworkOptions['appShell'];\n    layouts?: FrameworkOptions['layouts'];\n  } = {},\n): EntryDescriptor {\n  const routesDir = options.routesDir || 'app/routes';\n  const islandsDir = options.islandsDir || 'app/islands';\n  const isSSG = options.ssg === true;\n\n  // --- Imports ---\n  const imports: ImportDecl[] = [];\n\n  // Always needed\n  imports.push({ from: 'hono', names: ['Hono'] });\n  imports.push({\n    from: '@openelement/core',\n    names: ['renderDsd', 'renderDsdTree', 'escapeHtml'],\n  });\n\n  // Conditional middleware imports\n  const mw = options.middleware;\n  if (mw?.requestId !== false) {\n    imports.push({ from: 'hono/request-id', names: ['requestId'] });\n  }\n  if (mw?.logger !== false) {\n    imports.push({ from: 'hono/logger', names: ['logger'], alias: 'honoLogger' });\n  }\n  if (mw?.cors !== false) {\n    imports.push({ from: 'hono/cors', names: ['cors'] });\n  }\n  if (mw?.securityHeaders !== false) {\n    imports.push({ from: 'hono/secure-headers', names: ['secureHeaders'] });\n  }\n\n  // --- Middleware ---\n  const middleware: MiddlewareDecl[] = [];\n\n  if (mw?.requestId !== false) {\n    middleware.push({\n      kind: 'requestId',\n      comment: '1. Request ID - base for logging and error tracking',\n    });\n  }\n  if (mw?.logger !== false) {\n    middleware.push({\n      kind: 'logger',\n      comment: '2. Logger - structured request logging',\n    });\n  }\n  if (mw?.cors !== false) {\n    let corsOrigin: CorsOriginConfig | undefined;\n    if (mw?.corsOrigin !== undefined) {\n      if (typeof mw.corsOrigin === 'string') {\n        corsOrigin = mw.corsOrigin;\n      } else if (Array.isArray(mw.corsOrigin)) {\n        corsOrigin = mw.corsOrigin;\n      } else {\n        corsOrigin = { type: 'function', body: mw.corsOrigin.toString() };\n      }\n    }\n    middleware.push({\n      kind: 'cors',\n      comment: '3. CORS - Web Standards (no process.env)',\n      config: { corsOrigin },\n    });\n  }\n  if (mw?.securityHeaders !== false) {\n    middleware.push({\n      kind: 'securityHeaders',\n      comment: '4. Security headers',\n    });\n  }\n  if (mw?.csp) {\n    middleware.push({\n      kind: 'csp',\n      comment: '5. Content Security Policy',\n      config: { csp: mw.csp },\n    });\n  }\n\n  // --- Routes ---\n  const apiRoutes: ApiRouteDecl[] = routes\n    .filter((r) => r.type === 'api' && !r.special)\n    .map((r) => ({\n      kind: 'api' as const,\n      path: r.path,\n      varName: `$${r.varName}`,\n      filePath: r.filePath,\n      importPath: `/${routesDir}/${r.filePath}`,\n    }));\n\n  const pageRoutes: PageRouteDecl[] = routes\n    .filter((r) => r.type === 'page' && !r.special)\n    .map((r) => {\n      const isDynamic = r.path.includes(':');\n      const paramNames = isDynamic ? [...r.path.matchAll(/:([^/]+)/g)].map((m) => m[1]) : [];\n      return {\n        kind: 'page' as const,\n        path: r.path,\n        varName: `$${r.varName}`,\n        filePath: r.filePath,\n        defaultTagName: fileToTagName(r.filePath),\n        tagName: r.tagName || fileToTagName(r.filePath),\n        importPath: `/${routesDir}/${r.filePath}`,\n        isDynamic,\n        paramNames,\n      };\n    });\n\n  // --- Special files: _renderer.ts / _middleware.ts (v0.3.0) ---\n  const specialRoutes = routes.filter((r) => r.type === 'special');\n\n  const renderers: RendererDecl[] = specialRoutes\n    .filter((r) => r.special === 'renderer')\n    .map((r) => {\n      const scope = r.path.replace(/\\/?_renderer$/, '') || '/';\n      const depth = scope === '/' ? 0 : scope.split('/').filter(Boolean).length;\n      return {\n        varName: `$${r.varName}`,\n        scope,\n        importPath: `/${routesDir}/${r.filePath}`,\n        depth,\n      };\n    })\n    .sort((a, b) => b.depth - a.depth);\n\n  const middlewareScopes = specialRoutes\n    .filter((r) => r.special === 'middleware')\n    .map((r) => ({\n      varName: `$${r.varName}`,\n      scope: r.path.replace(/\\/?_middleware$/, '') || '/',\n      importPath: `/${routesDir}/${r.filePath}`,\n    }));\n\n  // --- Islands ---\n  const islandTagNames = options.islandTagNames || [];\n  const islandFiles = options.islandFiles || [];\n  const islandMeta = options.islandMeta || {};\n  const packageManifests = options.packageManifests || [];\n\n  const localIslands: IslandDecl[] = islandTagNames.map((tagName, i) => ({\n    tagName,\n    modulePath: islandFiles[i]\n      ? `/${islandsDir}/${islandFiles[i]}`\n      : `/${islandsDir}/${tagName}.ts`,\n    source: 'local',\n    ssr: islandMeta[tagName]?.hydrate === 'only' ? false : islandMeta[tagName]?.ssr,\n    dsd: islandMeta[tagName]?.hydrate === 'only' ? false : islandMeta[tagName]?.dsd,\n    hydrate: islandMeta[tagName]?.hydrate || options.upgradeStrategy || 'idle',\n    reason: islandMeta[tagName]?.reason,\n  }));\n\n  const packageIslandDecls: IslandDecl[] = packageManifests.flatMap((pkg) =>\n    pkg.declarations\n      .filter((d) => d.openElement?.module)\n      .map((d) => {\n        const modulePath = d.openElement?.module;\n        if (!modulePath) {\n          throw new Error(\n            `Package manifest declaration \"${d.tagName}\" is missing openElement.module`,\n          );\n        }\n        return {\n          tagName: d.tagName,\n          modulePath,\n          isPackage: true,\n          source: 'package',\n          hydrate:\n            (d.openElement?.hydrate || options.upgradeStrategy || 'idle') as IslandDecl['hydrate'],\n          ssr: d.openElement?.hydrate === 'only' ? false : d.openElement?.ssr,\n          dsd: d.openElement?.hydrate === 'only' ? false : d.openElement?.dsd,\n        };\n      })\n  );\n\n  const islands: IslandDecl[] = [...localIslands, ...packageIslandDecls];\n  const cemClassifications = options.cemClassifications || [];\n  const ssrAdmissionPlan = buildSsrAdmissionPlan(\n    islands,\n    cemClassifications,\n    options.clientOnlyTags || [],\n  );\n\n  // --- Document ---\n  const document: DocumentConfig = {\n    lang: options.html?.lang || 'en',\n    title: options.html?.title || 'openElement',\n    headExtras: options.headExtras || '',\n    allowHeadExtrasScripts: options.allowHeadExtrasScripts || false,\n  };\n  const appShell = buildAppShellPlan({\n    appShell: options.appShell,\n    layouts: options.layouts,\n  });\n\n  // --- Debug routes (dev only) ---\n  const debugRoutes = isSSG ? undefined : routes\n    .filter((r) => !r.special)\n    .map((r) => ({ path: r.path, type: r.type }));\n\n  return {\n    isSSG,\n    imports,\n    middleware,\n    apiRoutes,\n    pageRoutes,\n    islands,\n    ssrAdmissionPlan,\n    cemClassifications,\n    clientOnlyTags: options.clientOnlyTags,\n    renderers,\n    middlewareScopes,\n    document,\n    appShell,\n    upgradeStrategy: options.upgradeStrategy || 'idle',\n    debugRoutes,\n  };\n}\n\nexport function buildSsrAdmissionPlan(\n  islands: IslandDecl[],\n  cemClassifications: CompatibilityClassification[] = [],\n  clientOnlyTags: string[] = [],\n): SsrAdmissionPlan {\n  const renderableTags: string[] = [];\n  const mergedClientOnlyTags: string[] = [];\n  const rejectedTags: string[] = [];\n  const reasons: Record<string, string> = {};\n  const decisions: SsrAdmissionDecision[] = [];\n  const seen = new Set<string>();\n  const admittedTags = new Set<string>();\n\n  const cemMap = new Map<string, CompatibilityClassification>();\n  for (const classification of cemClassifications) {\n    cemMap.set(classification.tagName, classification);\n  }\n\n  for (const island of islands) {\n    const source = island.source || (island.isPackage ? 'package' : 'local');\n\n    if (seen.has(island.tagName)) {\n      const reason = 'duplicate custom element tag';\n      rejectedTags.push(island.tagName);\n      reasons[island.tagName] = reason;\n\n      if (admittedTags.has(island.tagName)) {\n        const rIdx = renderableTags.indexOf(island.tagName);\n        if (rIdx !== -1) renderableTags.splice(rIdx, 1);\n        const cIdx = mergedClientOnlyTags.indexOf(island.tagName);\n        if (cIdx !== -1) mergedClientOnlyTags.splice(cIdx, 1);\n        admittedTags.delete(island.tagName);\n      }\n\n      decisions.push({\n        tagName: island.tagName,\n        modulePath: island.modulePath,\n        source,\n        renderPath: 'rejected',\n        reason,\n      });\n      continue;\n    }\n    seen.add(island.tagName);\n\n    let renderPath: SsrAdmissionDecision['renderPath'];\n    let reason: string;\n\n    const cemClassification = cemMap.get(island.tagName);\n\n    if (cemClassification) {\n      const TIER_RENDER_PATH: Record<string, string> = {\n        'ssr-capable': 'ssr+client',\n        'client-only': 'client-only',\n        'experimental-dom': 'client-only',\n        rejected: 'rejected',\n      };\n\n      const knownTier = cemClassification.tier in TIER_RENDER_PATH;\n      renderPath = (TIER_RENDER_PATH[cemClassification.tier] ?? 'client-only') as typeof renderPath;\n      reason = knownTier\n        ? `CEM ${cemClassification.tier}: ${cemClassification.reason}`\n        : `Unknown CEM tier (${cemClassification.tier}) - conservative default to client-only`;\n    } else if (island.hydrate === 'only') {\n      renderPath = 'client-only';\n      reason = island.reason || 'client:only island is excluded from SSR';\n    } else if (island.ssr === false) {\n      renderPath = 'client-only';\n      reason = island.reason || 'openElement.ssr is false';\n    } else if (source === 'package') {\n      if (island.ssr === true) {\n        renderPath = 'ssr+client';\n        reason = 'package island with openElement.ssr=true';\n      } else {\n        renderPath = 'client-only';\n        reason = 'package island has no validated SSR capability (conservative default)';\n      }\n    } else {\n      renderPath = 'ssr+client';\n      reason = island.ssr === true ? 'openElement.ssr is true' : 'local island default SSR path';\n    }\n\n    if (renderPath === 'ssr+client') {\n      renderableTags.push(island.tagName);\n      admittedTags.add(island.tagName);\n    }\n    if (renderPath === 'client-only') {\n      mergedClientOnlyTags.push(island.tagName);\n      admittedTags.add(island.tagName);\n    }\n    if (renderPath === 'rejected') {\n      rejectedTags.push(island.tagName);\n      admittedTags.delete(island.tagName);\n    }\n\n    reasons[island.tagName] = reason;\n    decisions.push({\n      tagName: island.tagName,\n      modulePath: island.modulePath,\n      source,\n      renderPath,\n      reason,\n    });\n  }\n\n  for (const tag of clientOnlyTags) {\n    if (!seen.has(tag) && !admittedTags.has(tag)) {\n      mergedClientOnlyTags.push(tag);\n      admittedTags.add(tag);\n      seen.add(tag);\n      reasons[tag] = 'Registry client-only component (ADR-0035)';\n      decisions.push({\n        tagName: tag,\n        modulePath: '',\n        source: 'nested',\n        renderPath: 'client-only',\n        reason: 'Registry client-only component (ADR-0035)',\n      });\n    }\n  }\n\n  return {\n    renderableTags,\n    clientOnlyTags: mergedClientOnlyTags,\n    rejectedTags,\n    reasons,\n    decisions,\n    cemClassifications,\n  };\n}\n\n/** Options for the Hono entry code generator */\nexport interface HonoEntryOptions {\n  routesDir?: string;\n  islandsDir?: string;\n  componentsDir?: string;\n  middleware?: FrameworkOptions['middleware'];\n  ssg?: boolean;\n  islandTagNames?: string[];\n  /** Relative file paths for local islands (preserves subdirectory structure) */\n  islandFiles?: string[];\n  islandMeta?: Record<string, Partial<IslandDecl>>;\n  packageManifests?: OpenElementPackageManifest[];\n  /** @security Injected as raw HTML without sanitization */\n  headExtras?: string;\n  allowHeadExtrasScripts?: boolean;\n  html?: { lang?: string; title?: string };\n  upgradeStrategy?: HydrationStrategy;\n  /** Additional client-only tag names from external registries (ADR-0035 A1) */\n  clientOnlyTags?: string[];\n  appShell?: FrameworkOptions['appShell'];\n  layouts?: FrameworkOptions['layouts'];\n}\n\n/**\n * Generate the Hono entry module code from scanned routes.\n *\n * Internally builds a descriptor-shaped object and renders it directly.\n */\nexport function generateHonoEntryCode(\n  routes: RouteEntry[],\n  options: HonoEntryOptions = {},\n): string {\n  const descriptor = buildEntryDescriptor(routes, options);\n  return renderEntry(descriptor);\n}\n"],"names":[],"mappings":"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"}