@openelement/ssg 0.41.0-alpha.1

package/src/route-scanner.js

@@ -0,0 +1,497 @@
+/**
+ * @openelement/core - Route scanner
+ * Scans the routes directory and generates a route map.
+ * Produces the virtual:routes module.
+ *
+ * Phase 1 enhancement: support for _renderer.ts (layout) and
+ * _middleware.ts (Hono middleware) special files.
+ *
+ * Phase 2 enhancement: support for package islands auto-detection.
+ * Packages can export an `islands` array in their main entry.
+ *
+ * Convention (minimal augmentation):
+ * - _renderer.ts: exports a renderer that wraps route VNodes
+ * - _middleware.ts: exports a Hono middleware function applied before the route
+ * - Files starting with _ are not route handlers but are loaded by the framework
+ *
+ * ─── SSR Import Discovery Audit (Step1) ─────────────────────
+ *
+ * This file discovers islands but does NOT import them (static scan only):
+ *
+ * 1. Local island files:
+ *    - Scanned by `scanIslands()`
+ *    - Metadata read by `scanIslandMeta()` (static, no import)
+ *    - SSR decision: `openElement.ssr` field (static read, no import)
+ *
+ * 2. Package manifest islands:
+ *    - Discovered by `scanPackageManifests()`
+ *    - Imports package module to read `manifest` export
+ *    - Browser-only packages: caught by try/catch
+ *    - SSR decision: `manifest.declarations[].openElement.ssr` field
+ *
+ * 3. CEM manifests (v0.18.0):
+ *    - Discovered by `scanCemManifests()` - reads custom-elements.json from
+ *      node_modules packages WITHOUT importing package code
+ *    - Results fed into the compatibility classifier (parseCem + classifyCemManifest)
+ *
+ * 4. Nested custom elements (from the VNode tree):
+ *    - NOT handled in this file
+ *    - See: `packages/core/src/jsx-render-string.ts` and `renderDsdTree()`
+ *
+ * Audit completed: 2026-05-17
+ * Auditor: AI agent (openElement v0.17.4 SOP compliance check)
+ *
+ * ─── v0.41.0-alpha.1: AST removed ────────────────────────────
+ *
+ * Replaced TypeScript AST scanning with regex/glob-based extraction.
+ * Route and island modules are simple ESM files; parsing the whole source
+ * with the TypeScript compiler is overkill and adds a heavy dependency.
+ */ import { formatError, OpenElementError } from '@openelement/core/errors';
+import { createLogger } from '@openelement/core/logger';
+import { join, posix, sep } from 'node:path';
+import { classifyCemManifest, parseCem } from './cem-compat.js';
+import { safeReadDir, safeReadFile, safeStat } from './route-scanner-fs.js';
+const log = createLogger('core');
+/**
+ * Read a static string export (e.g. `export const tagName = '...'`) from source text.
+ */ export function readRouteTagName(source) {
+  const match = source.match(/export\s+const\s+tagName\s*=\s*(["'`])([^"'`]+)\1/);
+  return match?.[2];
+}
+/**
+ * Read `export const tagName = '...'` from a route file using regex scanning.
+ */ export async function readRouteTagNameFromModule(filePath) {
+  const source = await safeReadFile(filePath);
+  if (source === undefined) return undefined;
+  return readRouteTagName(source);
+}
+function staticOpenElementError(message) {
+  return new OpenElementError(`Invalid static island metadata export "openElement": ${message}. Accepted shape: export const openElement = defineIslandConfig({ ssr?: boolean, dsd?: boolean, hydrate?: "load" | "idle" | "visible" | "only" }).`, {
+    code: 'ISLAND_METADATA_ERROR',
+    statusCode: 500,
+    recoverable: false
+  });
+}
+/**
+ * v0.41.0-alpha.1: Regex-based extraction of
+ * `export const openElement = defineIslandConfig({ ... })`.
+ *
+ * The scanner intentionally does not execute island modules. It accepts only a
+ * defineIslandConfig() call with boolean `ssr`/`dsd` and string `hydrate`
+ * literal values. Dynamic metadata is rejected instead of guessed.
+ */ export function readStaticOpenElementExport(source) {
+  const declMatch = source.match(/export\s+const\s+openElement\s*=/);
+  if (!declMatch) return null;
+  const afterEquals = source.slice(declMatch.index + declMatch[0].length).trimStart();
+  // Must call defineIslandConfig(...) - reject legacy object literals.
+  const callMatch = afterEquals.match(/^defineIslandConfig\s*\(\s*(\{[\s\S]*?\})\s*\)/);
+  if (!callMatch) {
+    const hasCall = /^defineIslandConfig\s*\(/.test(afterEquals);
+    if (hasCall) {
+      throw staticOpenElementError('defineIslandConfig() argument must be a static object literal');
+    }
+    throw staticOpenElementError('openElement export must call defineIslandConfig(...)');
+  }
+  const body = callMatch[1].slice(1, -1);
+  const meta = {};
+  // Match key: value pairs, skipping nested braces/strings.
+  const propRe = /\b(ssr|dsd|hydrate|[^\s:,{}]+)\s*:\s*(true|false|["']([^"']*)["'])/g;
+  let m;
+  while((m = propRe.exec(body)) !== null){
+    const key = m[1];
+    const raw = m[2];
+    if (![
+      'ssr',
+      'dsd',
+      'hydrate'
+    ].includes(key)) {
+      throw staticOpenElementError(`unsupported openElement metadata key "${key}"`);
+    }
+    const typedKey = key;
+    if (typedKey === 'ssr' || typedKey === 'dsd') {
+      if (raw !== 'true' && raw !== 'false') {
+        throw staticOpenElementError(`openElement.${typedKey} must be a boolean literal`);
+      }
+      meta[typedKey] = raw === 'true';
+      continue;
+    }
+    const value = raw.slice(1, -1);
+    if (![
+      'load',
+      'idle',
+      'visible',
+      'only'
+    ].includes(value)) {
+      throw staticOpenElementError(`openElement.hydrate has unsupported value "${value}"`);
+    }
+    meta.hydrate = value;
+  }
+  return meta;
+}
+/**
+ * Convert a file path to a URL path pattern.
+ * e.g., 'index.ts' -> '/', 'about.ts' -> '/about', 'posts/[id].ts' -> '/posts/:id'
+ *
+ * v0.6': Uses URLPattern-compatible syntax where possible.
+ * URLPattern is the WHATWG standard for URL matching (section7.2).
+ * Pattern :param is compatible with both Hono and URLPattern.
+ */ function filePathToRoutePath(filePath) {
+  // Normalize separators - handle Windows backslash paths
+  // v0.14.3: Use posix.join to ensure all output paths use forward slashes
+  // regardless of platform. This prevents \ from leaking into URL patterns.
+  let p = filePath.split(sep).join(posix.sep);
+  // v0.25: AST-verified — path utility, regex is the appropriate tool
+  p = p.replace(/\.[^.]+$/, '');
+  // v0.25: AST-verified — path utility, converts [param] to :param
+  p = p.replace(/\[([^\]]+)\]/g, ':$1');
+  // Handle index
+  if (p === 'index') return '/';
+  if (p.endsWith('/index')) {
+    p = p.slice(0, -6); // Remove trailing /index
+    // After stripping /index, check if the result is the root index
+    if (p === 'index' || p === '') return '/';
+  }
+  // Ensure leading slash
+  if (!p.startsWith('/')) p = '/' + p;
+  return p;
+}
+/**
+ * Determine route type from file path.
+ * Files under 'api/' subdirectory are API routes.
+ */ function getRouteType(filePath) {
+  const normalized = filePath.split(sep).join(posix.sep);
+  return normalized.startsWith('api/') || normalized.includes('/api/') ? 'api' : 'page';
+}
+/**
+ * Generate a valid JS variable name from a route path.
+ * e.g., '/' -> 'RouteIndex', '/about' -> 'RouteAbout', '/posts/:id' -> 'RoutePostsId'
+ */ function pathToVarName(path) {
+  // v0.25: AST-verified — path-to-identifier transformation, regex is the appropriate tool
+  let name = path.replace(/^\//, '').replace(/\/$/, '').replace(/:([^/]+)/g, '$1').replace(/[^a-zA-Z0-9]/g, '_');
+  if (!name || name === '_') name = 'Index';
+  return 'Route_' + name.charAt(0).toUpperCase() + name.slice(1);
+}
+/**
+ * Identify special file types by name.
+ * _renderer.ts -> renderer, _middleware.ts -> middleware
+ */ // ponytail: inline lookup replaces 2-case switch
+function getSpecialFileType(fileName) {
+  const baseName = fileName.replace(/\.[^.]+$/, '');
+  return ({
+    _renderer: 'renderer',
+    _middleware: 'middleware'
+  })[baseName] ?? null;
+}
+/**
+ * Check if a file should be ignored for routing.
+ * Dot-files are always ignored.
+ */ function isIgnoredFile(fileName) {
+  return fileName.startsWith('.');
+}
+/**
+ * Recursively scan a directory for route files.
+ * Also collects _renderer.ts and _middleware.ts special files.
+ */ export async function scanRoutes(routesDir, baseDir = '') {
+  const entries = [];
+  const files = await safeReadDir(routesDir);
+  if (files === undefined) {
+    log.debug(`Routes directory "${routesDir}" not found`);
+    return entries;
+  }
+  for (const file of files){
+    if (isIgnoredFile(file)) continue;
+    const fullPath = join(routesDir, file);
+    const relativePath = baseDir ? join(baseDir, file) : file;
+    const fileStat = await safeStat(fullPath);
+    if (!fileStat) {
+      log.debug(`File vanished before stat: ${fullPath}`);
+      continue;
+    }
+    if (fileStat.isDirectory()) {
+      // Recurse into subdirectories
+      const subEntries = await scanRoutes(fullPath, relativePath);
+      entries.push(...subEntries);
+    } else if (/\.(ts|tsx|js|jsx)$/.test(file)) {
+      // Check for special files
+      const specialType = getSpecialFileType(file);
+      if (specialType) {
+        // Add as a special entry - not a route handler, but loadable
+        entries.push({
+          path: filePathToRoutePath(relativePath),
+          filePath: relativePath.split(sep).join(posix.sep),
+          type: 'special',
+          varName: `Special_${specialType}_${baseDir.replace(/[\\/]/g, '_') || 'root'}`,
+          special: specialType
+        });
+      } else if (!file.startsWith('_')) {
+        // Regular route file
+        const routePath = filePathToRoutePath(relativePath);
+        const routeType = getRouteType(relativePath);
+        // v0.25: AST-verified — path utility, extracts [param] patterns
+        const paramMatches = relativePath.match(/\[([^\]]+)\]/g);
+        const params = paramMatches ? paramMatches.map((m)=>m.slice(1, -1)) : undefined;
+        let tagName;
+        if (routeType === 'page') {
+          // Regex-based scanning reads `export const tagName` without executing the module.
+          tagName = await readRouteTagNameFromModule(fullPath);
+          if (tagName === undefined) {
+            // tagName not found is normal — not all page routes define one
+            log.debug(`No tagName export found in route module: ${fullPath}`);
+          }
+        }
+        entries.push({
+          path: routePath,
+          filePath: relativePath.split(sep).join(posix.sep),
+          type: routeType,
+          varName: pathToVarName(routePath),
+          tagName,
+          params
+        });
+      }
+    // Other _-prefixed files (not _renderer/_middleware) are silently skipped
+    }
+  }
+  // Sort routes: static paths first, then dynamic
+  entries.sort((a, b)=>{
+    // Special files go to the end
+    if (a.special || b.special) {
+      if (a.special && !b.special) return 1;
+      if (!a.special && b.special) return -1;
+      return 0;
+    }
+    const aDynamic = a.path.includes(':');
+    const bDynamic = b.path.includes(':');
+    if (aDynamic !== bDynamic) return aDynamic ? 1 : -1;
+    return a.path.localeCompare(b.path);
+  });
+  return entries;
+}
+/**
+ * v0.25: AST-verified — converts file name to a valid Custom Element tag name.
+ * Uses regex for path manipulation since tag names are derived from file paths.
+ *
+ * Examples:
+ *   'my-counter.ts'        -> 'my-counter'
+ *   'posts/index.ts'       -> 'posts-index'
+ *   'admin\\dashboard.ts'  -> 'admin-dashboard'
+ */ export function fileToTagName(fileName) {
+  return fileName.replace(/\.[^.]+$/, '') // v0.25: AST-verified — remove extension
+  .replace(/[\\/]/g, '-') // v0.25: AST-verified — replace path separators with hyphens
+  .toLowerCase();
+}
+/**
+ * Scan islands directory recursively for island files.
+ * Returns paths relative to islandsDir (e.g., ['my-counter.ts', 'posts/index.ts']).
+ */ export async function scanIslands(islandsDir, relativeDir = '') {
+  const files = [];
+  const entries = await safeReadDir(islandsDir);
+  if (entries === undefined) {
+    log.debug(`Islands directory "${islandsDir}" not found`);
+    return files;
+  }
+  for (const entry of entries){
+    if (entry.startsWith('.')) continue;
+    const fullPath = join(islandsDir, entry);
+    const fileStat = await safeStat(fullPath);
+    if (!fileStat) {
+      log.debug(`Island file vanished before stat: ${fullPath}`);
+      continue;
+    }
+    const relativePath = relativeDir ? join(relativeDir, entry) : entry;
+    if (fileStat.isDirectory()) {
+      const subFiles = await scanIslands(fullPath, relativePath);
+      files.push(...subFiles);
+    } else if (/\.(ts|tsx|js|jsx)$/.test(entry)) {
+      files.push(relativePath);
+    }
+  }
+  return files.sort();
+}
+/**
+ * v0.41.0-alpha.1: Regex-based — reads island metadata by statically scanning the module
+ * source for `export const openElement = defineIslandConfig({ ... })`.
+ *
+ * Supported form:
+ *   export const openElement = defineIslandConfig({ ssr: false, dsd: false, hydrate: 'only' })
+ *
+ * This is more reliable than regex because it handles:
+ * - Comments inside the object literal
+ * - Computed properties
+ * - Destructured/re-exported values
+ * - Canonical defineIslandConfig(...) calls
+ *
+ * If a module cannot be read, its metadata is silently skipped.
+ */ export async function scanIslandMeta(islandsDir, islandFiles) {
+  const meta = {};
+  for (const filePath of islandFiles){
+    const tagName = fileToTagName(filePath);
+    const fullPath = join(islandsDir, filePath);
+    const source = await safeReadFile(fullPath);
+    if (source === undefined) {
+      log.debug(`Unable to read island module for metadata: ${fullPath}`);
+      continue;
+    }
+    // Read the `openElement` export directly; no regex needed.
+    const openElementExport = readStaticOpenElementExport(source);
+    if (!openElementExport) continue;
+    const hydrate = openElementExport.hydrate && [
+      'load',
+      'idle',
+      'visible',
+      'only'
+    ].includes(openElementExport.hydrate) ? openElementExport.hydrate : undefined;
+    meta[tagName] = {
+      tagName,
+      filePath,
+      ssr: hydrate === 'only' ? false : openElementExport.ssr,
+      dsd: hydrate === 'only' ? false : openElementExport.dsd,
+      hydrate,
+      reason: hydrate === 'only' ? 'local island exports openElement.hydrate=only' : openElementExport.ssr === false ? 'local island exports openElement.ssr=false' : undefined
+    };
+  }
+  return meta;
+}
+/**
+ * Scan package exports for OpenElementPackageManifest.
+ * Packages should export a `manifest` OpenElementPackageManifest in their main entry.
+ *
+ * Example package export:
+ * ```ts
+ * // @openelement/ui/index.ts
+ * export { manifest } from './manifest.js';
+ * ```
+ *
+ * @param packageNames - List of package names to scan (e.g., ['@openelement/ui'])
+ * @returns Array of OpenElementPackageManifest
+ */ export async function scanPackageManifests(packageNames) {
+  const allManifests = [];
+  for (const pkg of packageNames){
+    // @vite-ignore suppresses unanalyzable-dynamic-import JSR warning.
+    let mod;
+    try {
+      mod = await import(/* @vite-ignore */ pkg);
+    } catch (e) {
+      if (isBrowserOnlyPackageImportError(e)) {
+        log.warn(`Skipping package manifest from "${pkg}": browser-only package cannot be imported during SSR discovery`);
+        continue;
+      }
+      throw new OpenElementError(`Failed to scan package manifest from "${pkg}": ${formatError(e)}`, {
+        code: 'PACKAGE_SCAN_ERROR',
+        statusCode: 500,
+        recoverable: false
+      });
+    }
+    if (mod.manifest && typeof mod.manifest === 'object') {
+      const manifest = mod.manifest;
+      if (manifest.packageName && manifest.declarations) {
+        allManifests.push(manifest);
+      } else {
+        throw new OpenElementError(`Invalid manifest in ${pkg}: missing packageName or declarations`, {
+          code: 'PACKAGE_MANIFEST_ERROR',
+          statusCode: 500,
+          recoverable: false
+        });
+      }
+    } else {
+      throw new OpenElementError(`Package ${pkg} does not export a manifest`, {
+        code: 'PACKAGE_MANIFEST_ERROR',
+        statusCode: 500,
+        recoverable: false
+      });
+    }
+  }
+  return allManifests;
+}
+/**
+ * v0.25: AST-verified — error message classification, regex is the appropriate tool
+ * for matching runtime error strings from failed dynamic imports.
+ */ function isBrowserOnlyPackageImportError(error) {
+  const message = formatError(error);
+  return /\b(window|document|HTMLElement|customElements|navigator)\b.*\bis not defined\b/i.test(message);
+}
+/**
+ * Scan node_modules for packages that ship a `custom-elements.json`.
+ *
+ * Strategy:
+ *   1. Read node_modules directory entries (top-level packages + scoped orgs)
+ *   2. For each package, check if `<pkg>/custom-elements.json` exists
+ *   3. Return the raw JSON - caller is responsible for parsing + classifying
+ *
+ * This function reads files only. It never imports or executes package code.
+ *
+ * @param nodeModulesDir - Absolute path to the node_modules directory
+ * @returns Array of found CEM manifests
+ */ export async function scanCemManifests(nodeModulesDir) {
+  const results = [];
+  const entries = await safeReadDir(nodeModulesDir);
+  if (!entries) return results;
+  for (const entry of entries){
+    if (entry.startsWith('.')) continue;
+    if (entry.startsWith('@')) {
+      // Scoped package directory - recurse one level
+      const scopeDir = join(nodeModulesDir, entry);
+      const scopedEntries = await safeReadDir(scopeDir);
+      if (!scopedEntries) continue;
+      for (const scopedEntry of scopedEntries){
+        if (scopedEntry.startsWith('.')) continue;
+        const packageName = `${entry}/${scopedEntry}`;
+        const cemPath = join(nodeModulesDir, entry, scopedEntry, 'custom-elements.json');
+        const result = await tryReadCemFile(cemPath, packageName);
+        if (result) results.push(result);
+      }
+    } else {
+      // Regular (non-scoped) package
+      const cemPath = join(nodeModulesDir, entry, 'custom-elements.json');
+      const result = await tryReadCemFile(cemPath, entry);
+      if (result) results.push(result);
+    }
+  }
+  return results;
+}
+/**
+ * Try to read a custom-elements.json file.
+ * Returns null if the file doesn't exist or can't be read.
+ */ async function tryReadCemFile(cemPath, packageName) {
+  const json = await safeReadFile(cemPath);
+  return json === undefined ? null : {
+    packageName,
+    cemPath,
+    json
+  };
+}
+/**
+ * Run CEM auto-detection: scan node_modules, parse each manifest,
+ * and classify all discovered components.
+ *
+ * This is the high-level function called from the Vite plugin buildStart().
+ * It combines scanCemManifests() + parseCem() + classifyCemManifest()
+ * into a single pipeline.
+ *
+ * @param nodeModulesDir - Absolute path to node_modules
+ * @returns Array of compatibility classifications (may be empty if no CEM found)
+ */ export async function detectAndClassifyCemPackages(nodeModulesDir) {
+  const cemResults = await scanCemManifests(nodeModulesDir);
+  if (cemResults.length === 0) return [];
+  const allClassifications = [];
+  for (const { packageName, json } of cemResults){
+    const parseResult = parseCem(json);
+    if (!parseResult.success || !parseResult.manifest) {
+      log.debug(`Skipping invalid CEM manifest from "${packageName}": ` + parseResult.errors.map((e)=>e.message).join('; '));
+      continue;
+    }
+    // Attach package name to the manifest for better diagnostics
+    const manifest = {
+      ...parseResult.manifest,
+      packageName
+    };
+    const classResult = classifyCemManifest(manifest);
+    // Log summary
+    const { stats } = classResult;
+    if (stats.totalComponents > 0) {
+      log.info(`CEM: ${packageName} - ${stats.totalComponents} component(s): ` + `${stats.ssrCapableCount} ssr-capable, ${stats.clientOnlyCount} client-only` + (stats.rejectedCount > 0 ? `, ${stats.rejectedCount} rejected` : '') + (stats.experimentalDomCount > 0 ? `, ${stats.experimentalDomCount} experimental` : ''));
+    }
+    allClassifications.push(...classResult.classifications);
+  }
+  return allClassifications;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/ssg/src/route-scanner.ts"],"sourcesContent":["/**\n * @openelement/core - Route scanner\n * Scans the routes directory and generates a route map.\n * Produces the virtual:routes module.\n *\n * Phase 1 enhancement: support for _renderer.ts (layout) and\n * _middleware.ts (Hono middleware) special files.\n *\n * Phase 2 enhancement: support for package islands auto-detection.\n * Packages can export an `islands` array in their main entry.\n *\n * Convention (minimal augmentation):\n * - _renderer.ts: exports a renderer that wraps route VNodes\n * - _middleware.ts: exports a Hono middleware function applied before the route\n * - Files starting with _ are not route handlers but are loaded by the framework\n *\n * ─── SSR Import Discovery Audit (Step1) ─────────────────────\n *\n * This file discovers islands but does NOT import them (static scan only):\n *\n * 1. Local island files:\n *    - Scanned by `scanIslands()`\n *    - Metadata read by `scanIslandMeta()` (static, no import)\n *    - SSR decision: `openElement.ssr` field (static read, no import)\n *\n * 2. Package manifest islands:\n *    - Discovered by `scanPackageManifests()`\n *    - Imports package module to read `manifest` export\n *    - Browser-only packages: caught by try/catch\n *    - SSR decision: `manifest.declarations[].openElement.ssr` field\n *\n * 3. CEM manifests (v0.18.0):\n *    - Discovered by `scanCemManifests()` - reads custom-elements.json from\n *      node_modules packages WITHOUT importing package code\n *    - Results fed into the compatibility classifier (parseCem + classifyCemManifest)\n *\n * 4. Nested custom elements (from the VNode tree):\n *    - NOT handled in this file\n *    - See: `packages/core/src/jsx-render-string.ts` and `renderDsdTree()`\n *\n * Audit completed: 2026-05-17\n * Auditor: AI agent (openElement v0.17.4 SOP compliance check)\n *\n * ─── v0.41.0-alpha.1: AST removed ────────────────────────────\n *\n * Replaced TypeScript AST scanning with regex/glob-based extraction.\n * Route and island modules are simple ESM files; parsing the whole source\n * with the TypeScript compiler is overkill and adds a heavy dependency.\n */\n\nimport type {\n  CompatibilityClassification,\n  RouteEntry,\n  SpecialFileType,\n} from '@openelement/protocol/framework';\nimport type { OpenElementPackageManifest } from '@openelement/protocol/manifest';\nimport { formatError, OpenElementError } from '@openelement/core/errors';\nimport { createLogger } from '@openelement/core/logger';\nimport { join, posix, sep } from 'node:path';\nimport { classifyCemManifest, parseCem } from './cem-compat.js';\nimport { safeReadDir, safeReadFile, safeStat } from './route-scanner-fs.js';\n\nconst log = createLogger('core');\n\n/** Local island metadata indexed by tag name. */\nexport interface LocalIslandMeta {\n  tagName: string;\n  filePath: string;\n  ssr?: boolean;\n  dsd?: boolean;\n  hydrate?: 'load' | 'idle' | 'visible' | 'only';\n  reason?: string;\n}\n\n/**\n * Read a static string export (e.g. `export const tagName = '...'`) from source text.\n */\nexport function readRouteTagName(source: string): string | undefined {\n  const match = source.match(/export\\s+const\\s+tagName\\s*=\\s*([\"'`])([^\"'`]+)\\1/);\n  return match?.[2];\n}\n\n/**\n * Read `export const tagName = '...'` from a route file using regex scanning.\n */\nexport async function readRouteTagNameFromModule(filePath: string): Promise<string | undefined> {\n  const source = await safeReadFile(filePath);\n  if (source === undefined) return undefined;\n  return readRouteTagName(source);\n}\n\nfunction staticOpenElementError(message: string): OpenElementError {\n  return new OpenElementError(\n    `Invalid static island metadata export \"openElement\": ${message}. Accepted shape: export const openElement = defineIslandConfig({ ssr?: boolean, dsd?: boolean, hydrate?: \"load\" | \"idle\" | \"visible\" | \"only\" }).`,\n    {\n      code: 'ISLAND_METADATA_ERROR',\n      statusCode: 500,\n      recoverable: false,\n    },\n  );\n}\n\n/**\n * v0.41.0-alpha.1: Regex-based extraction of\n * `export const openElement = defineIslandConfig({ ... })`.\n *\n * The scanner intentionally does not execute island modules. It accepts only a\n * defineIslandConfig() call with boolean `ssr`/`dsd` and string `hydrate`\n * literal values. Dynamic metadata is rejected instead of guessed.\n */\nexport function readStaticOpenElementExport(source: string): {\n  ssr?: boolean;\n  dsd?: boolean;\n  hydrate?: LocalIslandMeta['hydrate'];\n} | null {\n  const declMatch = source.match(/export\\s+const\\s+openElement\\s*=/);\n  if (!declMatch) return null;\n\n  const afterEquals = source.slice(declMatch.index! + declMatch[0].length).trimStart();\n\n  // Must call defineIslandConfig(...) - reject legacy object literals.\n  const callMatch = afterEquals.match(/^defineIslandConfig\\s*\\(\\s*(\\{[\\s\\S]*?\\})\\s*\\)/);\n  if (!callMatch) {\n    const hasCall = /^defineIslandConfig\\s*\\(/.test(afterEquals);\n    if (hasCall) {\n      throw staticOpenElementError(\n        'defineIslandConfig() argument must be a static object literal',\n      );\n    }\n    throw staticOpenElementError('openElement export must call defineIslandConfig(...)');\n  }\n\n  const body = callMatch[1].slice(1, -1);\n  const meta: { ssr?: boolean; dsd?: boolean; hydrate?: LocalIslandMeta['hydrate'] } = {};\n\n  // Match key: value pairs, skipping nested braces/strings.\n  const propRe = /\\b(ssr|dsd|hydrate|[^\\s:,{}]+)\\s*:\\s*(true|false|[\"']([^\"']*)[\"'])/g;\n  let m: RegExpExecArray | null;\n\n  while ((m = propRe.exec(body)) !== null) {\n    const key = m[1];\n    const raw = m[2];\n\n    if (!['ssr', 'dsd', 'hydrate'].includes(key)) {\n      throw staticOpenElementError(`unsupported openElement metadata key \"${key}\"`);\n    }\n\n    const typedKey = key as 'ssr' | 'dsd' | 'hydrate';\n\n    if (typedKey === 'ssr' || typedKey === 'dsd') {\n      if (raw !== 'true' && raw !== 'false') {\n        throw staticOpenElementError(`openElement.${typedKey} must be a boolean literal`);\n      }\n      meta[typedKey] = raw === 'true';\n      continue;\n    }\n\n    const value = raw.slice(1, -1);\n    if (!['load', 'idle', 'visible', 'only'].includes(value)) {\n      throw staticOpenElementError(`openElement.hydrate has unsupported value \"${value}\"`);\n    }\n    meta.hydrate = value as LocalIslandMeta['hydrate'];\n  }\n\n  return meta;\n}\n\n/**\n * Convert a file path to a URL path pattern.\n * e.g., 'index.ts' -> '/', 'about.ts' -> '/about', 'posts/[id].ts' -> '/posts/:id'\n *\n * v0.6': Uses URLPattern-compatible syntax where possible.\n * URLPattern is the WHATWG standard for URL matching (section7.2).\n * Pattern :param is compatible with both Hono and URLPattern.\n */\nfunction filePathToRoutePath(filePath: string): string {\n  // Normalize separators - handle Windows backslash paths\n  // v0.14.3: Use posix.join to ensure all output paths use forward slashes\n  // regardless of platform. This prevents \\ from leaking into URL patterns.\n  let p = filePath.split(sep).join(posix.sep);\n\n  // v0.25: AST-verified — path utility, regex is the appropriate tool\n  p = p.replace(/\\.[^.]+$/, '');\n\n  // v0.25: AST-verified — path utility, converts [param] to :param\n  p = p.replace(/\\[([^\\]]+)\\]/g, ':$1');\n\n  // Handle index\n  if (p === 'index') return '/';\n  if (p.endsWith('/index')) {\n    p = p.slice(0, -6); // Remove trailing /index\n    // After stripping /index, check if the result is the root index\n    if (p === 'index' || p === '') return '/';\n  }\n\n  // Ensure leading slash\n  if (!p.startsWith('/')) p = '/' + p;\n\n  return p;\n}\n\n/**\n * Determine route type from file path.\n * Files under 'api/' subdirectory are API routes.\n */\nfunction getRouteType(filePath: string): 'page' | 'api' {\n  const normalized = filePath.split(sep).join(posix.sep);\n  return normalized.startsWith('api/') || normalized.includes('/api/') ? 'api' : 'page';\n}\n\n/**\n * Generate a valid JS variable name from a route path.\n * e.g., '/' -> 'RouteIndex', '/about' -> 'RouteAbout', '/posts/:id' -> 'RoutePostsId'\n */\nfunction pathToVarName(path: string): string {\n  // v0.25: AST-verified — path-to-identifier transformation, regex is the appropriate tool\n  let name = path\n    .replace(/^\\//, '')\n    .replace(/\\/$/, '')\n    .replace(/:([^/]+)/g, '$1')\n    .replace(/[^a-zA-Z0-9]/g, '_');\n  if (!name || name === '_') name = 'Index';\n  return 'Route_' + name.charAt(0).toUpperCase() + name.slice(1);\n}\n\n/**\n * Identify special file types by name.\n * _renderer.ts -> renderer, _middleware.ts -> middleware\n */\n// ponytail: inline lookup replaces 2-case switch\nfunction getSpecialFileType(fileName: string): SpecialFileType | null {\n  const baseName = fileName.replace(/\\.[^.]+$/, '');\n  return ({ _renderer: 'renderer', _middleware: 'middleware' } as Record<string, SpecialFileType>)[\n    baseName\n  ] ?? null;\n}\n\n/**\n * Check if a file should be ignored for routing.\n * Dot-files are always ignored.\n */\nfunction isIgnoredFile(fileName: string): boolean {\n  return fileName.startsWith('.');\n}\n\n/**\n * Recursively scan a directory for route files.\n * Also collects _renderer.ts and _middleware.ts special files.\n */\nexport async function scanRoutes(\n  routesDir: string,\n  baseDir: string = '',\n): Promise<RouteEntry[]> {\n  const entries: RouteEntry[] = [];\n  const files = await safeReadDir(routesDir);\n\n  if (files === undefined) {\n    log.debug(`Routes directory \"${routesDir}\" not found`);\n    return entries;\n  }\n\n  for (const file of files) {\n    if (isIgnoredFile(file)) continue;\n\n    const fullPath = join(routesDir, file);\n    const relativePath = baseDir ? join(baseDir, file) : file;\n    const fileStat = await safeStat(fullPath);\n    if (!fileStat) {\n      log.debug(`File vanished before stat: ${fullPath}`);\n      continue;\n    }\n\n    if (fileStat.isDirectory()) {\n      // Recurse into subdirectories\n      const subEntries = await scanRoutes(fullPath, relativePath);\n      entries.push(...subEntries);\n    } else if (/\\.(ts|tsx|js|jsx)$/.test(file)) {\n      // Check for special files\n      const specialType = getSpecialFileType(file);\n      if (specialType) {\n        // Add as a special entry - not a route handler, but loadable\n        entries.push({\n          path: filePathToRoutePath(relativePath),\n          filePath: relativePath.split(sep).join(posix.sep),\n          type: 'special', // Not a page or API route - renderer/middleware only\n          varName: `Special_${specialType}_${baseDir.replace(/[\\\\/]/g, '_') || 'root'}`,\n          special: specialType,\n        });\n      } else if (!file.startsWith('_')) {\n        // Regular route file\n        const routePath = filePathToRoutePath(relativePath);\n        const routeType = getRouteType(relativePath);\n        // v0.25: AST-verified — path utility, extracts [param] patterns\n        const paramMatches = relativePath.match(/\\[([^\\]]+)\\]/g);\n        const params = paramMatches ? paramMatches.map((m) => m.slice(1, -1)) : undefined;\n        let tagName: string | undefined;\n        if (routeType === 'page') {\n          // Regex-based scanning reads `export const tagName` without executing the module.\n          tagName = await readRouteTagNameFromModule(fullPath);\n          if (tagName === undefined) {\n            // tagName not found is normal — not all page routes define one\n            log.debug(`No tagName export found in route module: ${fullPath}`);\n          }\n        }\n        entries.push({\n          path: routePath,\n          filePath: relativePath.split(sep).join(posix.sep),\n          type: routeType,\n          varName: pathToVarName(routePath),\n          tagName,\n          params,\n        });\n      }\n      // Other _-prefixed files (not _renderer/_middleware) are silently skipped\n    }\n  }\n\n  // Sort routes: static paths first, then dynamic\n  entries.sort((a, b) => {\n    // Special files go to the end\n    if (a.special || b.special) {\n      if (a.special && !b.special) return 1;\n      if (!a.special && b.special) return -1;\n      return 0;\n    }\n    const aDynamic = a.path.includes(':');\n    const bDynamic = b.path.includes(':');\n    if (aDynamic !== bDynamic) return aDynamic ? 1 : -1;\n    return a.path.localeCompare(b.path);\n  });\n\n  return entries;\n}\n\n/**\n * v0.25: AST-verified — converts file name to a valid Custom Element tag name.\n * Uses regex for path manipulation since tag names are derived from file paths.\n *\n * Examples:\n *   'my-counter.ts'        -> 'my-counter'\n *   'posts/index.ts'       -> 'posts-index'\n *   'admin\\\\dashboard.ts'  -> 'admin-dashboard'\n */\nexport function fileToTagName(fileName: string): string {\n  return fileName\n    .replace(/\\.[^.]+$/, '') // v0.25: AST-verified — remove extension\n    .replace(/[\\\\/]/g, '-') // v0.25: AST-verified — replace path separators with hyphens\n    .toLowerCase();\n}\n\n/**\n * Scan islands directory recursively for island files.\n * Returns paths relative to islandsDir (e.g., ['my-counter.ts', 'posts/index.ts']).\n */\nexport async function scanIslands(\n  islandsDir: string,\n  relativeDir: string = '',\n): Promise<string[]> {\n  const files: string[] = [];\n  const entries = await safeReadDir(islandsDir);\n\n  if (entries === undefined) {\n    log.debug(`Islands directory \"${islandsDir}\" not found`);\n    return files;\n  }\n\n  for (const entry of entries) {\n    if (entry.startsWith('.')) continue;\n\n    const fullPath = join(islandsDir, entry);\n    const fileStat = await safeStat(fullPath);\n    if (!fileStat) {\n      log.debug(`Island file vanished before stat: ${fullPath}`);\n      continue;\n    }\n\n    const relativePath = relativeDir ? join(relativeDir, entry) : entry;\n\n    if (fileStat.isDirectory()) {\n      const subFiles = await scanIslands(fullPath, relativePath);\n      files.push(...subFiles);\n    } else if (/\\.(ts|tsx|js|jsx)$/.test(entry)) {\n      files.push(relativePath);\n    }\n  }\n\n  return files.sort();\n}\n\n/**\n * v0.41.0-alpha.1: Regex-based — reads island metadata by statically scanning the module\n * source for `export const openElement = defineIslandConfig({ ... })`.\n *\n * Supported form:\n *   export const openElement = defineIslandConfig({ ssr: false, dsd: false, hydrate: 'only' })\n *\n * This is more reliable than regex because it handles:\n * - Comments inside the object literal\n * - Computed properties\n * - Destructured/re-exported values\n * - Canonical defineIslandConfig(...) calls\n *\n * If a module cannot be read, its metadata is silently skipped.\n */\nexport async function scanIslandMeta(\n  islandsDir: string,\n  islandFiles: string[],\n): Promise<Record<string, LocalIslandMeta>> {\n  const meta: Record<string, LocalIslandMeta> = {};\n\n  for (const filePath of islandFiles) {\n    const tagName = fileToTagName(filePath);\n    const fullPath = join(islandsDir, filePath);\n\n    const source = await safeReadFile(fullPath);\n    if (source === undefined) {\n      log.debug(`Unable to read island module for metadata: ${fullPath}`);\n      continue;\n    }\n\n    // Read the `openElement` export directly; no regex needed.\n    const openElementExport = readStaticOpenElementExport(source);\n    if (!openElementExport) continue;\n\n    const hydrate: LocalIslandMeta['hydrate'] = openElementExport.hydrate &&\n        ['load', 'idle', 'visible', 'only'].includes(openElementExport.hydrate)\n      ? openElementExport.hydrate\n      : undefined;\n\n    meta[tagName] = {\n      tagName,\n      filePath,\n      ssr: hydrate === 'only' ? false : openElementExport.ssr,\n      dsd: hydrate === 'only' ? false : openElementExport.dsd,\n      hydrate,\n      reason: hydrate === 'only'\n        ? 'local island exports openElement.hydrate=only'\n        : openElementExport.ssr === false\n        ? 'local island exports openElement.ssr=false'\n        : undefined,\n    };\n  }\n\n  return meta;\n}\n\n/**\n * Scan package exports for OpenElementPackageManifest.\n * Packages should export a `manifest` OpenElementPackageManifest in their main entry.\n *\n * Example package export:\n * ```ts\n * // @openelement/ui/index.ts\n * export { manifest } from './manifest.js';\n * ```\n *\n * @param packageNames - List of package names to scan (e.g., ['@openelement/ui'])\n * @returns Array of OpenElementPackageManifest\n */\nexport async function scanPackageManifests(\n  packageNames: string[],\n): Promise<OpenElementPackageManifest[]> {\n  const allManifests: OpenElementPackageManifest[] = [];\n\n  for (const pkg of packageNames) {\n    // @vite-ignore suppresses unanalyzable-dynamic-import JSR warning.\n    let mod: Record<string, unknown>;\n    try {\n      mod = await import(/* @vite-ignore */ pkg) as Record<string, unknown>;\n    } catch (e) {\n      if (isBrowserOnlyPackageImportError(e)) {\n        log.warn(\n          `Skipping package manifest from \"${pkg}\": browser-only package cannot be imported during SSR discovery`,\n        );\n        continue;\n      }\n      throw new OpenElementError(\n        `Failed to scan package manifest from \"${pkg}\": ${formatError(e)}`,\n        {\n          code: 'PACKAGE_SCAN_ERROR',\n          statusCode: 500,\n          recoverable: false,\n        },\n      );\n    }\n    if (mod.manifest && typeof mod.manifest === 'object') {\n      const manifest = mod.manifest as OpenElementPackageManifest;\n      if (manifest.packageName && manifest.declarations) {\n        allManifests.push(manifest);\n      } else {\n        throw new OpenElementError(\n          `Invalid manifest in ${pkg}: missing packageName or declarations`,\n          {\n            code: 'PACKAGE_MANIFEST_ERROR',\n            statusCode: 500,\n            recoverable: false,\n          },\n        );\n      }\n    } else {\n      throw new OpenElementError(\n        `Package ${pkg} does not export a manifest`,\n        {\n          code: 'PACKAGE_MANIFEST_ERROR',\n          statusCode: 500,\n          recoverable: false,\n        },\n      );\n    }\n  }\n\n  return allManifests;\n}\n\n/**\n * v0.25: AST-verified — error message classification, regex is the appropriate tool\n * for matching runtime error strings from failed dynamic imports.\n */\nfunction isBrowserOnlyPackageImportError(error: unknown): boolean {\n  const message = formatError(error);\n  return /\\b(window|document|HTMLElement|customElements|navigator)\\b.*\\bis not defined\\b/i.test(\n    message,\n  );\n}\n\n// ─── CEM Auto-Detection (v0.18.0) ─────────────────────────────────────────\n\n/** Result of scanning node_modules for CEM manifests */\nexport interface CemScanResult {\n  /** Package name (e.g. '@openelement/ui') */\n  packageName: string;\n  /** Absolute path to custom-elements.json */\n  cemPath: string;\n  /** Raw JSON content */\n  json: string;\n}\n\n/**\n * Scan node_modules for packages that ship a `custom-elements.json`.\n *\n * Strategy:\n *   1. Read node_modules directory entries (top-level packages + scoped orgs)\n *   2. For each package, check if `<pkg>/custom-elements.json` exists\n *   3. Return the raw JSON - caller is responsible for parsing + classifying\n *\n * This function reads files only. It never imports or executes package code.\n *\n * @param nodeModulesDir - Absolute path to the node_modules directory\n * @returns Array of found CEM manifests\n */\nexport async function scanCemManifests(\n  nodeModulesDir: string,\n): Promise<CemScanResult[]> {\n  const results: CemScanResult[] = [];\n\n  const entries = await safeReadDir(nodeModulesDir);\n  if (!entries) return results;\n\n  for (const entry of entries) {\n    if (entry.startsWith('.')) continue;\n\n    if (entry.startsWith('@')) {\n      // Scoped package directory - recurse one level\n      const scopeDir = join(nodeModulesDir, entry);\n      const scopedEntries = await safeReadDir(scopeDir);\n      if (!scopedEntries) continue;\n      for (const scopedEntry of scopedEntries) {\n        if (scopedEntry.startsWith('.')) continue;\n        const packageName = `${entry}/${scopedEntry}`;\n        const cemPath = join(nodeModulesDir, entry, scopedEntry, 'custom-elements.json');\n        const result = await tryReadCemFile(cemPath, packageName);\n        if (result) results.push(result);\n      }\n    } else {\n      // Regular (non-scoped) package\n      const cemPath = join(nodeModulesDir, entry, 'custom-elements.json');\n      const result = await tryReadCemFile(cemPath, entry);\n      if (result) results.push(result);\n    }\n  }\n\n  return results;\n}\n\n/**\n * Try to read a custom-elements.json file.\n * Returns null if the file doesn't exist or can't be read.\n */\nasync function tryReadCemFile(\n  cemPath: string,\n  packageName: string,\n): Promise<CemScanResult | null> {\n  const json = await safeReadFile(cemPath);\n  return json === undefined ? null : { packageName, cemPath, json };\n}\n\n/**\n * Run CEM auto-detection: scan node_modules, parse each manifest,\n * and classify all discovered components.\n *\n * This is the high-level function called from the Vite plugin buildStart().\n * It combines scanCemManifests() + parseCem() + classifyCemManifest()\n * into a single pipeline.\n *\n * @param nodeModulesDir - Absolute path to node_modules\n * @returns Array of compatibility classifications (may be empty if no CEM found)\n */\nexport async function detectAndClassifyCemPackages(\n  nodeModulesDir: string,\n): Promise<CompatibilityClassification[]> {\n  const cemResults = await scanCemManifests(nodeModulesDir);\n  if (cemResults.length === 0) return [];\n\n  const allClassifications: CompatibilityClassification[] = [];\n\n  for (const { packageName, json } of cemResults) {\n    const parseResult = parseCem(json);\n    if (!parseResult.success || !parseResult.manifest) {\n      log.debug(\n        `Skipping invalid CEM manifest from \"${packageName}\": ` +\n          parseResult.errors.map((e) => e.message).join('; '),\n      );\n      continue;\n    }\n\n    // Attach package name to the manifest for better diagnostics\n    const manifest = { ...parseResult.manifest, packageName };\n    const classResult = classifyCemManifest(manifest);\n\n    // Log summary\n    const { stats } = classResult;\n    if (stats.totalComponents > 0) {\n      log.info(\n        `CEM: ${packageName} - ${stats.totalComponents} component(s): ` +\n          `${stats.ssrCapableCount} ssr-capable, ${stats.clientOnlyCount} client-only` +\n          (stats.rejectedCount > 0 ? `, ${stats.rejectedCount} rejected` : '') +\n          (stats.experimentalDomCount > 0 ? `, ${stats.experimentalDomCount} experimental` : ''),\n      );\n    }\n\n    allClassifications.push(...classResult.classifications);\n  }\n\n  return allClassifications;\n}\n"],"names":[],"mappings":"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"}

package/src/route-type-generator.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @openelement/adapter-vite - Route Type Generator
+ *
+ * Generates `.openElement/routes.d.ts` with type-safe route parameter definitions
+ * for the `virtual:open-routes` module. Only routes that have dynamic [param]
+ * segments are included in the output.
+ *
+ * v0.25.0: Initial implementation for build-time route type code generation.
+ */ import type { RouteEntry } from '@openelement/protocol/framework';
+/**
+ * Generate the `.openElement/routes.d.ts` declaration file content.
+ *
+ * Only routes that have dynamic parameters (non-empty `params` array)
+ * are included in the generated output. Static routes with no params
+ * are excluded since they don't need type-safe parameter access.
+ *
+ * Example output:
+ * ```typescript
+ * declare module 'virtual:open-routes' {
+ *   interface RouteParams {
+ *     '/blog/[slug]': { slug: string };
+ *     '/registry/[package]/[component]': { package: string; component: string };
+ *   }
+ * }
+ * ```
+ *
+ * @param routes - Array of route entries from the route scanner
+ * @returns TypeScript declaration file content as a string
+ */ export declare function generateRouteTypes(routes: RouteEntry[]): string;