@ultimat3/cli 11.1.0 → 11.3.0

package/src/messages.ts

@@ -196,6 +196,20 @@ const CATALOG = {
   'cli.shot.verdict': '  verdict  {path}',
   'cli.shot.blind.status':
     'HTTP response status is not observed — the port records requests, never responses',
+  // `--island`. A component capture reports per STATE, so the summary counts pictures and the
+  // lines name one state each; nothing here restates a fact `--json` does not carry.
+  'cli.shot.island.ok':
+    '{island} clean — {pictures} picture(s), every one mounted, nothing logged and nothing threw',
+  'cli.shot.island.failed':
+    '{island}: {taken} of {expected} declared picture(s) taken — verdict.json names each refusal',
+  'cli.shot.island.state': '  {state}  {theme}  {width}x{height}  {file}',
+  'cli.shot.island.missing': '  missing  {file} — no picture was taken for this declared state',
+  'cli.shot.island.picture': '  pictures {path}',
+  'cli.shot.island.verdict': '  verdict  {path}',
+  'cli.shot.island.blind.crop':
+    'the picture is the viewport, not a crop — the browser port takes no clip rectangle, so a state sizes its own frame with viewport',
+  'cli.shot.island.blind.locale':
+    'toLocaleString() on a Date resolves its zone inside the engine — only an explicit timeZone is pinned by this harness',
   'cli.ci.failed':
     '{failed} of {runs} workflow run(s) on {branch} failed — {findings} finding(s) recovered from the log',
   'cli.ci.green': 'every one of {runs} workflow run(s) on {branch} passed',

package/src/reexport-manifest.ts

@@ -0,0 +1,62 @@
+// Whether a file is a pure re-export manifest — every statement in it an `import` or an `export`
+// that declares nothing. The line ceiling is a rule about REVIEWABLE LOGIC, and such a file has
+// none: its length is a function of the package's API size, so the ceiling measures the wrong
+// thing there. One added statement of logic disqualifies it and re-arms the ceiling on the spot.
+
+import { CLOSERS, maskLiterals, OPENERS } from './ts-scan';
+
+/** Every statement a manifest may hold begins with one of these two words. */
+const IMPORT_OR_EXPORT = /^(?:import|export)\b/;
+
+/**
+ * An `export` that DECLARES rather than re-exports. `export const LIMIT = 1` is a value with an
+ * initialiser, `export function` is logic outright, and both are exactly what the ceiling is for —
+ * so a file holding one is an ordinary source file that happens to start with re-exports.
+ */
+const DECLARES =
+  /^export\s+(?:default|declare|abstract|async|const|let|var|function|class|enum|namespace|module|interface)\b/;
+
+/**
+ * `export type { Ctx } from './ctx'` is a re-export; `export type Ctx = { … }` is a type alias, and
+ * an alias is a declaration a reviewer reads. The brace is the whole distinction.
+ */
+const TYPE_ALIAS = /^export\s+type\s+[A-Za-z_$]/;
+
+/**
+ * Top-level statements, split at the `;` that ends each one at bracket depth 0, over MASKED source
+ * — comments and string contents blanked — so a `;` inside a specifier or a comment is not read as
+ * a boundary. `undefined` when the file ends in something this cannot read as a statement: a scan
+ * that guesses would exempt a file on the strength of not understanding it.
+ */
+function topLevelStatements(masked: string): readonly string[] | undefined {
+  const statements: string[] = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < masked.length; i += 1) {
+    const ch = masked[i] as string;
+    if (OPENERS.has(ch)) depth += 1;
+    // Clamped, because an unbalanced closer would otherwise put every later `;` at a negative
+    // depth and the whole file would read as one unterminated statement.
+    else if (CLOSERS.has(ch)) depth = Math.max(0, depth - 1);
+    else if (ch === ';' && depth === 0) {
+      statements.push(masked.slice(start, i));
+      start = i + 1;
+    }
+  }
+  return masked.slice(start).trim() === '' ? statements : undefined;
+}
+
+/**
+ * True when every statement in `source` is an import or a declaration-free export. A file with no
+ * statement at all is NOT a manifest: an exemption has to be earned by what a file holds, and
+ * "this scan found nothing" is the one answer that must never grant one.
+ */
+export function isReExportManifest(source: string): boolean {
+  const statements = topLevelStatements(maskLiterals(source));
+  if (statements === undefined || statements.length === 0) return false;
+  return statements.every((statement) => {
+    const text = statement.trim();
+    if (text === '') return true;
+    return IMPORT_OR_EXPORT.test(text) && !DECLARES.test(text) && !TYPE_ALIAS.test(text);
+  });
+}

package/src/shot-browser.ts

@@ -0,0 +1,84 @@
+// Which browser a `x shot` run gets: start one in this container, or ATTACH to one somebody else is
+// running. Three rules over plain inputs and no `ParsedArgs`, so each is testable without a boot —
+// the `cmd-jobs.ts` / `jobs-report.ts` split, repeated for the one decision that is easy to get
+// silently wrong.
+
+import {
+  browserBinaryExists,
+  cdpUrlFrom,
+  cdpUrlProblem,
+  executablePathFrom,
+} from './browser-launcher';
+import { BadFlagError } from './errors';
+
+/** A runnable example, not a placeholder: every refusal below hands one of these back. */
+const CDP_FIX = 'x shot / --cdp-url wss://cdp.example.com/session/abc';
+
+/**
+ * Exactly one of these is set. `undefined` on both is the ordinary local run where the library
+ * finds its own Chrome — which is why neither is required rather than a union of two shapes.
+ */
+export interface ShotBrowserChoice {
+  /** Attach here. When set, nothing about a local executable was read. */
+  readonly cdpUrl?: string | undefined;
+  /** Launch this. Already proved to exist on disk. */
+  readonly executablePath?: string | undefined;
+}
+
+export interface ShotBrowserInput {
+  /** `--cdp-url` as typed. The env fallback is applied here, not by the caller. */
+  readonly cdpFlag?: string | undefined;
+  /** `--browser` as typed, before `PUPPETEER_EXECUTABLE_PATH` / `CHROME_PATH`. */
+  readonly browserFlag?: string | undefined;
+  readonly env: Readonly<Record<string, string | undefined>>;
+}
+
+/**
+ * Decided before anything boots, because a typo must not cost an embedded Postgres — and, on the
+ * attach path, a provider session — to report.
+ *
+ * The three rules, each chosen against a silent failure rather than for symmetry:
+ *
+ * 1. **Both FLAGS is refused, never ranked.** One names a Chrome to START and the other says the
+ *    browser is somebody else's, so honouring either ignores what was typed.
+ * 2. **An exported `SCRAPE_CDP_URL` loses to `--browser`.** A shell-wide default is not a typed
+ *    intent. The alternative is a flag that parses, reports nothing and quietly attaches somewhere
+ *    else — the `--critical` defect class `flag-reads.ts` exists for and cannot see here, because
+ *    the flag IS read.
+ * 3. **On an attach, no executable is read at all.** Checking the filesystem for a binary this run
+ *    will never execute is how a correct remote capture gets refused on a box with no Chrome.
+ */
+export function shotBrowserChoice(input: ShotBrowserInput): ShotBrowserChoice {
+  if (input.cdpFlag !== undefined && input.browserFlag !== undefined) {
+    throw new BadFlagError({
+      flag: 'cdp-url',
+      command: 'shot',
+      reason:
+        '--browser names a Chrome to launch here and --cdp-url attaches to one already running',
+      fix: CDP_FIX,
+    });
+  }
+  const cdpUrl = input.browserFlag === undefined ? cdpUrlFrom(input.cdpFlag, input.env) : undefined;
+  if (cdpUrl !== undefined) {
+    const problem = cdpUrlProblem(cdpUrl);
+    if (problem !== undefined) {
+      throw new BadFlagError({
+        flag: 'cdp-url',
+        command: 'shot',
+        reason: `"${cdpUrl}" ${problem}`,
+        fix: CDP_FIX,
+      });
+    }
+    return { cdpUrl };
+  }
+  const executablePath = executablePathFrom(input.browserFlag, input.env);
+  if (executablePath !== undefined && !browserBinaryExists(executablePath)) {
+    throw new BadFlagError({
+      flag: 'browser',
+      command: 'shot',
+      reason: `no executable at "${executablePath}"`,
+      fix: 'x shot / --browser /usr/bin/chromium',
+    });
+  }
+  return executablePath === undefined ? {} : { executablePath };
+}

package/src/shot-server.ts

@@ -0,0 +1,90 @@
+// The server a shot is taken against, and the hosts the page may reach while it is: the two
+// facts a ROUTE capture and a COMPONENT capture share, and the only ones. Its own file so
+// `island-shot.ts` can have them without importing the command that photographs a route, which
+// would be a cycle between two files that otherwise have nothing to say to each other.
+
+// why: no Bun native joins a path; `.x/shot` is a path both capture paths write under.
+import { join } from 'node:path';
+import { startDev } from './cmd-dev';
+import { clearLock, isProcessAlive, lockPath, parseLock, preflight, writeLock } from './dev-lock';
+import { DEV_BINDING } from './dev-roles';
+import { resolveServices } from './dev-services';
+
+export const SHOT_DIR = join('.x', 'shot');
+
+/**
+ * How `devServerFor` starts a scratch server. A parameter with a default rather than a direct
+ * call, for the reason every `Runner` in this package is one: the failure path below — a boot that
+ * throws, and the lock it has to hand back — is otherwise only reachable by breaking a real app.
+ */
+export type BootDevServer = (input: {
+  readonly root: string;
+  readonly port: number;
+  readonly env: Readonly<Record<string, string | undefined>>;
+}) => Promise<{ readonly url: string; stop(): Promise<void> }>;
+
+export interface ShotServer {
+  readonly url: string;
+  /** Which server the picture is of. Reported, because the two have different failure modes. */
+  readonly origin: 'booted' | 'reused';
+  stop(): Promise<void>;
+}
+
+/**
+ * One rule, two branches: photograph the `x dev` this checkout already has, or boot a scratch one.
+ * Reusing is not a convenience — embedded Postgres is a single-writer directory, so a second boot
+ * on one checkout is `X_DEV_ALREADY_RUNNING` and the picture would never be taken at all.
+ */
+export async function devServerFor(
+  root: string,
+  env: Readonly<Record<string, string | undefined>>,
+  port: number,
+  boot: BootDevServer = (input) => startDev(input),
+): Promise<ShotServer> {
+  const services = resolveServices(root, env);
+  const file = Bun.file(lockPath(services.stateDir));
+  if (await file.exists()) {
+    const lock = parseLock(await file.text());
+    if (lock !== null && isProcessAlive(lock.pid)) {
+      return { url: lock.url, origin: 'reused', stop: () => Promise.resolve() };
+    }
+  }
+  const { release } = await preflight({
+    stateDir: services.stateDir,
+    port,
+    hostname: DEV_BINDING.hostname,
+    embeddedDb: services.db.mode === 'embedded',
+  });
+  // The directory is CLAIMED from here down — `preflight` returns holding it, never having merely
+  // looked — so a boot that throws has to give it back. `cmd-dev.ts` states the same rule at the
+  // same seam. Without it one failed `x shot` refused every later `x dev` and `x shot` on this
+  // checkout, naming a pid that had already exited. The original error is re-thrown untouched: a
+  // teardown must never replace the failure it is cleaning up after.
+  const dev = await boot({ root, port, env }).catch((error: unknown) => {
+    release();
+    throw error;
+  });
+  await writeLock(services.stateDir, {
+    pid: process.pid,
+    port,
+    url: dev.url,
+    startedAt: new Date().toISOString(),
+  });
+  return {
+    url: dev.url,
+    origin: 'booted',
+    async stop() {
+      clearLock(services.stateDir);
+      await dev.stop();
+    },
+  };
+}
+
+/** `--allow-hosts a.com,b.com` on top of the app's own host. Empty means the app's host alone. */
+export const allowHostsFrom = (url: string, extra: string | undefined): readonly string[] => {
+  const named = (extra ?? '')
+    .split(',')
+    .map((host) => host.trim())
+    .filter((host) => host.length > 0);
+  return [new URL(url).hostname, ...named];
+};

package/src/shot-settle.ts

@@ -1,7 +1,8 @@
-// When a shot may be TAKEN: the two rules that decide whether the page has finished hydrating,
-// separated from both the command that drives a browser and the verdict that judges what came
-// back. Plain values and an injected sleep, so the whole loop is proved with neither.
+// When a shot may be TAKEN: the rules that decide whether the page has finished, separated from
+// both the command that drives a browser and the verdict that judges what came back. Plain values
+// and an injected sleep, so every loop here is proved with neither.
 
+import type { IslandReadiness } from './island-verdict';
 import type { IslandCount } from './shot-verdict';
 
 /**
@@ -55,3 +56,32 @@ export async function settleIslands(
   }
   return answer;
 }
+
+/**
+ * Read the harness's readiness until the page goes QUIET or the window runs out.
+ *
+ * Quiet and not idle, which is the whole rule: the page's own watcher sets `ready` after N
+ * consecutive frames in which no request started and none settled, so a state whose fixture is
+ * deliberately `pending` still reaches it. Waiting for nothing in flight would hang on exactly the
+ * state an author declared on purpose, and a fixed sleep would photograph whatever a slow machine
+ * had painted by then.
+ *
+ * A `null` answer never overwrites a real one, for `settleIslands`' reason: `null` is "the page
+ * answered no probe", and a probe that fails once must not turn a ready page into an unready one.
+ */
+export async function settleReadiness(
+  probe: () => Promise<IslandReadiness | null>,
+  options: SettleOptions,
+): Promise<IslandReadiness | null> {
+  const sleep = options.sleep ?? ((ms: number): Promise<void> => Bun.sleep(ms));
+  let answer = await probe();
+  let waited = 0;
+  while (answer?.ready !== true && waited < options.windowMs) {
+    // At least 1ms, or a `pollMs` of zero is a loop with no exit while the window stands.
+    const step = Math.max(1, Math.min(options.pollMs, options.windowMs - waited));
+    await sleep(step);
+    waited += step;
+    answer = (await probe()) ?? answer;
+  }
+  return answer;
+}

package/src/ts-scan.ts

@@ -161,10 +161,18 @@ export function lineIndex(text: string): (index: number) => number {
 }
 
 /**
- * Every string literal in the value expression starting at `from`, at the expression's own bracket
- * depth. Spanning the expression is what makes `cond ? 'a' : 'b'` and `table[k] ?? 'c'` checkable
- * instead of silently skipped; the depth rule is what keeps `command.join(' ')`'s separator and
- * `table['key']`'s key out — an argument is not a fix.
+ * Every string literal the value expression starting at `from` can EVALUATE TO, at the
+ * expression's own bracket depth. Spanning the expression is what makes `cond ? 'a' : 'b'` and
+ * `table[k] ?? 'c'` checkable instead of silently skipped; the depth rule is what keeps
+ * `command.join(' ')`'s separator and `table['key']`'s key out — an argument is not a fix.
+ *
+ * A ternary's CONDITION is dropped, which is the difference between reading the expression and
+ * reading every literal in it. `fix: input.slug === '' ? 'x g …' : 'x g …'` published the empty
+ * string as a fix line — `X_ERROR_FIX_INVALID`, "the fix line is empty", against source whose two
+ * real fixes are both correct — and `input.key === 'timeZone' ? … : …` published `timeZone`, a
+ * string then judged for banned phrases and cited paths that is not a fix at all. Costly enough
+ * that `@ultimat3/testing`'s island-state errors carry two classes under one code rather than one
+ * class with a ternary in it.
  */
 export function valueLiterals(
   masked: string,
@@ -173,21 +181,42 @@ export function valueLiterals(
   lineAt: (index: number) => number,
 ): readonly FixSite[] {
   const found: { value: string; index: number }[] = [];
+  // The literals of the segment being read. A segment ended by `?` is a condition and is dropped
+  // whole; one ended by `:` or by the end of the expression is a value the fix can evaluate to.
+  let segment: { value: string; index: number }[] = [];
+  const keep = (): void => {
+    found.push(...segment);
+    segment = [];
+  };
   let depth = 0;
+  /** Open `?`s still waiting for their `:`, so a `:` outside a ternary stays an ordinary char. */
+  let conditionals = 0;
   for (let i = from; i < masked.length; i += 1) {
     const ch = masked[i] as string;
     if (QUOTES.has(ch)) {
       const end = endOfLiteral(masked, i);
       // A quote that never closes is one character of code, not an empty literal to report.
       if (end === i + 1) continue;
-      if (depth === 0) found.push({ value: source.slice(i + 1, end - 1), index: i });
+      if (depth === 0) segment.push({ value: source.slice(i + 1, end - 1), index: i });
       i = end - 1;
     } else if (OPENERS.has(ch)) depth += 1;
     else if (CLOSERS.has(ch)) {
       if (depth === 0) break;
       depth -= 1;
+    } else if (depth === 0 && ch === '?') {
+      // `??` and `?.` are operators and end no segment: `input?.fix ?? 'x help'` evaluates to the
+      // literal, and dropping what came before it would drop the only answer the expression has.
+      if (masked[i + 1] === '?') i += 1;
+      else if (masked[i + 1] !== '.') {
+        segment = [];
+        conditionals += 1;
+      }
+    } else if (depth === 0 && ch === ':' && conditionals > 0) {
+      keep();
+      conditionals -= 1;
     } else if (depth === 0 && (ch === ',' || ch === ';')) break;
   }
+  keep();
   return found.map((literal) => ({
     at: '',
     line: lineAt(literal.index),

package/src/workspace-checks.ts

@@ -1,12 +1,20 @@
-// Four shape rules the gate owns: one file, one job (a hard line ceiling), every workspace
-// package shipping the same contract files, every published package's tarball matching what its
-// manifest promises, and every published package being in the root build graph. All report
-// findings — a shape rule that is only written down is not a rule (axiom 3).
+// Four shape rules the gate owns: one file, one job (a hard line ceiling on REVIEWABLE LOGIC),
+// every workspace package shipping the same contract files, every published package's tarball
+// matching what its manifest promises, and every published package being in the root build graph.
+// All report findings — a shape rule that is only written down is not a rule (axiom 3).
+//
+// The ceiling exempts a pure re-export manifest, and only that. Such a file has one job by
+// construction and its length is a function of the package's API size rather than of its
+// complexity: `@ultimat3/core`'s `src/index.ts` reached 514 lines with 513 statements and not one
+// of them logic, so the ceiling had stopped protecting anything and started refusing every new
+// public subject. `isReExportManifest` is the whole carve-out — one statement of logic in such a
+// file re-arms the ceiling on the same save, which is what keeps it from being a hole.
 
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { ERROR_DOCS_URL, renderCauseValue } from '@ultimat3/core';
 import type { Finding } from './output';
+import { isReExportManifest } from './reexport-manifest';
 import { eachSourceFile, isGenerated } from './source-files';
 import { checkRootReferences } from './tsconfig-references';
 
@@ -30,13 +38,21 @@ export const tooLongFinding = (path: string, lines: number): Finding => ({
 export const countLines = (text: string): number =>
   text === '' ? 0 : text.split('\n').length - (text.endsWith('\n') ? 1 : 0);
 
-/** Files are the unit of review: one file, one job, hard ceiling 500 lines. */
+/**
+ * Files are the unit of review: one file, one job, hard ceiling 500 lines of reviewable logic.
+ *
+ * The source is read before the count is judged rather than after, because the exemption is a
+ * question about CONTENTS: a 3,000-line file of re-exports is one job and a 501-line file with one
+ * statement of logic in it is not, and only reading tells them apart.
+ */
 export async function checkFileSizes(root: string): Promise<readonly Finding[]> {
   const findings: Finding[] = [];
   for await (const path of eachSourceFile(root)) {
     if (isGenerated(path)) continue;
-    const lines = countLines(await Bun.file(join(root, path)).text());
-    if (lines > LINE_CEILING) findings.push(tooLongFinding(path, lines));
+    const source = await Bun.file(join(root, path)).text();
+    const lines = countLines(source);
+    if (lines <= LINE_CEILING || isReExportManifest(source)) continue;
+    findings.push(tooLongFinding(path, lines));
   }
   return findings;
 }

package/src/island-solid-production.ts

@@ -1,129 +0,0 @@
-// Every `solid-js` import in an island chunk resolves to Solid's PRODUCTION browser build.
-// `Bun.build({ target: 'browser' })` always adds the `development` export condition and offers no
-// option that removes it — `conditions`, `production`, `env` and `define` were each measured under
-// Bun 1.4 and none of them does — so without this seam an island ships the dev bundle silently.
-
-// `node:path` by necessity: Bun ships no path API, and this file resolves a package entry back
-// to the directory its `exports` map is relative to.
-import { dirname, join } from 'node:path';
-import type { BunPlugin } from 'bun';
-import { IslandBuildFailedError } from './errors';
-
-/**
- * The conditions an island's `solid-js` subpath is resolved under. `development` is the one NOT in
- * the set, which is the whole point of the file; `production` is in it because an island chunk is
- * only ever built to be shipped — `x dev` serves the same chunk the container does, so a second
- * answer here would be a bundle the byte budget never measured.
- */
-const ISLAND_CONDITIONS: ReadonlySet<string> = new Set([
-  'production',
-  'browser',
-  'module',
-  'import',
-  'default',
-]);
-
-/** `solid-js` and its subpaths, and nothing else: Solid is the runtime an island is compiled for. */
-const SOLID_SPECIFIER = /^solid-js(?:\/|$)/;
-
-/**
- * Node's conditional-exports walk, restricted to what this file needs: the first key of the object
- * that the build's condition set contains, depth-first, with an array as an ordered fallback list.
- * Written out rather than delegated to `Bun.resolveSync` because the ONE thing it has to do
- * differently from Bun's resolver is refuse `development` — and `types` with it, which would
- * otherwise win on Solid's map and hand the bundler a `.d.ts`.
- */
-export function selectCondition(node: unknown, conditions: ReadonlySet<string>): string | null {
-  if (typeof node === 'string') return node;
-  if (Array.isArray(node)) {
-    for (const alternative of node as readonly unknown[]) {
-      const picked = selectCondition(alternative, conditions);
-      if (picked !== null) return picked;
-    }
-    return null;
-  }
-  if (typeof node !== 'object' || node === null) return null;
-  for (const [condition, value] of Object.entries(node)) {
-    if (!conditions.has(condition)) continue;
-    const picked = selectCondition(value, conditions);
-    if (picked !== null) return picked;
-  }
-  return null;
-}
-
-/** One parse per manifest: an island imports Solid from several files, and every file asks again. */
-const exportsCache = new Map<string, unknown>();
-
-async function exportsOf(manifest: string): Promise<unknown> {
-  const hit = exportsCache.get(manifest);
-  if (hit !== undefined || exportsCache.has(manifest)) return hit;
-  const parsed: unknown = JSON.parse(await Bun.file(manifest).text());
-  const field =
-    typeof parsed === 'object' && parsed !== null && 'exports' in parsed
-      ? (parsed as { readonly exports?: unknown }).exports
-      : undefined;
-  exportsCache.set(manifest, field);
-  return field;
-}
-
-/** Test seam: the cache is process-global because `x dev` rebuilds in one process. */
-export function clearSolidExportsCache(): void {
-  exportsCache.clear();
-}
-
-/**
- * The absolute file `specifier` must resolve to, or `null` for "Bun's own answer is already the
- * right one" — which is every subpath Solid declares as a plain string or a pattern, since a
- * declaration with no conditions on it cannot select the development build.
- */
-export async function solidProductionEntry(
-  specifier: string,
-  resolveDir: string,
-  importer: string,
-): Promise<string | null> {
-  let manifest: string;
-  try {
-    // `solid-js/package.json` is an `exports` entry of Solid's own map, so this reaches the exact
-    // copy the island would have imported — not a hoisted sibling at a different version.
-    manifest = Bun.resolveSync('solid-js/package.json', resolveDir);
-  } catch {
-    // Solid is not installed here. Bun's resolver says so, in its own words, naming the importer.
-    return null;
-  }
-  const field = await exportsOf(manifest);
-  const subpath = specifier === 'solid-js' ? '.' : `.${specifier.slice('solid-js'.length)}`;
-  if (typeof field !== 'object' || field === null || !(subpath in field)) return null;
-
-  const entry = selectCondition((field as Record<string, unknown>)[subpath], ISLAND_CONDITIONS);
-  const file = entry === null ? null : join(dirname(manifest), entry);
-  if (file === null || !(await Bun.file(file).exists())) {
-    throw new IslandBuildFailedError({
-      file: importer.length > 0 ? importer : specifier,
-      logs:
-        `${specifier} has no production browser entry: ${manifest} answers ` +
-        `${entry === null ? 'nothing' : JSON.stringify(entry)} under ` +
-        `[${[...ISLAND_CONDITIONS].join(', ')}], and an island may not ship Solid's ` +
-        'development build',
-    });
-  }
-  return file;
-}
-
-/**
- * The plugin `island-bundle.ts` hands `Bun.build`, beside `solidJsxPlugin`. Stateless apart from
- * the manifest cache, so one frozen descriptor serves every concurrent island build.
- *
- * The absolute path it answers with no longer matches `SOLID_SPECIFIER`, so Solid's own internal
- * `import … from 'solid-js'` is the only re-entry — and that one is wanted: it is how `web.js`
- * reaches `solid.js` rather than `dev.js`.
- */
-export const solidProductionPlugin: BunPlugin = {
-  name: 'ultimate-island-solid-production',
-  setup(build): void {
-    build.onResolve({ filter: SOLID_SPECIFIER }, async ({ path, importer, resolveDir }) => {
-      const from = resolveDir.length > 0 ? resolveDir : dirname(importer);
-      const entry = await solidProductionEntry(path, from, importer);
-      return entry === null ? undefined : { path: entry };
-    });
-  },
-};