@openelement/adapter-vite 0.41.0-alpha.1

package/src/plugin.js

@@ -0,0 +1,264 @@
+/**
+ * Extracted from index.ts in v0.22 (SOP-004: adapter-vite decomposition).
+ *
+ * This is the core build plugin implementation. It is NOT part of the
+ * public API. Use `openPipeline()` from the main entry instead.
+ *
+ * Internal only: called by openPipeline() and the @openelement/app umbrella.
+ */ import { join } from 'node:path';
+import process from 'node:process';
+import { formatError, OpenElementError } from '@openelement/core/errors';
+import { createLogger } from '@openelement/core/logger';
+const log = createLogger('adapter-vite');
+import honoDevServer from '@hono/vite-dev-server';
+import { OpenElementBuildContext } from './build-context.js';
+import { findWorkspaceRoot, generateWorkspaceAliases } from './workspace-alias.js';
+import { buildPlugin } from './build.js';
+import { generateHonoEntryCode } from '@openelement/ssg';
+import { buildHeadExtras } from './head-injection.js';
+import { islandTransformPlugin } from './island-transform.js';
+import { createGeneratedDataResolverPlugin } from './generated-data-resolver.js';
+import { detectAndClassifyCemPackages, fileToTagName, scanIslands, scanPackageManifests, scanRoutes } from '@openelement/ssg';
+import { createCoreResolvePlugin } from './subpath-resolver.js';
+import { mdxPlugin } from './plugin-mdx.js';
+function mergeAliasOptions(primary, fallback) {
+  if (!primary) return fallback ?? null;
+  if (!fallback) return primary;
+  const merged = [];
+  const append = (aliases)=>{
+    if (!aliases) return;
+    if (Array.isArray(aliases)) {
+      merged.push(...aliases);
+      return;
+    }
+    for (const [find, replacement] of Object.entries(aliases)){
+      merged.push({
+        find,
+        replacement
+      });
+    }
+  };
+  append(primary);
+  append(fallback);
+  return merged;
+}
+const OPTIONAL_PACKAGE_STUBS = {
+  '@openelement/content': 'export async function loadBlogData() { return { posts: [], basePath: "" }; }',
+  '@openelement/content/sitemap': 'export function generateSitemap() { return []; }',
+  '@openelement/app/i18n': 'export function loadI18nData() { return { locales: [], defaultLocale: "en" }; }'
+};
+export function optionalPackageStubsPlugin() {
+  return {
+    name: 'open:optional-package-stubs',
+    enforce: 'pre',
+    async resolveId (id) {
+      if (!(id in OPTIONAL_PACKAGE_STUBS)) return;
+      const resolved = await this.resolve(id, undefined, {
+        skipSelf: true
+      });
+      if (resolved) return null;
+      return `\0open:optional-stub:${id}`;
+    },
+    load (id) {
+      const prefix = '\0open:optional-stub:';
+      if (!id.startsWith(prefix)) return;
+      return OPTIONAL_PACKAGE_STUBS[id.slice(prefix.length)];
+    }
+  };
+}
+/**
+ * This is the core build plugin implementation. It is NOT part of the
+ * public API. Use `openPipeline()` from @openelement/adapter-vite instead.
+ *
+ * Internal only: called by openPipeline() and the @openelement/app umbrella.
+ * Jamstack: M=SSG+DSD, A=API Routes, J=Islands.
+ *
+ * @param options - Framework options
+ * @param externalCtx - Optional shared OpenElementBuildContext (used by openElement() umbrella)
+ * @internal
+ */ export function createOpenPlugin(options = {}, externalCtx) {
+  const metaUrl = import.meta.url;
+  // Build head extras (validated HTML fragments, stylesheets, scripts)
+  const { headExtras, allowHeadExtrasScripts } = buildHeadExtras(options);
+  const resolvedOptions = {
+    ...options,
+    routesDir: options.routesDir || 'app/routes',
+    islandsDir: options.islandsDir || 'app/islands',
+    componentsDir: options.componentsDir || 'app/components',
+    headExtras,
+    allowHeadExtrasScripts
+  };
+  const ctx = externalCtx || new OpenElementBuildContext(resolvedOptions);
+  // Pre-generate workspace aliases (sync, once, cached in ctx).
+  // Phase 1 config, Phase 2 client build, and Phase 3 SSG build
+  // all read ctx.phase1.userResolveAlias - zero redundant generation.
+  try {
+    const wsRoot = findWorkspaceRoot(process.cwd());
+    if (wsRoot) {
+      ctx.phase1.userResolveAlias = generateWorkspaceAliases(wsRoot);
+      log.info(`Auto-generated ${ctx.phase1.userResolveAlias.length} resolve alias(es) from workspace`);
+    }
+  } catch  {
+    log.debug('Workspace not available - aliases stay null');
+  }
+  const VIRTUAL_ENTRY_ID = 'virtual:open-hono-entry';
+  const RESOLVED_ENTRY_ID = '\0' + VIRTUAL_ENTRY_ID;
+  const VIRTUAL_BUILD_TRIGGER_ID = 'virtual:open-build-trigger';
+  const RESOLVED_BUILD_TRIGGER_ID = '\0' + VIRTUAL_BUILD_TRIGGER_ID;
+  function generateEntry(routes, islandTagNames = [], packageManifests = [], islandFiles = []) {
+    return generateHonoEntryCode(routes, {
+      routesDir: resolvedOptions.routesDir,
+      islandsDir: resolvedOptions.islandsDir,
+      componentsDir: resolvedOptions.componentsDir,
+      middleware: resolvedOptions.middleware,
+      islandTagNames,
+      islandFiles,
+      islandMeta: ctx.phase1.islandMeta,
+      packageManifests,
+      headExtras: resolvedOptions.headExtras,
+      allowHeadExtrasScripts,
+      html: resolvedOptions.html,
+      upgradeStrategy: resolvedOptions.island?.upgradeStrategy || 'idle',
+      clientOnlyTags: [],
+      appShell: resolvedOptions.appShell,
+      layouts: resolvedOptions.layouts
+    });
+  }
+  const corePlugin = {
+    name: 'open:core',
+    config (userConfig) {
+      if (userConfig.resolve?.alias) {
+        ctx.phase1.userResolveAlias = mergeAliasOptions(userConfig.resolve.alias, ctx.phase1.userResolveAlias);
+      }
+      const aliases = ctx.phase1.userResolveAlias;
+      return {
+        resolve: aliases ? {
+          alias: aliases
+        } : undefined,
+        build: {
+          // The generated virtual entry intentionally contains the whole route graph.
+          // Keep the budget explicit so Vite does not report it as an unexpected warning.
+          chunkSizeWarningLimit: 1500,
+          rollupOptions: {
+            input: [
+              VIRTUAL_BUILD_TRIGGER_ID
+            ]
+          }
+        }
+      };
+    },
+    configResolved (cfg) {
+      if (cfg.resolve?.alias && !ctx.phase1.userResolveAlias) {
+        ctx.phase1.userResolveAlias = cfg.resolve.alias;
+      }
+      // v0.14.6: Generate placeholder entry code with empty routes in configResolved.
+      // This is a Vite requirement - the virtual entry must exist before buildStart().
+      // The real entry with actual routes is generated in buildStart() which runs later.
+      ctx.phase1.honoEntryCode = generateEntry([], ctx.phase1.islandTagNames, ctx.phase1.packageManifests, ctx.phase1.islandFiles);
+    },
+    async buildStart () {
+      ctx.reset();
+      try {
+        const routes = await scanRoutes(resolvedOptions.routesDir);
+        const islandsRoot = join(process.cwd(), resolvedOptions.islandsDir || 'app/islands');
+        const islandFiles = await scanIslands(islandsRoot);
+        ctx.phase1.islandTagNames = islandFiles.map((f)=>fileToTagName(f));
+        ctx.phase1.islandFiles = islandFiles;
+        const { scanIslandMeta } = await import('@openelement/ssg');
+        ctx.phase1.islandMeta = await scanIslandMeta(islandsRoot, islandFiles);
+        if (resolvedOptions.packageIslands && resolvedOptions.packageIslands.length > 0) {
+          ctx.phase1.packageManifests = await scanPackageManifests(resolvedOptions.packageIslands);
+          if (ctx.phase1.packageManifests.length > 0) {
+            // Extract island declarations from manifests
+            ctx.phase1.packageIslandDecls = ctx.phase1.packageManifests.flatMap((pkg)=>pkg.declarations.filter((d)=>d.openElement?.module).map((d)=>({
+                  tagName: d.tagName,
+                  modulePath: d.openElement.module,
+                  isPackage: true,
+                  hydrate: d.openElement?.hydrate,
+                  ssr: d.openElement?.hydrate === 'only' ? false : d.openElement?.ssr,
+                  dsd: d.openElement?.hydrate === 'only' ? false : d.openElement?.dsd
+                })));
+            log.info(`Package islands: ${ctx.phase1.packageIslandDecls.map((i)=>i.tagName).join(', ')}`);
+          }
+        }
+        // Cache routes for lazy load() regeneration (ctx.blogOptions may not
+        // be set yet - openContent() buildStart() runs after this one).
+        ctx.phase1.cachedRoutes = routes;
+        ctx.phase1.honoEntryCode = generateEntry(routes, ctx.phase1.islandTagNames, ctx.phase1.packageManifests, ctx.phase1.islandFiles);
+        const { buildEntryDescriptor } = await import('@openelement/ssg');
+        // v0.18.0: CEM auto-detection - scan node_modules for custom-elements.json
+        // without importing or executing any package code.
+        try {
+          const nodeModulesDir = join(process.cwd(), 'node_modules');
+          ctx.phase1.cemClassifications = await detectAndClassifyCemPackages(nodeModulesDir);
+          if (ctx.phase1.cemClassifications.length > 0) {
+            log.info(`CEM auto-detection: classified ${ctx.phase1.cemClassifications.length} component(s) from node_modules`);
+          }
+        } catch (err) {
+          // CEM detection is best-effort - never fail the build
+          log.debug(`CEM auto-detection failed (non-fatal): ${formatError(err)}`);
+          ctx.phase1.cemClassifications = [];
+        }
+        ctx.phase1.ssrAdmissionPlan = buildEntryDescriptor(routes, {
+          routesDir: resolvedOptions.routesDir,
+          islandsDir: resolvedOptions.islandsDir,
+          islandTagNames: ctx.phase1.islandTagNames,
+          islandFiles: ctx.phase1.islandFiles,
+          islandMeta: ctx.phase1.islandMeta,
+          packageManifests: ctx.phase1.packageManifests,
+          cemClassifications: ctx.phase1.cemClassifications,
+          clientOnlyTags: [],
+          appShell: resolvedOptions.appShell,
+          layouts: resolvedOptions.layouts
+        }).ssrAdmissionPlan;
+        const pageCount = routes.filter((r)=>r.type === 'page' && !r.special).length;
+        const apiCount = routes.filter((r)=>r.type === 'api' && !r.special).length;
+        const totalIslands = ctx.phase1.islandTagNames.length + ctx.phase1.packageIslandDecls.length;
+        log.info(`Routes: ${pageCount} page(s), ${apiCount} API route(s), ` + `${totalIslands} island(s) - openElement Architecture`);
+      } catch (err) {
+        throw new OpenElementError(`Route scan failed: ${formatError(err)}`, {
+          code: 'ROUTE_SCAN_ERROR',
+          statusCode: 500,
+          recoverable: false
+        });
+      }
+    }
+  };
+  const virtualEntryPlugin = {
+    name: 'open:virtual-entry',
+    resolveId (id) {
+      if (id === VIRTUAL_ENTRY_ID) return RESOLVED_ENTRY_ID;
+      if (id === VIRTUAL_BUILD_TRIGGER_ID) return RESOLVED_BUILD_TRIGGER_ID;
+    },
+    load (id) {
+      if (id === RESOLVED_BUILD_TRIGGER_ID) {
+        return 'export default null;';
+      }
+      if (id === RESOLVED_ENTRY_ID) {
+        // Always regenerate to pick up late-settled ctx fields (e.g., blogOptions
+        // from openContent() buildStart() which runs after open:core buildStart()).
+        // In dev mode, load() is called lazily by the SSR runner, so all buildStart()
+        // hooks have completed by this point.
+        return generateEntry(ctx.phase1.cachedRoutes || [], ctx.phase1.islandTagNames, ctx.phase1.packageManifests, ctx.phase1.islandFiles);
+      }
+    }
+  };
+  const devServerPlugin = honoDevServer({
+    entry: VIRTUAL_ENTRY_ID,
+    injectClientScript: true
+  });
+  return [
+    mdxPlugin(),
+    corePlugin,
+    createGeneratedDataResolverPlugin({
+      root: process.cwd()
+    }),
+    createCoreResolvePlugin(metaUrl),
+    optionalPackageStubsPlugin(),
+    virtualEntryPlugin,
+    devServerPlugin,
+    islandTransformPlugin(resolvedOptions.islandsDir),
+    buildPlugin(resolvedOptions, ctx)
+  ];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/adapter-vite/src/plugin.ts"],"sourcesContent":["/**\n * Extracted from index.ts in v0.22 (SOP-004: adapter-vite decomposition).\n *\n * This is the core build plugin implementation. It is NOT part of the\n * public API. Use `openPipeline()` from the main entry instead.\n *\n * Internal only: called by openPipeline() and the @openelement/app umbrella.\n */\n\nimport type { Alias, Plugin } from 'vite';\nimport type {\n  FrameworkOptions,\n  HydrationStrategy,\n  RouteEntry,\n} from '@openelement/protocol/framework';\nimport type { OpenElementPackageManifest } from '@openelement/protocol/manifest';\n\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport { formatError, OpenElementError } from '@openelement/core/errors';\nimport { createLogger } from '@openelement/core/logger';\n\nconst log = createLogger('adapter-vite');\n\nimport honoDevServer from '@hono/vite-dev-server';\nimport { OpenElementBuildContext } from './build-context.js';\nimport { findWorkspaceRoot, generateWorkspaceAliases } from './workspace-alias.js';\nimport { buildPlugin } from './build.js';\nimport { generateHonoEntryCode } from '@openelement/ssg';\nimport { buildHeadExtras } from './head-injection.js';\nimport { islandTransformPlugin } from './island-transform.js';\nimport { createGeneratedDataResolverPlugin } from './generated-data-resolver.js';\nimport {\n  detectAndClassifyCemPackages,\n  fileToTagName,\n  scanIslands,\n  scanPackageManifests,\n  scanRoutes,\n} from '@openelement/ssg';\nimport { createCoreResolvePlugin } from './subpath-resolver.js';\nimport { mdxPlugin } from './plugin-mdx.js';\n\ntype LessAliasOptions = Record<string, string> | Alias[] | null | undefined;\n\nfunction mergeAliasOptions(\n  primary: LessAliasOptions,\n  fallback: LessAliasOptions,\n): Record<string, string> | Alias[] | null {\n  if (!primary) return fallback ?? null;\n  if (!fallback) return primary;\n\n  const merged: Alias[] = [];\n  const append = (aliases: LessAliasOptions): void => {\n    if (!aliases) return;\n    if (Array.isArray(aliases)) {\n      merged.push(...aliases);\n      return;\n    }\n    for (const [find, replacement] of Object.entries(aliases)) {\n      merged.push({ find, replacement });\n    }\n  };\n\n  append(primary);\n  append(fallback);\n  return merged;\n}\n\nconst OPTIONAL_PACKAGE_STUBS: Record<string, string> = {\n  '@openelement/content':\n    'export async function loadBlogData() { return { posts: [], basePath: \"\" }; }',\n  '@openelement/content/sitemap': 'export function generateSitemap() { return []; }',\n  '@openelement/app/i18n':\n    'export function loadI18nData() { return { locales: [], defaultLocale: \"en\" }; }',\n};\n\nexport function optionalPackageStubsPlugin(): Plugin {\n  return {\n    name: 'open:optional-package-stubs',\n    enforce: 'pre',\n    async resolveId(id) {\n      if (!(id in OPTIONAL_PACKAGE_STUBS)) return;\n      const resolved = await this.resolve(id, undefined, { skipSelf: true });\n      if (resolved) return null;\n      return `\\0open:optional-stub:${id}`;\n    },\n    load(id) {\n      const prefix = '\\0open:optional-stub:';\n      if (!id.startsWith(prefix)) return;\n      return OPTIONAL_PACKAGE_STUBS[id.slice(prefix.length)];\n    },\n  };\n}\n\n/**\n * This is the core build plugin implementation. It is NOT part of the\n * public API. Use `openPipeline()` from @openelement/adapter-vite instead.\n *\n * Internal only: called by openPipeline() and the @openelement/app umbrella.\n * Jamstack: M=SSG+DSD, A=API Routes, J=Islands.\n *\n * @param options - Framework options\n * @param externalCtx - Optional shared OpenElementBuildContext (used by openElement() umbrella)\n * @internal\n */\nexport function createOpenPlugin(\n  options: FrameworkOptions = {},\n  externalCtx?: OpenElementBuildContext,\n): Plugin[] {\n  const metaUrl = import.meta.url;\n\n  // Build head extras (validated HTML fragments, stylesheets, scripts)\n  const { headExtras, allowHeadExtrasScripts } = buildHeadExtras(options);\n\n  const resolvedOptions: FrameworkOptions & {\n    allowHeadExtrasScripts?: boolean;\n  } = {\n    ...options,\n    routesDir: options.routesDir || 'app/routes',\n    islandsDir: options.islandsDir || 'app/islands',\n    componentsDir: options.componentsDir || 'app/components',\n    headExtras,\n    allowHeadExtrasScripts,\n  };\n\n  const ctx = externalCtx || new OpenElementBuildContext(resolvedOptions);\n\n  // Pre-generate workspace aliases (sync, once, cached in ctx).\n  // Phase 1 config, Phase 2 client build, and Phase 3 SSG build\n  // all read ctx.phase1.userResolveAlias - zero redundant generation.\n  try {\n    const wsRoot = findWorkspaceRoot(process.cwd());\n    if (wsRoot) {\n      ctx.phase1.userResolveAlias = generateWorkspaceAliases(wsRoot);\n      log.info(\n        `Auto-generated ${\n          (ctx.phase1.userResolveAlias as Array<unknown>).length\n        } resolve alias(es) from workspace`,\n      );\n    }\n  } catch {\n    log.debug('Workspace not available - aliases stay null');\n  }\n\n  const VIRTUAL_ENTRY_ID = 'virtual:open-hono-entry';\n  const RESOLVED_ENTRY_ID = '\\0' + VIRTUAL_ENTRY_ID;\n  const VIRTUAL_BUILD_TRIGGER_ID = 'virtual:open-build-trigger';\n  const RESOLVED_BUILD_TRIGGER_ID = '\\0' + VIRTUAL_BUILD_TRIGGER_ID;\n\n  function generateEntry(\n    routes: RouteEntry[],\n    islandTagNames: string[] = [],\n    packageManifests: OpenElementPackageManifest[] = [],\n    islandFiles: string[] = [],\n  ): string {\n    return generateHonoEntryCode(routes, {\n      routesDir: resolvedOptions.routesDir,\n      islandsDir: resolvedOptions.islandsDir,\n      componentsDir: resolvedOptions.componentsDir,\n      middleware: resolvedOptions.middleware,\n      islandTagNames,\n      islandFiles,\n      islandMeta: ctx.phase1.islandMeta,\n      packageManifests,\n      headExtras: resolvedOptions.headExtras,\n      allowHeadExtrasScripts,\n      html: resolvedOptions.html,\n      upgradeStrategy: resolvedOptions.island?.upgradeStrategy || 'idle',\n      clientOnlyTags: [],\n      appShell: resolvedOptions.appShell,\n      layouts: resolvedOptions.layouts,\n    });\n  }\n\n  const corePlugin: Plugin = {\n    name: 'open:core',\n\n    config(userConfig) {\n      if (userConfig.resolve?.alias) {\n        ctx.phase1.userResolveAlias = mergeAliasOptions(\n          userConfig.resolve.alias as Record<string, string> | Alias[],\n          ctx.phase1.userResolveAlias,\n        );\n      }\n\n      const aliases = ctx.phase1.userResolveAlias as\n        | Alias[]\n        | Record<string, string>\n        | null;\n\n      return {\n        resolve: aliases ? { alias: aliases } : undefined,\n        build: {\n          // The generated virtual entry intentionally contains the whole route graph.\n          // Keep the budget explicit so Vite does not report it as an unexpected warning.\n          chunkSizeWarningLimit: 1500,\n          rollupOptions: {\n            input: [VIRTUAL_BUILD_TRIGGER_ID],\n          },\n        },\n      };\n    },\n\n    configResolved(cfg) {\n      if (cfg.resolve?.alias && !ctx.phase1.userResolveAlias) {\n        ctx.phase1.userResolveAlias = cfg.resolve.alias;\n      }\n      // v0.14.6: Generate placeholder entry code with empty routes in configResolved.\n      // This is a Vite requirement - the virtual entry must exist before buildStart().\n      // The real entry with actual routes is generated in buildStart() which runs later.\n      ctx.phase1.honoEntryCode = generateEntry(\n        [],\n        ctx.phase1.islandTagNames,\n        ctx.phase1.packageManifests,\n        ctx.phase1.islandFiles,\n      );\n    },\n\n    async buildStart() {\n      ctx.reset();\n\n      try {\n        const routes = await scanRoutes(resolvedOptions.routesDir!);\n\n        const islandsRoot = join(\n          process.cwd(),\n          resolvedOptions.islandsDir || 'app/islands',\n        );\n        const islandFiles = await scanIslands(islandsRoot);\n        ctx.phase1.islandTagNames = islandFiles.map((f) => fileToTagName(f));\n        ctx.phase1.islandFiles = islandFiles;\n        const { scanIslandMeta } = await import('@openelement/ssg');\n        ctx.phase1.islandMeta = await scanIslandMeta(islandsRoot, islandFiles);\n\n        if (\n          resolvedOptions.packageIslands &&\n          resolvedOptions.packageIslands.length > 0\n        ) {\n          ctx.phase1.packageManifests = await scanPackageManifests(\n            resolvedOptions.packageIslands,\n          );\n          if (ctx.phase1.packageManifests.length > 0) {\n            // Extract island declarations from manifests\n            ctx.phase1.packageIslandDecls = ctx.phase1.packageManifests.flatMap((pkg) =>\n              pkg.declarations\n                .filter((d) => d.openElement?.module)\n                .map((d) => ({\n                  tagName: d.tagName,\n                  modulePath: d.openElement!.module!,\n                  isPackage: true,\n                  hydrate: d.openElement?.hydrate as HydrationStrategy | undefined,\n                  ssr: d.openElement?.hydrate === 'only' ? false : d.openElement?.ssr,\n                  dsd: d.openElement?.hydrate === 'only' ? false : d.openElement?.dsd,\n                }))\n            );\n            log.info(\n              `Package islands: ${ctx.phase1.packageIslandDecls.map((i) => i.tagName).join(', ')}`,\n            );\n          }\n        }\n\n        // Cache routes for lazy load() regeneration (ctx.blogOptions may not\n        // be set yet - openContent() buildStart() runs after this one).\n        ctx.phase1.cachedRoutes = routes;\n\n        ctx.phase1.honoEntryCode = generateEntry(\n          routes,\n          ctx.phase1.islandTagNames,\n          ctx.phase1.packageManifests,\n          ctx.phase1.islandFiles,\n        );\n        const { buildEntryDescriptor } = await import('@openelement/ssg');\n\n        // v0.18.0: CEM auto-detection - scan node_modules for custom-elements.json\n        // without importing or executing any package code.\n        try {\n          const nodeModulesDir = join(process.cwd(), 'node_modules');\n          ctx.phase1.cemClassifications = await detectAndClassifyCemPackages(nodeModulesDir);\n          if (ctx.phase1.cemClassifications.length > 0) {\n            log.info(\n              `CEM auto-detection: classified ${ctx.phase1.cemClassifications.length} component(s) from node_modules`,\n            );\n          }\n        } catch (err) {\n          // CEM detection is best-effort - never fail the build\n          log.debug(\n            `CEM auto-detection failed (non-fatal): ${formatError(err)}`,\n          );\n          ctx.phase1.cemClassifications = [];\n        }\n\n        ctx.phase1.ssrAdmissionPlan = buildEntryDescriptor(routes, {\n          routesDir: resolvedOptions.routesDir,\n          islandsDir: resolvedOptions.islandsDir,\n          islandTagNames: ctx.phase1.islandTagNames,\n          islandFiles: ctx.phase1.islandFiles,\n          islandMeta: ctx.phase1.islandMeta,\n          packageManifests: ctx.phase1.packageManifests,\n          cemClassifications: ctx.phase1.cemClassifications,\n          clientOnlyTags: [],\n          appShell: resolvedOptions.appShell,\n          layouts: resolvedOptions.layouts,\n        }).ssrAdmissionPlan;\n        const pageCount = routes.filter(\n          (r) => r.type === 'page' && !r.special,\n        ).length;\n        const apiCount = routes.filter(\n          (r) => r.type === 'api' && !r.special,\n        ).length;\n        const totalIslands = ctx.phase1.islandTagNames.length +\n          ctx.phase1.packageIslandDecls.length;\n        log.info(\n          `Routes: ${pageCount} page(s), ${apiCount} API route(s), ` +\n            `${totalIslands} island(s) - openElement Architecture`,\n        );\n      } catch (err) {\n        throw new OpenElementError(`Route scan failed: ${formatError(err)}`, {\n          code: 'ROUTE_SCAN_ERROR',\n          statusCode: 500,\n          recoverable: false,\n        });\n      }\n    },\n  };\n\n  const virtualEntryPlugin: Plugin = {\n    name: 'open:virtual-entry',\n\n    resolveId(id) {\n      if (id === VIRTUAL_ENTRY_ID) return RESOLVED_ENTRY_ID;\n      if (id === VIRTUAL_BUILD_TRIGGER_ID) return RESOLVED_BUILD_TRIGGER_ID;\n    },\n\n    load(id) {\n      if (id === RESOLVED_BUILD_TRIGGER_ID) {\n        return 'export default null;';\n      }\n      if (id === RESOLVED_ENTRY_ID) {\n        // Always regenerate to pick up late-settled ctx fields (e.g., blogOptions\n        // from openContent() buildStart() which runs after open:core buildStart()).\n        // In dev mode, load() is called lazily by the SSR runner, so all buildStart()\n        // hooks have completed by this point.\n        return generateEntry(\n          ctx.phase1.cachedRoutes || [],\n          ctx.phase1.islandTagNames,\n          ctx.phase1.packageManifests,\n          ctx.phase1.islandFiles,\n        );\n      }\n    },\n  };\n\n  const devServerPlugin = honoDevServer({\n    entry: VIRTUAL_ENTRY_ID,\n    injectClientScript: true,\n  }) as Plugin;\n\n  return [\n    mdxPlugin(),\n    corePlugin,\n    createGeneratedDataResolverPlugin({ root: process.cwd() }),\n    createCoreResolvePlugin(metaUrl),\n    optionalPackageStubsPlugin(),\n    virtualEntryPlugin,\n    devServerPlugin,\n    islandTransformPlugin(resolvedOptions.islandsDir!),\n    buildPlugin(resolvedOptions, ctx),\n  ];\n}\n"],"names":[],"mappings":"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"}

package/src/ssg-package-resolver.js

@@ -0,0 +1,256 @@
+import { Deno } from "@deno/shim-deno";
+import { readFile } from 'node:fs/promises';
+import { formatError } from '@openelement/core/errors';
+const VIRTUAL_OPENELEMENT_PACKAGE_PREFIX = '\0openelement:ssg-pkg/';
+// Packages resolved by this plugin for JSR consumer SSG builds.
+// Retained optional packages (content, i18n) are handled by optionalPackageStubsPlugin
+// in build-ssg.ts instead. The resolver must NOT intercept them, because it runs
+// enforce: 'pre' and would prevent the stubs plugin from providing empty stubs
+// when packages are absent.
+const DEFAULT_OPENELEMENT_PACKAGES = new Set([
+  'adapter-vite',
+  'app',
+  'core',
+  'create',
+  'element',
+  'router',
+  'signal',
+  'ui'
+]);
+const OPENELEMENT_EXPORT_FILES = {
+  'adapter-vite': {
+    '.': 'src/index.ts',
+    'build-context': 'src/build-context.ts',
+    'head-injection': 'src/head-injection.ts',
+    'nitro-mount': 'src/nitro-mount.ts',
+    plugin: 'src/plugin.ts',
+    'subpath-resolver': 'src/subpath-resolver.ts',
+    'generated-data-resolver': 'src/generated-data-resolver.ts',
+    'plugin-mdx': 'src/plugin-mdx.ts',
+    'cli/build': 'src/cli/build.ts',
+    'cli/build-client': 'src/cli/build-client.ts',
+    'cli/build-ssg': 'src/cli/build-ssg.ts'
+  },
+  app: {
+    '.': 'src/index.ts',
+    i18n: 'src/i18n.ts',
+    'i18n-plugin': 'src/i18n-plugin.ts',
+    preact: 'src/preact.ts',
+    vite: 'src/vite.ts'
+  },
+  content: {
+    '.': 'src/index.ts',
+    'blog-data': 'src/blog/blog-data.ts',
+    mdx: 'src/mdx/compile.ts',
+    nav: 'src/nav/scanner.ts',
+    'nav-data': 'src/nav/writer.ts',
+    sitemap: 'src/sitemap/generator.ts'
+  },
+  core: {
+    '.': 'src/index.ts',
+    context: 'src/context.ts',
+    data: 'src/data.ts',
+    'dsd-hydration': 'src/dsd-hydration.ts',
+    errors: 'src/errors.ts',
+    'html-escape': 'src/html-escape.ts',
+    'island-transform': 'src/island-transform.ts',
+    isr: 'src/isr.ts',
+    'isr-runtime': 'src/isr-runtime.ts',
+    'jsx-runtime': 'src/jsx-runtime.ts',
+    'jsx-dev-runtime': 'src/jsx-runtime.ts',
+    logger: 'src/logger.ts',
+    prop: 'src/prop.ts',
+    'render-dsd-stream': 'src/render-dsd-stream.ts',
+    runtime: 'src/runtime.ts',
+    'signal-context': 'src/signal-context.ts',
+    'style-sheet': 'src/style-sheet.ts',
+    'tag-utils': 'src/tag-utils.ts'
+  },
+  create: {
+    '.': 'cli.ts'
+  },
+  element: {
+    '.': 'src/index.ts'
+  },
+  router: {
+    '.': 'src/data-context.ts',
+    'data-context': 'src/data-context.ts',
+    i18n: 'src/i18n.ts'
+  },
+  signal: {
+    '.': 'src/index.ts',
+    framework: 'src/framework.ts',
+    'preact-engine': 'src/preact-engine.ts'
+  },
+  ssg: {
+    '.': 'src/index.ts'
+  },
+  ui: {
+    '.': 'src/index.ts',
+    'open-button': 'src/open-button.tsx',
+    'open-callout': 'src/open-callout.tsx',
+    'open-card': 'src/open-card.tsx',
+    'open-code-block': 'src/open-code-block.tsx',
+    'open-dialog': 'src/open-dialog.tsx',
+    'open-dropdown': 'src/open-dropdown.tsx',
+    'open-hero-ping': 'src/open-hero-ping.tsx',
+    'open-input': 'src/open-input.tsx',
+    'open-layout': 'src/open-layout.tsx',
+    'open-modal': 'src/open-modal.tsx',
+    'open-props-tokens': 'src/open-props-tokens.ts',
+    'open-props-tokens.js': 'src/open-props-tokens.ts',
+    'open-step-card': 'src/open-step-card.tsx',
+    'open-tabs': 'src/open-tabs.tsx',
+    'open-theme-toggle': 'src/open-theme-toggle.tsx',
+    'open-badge': 'src/open-badge.tsx',
+    'open-brand-mark': 'src/open-brand-mark.tsx',
+    'open-lab-panel': 'src/open-lab-panel.tsx',
+    'open-lab-stage': 'src/open-lab-stage.tsx',
+    'open-standards-visual': 'src/open-standards-visual.tsx',
+    'daisy-classes': 'src/daisy-classes.ts',
+    'daisy-classes.js': 'src/daisy-classes.ts'
+  }
+};
+export function parseOpenPackageSpecifier(id) {
+  const bare = id.match(/^@openelement\/([^/@]+)(?:\/(.+))?$/);
+  if (bare) return {
+    packageName: bare[1],
+    subpath: bare[2] ?? '.'
+  };
+  const jsr = id.match(/^jsr:@openelement\/([^/@]+)(?:@([^/]+))?(?:\/(.+))?$/);
+  if (jsr) {
+    return {
+      packageName: jsr[1],
+      range: jsr[2],
+      subpath: jsr[3] ?? '.'
+    };
+  }
+  return null;
+}
+export function resolveOpenPackageExport(packageName, subpath) {
+  const exports = OPENELEMENT_EXPORT_FILES[packageName];
+  if (!exports) {
+    throw new Error(`[openElement/SSG] Unknown openElement package: @openelement/${packageName}`);
+  }
+  const normalized = normalizeSubpath(subpath);
+  const file = exports[normalized] ?? (normalized.endsWith('.js') ? exports[normalized.replace(/\.js$/, '')] : undefined);
+  if (file) return file;
+  throw new Error(`[openElement/SSG] Unknown @openelement/${packageName} export subpath: ${subpath}`);
+}
+export function toVirtualOpenPackageId(packageName, sourcePath) {
+  return `${VIRTUAL_OPENELEMENT_PACKAGE_PREFIX}${packageName}/${sourcePath}`;
+}
+export function resolveVirtualOpenPackageRelative(id, importer) {
+  if (!importer.startsWith(VIRTUAL_OPENELEMENT_PACKAGE_PREFIX)) return null;
+  if (!id.startsWith('./') && !id.startsWith('../')) return null;
+  const importerPath = importer.slice(VIRTUAL_OPENELEMENT_PACKAGE_PREFIX.length);
+  const [packageName, ...pathParts] = importerPath.split('/');
+  const base = pathParts.slice(0, -1);
+  const parts = [
+    ...base,
+    ...id.split('/')
+  ];
+  const resolved = [];
+  for (const part of parts){
+    if (!part || part === '.') continue;
+    if (part === '..') resolved.pop();
+    else resolved.push(part);
+  }
+  return toVirtualOpenPackageId(packageName, resolveSourcePathExtension(packageName, resolved.join('/')));
+}
+export function createOpenJsrPackageResolverPlugin(options) {
+  const fetchSource = options.fetchSource ?? fetch;
+  const registry = options.registry ?? (typeof import.meta.url === 'string' && import.meta.url.startsWith('https://') ? 'jsr' : 'npm');
+  const isNpmMode = registry === 'npm';
+  return {
+    name: 'open:ssg-package-resolve',
+    enforce: 'pre',
+    transform (code) {
+      if (!code.includes('npm:')) return null;
+      const rewritten = rewriteNpmSpecifiers(code);
+      if (rewritten === code) return null;
+      return {
+        code: rewritten,
+        map: null
+      };
+    },
+    resolveId (id, importer) {
+      if (options.workspaceRoot) return null;
+      if (isNpmMode) return null;
+      if (hasExactUserAlias(id, options.userAliases)) return null;
+      const spec = parseOpenPackageSpecifier(id);
+      if (spec) {
+        if (!DEFAULT_OPENELEMENT_PACKAGES.has(spec.packageName)) return null;
+        return toVirtualOpenPackageId(spec.packageName, resolveOpenPackageExport(spec.packageName, spec.subpath));
+      }
+      return resolveVirtualOpenPackageRelative(id, importer ?? '');
+    },
+    async load (id) {
+      if (options.workspaceRoot) return null;
+      if (isNpmMode) return null;
+      if (!id.startsWith(VIRTUAL_OPENELEMENT_PACKAGE_PREFIX)) return null;
+      const [packageName, ...pathParts] = id.slice(VIRTUAL_OPENELEMENT_PACKAGE_PREFIX.length).split('/');
+      const filePath = pathParts.join('/');
+      if (options.localPackageRoot) {
+        const localPath = `${options.localPackageRoot}/packages/${packageName}/${filePath}`;
+        try {
+          return options.readLocalSource ? options.readLocalSource(localPath) : typeof Deno !== 'undefined' ? await Deno.readTextFile(localPath) : await readFile(localPath, 'utf-8');
+        } catch (error) {
+          throw new Error(`[openElement/SSG] Failed to read local @openelement/${packageName}/${filePath} ` + `from ${localPath}: ${formatError(error)}`);
+        }
+      }
+      const url = `https://jsr.io/@openelement/${packageName}/${options.version}/${filePath}`;
+      const resp = await fetchSource(url);
+      if (!resp.ok) {
+        throw new Error(`[openElement/SSG] Failed to fetch @openelement/${packageName}/${filePath} ` + `from ${url}: HTTP ${resp.status}`);
+      }
+      const source = await resp.text();
+      // JSR rewrites bare npm specifiers (e.g. 'marked') to 'npm:marked@x.y.z'.
+      // Vite/Rolldown does not understand Deno's 'npm:' scheme, so we must
+      // convert them back to bare specifiers that the bundler can resolve.
+      return rewriteNpmSpecifiers(source);
+    }
+  };
+}
+export function hasExactUserAlias(id, aliases) {
+  if (!aliases) return false;
+  if (Array.isArray(aliases)) {
+    return aliases.some((alias)=>typeof alias.find === 'string' && alias.find === id);
+  }
+  return Object.prototype.hasOwnProperty.call(aliases, id);
+}
+function normalizeSubpath(subpath) {
+  if (subpath === '' || subpath === '.') return '.';
+  return subpath.replace(/^\.\//, '');
+}
+function resolveSourcePathExtension(packageName, path) {
+  const normalized = path.replace(/\.js$/, '');
+  const exports = OPENELEMENT_EXPORT_FILES[packageName];
+  if (exports) {
+    const matched = Object.values(exports).find((file)=>file.replace(/\.(tsx|ts)$/, '') === normalized);
+    if (matched) return matched;
+  }
+  return ensureTsExtension(path);
+}
+function ensureTsExtension(path) {
+  const withoutJs = path.replace(/\.js$/, '');
+  if (withoutJs.endsWith('.tsx') || withoutJs.endsWith('.ts')) return withoutJs;
+  return `${withoutJs}.ts`;
+}
+/**
+ * Rewrite Deno/JSR `npm:` import/export specifiers to bare specifiers that
+ * Vite/Rolldown can resolve. JSR rewrites bare npm imports like
+ * `import from 'marked'` to `import from 'npm:marked@12.0.0'`. Published openElement
+ * source can also use explicit `npm:` specifiers so fresh Deno consumers do not
+ * need root import-map aliases. Vite doesn't understand `npm:` so we strip the
+ * prefix and version, leaving a bare specifier like `marked` or
+ * `@preact/signals-core`.
+ *
+ * Handles:
+ */ const NPM_SPECIFIER_RE = /(\bfrom\s*|\bimport\s*\(\s*|\bimport\s+)(['"])npm:(@?[a-z0-9_-]+(?:\/[a-z0-9_-]+)?)@[^'"/]+(\/[^'"]*)?\2/g;
+function rewriteNpmSpecifiers(source) {
+  return source.replace(NPM_SPECIFIER_RE, (_match, prefix, quote, pkg, subpath)=>{
+    return `${prefix}${quote}${pkg}${subpath ?? ''}${quote}`;
+  });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/adapter-vite/src/ssg-package-resolver.ts"],"sourcesContent":["import { Deno } from \"@deno/shim-deno\";\nimport { readFile } from 'node:fs/promises';\nimport type { Alias, Plugin } from 'vite';\nimport { formatError } from '@openelement/core/errors';\n\nconst VIRTUAL_OPENELEMENT_PACKAGE_PREFIX = '\\0openelement:ssg-pkg/';\n// Packages resolved by this plugin for JSR consumer SSG builds.\n// Retained optional packages (content, i18n) are handled by optionalPackageStubsPlugin\n// in build-ssg.ts instead. The resolver must NOT intercept them, because it runs\n// enforce: 'pre' and would prevent the stubs plugin from providing empty stubs\n// when packages are absent.\nconst DEFAULT_OPENELEMENT_PACKAGES = new Set([\n  'adapter-vite',\n  'app',\n  'core',\n  'create',\n  'element',\n  'router',\n  'signal',\n  'ui',\n]);\n\nconst OPENELEMENT_EXPORT_FILES: Record<string, Record<string, string>> = {\n  'adapter-vite': {\n    '.': 'src/index.ts',\n    'build-context': 'src/build-context.ts',\n    'head-injection': 'src/head-injection.ts',\n    'nitro-mount': 'src/nitro-mount.ts',\n    plugin: 'src/plugin.ts',\n    'subpath-resolver': 'src/subpath-resolver.ts',\n    'generated-data-resolver': 'src/generated-data-resolver.ts',\n    'plugin-mdx': 'src/plugin-mdx.ts',\n    'cli/build': 'src/cli/build.ts',\n    'cli/build-client': 'src/cli/build-client.ts',\n    'cli/build-ssg': 'src/cli/build-ssg.ts',\n  },\n  app: {\n    '.': 'src/index.ts',\n    i18n: 'src/i18n.ts',\n    'i18n-plugin': 'src/i18n-plugin.ts',\n    preact: 'src/preact.ts',\n    vite: 'src/vite.ts',\n  },\n  content: {\n    '.': 'src/index.ts',\n    'blog-data': 'src/blog/blog-data.ts',\n    mdx: 'src/mdx/compile.ts',\n    nav: 'src/nav/scanner.ts',\n    'nav-data': 'src/nav/writer.ts',\n    sitemap: 'src/sitemap/generator.ts',\n  },\n  core: {\n    '.': 'src/index.ts',\n    context: 'src/context.ts',\n    data: 'src/data.ts',\n    'dsd-hydration': 'src/dsd-hydration.ts',\n    errors: 'src/errors.ts',\n    'html-escape': 'src/html-escape.ts',\n    'island-transform': 'src/island-transform.ts',\n    isr: 'src/isr.ts',\n    'isr-runtime': 'src/isr-runtime.ts',\n    'jsx-runtime': 'src/jsx-runtime.ts',\n    'jsx-dev-runtime': 'src/jsx-runtime.ts',\n    logger: 'src/logger.ts',\n    prop: 'src/prop.ts',\n    'render-dsd-stream': 'src/render-dsd-stream.ts',\n    runtime: 'src/runtime.ts',\n    'signal-context': 'src/signal-context.ts',\n    'style-sheet': 'src/style-sheet.ts',\n    'tag-utils': 'src/tag-utils.ts',\n  },\n  create: { '.': 'cli.ts' },\n  element: {\n    '.': 'src/index.ts',\n  },\n  router: {\n    '.': 'src/data-context.ts',\n    'data-context': 'src/data-context.ts',\n    i18n: 'src/i18n.ts',\n  },\n  signal: {\n    '.': 'src/index.ts',\n    framework: 'src/framework.ts',\n    'preact-engine': 'src/preact-engine.ts',\n  },\n  ssg: {\n    '.': 'src/index.ts',\n  },\n  ui: {\n    '.': 'src/index.ts',\n    'open-button': 'src/open-button.tsx',\n    'open-callout': 'src/open-callout.tsx',\n    'open-card': 'src/open-card.tsx',\n    'open-code-block': 'src/open-code-block.tsx',\n    'open-dialog': 'src/open-dialog.tsx',\n    'open-dropdown': 'src/open-dropdown.tsx',\n    'open-hero-ping': 'src/open-hero-ping.tsx',\n    'open-input': 'src/open-input.tsx',\n    'open-layout': 'src/open-layout.tsx',\n    'open-modal': 'src/open-modal.tsx',\n    'open-props-tokens': 'src/open-props-tokens.ts',\n    'open-props-tokens.js': 'src/open-props-tokens.ts',\n    'open-step-card': 'src/open-step-card.tsx',\n    'open-tabs': 'src/open-tabs.tsx',\n    'open-theme-toggle': 'src/open-theme-toggle.tsx',\n    'open-badge': 'src/open-badge.tsx',\n    'open-brand-mark': 'src/open-brand-mark.tsx',\n    'open-lab-panel': 'src/open-lab-panel.tsx',\n    'open-lab-stage': 'src/open-lab-stage.tsx',\n    'open-standards-visual': 'src/open-standards-visual.tsx',\n    'daisy-classes': 'src/daisy-classes.ts',\n    'daisy-classes.js': 'src/daisy-classes.ts',\n  },\n};\n\nexport interface OpenJsrPackageSpecifier {\n  packageName: string;\n  subpath: string;\n  range?: string;\n}\n\nexport interface OpenJsrPackageResolverOptions {\n  workspaceRoot: string | null;\n  version: string;\n  localPackageRoot?: string | null;\n  userAliases?: Record<string, string> | Alias[] | null;\n  fetchSource?: (url: string) => Promise<Response>;\n  readLocalSource?: (path: string) => string;\n  /** Registry mode. 'npm' lets Vite resolve @openelement/* from node_modules.\n   * 'jsr' keeps the legacy virtual-module source fetch for JSR consumers. */\n  registry?: 'npm' | 'jsr';\n}\n\nexport function parseOpenPackageSpecifier(id: string): OpenJsrPackageSpecifier | null {\n  const bare = id.match(/^@openelement\\/([^/@]+)(?:\\/(.+))?$/);\n  if (bare) return { packageName: bare[1], subpath: bare[2] ?? '.' };\n\n  const jsr = id.match(/^jsr:@openelement\\/([^/@]+)(?:@([^/]+))?(?:\\/(.+))?$/);\n  if (jsr) {\n    return {\n      packageName: jsr[1],\n      range: jsr[2],\n      subpath: jsr[3] ?? '.',\n    };\n  }\n\n  return null;\n}\n\nexport function resolveOpenPackageExport(packageName: string, subpath: string): string {\n  const exports = OPENELEMENT_EXPORT_FILES[packageName];\n  if (!exports) {\n    throw new Error(`[openElement/SSG] Unknown openElement package: @openelement/${packageName}`);\n  }\n\n  const normalized = normalizeSubpath(subpath);\n  const file = exports[normalized] ??\n    (normalized.endsWith('.js') ? exports[normalized.replace(/\\.js$/, '')] : undefined);\n  if (file) return file;\n\n  throw new Error(\n    `[openElement/SSG] Unknown @openelement/${packageName} export subpath: ${subpath}`,\n  );\n}\n\nexport function toVirtualOpenPackageId(packageName: string, sourcePath: string): string {\n  return `${VIRTUAL_OPENELEMENT_PACKAGE_PREFIX}${packageName}/${sourcePath}`;\n}\n\nexport function resolveVirtualOpenPackageRelative(id: string, importer: string): string | null {\n  if (!importer.startsWith(VIRTUAL_OPENELEMENT_PACKAGE_PREFIX)) return null;\n  if (!id.startsWith('./') && !id.startsWith('../')) return null;\n\n  const importerPath = importer.slice(VIRTUAL_OPENELEMENT_PACKAGE_PREFIX.length);\n  const [packageName, ...pathParts] = importerPath.split('/');\n  const base = pathParts.slice(0, -1);\n  const parts = [...base, ...id.split('/')];\n  const resolved: string[] = [];\n\n  for (const part of parts) {\n    if (!part || part === '.') continue;\n    if (part === '..') resolved.pop();\n    else resolved.push(part);\n  }\n\n  return toVirtualOpenPackageId(\n    packageName,\n    resolveSourcePathExtension(packageName, resolved.join('/')),\n  );\n}\n\nexport function createOpenJsrPackageResolverPlugin(\n  options: OpenJsrPackageResolverOptions,\n): Plugin {\n  const fetchSource = options.fetchSource ?? fetch;\n  const registry = options.registry ??\n    (typeof import.meta.url === 'string' && import.meta.url.startsWith('https://') ? 'jsr' : 'npm');\n  const isNpmMode = registry === 'npm';\n\n  return {\n    name: 'open:ssg-package-resolve',\n    enforce: 'pre',\n    transform(code) {\n      if (!code.includes('npm:')) return null;\n      const rewritten = rewriteNpmSpecifiers(code);\n      if (rewritten === code) return null;\n      return { code: rewritten, map: null };\n    },\n    resolveId(id, importer) {\n      if (options.workspaceRoot) return null;\n      if (isNpmMode) return null;\n      if (hasExactUserAlias(id, options.userAliases)) return null;\n\n      const spec = parseOpenPackageSpecifier(id);\n      if (spec) {\n        if (!DEFAULT_OPENELEMENT_PACKAGES.has(spec.packageName)) return null;\n        return toVirtualOpenPackageId(\n          spec.packageName,\n          resolveOpenPackageExport(spec.packageName, spec.subpath),\n        );\n      }\n\n      return resolveVirtualOpenPackageRelative(id, importer ?? '');\n    },\n    async load(id) {\n      if (options.workspaceRoot) return null;\n      if (isNpmMode) return null;\n      if (!id.startsWith(VIRTUAL_OPENELEMENT_PACKAGE_PREFIX)) return null;\n\n      const [packageName, ...pathParts] = id.slice(VIRTUAL_OPENELEMENT_PACKAGE_PREFIX.length).split(\n        '/',\n      );\n      const filePath = pathParts.join('/');\n      if (options.localPackageRoot) {\n        const localPath = `${options.localPackageRoot}/packages/${packageName}/${filePath}`;\n        try {\n          return options.readLocalSource\n            ? options.readLocalSource(localPath)\n            : typeof Deno !== 'undefined'\n            ? await Deno.readTextFile(localPath)\n            : await readFile(localPath, 'utf-8');\n        } catch (error) {\n          throw new Error(\n            `[openElement/SSG] Failed to read local @openelement/${packageName}/${filePath} ` +\n              `from ${localPath}: ${formatError(error)}`,\n          );\n        }\n      }\n\n      const url = `https://jsr.io/@openelement/${packageName}/${options.version}/${filePath}`;\n      const resp = await fetchSource(url);\n      if (!resp.ok) {\n        throw new Error(\n          `[openElement/SSG] Failed to fetch @openelement/${packageName}/${filePath} ` +\n            `from ${url}: HTTP ${resp.status}`,\n        );\n      }\n      const source = await resp.text();\n      // JSR rewrites bare npm specifiers (e.g. 'marked') to 'npm:marked@x.y.z'.\n      // Vite/Rolldown does not understand Deno's 'npm:' scheme, so we must\n      // convert them back to bare specifiers that the bundler can resolve.\n      return rewriteNpmSpecifiers(source);\n    },\n  };\n}\n\nexport function hasExactUserAlias(\n  id: string,\n  aliases: Record<string, string> | Alias[] | null | undefined,\n): boolean {\n  if (!aliases) return false;\n  if (Array.isArray(aliases)) {\n    return aliases.some((alias) => typeof alias.find === 'string' && alias.find === id);\n  }\n  return Object.prototype.hasOwnProperty.call(aliases, id);\n}\n\nfunction normalizeSubpath(subpath: string): string {\n  if (subpath === '' || subpath === '.') return '.';\n  return subpath.replace(/^\\.\\//, '');\n}\n\nfunction resolveSourcePathExtension(packageName: string, path: string): string {\n  const normalized = path.replace(/\\.js$/, '');\n  const exports = OPENELEMENT_EXPORT_FILES[packageName];\n  if (exports) {\n    const matched = Object.values(exports).find((file) =>\n      file.replace(/\\.(tsx|ts)$/, '') === normalized\n    );\n    if (matched) return matched;\n  }\n  return ensureTsExtension(path);\n}\n\nfunction ensureTsExtension(path: string): string {\n  const withoutJs = path.replace(/\\.js$/, '');\n  if (withoutJs.endsWith('.tsx') || withoutJs.endsWith('.ts')) return withoutJs;\n  return `${withoutJs}.ts`;\n}\n\n/**\n * Rewrite Deno/JSR `npm:` import/export specifiers to bare specifiers that\n * Vite/Rolldown can resolve. JSR rewrites bare npm imports like\n * `import from 'marked'` to `import from 'npm:marked@12.0.0'`. Published openElement\n * source can also use explicit `npm:` specifiers so fresh Deno consumers do not\n * need root import-map aliases. Vite doesn't understand `npm:` so we strip the\n * prefix and version, leaving a bare specifier like `marked` or\n * `@preact/signals-core`.\n *\n * Handles:\n */\nconst NPM_SPECIFIER_RE =\n  /(\\bfrom\\s*|\\bimport\\s*\\(\\s*|\\bimport\\s+)(['\"])npm:(@?[a-z0-9_-]+(?:\\/[a-z0-9_-]+)?)@[^'\"/]+(\\/[^'\"]*)?\\2/g;\n\nfunction rewriteNpmSpecifiers(source: string): string {\n  return source.replace(\n    NPM_SPECIFIER_RE,\n    (_match, prefix: string, quote: string, pkg: string, subpath?: string) => {\n      return `${prefix}${quote}${pkg}${subpath ?? ''}${quote}`;\n    },\n  );\n}\n"],"names":[],"mappings":"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"}

package/src/subpath-resolver.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Extracted from index.ts in v0.22 (SOP-004: adapter-vite decomposition).
+ *
+ * When @openelement/core is loaded from JSR (https:// import.meta.url),
+ * Vite's SSR runner cannot load https:// URLs via Node.js ESM loader.
+ * This module intercepts @openelement/core/* imports and loads source code
+ * through virtual modules, bypassing Node.js ESM loader entirely.
+ *
+ * ADR 0018 Phase 0: buildCoreSubpathAliases() DELETED.
+ * Local mode now relies on @deno/vite-plugin for bare specifier resolution.
+ * Remote JSR resolution (createCoreResolvePlugin) is retained because
+ * JSR packages are not in node_modules and require virtual module loading.
+ */ import type { Plugin } from 'vite';
+/** Virtual module ID prefix for JSR remote resolution */ export declare const VIRTUAL_CORE_PREFIX: '\0openelement:core/src/';
+/**
+ * Mapping of @openelement/core/* subpath specifiers to source files
+ * (used by JSR remote resolution only).
+ */ export declare const CORE_SUBPATHS: Record<string, string>;
+/**
+ * Create the core subpath resolution plugin for JSR remote execution.
+ *
+ * When @openelement/core is loaded from JSR (https:// import.meta.url),
+ * Vite's SSR runner cannot load https:// URLs via Node.js ESM loader.
+ * This plugin intercepts @openelement/core/* imports and loads source code
+ * through virtual modules, bypassing Node.js ESM loader entirely.
+ */ export declare function createCoreResolvePlugin(metaUrl: string): Plugin;