one 2.10.0 → 2.11.0

package/src/vite/dom/README.md

@@ -0,0 +1,91 @@
+# One DOM build integration
+
+The native plugin replaces a component with `createDOMComponent(id)` before
+Rolldown resolves its browser imports. It discovers boundaries in the native
+module graph, including dynamic imports, and stops at each proxy. It does not
+scan source directories or rewrite finished JavaScript or Hermes output.
+
+A descriptor ID hashes the canonical module path relative to the canonical
+project root. Same basenames in different directories remain distinct, and
+symlinked imports of one file share an ID. Absolute paths stay in the builder;
+the native proxy receives only the stable ID.
+
+Development uses the existing Vite client environment at `/_one/dom/<id>/`.
+Only registered IDs are served. The browser entry installs the existing React
+Refresh preamble before importing the original component, then calls
+`mountDOMComponent(Component, id)`. HTML provides `#one-dom-root`. Ordinary web
+and SSR imports retain the original component and existing render rules.
+Metro is unsupported and receives a configuration diagnostic.
+
+Native production generation awaits one Vite multi-entry ESM build before
+returning to the native bundle writer. Output lives beneath
+`assetsDest/one-dom`: HTML in `pages/<id>/index.html`, shared hashed chunks and
+imported assets in `assets/`, and `manifest.json` containing:
+
+```json
+{
+  "protocolVersion": 1,
+  "buildId": "sha256 of completed output bytes and relative entry paths",
+  "entries": {
+    "dom-<stable identity hash>": "pages/dom-<stable identity hash>/index.html"
+  }
+}
+```
+
+The build ID changes with output content; descriptor IDs do not depend on
+finished asset hashes. Removing the final boundary removes stale `one-dom`
+output. Native resource handlers select the immutable build or update root and
+resolve the manifest entry within that root. Native origins, loading, Updates
+activation and rollback require separate native proof.
+
+Browser builds use a relative base and standard Vite transforms for imported
+CSS, fonts and images. They set `publicDir: false` and `copyPublicDir: false`.
+Unrelated web public files are excluded. Root-relative public URLs such as
+`<img src="/logo.png">` are unsupported in packaged DOM components; import
+assets from the browser graph instead. There is no network or inline fallback.
+
+`bun run test src/vite/dom/build.test.ts` in `packages/one` exercises native
+isolation, discovery behind a lazy import, deferred native evaluation,
+completion of browser assets, deterministic build IDs, symlink identities,
+exclusion of unrelated public assets and removal of stale output. It also
+executes each emitted JSX entry with the real production React JSX runtime,
+including a deferred browser import. Browser and native host interaction are
+validated separately.
+
+## Browser runtime integration proof
+
+The compiler/browser probe on 2026-10-25 used the built One and VxRN modules
+at `72b352c531` and a byte-identical copy of the native-features
+`fixtures/dom/ProofPage.tsx`. Browser resolution selected the public
+`one/dom/client` and `one/dom` package exports, without runtime aliases.
+Two native graph descriptors produced separate HTML entries sharing the
+browser closure; the second descriptor was discovered behind a lazy native
+import before that module executed.
+
+Chromium exercised two isolated pages in both Vite development and emitted
+production ESM: data reconciliation, value/void/error actions and refs,
+retained refs after factory dependency changes, a delayed action spanning
+such a change, imported image/font/CSS, and deferred lazy evaluation.
+Transitive React Refresh preserved the document and input state. An invalid
+lazy import displayed the error overlay and recovered after repair. Reload
+reset local state and rejected the old ref without changing the other page.
+Production browser resources stayed beneath an immutable build namespace.
+
+The transport was simulated over HTTP with the built JavaScript
+`DOMNativeBridge`; native graph evaluation used a descriptor-only adapter.
+This establishes no Fabric, native origin, WebView, device or Updates proof.
+The source fixture's CSS referenced absent `OneNativeTestFont-BlockA.ttf`;
+the disposable copy used the existing `OneNativeTestFont-Regular.ttf`.
+That fixture correction belongs to its owner. The component itself was
+unchanged. Logs, module/fixture hashes and three 3x WebP captures are retained
+under `~/.team-machine/evidence/one-dom-build/real-runtime` on pro128.
+
+The actual production artifact replay later failed before ready with
+`jsxDEV is not a function`. The earlier probe did not reproduce the resolved
+native configuration. The native build passed `oxc.jsx.development: true` while
+the browser build selected React's production runtime. Packaged browser builds now
+disable JSX development transforms as well as Refresh, preserving the selected
+JSX runtime and import source. The focused build guard reproduces the failure
+with an inherited development config and a custom JSX import source mapped to
+the installed React runtime. The earlier browser proof does not establish
+correctness of final artifacts built through that configuration.

package/src/vite/dom/browser.ts

@@ -0,0 +1,152 @@
+import { mkdir, writeFile, rm, readdir, readFile, stat } from 'node:fs/promises'
+import { createHash } from 'node:crypto'
+import { join, relative } from 'node:path'
+import { build, type Plugin, type ResolvedConfig, type UserConfig } from 'vite'
+import type { DOMDescriptor, DOMManifest, DOMRegistry } from './registry'
+
+const ENTRY_PREFIX = 'virtual:one-dom-entry/'
+const REFRESH_ENTRY = 'virtual:one-dom-refresh'
+export const DOM_DEV_PREFIX = '/_one/dom/'
+
+export function domEntrySource(descriptor: DOMDescriptor, development = false): string {
+  return `${development ? `import ${JSON.stringify(REFRESH_ENTRY)};\n` : ''}import Component from ${JSON.stringify(descriptor.moduleId)};\nimport { mountDOMComponent } from "one/dom/client";\nmountDOMComponent(Component, ${JSON.stringify(descriptor.id)});\n`
+}
+
+export function domEntryPlugin(registry: DOMRegistry, development = () => false): Plugin {
+  return {
+    name: 'one:dom-browser-entry',
+    resolveId: {
+      filter: { id: /^\/?virtual:one-dom-(?:entry\/|refresh$)/ },
+      handler(source) {
+        const id = source.startsWith('/') ? source.slice(1) : source
+        if (development() && id === REFRESH_ENTRY) return `\0${id}`
+        if (id.startsWith(ENTRY_PREFIX) && registry.get(id.slice(ENTRY_PREFIX.length))) {
+          return `\0${id}`
+        }
+      },
+    },
+    load: {
+      filter: { id: /^\0virtual:one-dom-/ },
+      handler(id) {
+        if (development() && id === `\0${REFRESH_ENTRY}`) {
+          return `import { injectIntoGlobalHook } from '/@react-refresh';
+injectIntoGlobalHook(window);
+window.$RefreshReg$ = () => {};
+window.$RefreshSig$ = () => (type) => type;`
+        }
+        if (!id.startsWith(`\0${ENTRY_PREFIX}`)) return
+        const descriptor = registry.get(id.slice(ENTRY_PREFIX.length + 1))
+        if (!descriptor)
+          this.error('[one/use-dom] DOM entry is no longer in the native graph')
+        return domEntrySource(descriptor, development())
+      },
+    },
+  }
+}
+
+export function domHTML(id: string): string {
+  return `<!doctype html><html><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"></head><body><style>html,body{margin:0}#one-dom-root{display:flow-root;width:100%;min-width:0}</style><div id="one-dom-root"></div><script type="module" src="/${ENTRY_PREFIX}${id}"></script></body></html>`
+}
+
+// a fresh browser build receives browser configuration, never the standalone
+// native resolver, native defines, or the One router's application entry.
+export async function buildDOMAssets(
+  entries: DOMDescriptor[],
+  registry: DOMRegistry,
+  config: ResolvedConfig,
+  browserPlugins: Plugin[],
+  assetsDest: string,
+  assetsInclude?: UserConfig['assetsInclude']
+): Promise<DOMManifest> {
+  entries = [...entries].sort((a, b) => a.id.localeCompare(b.id))
+  const outDir = join(assetsDest, 'one-dom')
+  const manifest: DOMManifest = { protocolVersion: 1, buildId: '', entries: {} }
+  if (entries.length) {
+    const pages = new Map(
+      entries.map((entry) => [
+        join(registry.root, 'pages', entry.id, 'index.html').replaceAll('\\', '/'),
+        entry,
+      ])
+    )
+    const input = Object.fromEntries([...pages].map(([file, entry]) => [entry.id, file]))
+    const client = config.environments.client
+    await build({
+      configFile: false,
+      root: registry.root,
+      mode: config.mode,
+      logLevel: config.logLevel,
+      base: './',
+      publicDir: false,
+      envPrefix: config.envPrefix,
+      define: { ...config.define, ...client?.define },
+      resolve: { ...config.resolve, ...client?.resolve },
+      css: config.css,
+      oxc:
+        config.oxc === false
+          ? false
+          : {
+              ...config.oxc,
+              ...(typeof config.oxc?.jsx === 'object' && {
+                // the native config may have been resolved in development;
+                // packaged pages must use the production JSX runtime.
+                jsx: { ...config.oxc.jsx, development: false, refresh: false },
+              }),
+            },
+      assetsInclude,
+      plugins: [
+        ...browserPlugins,
+        domEntryPlugin(registry),
+        {
+          name: 'one:dom-html',
+          resolveId(id) {
+            if (pages.has(id)) return id
+          },
+          load(id) {
+            const entry = pages.get(id)
+            if (entry) return domHTML(entry.id)
+          },
+        },
+      ],
+      build: {
+        outDir,
+        emptyOutDir: true,
+        copyPublicDir: false,
+        assetsInlineLimit: 0,
+        cssCodeSplit: true,
+        rolldownOptions: {
+          input,
+          output: {
+            format: 'esm',
+            entryFileNames: 'assets/[name]-[hash].js',
+            chunkFileNames: 'assets/[name]-[hash].js',
+            assetFileNames: 'assets/[name]-[hash][extname]',
+          },
+        },
+      },
+    })
+    for (const [file, entry] of pages) {
+      manifest.entries[entry.id] = relative(registry.root, file).replaceAll('\\', '/')
+    }
+  }
+  if (!entries.length) {
+    await rm(outDir, { recursive: true, force: true })
+    return { ...manifest, buildId: createHash('sha256').update('{}').digest('hex') }
+  }
+  await mkdir(outDir, { recursive: true })
+  const hash = createHash('sha256').update(JSON.stringify(manifest.entries))
+  for (const file of (await readdir(outDir, { recursive: true })).sort()) {
+    if (file === 'manifest.json') continue
+    const path = join(outDir, file)
+    if (!(await stat(path)).isFile()) continue
+    const bytes = await readFile(path)
+    hash
+      .update(file.replaceAll('\\', '/'))
+      .update('\0')
+      .update(String(bytes.length))
+      .update('\0')
+      .update(bytes)
+  }
+  manifest.buildId = hash.digest('hex')
+  await writeFile(join(outDir, 'manifest.json'), JSON.stringify(manifest, null, 2))
+  return manifest
+}

package/src/vite/dom/build.test.ts

@@ -0,0 +1,204 @@
+import { mkdtemp, mkdir, readFile, rm, symlink, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { runInNewContext } from 'node:vm'
+import { createRequire } from 'node:module'
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+import { resolveConfig } from 'vite'
+import { expect, it } from 'vitest'
+import { useDOMPlugin } from '../plugins/useDomPlugin'
+import type { DOMManifest } from './registry'
+
+const require = createRequire(import.meta.url)
+
+it('isolates DOM dependencies in lazy native graphs and joins deterministic browser assets', async () => {
+  const { buildNativeBundle } = await import(
+    new URL('../../../../vxrn/src/utils/createNativeDevEngine.ts', import.meta.url).href
+  )
+  const root = await mkdtemp(join(tmpdir(), 'one-dom-build-'))
+  const previousPlugins = globalThis.__vxrnAddNativePlugins
+  try {
+    await mkdir(join(root, 'components'), { recursive: true })
+    await writeFile(join(root, 'package.json'), '{"type":"module"}')
+    await mkdir(join(root, 'public'))
+    await writeFile(join(root, 'public/unrelated.txt'), 'web-only public asset')
+    await writeFile(
+      join(root, 'entry.ts'),
+      `import First from './components/First';
+globalThis.first = First;
+globalThis.loadLazy = () => import('./lazy-native');`
+    )
+    await writeFile(
+      join(root, 'lazy-native.ts'),
+      `import Second from './components/Second';
+globalThis.nativeLazyRuns = (globalThis.nativeLazyRuns || 0) + 1;
+export default Second;`
+    )
+    await writeFile(
+      join(root, 'native-runtime.ts'),
+      'export function createDOMComponent(id) { return id }'
+    )
+    await writeFile(
+      join(root, 'browser-runtime.ts'),
+      'export function mountDOMComponent(Component, id) { globalThis.mounted = { element: Component(), id } }'
+    )
+    await writeFile(
+      join(root, 'components/browser.ts'),
+      `if (typeof document === 'undefined') throw Error('browser code executed in native'); export const label = 'browser';`
+    )
+    await writeFile(
+      join(root, 'components/deferred.ts'),
+      'globalThis.browserLazyRuns = (globalThis.browserLazyRuns || 0) + 1; export default 42'
+    )
+    await writeFile(join(root, 'components/style.css'), 'body { color: red }')
+    await writeFile(
+      join(root, 'components/icon.svg'),
+      '<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10"/>'
+    )
+    const component = `"use dom";
+import { label } from 'browser-alias';
+import './style.css';
+import icon from './icon.svg';
+export type Props = { title: string };
+export default function Component() { return <section data-label={label} data-icon={icon} data-load={() => import('./deferred')}>DOM JSX</section> }`
+    await writeFile(join(root, 'components/First.tsx'), component)
+    await writeFile(join(root, 'components/Second.tsx'), component)
+    await symlink('./First.tsx', join(root, 'components/Linked.tsx'))
+    const dom = useDOMPlugin({ root, routerRoot: 'app' })
+    await resolveConfig(
+      {
+        root,
+        configFile: false,
+        logLevel: 'silent',
+        plugins: [dom],
+        define: { 'process.env.NODE_ENV': JSON.stringify('production') },
+        // native bundling can inherit an already resolved development config.
+        oxc: {
+          jsx: {
+            runtime: 'automatic',
+            importSource: 'custom-jsx',
+            development: true,
+            refresh: true,
+          },
+        },
+        resolve: {
+          alias: {
+            'custom-jsx/jsx-runtime': require.resolve('react/jsx-runtime'),
+            'custom-jsx/jsx-dev-runtime': require.resolve('react/jsx-dev-runtime'),
+            'one/dom/client': join(root, 'browser-runtime.ts'),
+            'browser-alias': join(root, 'components/browser.ts'),
+          },
+        },
+      },
+      'build',
+      'production'
+    )
+    const registry = dom.api!.registry
+    expect(registry.descriptor(join(root, 'components/Linked.tsx')).id).toBe(
+      registry.descriptor(join(root, 'components/First.tsx')).id
+    )
+    const browserImports: string[] = []
+    globalThis.__vxrnAddNativePlugins = () => [
+      dom,
+      {
+        name: 'one-dom-native-test-runtime',
+        resolveId(source) {
+          if (source === 'one/dom/native') return join(root, 'native-runtime.ts')
+          if (/browser-alias|\.css$|\.svg$|deferred/.test(source)) {
+            browserImports.push(source)
+            throw new Error(`browser import reached native resolver: ${source}`)
+          }
+        },
+      },
+    ]
+    const build = () =>
+      buildNativeBundle({
+        root,
+        platform: 'ios',
+        entryFile: 'entry.ts',
+        minify: false,
+        assetsDest: join(root, 'output'),
+      })
+    const result = await build()
+    const manifestPath = join(root, 'output/one-dom/manifest.json')
+    const manifest = JSON.parse(await readFile(manifestPath, 'utf8')) as DOMManifest
+    await expect(
+      readFile(join(root, 'output/one-dom/unrelated.txt'))
+    ).rejects.toMatchObject({ code: 'ENOENT' })
+    expect(manifest.protocolVersion).toBe(1)
+    expect(manifest.buildId).toMatch(/^[a-f0-9]{64}$/)
+    expect(Object.keys(manifest.entries)).toHaveLength(2)
+    for (const html of Object.values(manifest.entries)) {
+      expect(html).toMatch(/^pages\/dom-[a-f0-9]{32}\/index.html$/)
+      // these must already exist when buildNativeBundle returns to packaging.
+      const page = await readFile(join(root, 'output/one-dom', html), 'utf8')
+      expect(page).toContain('one-dom-root')
+      const entry = page.match(/<script[^>]*src="([^"]+)"/)![1]
+      // execute emitted ESM with the real production JSX runtime, including a
+      // deferred browser import; parsing alone misses calls to missing jsxDEV.
+      await promisify(execFile)(
+        process.execPath,
+        [
+          '--input-type=module',
+          '-e',
+          String.raw`
+        import assert from 'node:assert/strict';
+        import { pathToFileURL } from 'node:url';
+        globalThis.document = { createElement: () => ({ relList: { supports: () => true } }) };
+        await import(pathToFileURL(process.argv[1]).href);
+        const { element } = globalThis.mounted;
+        assert.equal(element.type, 'section');
+        assert.equal(element.props['data-label'], 'browser');
+        assert.equal(element.props.children, 'DOM JSX');
+        assert.match(new URL(element.props['data-icon']).pathname, /\/one-dom\/assets\/icon-.*\.svg$/);
+        assert.equal(globalThis.browserLazyRuns, undefined);
+        assert.equal((await element.props['data-load']()).default, 42);
+        assert.equal(globalThis.browserLazyRuns, 1);
+      `,
+          join(root, 'output/one-dom', html, '..', entry),
+        ],
+        {
+          env: { ...process.env, NODE_ENV: 'production' },
+        }
+      )
+    }
+    const context: any = { console, setTimeout, clearTimeout }
+    runInNewContext(result.code, context)
+    expect(context.first).toBe(registry.descriptor(join(root, 'components/First.tsx')).id)
+    expect(context.nativeLazyRuns).toBeUndefined()
+    const lazy = await context.loadLazy()
+    expect(context.nativeLazyRuns).toBe(1)
+    expect(lazy.default).toBe(registry.descriptor(join(root, 'components/Second.tsx')).id)
+    expect(browserImports).toEqual([])
+    // unsupported desktop boundaries fail before a proxy can reach rendering.
+    await mkdir(join(root, 'node_modules'))
+    await symlink(
+      new URL('../../../', import.meta.url).pathname,
+      join(root, 'node_modules/one')
+    )
+    for (const platform of ['macos', 'linux'] as const) {
+      await expect(
+        buildNativeBundle({
+          root,
+          platform,
+          entryFile: 'entry.ts',
+          assetsDest: join(root, 'output'),
+        })
+      ).rejects.toThrow(`"use dom" supports iOS and Android; ${platform} is unsupported`)
+    }
+    await build()
+    expect(JSON.parse(await readFile(manifestPath, 'utf8'))).toEqual(manifest)
+    await writeFile(join(root, 'components/browser.ts'), 'export const label = "changed"')
+    await build()
+    const changed = JSON.parse(await readFile(manifestPath, 'utf8')) as DOMManifest
+    expect(changed.entries).toEqual(manifest.entries)
+    expect(changed.buildId).not.toBe(manifest.buildId)
+    await writeFile(join(root, 'entry.ts'), 'globalThis.noDOM = true')
+    await build()
+    await expect(readFile(manifestPath)).rejects.toMatchObject({ code: 'ENOENT' })
+  } finally {
+    globalThis.__vxrnAddNativePlugins = previousPlugins
+    await rm(root, { recursive: true, force: true })
+  }
+})

package/src/vite/dom/directive.ts

@@ -0,0 +1,76 @@
+import { parseSync } from 'oxc-parser'
+import { basename, relative, resolve } from 'node:path'
+import micromatch from 'micromatch'
+
+export function readDOMDirective(
+  code: string,
+  id: string,
+  options: { root: string; routerRoot: string; ignoredRouteFiles?: string[] }
+): boolean {
+  if (!code.includes('use dom') || !/\.[cm]?[jt]sx?$/.test(id)) return false
+  const fail = (reason: string): never => {
+    throw new Error(`[one/use-dom] ${id}: ${reason}`)
+  }
+  const parsed = parseSync(id, code, {
+    lang: /\.[cm]?tsx?$/.test(id) ? (id.endsWith('x') ? 'tsx' : 'ts') : 'jsx',
+  })
+  if (parsed.errors.length) fail(parsed.errors.map((error) => error.message).join('\n'))
+  const body = parsed.program.body as any[]
+  let directive = false
+  for (const node of body) {
+    if (node.type !== 'ExpressionStatement' || typeof node.directive !== 'string') break
+    if (node.directive === 'use dom') directive = true
+  }
+  if (!directive) return false
+  const route = relative(resolve(options.root, options.routerRoot), id).replaceAll(
+    '\\',
+    '/'
+  )
+  const ignored =
+    options.ignoredRouteFiles?.length &&
+    micromatch.isMatch(`./${route}`, options.ignoredRouteFiles, { matchBase: true })
+  if (
+    (!route.startsWith('../') && !ignored) ||
+    /(?:^|\.)(?:server)(?:\.|$)/.test(basename(id)) ||
+    /(?:^_layout\.|\+api\.|^_middleware\.)/.test(basename(id))
+  ) {
+    fail(
+      '"use dom" is component-only; move it out of route, layout, API and server modules'
+    )
+  }
+  let defaults = 0
+  for (const node of body) {
+    if (node.type === 'ImportDeclaration' && node.source.value === 'server-only') {
+      fail('server-only modules cannot use the "use dom" directive')
+    }
+    if (node.type === 'ExportDefaultDeclaration') {
+      if (/^(?:TSInterface|TSTypeAlias)/.test(node.declaration?.type)) continue
+      defaults++
+    }
+    if (node.type === 'ExportAllDeclaration' && node.exportKind !== 'type') {
+      fail(
+        'export-star is unsupported; export one default component and erased types only'
+      )
+    }
+    if (node.type !== 'ExportNamedDeclaration' || node.exportKind === 'type') continue
+    if (
+      node.declaration &&
+      !/^(?:TSInterface|TSTypeAlias|TSDeclareFunction)/.test(node.declaration.type) &&
+      !node.declaration.declare
+    ) {
+      fail(
+        'named runtime exports are unsupported; export one default component and erased types only'
+      )
+    }
+    for (const specifier of node.specifiers ?? []) {
+      if (specifier.exportKind === 'type') continue
+      if ((specifier.exported.name ?? specifier.exported.value) === 'default') defaults++
+      else
+        fail(
+          'named runtime exports are unsupported; export one default component and erased types only'
+        )
+    }
+  }
+  if (defaults !== 1) fail('expected exactly one default runtime component export')
+  return true
+}

package/src/vite/dom/registry.ts

@@ -0,0 +1,67 @@
+import { createHash } from 'node:crypto'
+import { realpathSync } from 'node:fs'
+import { relative, resolve } from 'node:path'
+
+export interface DOMDescriptor {
+  id: string
+  identity: string
+  moduleId: string
+}
+
+export interface DOMManifest {
+  protocolVersion: 1
+  buildId: string
+  entries: Record<string, string>
+}
+
+export class DOMRegistry {
+  private descriptors = new Map<string, DOMDescriptor>()
+  private graphs = new Map<string, Set<string>>()
+  readonly root: string
+
+  constructor(root: string) {
+    this.root = realpathSync(root)
+  }
+
+  descriptor(moduleId: string): DOMDescriptor {
+    const canonical = realpathSync(moduleId.split('?')[0])
+    const identity = relative(this.root, canonical).replaceAll('\\', '/')
+    const id = `dom-${createHash('sha256').update(identity).digest('hex').slice(0, 32)}`
+    return { id, identity, moduleId: canonical }
+  }
+
+  register(moduleId: string): DOMDescriptor {
+    const descriptor = this.descriptor(moduleId)
+    this.descriptors.set(descriptor.id, descriptor)
+    return descriptor
+  }
+
+  get(id: string): DOMDescriptor | undefined {
+    return this.descriptors.get(id)
+  }
+
+  // each platform holds its own graph, so a rebuild cannot erase the other.
+  replaceGraph(graph: string, entries: DOMDescriptor[]) {
+    this.graphs.set(graph, new Set(entries.map((entry) => entry.id)))
+    for (const entry of entries) this.descriptors.set(entry.id, entry)
+    for (const id of this.descriptors.keys()) {
+      if (![...this.graphs.values()].some((ids) => ids.has(id))) {
+        this.descriptors.delete(id)
+      }
+    }
+  }
+
+  hasModule(moduleId: string): boolean {
+    const file = resolve(moduleId).replaceAll('\\', '/')
+    return [...this.descriptors.values()].some(
+      (entry) => entry.moduleId.replaceAll('\\', '/') === file
+    )
+  }
+
+  invalidate(moduleId: string) {
+    const file = resolve(moduleId).replaceAll('\\', '/')
+    for (const [id, entry] of this.descriptors) {
+      if (entry.moduleId.replaceAll('\\', '/') === file) this.descriptors.delete(id)
+    }
+  }
+}

package/src/vite/one-defines.test.ts

@@ -1,4 +1,4 @@
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { mkdir, mkdtemp, rm, symlink, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { fileURLToPath } from 'node:url'
@@ -6,6 +6,7 @@ import { runInNewContext } from 'node:vm'
 import { rolldown } from 'rolldown'
 import { resolveConfig, type Plugin } from 'vite'
 import { describe, expect, test } from 'vitest'
+import type { createNativeDevEngine } from '../../../vxrn/src/utils/createNativeDevEngine'
 import type { NativeAppManifest } from '../native/appManifest'
 import { one } from './one'
 
@@ -158,3 +159,60 @@ test.each(['serve', 'build'] as const)(
     }
   }
 )
+
+test('macos rejects a package with only mobile and web implementations at bundle time', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'one-macos-platform-import-'))
+  const fixture = fileURLToPath(
+    new URL('../../../../tests/native-features', import.meta.url)
+  )
+  const originalCwd = process.cwd()
+  const originalPlugins = globalThis.__vxrnAddNativePlugins
+  let native: Awaited<ReturnType<typeof createNativeDevEngine>> | undefined
+  try {
+    const pkg = join(root, 'node_modules/expo-ghostty')
+    await mkdir(pkg, { recursive: true })
+    await symlink(
+      fileURLToPath(new URL('../../', import.meta.url)),
+      join(root, 'node_modules/one')
+    )
+    await writeFile(
+      join(pkg, 'package.json'),
+      JSON.stringify({ name: 'expo-ghostty', main: 'index.js' })
+    )
+    await writeFile(join(pkg, 'index.js'), "export { default } from './GhosttyView'")
+    for (const platform of ['ios', 'android', 'web']) {
+      await writeFile(
+        join(pkg, `GhosttyView.${platform}.js`),
+        `export default '${platform}'`
+      )
+    }
+    process.chdir(fixture)
+    await one({ native: { app: { name: 'ProbeApp' } } })
+    process.chdir(originalCwd)
+    const { createNativeDevEngine } =
+      await import('../../../vxrn/src/utils/createNativeDevEngine')
+    native = await createNativeDevEngine({
+      root,
+      platform: 'macos',
+      port: 0,
+      plugins: [
+        {
+          name: 'macos-platform-import-fixture',
+          transform(_code, id) {
+            if (id.endsWith('/__virtual-native-entry.tsx')) {
+              return "import GhosttyView from 'expo-ghostty'; globalThis.ghostty = GhosttyView"
+            }
+          },
+        },
+      ],
+    })
+    await expect(native.getBundle()).rejects.toThrow(
+      /expo-ghostty\/GhosttyView has no macOS implementation: cannot resolve import "\.\/GhosttyView"/
+    )
+  } finally {
+    await native?.close()
+    process.chdir(originalCwd)
+    globalThis.__vxrnAddNativePlugins = originalPlugins
+    await rm(root, { recursive: true, force: true })
+  }
+})