@openelement/ssg 0.41.0-alpha.1

package/src/external-resolver.d.ts

@@ -0,0 +1,62 @@
+/**
+ * adapter-vite internal SSG - Deno External Dependency Pre-Resolution (ADR-0047).
+ *
+ * Eliminates ESM subpath leaks into Rolldown by having Deno resolve all
+ * external package transitive dependencies before the bundler sees them.
+ * Produces a complete specifier list so ssr.external needs no regex.
+ *
+ * ADR-0054: AST-based specifier resolution replaces manual regex patterns.
+ * For each external package, we parse its package.json exports field to
+ * auto-discover ALL subpath exports. No more regex maintenance.
+ */ import type { ExternalManifest } from '@openelement/protocol/ssg';
+interface DenoInfoModule {
+  specifier: string;
+  error?: string;
+}
+interface DenoInfoOutput {
+  modules: DenoInfoModule[];
+  roots: string[];
+  redirects?: Record<string, string>;
+}
+/**
+ * ADR-0054: Recursively walk a package.json exports field to extract all
+ * export subpaths as bare specifier strings.
+ *
+ * Handles:
+ *   "."          → "package-name"
+ *   "./sub"      → "package-name/sub"
+ *   "./sub/*"    → "package-name/sub/*" (wildcard, matches all sub-subpaths)
+ *   "./*"        → "package-name/*"
+ *   Conditional  → recurses into sub-conditions (import/require/default)
+ *
+ * Skips condition keys: import, require, node, default, types, browser,
+ * deno, worker, development, production, module.
+ */ export declare function walkExports(exports: unknown, packageName: string, prefix?: string): string[];
+/**
+ * ADR-0054: Resolve a package's exports to a complete list of bare specifiers
+ * by reading its package.json from node_modules.
+ */ export declare function resolvePackageExports(packageName: string, projectRoot: string): string[];
+/**
+ * ADR-0054: Complete external specifier list by resolving each package's
+ * exports via AST (package.json exports walk).
+ */ export declare function completeExternalSpecifiers(baseSpecifiers: string[], externalPackages: string[], projectRoot: string): string[];
+/**
+ * ADR-0047: Parse `deno info --json` output to extract all specifiers belonging
+ * to external packages. This eliminates the need for regex-based external matching
+ * that leaks ESM subpaths into Rolldown.
+ */ export declare function extractExternalSpecifiers(denoInfo: DenoInfoOutput, externalPackages: string[]): string[];
+/**
+ * Build a fallback manifest.
+ * Used when Deno is unavailable or skipResolution is true.
+ *
+ * ADR-0054: Uses AST-based exports resolution instead of regex patterns.
+ */ export declare function buildFallbackManifest(externalPackages: string[], projectRoot: string): ExternalManifest;
+/**
+ * Resolve the complete external dependency manifest using Deno module graph.
+ *
+ * Flow:
+ * 1. Check cache (.openElement/external-manifest.json by deno.lock hash)
+ * 2. If cache miss: write temp probe module, run `deno info --json`, parse
+ * 3. Supplement with AST-based exports resolution (ADR-0054)
+ * 4. Fallback to AST-only if Deno is unavailable
+ */ export declare function resolveExternalManifest(externalPackages: string[], projectRoot: string, skipResolution?: boolean): Promise<ExternalManifest>;

package/src/external-resolver.js

@@ -0,0 +1,285 @@
+/**
+ * adapter-vite internal SSG - Deno External Dependency Pre-Resolution (ADR-0047).
+ *
+ * Eliminates ESM subpath leaks into Rolldown by having Deno resolve all
+ * external package transitive dependencies before the bundler sees them.
+ * Produces a complete specifier list so ssr.external needs no regex.
+ *
+ * ADR-0054: AST-based specifier resolution replaces manual regex patterns.
+ * For each external package, we parse its package.json exports field to
+ * auto-discover ALL subpath exports. No more regex maintenance.
+ */ import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { writeJson } from '@openelement/content/write-json';
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+/** Conditional keys to skip when walking exports (not subpaths). */ const CONDITION_KEYS = new Set([
+  'import',
+  'require',
+  'node',
+  'default',
+  'types',
+  'browser',
+  'deno',
+  'worker',
+  'development',
+  'production',
+  'module'
+]);
+/**
+ * ADR-0054: Recursively walk a package.json exports field to extract all
+ * export subpaths as bare specifier strings.
+ *
+ * Handles:
+ *   "."          → "package-name"
+ *   "./sub"      → "package-name/sub"
+ *   "./sub/*"    → "package-name/sub/*" (wildcard, matches all sub-subpaths)
+ *   "./*"        → "package-name/*"
+ *   Conditional  → recurses into sub-conditions (import/require/default)
+ *
+ * Skips condition keys: import, require, node, default, types, browser,
+ * deno, worker, development, production, module.
+ */ export function walkExports(exports, packageName, prefix = '') {
+  const results = [];
+  if (typeof exports === 'string') {
+    // Leaf: e.g. ".": "./index.js" → package-name
+    // Strip "./" prefix to get subpath: "./sub" → "sub", "./*" → "*", "." → ""
+    const subpath = prefix.replace(/^\.\/?/, '');
+    results.push(subpath ? `${packageName}/${subpath}` : packageName);
+    return results;
+  }
+  if (exports === null || exports === undefined) {
+    return results;
+  }
+  if (Array.isArray(exports)) {
+    // Array fallback — take first valid
+    for (const item of exports){
+      const sub = walkExports(item, packageName, prefix);
+      if (sub.length > 0) {
+        results.push(...sub);
+        break;
+      }
+    }
+    return results;
+  }
+  if (typeof exports === 'object') {
+    const obj = exports;
+    const hasSubpathKeys = Object.keys(obj).some((k)=>!CONDITION_KEYS.has(k));
+    const hasConditionKeys = Object.keys(obj).some((k)=>CONDITION_KEYS.has(k));
+    if (hasConditionKeys && !hasSubpathKeys) {
+      // Pure condition block: recurse into each condition
+      const seen = new Set();
+      for (const key of Object.keys(obj)){
+        if (CONDITION_KEYS.has(key)) {
+          const sub = walkExports(obj[key], packageName, prefix);
+          for (const s of sub){
+            if (!seen.has(s)) {
+              seen.add(s);
+              results.push(s);
+            }
+          }
+        }
+      }
+    } else if (hasSubpathKeys) {
+      // Subpath mapping: each key is a subpath
+      for (const key of Object.keys(obj)){
+        if (CONDITION_KEYS.has(key)) continue;
+        const newPrefix = key; // e.g. ".", "./secure-headers", "./*"
+        const sub = walkExports(obj[key], packageName, newPrefix);
+        results.push(...sub);
+      }
+    }
+  }
+  return results;
+}
+/**
+ * ADR-0054: Resolve a package's exports to a complete list of bare specifiers
+ * by reading its package.json from node_modules.
+ */ export function resolvePackageExports(packageName, projectRoot) {
+  // Try standard node_modules resolution first
+  const candidates = [
+    join(projectRoot, 'node_modules', packageName, 'package.json'),
+    join(projectRoot, 'node_modules', '.deno', `${packageName}.node_modules`, packageName, 'package.json')
+  ];
+  for (const pkgPath of candidates){
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        if (pkg.exports) {
+          return walkExports(pkg.exports, packageName);
+        }
+        break;
+      } catch  {
+      // corrupt package.json — skip
+      }
+    }
+  }
+  // Fallback: return just the main package name
+  return [
+    packageName
+  ];
+}
+/**
+ * ADR-0054: Complete external specifier list by resolving each package's
+ * exports via AST (package.json exports walk).
+ */ export function completeExternalSpecifiers(baseSpecifiers, externalPackages, projectRoot) {
+  const seen = new Set(baseSpecifiers);
+  const result = [
+    ...baseSpecifiers
+  ];
+  for (const pkg of externalPackages){
+    try {
+      const subpaths = resolvePackageExports(pkg, projectRoot);
+      for (const sp of subpaths){
+        if (!seen.has(sp)) {
+          seen.add(sp);
+          result.push(sp);
+        }
+      }
+    } catch  {
+    // Package not found or has no exports — keep base specifiers
+    }
+  }
+  return result.sort();
+}
+/**
+ * Compute a stable hash of deno.lock for cache invalidation.
+ * Returns 'no-lock' if deno.lock doesn't exist.
+ */ function computeLockHash(projectRoot) {
+  const lockPath = join(projectRoot, 'deno.lock');
+  if (!existsSync(lockPath)) return 'no-lock';
+  const content = readFileSync(lockPath, 'utf-8');
+  return createHash('sha256').update(content).digest('hex').substring(0, 16);
+}
+/**
+ * Read a cached manifest from .openElement/external-manifest.json.
+ * Returns null if the cache is stale (lock hash mismatch) or missing.
+ */ function readCachedManifest(projectRoot, lockHash) {
+  const cachePath = join(projectRoot, '.openElement', 'external-manifest.json');
+  if (!existsSync(cachePath)) return null;
+  try {
+    const cached = JSON.parse(readFileSync(cachePath, 'utf-8'));
+    if (cached.lockHash === lockHash && cached.specifiers?.length > 0) {
+      return cached; // Cache hit — lock unchanged, deps stable
+    }
+  } catch  {
+  /* stale/corrupt cache — treat as miss */ }
+  return null;
+}
+/**
+ * Write the manifest cache to .openElement/external-manifest.json.
+ */ function writeCachedManifest(projectRoot, manifest) {
+  const dir = join(projectRoot, '.openElement');
+  if (!existsSync(dir)) mkdirSync(dir, {
+    recursive: true
+  });
+  writeFileSync(join(dir, 'external-manifest.json'), writeJson(manifest), 'utf-8');
+}
+/**
+ * ADR-0047: Parse `deno info --json` output to extract all specifiers belonging
+ * to external packages. This eliminates the need for regex-based external matching
+ * that leaks ESM subpaths into Rolldown.
+ */ export function extractExternalSpecifiers(denoInfo, externalPackages) {
+  const specifiers = new Set();
+  for (const mod of denoInfo.modules){
+    if (mod.error) continue;
+    const spec = mod.specifier;
+    // Only process npm: specifiers — these are the ones Rolldown chokes on.
+    if (!spec.startsWith('npm:')) continue;
+    for (const pkg of externalPackages){
+      // Match: npm:pkg@..., npm:pkg@.../sub/path, npm:pkg/sub/path
+      if (spec === `npm:${pkg}` || spec.startsWith(`npm:${pkg}@`) || spec.startsWith(`npm:${pkg}/`)) {
+        // Strip npm: prefix to get the bare specifier Rolldown expects.
+        const bare = spec.replace(/^npm:/, '');
+        // Strip version tag to get clean bare specifier:
+        //   entities@^4/lib/escape.js → entities/lib/escape.js
+        const clean = bare.replace(/@[^/]+/, '');
+        specifiers.add(clean);
+      }
+    }
+  }
+  return [
+    ...specifiers
+  ].sort();
+}
+/**
+ * Build a fallback manifest.
+ * Used when Deno is unavailable or skipResolution is true.
+ *
+ * ADR-0054: Uses AST-based exports resolution instead of regex patterns.
+ */ export function buildFallbackManifest(externalPackages, projectRoot) {
+  const specifiers = completeExternalSpecifiers([], externalPackages, projectRoot);
+  return {
+    specifiers,
+    importMap: {},
+    generatedAt: new Date().toISOString(),
+    lockHash: 'fallback'
+  };
+}
+/**
+ * Build importmap entries from Deno redirects.
+ * Only includes redirects that point to npm: URLs.
+ */ function buildImportMapFromRedirects(output, _externalPackages) {
+  const importMap = {};
+  if (output.redirects) {
+    for (const [key, value] of Object.entries(output.redirects)){
+      // Only include redirects that start with npm:
+      if (value.startsWith('npm:')) {
+        importMap[key] = value;
+      }
+    }
+  }
+  return importMap;
+}
+/**
+ * Resolve the complete external dependency manifest using Deno module graph.
+ *
+ * Flow:
+ * 1. Check cache (.openElement/external-manifest.json by deno.lock hash)
+ * 2. If cache miss: write temp probe module, run `deno info --json`, parse
+ * 3. Supplement with AST-based exports resolution (ADR-0054)
+ * 4. Fallback to AST-only if Deno is unavailable
+ */ export async function resolveExternalManifest(externalPackages, projectRoot, skipResolution = false) {
+  const lockHash = computeLockHash(projectRoot);
+  // Cache hit?
+  if (!skipResolution) {
+    const cached = readCachedManifest(projectRoot, lockHash);
+    if (cached) return cached;
+  }
+  if (skipResolution) {
+    return buildFallbackManifest(externalPackages, projectRoot);
+  }
+  // Try Deno pre-resolution
+  try {
+    const probeCode = externalPackages.map((pkg)=>`import '${pkg}';`).join('\n');
+    const probePath = join(projectRoot, '.openElement', '.external-probe.ts');
+    mkdirSync(join(projectRoot, '.openElement'), {
+      recursive: true
+    });
+    writeFileSync(probePath, probeCode, 'utf-8');
+    const { execSync } = await import('node:child_process');
+    const deno = execSync(`deno info --json "${probePath}"`, {
+      cwd: projectRoot,
+      maxBuffer: 10 * 1024 * 1024,
+      timeout: 15000
+    });
+    unlinkSync(probePath);
+    const output = JSON.parse(deno.toString());
+    const baseSpecifiers = extractExternalSpecifiers(output, externalPackages);
+    // ADR-0054: Supplement with AST-based exports resolution
+    const specifiers = completeExternalSpecifiers(baseSpecifiers, externalPackages, projectRoot);
+    const importMap = buildImportMapFromRedirects(output, externalPackages);
+    const manifest = {
+      specifiers,
+      importMap,
+      generatedAt: new Date().toISOString(),
+      lockHash
+    };
+    writeCachedManifest(projectRoot, manifest);
+    return manifest;
+  } catch (_err) {
+    // Deno not available or failed — fallback to AST-based resolution
+    const fallback = buildFallbackManifest(externalPackages, projectRoot);
+    return fallback;
+  }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/ssg/src/external-resolver.ts"],"sourcesContent":["/**\n * adapter-vite internal SSG - Deno External Dependency Pre-Resolution (ADR-0047).\n *\n * Eliminates ESM subpath leaks into Rolldown by having Deno resolve all\n * external package transitive dependencies before the bundler sees them.\n * Produces a complete specifier list so ssr.external needs no regex.\n *\n * ADR-0054: AST-based specifier resolution replaces manual regex patterns.\n * For each external package, we parse its package.json exports field to\n * auto-discover ALL subpath exports. No more regex maintenance.\n */\nimport type { ExternalManifest } from '@openelement/protocol/ssg';\nimport { join } from 'node:path';\nimport { createHash } from 'node:crypto';\nimport { writeJson } from '@openelement/content/write-json';\nimport { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';\n\ninterface DenoInfoModule {\n  specifier: string;\n  error?: string;\n}\n\ninterface DenoInfoOutput {\n  modules: DenoInfoModule[];\n  roots: string[];\n  redirects?: Record<string, string>;\n}\n\n/** Package.json minimal shape for exports parsing. */\ninterface PkgJson {\n  exports?: unknown;\n  main?: string;\n}\n\n/** Conditional keys to skip when walking exports (not subpaths). */\nconst CONDITION_KEYS = new Set([\n  'import',\n  'require',\n  'node',\n  'default',\n  'types',\n  'browser',\n  'deno',\n  'worker',\n  'development',\n  'production',\n  'module',\n]);\n\n/**\n * ADR-0054: Recursively walk a package.json exports field to extract all\n * export subpaths as bare specifier strings.\n *\n * Handles:\n *   \".\"          → \"package-name\"\n *   \"./sub\"      → \"package-name/sub\"\n *   \"./sub/*\"    → \"package-name/sub/*\" (wildcard, matches all sub-subpaths)\n *   \"./*\"        → \"package-name/*\"\n *   Conditional  → recurses into sub-conditions (import/require/default)\n *\n * Skips condition keys: import, require, node, default, types, browser,\n * deno, worker, development, production, module.\n */\nexport function walkExports(\n  exports: unknown,\n  packageName: string,\n  prefix = '',\n): string[] {\n  const results: string[] = [];\n\n  if (typeof exports === 'string') {\n    // Leaf: e.g. \".\": \"./index.js\" → package-name\n    // Strip \"./\" prefix to get subpath: \"./sub\" → \"sub\", \"./*\" → \"*\", \".\" → \"\"\n    const subpath = prefix.replace(/^\\.\\/?/, '');\n    results.push(subpath ? `${packageName}/${subpath}` : packageName);\n    return results;\n  }\n\n  if (exports === null || exports === undefined) {\n    return results;\n  }\n\n  if (Array.isArray(exports)) {\n    // Array fallback — take first valid\n    for (const item of exports) {\n      const sub = walkExports(item, packageName, prefix);\n      if (sub.length > 0) {\n        results.push(...sub);\n        break;\n      }\n    }\n    return results;\n  }\n\n  if (typeof exports === 'object') {\n    const obj = exports as Record<string, unknown>;\n\n    const hasSubpathKeys = Object.keys(obj).some((k) => !CONDITION_KEYS.has(k));\n    const hasConditionKeys = Object.keys(obj).some((k) => CONDITION_KEYS.has(k));\n\n    if (hasConditionKeys && !hasSubpathKeys) {\n      // Pure condition block: recurse into each condition\n      const seen = new Set<string>();\n      for (const key of Object.keys(obj)) {\n        if (CONDITION_KEYS.has(key)) {\n          const sub = walkExports(obj[key], packageName, prefix);\n          for (const s of sub) {\n            if (!seen.has(s)) {\n              seen.add(s);\n              results.push(s);\n            }\n          }\n        }\n      }\n    } else if (hasSubpathKeys) {\n      // Subpath mapping: each key is a subpath\n      for (const key of Object.keys(obj)) {\n        if (CONDITION_KEYS.has(key)) continue;\n        const newPrefix = key; // e.g. \".\", \"./secure-headers\", \"./*\"\n        const sub = walkExports(obj[key], packageName, newPrefix);\n        results.push(...sub);\n      }\n    }\n  }\n\n  return results;\n}\n\n/**\n * ADR-0054: Resolve a package's exports to a complete list of bare specifiers\n * by reading its package.json from node_modules.\n */\nexport function resolvePackageExports(packageName: string, projectRoot: string): string[] {\n  // Try standard node_modules resolution first\n  const candidates = [\n    join(projectRoot, 'node_modules', packageName, 'package.json'),\n    join(\n      projectRoot,\n      'node_modules',\n      '.deno',\n      `${packageName}.node_modules`,\n      packageName,\n      'package.json',\n    ),\n  ];\n\n  for (const pkgPath of candidates) {\n    if (existsSync(pkgPath)) {\n      try {\n        const pkg: PkgJson = JSON.parse(readFileSync(pkgPath, 'utf-8'));\n        if (pkg.exports) {\n          return walkExports(pkg.exports, packageName);\n        }\n        // No exports field — use main or default to package name\n        break;\n      } catch {\n        // corrupt package.json — skip\n      }\n    }\n  }\n\n  // Fallback: return just the main package name\n  return [packageName];\n}\n\n/**\n * ADR-0054: Complete external specifier list by resolving each package's\n * exports via AST (package.json exports walk).\n */\nexport function completeExternalSpecifiers(\n  baseSpecifiers: string[],\n  externalPackages: string[],\n  projectRoot: string,\n): string[] {\n  const seen = new Set(baseSpecifiers);\n  const result = [...baseSpecifiers];\n\n  for (const pkg of externalPackages) {\n    try {\n      const subpaths = resolvePackageExports(pkg, projectRoot);\n      for (const sp of subpaths) {\n        if (!seen.has(sp)) {\n          seen.add(sp);\n          result.push(sp);\n        }\n      }\n    } catch {\n      // Package not found or has no exports — keep base specifiers\n    }\n  }\n\n  return result.sort();\n}\n\n/**\n * Compute a stable hash of deno.lock for cache invalidation.\n * Returns 'no-lock' if deno.lock doesn't exist.\n */\nfunction computeLockHash(projectRoot: string): string {\n  const lockPath = join(projectRoot, 'deno.lock');\n  if (!existsSync(lockPath)) return 'no-lock';\n  const content = readFileSync(lockPath, 'utf-8');\n  return createHash('sha256').update(content).digest('hex').substring(0, 16);\n}\n\n/**\n * Read a cached manifest from .openElement/external-manifest.json.\n * Returns null if the cache is stale (lock hash mismatch) or missing.\n */\nfunction readCachedManifest(projectRoot: string, lockHash: string): ExternalManifest | null {\n  const cachePath = join(projectRoot, '.openElement', 'external-manifest.json');\n  if (!existsSync(cachePath)) return null;\n  try {\n    const cached = JSON.parse(readFileSync(cachePath, 'utf-8')) as ExternalManifest;\n    if (cached.lockHash === lockHash && cached.specifiers?.length > 0) {\n      return cached; // Cache hit — lock unchanged, deps stable\n    }\n  } catch {\n    /* stale/corrupt cache — treat as miss */\n  }\n  return null;\n}\n\n/**\n * Write the manifest cache to .openElement/external-manifest.json.\n */\nfunction writeCachedManifest(projectRoot: string, manifest: ExternalManifest): void {\n  const dir = join(projectRoot, '.openElement');\n  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });\n  writeFileSync(join(dir, 'external-manifest.json'), writeJson(manifest), 'utf-8');\n}\n\n/**\n * ADR-0047: Parse `deno info --json` output to extract all specifiers belonging\n * to external packages. This eliminates the need for regex-based external matching\n * that leaks ESM subpaths into Rolldown.\n */\nexport function extractExternalSpecifiers(\n  denoInfo: DenoInfoOutput,\n  externalPackages: string[],\n): string[] {\n  const specifiers = new Set<string>();\n\n  for (const mod of denoInfo.modules) {\n    if (mod.error) continue;\n    const spec = mod.specifier;\n    // Only process npm: specifiers — these are the ones Rolldown chokes on.\n    if (!spec.startsWith('npm:')) continue;\n\n    for (const pkg of externalPackages) {\n      // Match: npm:pkg@..., npm:pkg@.../sub/path, npm:pkg/sub/path\n      if (\n        spec === `npm:${pkg}` ||\n        spec.startsWith(`npm:${pkg}@`) ||\n        spec.startsWith(`npm:${pkg}/`)\n      ) {\n        // Strip npm: prefix to get the bare specifier Rolldown expects.\n        const bare = spec.replace(/^npm:/, '');\n        // Strip version tag to get clean bare specifier:\n        //   entities@^4/lib/escape.js → entities/lib/escape.js\n        const clean = bare.replace(/@[^/]+/, '');\n        specifiers.add(clean);\n      }\n    }\n  }\n\n  return [...specifiers].sort();\n}\n\n/**\n * Build a fallback manifest.\n * Used when Deno is unavailable or skipResolution is true.\n *\n * ADR-0054: Uses AST-based exports resolution instead of regex patterns.\n */\nexport function buildFallbackManifest(\n  externalPackages: string[],\n  projectRoot: string,\n): ExternalManifest {\n  const specifiers = completeExternalSpecifiers([], externalPackages, projectRoot);\n\n  return {\n    specifiers,\n    importMap: {}, // Fallback skips importmap generation\n    generatedAt: new Date().toISOString(),\n    lockHash: 'fallback',\n  };\n}\n\n/**\n * Build importmap entries from Deno redirects.\n * Only includes redirects that point to npm: URLs.\n */\nfunction buildImportMapFromRedirects(\n  output: DenoInfoOutput,\n  _externalPackages: string[],\n): Record<string, string> {\n  const importMap: Record<string, string> = {};\n\n  if (output.redirects) {\n    for (const [key, value] of Object.entries(output.redirects)) {\n      // Only include redirects that start with npm:\n      if (value.startsWith('npm:')) {\n        importMap[key] = value;\n      }\n    }\n  }\n\n  return importMap;\n}\n\n/**\n * Resolve the complete external dependency manifest using Deno module graph.\n *\n * Flow:\n * 1. Check cache (.openElement/external-manifest.json by deno.lock hash)\n * 2. If cache miss: write temp probe module, run `deno info --json`, parse\n * 3. Supplement with AST-based exports resolution (ADR-0054)\n * 4. Fallback to AST-only if Deno is unavailable\n */\nexport async function resolveExternalManifest(\n  externalPackages: string[],\n  projectRoot: string,\n  skipResolution = false,\n): Promise<ExternalManifest> {\n  const lockHash = computeLockHash(projectRoot);\n\n  // Cache hit?\n  if (!skipResolution) {\n    const cached = readCachedManifest(projectRoot, lockHash);\n    if (cached) return cached;\n  }\n\n  if (skipResolution) {\n    return buildFallbackManifest(externalPackages, projectRoot);\n  }\n\n  // Try Deno pre-resolution\n  try {\n    const probeCode = externalPackages\n      .map((pkg) => `import '${pkg}';`)\n      .join('\\n');\n    const probePath = join(projectRoot, '.openElement', '.external-probe.ts');\n\n    mkdirSync(join(projectRoot, '.openElement'), { recursive: true });\n    writeFileSync(probePath, probeCode, 'utf-8');\n\n    const { execSync } = await import('node:child_process');\n    const deno = execSync(\n      `deno info --json \"${probePath}\"`,\n      { cwd: projectRoot, maxBuffer: 10 * 1024 * 1024, timeout: 15000 },\n    );\n\n    unlinkSync(probePath);\n    const output: DenoInfoOutput = JSON.parse(deno.toString());\n\n    const baseSpecifiers = extractExternalSpecifiers(output, externalPackages);\n    // ADR-0054: Supplement with AST-based exports resolution\n    const specifiers = completeExternalSpecifiers(\n      baseSpecifiers,\n      externalPackages,\n      projectRoot,\n    );\n    const importMap = buildImportMapFromRedirects(output, externalPackages);\n\n    const manifest: ExternalManifest = {\n      specifiers,\n      importMap,\n      generatedAt: new Date().toISOString(),\n      lockHash,\n    };\n\n    writeCachedManifest(projectRoot, manifest);\n    return manifest;\n  } catch (_err) {\n    // Deno not available or failed — fallback to AST-based resolution\n    const fallback = buildFallbackManifest(externalPackages, projectRoot);\n    return fallback;\n  }\n}\n"],"names":[],"mappings":"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"}

package/src/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @openelement/ssg - Adapter-agnostic SSG engine.
+ *
+ * Provides parallel SSG rendering, entry code generation, route scanning,
+ * island manifest generation, and HTML post-processing.
+ *
+ * This engine depends on protocol, core, router, and content — never on
+ * Vite or adapter-vite. Build adapters (e.g. adapter-vite) delegate SSG
+ * orchestration to this package.
+ *
+ * Architecture:
+ *   - Sequential rendering (baseline): render pages one at a time
+ *   - Parallel rendering (pool-based): render pages with concurrency limit
+ *
+ * @module @openelement/ssg
+ */ export type { ApiRouteDecl, AppShellDecl, AppShellPlan, ClientIslandEntry, CorsOriginConfig, CspConfig, DocumentConfig, EntryDescriptor, ExternalManifest, ImportDecl, IslandDecl, MiddlewareDecl, MiddlewareScopeDecl, PageRouteDecl, ParallelRenderOptions, ParallelRenderPageOutput, ParallelRenderResult, RendererDecl, ResolvedAppShell, RouteDecl, SpeculationRulesOptions, SsgIslandDeclForReport, SsgPageInput, SsgPageOutput, SsgRenderEvidence, SsgRenderOptions, SsrAdmissionPlan, SsrBundle } from '@openelement/protocol/ssg';
+export { resolveDynamicRoutePath, ssgRender } from "./ssg-render.js";
+export { buildIslandChunkMap, buildSpeculationRulesJson, injectClientScript, injectCspMeta, injectDsdPolyfill, injectSpeculationRules, injectViewTransitionMeta, insertAfterHead } from "./postprocess.js";
+export { cleanSsrArtifacts, postProcessClientIslandBuild } from "./build-postprocess.js";
+export type { BuildContextView } from "./build-postprocess.js";
+export { generateSsrPolyfillBanner } from "./ssr-polyfills.js";
+export { buildFallbackManifest, completeExternalSpecifiers, extractExternalSpecifiers, resolveExternalManifest, resolvePackageExports, walkExports } from "./external-resolver.js";
+export { detectAndClassifyCemPackages, fileToTagName, scanCemManifests, scanIslandMeta, scanIslands, scanPackageManifests, scanRoutes } from "./route-scanner.js";
+export { generateRouteTypes } from "./route-type-generator.js";
+export { buildEntryDescriptor, buildSsrAdmissionPlan } from "./entry-renderer.js";
+export { generateHonoEntryCode, renderEntry } from "./entry-renderer.js";
+export type { HonoEntryOptions } from "./entry-renderer.js";
+export { extractCustomElementTags, generateIslandManifests, writeIslandManifests } from "./island-manifest.js";
+export { stableHash } from "./ssg-helpers.js";
+export type { IslandLayerMap, IslandManifestEntry, IslandStrategyMap, PageIslandManifest } from "./island-manifest.js";
+export { generateClientEntry, validateClientIslandEntry } from "./entry-generators.js";

package/src/index.js

@@ -0,0 +1,28 @@
+/**
+ * @openelement/ssg - Adapter-agnostic SSG engine.
+ *
+ * Provides parallel SSG rendering, entry code generation, route scanning,
+ * island manifest generation, and HTML post-processing.
+ *
+ * This engine depends on protocol, core, router, and content — never on
+ * Vite or adapter-vite. Build adapters (e.g. adapter-vite) delegate SSG
+ * orchestration to this package.
+ *
+ * Architecture:
+ *   - Sequential rendering (baseline): render pages one at a time
+ *   - Parallel rendering (pool-based): render pages with concurrency limit
+ *
+ * @module @openelement/ssg
+ */ export { resolveDynamicRoutePath, ssgRender } from './ssg-render.js';
+export { buildIslandChunkMap, buildSpeculationRulesJson, injectClientScript, injectCspMeta, injectDsdPolyfill, injectSpeculationRules, injectViewTransitionMeta, insertAfterHead } from './postprocess.js';
+export { cleanSsrArtifacts, postProcessClientIslandBuild } from './build-postprocess.js';
+export { generateSsrPolyfillBanner } from './ssr-polyfills.js';
+export { buildFallbackManifest, completeExternalSpecifiers, extractExternalSpecifiers, resolveExternalManifest, resolvePackageExports, walkExports } from './external-resolver.js';
+export { detectAndClassifyCemPackages, fileToTagName, scanCemManifests, scanIslandMeta, scanIslands, scanPackageManifests, scanRoutes } from './route-scanner.js';
+export { generateRouteTypes } from './route-type-generator.js';
+export { buildEntryDescriptor, buildSsrAdmissionPlan } from './entry-renderer.js';
+export { generateHonoEntryCode, renderEntry } from './entry-renderer.js';
+export { extractCustomElementTags, generateIslandManifests, writeIslandManifests } from './island-manifest.js';
+export { stableHash } from './ssg-helpers.js';
+export { generateClientEntry, validateClientIslandEntry } from './entry-generators.js';
+//# sourceMappingURL=data:application/json;base64,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

package/src/island-manifest.d.ts

@@ -0,0 +1,27 @@
+import type { ComponentLayer, HydrationStrategy } from '@openelement/protocol/framework';
+/** Island manifest entry for a single custom element */ export interface IslandManifestEntry {
+  /** Custom element tag name (e.g. 'open-theme-toggle') */ tagName: string;
+  /** Client chunk URL relative to site root */ chunkUrl: string;
+  /** Upgrade strategy */ strategy: HydrationStrategy;
+  /** Component layer */ layer: ComponentLayer;
+}
+/** Per-page island manifest */ export interface PageIslandManifest {
+  /** Page route (e.g. '/guide/getting-started') */ route: string;
+  /** Islands found on this page */ islands: IslandManifestEntry[];
+  /** Build timestamp (ISO 8601) */ builtAt: string;
+}
+/** Strategy map type: tagName -> strategy */ export type IslandStrategyMap = Record<string, HydrationStrategy>;
+/** Layer map type: tagName -> layer */ export type IslandLayerMap = Record<string, ComponentLayer>;
+/**
+ * Extract custom element tag names from HTML content.
+ * Matches <xxx-yyy> or <xxx-yyy ...> patterns (custom elements must contain a hyphen).
+ * v0.14.6: Strips HTML comments, script blocks, and style blocks before matching
+ * to avoid false positives (e.g., CE tags inside comments or script content).
+ */ export declare function extractCustomElementTags(html: string): string[];
+/**
+ * Generate island manifests for all HTML files in the output directory.
+ */ export declare function generateIslandManifests(htmlDir: string, islandChunkMap: Record<string, string>, strategyMap?: IslandStrategyMap, layerMap?: IslandLayerMap): PageIslandManifest[];
+/**
+ * Write island manifest files to disk.
+ * Each page gets its own JSON file at {outDir}/island-manifests/{route-hash}.json
+ */ export declare function writeIslandManifests(outputDir: string, manifests: PageIslandManifest[]): Promise<void>;

package/src/island-manifest.js

@@ -0,0 +1,78 @@
+/**
+ * @openelement/core - Island Upgrade Manifest
+ *
+ * Generates per-page island manifest JSON files during SSG post-processing.
+ * Each manifest lists the islands found on a page with their chunk URLs and strategies.
+ */ import { join } from 'node:path';
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { writeJson } from '@openelement/content/write-json';
+import { stableHash } from './ssg-helpers.js';
+/**
+ * Extract custom element tag names from HTML content.
+ * Matches <xxx-yyy> or <xxx-yyy ...> patterns (custom elements must contain a hyphen).
+ * v0.14.6: Strips HTML comments, script blocks, and style blocks before matching
+ * to avoid false positives (e.g., CE tags inside comments or script content).
+ */ export function extractCustomElementTags(html) {
+  // Strip HTML comments, script blocks, and style blocks first
+  const cleaned = html.replace(/<!--[\s\S]*?-->/g, '') // Remove HTML comments
+  .replace(/<script[\s>][\s\S]*?<\/script>/gi, '') // Remove script blocks
+  .replace(/<style[\s>][\s\S]*?<\/style>/gi, ''); // Remove style blocks
+  const tagPattern = /<([a-z][a-z0-9]*-[a-z0-9-]+)[\s>\/]/gi;
+  const tags = new Set();
+  let match;
+  while((match = tagPattern.exec(cleaned)) !== null){
+    tags.add(match[1].toLowerCase());
+  }
+  return [
+    ...tags
+  ];
+}
+/**
+ * Generate island manifests for all HTML files in the output directory.
+ */ export function generateIslandManifests(htmlDir, islandChunkMap, strategyMap = {}, layerMap = {}) {
+  const manifests = [];
+  if (!existsSync(htmlDir)) return manifests;
+  const entries = readdirSync(htmlDir, {
+    withFileTypes: true
+  });
+  for (const entry of entries){
+    if (entry.isDirectory()) {
+      const subManifests = generateIslandManifests(join(htmlDir, entry.name), islandChunkMap, strategyMap, layerMap);
+      for (const m of subManifests){
+        m.route = `/${entry.name}${m.route}`;
+      }
+      manifests.push(...subManifests);
+    } else if (entry.name.endsWith('.html')) {
+      const html = readFileSync(join(htmlDir, entry.name), 'utf-8');
+      const tags = extractCustomElementTags(html);
+      const islands = tags.filter((tag)=>tag in islandChunkMap).map((tag)=>({
+          tagName: tag,
+          chunkUrl: islandChunkMap[tag],
+          strategy: strategyMap[tag] || 'idle',
+          layer: layerMap[tag] || 'dsd-static'
+        }));
+      const route = entry.name === 'index.html' ? '/' : `/${entry.name.replace(/\.html$/, '')}`;
+      manifests.push({
+        route,
+        islands,
+        builtAt: new Date().toISOString()
+      });
+    }
+  }
+  return manifests;
+}
+/**
+ * Write island manifest files to disk.
+ * Each page gets its own JSON file at {outDir}/island-manifests/{route-hash}.json
+ */ export async function writeIslandManifests(outputDir, manifests) {
+  const manifestDir = join(outputDir, 'island-manifests');
+  mkdirSync(manifestDir, {
+    recursive: true
+  });
+  for (const manifest of manifests){
+    const hash = await stableHash(manifest.route);
+    const filename = `page-${hash}.json`;
+    writeFileSync(join(manifestDir, filename), writeJson(manifest), 'utf-8');
+  }
+} // stableHash moved to ssg-helpers.ts — imported above
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/ssg/src/island-manifest.ts"],"sourcesContent":["/**\n * @openelement/core - Island Upgrade Manifest\n *\n * Generates per-page island manifest JSON files during SSG post-processing.\n * Each manifest lists the islands found on a page with their chunk URLs and strategies.\n */\n\nimport { join } from 'node:path';\nimport { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';\nimport type { ComponentLayer, HydrationStrategy } from '@openelement/protocol/framework';\nimport { writeJson } from '@openelement/content/write-json';\nimport { stableHash } from './ssg-helpers.js';\n\n/** Island manifest entry for a single custom element */\nexport interface IslandManifestEntry {\n  /** Custom element tag name (e.g. 'open-theme-toggle') */\n  tagName: string;\n  /** Client chunk URL relative to site root */\n  chunkUrl: string;\n  /** Upgrade strategy */\n  strategy: HydrationStrategy;\n  /** Component layer */\n  layer: ComponentLayer;\n}\n\n/** Per-page island manifest */\nexport interface PageIslandManifest {\n  /** Page route (e.g. '/guide/getting-started') */\n  route: string;\n  /** Islands found on this page */\n  islands: IslandManifestEntry[];\n  /** Build timestamp (ISO 8601) */\n  builtAt: string;\n}\n\n/** Strategy map type: tagName -> strategy */\nexport type IslandStrategyMap = Record<string, HydrationStrategy>;\n\n/** Layer map type: tagName -> layer */\nexport type IslandLayerMap = Record<string, ComponentLayer>;\n\n/**\n * Extract custom element tag names from HTML content.\n * Matches <xxx-yyy> or <xxx-yyy ...> patterns (custom elements must contain a hyphen).\n * v0.14.6: Strips HTML comments, script blocks, and style blocks before matching\n * to avoid false positives (e.g., CE tags inside comments or script content).\n */\nexport function extractCustomElementTags(html: string): string[] {\n  // Strip HTML comments, script blocks, and style blocks first\n  const cleaned = html\n    .replace(/<!--[\\s\\S]*?-->/g, '') // Remove HTML comments\n    .replace(/<script[\\s>][\\s\\S]*?<\\/script>/gi, '') // Remove script blocks\n    .replace(/<style[\\s>][\\s\\S]*?<\\/style>/gi, ''); // Remove style blocks\n  const tagPattern = /<([a-z][a-z0-9]*-[a-z0-9-]+)[\\s>\\/]/gi;\n  const tags = new Set<string>();\n  let match: RegExpExecArray | null;\n  while ((match = tagPattern.exec(cleaned)) !== null) {\n    tags.add(match[1].toLowerCase());\n  }\n  return [...tags];\n}\n\n/**\n * Generate island manifests for all HTML files in the output directory.\n */\nexport function generateIslandManifests(\n  htmlDir: string,\n  islandChunkMap: Record<string, string>,\n  strategyMap: IslandStrategyMap = {},\n  layerMap: IslandLayerMap = {},\n): PageIslandManifest[] {\n  const manifests: PageIslandManifest[] = [];\n\n  if (!existsSync(htmlDir)) return manifests;\n\n  const entries = readdirSync(htmlDir, { withFileTypes: true });\n\n  for (const entry of entries) {\n    if (entry.isDirectory()) {\n      const subManifests = generateIslandManifests(\n        join(htmlDir, entry.name),\n        islandChunkMap,\n        strategyMap,\n        layerMap,\n      );\n      for (const m of subManifests) {\n        m.route = `/${entry.name}${m.route}`;\n      }\n      manifests.push(...subManifests);\n    } else if (entry.name.endsWith('.html')) {\n      const html = readFileSync(join(htmlDir, entry.name), 'utf-8');\n      const tags = extractCustomElementTags(html);\n\n      const islands: IslandManifestEntry[] = tags\n        .filter((tag) => tag in islandChunkMap)\n        .map((tag) => ({\n          tagName: tag,\n          chunkUrl: islandChunkMap[tag],\n          strategy: strategyMap[tag] || 'idle',\n          layer: layerMap[tag] || 'dsd-static',\n        }));\n\n      const route = entry.name === 'index.html' ? '/' : `/${entry.name.replace(/\\.html$/, '')}`;\n\n      manifests.push({\n        route,\n        islands,\n        builtAt: new Date().toISOString(),\n      });\n    }\n  }\n\n  return manifests;\n}\n\n/**\n * Write island manifest files to disk.\n * Each page gets its own JSON file at {outDir}/island-manifests/{route-hash}.json\n */\nexport async function writeIslandManifests(\n  outputDir: string,\n  manifests: PageIslandManifest[],\n): Promise<void> {\n  const manifestDir = join(outputDir, 'island-manifests');\n  mkdirSync(manifestDir, { recursive: true });\n\n  for (const manifest of manifests) {\n    const hash = await stableHash(manifest.route);\n    const filename = `page-${hash}.json`;\n    writeFileSync(join(manifestDir, filename), writeJson(manifest), 'utf-8');\n  }\n}\n\n// stableHash moved to ssg-helpers.ts — imported above\n"],"names":[],"mappings":"AAAA;;;;;CAKC,GAED,SAAS,IAAI,QAAQ,YAAY;AACjC,SAAS,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,QAAQ,UAAU;AAE1F,SAAS,SAAS,QAAQ,kCAAkC;AAC5D,SAAS,UAAU,QAAQ,mBAAmB;AA8B9C;;;;;CAKC,GACD,OAAO,SAAS,yBAAyB,IAAY;EACnD,6DAA6D;EAC7D,MAAM,UAAU,KACb,OAAO,CAAC,oBAAoB,IAAI,uBAAuB;GACvD,OAAO,CAAC,oCAAoC,IAAI,uBAAuB;GACvE,OAAO,CAAC,kCAAkC,KAAK,sBAAsB;EACxE,MAAM,aAAa;EACnB,MAAM,OAAO,IAAI;EACjB,IAAI;EACJ,MAAO,CAAC,QAAQ,WAAW,IAAI,CAAC,QAAQ,MAAM,KAAM;IAClD,KAAK,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,WAAW;EAC/B;EACA,OAAO;OAAI;GAAK;AAClB;AAEA;;CAEC,GACD,OAAO,SAAS,wBACd,OAAe,EACf,cAAsC,EACtC,cAAiC,CAAC,CAAC,EACnC,WAA2B,CAAC,CAAC;EAE7B,MAAM,YAAkC,EAAE;EAE1C,IAAI,CAAC,WAAW,UAAU,OAAO;EAEjC,MAAM,UAAU,YAAY,SAAS;IAAE,eAAe;EAAK;EAE3D,KAAK,MAAM,SAAS,QAAS;IAC3B,IAAI,MAAM,WAAW,IAAI;MACvB,MAAM,eAAe,wBACnB,KAAK,SAAS,MAAM,IAAI,GACxB,gBACA,aACA;MAEF,KAAK,MAAM,KAAK,aAAc;QAC5B,EAAE,KAAK,GAAG,CAAC,CAAC,EAAE,MAAM,IAAI,GAAG,EAAE,KAAK,EAAE;MACtC;MACA,UAAU,IAAI,IAAI;IACpB,OAAO,IAAI,MAAM,IAAI,CAAC,QAAQ,CAAC,UAAU;MACvC,MAAM,OAAO,aAAa,KAAK,SAAS,MAAM,IAAI,GAAG;MACrD,MAAM,OAAO,yBAAyB;MAEtC,MAAM,UAAiC,KACpC,MAAM,CAAC,CAAC,MAAQ,OAAO,gBACvB,GAAG,CAAC,CAAC,MAAQ,CAAC;UACb,SAAS;UACT,UAAU,cAAc,CAAC,IAAI;UAC7B,UAAU,WAAW,CAAC,IAAI,IAAI;UAC9B,OAAO,QAAQ,CAAC,IAAI,IAAI;QAC1B,CAAC;MAEH,MAAM,QAAQ,MAAM,IAAI,KAAK,eAAe,MAAM,CAAC,CAAC,EAAE,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,KAAK;MAEzF,UAAU,IAAI,CAAC;QACb;QACA;QACA,SAAS,IAAI,OAAO,WAAW;MACjC;IACF;EACF;EAEA,OAAO;AACT;AAEA;;;CAGC,GACD,OAAO,eAAe,qBACpB,SAAiB,EACjB,SAA+B;EAE/B,MAAM,cAAc,KAAK,WAAW;EACpC,UAAU,aAAa;IAAE,WAAW;EAAK;EAEzC,KAAK,MAAM,YAAY,UAAW;IAChC,MAAM,OAAO,MAAM,WAAW,SAAS,KAAK;IAC5C,MAAM,WAAW,CAAC,KAAK,EAAE,KAAK,KAAK,CAAC;IACpC,cAAc,KAAK,aAAa,WAAW,UAAU,WAAW;EAClE;AACF,EAEA,sDAAsD"}