@openelement/adapter-vite 0.41.0-alpha.1

package/src/build-manifest.js

@@ -0,0 +1,198 @@
+/**
+ * @openelement/adapter-vite - Build Manifest / Observability
+ *
+ * Scans build output directories after each phase and prints a structured
+ * summary table. This gives developers visibility into:
+ *   - Per-island chunk sizes (Phase 2)
+ *   - Total JS/CSS bundle budgets (Phase 3)
+ *   - HTML page counts and compression potential
+ *   - headExtras injection size
+ *
+ * Output format: Fixed-width table via console.info (no external dependency).
+ *
+ * Called by:
+ *   - cli/build-client.ts (after Phase 2: client chunks ready)
+ *   - cli/build-ssg.ts    (after Phase 3: HTML + post-process complete)
+ */ import { join, resolve } from 'node:path';
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { createLogger } from '@openelement/core/logger';
+const log = createLogger('ssg');
+/**
+ * Format bytes to human-readable string.
+ */ function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 10) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+/**
+ * Recursively collect all matching files with their sizes.
+ */ function collectFiles(dir, extension, basePath = '') {
+  const results = [];
+  if (!existsSync(dir)) return results;
+  const entries = readdirSync(dir, {
+    withFileTypes: true
+  });
+  for (const entry of entries){
+    const fullPath = join(dir, entry.name);
+    const relPath = basePath ? `${basePath}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      results.push(...collectFiles(fullPath, extension, relPath));
+    } else if (entry.name.endsWith(extension)) {
+      try {
+        const stat = statSync(fullPath);
+        results.push({
+          name: entry.name,
+          path: relPath,
+          sizeBytes: stat.size,
+          sizeKB: formatSize(stat.size)
+        });
+      } catch (e) {
+        log.warn(`Cannot stat ${relPath}: ${e.message}`);
+      }
+    }
+  }
+  return results;
+}
+/**
+ * Scan client build output (dist/client/) for island chunks.
+ */ export function scanClientBuild(root, outDir = 'dist') {
+  const clientDir = resolve(root, outDir, 'client');
+  const islands = [];
+  let clientEntry = null;
+  let totalJsBytes = 0;
+  // Scan islands/ subdirectory (single pass - avoid redundant directory scans)
+  const islandsDir = join(clientDir, 'islands');
+  if (existsSync(islandsDir)) {
+    const files = readdirSync(islandsDir);
+    for (const file of files){
+      if (!file.endsWith('.js')) continue;
+      const fullPath = join(islandsDir, file);
+      try {
+        const fileStat = statSync(fullPath);
+        if (file === 'client.js') {
+          // Client entry (shared island upgrade runtime)
+          clientEntry = {
+            name: 'client.js',
+            path: 'islands/client.js',
+            sizeBytes: fileStat.size,
+            sizeKB: formatSize(fileStat.size)
+          };
+        } else {
+          // Island chunk or shared chunk
+          const _isIslandChunk = /^island-(.+?)-[A-Za-z0-9]+\.js$/.test(file);
+          islands.push({
+            name: file,
+            path: `islands/${file}`,
+            sizeBytes: fileStat.size,
+            sizeKB: formatSize(fileStat.size)
+          });
+        }
+        totalJsBytes += fileStat.size;
+      } catch (e) {
+        log.warn(`Cannot stat ${file}: ${e.message}`);
+      }
+    }
+  }
+  return {
+    islands,
+    clientEntry,
+    totalJsBytes
+  };
+}
+/**
+ * Scan SSG output (dist/*.html) for page information.
+ */ export function scanSSGOutput(root, outDir = 'dist') {
+  const distDir = resolve(root, outDir);
+  return collectFiles(distDir, '.html');
+}
+/**
+ * Print a formatted build manifest table to console.
+ *
+ * This is called at the end of each build phase to provide observability
+ * into what was produced and how large everything is.
+ */ export function printBuildManifest(options) {
+  const { root, outDir = 'dist', phase, headExtras = '' } = options;
+  const timestamp = new Date().toISOString();
+  // Gather data
+  const clientData = scanClientBuild(root, outDir);
+  const htmlPages = phase === 3 ? scanSSGOutput(root, outDir) : [];
+  const headExtrasSize = new TextEncoder().encode(headExtras).length;
+  // Budget thresholds
+  const ISLAND_BUDGET_KB = 50; // Warn if single island > 50KB
+  const TOTAL_JS_BUDGET_KB = 200; // Warn if total JS > 200KB
+  const PAGE_BUDGET_KB = 200; // Advisory only: single uncompressed HTML page budget.
+  const warnings = [];
+  // Check island budgets
+  for (const island of clientData.islands){
+    if (island.sizeBytes > ISLAND_BUDGET_KB * 1024) {
+      warnings.push(`Warning: ${island.name} (${island.sizeKB}) exceeds ${ISLAND_BUDGET_KB} KB budget`);
+    }
+  }
+  // Check total JS budget
+  if (clientData.totalJsBytes > TOTAL_JS_BUDGET_KB * 1024) {
+    warnings.push(`Warning: Total JS (${formatSize(clientData.totalJsBytes)}) exceeds ${TOTAL_JS_BUDGET_KB} KB budget`);
+  }
+  // Check page sizes
+  for (const page of htmlPages){
+    if (page.sizeBytes > PAGE_BUDGET_KB * 1024) {
+      warnings.push(`Warning: ${page.path} (${page.sizeKB}) exceeds advisory ${PAGE_BUDGET_KB} KB HTML budget - consider compression`);
+    }
+  }
+  const manifest = {
+    phase,
+    timestamp,
+    islands: clientData.islands,
+    clientEntry: clientData.clientEntry,
+    htmlPages,
+    totalJsBytes: clientData.totalJsBytes,
+    totalHtmlBytes: htmlPages.reduce((sum, p)=>sum + p.sizeBytes, 0),
+    headExtrasSize,
+    warnings
+  };
+  // Print table using ASCII-only output so build logs remain portable.
+  console.info('');
+  console.info(`== openElement Build Manifest - Phase ${phase} @ ${timestamp.slice(11, 19)} ==`);
+  if (manifest.islands.length > 0 || manifest.clientEntry) {
+    console.info('\n  Client Islands:');
+    console.info('  File                         Size');
+    console.info('  --------------------------   --------');
+    for (const island of manifest.islands){
+      const displayName = island.name.length > 30 ? island.name.slice(0, 27) + '...' : island.name;
+      console.info(`  ${displayName.padEnd(26)}   ${island.sizeKB.padEnd(8)}`);
+    }
+    if (manifest.clientEntry) {
+      console.info(`  ${'client.js (entry)'.padEnd(26)}   ${manifest.clientEntry.sizeKB.padEnd(8)}`);
+    }
+    console.info('  --------------------------   --------');
+    console.info(`  ${'TOTAL JS'.padEnd(26)}   ${formatSize(manifest.totalJsBytes).padEnd(8)}`);
+  } else {
+    console.info('\n  Client Islands: none - zero client JS');
+  }
+  if (phase === 3 && manifest.htmlPages.length > 0) {
+    console.info(`\n  HTML Pages (${manifest.htmlPages.length} files, ${formatSize(manifest.totalHtmlBytes)} total):`);
+    const maxShow = 15;
+    const shown = manifest.htmlPages.slice(0, maxShow);
+    for (const page of shown){
+      const displayName = page.path.length > 40 ? page.path.slice(0, 37) + '...' : page.path;
+      console.info(`    - ${displayName} (${page.sizeKB})`);
+    }
+    if (manifest.htmlPages.length > maxShow) {
+      console.info(`    ... +${manifest.htmlPages.length - maxShow} more pages`);
+    }
+  }
+  if (manifest.headExtrasSize > 0) {
+    console.info(`\n  headExtras: ${formatSize(manifest.headExtrasSize)} (${manifest.headExtrasSize} bytes injected)`);
+  }
+  if (warnings.length > 0) {
+    console.info('\n  Budget Warnings:');
+    for (const w of warnings){
+      console.info(`     ${w}`);
+    }
+  } else {
+    console.info('\n  All artifacts within budget limits');
+  }
+  console.info('');
+  return manifest;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/adapter-vite/src/build-manifest.ts"],"sourcesContent":["/**\n * @openelement/adapter-vite - Build Manifest / Observability\n *\n * Scans build output directories after each phase and prints a structured\n * summary table. This gives developers visibility into:\n *   - Per-island chunk sizes (Phase 2)\n *   - Total JS/CSS bundle budgets (Phase 3)\n *   - HTML page counts and compression potential\n *   - headExtras injection size\n *\n * Output format: Fixed-width table via console.info (no external dependency).\n *\n * Called by:\n *   - cli/build-client.ts (after Phase 2: client chunks ready)\n *   - cli/build-ssg.ts    (after Phase 3: HTML + post-process complete)\n */\n\nimport { join, resolve } from 'node:path';\nimport { existsSync, readdirSync, statSync } from 'node:fs';\nimport { createLogger } from '@openelement/core/logger';\n\nconst log = createLogger('ssg');\n\n/** File size info for a single artifact */\nexport interface ArtifactInfo {\n  name: string;\n  path: string;\n  sizeBytes: number;\n  sizeKB: string;\n}\n\n/** Full build manifest summary */\nexport interface BuildManifest {\n  phase: 1 | 2 | 3;\n  timestamp: string;\n  islands: ArtifactInfo[];\n  clientEntry: ArtifactInfo | null;\n  htmlPages: ArtifactInfo[];\n  totalJsBytes: number;\n  totalHtmlBytes: number;\n  headExtrasSize: number;\n  /** Budget warnings (files > threshold) */\n  warnings: string[];\n}\n\n/**\n * Format bytes to human-readable string.\n */\nfunction formatSize(bytes: number): string {\n  if (bytes < 1024) return `${bytes} B`;\n  if (bytes < 1024 * 10) return `${(bytes / 1024).toFixed(1)} KB`;\n  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`;\n  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;\n}\n\n/**\n * Recursively collect all matching files with their sizes.\n */\nfunction collectFiles(\n  dir: string,\n  extension: string,\n  basePath = '',\n): ArtifactInfo[] {\n  const results: ArtifactInfo[] = [];\n  if (!existsSync(dir)) return results;\n\n  const entries = readdirSync(dir, { withFileTypes: true });\n  for (const entry of entries) {\n    const fullPath = join(dir, entry.name);\n    const relPath = basePath ? `${basePath}/${entry.name}` : entry.name;\n    if (entry.isDirectory()) {\n      results.push(...collectFiles(fullPath, extension, relPath));\n    } else if (entry.name.endsWith(extension)) {\n      try {\n        const stat = statSync(fullPath);\n        results.push({\n          name: entry.name,\n          path: relPath,\n          sizeBytes: stat.size,\n          sizeKB: formatSize(stat.size),\n        });\n      } catch (e) {\n        log.warn(`Cannot stat ${relPath}: ${(e as Error).message}`);\n      }\n    }\n  }\n  return results;\n}\n\n/**\n * Scan client build output (dist/client/) for island chunks.\n */\nexport function scanClientBuild(\n  root: string,\n  outDir: string = 'dist',\n): { islands: ArtifactInfo[]; clientEntry: ArtifactInfo | null; totalJsBytes: number } {\n  const clientDir = resolve(root, outDir, 'client');\n  const islands: ArtifactInfo[] = [];\n  let clientEntry: ArtifactInfo | null = null;\n  let totalJsBytes = 0;\n\n  // Scan islands/ subdirectory (single pass - avoid redundant directory scans)\n  const islandsDir = join(clientDir, 'islands');\n  if (existsSync(islandsDir)) {\n    const files = readdirSync(islandsDir);\n    for (const file of files) {\n      if (!file.endsWith('.js')) continue;\n      const fullPath = join(islandsDir, file);\n      try {\n        const fileStat = statSync(fullPath);\n        if (file === 'client.js') {\n          // Client entry (shared island upgrade runtime)\n          clientEntry = {\n            name: 'client.js',\n            path: 'islands/client.js',\n            sizeBytes: fileStat.size,\n            sizeKB: formatSize(fileStat.size),\n          };\n        } else {\n          // Island chunk or shared chunk\n          const _isIslandChunk = /^island-(.+?)-[A-Za-z0-9]+\\.js$/.test(file);\n          islands.push({\n            name: file,\n            path: `islands/${file}`,\n            sizeBytes: fileStat.size,\n            sizeKB: formatSize(fileStat.size),\n          });\n        }\n        totalJsBytes += fileStat.size;\n      } catch (e) {\n        log.warn(`Cannot stat ${file}: ${(e as Error).message}`);\n      }\n    }\n  }\n\n  return { islands, clientEntry, totalJsBytes };\n}\n\n/**\n * Scan SSG output (dist/*.html) for page information.\n */\nexport function scanSSGOutput(\n  root: string,\n  outDir: string = 'dist',\n): ArtifactInfo[] {\n  const distDir = resolve(root, outDir);\n  return collectFiles(distDir, '.html');\n}\n\n/**\n * Print a formatted build manifest table to console.\n *\n * This is called at the end of each build phase to provide observability\n * into what was produced and how large everything is.\n */\nexport function printBuildManifest(options: {\n  root: string;\n  outDir?: string;\n  phase: 2 | 3;\n  headExtras?: string;\n}): BuildManifest {\n  const { root, outDir = 'dist', phase, headExtras = '' } = options;\n  const timestamp = new Date().toISOString();\n\n  // Gather data\n  const clientData = scanClientBuild(root, outDir);\n  const htmlPages = phase === 3 ? scanSSGOutput(root, outDir) : [];\n  const headExtrasSize = new TextEncoder().encode(headExtras).length;\n\n  // Budget thresholds\n  const ISLAND_BUDGET_KB = 50; // Warn if single island > 50KB\n  const TOTAL_JS_BUDGET_KB = 200; // Warn if total JS > 200KB\n  const PAGE_BUDGET_KB = 200; // Advisory only: single uncompressed HTML page budget.\n\n  const warnings: string[] = [];\n\n  // Check island budgets\n  for (const island of clientData.islands) {\n    if (island.sizeBytes > ISLAND_BUDGET_KB * 1024) {\n      warnings.push(\n        `Warning: ${island.name} (${island.sizeKB}) exceeds ${ISLAND_BUDGET_KB} KB budget`,\n      );\n    }\n  }\n\n  // Check total JS budget\n  if (clientData.totalJsBytes > TOTAL_JS_BUDGET_KB * 1024) {\n    warnings.push(\n      `Warning: Total JS (${\n        formatSize(clientData.totalJsBytes)\n      }) exceeds ${TOTAL_JS_BUDGET_KB} KB budget`,\n    );\n  }\n\n  // Check page sizes\n  for (const page of htmlPages) {\n    if (page.sizeBytes > PAGE_BUDGET_KB * 1024) {\n      warnings.push(\n        `Warning: ${page.path} (${page.sizeKB}) exceeds advisory ${PAGE_BUDGET_KB} KB HTML budget - consider compression`,\n      );\n    }\n  }\n\n  const manifest: BuildManifest = {\n    phase,\n    timestamp,\n    islands: clientData.islands,\n    clientEntry: clientData.clientEntry,\n    htmlPages,\n    totalJsBytes: clientData.totalJsBytes,\n    totalHtmlBytes: htmlPages.reduce((sum, p) => sum + p.sizeBytes, 0),\n    headExtrasSize,\n    warnings,\n  };\n\n  // Print table using ASCII-only output so build logs remain portable.\n  console.info('');\n  console.info(`== openElement Build Manifest - Phase ${phase} @ ${timestamp.slice(11, 19)} ==`);\n\n  if (manifest.islands.length > 0 || manifest.clientEntry) {\n    console.info('\\n  Client Islands:');\n    console.info('  File                         Size');\n    console.info('  --------------------------   --------');\n\n    for (const island of manifest.islands) {\n      const displayName = island.name.length > 30 ? island.name.slice(0, 27) + '...' : island.name;\n      console.info(`  ${displayName.padEnd(26)}   ${island.sizeKB.padEnd(8)}`);\n    }\n\n    if (manifest.clientEntry) {\n      console.info(\n        `  ${'client.js (entry)'.padEnd(26)}   ${manifest.clientEntry.sizeKB.padEnd(8)}`,\n      );\n    }\n\n    console.info('  --------------------------   --------');\n    console.info(`  ${'TOTAL JS'.padEnd(26)}   ${formatSize(manifest.totalJsBytes).padEnd(8)}`);\n  } else {\n    console.info('\\n  Client Islands: none - zero client JS');\n  }\n\n  if (phase === 3 && manifest.htmlPages.length > 0) {\n    console.info(\n      `\\n  HTML Pages (${manifest.htmlPages.length} files, ${\n        formatSize(manifest.totalHtmlBytes)\n      } total):`,\n    );\n\n    const maxShow = 15;\n    const shown = manifest.htmlPages.slice(0, maxShow);\n    for (const page of shown) {\n      const displayName = page.path.length > 40 ? page.path.slice(0, 37) + '...' : page.path;\n      console.info(`    - ${displayName} (${page.sizeKB})`);\n    }\n    if (manifest.htmlPages.length > maxShow) {\n      console.info(`    ... +${manifest.htmlPages.length - maxShow} more pages`);\n    }\n  }\n\n  if (manifest.headExtrasSize > 0) {\n    console.info(\n      `\\n  headExtras: ${\n        formatSize(manifest.headExtrasSize)\n      } (${manifest.headExtrasSize} bytes injected)`,\n    );\n  }\n\n  if (warnings.length > 0) {\n    console.info('\\n  Budget Warnings:');\n    for (const w of warnings) {\n      console.info(`     ${w}`);\n    }\n  } else {\n    console.info('\\n  All artifacts within budget limits');\n  }\n\n  console.info('');\n\n  return manifest;\n}\n"],"names":[],"mappings":"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"}

package/src/build.js

@@ -0,0 +1,97 @@
+/**
+ * @openelement/adapter-vite - Build plugin
+ * openElement Architecture (K·I·S·S): Knowledge · Isolated · Semantic · Static
+ * Build produces only static files (K+S), Islands are the only JS (I).
+ * API Routes (S - Serverless extension) deploy separately.
+ *
+ * ADR 0011: closeBundle writes metadata to ctx, then triggers Phase 2/3.
+ * No globalThis bridge - ctx stays in createOpenPlugin() closure scope throughout.
+ */ import { join } from 'node:path';
+import process from 'node:process';
+import { createLogger } from '@openelement/core/logger';
+import { cleanSsrArtifacts, postProcessClientIslandBuild } from '@openelement/ssg';
+const log = createLogger('core');
+/** Vite plugin: writes build metadata to ctx, then runs Phase 2 + Phase 3 */ export function buildPlugin(options = {}, ctx) {
+  let config;
+  return {
+    name: 'open:build',
+    configResolved (resolvedConfig) {
+      config = resolvedConfig;
+    },
+    async closeBundle () {
+      // Only run in build mode (not dev)
+      if (config.command !== 'build') return;
+      if (!ctx) {
+        log.warn('open:build skipped Phase 2/3 because no OpenElementBuildContext was provided.');
+        return;
+      }
+      // Serialize SSR noExternal patterns (RegExp -> marker objects)
+      const ssrNoExternal = (options.ssr?.noExternal || config.ssr?.noExternal || []).map((item)=>{
+        if (item instanceof RegExp) {
+          return {
+            __type: 'RegExp',
+            source: item.source,
+            flags: item.flags
+          };
+        }
+        return item;
+      });
+      // --- Write to OpenElementBuildContext ----------
+      ctx.populatePhase3(options, config, ssrNoExternal);
+      const totalIslands = (ctx.phase1.islandTagNames?.length || 0) + (ctx.phase1.packageIslandDecls?.length || 0);
+      log.info('Phase 1/3 complete - SSR bundle + metadata written to ctx');
+      // ADR 0023: Phase 3 (SSG) runs before Phase 2 (client bundle).
+      // SSG only needs Phase 1 - it renders HTML from the SSR bundle.
+      // Phase 2 runs last because client chunks have content hashes that
+      // don't affect HTML content, and injection is a post-processing step.
+      ctx.completePhase1();
+      await ctx.runPhase3(async ()=>{
+        const { buildSSG } = await import('./cli/build-ssg.js');
+        await buildSSG({}, ctx);
+      });
+      // Phase 2: Client island bundle (only if islands exist)
+      if (totalIslands > 0) {
+        await ctx.runPhase2(async ()=>{
+          const { buildClient } = await import('./cli/build-client.js');
+          await buildClient(ctx);
+        });
+      }
+      // -- Inject client script (only runs if Phase 2 completed) --
+      // Phase 2's manifest.json tells us the client chunk URLs to inject
+      // into the already-rendered HTML pages.
+      if (ctx.isPhaseComplete(2)) {
+        try {
+          const outDir = ctx.phase3.outDir || 'dist';
+          const root = ctx.phase3.root || process.cwd();
+          const clientManifestPath = join(root, outDir, 'client', '.vite', 'manifest.json');
+          const { existsSync, readFileSync } = await import('node:fs');
+          if (existsSync(clientManifestPath)) {
+            const manifestRaw = readFileSync(clientManifestPath, 'utf-8');
+            const manifest = JSON.parse(manifestRaw);
+            for (const [src, entry] of Object.entries(manifest)){
+              if ((src.includes('open-client-entry') || src.includes('virtual:open-client')) && entry.file) {
+                const base = ctx.phase3.base || '/';
+                const scriptSrc = `${base}client/${entry.file}`;
+                await postProcessClientIslandBuild(ctx, scriptSrc);
+                log.info(`Client script injected: ${scriptSrc}`);
+                break;
+              }
+            }
+          }
+        } catch (error) {
+          log.warn(`Failed to inject client script: ${error}`);
+        }
+      } else {
+        log.info('No Phase 2 - client script injection skipped');
+      }
+      // -- Clean Phase 1 SSR artifacts from public dist (v0.14.10) --
+      try {
+        await cleanSsrArtifacts(ctx);
+      } catch (error) {
+        log.warn(`Failed to clean SSR artifacts: ${error}`);
+      }
+      log.info('Build complete.');
+    }
+  };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/adapter-vite/src/build.ts"],"sourcesContent":["/**\n * @openelement/adapter-vite - Build plugin\n * openElement Architecture (K·I·S·S): Knowledge · Isolated · Semantic · Static\n * Build produces only static files (K+S), Islands are the only JS (I).\n * API Routes (S - Serverless extension) deploy separately.\n *\n * ADR 0011: closeBundle writes metadata to ctx, then triggers Phase 2/3.\n * No globalThis bridge - ctx stays in createOpenPlugin() closure scope throughout.\n */\n\nimport type { Plugin, ResolvedConfig } from 'vite';\nimport type { FrameworkOptions } from '@openelement/protocol/framework';\nimport type { OpenElementBuildContext } from './build-context.js';\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport { createLogger } from '@openelement/core/logger';\nimport { cleanSsrArtifacts, postProcessClientIslandBuild } from '@openelement/ssg';\n\nconst log = createLogger('core');\n\n/** Vite plugin: writes build metadata to ctx, then runs Phase 2 + Phase 3 */\nexport function buildPlugin(\n  options: FrameworkOptions & { allowHeadExtrasScripts?: boolean } = {},\n  ctx?: OpenElementBuildContext,\n): Plugin {\n  let config: ResolvedConfig;\n\n  return {\n    name: 'open:build',\n\n    configResolved(resolvedConfig) {\n      config = resolvedConfig;\n    },\n\n    async closeBundle() {\n      // Only run in build mode (not dev)\n      if (config.command !== 'build') return;\n\n      if (!ctx) {\n        log.warn('open:build skipped Phase 2/3 because no OpenElementBuildContext was provided.');\n        return;\n      }\n\n      // Serialize SSR noExternal patterns (RegExp -> marker objects)\n      const ssrNoExternal = ((options.ssr?.noExternal ||\n        (config.ssr as { noExternal?: (string | RegExp)[] } | undefined)?.noExternal) || [])\n        .map((item) => {\n          if (item instanceof RegExp) {\n            return { __type: 'RegExp', source: item.source, flags: item.flags };\n          }\n          return item;\n        });\n\n      // --- Write to OpenElementBuildContext ----------\n      ctx.populatePhase3(\n        options,\n        config,\n        ssrNoExternal as (string | { __type: 'RegExp'; source: string; flags: string })[],\n      );\n\n      const totalIslands = (ctx.phase1.islandTagNames?.length || 0) +\n        (ctx.phase1.packageIslandDecls?.length || 0);\n\n      log.info('Phase 1/3 complete - SSR bundle + metadata written to ctx');\n\n      // ADR 0023: Phase 3 (SSG) runs before Phase 2 (client bundle).\n      // SSG only needs Phase 1 - it renders HTML from the SSR bundle.\n      // Phase 2 runs last because client chunks have content hashes that\n      // don't affect HTML content, and injection is a post-processing step.\n      ctx.completePhase1();\n\n      await ctx.runPhase3(async () => {\n        const { buildSSG } = await import('./cli/build-ssg.js');\n        await buildSSG({}, ctx);\n      });\n\n      // Phase 2: Client island bundle (only if islands exist)\n      if (totalIslands > 0) {\n        await ctx.runPhase2(async () => {\n          const { buildClient } = await import('./cli/build-client.js');\n          await buildClient(ctx);\n        });\n      }\n\n      // -- Inject client script (only runs if Phase 2 completed) --\n      // Phase 2's manifest.json tells us the client chunk URLs to inject\n      // into the already-rendered HTML pages.\n      if (ctx.isPhaseComplete(2)) {\n        try {\n          const outDir = ctx.phase3.outDir || 'dist';\n          const root = ctx.phase3.root || process.cwd();\n          const clientManifestPath = join(root, outDir, 'client', '.vite', 'manifest.json');\n          const { existsSync, readFileSync } = await import('node:fs');\n          if (existsSync(clientManifestPath)) {\n            const manifestRaw = readFileSync(clientManifestPath, 'utf-8');\n            const manifest = JSON.parse(manifestRaw);\n            for (const [src, entry] of Object.entries(manifest) as [string, { file?: string }][]) {\n              if (\n                (src.includes('open-client-entry') || src.includes('virtual:open-client')) &&\n                entry.file\n              ) {\n                const base = ctx.phase3.base || '/';\n                const scriptSrc = `${base}client/${entry.file}`;\n                await postProcessClientIslandBuild(ctx, scriptSrc);\n                log.info(`Client script injected: ${scriptSrc}`);\n                break;\n              }\n            }\n          }\n        } catch (error) {\n          log.warn(`Failed to inject client script: ${error}`);\n        }\n      } else {\n        log.info('No Phase 2 - client script injection skipped');\n      }\n\n      // -- Clean Phase 1 SSR artifacts from public dist (v0.14.10) --\n      try {\n        await cleanSsrArtifacts(ctx);\n      } catch (error) {\n        log.warn(`Failed to clean SSR artifacts: ${error}`);\n      }\n\n      log.info('Build complete.');\n    },\n  };\n}\n"],"names":[],"mappings":"AAAA;;;;;;;;CAQC,GAKD,SAAS,IAAI,QAAQ,YAAY;AACjC,OAAO,aAAa,eAAe;AACnC,SAAS,YAAY,QAAQ,2BAA2B;AACxD,SAAS,iBAAiB,EAAE,4BAA4B,QAAQ,mBAAmB;AAEnF,MAAM,MAAM,aAAa;AAEzB,2EAA2E,GAC3E,OAAO,SAAS,YACd,UAAmE,CAAC,CAAC,EACrE,GAA6B;EAE7B,IAAI;EAEJ,OAAO;IACL,MAAM;IAEN,gBAAe,cAAc;MAC3B,SAAS;IACX;IAEA,MAAM;MACJ,mCAAmC;MACnC,IAAI,OAAO,OAAO,KAAK,SAAS;MAEhC,IAAI,CAAC,KAAK;QACR,IAAI,IAAI,CAAC;QACT;MACF;MAEA,+DAA+D;MAC/D,MAAM,gBAAgB,CAAC,AAAC,QAAQ,GAAG,EAAE,cAClC,OAAO,GAAG,EAAuD,cAAe,EAAE,EAClF,GAAG,CAAC,CAAC;QACJ,IAAI,gBAAgB,QAAQ;UAC1B,OAAO;YAAE,QAAQ;YAAU,QAAQ,KAAK,MAAM;YAAE,OAAO,KAAK,KAAK;UAAC;QACpE;QACA,OAAO;MACT;MAEF,kDAAkD;MAClD,IAAI,cAAc,CAChB,SACA,QACA;MAGF,MAAM,eAAe,CAAC,IAAI,MAAM,CAAC,cAAc,EAAE,UAAU,CAAC,IAC1D,CAAC,IAAI,MAAM,CAAC,kBAAkB,EAAE,UAAU,CAAC;MAE7C,IAAI,IAAI,CAAC;MAET,+DAA+D;MAC/D,gEAAgE;MAChE,mEAAmE;MACnE,sEAAsE;MACtE,IAAI,cAAc;MAElB,MAAM,IAAI,SAAS,CAAC;QAClB,MAAM,EAAE,QAAQ,EAAE,GAAG,MAAM,MAAM,CAAC;QAClC,MAAM,SAAS,CAAC,GAAG;MACrB;MAEA,wDAAwD;MACxD,IAAI,eAAe,GAAG;QACpB,MAAM,IAAI,SAAS,CAAC;UAClB,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,MAAM,CAAC;UACrC,MAAM,YAAY;QACpB;MACF;MAEA,8DAA8D;MAC9D,mEAAmE;MACnE,wCAAwC;MACxC,IAAI,IAAI,eAAe,CAAC,IAAI;QAC1B,IAAI;UACF,MAAM,SAAS,IAAI,MAAM,CAAC,MAAM,IAAI;UACpC,MAAM,OAAO,IAAI,MAAM,CAAC,IAAI,IAAI,QAAQ,GAAG;UAC3C,MAAM,qBAAqB,KAAK,MAAM,QAAQ,UAAU,SAAS;UACjE,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,GAAG,MAAM,MAAM,CAAC;UAClD,IAAI,WAAW,qBAAqB;YAClC,MAAM,cAAc,aAAa,oBAAoB;YACrD,MAAM,WAAW,KAAK,KAAK,CAAC;YAC5B,KAAK,MAAM,CAAC,KAAK,MAAM,IAAI,OAAO,OAAO,CAAC,UAA4C;cACpF,IACE,CAAC,IAAI,QAAQ,CAAC,wBAAwB,IAAI,QAAQ,CAAC,sBAAsB,KACzE,MAAM,IAAI,EACV;gBACA,MAAM,OAAO,IAAI,MAAM,CAAC,IAAI,IAAI;gBAChC,MAAM,YAAY,GAAG,KAAK,OAAO,EAAE,MAAM,IAAI,EAAE;gBAC/C,MAAM,6BAA6B,KAAK;gBACxC,IAAI,IAAI,CAAC,CAAC,wBAAwB,EAAE,WAAW;gBAC/C;cACF;YACF;UACF;QACF,EAAE,OAAO,OAAO;UACd,IAAI,IAAI,CAAC,CAAC,gCAAgC,EAAE,OAAO;QACrD;MACF,OAAO;QACL,IAAI,IAAI,CAAC;MACX;MAEA,gEAAgE;MAChE,IAAI;QACF,MAAM,kBAAkB;MAC1B,EAAE,OAAO,OAAO;QACd,IAAI,IAAI,CAAC,CAAC,+BAA+B,EAAE,OAAO;MACpD;MAEA,IAAI,IAAI,CAAC;IACX;EACF;AACF"}

package/src/cli/build-client.d.ts

@@ -0,0 +1,3 @@
+import type { OpenElementBuildContext } from "../build-context.js";
+declare function buildClient(ctx: OpenElementBuildContext): Promise<void>;
+export { buildClient };