@openelement/adapter-vite 0.41.0-alpha.1

package/src/cli/build-ssg.js

@@ -0,0 +1,377 @@
+import { Deno } from "@deno/shim-deno";
+/**
+ * @openelement/adapter-vite - CLI: SSG Build
+ *
+ * SSG rendering + post-processing.
+ * Builds a self-contained SSR bundle via viteBuild(ssr:true, noExternal),
+ * then imports it to render all pages to static HTML, and post-processes
+ * island paths.
+ *
+ * ADR 0011: This module exports buildSSG() only - it is called from
+ * closeBundle() in open:build plugin. No longer a standalone CLI entry.
+ * ctx parameter is required (no globalThis fallback).
+ *
+ * Usage:
+ *   deno task build  (unified entry - runs all 3 phases)
+ */ import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { normalizePath } from 'vite';
+import process from 'node:process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { ssgRender } from '@openelement/ssg';
+import { SsrRenderError } from '@openelement/core/errors';
+import { createLogger } from '@openelement/core/logger';
+import { createSsgRenderEvidence } from './ssg-render.js';
+import { createGeneratedDataResolverPlugin } from '../generated-data-resolver.js';
+import { createOpenJsrPackageResolverPlugin } from '../ssg-package-resolver.js';
+import { generateSsrPolyfillBanner, resolveExternalManifest } from '@openelement/ssg';
+import { optionalPackageStubsPlugin } from '../plugin.js';
+import { normalizeViteAliases } from '../alias-utils.js';
+/** Fallback package version when adapter-vite cannot read its own deno.json. */ const DEFAULT_ADAPTER_VERSION_FALLBACK = '0.35.1';
+/** Chunk size warning limit (kB) for the SSR bundle build. */ const SSR_CHUNK_SIZE_WARNING_LIMIT_KB = 1500;
+/** Rollup/Vite output paths mapping for known externals. */ const SSR_EXTERNAL_PATHS = {
+  'sanitize-html': 'npm:sanitize-html@^2.17.4'
+};
+const log = createLogger('ssg');
+const VIRTUAL_SSG_ENTRY_ID = 'virtual:open-ssg-entry';
+const RESOLVED_SSG_ENTRY_ID = '\0' + VIRTUAL_SSG_ENTRY_ID;
+function getJsrPackageVersion(metaUrl) {
+  const match = metaUrl.match(/\/@openelement\/adapter-vite\/([^/]+)\//);
+  if (match) return match[1];
+  // Read from own deno.json
+  try {
+    const denoJson = JSON.parse(typeof Deno !== 'undefined' ? Deno.readTextFileSync(new URL('../deno.json', import.meta.url)) : readFileSync(new URL('../deno.json', import.meta.url), 'utf-8'));
+    return denoJson.version || DEFAULT_ADAPTER_VERSION_FALLBACK;
+  } catch  {
+    return DEFAULT_ADAPTER_VERSION_FALLBACK;
+  }
+}
+function getLocalOpenElementPackageRoot(metaUrl) {
+  if (!metaUrl.startsWith('file:')) return null;
+  try {
+    const root = resolve(fileURLToPath(new URL('.', metaUrl)), '..', '..', '..', '..');
+    return existsSync(resolve(root, 'packages', 'core', 'deno.json')) ? root : null;
+  } catch  {
+    return null;
+  }
+}
+async function buildSSG(options = {}, ctx) {
+  const root = options.root || ctx.phase3.root || process.cwd();
+  const outDir = options.outDir || ctx.phase3.outDir || 'dist';
+  const routesDir = options.routesDir || ctx.phase3.routesDir || 'app/routes';
+  const islandsDir = options.islandsDir || ctx.phase3.islandsDir || 'app/islands';
+  const appShell = options.appShell ?? ctx.phase3.appShell;
+  const layouts = options.layouts ?? ctx.phase3.layouts;
+  // SOP-v0.21.6: Detect if we're running from a Deno workspace.
+  // In workspace mode, @deno/vite-plugin resolves bare specifiers.
+  // In JSR mode, we need the open:ssg-core-resolve plugin.
+  const workspaceRoot = (()=>{
+    try {
+      for(let d = resolve(root); d !== resolve(d, '..'); d = resolve(d, '..')){
+        const cfg = JSON.parse(readFileSync(resolve(d, 'deno.json'), 'utf-8'));
+        if (cfg.workspace && Array.isArray(cfg.workspace)) return d;
+      }
+    } catch  {}
+    return null;
+  })();
+  // Read island metadata from ctx (ADR 0010: no .openElement/ fallback)
+  const islandTagNames = options.islandTagNames || ctx.phase1.islandTagNames || [];
+  const islandMeta = options.islandMeta || ctx.phase1.islandMeta || {};
+  const packageManifests = options.packageManifests || ctx.phase1.packageManifests || [];
+  const metadataResolveAlias = options.resolveAlias || ctx.phase1.userResolveAlias;
+  // Read options from ctx
+  if (!options.headExtras) options.headExtras = ctx.phase3.headExtras || undefined;
+  if (options.allowHeadExtrasScripts === undefined) {
+    options.allowHeadExtrasScripts = ctx.phase3.allowHeadExtrasScripts;
+  }
+  if (!options.html) options.html = ctx.phase3.html || undefined;
+  if (!options.middleware) options.middleware = ctx.phase3.middleware || undefined;
+  if (!options.upgradeStrategy) options.upgradeStrategy = ctx.phase3.upgradeStrategy;
+  if (!options.base) options.base = ctx.phase3.base;
+  if (options.viewTransition === undefined) options.viewTransition = ctx.phase3.viewTransition;
+  if (!options.speculation) options.speculation = ctx.phase3.speculation || undefined;
+  // Generate SSG entry code
+  const { scanRoutes, scanIslands, scanIslandMeta, fileToTagName } = await import('@openelement/ssg');
+  const { generateHonoEntryCode } = await import('@openelement/ssg');
+  const routes = await scanRoutes(routesDir);
+  // v0.25.0: Generate type-safe route parameter declarations for `virtual:open-routes`
+  const { generateRouteTypes } = await import('@openelement/ssg');
+  const routeTypeDts = generateRouteTypes(routes);
+  const dotOpenElementDir = join(root, '.openElement');
+  mkdirSync(dotOpenElementDir, {
+    recursive: true
+  });
+  writeFileSync(join(dotOpenElementDir, 'routes.d.ts'), routeTypeDts, 'utf-8');
+  log.info(`Route types generated -> .openElement/routes.d.ts`);
+  const islandsRoot = join(root, islandsDir);
+  const ssgIslandFiles = await scanIslands(islandsRoot);
+  const ssgIslandTagNames = islandTagNames.length > 0 ? islandTagNames : ssgIslandFiles.map((f)=>fileToTagName(f));
+  const ssgIslandMeta = Object.keys(islandMeta).length > 0 ? islandMeta : await scanIslandMeta(islandsRoot, ssgIslandFiles);
+  const { buildEntryDescriptor } = await import('@openelement/ssg');
+  ctx.phase1.ssrAdmissionPlan = buildEntryDescriptor(routes, {
+    routesDir,
+    islandsDir,
+    ssg: true,
+    islandTagNames: ssgIslandTagNames,
+    islandFiles: ssgIslandFiles,
+    islandMeta: ssgIslandMeta,
+    packageManifests,
+    clientOnlyTags: [],
+    appShell,
+    layouts
+  }).ssrAdmissionPlan;
+  const rawSsgEntryCode = generateSsrPolyfillBanner() + '\n' + generateHonoEntryCode(routes, {
+    routesDir,
+    islandsDir,
+    middleware: options.middleware,
+    ssg: true,
+    islandTagNames: ssgIslandTagNames,
+    islandFiles: ssgIslandFiles,
+    islandMeta: ssgIslandMeta,
+    packageManifests,
+    headExtras: options.headExtras,
+    allowHeadExtrasScripts: options.allowHeadExtrasScripts,
+    html: options.html,
+    upgradeStrategy: options.upgradeStrategy || 'idle',
+    clientOnlyTags: [],
+    appShell,
+    layouts
+  });
+  // Deno import map resolution handles bare specifiers (e.g. @openelement/ui/open-callout)
+  // via the createDenoImportMapPlugin added to the Phase 3 viteBuild plugins below.
+  const ssgEntryCode = rawSsgEntryCode;
+  try {
+    const { build: viteBuild } = await import('vite');
+    // SSR noExternal: packages that MUST be inlined into the SSR bundle.
+    // Without these, the SSR bundle contains bare specifier imports that cannot
+    // be resolved in non-workspace environments (e.g. CF Pages), causing
+    // import(entry.js) to fail and the entire SSG pipeline to produce empty HTML.
+    const defaultNoExternal = [
+      /^@openelement\//
+    ];
+    // ADR-0047: External packages are externalized, not bundled.
+    // ADR-0054: AST-based exports resolution covers ALL subpath exports
+    // so Rolldown externalizes them correctly via manifest.specifiers.
+    // Consumer template deno.json declares these packages so Deno can
+    // resolve them at runtime when buildSSG() executes import(entry.js).
+    // Hono stays external unless the user explicitly requests adapter-specific
+    // bundling through options.ssr.noExternal.
+    const ssrExternalDefaults = [
+      'hono'
+    ];
+    // Step 0: Deno pre-resolution + AST subpath discovery (ADR-0047 + ADR-0054)
+    const manifest = await resolveExternalManifest(ssrExternalDefaults, root, options.skipPreResolution || ctx.phase3?.skipPreResolution);
+    const userNoExternal = options.ssr?.noExternal || [];
+    const allNoExternal = [
+      ...defaultNoExternal,
+      ...userNoExternal
+    ];
+    // Handle alias - prefer CLI options, then ctx from Phase 1
+    const alias = metadataResolveAlias;
+    const viteResolveAlias = normalizeViteAliases(alias, root);
+    if (alias) {
+      if (Array.isArray(alias)) {
+        for (const a of alias){
+          if (a.find === '@openelement/ui') {
+            // v0.14.6: Check if replacement is already covered by defaultNoExternal
+            const isAlreadyCovered = defaultNoExternal.some((pattern)=>pattern instanceof RegExp && pattern.test(a.replacement));
+            if (!isAlreadyCovered) {
+              allNoExternal.push(a.replacement);
+            }
+          }
+        }
+      } else if ('@openelement/ui' in alias) {
+        const isAlreadyCovered = defaultNoExternal.some((pattern)=>pattern instanceof RegExp && pattern.test(alias['@openelement/ui']));
+        if (!isAlreadyCovered) {
+          allNoExternal.push(alias['@openelement/ui']);
+        }
+      }
+    }
+    // Build the self-contained SSR bundle (ADR 0008 Phase C)
+    // Replaces createServer() + ssrLoadModule() with viteBuild + import().
+    // noExternal ensures all dependencies are inlined into a single bundle,
+    // so module-level variables (Phase B) are shared across the entire graph.
+    const ssrOutDir = join(root, outDir, 'server');
+    log.info(`Building SSR bundle -> ${ssrOutDir}`);
+    const clientOnlyIslandIds = new Set(Object.entries(ssgIslandMeta).filter(([, meta])=>meta.ssr === false).map(([tag])=>{
+      const file = ssgIslandFiles[ssgIslandTagNames.indexOf(tag)];
+      return file ? normalizePath(resolve(root, islandsDir, file)) : '';
+    }).filter(Boolean));
+    // v0.21: Build filePath -> tagName map for client-only placeholder generation.
+    const clientOnlyTagMap = new Map();
+    for (const [tag, meta] of Object.entries(ssgIslandMeta)){
+      if (meta.ssr !== false) continue;
+      const file = ssgIslandFiles[ssgIslandTagNames.indexOf(tag)];
+      if (file) clientOnlyTagMap.set(normalizePath(resolve(root, islandsDir, file)), tag);
+    }
+    // v0.21 SOP-004: Conflict detection: same tag must not be both SSR and client:only.
+    const ssrTags = new Set(Object.entries(ssgIslandMeta).filter(([, meta])=>meta.ssr !== false).map(([tag])=>tag));
+    const conflictTags = [
+      ...clientOnlyTagMap.values()
+    ].filter((t)=>ssrTags.has(t));
+    if (conflictTags.length > 0) {
+      throw new Error(`[openElement] SSR+client:only conflict detected for tags: ${conflictTags.join(', ')}. ` + 'A tag cannot be both SSR-capable and client:only on the same page.');
+    }
+    await viteBuild({
+      configFile: false,
+      root,
+      logLevel: 'error',
+      build: {
+        ssr: true,
+        outDir: ssrOutDir,
+        chunkSizeWarningLimit: SSR_CHUNK_SIZE_WARNING_LIMIT_KB,
+        rollupOptions: {
+          input: {
+            entry: VIRTUAL_SSG_ENTRY_ID
+          },
+          // v0.21: Suppress IMPORT_IS_UNDEFINED for revalidate; the generated
+          // code uses typeof check which correctly handles undefined exports.
+          onwarn (warning, warn) {
+            if (warning.code === 'IMPORT_IS_UNDEFINED') return;
+            warn(warning);
+          },
+          output: {
+            format: 'esm',
+            // Workspace sources may use explicit npm: specifiers that Rolldown
+            // rewrites to bare imports while bundling. Re-emit known externals
+            // as Deno-resolvable npm: imports for fresh JSR consumers.
+            paths: SSR_EXTERNAL_PATHS,
+            // ADR-0044: customElements polyfill must run before ESM imports.
+            // Uses Map-backed define()/get(); renderDsdByName() looks up
+            // components via customElements.get(tagName) during SSG rendering.
+            // SOP-016: HTMLElement stub is self-contained in @openelement/core/dsd-element.ts.
+            banner: `\
+if (typeof globalThis.customElements === 'undefined') {
+  const __openCeRegistry = new Map();
+  globalThis.customElements = {
+    define(name, ctor, _opts) { __openCeRegistry.set(name, ctor); },
+    get(name) { return __openCeRegistry.get(name); },
+    whenDefined(name) { return Promise.resolve(__openCeRegistry.get(name)); },
+    upgrade(_root) {},
+  };
+}
+`
+          }
+        }
+      },
+      ssr: {
+        noExternal: allNoExternal,
+        external: manifest.specifiers
+      },
+      // ADR 0008 Phase A: Inject headExtras via define instead of .openElement/head-extras.html
+      // The generated entry code uses __HEAD_EXTRAS__ which gets replaced
+      // at build time. This avoids the Vite SSR AsyncFunction syntax errors
+      // that large inline strings (with backticks/${}) cause.
+      define: options.headExtras ? {
+        __HEAD_EXTRAS__: JSON.stringify(options.headExtras)
+      } : {
+        __HEAD_EXTRAS__: '""'
+      },
+      esbuild: {
+        // ADR-0057: JSX automatic runtime, same reason as build-client.ts.
+        // SSG build also processes .tsx island files for SSR rendering.
+        jsx: 'automatic',
+        jsxImportSource: '@openelement/core',
+        tsconfigRaw: {
+          compilerOptions: {
+            useDefineForClassFields: false
+          }
+        }
+      },
+      plugins: [
+        // ADR 0010: Virtual SSG entry module
+        // Replaces .openElement/.openElement-ssg-entry.ts file write
+        {
+          name: 'open:virtual-ssg-entry',
+          resolveId (id) {
+            if (id === VIRTUAL_SSG_ENTRY_ID) return RESOLVED_SSG_ENTRY_ID;
+          },
+          load (id) {
+            if (id === RESOLVED_SSG_ENTRY_ID) return ssgEntryCode;
+          }
+        },
+        // ADR 0008 Phase C: Provide stubs for retained optional packages.
+        // The generated entry code can import @openelement/content and
+        // @openelement/i18n, but these may not be installed.
+        // This plugin resolves them to empty stubs when missing, so the
+        // viteBuild() succeeds regardless of which packages are available.
+        optionalPackageStubsPlugin(),
+        createGeneratedDataResolverPlugin({
+          root,
+          name: 'open:ssg-generated-data'
+        }),
+        createOpenJsrPackageResolverPlugin({
+          workspaceRoot,
+          version: getJsrPackageVersion(import.meta.url),
+          localPackageRoot: getLocalOpenElementPackageRoot(import.meta.url),
+          userAliases: metadataResolveAlias
+        }),
+        {
+          name: 'open:ssg-client-only-island-stubs',
+          enforce: 'pre',
+          load (id) {
+            const normalized = normalizePath(id.split('?')[0]);
+            if (!clientOnlyIslandIds.has(normalized)) return;
+            const tagName = clientOnlyTagMap.get(normalized) || 'open-client-only-stub';
+            // Client-only stub marker uses an unbranded attribute.
+            // SSR outputs <tag-name data-client-only="true"></tag-name>
+            // Client runtime imports the real module and upgrades the element.
+            return [
+              `import { defineIslandConfig } from '@openelement/app';`,
+              `export const tagName = ${JSON.stringify(tagName)};`,
+              'export const openElement = defineIslandConfig({ ssr: false });',
+              `export default class OpenClientOnlyStub extends HTMLElement {
+  connectedCallback() {
+    if (!this.hasAttribute('data-client-only')) {
+      this.setAttribute('data-client-only', 'true');
+    }
+  }
+}`
+            ].join('\n');
+          }
+        }
+      ],
+      resolve: {
+        preserveSymlinks: true,
+        extensions: [
+          '.ts',
+          '.tsx',
+          '.js',
+          '.jsx',
+          '.json'
+        ],
+        ...viteResolveAlias ? {
+          alias: viteResolveAlias
+        } : {}
+      }
+    });
+    log.info('SSR bundle built successfully');
+    // Load the SSR bundle and run SSG rendering pipeline
+    const ssrBundlePath = resolve(ssrOutDir, 'entry.js');
+    // M-18 fix: Use process.platform instead of Deno.build.os for Node.js compat
+    const isWindows = typeof process !== 'undefined' && process.platform === 'win32';
+    const ssrBundleUrl = isWindows ? 'file:///' + ssrBundlePath.replace(/\\/g, '/') : 'file://' + ssrBundlePath;
+    const module = await import(ssrBundleUrl);
+    if (!module.default) {
+      throw new SsrRenderError('virtual:open-ssg-entry', new Error('Failed to load Hono app'));
+    }
+    // Delegate to shared ssgRender() - zero Vite dependency from this point
+    await ssgRender(module, {
+      root,
+      outDir,
+      base: options.base || '/',
+      headExtras: options.headExtras,
+      html: options.html,
+      middleware: options.middleware,
+      islandTagNames: ssgIslandTagNames,
+      viewTransition: options.viewTransition,
+      speculation: options.speculation
+    }, createSsgRenderEvidence(ctx));
+    log.info('Static site generated -> ' + join(root, outDir));
+  } catch (err) {
+    const cause = err instanceof Error ? err : new Error(String(err));
+    throw new SsrRenderError('SSG pipeline', cause);
+  }
+}
+export { buildSSG };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/adapter-vite/src/cli/build-ssg.ts"],"sourcesContent":["import { Deno } from \"@deno/shim-deno\";\n/**\n * @openelement/adapter-vite - CLI: SSG Build\n *\n * SSG rendering + post-processing.\n * Builds a self-contained SSR bundle via viteBuild(ssr:true, noExternal),\n * then imports it to render all pages to static HTML, and post-processes\n * island paths.\n *\n * ADR 0011: This module exports buildSSG() only - it is called from\n * closeBundle() in open:build plugin. No longer a standalone CLI entry.\n * ctx parameter is required (no globalThis fallback).\n *\n * Usage:\n *   deno task build  (unified entry - runs all 3 phases)\n */\n\nimport { join, resolve } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { normalizePath } from 'vite';\nimport process from 'node:process';\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';\nimport type { FrameworkOptions, HydrationStrategy } from '@openelement/protocol/framework';\nimport type { OpenElementPackageManifest } from '@openelement/protocol/manifest';\nimport type { OpenElementBuildContext } from '../build-context.js';\nimport { ssgRender } from '@openelement/ssg';\nimport { SsrRenderError } from '@openelement/core/errors';\nimport { createLogger } from '@openelement/core/logger';\nimport { createSsgRenderEvidence } from './ssg-render.js';\nimport { createGeneratedDataResolverPlugin } from '../generated-data-resolver.js';\nimport { createOpenJsrPackageResolverPlugin } from '../ssg-package-resolver.js';\nimport { generateSsrPolyfillBanner, resolveExternalManifest } from '@openelement/ssg';\nimport { optionalPackageStubsPlugin } from '../plugin.js';\nimport { normalizeViteAliases } from '../alias-utils.js';\n\n/** Fallback package version when adapter-vite cannot read its own deno.json. */\nconst DEFAULT_ADAPTER_VERSION_FALLBACK = '0.35.1';\n\n/** Chunk size warning limit (kB) for the SSR bundle build. */\nconst SSR_CHUNK_SIZE_WARNING_LIMIT_KB = 1500;\n\n/** Rollup/Vite output paths mapping for known externals. */\nconst SSR_EXTERNAL_PATHS: Record<string, string> = {\n  'sanitize-html': 'npm:sanitize-html@^2.17.4',\n};\n\nconst log = createLogger('ssg');\n\nconst VIRTUAL_SSG_ENTRY_ID = 'virtual:open-ssg-entry';\nconst RESOLVED_SSG_ENTRY_ID = '\\0' + VIRTUAL_SSG_ENTRY_ID;\nfunction getJsrPackageVersion(metaUrl: string): string {\n  const match = metaUrl.match(/\\/@openelement\\/adapter-vite\\/([^/]+)\\//);\n  if (match) return match[1];\n  // Read from own deno.json\n  try {\n    const denoJson = JSON.parse(\n      typeof Deno !== 'undefined'\n        ? Deno.readTextFileSync(new URL('../deno.json', import.meta.url))\n        : readFileSync(new URL('../deno.json', import.meta.url), 'utf-8'),\n    );\n    return denoJson.version || DEFAULT_ADAPTER_VERSION_FALLBACK;\n  } catch {\n    return DEFAULT_ADAPTER_VERSION_FALLBACK;\n  }\n}\n\nfunction getLocalOpenElementPackageRoot(metaUrl: string): string | null {\n  if (!metaUrl.startsWith('file:')) return null;\n  try {\n    const root = resolve(fileURLToPath(new URL('.', metaUrl)), '..', '..', '..', '..');\n    return existsSync(resolve(root, 'packages', 'core', 'deno.json')) ? root : null;\n  } catch {\n    return null;\n  }\n}\n\ninterface BuildSSGOptions {\n  root?: string;\n  outDir?: string;\n  routesDir?: string;\n  islandsDir?: string;\n  middleware?: FrameworkOptions['middleware'];\n  ssr?: FrameworkOptions['ssr'];\n  islandTagNames?: string[];\n  islandMeta?: Record<string, Partial<import('@openelement/protocol/ssg').IslandDecl>>;\n  packageManifests?: OpenElementPackageManifest[];\n  /** @security Injected as raw HTML without sanitization */\n  headExtras?: string;\n  allowHeadExtrasScripts?: boolean;\n  html?: { lang?: string; title?: string };\n  appShell?: FrameworkOptions['appShell'];\n  layouts?: FrameworkOptions['layouts'];\n  upgradeStrategy?: HydrationStrategy;\n  resolveAlias?: Record<string, string> | import('vite').Alias[];\n  base?: string;\n  /**\n   * View Transitions API configuration.\n   * When true (default), injects <meta name=\"view-transition\" content=\"same-origin\">\n   * into all HTML files for smooth cross-page animations in MPA navigation.\n   * Set to false to disable.\n   * @default true\n   */\n  viewTransition?: boolean;\n  /**\n   * Speculation Rules API configuration.\n   * Enables browser prefetch/prerender of pages before the user navigates.\n   * Can be a boolean (true = auto-generate from routes) or explicit rules.\n   */\n  speculation?: boolean | import('@openelement/protocol/ssg').SpeculationRulesOptions;\n  /** ADR-0047: Skip Deno pre-resolution, use regex fallback for external deps. */\n  skipPreResolution?: boolean;\n}\n\nasync function buildSSG(\n  options: BuildSSGOptions = {},\n  ctx: OpenElementBuildContext,\n): Promise<void> {\n  const root = options.root || ctx.phase3.root || process.cwd();\n  const outDir = options.outDir || ctx.phase3.outDir || 'dist';\n  const routesDir = options.routesDir || ctx.phase3.routesDir || 'app/routes';\n  const islandsDir = options.islandsDir || ctx.phase3.islandsDir || 'app/islands';\n  const appShell = options.appShell ?? ctx.phase3.appShell;\n  const layouts = options.layouts ?? ctx.phase3.layouts;\n\n  // SOP-v0.21.6: Detect if we're running from a Deno workspace.\n  // In workspace mode, @deno/vite-plugin resolves bare specifiers.\n  // In JSR mode, we need the open:ssg-core-resolve plugin.\n  const workspaceRoot = (() => {\n    try {\n      for (let d = resolve(root); d !== resolve(d, '..'); d = resolve(d, '..')) {\n        const cfg = JSON.parse(readFileSync(resolve(d, 'deno.json'), 'utf-8'));\n        if (cfg.workspace && Array.isArray(cfg.workspace)) return d;\n      }\n    } catch { /* deno.json not found, keep walking up */ }\n    return null;\n  })();\n\n  // Read island metadata from ctx (ADR 0010: no .openElement/ fallback)\n  const islandTagNames = options.islandTagNames || ctx.phase1.islandTagNames || [];\n  const islandMeta = options.islandMeta || ctx.phase1.islandMeta || {};\n  const packageManifests = options.packageManifests || ctx.phase1.packageManifests || [];\n  const metadataResolveAlias = options.resolveAlias ||\n    (ctx.phase1.userResolveAlias as Record<string, string> | import('vite').Alias[] | undefined);\n\n  // Read options from ctx\n  if (!options.headExtras) options.headExtras = ctx.phase3.headExtras || undefined;\n  if (options.allowHeadExtrasScripts === undefined) {\n    options.allowHeadExtrasScripts = ctx.phase3.allowHeadExtrasScripts;\n  }\n  if (!options.html) options.html = ctx.phase3.html || undefined;\n  if (!options.middleware) options.middleware = ctx.phase3.middleware || undefined;\n  if (!options.upgradeStrategy) options.upgradeStrategy = ctx.phase3.upgradeStrategy;\n  if (!options.base) options.base = ctx.phase3.base;\n  if (options.viewTransition === undefined) options.viewTransition = ctx.phase3.viewTransition;\n  if (!options.speculation) options.speculation = ctx.phase3.speculation || undefined;\n\n  // Generate SSG entry code\n  const { scanRoutes, scanIslands, scanIslandMeta, fileToTagName } = await import(\n    '@openelement/ssg'\n  );\n  const { generateHonoEntryCode } = await import('@openelement/ssg');\n\n  const routes = await scanRoutes(routesDir);\n\n  // v0.25.0: Generate type-safe route parameter declarations for `virtual:open-routes`\n  const { generateRouteTypes } = await import('@openelement/ssg');\n  const routeTypeDts = generateRouteTypes(routes);\n  const dotOpenElementDir = join(root, '.openElement');\n  mkdirSync(dotOpenElementDir, { recursive: true });\n  writeFileSync(join(dotOpenElementDir, 'routes.d.ts'), routeTypeDts, 'utf-8');\n  log.info(`Route types generated -> .openElement/routes.d.ts`);\n\n  const islandsRoot = join(root, islandsDir);\n  const ssgIslandFiles = await scanIslands(islandsRoot);\n  const ssgIslandTagNames = islandTagNames.length > 0\n    ? islandTagNames\n    : ssgIslandFiles.map((f) => fileToTagName(f));\n  const ssgIslandMeta = Object.keys(islandMeta).length > 0\n    ? islandMeta\n    : await scanIslandMeta(islandsRoot, ssgIslandFiles);\n  const { buildEntryDescriptor } = await import('@openelement/ssg');\n\n  ctx.phase1.ssrAdmissionPlan = buildEntryDescriptor(routes, {\n    routesDir,\n    islandsDir,\n    ssg: true,\n    islandTagNames: ssgIslandTagNames,\n    islandFiles: ssgIslandFiles,\n    islandMeta: ssgIslandMeta,\n    packageManifests,\n    clientOnlyTags: [],\n    appShell,\n    layouts,\n  }).ssrAdmissionPlan;\n\n  const rawSsgEntryCode = generateSsrPolyfillBanner() + '\\n' + generateHonoEntryCode(routes, {\n    routesDir,\n    islandsDir,\n    middleware: options.middleware,\n    ssg: true,\n    islandTagNames: ssgIslandTagNames,\n    islandFiles: ssgIslandFiles,\n    islandMeta: ssgIslandMeta,\n    packageManifests,\n    headExtras: options.headExtras,\n    allowHeadExtrasScripts: options.allowHeadExtrasScripts,\n    html: options.html,\n    upgradeStrategy: options.upgradeStrategy || 'idle',\n    clientOnlyTags: [],\n    appShell,\n    layouts,\n  });\n  // Deno import map resolution handles bare specifiers (e.g. @openelement/ui/open-callout)\n  // via the createDenoImportMapPlugin added to the Phase 3 viteBuild plugins below.\n  const ssgEntryCode = rawSsgEntryCode;\n\n  try {\n    const { build: viteBuild } = await import('vite');\n\n    // SSR noExternal: packages that MUST be inlined into the SSR bundle.\n    // Without these, the SSR bundle contains bare specifier imports that cannot\n    // be resolved in non-workspace environments (e.g. CF Pages), causing\n    // import(entry.js) to fail and the entire SSG pipeline to produce empty HTML.\n    const defaultNoExternal = [\n      /^@openelement\\//,\n    ];\n    // ADR-0047: External packages are externalized, not bundled.\n    // ADR-0054: AST-based exports resolution covers ALL subpath exports\n    // so Rolldown externalizes them correctly via manifest.specifiers.\n    // Consumer template deno.json declares these packages so Deno can\n    // resolve them at runtime when buildSSG() executes import(entry.js).\n    // Hono stays external unless the user explicitly requests adapter-specific\n    // bundling through options.ssr.noExternal.\n    const ssrExternalDefaults = [\n      'hono',\n    ];\n\n    // Step 0: Deno pre-resolution + AST subpath discovery (ADR-0047 + ADR-0054)\n    const manifest = await resolveExternalManifest(\n      ssrExternalDefaults,\n      root,\n      options.skipPreResolution || ctx.phase3?.skipPreResolution,\n    );\n\n    const userNoExternal = options.ssr?.noExternal || [];\n    const allNoExternal = [...defaultNoExternal, ...userNoExternal];\n\n    // Handle alias - prefer CLI options, then ctx from Phase 1\n    const alias = metadataResolveAlias;\n    const viteResolveAlias = normalizeViteAliases(alias, root);\n    if (alias) {\n      if (Array.isArray(alias)) {\n        for (const a of alias) {\n          if (a.find === '@openelement/ui') {\n            // v0.14.6: Check if replacement is already covered by defaultNoExternal\n            const isAlreadyCovered = defaultNoExternal.some(\n              (pattern: string | RegExp) =>\n                pattern instanceof RegExp && pattern.test(a.replacement),\n            );\n            if (!isAlreadyCovered) {\n              allNoExternal.push(a.replacement);\n            }\n          }\n        }\n      } else if ('@openelement/ui' in alias) {\n        const isAlreadyCovered = defaultNoExternal.some(\n          (pattern: string | RegExp) =>\n            pattern instanceof RegExp && pattern.test(alias['@openelement/ui']),\n        );\n        if (!isAlreadyCovered) {\n          allNoExternal.push(alias['@openelement/ui']);\n        }\n      }\n    }\n\n    // Build the self-contained SSR bundle (ADR 0008 Phase C)\n    // Replaces createServer() + ssrLoadModule() with viteBuild + import().\n    // noExternal ensures all dependencies are inlined into a single bundle,\n    // so module-level variables (Phase B) are shared across the entire graph.\n    const ssrOutDir = join(root, outDir, 'server');\n    log.info(`Building SSR bundle -> ${ssrOutDir}`);\n    const clientOnlyIslandIds = new Set(\n      Object.entries(ssgIslandMeta)\n        .filter(([, meta]) => meta.ssr === false)\n        .map(([tag]) => {\n          const file = ssgIslandFiles[ssgIslandTagNames.indexOf(tag)];\n          return file ? normalizePath(resolve(root, islandsDir, file)) : '';\n        })\n        .filter(Boolean),\n    );\n    // v0.21: Build filePath -> tagName map for client-only placeholder generation.\n    const clientOnlyTagMap = new Map<string, string>();\n    for (const [tag, meta] of Object.entries(ssgIslandMeta)) {\n      if (meta.ssr !== false) continue;\n      const file = ssgIslandFiles[ssgIslandTagNames.indexOf(tag)];\n      if (file) clientOnlyTagMap.set(normalizePath(resolve(root, islandsDir, file)), tag);\n    }\n\n    // v0.21 SOP-004: Conflict detection: same tag must not be both SSR and client:only.\n    const ssrTags = new Set(\n      Object.entries(ssgIslandMeta)\n        .filter(([, meta]) => meta.ssr !== false)\n        .map(([tag]) => tag),\n    );\n    const conflictTags = [...clientOnlyTagMap.values()].filter((t) => ssrTags.has(t));\n    if (conflictTags.length > 0) {\n      throw new Error(\n        `[openElement] SSR+client:only conflict detected for tags: ${conflictTags.join(', ')}. ` +\n          'A tag cannot be both SSR-capable and client:only on the same page.',\n      );\n    }\n\n    await viteBuild({\n      configFile: false,\n      root,\n      logLevel: 'error',\n      build: {\n        ssr: true,\n        outDir: ssrOutDir,\n        chunkSizeWarningLimit: SSR_CHUNK_SIZE_WARNING_LIMIT_KB,\n        rollupOptions: {\n          input: { entry: VIRTUAL_SSG_ENTRY_ID },\n          // v0.21: Suppress IMPORT_IS_UNDEFINED for revalidate; the generated\n          // code uses typeof check which correctly handles undefined exports.\n          onwarn(warning, warn) {\n            if (warning.code === 'IMPORT_IS_UNDEFINED') return;\n            warn(warning);\n          },\n          output: {\n            format: 'esm',\n            // Workspace sources may use explicit npm: specifiers that Rolldown\n            // rewrites to bare imports while bundling. Re-emit known externals\n            // as Deno-resolvable npm: imports for fresh JSR consumers.\n            paths: SSR_EXTERNAL_PATHS,\n            // ADR-0044: customElements polyfill must run before ESM imports.\n            // Uses Map-backed define()/get(); renderDsdByName() looks up\n            // components via customElements.get(tagName) during SSG rendering.\n            // SOP-016: HTMLElement stub is self-contained in @openelement/core/dsd-element.ts.\n            banner: `\\\nif (typeof globalThis.customElements === 'undefined') {\n  const __openCeRegistry = new Map();\n  globalThis.customElements = {\n    define(name, ctor, _opts) { __openCeRegistry.set(name, ctor); },\n    get(name) { return __openCeRegistry.get(name); },\n    whenDefined(name) { return Promise.resolve(__openCeRegistry.get(name)); },\n    upgrade(_root) {},\n  };\n}\n`,\n          },\n        },\n      },\n      ssr: { noExternal: allNoExternal, external: manifest.specifiers },\n      // ADR 0008 Phase A: Inject headExtras via define instead of .openElement/head-extras.html\n      // The generated entry code uses __HEAD_EXTRAS__ which gets replaced\n      // at build time. This avoids the Vite SSR AsyncFunction syntax errors\n      // that large inline strings (with backticks/${}) cause.\n      define: options.headExtras\n        ? { __HEAD_EXTRAS__: JSON.stringify(options.headExtras) }\n        : { __HEAD_EXTRAS__: '\"\"' },\n      esbuild: {\n        // ADR-0057: JSX automatic runtime, same reason as build-client.ts.\n        // SSG build also processes .tsx island files for SSR rendering.\n        jsx: 'automatic',\n        jsxImportSource: '@openelement/core',\n        tsconfigRaw: {\n          compilerOptions: {\n            useDefineForClassFields: false,\n          },\n        },\n      },\n      plugins: [\n        // ADR 0010: Virtual SSG entry module\n        // Replaces .openElement/.openElement-ssg-entry.ts file write\n        {\n          name: 'open:virtual-ssg-entry',\n          resolveId(id) {\n            if (id === VIRTUAL_SSG_ENTRY_ID) return RESOLVED_SSG_ENTRY_ID;\n          },\n          load(id) {\n            if (id === RESOLVED_SSG_ENTRY_ID) return ssgEntryCode;\n          },\n        },\n        // ADR 0008 Phase C: Provide stubs for retained optional packages.\n        // The generated entry code can import @openelement/content and\n        // @openelement/i18n, but these may not be installed.\n        // This plugin resolves them to empty stubs when missing, so the\n        // viteBuild() succeeds regardless of which packages are available.\n        optionalPackageStubsPlugin(),\n        createGeneratedDataResolverPlugin({\n          root,\n          name: 'open:ssg-generated-data',\n        }),\n        createOpenJsrPackageResolverPlugin({\n          workspaceRoot,\n          version: getJsrPackageVersion(import.meta.url),\n          localPackageRoot: getLocalOpenElementPackageRoot(import.meta.url),\n          userAliases: metadataResolveAlias,\n        }),\n        {\n          name: 'open:ssg-client-only-island-stubs',\n          enforce: 'pre',\n          load(id) {\n            const normalized = normalizePath(id.split('?')[0]);\n            if (!clientOnlyIslandIds.has(normalized)) return;\n            const tagName = clientOnlyTagMap.get(normalized) || 'open-client-only-stub';\n            // Client-only stub marker uses an unbranded attribute.\n            // SSR outputs <tag-name data-client-only=\"true\"></tag-name>\n            // Client runtime imports the real module and upgrades the element.\n            return [\n              `import { defineIslandConfig } from '@openelement/app';`,\n              `export const tagName = ${JSON.stringify(tagName)};`,\n              'export const openElement = defineIslandConfig({ ssr: false });',\n              `export default class OpenClientOnlyStub extends HTMLElement {\n  connectedCallback() {\n    if (!this.hasAttribute('data-client-only')) {\n      this.setAttribute('data-client-only', 'true');\n    }\n  }\n}`,\n            ].join('\\n');\n          },\n        },\n      ],\n      resolve: {\n        preserveSymlinks: true,\n        extensions: ['.ts', '.tsx', '.js', '.jsx', '.json'],\n        ...(viteResolveAlias ? { alias: viteResolveAlias } : {}),\n      },\n    });\n    log.info('SSR bundle built successfully');\n\n    // Load the SSR bundle and run SSG rendering pipeline\n    const ssrBundlePath = resolve(ssrOutDir, 'entry.js');\n    // M-18 fix: Use process.platform instead of Deno.build.os for Node.js compat\n    const isWindows = typeof process !== 'undefined' && process.platform === 'win32';\n    const ssrBundleUrl = isWindows\n      ? 'file:///' + ssrBundlePath.replace(/\\\\/g, '/')\n      : 'file://' + ssrBundlePath;\n    const module = await import(ssrBundleUrl) as Record<string, unknown>;\n\n    if (!module.default) {\n      throw new SsrRenderError('virtual:open-ssg-entry', new Error('Failed to load Hono app'));\n    }\n\n    // Delegate to shared ssgRender() - zero Vite dependency from this point\n    await ssgRender(\n      module as Parameters<typeof ssgRender>[0],\n      {\n        root,\n        outDir,\n        base: options.base || '/',\n        headExtras: options.headExtras,\n        html: options.html,\n        middleware: options.middleware,\n        islandTagNames: ssgIslandTagNames,\n        viewTransition: options.viewTransition,\n        speculation: options.speculation as boolean | Record<string, unknown> | undefined,\n      },\n      createSsgRenderEvidence(ctx),\n    );\n\n    log.info('Static site generated -> ' + join(root, outDir));\n  } catch (err) {\n    const cause = err instanceof Error ? err : new Error(String(err));\n    throw new SsrRenderError('SSG pipeline', cause);\n  }\n}\n\nexport { buildSSG };\n"],"names":[],"mappings":"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"}

package/src/cli/build.js

@@ -0,0 +1,27 @@
+/**
+ * @openelement/adapter-vite - CLI: Full Static Build
+ *
+ * ADR 0011: One-command build entry. viteBuild() triggers Phase 1,
+ * and closeBundle() in open:build plugin automatically runs Phase 2/3.
+ * No orchestrator needed - all three phases run in a single viteBuild() call.
+ *
+ * Usage:
+ *   deno run -A npm:@openelement/adapter-vite/cli/build
+ *   deno task build
+ */ import { build as viteBuild } from 'vite';
+import process from 'node:process';
+import { formatError } from '@openelement/core/errors';
+import { createLogger } from '@openelement/core/logger';
+if (import.meta.main) {
+  try {
+    await viteBuild({
+      configLoader: 'native'
+    });
+    process.exit(0);
+  } catch (error) {
+    const log = createLogger('adapter-vite');
+    log.error(`Build failed: ${formatError(error)}`);
+    process.exit(1);
+  }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9vcGVuZWxlbWVudC9vcGVuZWxlbWVudC9wYWNrYWdlcy9hZGFwdGVyLXZpdGUvc3JjL2NsaS9idWlsZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBvcGVuZWxlbWVudC9hZGFwdGVyLXZpdGUgLSBDTEk6IEZ1bGwgU3RhdGljIEJ1aWxkXG4gKlxuICogQURSIDAwMTE6IE9uZS1jb21tYW5kIGJ1aWxkIGVudHJ5LiB2aXRlQnVpbGQoKSB0cmlnZ2VycyBQaGFzZSAxLFxuICogYW5kIGNsb3NlQnVuZGxlKCkgaW4gb3BlbjpidWlsZCBwbHVnaW4gYXV0b21hdGljYWxseSBydW5zIFBoYXNlIDIvMy5cbiAqIE5vIG9yY2hlc3RyYXRvciBuZWVkZWQgLSBhbGwgdGhyZWUgcGhhc2VzIHJ1biBpbiBhIHNpbmdsZSB2aXRlQnVpbGQoKSBjYWxsLlxuICpcbiAqIFVzYWdlOlxuICogICBkZW5vIHJ1biAtQSBucG06QG9wZW5lbGVtZW50L2FkYXB0ZXItdml0ZS9jbGkvYnVpbGRcbiAqICAgZGVubyB0YXNrIGJ1aWxkXG4gKi9cblxuaW1wb3J0IHsgYnVpbGQgYXMgdml0ZUJ1aWxkIH0gZnJvbSAndml0ZSc7XG5pbXBvcnQgcHJvY2VzcyBmcm9tICdub2RlOnByb2Nlc3MnO1xuaW1wb3J0IHsgZm9ybWF0RXJyb3IgfSBmcm9tICdAb3BlbmVsZW1lbnQvY29yZS9lcnJvcnMnO1xuaW1wb3J0IHsgY3JlYXRlTG9nZ2VyIH0gZnJvbSAnQG9wZW5lbGVtZW50L2NvcmUvbG9nZ2VyJztcblxuaWYgKGltcG9ydC5tZXRhLm1haW4pIHtcbiAgdHJ5IHtcbiAgICBhd2FpdCB2aXRlQnVpbGQoeyBjb25maWdMb2FkZXI6ICduYXRpdmUnIH0pO1xuICAgIHByb2Nlc3MuZXhpdCgwKTtcbiAgfSBjYXRjaCAoZXJyb3IpIHtcbiAgICBjb25zdCBsb2cgPSBjcmVhdGVMb2dnZXIoJ2FkYXB0ZXItdml0ZScpO1xuICAgIGxvZy5lcnJvcihgQnVpbGQgZmFpbGVkOiAke2Zvcm1hdEVycm9yKGVycm9yKX1gKTtcbiAgICBwcm9jZXNzLmV4aXQoMSk7XG4gIH1cbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7OztDQVVDLEdBRUQsU0FBUyxTQUFTLFNBQVMsUUFBUSxPQUFPO0FBQzFDLE9BQU8sYUFBYSxlQUFlO0FBQ25DLFNBQVMsV0FBVyxRQUFRLDJCQUEyQjtBQUN2RCxTQUFTLFlBQVksUUFBUSwyQkFBMkI7QUFFeEQsSUFBSSxZQUFZLElBQUksRUFBRTtFQUNwQixJQUFJO0lBQ0YsTUFBTSxVQUFVO01BQUUsY0FBYztJQUFTO0lBQ3pDLFFBQVEsSUFBSSxDQUFDO0VBQ2YsRUFBRSxPQUFPLE9BQU87SUFDZCxNQUFNLE1BQU0sYUFBYTtJQUN6QixJQUFJLEtBQUssQ0FBQyxDQUFDLGNBQWMsRUFBRSxZQUFZLFFBQVE7SUFDL0MsUUFBUSxJQUFJLENBQUM7RUFDZjtBQUNGIn0=

package/src/cli/ssg-render.js

@@ -0,0 +1,32 @@
+/**
+ * Compatibility wrapper for the SSG render pipeline.
+ *
+ * The implementation is internal to adapter-vite in v0.40.x.
+ * adapter-vite keeps this module so existing imports continue to work while
+ * build orchestration uses the local SSG helpers.
+ */ import { resolveDynamicRoutePath, ssgRender as ssgRenderCore } from '@openelement/ssg';
+import { printBuildManifest } from '../build-manifest.js';
+export { resolveDynamicRoutePath };
+export async function ssgRender(module, options, ctx) {
+  return await ssgRenderCore(module, options, createSsgRenderEvidence(ctx));
+}
+export function createSsgRenderEvidence(ctx) {
+  if (!ctx) return {};
+  return {
+    i18nOptions: ctx.plugins.i18nOptions,
+    localIslandMeta: ctx.phase1.islandMeta,
+    packageIslandDecls: ctx.phase1.packageIslandDecls,
+    packageManifests: ctx.phase1.packageManifests,
+    admissionDecisions: ctx.phase1.ssrAdmissionPlan?.decisions || [],
+    cemClassifications: ctx.phase1.cemClassifications,
+    onPrintBuildManifest: (input)=>{
+      printBuildManifest(input);
+    },
+    onGenerateSitemap: async (outputDir)=>{
+      if (!ctx.plugins.sitemapOptions) return;
+      const { generateSitemap } = await import('@openelement/content/sitemap');
+      generateSitemap(outputDir, ctx.plugins.sitemapOptions);
+    }
+  };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/generated-data-resolver.d.ts

@@ -0,0 +1,12 @@
+import type { Plugin } from 'vite';
+export declare const GENERATED_NAV_ID: '@openelement/generated/nav';
+export declare const GENERATED_BLOG_DATA_ID: '@openelement/generated/blog-data';
+export declare const GENERATED_I18N_ID: '@openelement/generated/i18n';
+export type GeneratedDataResolverOptions = {
+  root: string;
+  dataDir?: string;
+  name?: string;
+  allowFallback?: boolean;
+};
+export declare function generatedDataPath(root: string, id: string, dataDir?: string): string | null;
+export declare function createGeneratedDataResolverPlugin(options: GeneratedDataResolverOptions): Plugin;

package/src/generated-data-resolver.js

@@ -0,0 +1,52 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+export const GENERATED_NAV_ID = '@openelement/generated/nav';
+export const GENERATED_BLOG_DATA_ID = '@openelement/generated/blog-data';
+export const GENERATED_I18N_ID = '@openelement/generated/i18n';
+const GENERATED_DATA_FILES = {
+  [GENERATED_NAV_ID]: '_generated-nav.ts',
+  [GENERATED_BLOG_DATA_ID]: '_generated-blog-data.ts',
+  [GENERATED_I18N_ID]: '_generated-i18n-data.ts'
+};
+const GENERATED_DATA_FALLBACKS = {
+  [GENERATED_NAV_ID]: 'export const headerNav = [];\nexport const navSections = [];',
+  [GENERATED_BLOG_DATA_ID]: [
+    'export const posts = [];',
+    'export function getPostBySlug() { return undefined; }',
+    'export function getBlogOptions() { return {}; }'
+  ].join('\n'),
+  [GENERATED_I18N_ID]: [
+    'export const locales = [];',
+    'export function getDefaultLocale() { return "en"; }',
+    'export function getI18nOptions() { return null; }'
+  ].join('\n')
+};
+export function generatedDataPath(root, id, dataDir = 'app/data') {
+  const fileName = GENERATED_DATA_FILES[id];
+  if (!fileName) return null;
+  return resolve(root, dataDir, fileName);
+}
+export function createGeneratedDataResolverPlugin(options) {
+  const dataDir = options.dataDir ?? 'app/data';
+  const allowFallback = options.allowFallback ?? true;
+  return {
+    name: options.name ?? 'open:generated-data',
+    enforce: 'pre',
+    resolveId (id) {
+      if (!GENERATED_DATA_FILES[id]) return null;
+      const path = generatedDataPath(options.root, id, dataDir);
+      if (path && existsSync(path)) return path;
+      return '\0open:generated-data:' + id;
+    },
+    load (id) {
+      const prefix = '\0open:generated-data:';
+      if (!id.startsWith(prefix)) return null;
+      const sourceId = id.slice(prefix.length);
+      const path = generatedDataPath(options.root, sourceId, dataDir);
+      if (path && existsSync(path)) return readFileSync(path, 'utf-8');
+      if (allowFallback) return GENERATED_DATA_FALLBACKS[sourceId] ?? null;
+      return null;
+    }
+  };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/src/head-injection.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @openelement/adapter-vite — Head injection validation & serialization.
+ *
+ * Extracted from index.ts in v0.22 (SOP-004: adapter-vite decomposition).
+ *
+ * Provides:
+ * - assertNoScriptTags() — script tag safety check for head fragments
+ * - validateSafeUrl()    — URL protocol validation against XSS vectors
+ * - buildHeadExtras()    — serialize headFragments, stylesheets, and scripts
+ *                          into a single headExtras string
+ */ import type { FrameworkOptions } from '@openelement/protocol/framework';
+/**
+ * Assert that HTML content does NOT contain <script> tags.
+ * Scripts must go through inject.scripts for URL validation.
+ */ export declare function assertNoScriptTags(html: string, context: string): void;
+/**
+ * Validate a URL string for known XSS vectors (javascript:, data:, etc.).
+ * Also validates percent-encoding is not malformed.
+ * Returns the normalized URL string.
+ */ export declare function validateSafeUrl(url: string, context: string): string;
+/** Result of building head extras from FrameworkOptions. */ export interface HeadExtrasResult {
+  headExtras: string | undefined;
+  allowHeadExtrasScripts: boolean;
+}
+/**
+ * Build the headExtras string from FrameworkOptions.inject.
+ *
+ * Serializes headFragments, stylesheets, and scripts into a single
+ * HTML string to inject into <head>. Validates all URLs and ensures
+ * no raw <script> tags bypass the structured injection APIs.
+ */ export declare function buildHeadExtras(options: FrameworkOptions): HeadExtrasResult;