@openelement/adapter-vite 0.41.0-alpha.1

package/src/cli/build-client.js

@@ -0,0 +1,292 @@
+/**
+ * @openelement/adapter-vite - CLI: Client Island Build
+ *
+ * Client build for Island components.
+ * Produces dist/client/islands/*.js + manifest for SSG post-processing.
+ *
+ * ADR 0011: This module exports buildClient() 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 { build as viteBuild } from 'vite';
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import process from 'node:process';
+import { generateClientEntry } from '@openelement/ssg';
+import { createOpenJsrPackageResolverPlugin } from '../ssg-package-resolver.js';
+import { formatError } from '@openelement/core/errors';
+import { createLogger } from '@openelement/core/logger';
+const log = createLogger('ssg');
+const VIRTUAL_CLIENT_ENTRY_ID = 'virtual:open-client-entry';
+const RESOLVED_CLIENT_ENTRY_ID = '\0' + VIRTUAL_CLIENT_ENTRY_ID;
+const FALLBACK_openElement_VERSION = '0.23.0';
+/** Workspace root derived from this module's location (packages/adapter-vite/src/cli/).
+ * Only valid in local workspace (file:// import.meta.url). In JSR consumers, returns null. */ const WORKSPACE_ROOT = (()=>{
+  if (!import.meta.url.startsWith('file:')) return null;
+  try {
+    return fileURLToPath(new URL('../../../..', import.meta.url)).replace(/\\/g, '/');
+  } catch  {
+    return null;
+  }
+})();
+function getJsrPackageVersion(metaUrl) {
+  const match = metaUrl.match(/\/@openelement\/adapter-vite\/([^/]+)\//);
+  return match?.[1] ?? FALLBACK_openElement_VERSION;
+}
+/**
+ * Look up a bare specifier in a deno.json import map.
+ * Walks up directory tree to find workspace-level deno.json as fallback.
+ * Returns { target, denoJsonDir } so relative paths can be resolved correctly.
+ */ function lookupInDenoJson(id, root) {
+  const denoJsonDirs = new Set();
+  let dir = resolve(root);
+  // Walk up from consumer root
+  while(!denoJsonDirs.has(dir)){
+    denoJsonDirs.add(dir);
+    const found = tryDenoJsonDir(id, dir);
+    if (found) return found;
+    const parent = resolve(dir, '..');
+    if (parent === dir) break;
+    dir = parent;
+  }
+  // Also try workspace root (module-relative, for monorepo dev / testing)
+  if (WORKSPACE_ROOT && !denoJsonDirs.has(WORKSPACE_ROOT)) {
+    const found = tryDenoJsonDir(id, WORKSPACE_ROOT);
+    if (found) return found;
+  }
+  return null;
+}
+/** Check a single directory for a deno.json with the given import. */ function tryDenoJsonDir(id, dir) {
+  const denoJsonPath = join(dir, 'deno.json');
+  if (!existsSync(denoJsonPath)) return null;
+  const raw = readFileSync(denoJsonPath, 'utf-8');
+  // Strip JSONC comments:
+  // - Line comments: // at start of line (after optional whitespace)
+  // - Block comments: /* ... */
+  // - Trailing commas (Deno JSONC allows them, JSON.parse does not)
+  const json = raw.replace(/^\s*\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '').replace(/,\s*([}\]])/g, '$1');
+  let denoJson;
+  try {
+    denoJson = JSON.parse(json);
+  } catch  {
+    return null; // Invalid JSON — skip this deno.json
+  }
+  const imports = denoJson.imports;
+  if (!imports) return null;
+  // Exact match
+  if (imports[id]) return {
+    target: imports[id],
+    denoJsonDir: dir
+  };
+  // Prefix/subpath matching (trailing slash)
+  for (const [key, value] of Object.entries(imports)){
+    if (key.endsWith('/') && id.startsWith(key)) {
+      return {
+        target: value + id.slice(key.length),
+        denoJsonDir: dir
+      };
+    }
+  }
+  return null;
+}
+/**
+ * Convert a Deno import map target to a resolvable Vite path.
+ * - file:// URLs → absolute filesystem path
+ * - Relative paths (./) → resolved relative to denoJsonDir
+ * - npm:, jsr: → null (handled by node_modules)
+ */ function convertImportMapTarget(target, denoJsonDir) {
+  if (target.startsWith('file://')) {
+    try {
+      return fileURLToPath(target).replace(/\\/g, '/');
+    } catch  {
+      return null;
+    }
+  }
+  // Relative path — resolve relative to the deno.json directory
+  if (target.startsWith('./') || target.startsWith('../')) {
+    return resolve(denoJsonDir, target).replace(/\\/g, '/');
+  }
+  // npm:, jsr: — let Vite/Rolldown handle these normally
+  return null;
+}
+async function buildClient(ctx) {
+  const root = ctx.phase3.root || process.cwd();
+  const outDir = ctx.phase3.outDir || 'dist';
+  const islandsDir = ctx.phase3.islandsDir || 'app/islands';
+  const localIslands = ctx.phase1.islandTagNames || [];
+  const localIslandFiles = ctx.phase1.islandFiles || [];
+  const packageIslandDecls = ctx.phase1.packageIslandDecls || [];
+  // Aliases pre-generated by createOpenPlugin() and stored in ctx
+  const resolveAlias = ctx.phase1.userResolveAlias;
+  const serializedAlias = resolveAlias ? Array.isArray(resolveAlias) ? resolveAlias.filter((a)=>typeof a.find === 'string').map((a)=>({
+      find: a.find,
+      replacement: a.replacement
+    })) : Object.entries(resolveAlias).map(([find, replacement])=>({
+      find,
+      replacement
+    })) : [];
+  // Always resolve @openelement/core/style-sheet from workspace (core re-exports it)
+  if (WORKSPACE_ROOT) {
+    serializedAlias.push({
+      find: '@openelement/core/style-sheet',
+      replacement: join(WORKSPACE_ROOT, 'packages', 'core', 'src', 'style-sheet.ts')
+    });
+    serializedAlias.push({
+      find: /^@openelement\/router/,
+      replacement: join(WORKSPACE_ROOT, 'packages', 'router', 'src')
+    });
+  }
+  serializedAlias.sort((a, b)=>{
+    const findA = typeof a.find === 'string' ? a.find.length : 0;
+    const findB = typeof b.find === 'string' ? b.find.length : 0;
+    return findB - findA;
+  });
+  if (localIslands.length === 0 && packageIslandDecls.length === 0) {
+    log.info('No islands found - zero client JS output');
+    return;
+  }
+  const totalIslands = localIslands.length + packageIslandDecls.length;
+  log.info(`Building client bundle for ${totalIslands} island(s)...`);
+  // Generate client entry code
+  const islandEntries = [
+    ...localIslands.map((tagName, i)=>({
+        tagName,
+        modulePath: resolve(root, localIslandFiles[i] ? `${islandsDir}/${localIslandFiles[i]}` : `${islandsDir}/${tagName}.ts`).replace(/\\/g, '/'),
+        isPackage: false,
+        strategy: ctx.phase1.islandMeta[tagName]?.hydrate || ctx.phase3.upgradeStrategy || 'idle',
+        ssr: ctx.phase1.islandMeta[tagName]?.hydrate === 'only' ? false : ctx.phase1.islandMeta[tagName]?.ssr,
+        dsd: ctx.phase1.islandMeta[tagName]?.hydrate === 'only' ? false : ctx.phase1.islandMeta[tagName]?.dsd,
+        reason: ctx.phase1.islandMeta[tagName]?.reason
+      })),
+    ...packageIslandDecls.map((island)=>({
+        tagName: island.tagName,
+        modulePath: island.modulePath,
+        isPackage: true,
+        strategy: island.hydrate || ctx.phase3.upgradeStrategy || 'idle',
+        ssr: island.hydrate === 'only' ? false : island.ssr,
+        dsd: island.hydrate === 'only' ? false : island.dsd,
+        reason: island.reason
+      }))
+  ];
+  const clientEntryCode = generateClientEntry(islandEntries);
+  // Restore RegExp from serialized noExternal patterns
+  const noExternalPatterns = (ctx.phase3.ssrNoExternal || []).map((item)=>{
+    if (typeof item === 'string') return item;
+    if (item && typeof item === 'object' && item.__type === 'RegExp') {
+      return new RegExp(item.source, item.flags);
+    }
+    return item;
+  });
+  const clientOutDir = resolve(root, outDir, 'client');
+  const clientBase = ctx.phase3.base || '/';
+  const clientConfig = {
+    configFile: false,
+    root,
+    base: `${clientBase}client/`,
+    logLevel: 'warn',
+    // ADR-0057: JSX automatic runtime must be configured in the internal
+    // viteBuild() call — configFile:false means user's vite.config.ts is
+    // NOT read. Without this, esbuild defaults to classic React.createElement
+    // transform, producing {type, props, $$typeof} objects that DsdElement
+    // does not recognize (causes [object Object] rendering).
+    esbuild: {
+      jsx: 'automatic',
+      jsxImportSource: '@openelement/core'
+    },
+    build: {
+      outDir: clientOutDir,
+      emptyOutDir: true,
+      chunkSizeWarningLimit: 1500,
+      minify: 'oxc',
+      manifest: true,
+      rollupOptions: {
+        input: {
+          client: VIRTUAL_CLIENT_ENTRY_ID
+        },
+        output: {
+          format: 'esm',
+          entryFileNames: 'islands/[name].js',
+          chunkFileNames: 'islands/[name]-[hash].js',
+          manualChunks (id) {
+            if (id.includes(`/${islandsDir}/`)) {
+              const match = id.match(/\/([^/]+)\.(ts|js)$/);
+              if (match) return `island-${match[1]}`;
+            }
+            for (const island of packageIslandDecls){
+              if (id.includes(island.modulePath)) return `island-${island.tagName}`;
+            }
+          }
+        }
+      }
+    },
+    resolve: {
+      ...serializedAlias.length > 0 ? {
+        alias: serializedAlias
+      } : {},
+      extensions: [
+        '.ts',
+        '.tsx',
+        '.js',
+        '.jsx',
+        '.json'
+      ]
+    },
+    ssr: {
+      noExternal: noExternalPatterns.length > 0 ? noExternalPatterns : undefined
+    },
+    plugins: [
+      createOpenJsrPackageResolverPlugin({
+        workspaceRoot: WORKSPACE_ROOT,
+        version: getJsrPackageVersion(import.meta.url)
+      }),
+      {
+        name: 'open:virtual-client-entry',
+        resolveId (id) {
+          if (id === VIRTUAL_CLIENT_ENTRY_ID) return RESOLVED_CLIENT_ENTRY_ID;
+        },
+        load (id) {
+          if (id === RESOLVED_CLIENT_ENTRY_ID) return clientEntryCode;
+        }
+      },
+      {
+        name: 'open:deno-import-map-resolve',
+        enforce: 'pre',
+        async resolveId (id, importer) {
+          // Only handle bare specifiers (no relative imports, no absolute paths)
+          if (id.startsWith('.') || id.startsWith('/') || id.startsWith('file:')) {
+            return null;
+          }
+          // Try deno.json import map — walks up from root to find
+          // workspace-level deno.json as fallback for monorepo dev.
+          const result = lookupInDenoJson(id, root);
+          if (!result) return null;
+          // Only handle file:// and relative targets (workspace-local dev mappings).
+          // npm:, jsr: → return null, let node_modules handle them.
+          const resolved = convertImportMapTarget(result.target, result.denoJsonDir);
+          if (!resolved) return null;
+          return await this.resolve(resolved, importer, {
+            skipSelf: true
+          });
+        }
+      }
+    ]
+  };
+  try {
+    await viteBuild(clientConfig);
+    log.info('Client bundle built -> ' + clientOutDir);
+    const { printBuildManifest } = await import('../build-manifest.js');
+    printBuildManifest({
+      root,
+      outDir,
+      phase: 2
+    });
+  } catch (error) {
+    log.error(`Client build failed: ${formatError(error)}`);
+    throw error;
+  }
+}
+export { buildClient };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/adapter-vite/src/cli/build-client.ts"],"sourcesContent":["/**\n * @openelement/adapter-vite - CLI: Client Island Build\n *\n * Client build for Island components.\n * Produces dist/client/islands/*.js + manifest for SSG post-processing.\n *\n * ADR 0011: This module exports buildClient() 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 { build as viteBuild, type InlineConfig } from 'vite';\nimport { existsSync, readFileSync } from 'node:fs';\nimport { join, resolve } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport process from 'node:process';\nimport { generateClientEntry } from '@openelement/ssg';\nimport type { ClientIslandEntry } from '@openelement/protocol/ssg';\nimport type { OpenElementBuildContext } from '../build-context.js';\nimport { createOpenJsrPackageResolverPlugin } from '../ssg-package-resolver.js';\nimport { formatError } from '@openelement/core/errors';\nimport { createLogger } from '@openelement/core/logger';\n\nconst log = createLogger('ssg');\n\nconst VIRTUAL_CLIENT_ENTRY_ID = 'virtual:open-client-entry';\nconst RESOLVED_CLIENT_ENTRY_ID = '\\0' + VIRTUAL_CLIENT_ENTRY_ID;\nconst FALLBACK_openElement_VERSION = '0.23.0';\n\ntype ViteBuildOptionsWithManifest = NonNullable<InlineConfig['build']> & {\n  manifest?: boolean;\n};\n\ntype ViteInlineConfigWithManifest = Omit<InlineConfig, 'build'> & {\n  build?: ViteBuildOptionsWithManifest;\n};\n\n/** Workspace root derived from this module's location (packages/adapter-vite/src/cli/).\n * Only valid in local workspace (file:// import.meta.url). In JSR consumers, returns null. */\nconst WORKSPACE_ROOT: string | null = (() => {\n  if (!import.meta.url.startsWith('file:')) return null;\n  try {\n    return fileURLToPath(new URL('../../../..', import.meta.url)).replace(/\\\\/g, '/');\n  } catch {\n    return null;\n  }\n})();\n\nfunction getJsrPackageVersion(metaUrl: string): string {\n  const match = metaUrl.match(/\\/@openelement\\/adapter-vite\\/([^/]+)\\//);\n  return match?.[1] ?? FALLBACK_openElement_VERSION;\n}\n\n/**\n * Look up a bare specifier in a deno.json import map.\n * Walks up directory tree to find workspace-level deno.json as fallback.\n * Returns { target, denoJsonDir } so relative paths can be resolved correctly.\n */\nfunction lookupInDenoJson(\n  id: string,\n  root: string,\n): { target: string; denoJsonDir: string } | null {\n  const denoJsonDirs = new Set<string>();\n  let dir = resolve(root);\n\n  // Walk up from consumer root\n  while (!denoJsonDirs.has(dir)) {\n    denoJsonDirs.add(dir);\n    const found = tryDenoJsonDir(id, dir);\n    if (found) return found;\n    const parent = resolve(dir, '..');\n    if (parent === dir) break;\n    dir = parent;\n  }\n\n  // Also try workspace root (module-relative, for monorepo dev / testing)\n  if (WORKSPACE_ROOT && !denoJsonDirs.has(WORKSPACE_ROOT)) {\n    const found = tryDenoJsonDir(id, WORKSPACE_ROOT);\n    if (found) return found;\n  }\n\n  return null;\n}\n\n/** Check a single directory for a deno.json with the given import. */\nfunction tryDenoJsonDir(\n  id: string,\n  dir: string,\n): { target: string; denoJsonDir: string } | null {\n  const denoJsonPath = join(dir, 'deno.json');\n  if (!existsSync(denoJsonPath)) return null;\n  const raw = readFileSync(denoJsonPath, 'utf-8');\n  // Strip JSONC comments:\n  // - Line comments: // at start of line (after optional whitespace)\n  // - Block comments: /* ... */\n  // - Trailing commas (Deno JSONC allows them, JSON.parse does not)\n  const json = raw\n    .replace(/^\\s*\\/\\/.*$/gm, '')\n    .replace(/\\/\\*[\\s\\S]*?\\*\\//g, '')\n    .replace(/,\\s*([}\\]])/g, '$1');\n  let denoJson: Record<string, unknown>;\n  try {\n    denoJson = JSON.parse(json);\n  } catch {\n    return null; // Invalid JSON — skip this deno.json\n  }\n  const imports = denoJson.imports as Record<string, string> | undefined;\n  if (!imports) return null;\n  // Exact match\n  if (imports[id]) return { target: imports[id], denoJsonDir: dir };\n  // Prefix/subpath matching (trailing slash)\n  for (const [key, value] of Object.entries(imports)) {\n    if (key.endsWith('/') && id.startsWith(key)) {\n      return { target: value + id.slice(key.length), denoJsonDir: dir };\n    }\n  }\n  return null;\n}\n\n/**\n * Convert a Deno import map target to a resolvable Vite path.\n * - file:// URLs → absolute filesystem path\n * - Relative paths (./) → resolved relative to denoJsonDir\n * - npm:, jsr: → null (handled by node_modules)\n */\nfunction convertImportMapTarget(target: string, denoJsonDir: string): string | null {\n  if (target.startsWith('file://')) {\n    try {\n      return fileURLToPath(target).replace(/\\\\/g, '/');\n    } catch {\n      return null;\n    }\n  }\n  // Relative path — resolve relative to the deno.json directory\n  if (target.startsWith('./') || target.startsWith('../')) {\n    return resolve(denoJsonDir, target).replace(/\\\\/g, '/');\n  }\n  // npm:, jsr: — let Vite/Rolldown handle these normally\n  return null;\n}\n\nasync function buildClient(ctx: OpenElementBuildContext): Promise<void> {\n  const root = ctx.phase3.root || process.cwd();\n  const outDir = ctx.phase3.outDir || 'dist';\n  const islandsDir = ctx.phase3.islandsDir || 'app/islands';\n  const localIslands = ctx.phase1.islandTagNames || [];\n  const localIslandFiles = ctx.phase1.islandFiles || [];\n  const packageIslandDecls = ctx.phase1.packageIslandDecls || [];\n\n  // Aliases pre-generated by createOpenPlugin() and stored in ctx\n  const resolveAlias = ctx.phase1.userResolveAlias;\n  const serializedAlias = resolveAlias\n    ? (Array.isArray(resolveAlias)\n      ? resolveAlias.filter((a) => typeof a.find === 'string').map((a) => ({\n        find: a.find as string,\n        replacement: a.replacement,\n      }))\n      : Object.entries(resolveAlias).map(([find, replacement]) => ({ find, replacement })))\n    : [];\n\n  // Always resolve @openelement/core/style-sheet from workspace (core re-exports it)\n  if (WORKSPACE_ROOT) {\n    serializedAlias.push({\n      find: '@openelement/core/style-sheet',\n      replacement: join(WORKSPACE_ROOT, 'packages', 'core', 'src', 'style-sheet.ts'),\n    });\n    (serializedAlias as Array<{ find: string | RegExp; replacement: string }>).push({\n      find: /^@openelement\\/router/,\n      replacement: join(WORKSPACE_ROOT, 'packages', 'router', 'src'),\n    });\n  }\n  serializedAlias.sort((a, b) => {\n    const findA = typeof a.find === 'string' ? a.find.length : 0;\n    const findB = typeof b.find === 'string' ? b.find.length : 0;\n    return findB - findA;\n  });\n\n  if (localIslands.length === 0 && packageIslandDecls.length === 0) {\n    log.info('No islands found - zero client JS output');\n    return;\n  }\n\n  const totalIslands = localIslands.length + packageIslandDecls.length;\n  log.info(`Building client bundle for ${totalIslands} island(s)...`);\n\n  // Generate client entry code\n  const islandEntries: ClientIslandEntry[] = [\n    ...localIslands.map((tagName: string, i: number) => ({\n      tagName,\n      modulePath: resolve(\n        root,\n        localIslandFiles[i]\n          ? `${islandsDir}/${localIslandFiles[i]}`\n          : `${islandsDir}/${tagName}.ts`,\n      ).replace(/\\\\/g, '/'),\n      isPackage: false,\n      strategy: ctx.phase1.islandMeta[tagName]?.hydrate || ctx.phase3.upgradeStrategy || 'idle',\n      ssr: ctx.phase1.islandMeta[tagName]?.hydrate === 'only'\n        ? false\n        : ctx.phase1.islandMeta[tagName]?.ssr,\n      dsd: ctx.phase1.islandMeta[tagName]?.hydrate === 'only'\n        ? false\n        : ctx.phase1.islandMeta[tagName]?.dsd,\n      reason: ctx.phase1.islandMeta[tagName]?.reason,\n    })),\n    ...packageIslandDecls.map(\n      (island) => ({\n        tagName: island.tagName,\n        modulePath: island.modulePath,\n        isPackage: true,\n        strategy: island.hydrate || ctx.phase3.upgradeStrategy || 'idle',\n        ssr: island.hydrate === 'only' ? false : island.ssr,\n        dsd: island.hydrate === 'only' ? false : island.dsd,\n        reason: island.reason,\n      }),\n    ),\n  ];\n\n  const clientEntryCode = generateClientEntry(islandEntries);\n\n  // Restore RegExp from serialized noExternal patterns\n  const noExternalPatterns = (ctx.phase3.ssrNoExternal || []).map((item) => {\n    if (typeof item === 'string') return item;\n    if (item && typeof item === 'object' && (item as Record<string, unknown>).__type === 'RegExp') {\n      return new RegExp(\n        (item as { source: string; flags: string }).source,\n        (item as { source: string; flags: string }).flags,\n      );\n    }\n    return item;\n  });\n\n  const clientOutDir = resolve(root, outDir, 'client');\n  const clientBase = ctx.phase3.base || '/';\n  const clientConfig: ViteInlineConfigWithManifest = {\n    configFile: false,\n    root,\n    base: `${clientBase}client/`,\n    logLevel: 'warn',\n    // ADR-0057: JSX automatic runtime must be configured in the internal\n    // viteBuild() call — configFile:false means user's vite.config.ts is\n    // NOT read. Without this, esbuild defaults to classic React.createElement\n    // transform, producing {type, props, $$typeof} objects that DsdElement\n    // does not recognize (causes [object Object] rendering).\n    esbuild: {\n      jsx: 'automatic',\n      jsxImportSource: '@openelement/core',\n    },\n    build: {\n      outDir: clientOutDir,\n      emptyOutDir: true,\n      chunkSizeWarningLimit: 1500,\n      minify: 'oxc',\n      manifest: true,\n      rollupOptions: {\n        input: { client: VIRTUAL_CLIENT_ENTRY_ID },\n        output: {\n          format: 'esm',\n          entryFileNames: 'islands/[name].js',\n          chunkFileNames: 'islands/[name]-[hash].js',\n          manualChunks(id: string) {\n            if (id.includes(`/${islandsDir}/`)) {\n              const match = id.match(/\\/([^/]+)\\.(ts|js)$/);\n              if (match) return `island-${match[1]}`;\n            }\n            for (const island of packageIslandDecls) {\n              if (id.includes(island.modulePath)) return `island-${island.tagName}`;\n            }\n          },\n        },\n      },\n    },\n    resolve: {\n      ...(serializedAlias.length > 0 ? { alias: serializedAlias } : {}),\n      extensions: ['.ts', '.tsx', '.js', '.jsx', '.json'],\n    },\n    ssr: {\n      noExternal: (noExternalPatterns.length > 0 ? noExternalPatterns : undefined) as\n        | (string | RegExp)[]\n        | undefined,\n    },\n    plugins: [\n      createOpenJsrPackageResolverPlugin({\n        workspaceRoot: WORKSPACE_ROOT,\n        version: getJsrPackageVersion(import.meta.url),\n      }),\n      {\n        name: 'open:virtual-client-entry',\n        resolveId(id) {\n          if (id === VIRTUAL_CLIENT_ENTRY_ID) return RESOLVED_CLIENT_ENTRY_ID;\n        },\n        load(id) {\n          if (id === RESOLVED_CLIENT_ENTRY_ID) return clientEntryCode;\n        },\n      },\n      {\n        name: 'open:deno-import-map-resolve',\n        enforce: 'pre',\n        async resolveId(id, importer) {\n          // Only handle bare specifiers (no relative imports, no absolute paths)\n          if (id.startsWith('.') || id.startsWith('/') || id.startsWith('file:')) {\n            return null;\n          }\n\n          // Try deno.json import map — walks up from root to find\n          // workspace-level deno.json as fallback for monorepo dev.\n          const result = lookupInDenoJson(id, root);\n          if (!result) return null;\n\n          // Only handle file:// and relative targets (workspace-local dev mappings).\n          // npm:, jsr: → return null, let node_modules handle them.\n          const resolved = convertImportMapTarget(result.target, result.denoJsonDir);\n          if (!resolved) return null;\n\n          return await this.resolve(resolved, importer, { skipSelf: true });\n        },\n      },\n    ],\n  };\n\n  try {\n    await viteBuild(clientConfig);\n    log.info('Client bundle built -> ' + clientOutDir);\n\n    const { printBuildManifest } = await import('../build-manifest.js');\n    printBuildManifest({ root, outDir, phase: 2 });\n  } catch (error) {\n    log.error(`Client build failed: ${formatError(error)}`);\n    throw error;\n  }\n}\n\nexport { buildClient };\n"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,40 @@
+import type { FrameworkOptions, HydrationStrategy } from '@openelement/protocol/framework';
+import type { OpenElementPackageManifest } from '@openelement/protocol/manifest';
+import type { OpenElementBuildContext } from "../build-context.js";
+interface BuildSSGOptions {
+  root?: string;
+  outDir?: string;
+  routesDir?: string;
+  islandsDir?: string;
+  middleware?: FrameworkOptions['middleware'];
+  ssr?: FrameworkOptions['ssr'];
+  islandTagNames?: string[];
+  islandMeta?: Record<string, Partial<import('@openelement/protocol/ssg').IslandDecl>>;
+  packageManifests?: OpenElementPackageManifest[];
+  /** @security Injected as raw HTML without sanitization */ headExtras?: string;
+  allowHeadExtrasScripts?: boolean;
+  html?: {
+    lang?: string;
+    title?: string;
+  };
+  appShell?: FrameworkOptions['appShell'];
+  layouts?: FrameworkOptions['layouts'];
+  upgradeStrategy?: HydrationStrategy;
+  resolveAlias?: Record<string, string> | import('vite').Alias[];
+  base?: string;
+  /**
+   * View Transitions API configuration.
+   * When true (default), injects <meta name="view-transition" content="same-origin">
+   * into all HTML files for smooth cross-page animations in MPA navigation.
+   * Set to false to disable.
+   * @default true
+   */ viewTransition?: boolean;
+  /**
+   * Speculation Rules API configuration.
+   * Enables browser prefetch/prerender of pages before the user navigates.
+   * Can be a boolean (true = auto-generate from routes) or explicit rules.
+   */ speculation?: boolean | import('@openelement/protocol/ssg').SpeculationRulesOptions;
+  /** ADR-0047: Skip Deno pre-resolution, use regex fallback for external deps. */ skipPreResolution?: boolean;
+}
+declare function buildSSG(options: BuildSSGOptions | undefined, ctx: OpenElementBuildContext): Promise<void>;
+export { buildSSG };