@openelement/ssg 0.41.0-alpha.1

package/src/entry-render-ssg.js

@@ -0,0 +1,169 @@
+/**
+ * @openelement/ssg - SSG entry code generation
+ *
+ * Generates the SSG-specific sections of the virtual Hono entry module,
+ * including SSG utility re-exports, routeInfo, renderRoute, getStaticPaths,
+ * and supporting helper functions.
+ */ import { routeRevalidateExpr, routeTagNameExpr } from './entry-render-helpers.js';
+/**
+ * Render the SSG-specific section of the entry code.
+ *
+ * This includes SSG utility re-exports, route metadata, renderRoute,
+ * getStaticPaths, and supporting helper functions.
+ *
+ * Returns an empty string when SSG mode is disabled.
+ */ export function renderSsgSection(desc) {
+  if (!desc.isSSG) return '';
+  const lines = [];
+  lines.push('');
+  lines.push('// - SSG Utility Re-exports (ADR 0008 Phase C) -');
+  lines.push('// Used by build-ssg.ts after importing the SSR bundle.');
+  lines.push('// Shared module scope ensures adapter/data state is consistent.');
+  lines.push('');
+  lines.push('export { renderDsd, renderDsdTree, wrapInDocument } from "@openelement/core"');
+  lines.push('export { posts, getPostBySlug, getBlogOptions } from "@openelement/generated/blog-data"');
+  lines.push('export { generateSitemap } from "@openelement/content/sitemap"');
+  lines.push('export { locales, getDefaultLocale, getI18nOptions } from "@openelement/generated/i18n"');
+  lines.push('');
+  lines.push('// - ADR 0014: DSD-first rendering API -');
+  lines.push('// build-ssg.ts calls these - never touches customElements directly.');
+  lines.push('');
+  // --- routeInfo: structured route metadata ---
+  lines.push('export const routeInfo = [');
+  for (const r of desc.pageRoutes){
+    const tagNameExpr = routeTagNameExpr(r.varName, r.tagName);
+    lines.push(`  { path: '${r.path}', filePath: ${JSON.stringify(r.filePath)}, tagName: ${tagNameExpr}, module: ${r.varName}, isDynamic: ${!!r.isDynamic}, paramNames: ${JSON.stringify(r.paramNames || [])}, revalidate: ${routeRevalidateExpr(r.varName)}, rendering: (__pageDefinition(${r.varName}).renderIntent?.mode || "auto"), streaming: (__pageDefinition(${r.varName}).renderIntent?.streaming || "auto") },`);
+  }
+  lines.push('];');
+  lines.push('');
+  lines.push('function __pageDefinition(module) {');
+  lines.push('  return module?.default?.openElementPage || {};');
+  lines.push('}');
+  lines.push('');
+  lines.push('function __routeMeta(module) {');
+  lines.push('  const page = __pageDefinition(module);');
+  lines.push('  return {');
+  lines.push('    ...(page.route !== undefined ? { route: page.route } : {}),');
+  lines.push('    ...(page.head?.title !== undefined ? { title: page.head.title } : {}),');
+  lines.push('    ...(page.head?.description !== undefined ? { description: page.head.description } : {}),');
+  lines.push('  };');
+  lines.push('}');
+  lines.push('');
+  lines.push('function __rendererContext(routePath, params) {');
+  lines.push('  return {');
+  lines.push('    req: {');
+  lines.push('      path: routePath,');
+  lines.push('      param: (name) => name ? params[name] : params,');
+  lines.push('    },');
+  lines.push('    get: () => undefined,');
+  lines.push('    set: () => undefined,');
+  lines.push('  };');
+  lines.push('}');
+  lines.push('');
+  lines.push('function __matchingRenderers(routePath) {');
+  lines.push('  const renderers = [];');
+  for (const renderer of desc.renderers){
+    if (renderer.scope === '/') {
+      lines.push(`  renderers.push(${renderer.varName}.default);`);
+    } else {
+      lines.push(`  if (routePath.toLowerCase() === '${renderer.scope.toLowerCase()}' || routePath.toLowerCase().startsWith('${renderer.scope.toLowerCase()}/')) renderers.push(${renderer.varName}.default);`);
+    }
+  }
+  lines.push('  return renderers;');
+  lines.push('}');
+  lines.push('');
+  // --- renderRoute ---
+  lines.push('/**');
+  lines.push(' * Render a route to structured output with diagnostics (ADR 0014, v0.15.3).');
+  lines.push(' * Returns { html, errors, hydrationHints, componentCount, renderTimeMs }.');
+  lines.push(' * Caller can inspect errors/hints for observability or use .html for output.');
+  lines.push(' */');
+  lines.push('export async function renderRoute(routePath, options = {}) {');
+  lines.push('  const info = routeInfo.find(r => r.path === routePath);');
+  lines.push("  if (!info) throw new Error('[openElement] renderRoute: route not found: ' + routePath);");
+  lines.push('  const { params = {}, locale, title, lang, headExtras } = options;');
+  lines.push('  const page = __pageDefinition(info.module);');
+  lines.push('  const routeMeta = __routeMeta(info.module);');
+  lines.push('  const loadContext = {');
+  lines.push('    params,');
+  lines.push('    request: options.request,');
+  lines.push('    env: options.env || {},');
+  lines.push('    platform: options.platform,');
+  lines.push('    route: { path: routePath, filePath: info.filePath },');
+  lines.push('  };');
+  lines.push('  let data;');
+  lines.push('  try {');
+  lines.push('    data = typeof info.module.loader === "function" ? await info.module.loader(loadContext) : undefined;');
+  lines.push('  } catch (error) {');
+  lines.push('    if (__isOpenElementRedirect(error)) {');
+  lines.push('      const html = wrapInDocument(__statusHtml("Redirect", "Redirecting to " + error.location), {');
+  lines.push('        title: "Redirect",');
+  lines.push('        lang: lang || locale || "en",');
+  lines.push('        headExtras: headExtras !== undefined ? headExtras : (typeof __headExtras !== "undefined" ? __headExtras : ""),');
+  lines.push(`        allowHeadExtrasScripts: ${JSON.stringify(desc.document.allowHeadExtrasScripts)},`);
+  lines.push('      });');
+  lines.push('      return { html, status: error.status, redirect: { location: error.location, status: error.status }, errors: [], hydrationHints: [], componentCount: 0, renderTimeMs: 0 };');
+  lines.push('    }');
+  lines.push('    if (__isOpenElementNotFound(error)) {');
+  lines.push('      const html = wrapInDocument(__statusHtml("404 Not Found", error.message || "Not Found"), {');
+  lines.push('        title: "404 Not Found",');
+  lines.push('        lang: lang || locale || "en",');
+  lines.push('        headExtras: headExtras !== undefined ? headExtras : (typeof __headExtras !== "undefined" ? __headExtras : ""),');
+  lines.push(`        allowHeadExtrasScripts: ${JSON.stringify(desc.document.allowHeadExtrasScripts)},`);
+  lines.push('      });');
+  lines.push('      return { html, status: 404, notFound: true, errors: [], hydrationHints: [], componentCount: 0, renderTimeMs: 0 };');
+  lines.push('    }');
+  lines.push('    throw error;');
+  lines.push('  }');
+  lines.push('  const props = { ...params, data, __openElementActionData: undefined, __openElementParams: params, __openElementRequest: options.request, __openElementRoute: loadContext.route, __openElementMeta: routeMeta };');
+  lines.push('  if (locale) props.locale = locale;');
+  lines.push('  const startTime = typeof performance !== "undefined" ? performance.now() : 0;');
+  lines.push('  let node = jsx(info.tagName, props);');
+  lines.push('  for (const renderer of __matchingRenderers(routePath)) {');
+  lines.push('    node = await renderer.wrap(node, __rendererContext(routePath, params));');
+  lines.push('  }');
+  lines.push('  const content = await __renderAppShell(node, routePath, { locale, routeMeta });');
+  lines.push('  const renderTimeMs = typeof performance !== "undefined" ? performance.now() - startTime : 0;');
+  lines.push('  const componentCount = (content.match(/<template shadowrootmode="open"/g) || []).length;');
+  lines.push('  const fullHtml = wrapInDocument(content, {');
+  lines.push('    title: title || page.head?.title || "openElement",');
+  lines.push('    lang: lang || locale || "en",');
+  lines.push('    meta: { description: page.head?.description, tags: page.head?.meta },');
+  lines.push('    headExtras: headExtras !== undefined ? headExtras : (typeof __headExtras !== "undefined" ? __headExtras : ""),');
+  lines.push('    dangerouslyHeadFragments: page.head?.dangerouslyHeadFragments || [],');
+  lines.push(`    allowHeadExtrasScripts: ${JSON.stringify(desc.document.allowHeadExtrasScripts)},`);
+  lines.push('  });');
+  lines.push('  return {');
+  lines.push('    html: fullHtml,');
+  lines.push('    errors: [],');
+  lines.push('    hydrationHints: [],');
+  lines.push('    componentCount,');
+  lines.push('    renderTimeMs,');
+  lines.push('  };');
+  lines.push('}');
+  lines.push('');
+  // --- getStaticPaths ---
+  lines.push('/**');
+  lines.push(' * Get static paths for a dynamic route (ADR 0014).');
+  lines.push(' * Returns [] for non-dynamic routes.');
+  lines.push(' */');
+  lines.push('export async function getStaticPaths(routePath) {');
+  lines.push('  const info = routeInfo.find(r => r.path === routePath);');
+  lines.push('  if (!info || !info.isDynamic) return [];');
+  const dynamicRoutes = desc.pageRoutes.filter((r)=>r.isDynamic);
+  if (dynamicRoutes.length > 0) {
+    lines.push("  // Dispatch to the route module's getStaticPaths()");
+    for (const r of dynamicRoutes){
+      lines.push(`  if (routePath === '${r.path.replace(/'/g, "\\'")}') {`);
+      lines.push(`    if (typeof ${r.varName}.getStaticPaths === 'function') {`);
+      lines.push(`      return await ${r.varName}.getStaticPaths();`);
+      lines.push(`    }`);
+      lines.push(`    return [];`);
+      lines.push(`  }`);
+    }
+  }
+  lines.push('  return [];');
+  lines.push('}');
+  return lines.join('\n');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/ssg/src/entry-render-ssg.ts"],"sourcesContent":["/**\n * @openelement/ssg - SSG entry code generation\n *\n * Generates the SSG-specific sections of the virtual Hono entry module,\n * including SSG utility re-exports, routeInfo, renderRoute, getStaticPaths,\n * and supporting helper functions.\n */\n\nimport type { EntryDescriptor } from '@openelement/protocol/ssg';\nimport { routeRevalidateExpr, routeTagNameExpr } from './entry-render-helpers.js';\n\n/**\n * Render the SSG-specific section of the entry code.\n *\n * This includes SSG utility re-exports, route metadata, renderRoute,\n * getStaticPaths, and supporting helper functions.\n *\n * Returns an empty string when SSG mode is disabled.\n */\nexport function renderSsgSection(desc: EntryDescriptor): string {\n  if (!desc.isSSG) return '';\n\n  const lines: string[] = [];\n\n  lines.push('');\n  lines.push(\n    '// - SSG Utility Re-exports (ADR 0008 Phase C) -',\n  );\n  lines.push('// Used by build-ssg.ts after importing the SSR bundle.');\n  lines.push(\n    '// Shared module scope ensures adapter/data state is consistent.',\n  );\n  lines.push('');\n  lines.push(\n    'export { renderDsd, renderDsdTree, wrapInDocument } from \"@openelement/core\"',\n  );\n  lines.push(\n    'export { posts, getPostBySlug, getBlogOptions } from \"@openelement/generated/blog-data\"',\n  );\n  lines.push('export { generateSitemap } from \"@openelement/content/sitemap\"');\n  lines.push(\n    'export { locales, getDefaultLocale, getI18nOptions } from \"@openelement/generated/i18n\"',\n  );\n  lines.push('');\n  lines.push(\n    '// - ADR 0014: DSD-first rendering API -',\n  );\n  lines.push(\n    '// build-ssg.ts calls these - never touches customElements directly.',\n  );\n  lines.push('');\n\n  // --- routeInfo: structured route metadata ---\n  lines.push('export const routeInfo = [');\n  for (const r of desc.pageRoutes) {\n    const tagNameExpr = routeTagNameExpr(r.varName, r.tagName);\n    lines.push(\n      `  { path: '${r.path}', filePath: ${\n        JSON.stringify(r.filePath)\n      }, tagName: ${tagNameExpr}, module: ${r.varName}, isDynamic: ${!!r\n        .isDynamic}, paramNames: ${JSON.stringify(r.paramNames || [])}, revalidate: ${\n        routeRevalidateExpr(r.varName)\n      }, rendering: (__pageDefinition(${r.varName}).renderIntent?.mode || \"auto\"), streaming: (__pageDefinition(${r.varName}).renderIntent?.streaming || \"auto\") },`,\n    );\n  }\n  lines.push('];');\n  lines.push('');\n\n  lines.push('function __pageDefinition(module) {');\n  lines.push('  return module?.default?.openElementPage || {};');\n  lines.push('}');\n  lines.push('');\n\n  lines.push('function __routeMeta(module) {');\n  lines.push('  const page = __pageDefinition(module);');\n  lines.push('  return {');\n  lines.push('    ...(page.route !== undefined ? { route: page.route } : {}),');\n  lines.push('    ...(page.head?.title !== undefined ? { title: page.head.title } : {}),');\n  lines.push(\n    '    ...(page.head?.description !== undefined ? { description: page.head.description } : {}),',\n  );\n  lines.push('  };');\n  lines.push('}');\n  lines.push('');\n\n  lines.push('function __rendererContext(routePath, params) {');\n  lines.push('  return {');\n  lines.push('    req: {');\n  lines.push('      path: routePath,');\n  lines.push('      param: (name) => name ? params[name] : params,');\n  lines.push('    },');\n  lines.push('    get: () => undefined,');\n  lines.push('    set: () => undefined,');\n  lines.push('  };');\n  lines.push('}');\n  lines.push('');\n\n  lines.push('function __matchingRenderers(routePath) {');\n  lines.push('  const renderers = [];');\n  for (const renderer of desc.renderers) {\n    if (renderer.scope === '/') {\n      lines.push(`  renderers.push(${renderer.varName}.default);`);\n    } else {\n      lines.push(\n        `  if (routePath.toLowerCase() === '${renderer.scope.toLowerCase()}' || routePath.toLowerCase().startsWith('${renderer.scope.toLowerCase()}/')) renderers.push(${renderer.varName}.default);`,\n      );\n    }\n  }\n  lines.push('  return renderers;');\n  lines.push('}');\n  lines.push('');\n\n  // --- renderRoute ---\n  lines.push('/**');\n  lines.push(' * Render a route to structured output with diagnostics (ADR 0014, v0.15.3).');\n  lines.push(\n    ' * Returns { html, errors, hydrationHints, componentCount, renderTimeMs }.',\n  );\n  lines.push(\n    ' * Caller can inspect errors/hints for observability or use .html for output.',\n  );\n  lines.push(' */');\n  lines.push('export async function renderRoute(routePath, options = {}) {');\n  lines.push('  const info = routeInfo.find(r => r.path === routePath);');\n  lines.push(\n    \"  if (!info) throw new Error('[openElement] renderRoute: route not found: ' + routePath);\",\n  );\n  lines.push(\n    '  const { params = {}, locale, title, lang, headExtras } = options;',\n  );\n  lines.push('  const page = __pageDefinition(info.module);');\n  lines.push('  const routeMeta = __routeMeta(info.module);');\n  lines.push('  const loadContext = {');\n  lines.push('    params,');\n  lines.push('    request: options.request,');\n  lines.push('    env: options.env || {},');\n  lines.push('    platform: options.platform,');\n  lines.push('    route: { path: routePath, filePath: info.filePath },');\n  lines.push('  };');\n  lines.push('  let data;');\n  lines.push('  try {');\n  lines.push(\n    '    data = typeof info.module.loader === \"function\" ? await info.module.loader(loadContext) : undefined;',\n  );\n  lines.push('  } catch (error) {');\n  lines.push('    if (__isOpenElementRedirect(error)) {');\n  lines.push(\n    '      const html = wrapInDocument(__statusHtml(\"Redirect\", \"Redirecting to \" + error.location), {',\n  );\n  lines.push('        title: \"Redirect\",');\n  lines.push('        lang: lang || locale || \"en\",');\n  lines.push(\n    '        headExtras: headExtras !== undefined ? headExtras : (typeof __headExtras !== \"undefined\" ? __headExtras : \"\"),',\n  );\n  lines.push(\n    `        allowHeadExtrasScripts: ${JSON.stringify(desc.document.allowHeadExtrasScripts)},`,\n  );\n  lines.push('      });');\n  lines.push(\n    '      return { html, status: error.status, redirect: { location: error.location, status: error.status }, errors: [], hydrationHints: [], componentCount: 0, renderTimeMs: 0 };',\n  );\n  lines.push('    }');\n  lines.push('    if (__isOpenElementNotFound(error)) {');\n  lines.push(\n    '      const html = wrapInDocument(__statusHtml(\"404 Not Found\", error.message || \"Not Found\"), {',\n  );\n  lines.push('        title: \"404 Not Found\",');\n  lines.push('        lang: lang || locale || \"en\",');\n  lines.push(\n    '        headExtras: headExtras !== undefined ? headExtras : (typeof __headExtras !== \"undefined\" ? __headExtras : \"\"),',\n  );\n  lines.push(\n    `        allowHeadExtrasScripts: ${JSON.stringify(desc.document.allowHeadExtrasScripts)},`,\n  );\n  lines.push('      });');\n  lines.push(\n    '      return { html, status: 404, notFound: true, errors: [], hydrationHints: [], componentCount: 0, renderTimeMs: 0 };',\n  );\n  lines.push('    }');\n  lines.push('    throw error;');\n  lines.push('  }');\n  lines.push(\n    '  const props = { ...params, data, __openElementActionData: undefined, __openElementParams: params, __openElementRequest: options.request, __openElementRoute: loadContext.route, __openElementMeta: routeMeta };',\n  );\n  lines.push('  if (locale) props.locale = locale;');\n  lines.push('  const startTime = typeof performance !== \"undefined\" ? performance.now() : 0;');\n  lines.push('  let node = jsx(info.tagName, props);');\n  lines.push('  for (const renderer of __matchingRenderers(routePath)) {');\n  lines.push(\n    '    node = await renderer.wrap(node, __rendererContext(routePath, params));',\n  );\n  lines.push('  }');\n  lines.push('  const content = await __renderAppShell(node, routePath, { locale, routeMeta });');\n  lines.push(\n    '  const renderTimeMs = typeof performance !== \"undefined\" ? performance.now() - startTime : 0;',\n  );\n  lines.push(\n    '  const componentCount = (content.match(/<template shadowrootmode=\"open\"/g) || []).length;',\n  );\n  lines.push('  const fullHtml = wrapInDocument(content, {');\n  lines.push('    title: title || page.head?.title || \"openElement\",');\n  lines.push('    lang: lang || locale || \"en\",');\n  lines.push('    meta: { description: page.head?.description, tags: page.head?.meta },');\n  lines.push(\n    '    headExtras: headExtras !== undefined ? headExtras : (typeof __headExtras !== \"undefined\" ? __headExtras : \"\"),',\n  );\n  lines.push('    dangerouslyHeadFragments: page.head?.dangerouslyHeadFragments || [],');\n  lines.push(\n    `    allowHeadExtrasScripts: ${JSON.stringify(desc.document.allowHeadExtrasScripts)},`,\n  );\n  lines.push('  });');\n  lines.push('  return {');\n  lines.push('    html: fullHtml,');\n  lines.push('    errors: [],');\n  lines.push('    hydrationHints: [],');\n  lines.push('    componentCount,');\n  lines.push('    renderTimeMs,');\n  lines.push('  };');\n  lines.push('}');\n  lines.push('');\n\n  // --- getStaticPaths ---\n  lines.push('/**');\n  lines.push(' * Get static paths for a dynamic route (ADR 0014).');\n  lines.push(' * Returns [] for non-dynamic routes.');\n  lines.push(' */');\n  lines.push('export async function getStaticPaths(routePath) {');\n  lines.push('  const info = routeInfo.find(r => r.path === routePath);');\n  lines.push('  if (!info || !info.isDynamic) return [];');\n  const dynamicRoutes = desc.pageRoutes.filter((r) => r.isDynamic);\n  if (dynamicRoutes.length > 0) {\n    lines.push(\"  // Dispatch to the route module's getStaticPaths()\");\n    for (const r of dynamicRoutes) {\n      lines.push(`  if (routePath === '${r.path.replace(/'/g, \"\\\\'\")}') {`);\n      lines.push(\n        `    if (typeof ${r.varName}.getStaticPaths === 'function') {`,\n      );\n      lines.push(`      return await ${r.varName}.getStaticPaths();`);\n      lines.push(`    }`);\n      lines.push(`    return [];`);\n      lines.push(`  }`);\n    }\n  }\n  lines.push('  return [];');\n  lines.push('}');\n\n  return lines.join('\\n');\n}\n"],"names":[],"mappings":"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"}

package/src/entry-renderer.d.ts

@@ -0,0 +1,87 @@
+/**
+ * @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 type { EntryDescriptor, IslandDecl, SsrAdmissionPlan } from '@openelement/protocol/ssg';
+import type { CompatibilityClassification, FrameworkOptions, HydrationStrategy, RouteEntry } from '@openelement/protocol/framework';
+import type { OpenElementPackageManifest } from '@openelement/protocol/manifest';
+/**
+ * Render an EntryDescriptor into a complete virtual module string.
+ *
+ * Pure function - deterministic, testable, side-effect-free.
+ */ export declare function renderEntry(desc: EntryDescriptor): string;
+export declare function buildEntryDescriptor(routes: RouteEntry[], options?: {
+  routesDir?: string;
+  islandsDir?: string;
+  middleware?: FrameworkOptions['middleware'];
+  ssg?: boolean;
+  islandTagNames?: string[];
+  /** Relative file paths for local islands (preserves subdirectory structure) */ islandFiles?: string[];
+  /** Local island metadata indexed by tag name. */ islandMeta?: Record<string, Partial<IslandDecl>>;
+  /** Package manifests discovered from npm/JSR packages */ packageManifests?: OpenElementPackageManifest[];
+  /** CEM-derived compatibility classifications (from compatibility classifier) */ cemClassifications?: CompatibilityClassification[];
+  /** @security Injected as raw HTML without sanitization */ headExtras?: string;
+  allowHeadExtrasScripts?: boolean;
+  html?: {
+    lang?: string;
+    title?: string;
+  };
+  upgradeStrategy?: HydrationStrategy;
+  /** Additional client-only tag names from external registries (ADR-0035 A1) */ clientOnlyTags?: string[];
+  appShell?: FrameworkOptions['appShell'];
+  layouts?: FrameworkOptions['layouts'];
+}): EntryDescriptor;
+export declare function buildSsrAdmissionPlan(islands: IslandDecl[], cemClassifications?: CompatibilityClassification[], clientOnlyTags?: string[]): SsrAdmissionPlan;
+/** Options for the Hono entry code generator */ export interface HonoEntryOptions {
+  routesDir?: string;
+  islandsDir?: string;
+  componentsDir?: string;
+  middleware?: FrameworkOptions['middleware'];
+  ssg?: boolean;
+  islandTagNames?: string[];
+  /** Relative file paths for local islands (preserves subdirectory structure) */ islandFiles?: string[];
+  islandMeta?: Record<string, Partial<IslandDecl>>;
+  packageManifests?: OpenElementPackageManifest[];
+  /** @security Injected as raw HTML without sanitization */ headExtras?: string;
+  allowHeadExtrasScripts?: boolean;
+  html?: {
+    lang?: string;
+    title?: string;
+  };
+  upgradeStrategy?: HydrationStrategy;
+  /** Additional client-only tag names from external registries (ADR-0035 A1) */ clientOnlyTags?: string[];
+  appShell?: FrameworkOptions['appShell'];
+  layouts?: FrameworkOptions['layouts'];
+}
+/**
+ * Generate the Hono entry module code from scanned routes.
+ *
+ * Internally builds a descriptor-shaped object and renders it directly.
+ */ export declare function generateHonoEntryCode(routes: RouteEntry[], options?: HonoEntryOptions): string;