@pyreon/vite-plugin 0.13.1 → 0.15.0

package/src/index.ts

@@ -32,8 +32,8 @@
  *   vite build --ssr src/entry-server.ts --outDir dist/server   # server bundle
  */
 
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
-import { join as pathJoin } from 'node:path'
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
+import { dirname, join as pathJoin } from 'node:path'
 import { generateContext, transformJSX } from '@pyreon/compiler'
 import type { Plugin, ViteDevServer } from 'vite'
 
@@ -112,6 +112,73 @@ const COMPAT_ALIASES: Record<CompatFramework, Record<string, string>> = {
   },
 }
 
+/**
+ * Detect whether a file id resolves to a `@pyreon/*` framework-package source
+ * (i.e. a published Pyreon package whose .tsx is being pulled in via the
+ * `bun` condition workspace-link, NOT user code, NOT an example app).
+ *
+ * Why this exists: in compat mode, OXC's per-project `importSource` is set
+ * to `@pyreon/core` and the resolveId hook redirects `@pyreon/core/jsx-runtime`
+ * to the compat package. That's correct for user code (the whole point of
+ * compat mode) but WRONG for framework-internal sources like
+ * `@pyreon/zero/src/link.tsx`, which need the real `@pyreon/core` runtime.
+ * The fix skips the redirect when the importer is a `@pyreon/*` framework
+ * file. Result: published-package consumers (where `@pyreon/zero` resolves
+ * to its pre-built `lib/`) and workspace-dev consumers (where it resolves
+ * to source) both get correct JSX runtime resolution.
+ *
+ * Detection heuristic: walk to nearest `package.json`, require BOTH:
+ *   1. `name` starts with `@pyreon/` (workspace member of the @pyreon scope)
+ *   2. file path contains `/packages/` AND NOT `/examples/`
+ *
+ * Step 2 excludes the existing `@pyreon/example-{react,vue,solid,preact}-compat`
+ * apps under `examples/`. Without it, user code in those apps would skip the
+ * compat-mode JSX-runtime redirect and import `@pyreon/core/jsx-runtime`
+ * directly — breaking the React/Vue/Solid/Preact compat layer's contract.
+ *
+ * Result cached per directory. The `/packages/` + `/examples/` check is a
+ * structural property of the monorepo (workspace layout), not the package
+ * name — so it's robust against renames.
+ */
+function isPyreonWorkspaceFile(id: string, cache: Map<string, boolean>): boolean {
+  // Strip query strings (e.g. `?vue&type=script`) to get the bare path.
+  const queryIdx = id.indexOf('?')
+  const filePath = queryIdx === -1 ? id : id.slice(0, queryIdx)
+  if (!filePath || filePath[0] === '\0') return false
+
+  // Path-based filter first (cheap): file must live under `<root>/packages/`
+  // and not under `<root>/examples/`. This excludes example apps even when
+  // they have `@pyreon/example-*` names.
+  if (!filePath.includes('/packages/') || filePath.includes('/examples/')) {
+    return false
+  }
+
+  let dir = dirname(filePath)
+  // Walk up at most ~12 levels — enough for any realistic monorepo depth.
+  for (let i = 0; i < 12; i++) {
+    const cached = cache.get(dir)
+    if (cached !== undefined) return cached
+
+    const pkgPath = pathJoin(dir, 'package.json')
+    if (existsSync(pkgPath)) {
+      let isPyreon = false
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8')) as { name?: string }
+        isPyreon = typeof pkg.name === 'string' && pkg.name.startsWith('@pyreon/')
+      } catch {
+        // Malformed package.json — treat as not-pyreon.
+      }
+      cache.set(dir, isPyreon)
+      return isPyreon
+    }
+
+    const parent = dirname(dir)
+    if (parent === dir) break // reached filesystem root
+    dir = parent
+  }
+  return false
+}
+
 /**
  * Return the Pyreon compat target for an import specifier, or undefined if
  * the import should not be redirected.
@@ -137,6 +204,17 @@ export default function pyreonPlugin(options?: PyreonPluginOptions): Plugin {
   let isBuild = false
   let projectRoot = ''
 
+  // ── Cross-module signal export registry ─────────────────────────────────
+  // Tracks which modules export signal() declarations so imported signals
+  // can be auto-called in JSX across file boundaries.
+  // Key: normalized module ID, Value: set of exported signal names
+  const signalExportRegistry = new Map<string, Set<string>>()
+  // Cache resolved import specifiers to avoid redundant resolution calls
+  const resolveCache = new Map<string, string | null>()
+  // Cache `isPyreonWorkspaceFile` lookups by directory — package.json reads
+  // happen at most once per containing directory across the build.
+  const pyreonWorkspaceDirCache = new Map<string, boolean>()
+
   return {
     name: 'pyreon',
     enforce: 'pre',
@@ -150,7 +228,13 @@ export default function pyreonPlugin(options?: PyreonPluginOptions): Plugin {
       // they resolve to workspace packages via our resolveId hook, not node_modules.
       const optimizeDepsExclude = compat ? Object.keys(COMPAT_ALIASES[compat]) : []
 
-      const jsxSource = compat ? COMPAT_JSX_SOURCE[compat] : '@pyreon/core'
+      // Always set OXC's JSX importSource to `@pyreon/core`. In compat mode,
+      // we redirect `@pyreon/core/jsx-runtime` imports to the compat package
+      // VIA `resolveId` — but ONLY for user code, never for `@pyreon/*`
+      // workspace-package files (zero, router, runtime-dom, etc.). Setting
+      // OXC's importSource directly to the compat package would force the
+      // compat runtime on framework internals too, which they cannot handle.
+      const jsxSource = '@pyreon/core'
 
       return {
         // Use "bun" condition for workspace resolution — source .ts/.tsx files
@@ -180,9 +264,34 @@ export default function pyreonPlugin(options?: PyreonPluginOptions): Plugin {
       }
     },
 
+    // ── Pre-scan all source files for signal exports ──────────────────────
+    async buildStart() {
+      // Pre-scan all source files for signal exports so the registry
+      // is complete before any transforms run. This solves the build
+      // ordering problem where component.tsx is transformed before
+      // store.ts — without pre-scanning, the registry would be empty.
+      await prescanSignalExports(projectRoot, signalExportRegistry)
+    },
+
     // ── Virtual module + compat alias resolution ─────────────────────────────
     async resolveId(id, importer) {
       if (id === HMR_RUNTIME_IMPORT) return HMR_RUNTIME_ID
+
+      // `@pyreon/core/jsx-runtime` resolves to the compat package only for
+      // user code — never for `@pyreon/*` framework files (zero, router,
+      // runtime-dom, etc.). Without this importer guard, every JSX file in
+      // the build (including framework internals resolved via the `bun`
+      // workspace condition) would get redirected to a compat runtime that
+      // doesn't match the framework's JSX shape. Caught by `cpa-smoke-app-*-compat`.
+      if (
+        compat &&
+        (id === '@pyreon/core/jsx-runtime' || id === '@pyreon/core/jsx-dev-runtime') &&
+        importer &&
+        isPyreonWorkspaceFile(importer, pyreonWorkspaceDirCache)
+      ) {
+        return // let Vite resolve to the real `@pyreon/core/jsx-runtime`
+      }
+
       const target = getCompatTarget(compat, id)
       if (!target) return
 
@@ -198,7 +307,7 @@ export default function pyreonPlugin(options?: PyreonPluginOptions): Plugin {
       }
     },
 
-    transform(code, id, transformOptions) {
+    async transform(code, id, transformOptions) {
       const ext = getExt(id)
       if (ext !== '.tsx' && ext !== '.jsx' && ext !== '.pyreon') return
 
@@ -213,11 +322,22 @@ export default function pyreonPlugin(options?: PyreonPluginOptions): Plugin {
         return
       }
 
+      // ── Scan for exported signal declarations (populate registry) ──────
+      // This runs on every .tsx/.jsx file so the registry is built
+      // incrementally. buildStart pre-scans all files, but this handles
+      // files created/modified after buildStart (dev mode HMR).
+      scanSignalExports(code, normalizeModuleId(id), signalExportRegistry)
+
+      // ── Resolve imported signals from the registry ─────────────────────
+      // Check each import in this file: if the imported module has signal
+      // exports in the registry, pass them as knownSignals to the compiler.
+      const knownSignals = await resolveImportedSignals(code, id, signalExportRegistry, this, resolveCache)
+
       // Vite passes `ssr: true` when transforming for the SSR module graph
       // (both build --ssr and dev `ssrLoadModule`). The compiler emits plain
       // `h()` calls in that mode so `runtime-server` can render to a string.
       const isSsr = transformOptions?.ssr === true
-      const result = transformJSX(code, id, { ssr: isSsr })
+      const result = transformJSX(code, id, { ssr: isSsr, knownSignals })
       // Surface compiler warnings in the terminal
       for (const w of result.warnings) {
         this.warn(`${w.message} (${id}:${w.line}:${w.column})`)
@@ -333,8 +453,19 @@ function generateProjectContext(root: string): void {
  * The arguments are extracted via balanced-paren matching in `injectHmr`.
  * A brace-depth check filters out matches inside functions/blocks — only
  * module-scope (depth 0) signals are rewritten for HMR state preservation.
+ *
+ * The optional `<...>` group accepts a TypeScript type parameter so that
+ * `signal<T>(initial)` declarations are also rewritten — without it, any
+ * generic-typed module-scope signal silently skipped HMR preservation.
+ *
+ * The inner `(?:[^<>]|<[^<>]*>)*` permits one level of generic nesting
+ * (e.g. `signal<Array<Row>>([])`, `signal<Map<string, number>>(m)`).
+ * Deeper nesting (`signal<Array<{ id: T<U> }>>(...)`) falls back to
+ * not-rewritten — tracked as a follow-up if real consumers need it,
+ * but unlikely at module scope where generics are usually shallow.
  */
-const SIGNAL_PREFIX_RE = /^((?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*)signal\(/gm
+const SIGNAL_PREFIX_RE =
+  /^((?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*)signal(?:<(?:[^<>]|<[^<>]*>)*>)?\(/gm
 
 /**
  * Detect whether the module exports any component-like functions
@@ -552,6 +683,211 @@ function isAssetRequest(url: string): boolean {
 // Inlined here so it's available without a filesystem read. This is the
 // compiled-to-JS version of hmr-runtime.ts — kept in sync manually.
 
+// ─── Cross-module signal auto-call helpers ──────────────────────────────────
+
+/**
+ * Normalize a Vite module ID by stripping query strings (?v=..., ?t=...)
+ * and resolving to an absolute path for consistent registry lookups.
+ */
+function normalizeModuleId(id: string): string {
+  const queryIndex = id.indexOf('?')
+  return queryIndex >= 0 ? id.slice(0, queryIndex) : id
+}
+
+/**
+ * Pre-scan all source files in the project for signal exports.
+ *
+ * Called from `buildStart` so the registry is fully populated before any
+ * transforms run. This solves the build ordering problem where component.tsx
+ * is transformed before store.ts — without pre-scanning, the registry would
+ * be empty and imported signals would not be auto-called.
+ */
+async function prescanSignalExports(root: string, registry: Map<string, Set<string>>): Promise<void> {
+  const files: string[] = []
+
+  function walk(dir: string) {
+    try {
+      for (const entry of readdirSync(dir)) {
+        if (entry.startsWith('.') || entry === 'node_modules' || entry === 'dist' || entry === 'lib' || entry === 'build') continue
+        const full = pathJoin(dir, entry)
+        try {
+          const stat = statSync(full)
+          if (stat.isDirectory()) walk(full)
+          else if (/\.(ts|tsx|js|jsx)$/.test(entry)) files.push(full)
+        } catch {
+          /* permission error, etc. */
+        }
+      }
+    } catch {
+      /* dir doesn't exist */
+    }
+  }
+
+  walk(root)
+
+  for (const file of files) {
+    try {
+      const code = readFileSync(file, 'utf-8')
+      scanSignalExports(code, file, registry)
+    } catch {
+      /* read error */
+    }
+  }
+}
+
+/**
+ * Scan a module's source for exported signal declarations and register them.
+ *
+ * Detects patterns:
+ *   1. `export const x = signal(...)` or `export const x = computed(...)` — inline export
+ *   2. `const x = signal(...); export { x }` — separate declaration + named export
+ *   3. `export default signal(...)` — default export (tracked as 'default')
+ *
+ * Re-exports (`export { x } from './signals'`) are NOT detected — the source
+ * module must be scanned directly. This is a known limitation.
+ *
+ * Uses simple regex — no AST parse needed.
+ */
+function scanSignalExports(code: string, moduleId: string, registry: Map<string, Set<string>>): void {
+  const normalizedId = normalizeModuleId(moduleId)
+  let match: RegExpExecArray | null
+  const signals = new Set<string>()
+
+  // Pattern 1: export const x = signal(...) or export const x = computed(...)
+  const EXPORT_CONST_RE = /export\s+const\s+(\w+)\s*=\s*(?:signal|computed)\s*[<(]/g
+  while ((match = EXPORT_CONST_RE.exec(code)) !== null) {
+    signals.add(match[1]!)
+  }
+
+  // Pattern 2: const x = signal(...) followed by export { x }
+  // First, find all local `const x = signal(` or `const x = computed(` declarations
+  const localSignals = new Set<string>()
+  const LOCAL_SIGNAL_RE = /(?:^|[\s;])const\s+(\w+)\s*=\s*(?:signal|computed)\s*[<(]/gm
+  while ((match = LOCAL_SIGNAL_RE.exec(code)) !== null) {
+    localSignals.add(match[1]!)
+  }
+
+  // Then check named exports: export { x, y as z }
+  if (localSignals.size > 0) {
+    const NAMED_EXPORT_RE = /export\s*\{([^}]+)\}/g
+    while ((match = NAMED_EXPORT_RE.exec(code)) !== null) {
+      // Skip re-exports (export { x } from '...')
+      const afterBrace = code.slice(match.index + match[0].length).trimStart()
+      if (afterBrace.startsWith('from')) continue
+
+      for (const spec of match[1]!.split(',')) {
+        const trimmed = spec.trim()
+        if (!trimmed) continue
+        const parts = trimmed.split(/\s+as\s+/)
+        const localName = parts[0]!.trim()
+        const exportedName = (parts[1] ?? parts[0])!.trim()
+        if (localSignals.has(localName)) {
+          signals.add(exportedName)
+        }
+      }
+    }
+  }
+
+  // Pattern 3: export default signal(...) or export default computed(...) — tracked as 'default'
+  if (/export\s+default\s+(?:signal|computed)\s*[<(]/.test(code)) {
+    signals.add('default')
+  }
+
+  if (signals.size > 0) {
+    registry.set(normalizedId, signals)
+  } else {
+    // Clean up if module no longer exports signals (e.g. after edit)
+    registry.delete(normalizedId)
+  }
+}
+
+/**
+ * Resolve imported signal names from the signal export registry.
+ *
+ * For each import in the source, resolves the module and checks if it has
+ * signal exports in the registry. Returns the local names of imported signals.
+ *
+ * Handles named imports (`import { x } from ...`) and default imports
+ * (`import x from ...` — matched against 'default' in the registry).
+ */
+async function resolveImportedSignals(
+  code: string,
+  _moduleId: string,
+  registry: Map<string, Set<string>>,
+  pluginCtx: { resolve: (id: string, importer?: string, options?: { skipSelf: boolean }) => Promise<{ id: string } | null> },
+  resolveCache: Map<string, string | null>,
+): Promise<string[]> {
+  if (registry.size === 0) return []
+
+  const knownSignals: string[] = []
+  let match: RegExpExecArray | null
+
+  /** Resolve a source specifier to a normalized module ID, using the cache. */
+  async function resolveSource(source: string): Promise<string | null> {
+    const cacheKey = `${_moduleId}::${source}`
+    if (resolveCache.has(cacheKey)) return resolveCache.get(cacheKey) ?? null
+    let resolvedId: string | null = null
+    try {
+      const resolved = await pluginCtx.resolve(source, _moduleId, { skipSelf: true })
+      resolvedId = resolved?.id ? normalizeModuleId(resolved.id) : null
+    } catch {
+      /* resolve error */
+    }
+    resolveCache.set(cacheKey, resolvedId)
+    return resolvedId
+  }
+
+  // Named imports: import { name1, name2 as alias } from 'source'
+  // Excludes `import type { ... }` — type-only imports have no runtime value
+  const IMPORT_RE = /import\s+(?!type\s)\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/g
+  while ((match = IMPORT_RE.exec(code)) !== null) {
+    const specifiers = match[1]!
+    const source = match[2]!
+
+    const resolvedId = await resolveSource(source)
+    if (!resolvedId) continue
+    const exportedSignals = registry.get(resolvedId)
+    if (!exportedSignals) continue
+
+    // Parse import specifiers: "count, theme as t, other"
+    for (const spec of specifiers.split(',')) {
+      const trimmed = spec.trim()
+      if (!trimmed) continue
+
+      const parts = trimmed.split(/\s+as\s+/)
+      const importedName = parts[0]!.trim()
+      const localName = (parts[1] ?? parts[0])!.trim()
+
+      if (exportedSignals.has(importedName)) {
+        knownSignals.push(localName)
+      }
+    }
+  }
+
+  // Default imports: import count from './store'
+  // Excludes: `import { ... }`, `import type X`, `import * as X`
+  const DEFAULT_IMPORT_RE = /import\s+(?!type\s)(\w+)\s+from\s*['"]([^'"]+)['"]/g
+  while ((match = DEFAULT_IMPORT_RE.exec(code)) !== null) {
+    // Skip if this is actually a `import type X from` pattern
+    const fullMatch = match[0]
+    if (/import\s+type\s+/.test(fullMatch)) continue
+
+    const localName = match[1]!
+    const source = match[2]!
+
+    const resolvedId = await resolveSource(source)
+    if (!resolvedId) continue
+    const exportedSignals = registry.get(resolvedId)
+    if (!exportedSignals) continue
+
+    if (exportedSignals.has('default')) {
+      knownSignals.push(localName)
+    }
+  }
+
+  return knownSignals
+}
+
 const HMR_RUNTIME_SOURCE = `
 const REGISTRY_KEY = "__pyreon_hmr_registry__";
 

package/src/tests/compat-resolve.test.ts

@@ -0,0 +1,260 @@
+/**
+ * Compat-mode `resolveId` and `getCompatTarget` coverage for
+ * @pyreon/vite-plugin (PR #323). The existing test file covers
+ * compat-mode `transform` short-circuiting; this covers the
+ * resolveId hook + the JSX-runtime aliasing branch.
+ */
+
+import { resolve } from 'node:path'
+import { describe, expect, it } from 'vitest'
+import pyreonPlugin, { type PyreonPluginOptions } from '../index'
+
+type ConfigHook = (
+  userConfig: Record<string, unknown>,
+  env: { command: string; isSsrBuild?: boolean },
+) => Record<string, unknown>
+
+type ResolveIdCtx = {
+  resolve: (
+    id: string,
+    importer?: string,
+    options?: { skipSelf: boolean },
+  ) => Promise<{ id: string } | null>
+}
+type ResolveIdHook = (
+  this: ResolveIdCtx,
+  id: string,
+  importer?: string,
+) => Promise<string | undefined>
+
+function bootstrap(opts?: PyreonPluginOptions) {
+  const plugin = pyreonPlugin(opts)
+  ;(plugin.config as unknown as ConfigHook)({}, { command: 'serve' })
+  return plugin
+}
+
+async function callResolveId(
+  plugin: ReturnType<typeof pyreonPlugin>,
+  id: string,
+  resolveMap: Record<string, string> = {},
+  importer?: string,
+): Promise<string | undefined> {
+  const hook = plugin.resolveId as ResolveIdHook
+  return hook.call(
+    {
+      resolve: async (specifier: string) => {
+        const resolved = resolveMap[specifier]
+        return resolved ? { id: resolved } : null
+      },
+    },
+    id,
+    importer,
+  )
+}
+
+describe('compat-mode resolveId — react', () => {
+  it('redirects "react" → @pyreon/react-compat', async () => {
+    const plugin = bootstrap({ compat: 'react' })
+    const resolved = await callResolveId(plugin, 'react', {
+      '@pyreon/react-compat': '/abs/react-compat/index.ts',
+    })
+    expect(resolved).toBe('/abs/react-compat/index.ts')
+  })
+
+  it('redirects "react/jsx-runtime" → @pyreon/react-compat/jsx-runtime', async () => {
+    const plugin = bootstrap({ compat: 'react' })
+    const resolved = await callResolveId(plugin, 'react/jsx-runtime', {
+      '@pyreon/react-compat/jsx-runtime': '/abs/react-compat/jsx-runtime.ts',
+    })
+    expect(resolved).toBe('/abs/react-compat/jsx-runtime.ts')
+  })
+
+  it('redirects @pyreon/core/jsx-runtime → @pyreon/react-compat/jsx-runtime in react compat', async () => {
+    const plugin = bootstrap({ compat: 'react' })
+    const resolved = await callResolveId(plugin, '@pyreon/core/jsx-runtime', {
+      '@pyreon/react-compat/jsx-runtime': '/abs/react-compat/jsx-runtime.ts',
+    })
+    expect(resolved).toBe('/abs/react-compat/jsx-runtime.ts')
+  })
+
+  it('redirects @pyreon/core/jsx-dev-runtime in react compat', async () => {
+    const plugin = bootstrap({ compat: 'react' })
+    const resolved = await callResolveId(plugin, '@pyreon/core/jsx-dev-runtime', {
+      '@pyreon/react-compat/jsx-runtime': '/abs/react-compat/jsx-runtime.ts',
+    })
+    expect(resolved).toBe('/abs/react-compat/jsx-runtime.ts')
+  })
+
+  it('returns undefined for non-aliased imports', async () => {
+    const plugin = bootstrap({ compat: 'react' })
+    const resolved = await callResolveId(plugin, 'lodash', {})
+    expect(resolved).toBeUndefined()
+  })
+})
+
+describe('compat-mode resolveId — preact', () => {
+  it('redirects "preact" → @pyreon/preact-compat', async () => {
+    const plugin = bootstrap({ compat: 'preact' })
+    const resolved = await callResolveId(plugin, 'preact', {
+      '@pyreon/preact-compat': '/abs/preact-compat/index.ts',
+    })
+    expect(resolved).toBe('/abs/preact-compat/index.ts')
+  })
+
+  it('redirects "preact/hooks" → @pyreon/preact-compat/hooks', async () => {
+    const plugin = bootstrap({ compat: 'preact' })
+    const resolved = await callResolveId(plugin, 'preact/hooks', {
+      '@pyreon/preact-compat/hooks': '/abs/preact-compat/hooks.ts',
+    })
+    expect(resolved).toBe('/abs/preact-compat/hooks.ts')
+  })
+
+  it('redirects @pyreon/core/jsx-runtime in preact compat', async () => {
+    const plugin = bootstrap({ compat: 'preact' })
+    const resolved = await callResolveId(plugin, '@pyreon/core/jsx-runtime', {
+      '@pyreon/preact-compat/jsx-runtime': '/abs/preact-compat/jsx-runtime.ts',
+    })
+    expect(resolved).toBe('/abs/preact-compat/jsx-runtime.ts')
+  })
+
+  it('redirects @preact/signals → @pyreon/preact-compat/signals', async () => {
+    const plugin = bootstrap({ compat: 'preact' })
+    const resolved = await callResolveId(plugin, '@preact/signals', {
+      '@pyreon/preact-compat/signals': '/abs/preact-compat/signals.ts',
+    })
+    expect(resolved).toBe('/abs/preact-compat/signals.ts')
+  })
+})
+
+describe('compat-mode resolveId — vue', () => {
+  it('redirects "vue" → @pyreon/vue-compat', async () => {
+    const plugin = bootstrap({ compat: 'vue' })
+    const resolved = await callResolveId(plugin, 'vue', {
+      '@pyreon/vue-compat': '/abs/vue-compat/index.ts',
+    })
+    expect(resolved).toBe('/abs/vue-compat/index.ts')
+  })
+
+  it('redirects @pyreon/core/jsx-runtime in vue compat', async () => {
+    const plugin = bootstrap({ compat: 'vue' })
+    const resolved = await callResolveId(plugin, '@pyreon/core/jsx-runtime', {
+      '@pyreon/vue-compat/jsx-runtime': '/abs/vue-compat/jsx-runtime.ts',
+    })
+    expect(resolved).toBe('/abs/vue-compat/jsx-runtime.ts')
+  })
+})
+
+describe('compat-mode resolveId — solid', () => {
+  it('redirects "solid-js" → @pyreon/solid-compat', async () => {
+    const plugin = bootstrap({ compat: 'solid' })
+    const resolved = await callResolveId(plugin, 'solid-js', {
+      '@pyreon/solid-compat': '/abs/solid-compat/index.ts',
+    })
+    expect(resolved).toBe('/abs/solid-compat/index.ts')
+  })
+
+  it('redirects @pyreon/core/jsx-runtime in solid compat', async () => {
+    const plugin = bootstrap({ compat: 'solid' })
+    const resolved = await callResolveId(plugin, '@pyreon/core/jsx-runtime', {
+      '@pyreon/solid-compat/jsx-runtime': '/abs/solid-compat/jsx-runtime.ts',
+    })
+    expect(resolved).toBe('/abs/solid-compat/jsx-runtime.ts')
+  })
+})
+
+describe('compat-mode resolveId — framework-importer carve-out', () => {
+  // Regression: in compat mode, `@pyreon/core/jsx-runtime` must NOT be
+  // redirected to the compat package when the importer is itself a
+  // `@pyreon/*` workspace-package source file (zero, router, runtime-dom,
+  // etc.). Pre-fix, OXC's project-wide importSource was set to the compat
+  // package, so framework-internal JSX got rewritten to import a runtime
+  // shape it doesn't speak. The fix sets OXC to `@pyreon/core` always and
+  // redirects in `resolveId` only for non-framework importers. Caught by
+  // `cpa-smoke-app-*-compat` cells in `scripts/scaffold-smoke.ts`.
+  // Bisect-verified: dropping the `isPyreonWorkspaceFile(importer)` guard
+  // makes these tests fail with the redirected jsx-runtime path.
+
+  const repoRoot = resolve(import.meta.dirname, '../../../../..')
+  const frameworkImporter = `${repoRoot}/packages/zero/zero/src/link.tsx`
+  const userImporter = `${repoRoot}/examples/some-user-app/src/foo.tsx`
+  // The 4 existing compat-layer example apps under `examples/` have
+  // package.json names like `@pyreon/example-react-compat`. The carve-out
+  // helper must NOT treat their source files as framework files — doing so
+  // skips the JSX-runtime redirect and breaks the compat layer end-to-end.
+  // Bisect-verified: when the helper checked `name.startsWith('@pyreon/')`
+  // alone (without the `/examples/` exclusion), all 4 compat-layer e2e
+  // suites failed in CI with `section.demo` never rendering.
+  const exampleAppImporter = `${repoRoot}/examples/react-compat/src/Foo.tsx`
+
+  it('does NOT redirect @pyreon/core/jsx-runtime when imported FROM @pyreon/zero workspace source (react)', async () => {
+    const plugin = bootstrap({ compat: 'react' })
+    const resolved = await callResolveId(
+      plugin,
+      '@pyreon/core/jsx-runtime',
+      { '@pyreon/react-compat/jsx-runtime': '/abs/react-compat/jsx-runtime.ts' },
+      frameworkImporter,
+    )
+    expect(resolved).toBeUndefined() // pass through to Vite's resolver
+  })
+
+  it('does NOT redirect @pyreon/core/jsx-dev-runtime when imported FROM framework source (preact)', async () => {
+    const plugin = bootstrap({ compat: 'preact' })
+    const resolved = await callResolveId(
+      plugin,
+      '@pyreon/core/jsx-dev-runtime',
+      { '@pyreon/preact-compat/jsx-runtime': '/abs/preact-compat/jsx-runtime.ts' },
+      frameworkImporter,
+    )
+    expect(resolved).toBeUndefined()
+  })
+
+  it('STILL redirects @pyreon/core/jsx-runtime when imported FROM user code (react)', async () => {
+    const plugin = bootstrap({ compat: 'react' })
+    const resolved = await callResolveId(
+      plugin,
+      '@pyreon/core/jsx-runtime',
+      { '@pyreon/react-compat/jsx-runtime': '/abs/react-compat/jsx-runtime.ts' },
+      userImporter,
+    )
+    expect(resolved).toBe('/abs/react-compat/jsx-runtime.ts')
+  })
+
+  it('STILL redirects @pyreon/core/jsx-runtime when no importer (entry point)', async () => {
+    const plugin = bootstrap({ compat: 'react' })
+    const resolved = await callResolveId(
+      plugin,
+      '@pyreon/core/jsx-runtime',
+      { '@pyreon/react-compat/jsx-runtime': '/abs/react-compat/jsx-runtime.ts' },
+    )
+    expect(resolved).toBe('/abs/react-compat/jsx-runtime.ts')
+  })
+
+  it('STILL redirects @pyreon/core/jsx-runtime when imported FROM an example app under examples/ (e.g. @pyreon/example-react-compat)', async () => {
+    const plugin = bootstrap({ compat: 'react' })
+    const resolved = await callResolveId(
+      plugin,
+      '@pyreon/core/jsx-runtime',
+      { '@pyreon/react-compat/jsx-runtime': '/abs/react-compat/jsx-runtime.ts' },
+      exampleAppImporter,
+    )
+    expect(resolved).toBe('/abs/react-compat/jsx-runtime.ts')
+  })
+})
+
+describe('compat-mode resolveId — no compat', () => {
+  it('returns undefined for any framework alias when compat is unset', async () => {
+    const plugin = bootstrap()
+    expect(await callResolveId(plugin, 'react', {})).toBeUndefined()
+    expect(await callResolveId(plugin, 'vue', {})).toBeUndefined()
+    expect(await callResolveId(plugin, 'preact', {})).toBeUndefined()
+    expect(await callResolveId(plugin, 'solid-js', {})).toBeUndefined()
+  })
+
+  it('still resolves the HMR runtime virtual id (independent of compat)', async () => {
+    const plugin = bootstrap()
+    const resolved = await callResolveId(plugin, 'virtual:pyreon/hmr-runtime', {})
+    // Internal ID — has the leading '\0' marker convention or similar
+    expect(resolved).toBeDefined()
+    expect(typeof resolved).toBe('string')
+  })
+})