@1agh/maude 0.18.0 → 0.18.2

package/plugins/design/dev-server/dist/runtime/react_jsx-runtime.js

@@ -0,0 +1,103 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// ../../../node_modules/.pnpm/react@19.2.6/node_modules/react/cjs/react-jsx-runtime.production.js
+var exports_react_jsx_runtime_production = {};
+__export(exports_react_jsx_runtime_production, {
+  jsxs: () => $jsxs,
+  jsx: () => $jsx,
+  Fragment: () => $Fragment
+});
+function jsxProd(type, config, maybeKey) {
+  var key = null;
+  maybeKey !== undefined && (key = "" + maybeKey);
+  config.key !== undefined && (key = "" + config.key);
+  if ("key" in config) {
+    maybeKey = {};
+    for (var propName in config)
+      propName !== "key" && (maybeKey[propName] = config[propName]);
+  } else
+    maybeKey = config;
+  config = maybeKey.ref;
+  return {
+    $$typeof: REACT_ELEMENT_TYPE,
+    type,
+    key,
+    ref: config !== undefined ? config : null,
+    props: maybeKey
+  };
+}
+var REACT_ELEMENT_TYPE, REACT_FRAGMENT_TYPE, $Fragment, $jsx, $jsxs;
+var init_react_jsx_runtime_production = __esm(() => {
+  REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element");
+  REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+  $Fragment = REACT_FRAGMENT_TYPE;
+  $jsx = jsxProd;
+  $jsxs = jsxProd;
+});
+
+// ../../../node_modules/.pnpm/react@19.2.6/node_modules/react/jsx-runtime.js
+var require_jsx_runtime = __commonJS((exports, module) => {
+  init_react_jsx_runtime_production();
+  if (true) {
+    module.exports = exports_react_jsx_runtime_production;
+  }
+});
+
+// synth:/home/runner/work/maude/maude/plugins/design/dev-server/.runtime-bundle-react_jsx-runtime-entry.tsx
+var __mod__ = __toESM(require_jsx_runtime(), 1);
+var {
+  Fragment,
+  jsx,
+  jsxs
+} = __mod__;
+var __runtime_bundle_react_jsx_runtime_entry_default = __mod__;
+export {
+  jsxs,
+  jsx,
+  __runtime_bundle_react_jsx_runtime_entry_default as default,
+  Fragment
+};

package/plugins/design/dev-server/http.ts

@@ -5,8 +5,7 @@
 // top-level fall-through for paths Bun's `routes` field doesn't cover.
 
 import { watch } from 'node:fs';
-import { dirname, join, posix } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { join, posix } from 'node:path';
 
 import type { Api } from './api.ts';
 import { buildCanvasModule } from './canvas-build.ts';
@@ -17,9 +16,12 @@ import { isFormat, isScope, runExport } from './exporters/index.ts';
 import type { ActiveJsonShape } from './exporters/scope.ts';
 import type { Inspect } from './inspect.ts';
 import { canvasSlug, writeLocator } from './locator.ts';
+import { DEV_SERVER_ROOT } from './paths.ts';
 import { RUNTIME_PACKAGES, getRuntimeBundle, packageForSlug, slugFor } from './runtime-bundle.ts';
 
-const HERE = dirname(fileURLToPath(import.meta.url));
+// Real disk install root — never the virtual `/$bunfs/root` of compiled bins.
+// See paths.ts for the resolution logic + Phase 19.1 / v0.18.1 rationale.
+const HERE = DEV_SERVER_ROOT;
 
 export const MIME: Record<string, string> = {
   '.html': 'text/html; charset=utf-8',

package/plugins/design/dev-server/paths.ts

@@ -0,0 +1,110 @@
+// Path resolution for the dev-server, robust across THREE runtime modes:
+//
+//   1. Dev (`bun server.ts`):      import.meta.url is a real file:// path,
+//                                  use dirname of it.
+//   2. Compiled binary, npm:       maude installed via `npm i -g @1agh/maude`;
+//                                  binary lives in a sub-package dir, deps in
+//                                  the parent @1agh/maude/ dir. import.meta.url
+//                                  is the virtual `/$bunfs/root` (bun --compile
+//                                  embedded fs) — NOT a real disk path.
+//                                  Walk up from process.execPath until we find
+//                                  the real plugins/design/dev-server/ dir.
+//   3. Compiled binary, marketplace cache: similar to (2) but lives at
+//                                  ~/.claude/plugins/cache/maude/design/<v>/
+//                                  dev-server/. Same walk-up logic finds it.
+//
+// Why this matters: Phase 19 v0.18.0 used `dirname(fileURLToPath(import.meta.url))`
+// universally. In the compiled binary that's `/$bunfs/root` — a virtual path —
+// so `existsSync('/$bunfs/root/dist/client.bundle.js')` always returned false
+// even when the file was sitting on disk at the real install path. Self-heal
+// false-triggered, http.ts /_client/* fell through to /$bunfs/root/client/*.jsx
+// (raw source), runtime-bundle.ts synthetic entrypoint anchored in virtual fs
+// so Bun.build couldn't walk node_modules. Every observed symptom traces to
+// this one bug. Phase 19.1 / v0.18.1.
+
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/**
+ * Real disk path to the dev-server install dir
+ * (`plugins/design/dev-server/` inside whatever package layout we're in).
+ *
+ * Always a directory that contains `http.ts` + `dist/` + (optionally)
+ * `node_modules/` and `client/`. Never a virtual `/$bunfs/*` path.
+ */
+export const DEV_SERVER_ROOT: string = resolveDevServerRoot();
+
+/** `<DEV_SERVER_ROOT>/dist/` — committed artifacts + runtime bundles + binary. */
+export const DIST_DIR: string = join(DEV_SERVER_ROOT, 'dist');
+
+/** `<DEV_SERVER_ROOT>/client/` — raw source HTML + JSX + CSS for dev fallback. */
+export const CLIENT_DIR: string = join(DEV_SERVER_ROOT, 'client');
+
+/** `<DEV_SERVER_ROOT>/dist/runtime/` — pre-built /_canvas-runtime/*.js bundles. */
+export const RUNTIME_BUNDLES_DIR: string = join(DIST_DIR, 'runtime');
+
+/**
+ * Whether we are running inside a `bun --compile` standalone binary
+ * (true when `import.meta.url` resolves to bun's virtual filesystem).
+ *
+ * Useful for code that needs to know whether disk-relative fallback paths
+ * (e.g. `<DEV_SERVER_ROOT>/client/app.jsx`) are even reachable — in compiled
+ * mode the answer is "only if shipped via the install layout".
+ */
+export const IS_COMPILED_BINARY: boolean = isVirtualBunfsPath(getImportMetaDir());
+
+function getImportMetaDir(): string | null {
+  try {
+    return dirname(fileURLToPath(import.meta.url));
+  } catch {
+    return null;
+  }
+}
+
+function isVirtualBunfsPath(p: string | null): boolean {
+  return p !== null && (p.startsWith('/$bunfs') || p.startsWith('B:/~BUN'));
+}
+
+function isDevServerDir(dir: string): boolean {
+  // Anchor: http.ts is the route-table file — unique enough to identify the
+  // dev-server install dir. We do NOT also require package.json: npm excludes
+  // nested workspace package.json files from tarballs by default, so checking
+  // for it caused walk-up to silently fall through to /$bunfs/root for every
+  // npm-installed user. Discovered in v0.18.1 retro. Process.execPath walk-up
+  // only traverses node_modules layers above the binary, so false-match risk
+  // from a stray http.ts file in the user's working tree is negligible.
+  return existsSync(join(dir, 'http.ts'));
+}
+
+function resolveDevServerRoot(): string {
+  // (1) Dev mode: import.meta.url is a real file:// path AND lands in the
+  // dev-server dir. Common case for `bun run server.ts`, tests, etc.
+  const importDir = getImportMetaDir();
+  if (importDir && !isVirtualBunfsPath(importDir) && isDevServerDir(importDir)) {
+    return importDir;
+  }
+
+  // (2 + 3) Compiled binary: walk up from process.execPath until we find a dir
+  // that *contains* `plugins/design/dev-server/<canonical files>`. Match both
+  // npm install layout (binary at @1agh/maude-<plat>/maude → walk up 4 levels
+  // to @1agh/maude/) AND marketplace cache layout (binary somewhere under
+  // ~/.claude/plugins/cache/maude/design/<v>/dev-server/dist/).
+  let cur = dirname(process.execPath);
+  for (let i = 0; i < 10; i++) {
+    // Check if cur itself is the dev-server root.
+    if (isDevServerDir(cur)) return cur;
+    // Check if cur contains plugins/design/dev-server/.
+    const nested = join(cur, 'plugins', 'design', 'dev-server');
+    if (isDevServerDir(nested)) return nested;
+    const parent = dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+
+  // Final fallback for unanchored test contexts (e.g. tests spawning compiled
+  // binary in a tmp dir without our layout). Return the import dir even if
+  // it's virtual — callers should expect existsSync to fail and surface a
+  // clear error.
+  return importDir ?? dirname(process.execPath);
+}

package/plugins/design/dev-server/runtime-bundle.ts

@@ -18,10 +18,28 @@
 //   - In dev we externalise *nothing* — the four bundles together are
 //     self-contained. The importmap wires them together at runtime.
 
-import { dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
 
-const HERE = dirname(fileURLToPath(import.meta.url));
+import { DEV_SERVER_ROOT, RUNTIME_BUNDLES_DIR } from './paths.ts';
+
+// Real disk install root — synthetic entry points must anchor here so
+// Bun.build's resolver walks UP and finds node_modules/react on disk.
+// In compiled binaries, import.meta.url is the virtual `/$bunfs/root`
+// where no node_modules exists (Phase 19.1 / v0.18.1).
+const HERE = DEV_SERVER_ROOT;
+
+/**
+ * Read a pre-built runtime bundle from `dist/runtime/<slug>.js`. Returns
+ * null when missing → caller falls back to dynamic Bun.build (dev mode).
+ */
+async function loadPrebuiltRuntimeBundle(pkg: RuntimePackage): Promise<BundleCacheEntry | null> {
+  const path = join(RUNTIME_BUNDLES_DIR, `${slugFor(pkg)}.js`);
+  const file = Bun.file(path);
+  if (!(await file.exists())) return null;
+  const js = await file.text();
+  if (!js) return null;
+  return { js, etag: Bun.hash(js).toString(16) };
+}
 
 export const RUNTIME_PACKAGES = [
   'react',
@@ -99,10 +117,37 @@ const cache = new Map<RuntimePackage, BundleCacheEntry>();
  * each entry includes everything it needs; the four bundles only share state
  * at the browser level (via React's module-singleton convention — multiple
  * imports of "react" resolve to the same module thanks to the importmap).
+ *
+ * Two paths:
+ *   1. **Pre-built on disk** (Phase 19.1 / v0.18.1). Every release ships
+ *      `dist/runtime/<slug>.js` so npm-installed users + marketplace cache
+ *      users never need disk node_modules/react or Bun.build at request time.
+ *      Read from disk → return.
+ *   2. **Dynamic Bun.build** — only fires for dev (cd dev-server; bun
+ *      server.ts) where `dist/runtime/` may be empty/stale.
  */
-export async function getRuntimeBundle(pkg: RuntimePackage): Promise<BundleCacheEntry> {
+export interface GetRuntimeBundleOptions {
+  /** Skip the disk cache lookup — used by build.ts to force a fresh dynamic build. */
+  skipPrebuilt?: boolean;
+  /** Minify the dynamic build output — used by build.ts in release mode. */
+  minify?: boolean;
+}
+
+export async function getRuntimeBundle(
+  pkg: RuntimePackage,
+  opts: GetRuntimeBundleOptions = {}
+): Promise<BundleCacheEntry> {
   const hit = cache.get(pkg);
-  if (hit) return hit;
+  if (hit && !opts.skipPrebuilt) return hit;
+
+  // (1) Pre-built bundle path — try disk first (unless caller opts out).
+  if (!opts.skipPrebuilt) {
+    const prebuilt = await loadPrebuiltRuntimeBundle(pkg);
+    if (prebuilt) {
+      cache.set(pkg, prebuilt);
+      return prebuilt;
+    }
+  }
 
   // A throwaway entrypoint that re-exports every member of the target package.
   // We use named re-exports (default + an enumerated namespace) so the bundle
@@ -144,7 +189,7 @@ export async function getRuntimeBundle(pkg: RuntimePackage): Promise<BundleCache
     entrypoints: [entryName],
     target: 'browser',
     format: 'esm',
-    minify: false,
+    minify: opts.minify ?? false,
     splitting: false,
     define: {
       // Force React's production module (smaller, no dev-only `let React`
@@ -228,8 +273,8 @@ export function bunCacheRemediation(pkg: string, log: string): string | null {
   const basePkg = pkg.split('/')[0] ?? pkg;
   return [
     `  ⚠ Bun's global package cache for "${basePkg}" appears to be in a bad state`,
-    `    (truncated install, EISDIR/ENOENT on an index file).`,
-    ``,
+    '    (truncated install, EISDIR/ENOENT on an index file).',
+    '',
     `    Fix: run \`bun pm cache rm ${basePkg}\` then reload the page.`,
   ].join('\n');
 }

package/plugins/design/dev-server/server.ts

@@ -17,13 +17,13 @@
 import { spawn } from 'node:child_process';
 
 import { createApi } from './api.ts';
+import { bootSelfHeal } from './boot-self-heal.ts';
 import { createContext } from './context.ts';
 import { createFsWatch } from './fs-watch.ts';
 import { createHttp } from './http.ts';
 import { createInspect } from './inspect.ts';
 import { startHeapWatch } from './mem.ts';
 import { createWs } from './ws.ts';
-import { bootSelfHeal } from './boot-self-heal.ts';
 
 // Phase 19 / DDR-044 — covers the marketplace-cache-install gap where
 // node_modules/ ships empty (git clone honors .gitignore). Auto-installs +

package/plugins/design/dev-server/test/boot-self-heal.test.ts

@@ -1,19 +1,21 @@
-// Boot self-heal logic — Phase 19 / DDR-044.
-// Covers the marketplace-cache-install gap: if dist/ or node_modules/ is
-// missing on boot, self-heal runs bun install + build. Opt out with
-// MAUDE_NO_AUTOBUILD=1.
+// Boot artifact check — Phase 19 / DDR-044, simplified in v0.18.1.
+// v0.18.0 tried to `bun install` + `bun run build.ts` when node_modules/react
+// was missing; that misfired in every install scenario (see boot-self-heal.ts
+// header). v0.18.1 ships pre-built runtime bundles + just verifies they're
+// reachable. Missing artifact == broken install, not first-boot gap.
 
 import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
-import { bootSelfHeal, type SelfHealOptions } from '../boot-self-heal.ts';
+import { type SelfHealOptions, bootSelfHeal } from '../boot-self-heal.ts';
 
 let TMP: string;
 
 beforeEach(() => {
   TMP = mkdtempSync(join(tmpdir(), 'maude-self-heal-'));
+  mkdirSync(join(TMP, 'dist', 'runtime'), { recursive: true });
 });
 
 afterEach(() => {
@@ -21,16 +23,10 @@ afterEach(() => {
 });
 
 function harness(extra: Partial<SelfHealOptions> = {}) {
-  const calls: { cmd: readonly string[]; cwd: string }[] = [];
   const logs: string[] = [];
   let exited: number | null = null;
   const opts: SelfHealOptions = {
     here: TMP,
-    optOut: false,
-    spawn: async (cmd, cwd) => {
-      calls.push({ cmd, cwd });
-      return { code: 0 };
-    },
     log: (m) => logs.push(m),
     exit: ((code: number) => {
       exited = code;
@@ -38,75 +34,54 @@ function harness(extra: Partial<SelfHealOptions> = {}) {
     }) as never,
     ...extra,
   };
-  return { opts, calls, logs, getExited: () => exited };
+  return { opts, logs, getExited: () => exited };
 }
 
-function seedDist() {
-  mkdirSync(join(TMP, 'dist'), { recursive: true });
+function seedAll() {
   writeFileSync(join(TMP, 'dist', 'client.bundle.js'), '/* stub */');
-}
-
-function seedDeps() {
-  mkdirSync(join(TMP, 'node_modules', 'react'), { recursive: true });
-  writeFileSync(join(TMP, 'node_modules', 'react', 'package.json'), '{}');
+  writeFileSync(join(TMP, 'dist', 'runtime', 'react.js'), '/* stub */');
 }
 
 describe('bootSelfHeal', () => {
-  test('skips when dist + node_modules both present', async () => {
-    seedDist();
-    seedDeps();
-    const { opts, calls } = harness();
-    const result = await bootSelfHeal(opts);
-    expect(result.skipped).toBe('all-present');
-    expect(result.ran).toEqual([]);
-    expect(calls).toEqual([]);
-  });
-
-  test('runs `bun install --production` when node_modules/react is missing', async () => {
-    seedDist();
-    const { opts, calls } = harness();
-    const result = await bootSelfHeal(opts);
-    expect(result.ran).toEqual(['install']);
-    expect(calls).toHaveLength(1);
-    expect(calls[0]?.cmd).toEqual(['bun', 'install', '--production']);
-    expect(calls[0]?.cwd).toBe(TMP);
-  });
-
-  test('runs `bun run build.ts` when dist/client.bundle.js is missing', async () => {
-    seedDeps();
-    const { opts, calls } = harness();
+  test('passes when both required artifacts present', async () => {
+    seedAll();
+    const { opts, logs } = harness();
     const result = await bootSelfHeal(opts);
-    expect(result.ran).toEqual(['build']);
-    expect(calls).toHaveLength(1);
-    expect(calls[0]?.cmd).toEqual(['bun', 'run', 'build.ts']);
+    expect(result.verified).toEqual(['client.bundle.js', 'runtime/react.js']);
+    expect(logs).toEqual([]);
   });
 
-  test('runs install BEFORE build when both missing (build needs deps)', async () => {
-    const { opts, calls } = harness();
-    const result = await bootSelfHeal(opts);
-    expect(result.ran).toEqual(['install', 'build']);
-    expect(calls[0]?.cmd).toEqual(['bun', 'install', '--production']);
-    expect(calls[1]?.cmd).toEqual(['bun', 'run', 'build.ts']);
+  test('exits 1 with remediation when dist/client.bundle.js missing', async () => {
+    writeFileSync(join(TMP, 'dist', 'runtime', 'react.js'), '/* stub */');
+    const { opts, logs, getExited } = harness();
+    await expect(bootSelfHeal(opts)).rejects.toThrow('__exit:1');
+    expect(getExited()).toBe(1);
+    const msg = logs.join('\n');
+    expect(msg).toMatch(/dist\/client\.bundle\.js/);
+    expect(msg).toMatch(/npm uninstall -g @1agh\/maude/);
   });
 
-  test('MAUDE_NO_AUTOBUILD=1: exits 1 with remediation message; no spawn', async () => {
-    const { opts, calls, logs, getExited } = harness({ optOut: true });
+  test('exits 1 with remediation when dist/runtime/react.js missing', async () => {
+    writeFileSync(join(TMP, 'dist', 'client.bundle.js'), '/* stub */');
+    const { opts, logs, getExited } = harness();
     await expect(bootSelfHeal(opts)).rejects.toThrow('__exit:1');
     expect(getExited()).toBe(1);
-    expect(calls).toEqual([]);
-    expect(logs.join('\n')).toMatch(/MAUDE_NO_AUTOBUILD=1/);
-    expect(logs.join('\n')).toMatch(/dist\/client\.bundle\.js/);
-    expect(logs.join('\n')).toMatch(/node_modules\/react/);
+    const msg = logs.join('\n');
+    expect(msg).toMatch(/dist\/runtime\/react\.js/);
   });
 
-  test('spawn failure aborts with exit 1 + remediation hint', async () => {
-    seedDist(); // only deps missing
-    const { opts, logs, getExited } = harness({
-      spawn: async () => ({ code: 42 }),
-    });
+  test('lists ALL missing artifacts in one message (not first-fail-only)', async () => {
+    // Nothing seeded — both missing.
+    const { opts, logs } = harness();
     await expect(bootSelfHeal(opts)).rejects.toThrow('__exit:1');
-    expect(getExited()).toBe(1);
-    expect(logs.join('\n')).toMatch(/exited 42/);
-    expect(logs.join('\n')).toMatch(/MAUDE_NO_AUTOBUILD=1/);
+    const msg = logs.join('\n');
+    expect(msg).toMatch(/dist\/client\.bundle\.js/);
+    expect(msg).toMatch(/dist\/runtime\/react\.js/);
+  });
+
+  test('remediation surfaces the looked-under path so user can verify', async () => {
+    const { opts, logs } = harness();
+    await expect(bootSelfHeal(opts)).rejects.toThrow();
+    expect(logs.join('\n')).toContain(TMP);
   });
 });

package/plugins/design/dev-server/test/paths.test.ts

@@ -0,0 +1,31 @@
+// paths.ts — resolves real disk install root across dev mode, compiled npm
+// install, and compiled marketplace install. Phase 19.1 / v0.18.1.
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  CLIENT_DIR,
+  DEV_SERVER_ROOT,
+  DIST_DIR,
+  IS_COMPILED_BINARY,
+  RUNTIME_BUNDLES_DIR,
+} from '../paths.ts';
+
+describe('paths.ts', () => {
+  test('DEV_SERVER_ROOT contains http.ts + package.json (canonical anchor)', () => {
+    expect(DEV_SERVER_ROOT).not.toMatch(/\$bunfs|~BUN/);
+    expect(Bun.file(`${DEV_SERVER_ROOT}/http.ts`).size).toBeGreaterThan(0);
+    expect(Bun.file(`${DEV_SERVER_ROOT}/package.json`).size).toBeGreaterThan(0);
+  });
+
+  test('DIST_DIR + CLIENT_DIR + RUNTIME_BUNDLES_DIR are descendants of DEV_SERVER_ROOT', () => {
+    expect(DIST_DIR).toBe(`${DEV_SERVER_ROOT}/dist`);
+    expect(CLIENT_DIR).toBe(`${DEV_SERVER_ROOT}/client`);
+    expect(RUNTIME_BUNDLES_DIR).toBe(`${DEV_SERVER_ROOT}/dist/runtime`);
+  });
+
+  test('IS_COMPILED_BINARY is false when running under bun directly (this test)', () => {
+    // bun:test invokes via `bun`, so import.meta.url is a real file:// path.
+    expect(IS_COMPILED_BINARY).toBe(false);
+  });
+});