diff --git a/README.md b/README.md
index d363b0ec2..3801a1d7f 100644
--- a/README.md
+++ b/README.md
@@ -248,4 +248,4 @@ Bulma framework!_
 
 ## License
 
-MIT © [Alex Smith](https://github.com/allxsmith)
+Source code licensed MIT
diff --git a/bestax-mcp/README.md b/bestax-mcp/README.md
index 3cb7a7cd2..1b1cc9e04 100644
--- a/bestax-mcp/README.md
+++ b/bestax-mcp/README.md
@@ -96,4 +96,4 @@ One per skill, so a task can start from the library's own guidance:
 - [Documentation](https://bestax.io)
 - [GitHub](https://github.com/allxsmith/bestax)
 
-MIT © Alex Smith
+Source code licensed MIT
diff --git a/bestax-mcp/data/skills.json b/bestax-mcp/data/skills.json
index 2f7959adf..4c77c280c 100644
--- a/bestax-mcp/data/skills.json
+++ b/bestax-mcp/data/skills.json
@@ -81,24 +81,43 @@
     },
     {
       "name": "bestax-migrate",
-      "description": "Migrate an existing app from react-bulma-components (v4) to @allxsmith/bestax-bulma on Bulma v1 — run the bestax-migrate codemod, then resolve every TODO(bestax-migrate) comment it leaves using the mapping references. Use when a repo imports react-bulma-components and wants to move to bestax-bulma, when TODO(bestax-migrate) comments are present in a codebase, or when asked to migrate off an unmaintained React Bulma library.",
+      "description": "Migrate an existing app from an unmaintained React Bulma library — react-bulma-components (v4) or rbx (v2) — to @allxsmith/bestax-bulma on Bulma v1. Run the bestax-migrate codemod, then resolve every TODO(bestax-migrate) comment it leaves using the per-source mapping references. Use when a repo imports react-bulma-components or rbx and wants to move to bestax-bulma, when TODO(bestax-migrate) comments are present in a codebase, or when asked to migrate off an unmaintained React Bulma library.",
       "promptName": "migrate",
       "dir": "bestax-migrate",
       "references": [
         {
-          "id": "component-map",
-          "file": "references/component-map.md",
+          "id": "css-migration",
+          "file": "references/css-migration.md",
+          "bytes": 8555
+        },
+        {
+          "id": "rbx-component-map",
+          "file": "references/rbx/component-map.md",
+          "bytes": 12252
+        },
+        {
+          "id": "rbx-prop-map",
+          "file": "references/rbx/prop-map.md",
+          "bytes": 7973
+        },
+        {
+          "id": "rbx-unmappables",
+          "file": "references/rbx/unmappables.md",
+          "bytes": 11237
+        },
+        {
+          "id": "react-bulma-components-component-map",
+          "file": "references/react-bulma-components/component-map.md",
           "bytes": 13190
         },
         {
-          "id": "css-migration",
-          "file": "references/css-migration.md",
-          "bytes": 7999
+          "id": "react-bulma-components-prop-map",
+          "file": "references/react-bulma-components/prop-map.md",
+          "bytes": 6363
         },
-        { "id": "prop-map", "file": "references/prop-map.md", "bytes": 6363 },
         {
-          "id": "unmappables",
-          "file": "references/unmappables.md",
+          "id": "react-bulma-components-unmappables",
+          "file": "references/react-bulma-components/unmappables.md",
           "bytes": 4861
         }
       ],
diff --git a/bestax-migrate/CLAUDE.md b/bestax-migrate/CLAUDE.md
index 662f7b5f8..ac2ab50b5 100644
--- a/bestax-migrate/CLAUDE.md
+++ b/bestax-migrate/CLAUDE.md
@@ -2,19 +2,37 @@
 
 jscodeshift-based CLI (`pnpm dlx bestax-migrate <source> <paths…>`) that migrates existing
 apps from other React Bulma libraries to `@allxsmith/bestax-bulma`. Multi-source by design:
-each source library registers in `src/sources/registry.ts`; the first is
-`react-bulma-components` (v4 only).
+each source library registers in `src/sources/registry.ts`. Two are shipped —
+`react-bulma-components` (v4 only) and `rbx` (v2 only).
 
 ## Hard rules
 
-- **react-bulma-components is NEVER installed anywhere in this repo** (supply-chain
-  policy). Fixtures are read as _text_ (`__testfixtures__`, `fixtures/kitchen-sink`); the
-  migration _input_ is never typechecked or executed. Validation typechecks the migrated
-  _output_ against the workspace `@allxsmith/bestax-bulma`.
-- Mapping-table first: `src/sources/react-bulma-components/mapping.ts` is the single source
-  of truth. Every RBC v4 export must have an entry (`mapped`/`partial`/`todo`) — the
-  `mapping-coverage` test walks the vendored `RBC_EXPORTS` list against it. New coverage is
-  a table edit (plus a `special` handler in `specials.ts` when structure changes).
+- **No source library is EVER installed anywhere in this repo** (supply-chain policy) —
+  not react-bulma-components, not rbx. Fixtures are read as _text_ (`__testfixtures__`,
+  `fixtures/kitchen-sink`, `fixtures/rbx-kitchen-sink`); the migration _input_ is never
+  typechecked or executed. Validation typechecks the migrated _output_ against the
+  workspace `@allxsmith/bestax-bulma`.
+- Mapping-table first: each source's `mapping.ts` is its single source of truth. Every
+  export of that library must have an entry (`mapped`/`partial`/`todo`) — the
+  `mapping-coverage` test walks the vendored `RBC_EXPORTS` / `RBX_EXPORTS` list against it,
+  in both directions, so the table cannot grow an entry for something the library never
+  exported either. New coverage is a table edit (plus a `special` handler in `specials.ts`
+  when structure changes).
+- **A new source is a directory plus one registry line.** `src/sources/_shared/` holds
+  everything library-agnostic: `jsx-utils.ts` (AST helpers + `TransformContext`),
+  `props.ts` (the `PropAction` interpreter — its universal table is a parameter, not an
+  import), `imports.ts` (binding collection and import aliasing), `specials-utils.ts`
+  (`alignTarget`, `mergeClassName`, `parseIconClasses`, and the `stripModifierProps`
+  factory), and `make-styles-transform.ts` (the whole Bulma 0.9→v1 stylesheet transform,
+  parameterised by the source package's own specifiers). What stays per-source is the data
+  — `mapping.ts`, `specials.ts`, `responsive.ts`, `deps.ts` — plus a `transform.ts` that
+  orchestrates them.
+- `'<source>'` must be added to `MIGRATE_SOURCE_VALUES` in `telemetry-worker/src/schema.ts`
+  or its events are dropped at ingest; `check:conformance --only=telemetry-allowlists`
+  fails until it is. That worker deploys to production on merge, so the two land together.
+  The same check regex-scrapes each source's `index.ts` for
+  `: MigrationSource = { … name: '…' }` — a declaration that doesn't match that shape is a
+  hard violation, not a skip.
 - Anything unsafe gets a `// TODO(bestax-migrate): <hint>` comment on the enclosing
   statement + a report entry — never a silent skip, never a best-guess rewrite of dynamic
   values.
@@ -58,12 +76,20 @@ each source library registers in `src/sources/registry.ts`; the first is
   supported ones go in the other fixture files, which must stay TODO-free.
 - Fixtures and `.e2e-tmp` are excluded from tsc/eslint/prettier at both root and package
   level (root `eslint.config.js` + both `.prettierignore`s) — keep them that way.
-- Real-world corpus: `pnpm --filter bestax-migrate validate:corpus` fetches the
-  react-bulma-components repo's own MIT-licensed Storybook stories (pinned SHA, text only,
-  into `.e2e-tmp/`) and scores the transform over them — fails on any crash or
-  unknown-component TODO. Deliberately NOT in CI (no third-party fetches in the pipeline);
-  run it before releases and after mapping changes, and eyeball the before/after diffs it
-  writes to `.e2e-tmp/corpus-out/`.
+- Real-world corpus, one script per source, both fetching a pinned SHA as text only into
+  `.e2e-tmp/` and failing on any crash or unknown-component TODO. Deliberately NOT in CI
+  (no third-party fetches in the pipeline); run them before releases and after mapping
+  changes, and eyeball the before/after diffs they write:
+  - `validate:corpus` — react-bulma-components' own MIT Storybook stories →
+    `.e2e-tmp/corpus-out/`.
+  - `validate:corpus:rbx` — rbx's own MIT docs. rbx used **docz**, not Storybook, so the
+    script extracts the `<Playground>` blocks out of its 43 `*.docs.mdx` pages (254 blocks)
+    and rebuilds each page as one synthetic module written the way a consumer writes rbx.
+    Output lands in `.e2e-tmp/corpus-out-rbx/`.
+
+  The corpus is the only check that sees breadth; the kitchen-sink e2e is the only one that
+  sees bestax's _real_ prop names. Both are needed — the rbx e2e's typecheck caught six
+  mapping errors that 254 clean Playgrounds had not.
 
 ## Releases
 
diff --git a/bestax-migrate/README.md b/bestax-migrate/README.md
index d04c3782b..8a74f058d 100644
--- a/bestax-migrate/README.md
+++ b/bestax-migrate/README.md
@@ -13,9 +13,12 @@ Codemods that migrate existing React apps to [`@allxsmith/bestax-bulma`](https:/
 
 Currently supported source libraries:
 
-| Source                                                                           | Status                                                            |
-| -------------------------------------------------------------------------------- | ----------------------------------------------------------------- |
-| [`react-bulma-components`](https://github.com/couds/react-bulma-components) (v4) | ✅ All 32 components mapped (a few patterns are flagged as TODOs) |
+| Source                                                                           | Status                                                              |
+| -------------------------------------------------------------------------------- | ------------------------------------------------------------------- |
+| [`react-bulma-components`](https://github.com/couds/react-bulma-components) (v4) | ✅ All 32 components mapped (a few patterns are flagged as TODOs)   |
+| [`rbx`](https://github.com/dfee/rbx) (v2)                                        | ✅ Full export surface mapped (a few patterns are flagged as TODOs) |
+
+Pass the source library as the first argument: `bestax-migrate <source> <paths…>`.
 
 ## Requirements
 
@@ -30,6 +33,8 @@ the app being migrated — the source is read as text and is never executed.
 ```bash
 # Preview what would change (no writes)
 pnpm dlx bestax-migrate react-bulma-components src/ --dry
+# …or, for an rbx app
+pnpm dlx bestax-migrate rbx src/ --dry
 
 # Apply the migration
 pnpm dlx bestax-migrate react-bulma-components src/
@@ -39,15 +44,15 @@ npm and yarn work too: `npx bestax-migrate …` / `yarn dlx bestax-migrate …`.
 
 The codemod uses [jscodeshift](https://github.com/facebook/jscodeshift) to:
 
-- rewrite `react-bulma-components` imports to `@allxsmith/bestax-bulma` (including `const { Input } = Form` destructuring and namespace imports)
+- rewrite the source library's imports to `@allxsmith/bestax-bulma` (including destructuring and namespace imports)
 - rename components and compound sub-components (`Form.Textarea` → `TextArea`, `Card.Footer.Item` → `Card.FooterItem`, `Hero.Footer` → `Hero.Foot`, …)
 - convert props (`renderAs` → `as`, `loading` → `isLoading`, numeric spacing/text sizes → string unions, `textAlign="center"` → `textAlign="centered"`, …)
 - flatten responsive breakpoint objects (`mobile={{ size: 4 }}` → `sizeMobile={4}`)
 - restructure patterns bestax models differently (`Table.Container`, Navbar dropdowns, `Form.Help`, icon-font children → `<Icon name=…>`)
 - migrate stylesheets: CSS imports converge on `@allxsmith/bestax-bulma/bestax.css`, and SCSS files move from Bulma 0.9's `@import` + `$var !default` overrides to `@use 'bulma/sass' with (…)` plus `@use '@allxsmith/bestax-bulma/scss/extras'`
-- update `package.json`: remove `react-bulma-components`, add `@allxsmith/bestax-bulma`, bump `bulma` to `^1`, and swap the dead `node-sass` for dart `sass` (no install is ever run)
+- update `package.json`: remove the source library, add `@allxsmith/bestax-bulma`, raise a declared pre-1.0 `bulma` to `^1` (adding it only when your sources import `bulma/…` directly — otherwise it arrives transitively), and swap the dead `node-sass` for dart `sass` (no install is ever run). Migrating **rbx** is what frees an app from Bulma 0.7.5: rbx pinned it as a _direct_ dependency, so the app could not choose its own Bulma version at all. The four Bulma extensions rbx also pulled in (`bulma-badge`, `bulma-divider`, `bulma-pageloader`, `bulma-tooltip`) are **reported rather than removed** — bestax replaces all four, but a manifest entry is a deliberate declaration and your own Sass may import them
 
-Anything without a safe automatic conversion is left in place with a `// TODO(bestax-migrate): …` comment, and the run ends with a report of every TODO by file and line. TODOs are expected output, not errors — resolve them with the [migration guide](https://bestax.io/docs/guides/getting-started/migration/react-bulma-components), or let the [`bestax-migrate` Agent Skill](https://bestax.io/docs/skills/intro) walk them for you:
+Anything without a safe automatic conversion is left in place with a `// TODO(bestax-migrate): …` comment, and the run ends with a report of every TODO by file and line. TODOs are expected output, not errors — resolve them with the migration guide ([react-bulma-components](https://bestax.io/docs/guides/getting-started/migration/react-bulma-components), [rbx](https://bestax.io/docs/guides/getting-started/migration/rbx)), or let the [`bestax-migrate` Agent Skill](https://bestax.io/docs/skills/intro) walk them for you:
 
 ```bash
 npx skills add https://github.com/allxsmith/bestax --skill bestax-migrate
@@ -69,7 +74,7 @@ npx skills add https://github.com/allxsmith/bestax --skill bestax-migrate
 2. Search for `TODO(bestax-migrate)` and resolve each comment
 3. Typecheck/build and review the rendered app
 
-Full walkthrough: [react-bulma-components migration guide](https://bestax.io/docs/guides/getting-started/migration/react-bulma-components).
+Full walkthrough: [react-bulma-components migration guide](https://bestax.io/docs/guides/getting-started/migration/react-bulma-components) · [rbx migration guide](https://bestax.io/docs/guides/getting-started/migration/rbx).
 
 ## Hardened by default
 
@@ -100,4 +105,4 @@ Full disclosure of every field and control: [Telemetry guide](https://bestax.io/
 
 ## License
 
-MIT © Alex Smith
+Source code licensed MIT
diff --git a/bestax-migrate/e2e/rbx-kitchen-sink.test.ts b/bestax-migrate/e2e/rbx-kitchen-sink.test.ts
new file mode 100644
index 000000000..acc2f6c48
--- /dev/null
+++ b/bestax-migrate/e2e/rbx-kitchen-sink.test.ts
@@ -0,0 +1,326 @@
+/**
+ * End-to-end gate: copy the source-only rbx kitchen-sink app into .e2e-tmp/,
+ * run the codemod on every file, then typecheck the MIGRATED output against
+ * the real @allxsmith/bestax-bulma types (workspace dependency — bulma-ui
+ * must be built first; turbo orders this).
+ *
+ * rbx itself is never installed: the input app is never typechecked, and
+ * leftovers.tsx — the file that exercises everything the codemod
+ * intentionally refuses to convert — is excluded from the output typecheck
+ * and asserted through its TODO annotations instead.
+ */
+
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { rbx } from '../src/sources/rbx/index.js';
+import { runTransform } from '../src/runner.js';
+import type { TodoEntry } from '../src/types.js';
+import { compileMigratedScss } from './support/compile-scss.js';
+
+const packageRoot = path.join(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '..'
+);
+const fixtureDir = path.join(packageRoot, 'fixtures', 'rbx-kitchen-sink');
+
+// One scratch directory PER PROCESS, not one shared path — see the comment in
+// kitchen-sink.test.ts for why (`pnpm all` runs two jest processes over this
+// file concurrently). BESTAX_E2E_KEEP=1 leaves it behind for inspection.
+const tmpRoot = path.join(packageRoot, '.e2e-tmp');
+fs.mkdirSync(tmpRoot, { recursive: true });
+const tmpDir = fs.mkdtempSync(path.join(tmpRoot, 'rbx-kitchen-sink-'));
+
+interface MigratedApp {
+  todosByFile: Map<string, TodoEntry[]>;
+  files: string[];
+  /**
+   * package.json entries are tracked separately: every `deps` entry is a
+   * report line describing what the updater changed, not a problem the user
+   * has to fix, so they must not count against the "no TODOs" assertion.
+   */
+  depTodos: TodoEntry[];
+}
+
+function migrateKitchenSink(): MigratedApp {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+  fs.cpSync(fixtureDir, tmpDir, { recursive: true });
+
+  const srcDir = path.join(tmpDir, 'src');
+  const files = fs.readdirSync(srcDir).filter(f => /\.(tsx?|jsx?)$/.test(f));
+  const todosByFile = new Map<string, TodoEntry[]>();
+
+  for (const file of files) {
+    const filePath = path.join(srcDir, file);
+    const source = fs.readFileSync(filePath, 'utf8');
+    const todos: TodoEntry[] = [];
+    const { output } = runTransform(rbx.transform, file, source, {
+      add: entry => todos.push(entry),
+    });
+    if (output !== null) fs.writeFileSync(filePath, output);
+    todosByFile.set(file, todos);
+  }
+
+  const scssPath = path.join(srcDir, 'styles.scss');
+  const scssTodos: TodoEntry[] = [];
+  const scssOut = rbx.transformStyles!(
+    'styles.scss',
+    fs.readFileSync(scssPath, 'utf8'),
+    { add: entry => scssTodos.push(entry) },
+    { cssMode: 'bestax' }
+  );
+  if (scssOut !== null) fs.writeFileSync(scssPath, scssOut);
+  todosByFile.set('styles.scss', scssTodos);
+
+  const pkgPath = path.join(tmpDir, 'package.json');
+  const pkgTodos: TodoEntry[] = [];
+  const pkgNext = rbx.updateDependencies!(
+    'package.json',
+    JSON.parse(fs.readFileSync(pkgPath, 'utf8')),
+    { add: entry => pkgTodos.push(entry) },
+    { cssMode: 'bestax', bulmaReferenced: true }
+  );
+  if (pkgNext !== null) {
+    fs.writeFileSync(pkgPath, `${JSON.stringify(pkgNext, null, 2)}\n`);
+  }
+
+  return { todosByFile, files, depTodos: pkgTodos };
+}
+
+describe('rbx kitchen-sink e2e', () => {
+  let app: MigratedApp;
+
+  beforeAll(() => {
+    app = migrateKitchenSink();
+  });
+
+  afterAll(() => {
+    if (!process.env.BESTAX_E2E_KEEP) {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('migrates every kitchen-sink file', () => {
+    expect(app.files.sort()).toEqual([
+      'App.tsx',
+      'components.tsx',
+      'elements.tsx',
+      'form.tsx',
+      'grid.tsx',
+      'helpers.tsx',
+      'layout.tsx',
+      'leftovers.tsx',
+    ]);
+    for (const file of app.files) {
+      const migrated = fs.readFileSync(path.join(tmpDir, 'src', file), 'utf8');
+      // Only leftovers.tsx may keep its (trimmed, TODO-annotated) rbx import.
+      if (file !== 'leftovers.tsx') {
+        expect({ file, hasRbx: /from ["']rbx["']/.test(migrated) }).toEqual({
+          file,
+          hasRbx: false,
+        });
+      }
+    }
+  });
+
+  it('leaves no TODOs outside leftovers.tsx, bar the Modal advisory', () => {
+    // `component:Modal` fires on EVERY conversion by design: bestax renders
+    // the modal inline and implements neither Escape-to-close nor scroll
+    // locking, all of which rbx did by default. The markup migrates cleanly —
+    // this file still typechecks — but the behaviour differs, and nothing
+    // else would tell the user.
+    for (const [file, todos] of app.todosByFile) {
+      if (file === 'leftovers.tsx') continue;
+      const unexpected = todos.filter(t => t.rule !== 'component:Modal');
+      expect({ file, todos: unexpected }).toEqual({ file, todos: [] });
+    }
+    const components = app.todosByFile.get('components.tsx') ?? [];
+    expect(components.every(t => t.rule === 'component:Modal')).toBe(true);
+  });
+
+  it('adopts the bestax combined CSS bundle in App.tsx', () => {
+    const migrated = fs.readFileSync(
+      path.join(tmpDir, 'src', 'App.tsx'),
+      'utf8'
+    );
+    expect(migrated).toContain('import "@allxsmith/bestax-bulma/bestax.css";');
+    expect(migrated).not.toContain('rbx/index.css');
+  });
+
+  it('turns rbx helper props into wrapping Badge and Tooltip components', () => {
+    const migrated = fs.readFileSync(
+      path.join(tmpDir, 'src', 'helpers.tsx'),
+      'utf8'
+    );
+    expect(migrated).toContain('<Badge content="4" color="danger">');
+    expect(migrated).toContain('<Tooltip label="Help" position="right"');
+    // And the flattened breakpoint objects.
+    expect(migrated).toContain('visibilityMobile="hidden"');
+    expect(migrated).toContain('displayTablet="flex"');
+  });
+
+  it('migrates the SCSS entry to Bulma v1 modules', () => {
+    const scss = fs.readFileSync(
+      path.join(tmpDir, 'src', 'styles.scss'),
+      'utf8'
+    );
+    expect(scss).toContain("@use 'bulma/sass' with (");
+    expect(scss).not.toContain('~rbx/rbx');
+  });
+
+  it('compiles the migrated SCSS entry with Dart Sass', () => {
+    const scss = fs.readFileSync(
+      path.join(tmpDir, 'src', 'styles.scss'),
+      'utf8'
+    );
+    const { status, diagnostics } = compileMigratedScss(scss);
+    expect({ status, diagnostics }).toEqual({ status: 0, diagnostics: '' });
+  });
+
+  it('deletes rbx, bumps Bulma, and reports the extensions', () => {
+    const pkg = JSON.parse(
+      fs.readFileSync(path.join(tmpDir, 'package.json'), 'utf8')
+    );
+    expect(pkg.dependencies.rbx).toBeUndefined();
+    // The four extensions are reported, not deleted: a manifest entry is a
+    // deliberate declaration and the app's own Sass may import them.
+    expect(pkg.dependencies['bulma-badge']).toBe('^3.0.1');
+    expect(pkg.dependencies['bulma-tooltip']).toBe('^2.0.2');
+    expect(pkg.dependencies['@allxsmith/bestax-bulma']).toBe('^5');
+    expect(pkg.dependencies.bulma).toBe('^1.0.4');
+    expect(pkg.devDependencies['node-sass']).toBeUndefined();
+    expect(pkg.devDependencies.sass).toBe('^1.79.0');
+  });
+
+  it('reports the dependency changes and the React 16 peer gap', () => {
+    const messages = app.depTodos.map(t => `${t.rule}: ${t.message}`);
+    expect(
+      messages.some(m => /^deps: removed rbx and bumped bulma/.test(m))
+    ).toBe(true);
+    expect(
+      messages.some(m => /are Bulma extensions rbx depended on/.test(m))
+    ).toBe(true);
+    expect(messages.some(m => m.startsWith('peer-deps: react ^16.8.6'))).toBe(
+      true
+    );
+  });
+
+  it('annotates every intentionally unsupported pattern in leftovers.tsx', () => {
+    const todos = app.todosByFile.get('leftovers.tsx') ?? [];
+    const rules = new Set(todos.map(t => t.rule));
+    expect(rules).toContain('component:Tile');
+    expect(rules).toContain('component:List');
+    expect(rules).toContain('component:Generic');
+    expect(rules).toContain('component:Fieldset');
+    expect(rules).toContain('component:Numeric');
+    expect(rules).toContain('component:Highlight');
+    expect(rules).toContain('component:Icon');
+    expect(rules).toContain('component:File.Label');
+    expect(rules).toContain('component:Dropdown');
+    expect(todos.length).toBeGreaterThanOrEqual(10);
+    const migrated = fs.readFileSync(
+      path.join(tmpDir, 'src', 'leftovers.tsx'),
+      'utf8'
+    );
+    expect(migrated).toContain('TODO(bestax-migrate)');
+    // Unmappable components keep a trimmed, TODO-annotated rbx import.
+    expect(migrated).toMatch(/from ["']rbx["']/);
+  });
+
+  it('documents every TODO rule it emits in the skill reference', () => {
+    // A rule with no recipe is a dead end for the user reading the report.
+    // `component:Modal` shipped exactly that way — emitted on every Modal
+    // conversion, documented nowhere — and only a reviewer caught it.
+    const skillDir = path.join(packageRoot, '..', 'skills', 'bestax-migrate');
+    const refsDir = path.join(skillDir, 'references', 'rbx');
+    const refs = [
+      ...fs
+        .readdirSync(refsDir)
+        .filter(f => f.endsWith('.md'))
+        .map(f => path.join(refsDir, f)),
+      path.join(skillDir, 'SKILL.md'),
+    ]
+      .map(f => fs.readFileSync(f, 'utf8'))
+      .join('\n');
+
+    const emitted = new Set<string>();
+    for (const todos of app.todosByFile.values()) {
+      for (const todo of todos) emitted.add(todo.rule);
+    }
+    for (const todo of app.depTodos) emitted.add(todo.rule);
+    expect(emitted.size).toBeGreaterThan(0);
+
+    // Match documented rule TOKENS, not substrings. `refs.includes(rule)`
+    // let `component:List` pass off the text of `component:List.Item`, and
+    // the prop fallback matched any backticked occurrence of the word
+    // anywhere in prose — so the guard could pass while the rule it was
+    // meant to pin went undocumented.
+    const tokens = new Set(
+      [...refs.matchAll(/(?:component|prop):[A-Za-z][\w.*]*/g)].map(m => m[0])
+    );
+    // A prop rule may instead be written bare in a row that names the
+    // component beside it (`| \`expanded\` on \`Field\` |`).
+    const backticked = new Set(
+      [...refs.matchAll(/`([A-Za-z][\w.-]*)`/g)].map(m => m[1])
+    );
+
+    const documented = (rule: string): boolean => {
+      if (tokens.has(rule)) return true;
+      if (rule.startsWith('component:')) {
+        // A dotted part may be covered by its parent's section, which the
+        // reference writes as `component:File.*` or as a section for the
+        // parent component itself.
+        const parent = rule.slice('component:'.length).split('.')[0];
+        return (
+          tokens.has(`component:${parent}.*`) ||
+          tokens.has(`component:${parent}`)
+        );
+      }
+      if (rule.startsWith('prop:')) {
+        return backticked.has(rule.slice('prop:'.length));
+      }
+      return backticked.has(rule);
+    };
+
+    const undocumented = [...emitted].sort().filter(r => !documented(r));
+    expect(undocumented).toEqual([]);
+  });
+
+  it('typechecks the migrated output against @allxsmith/bestax-bulma', () => {
+    fs.writeFileSync(
+      path.join(tmpDir, 'global.d.ts'),
+      "declare module '*.css';\ndeclare module '*.scss';\n"
+    );
+    fs.writeFileSync(
+      path.join(tmpDir, 'tsconfig.json'),
+      JSON.stringify(
+        {
+          compilerOptions: {
+            strict: true,
+            noEmit: true,
+            jsx: 'react-jsx',
+            module: 'ESNext',
+            target: 'ES2022',
+            moduleResolution: 'bundler',
+            lib: ['ES2022', 'DOM', 'DOM.Iterable'],
+            skipLibCheck: true,
+          },
+          include: ['src/**/*', 'global.d.ts'],
+          exclude: ['src/leftovers.tsx'],
+        },
+        null,
+        2
+      )
+    );
+    const result = spawnSync('pnpm', ['exec', 'tsc', '-p', tmpDir], {
+      cwd: packageRoot,
+      encoding: 'utf8',
+    });
+    const diagnostics = `${result.stdout ?? ''}\n${result.stderr ?? ''}`.trim();
+    expect({ status: result.status, diagnostics }).toEqual({
+      status: 0,
+      diagnostics: '',
+    });
+  }, 120000);
+});
diff --git a/bestax-migrate/fixtures/rbx-kitchen-sink/package.json b/bestax-migrate/fixtures/rbx-kitchen-sink/package.json
new file mode 100644
index 000000000..c90e9d1fc
--- /dev/null
+++ b/bestax-migrate/fixtures/rbx-kitchen-sink/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "rbx-kitchen-sink",
+  "private": true,
+  "version": "0.0.0",
+  "dependencies": {
+    "bulma": "0.7.5",
+    "bulma-badge": "^3.0.1",
+    "bulma-divider": "^0.2.0",
+    "bulma-pageloader": "^2.1.0",
+    "bulma-tooltip": "^2.0.2",
+    "rbx": "^2.2.0",
+    "react": "^16.8.6",
+    "react-dom": "^16.8.6",
+    "@fortawesome/react-fontawesome": "^0.1.4",
+    "@fortawesome/free-solid-svg-icons": "^5.9.0"
+  },
+  "devDependencies": {
+    "node-sass": "^4.12.0"
+  }
+}
diff --git a/bestax-migrate/fixtures/rbx-kitchen-sink/src/App.tsx b/bestax-migrate/fixtures/rbx-kitchen-sink/src/App.tsx
new file mode 100644
index 000000000..14de3cf7c
--- /dev/null
+++ b/bestax-migrate/fixtures/rbx-kitchen-sink/src/App.tsx
@@ -0,0 +1,20 @@
+import React from "react";
+import "rbx/index.css";
+import "./styles.scss";
+import { Elements } from "./elements";
+import { Components } from "./components";
+import { FormControls } from "./form";
+import { Layout } from "./layout";
+import { Grid } from "./grid";
+import { Helpers } from "./helpers";
+
+export const App = () => (
+  <>
+    <Elements />
+    <Components />
+    <FormControls />
+    <Layout />
+    <Grid />
+    <Helpers />
+  </>
+);
diff --git a/bestax-migrate/fixtures/rbx-kitchen-sink/src/components.tsx b/bestax-migrate/fixtures/rbx-kitchen-sink/src/components.tsx
new file mode 100644
index 000000000..4b5a8b91e
--- /dev/null
+++ b/bestax-migrate/fixtures/rbx-kitchen-sink/src/components.tsx
@@ -0,0 +1,102 @@
+import React from "react";
+import {
+  Breadcrumb,
+  Card,
+  Level,
+  Media,
+  Menu,
+  Message,
+  Modal,
+  Navbar,
+  Pagination,
+  Panel,
+  Tab,
+} from "rbx";
+
+export const Components = () => (
+  <>
+    <Card>
+      <Card.Header>
+        <Card.Header.Title align="centered">Card</Card.Header.Title>
+        <Card.Header.Icon>+</Card.Header.Icon>
+      </Card.Header>
+      <Card.Content>Body</Card.Content>
+      <Card.Footer>
+        <Card.Footer.Item>Action</Card.Footer.Item>
+      </Card.Footer>
+    </Card>
+    <Breadcrumb align="centered" separator="bullet" size="small">
+      <Breadcrumb.Item href="/">Home</Breadcrumb.Item>
+      <Breadcrumb.Item active href="/here">
+        Here
+      </Breadcrumb.Item>
+    </Breadcrumb>
+    <Level breakpoint="mobile">
+      <Level.Item align="left">Left</Level.Item>
+      <Level.Item>Middle</Level.Item>
+      <Level.Item align="right">Right</Level.Item>
+    </Level>
+    <Media>
+      <Media.Item align="left">Avatar</Media.Item>
+      <Media.Item align="content">Content</Media.Item>
+      <Media.Item align="right">Extra</Media.Item>
+    </Media>
+    <Menu>
+      <Menu.Label>Menu</Menu.Label>
+      <Menu.List>
+        <Menu.List.Item active>Active</Menu.List.Item>
+        <Menu.List.Item>Other</Menu.List.Item>
+      </Menu.List>
+    </Menu>
+    <Message color="success">
+      <Message.Header>Header</Message.Header>
+      <Message.Body>Body</Message.Body>
+    </Message>
+    <Modal active>
+      <Modal.Background />
+      <Modal.Card>
+        <Modal.Card.Head>
+          <Modal.Card.Title>Title</Modal.Card.Title>
+        </Modal.Card.Head>
+        <Modal.Card.Body>Body</Modal.Card.Body>
+        <Modal.Card.Foot>Foot</Modal.Card.Foot>
+      </Modal.Card>
+      <Modal.Close />
+    </Modal>
+    <Navbar color="primary" fixed="top" transparent>
+      <Navbar.Brand>
+        <Navbar.Item>Brand</Navbar.Item>
+        <Navbar.Burger />
+      </Navbar.Brand>
+      <Navbar.Menu>
+        <Navbar.Segment align="start">
+          <Navbar.Item active>Start</Navbar.Item>
+          <Navbar.Divider />
+        </Navbar.Segment>
+        <Navbar.Segment align="end">
+          <Navbar.Item>End</Navbar.Item>
+        </Navbar.Segment>
+      </Navbar.Menu>
+    </Navbar>
+    <Pagination align="centered" size="small" rounded>
+      <Pagination.Step align="previous">Prev</Pagination.Step>
+      <Pagination.List>
+        <Pagination.Link>1</Pagination.Link>
+        <Pagination.Ellipsis />
+      </Pagination.List>
+      <Pagination.Step align="next">Next</Pagination.Step>
+    </Pagination>
+    <Panel color="info">
+      <Panel.Heading>Panel</Panel.Heading>
+      <Panel.Tab.Group>
+        <Panel.Tab active>All</Panel.Tab>
+        <Panel.Tab>Some</Panel.Tab>
+      </Panel.Tab.Group>
+      <Panel.Block active>Block</Panel.Block>
+    </Panel>
+    <Tab.Group align="centered" size="medium" kind="toggle-rounded" fullwidth>
+      <Tab active>One</Tab>
+      <Tab>Two</Tab>
+    </Tab.Group>
+  </>
+);
diff --git a/bestax-migrate/fixtures/rbx-kitchen-sink/src/elements.tsx b/bestax-migrate/fixtures/rbx-kitchen-sink/src/elements.tsx
new file mode 100644
index 000000000..47970d38e
--- /dev/null
+++ b/bestax-migrate/fixtures/rbx-kitchen-sink/src/elements.tsx
@@ -0,0 +1,70 @@
+import React from "react";
+import {
+  Block,
+  Box,
+  Button,
+  Content,
+  Delete,
+  Loader,
+  Notification,
+  PageLoader,
+  Progress,
+  Table,
+  Tag,
+  Title,
+} from "rbx";
+
+export const Elements = () => (
+  <Block>
+    <Box>
+      <Title size={1} spaced>
+        Kitchen sink
+      </Title>
+      <Title subtitle size={4}>
+        Every mapped element
+      </Title>
+      <Content size="medium">
+        <p>Body copy</p>
+      </Content>
+      <Button.Group hasAddons align="centered">
+        <Button color="primary" size="small" outlined>
+          One
+        </Button>
+        <Button color="link" rounded inverted>
+          Two
+        </Button>
+        <Button state="loading" fullwidth static>
+          Three
+        </Button>
+      </Button.Group>
+      <Tag.Group gapless>
+        <Tag color="info" size="medium" rounded>
+          tag
+        </Tag>
+        <Tag delete />
+      </Tag.Group>
+      <Delete size="small" />
+      <Notification color="warning">Careful</Notification>
+      <Progress color="danger" value={40} max={100} size="medium" />
+      <Loader />
+      <PageLoader active color="info" />
+      <Table bordered striped narrow hoverable fullwidth>
+        <Table.Head>
+          <Table.Row>
+            <Table.Heading>Name</Table.Heading>
+          </Table.Row>
+        </Table.Head>
+        <Table.Body>
+          <Table.Row>
+            <Table.Cell>Value</Table.Cell>
+          </Table.Row>
+        </Table.Body>
+        <Table.Foot>
+          <Table.Row>
+            <Table.Cell>Total</Table.Cell>
+          </Table.Row>
+        </Table.Foot>
+      </Table>
+    </Box>
+  </Block>
+);
diff --git a/bestax-migrate/fixtures/rbx-kitchen-sink/src/form.tsx b/bestax-migrate/fixtures/rbx-kitchen-sink/src/form.tsx
new file mode 100644
index 000000000..69e14ef79
--- /dev/null
+++ b/bestax-migrate/fixtures/rbx-kitchen-sink/src/form.tsx
@@ -0,0 +1,54 @@
+import React from "react";
+import {
+  Checkbox,
+  Control,
+  Field,
+  Help,
+  Input,
+  Label,
+  Radio,
+  Select,
+  Textarea,
+} from "rbx";
+
+export const FormControls = () => (
+  <>
+    <Field horizontal>
+      <Field.Label size="normal">
+        <Label size="small">Email</Label>
+      </Field.Label>
+      <Field.Body>
+        <Control expanded loading>
+          <Input
+            type="email"
+            color="danger"
+            size="small"
+            rounded
+            state="focused"
+            readOnly
+          />
+        </Control>
+        <Help color="danger">Required</Help>
+      </Field.Body>
+    </Field>
+    <Field kind="addons">
+      <Control>
+        <Select.Container fullwidth rounded size="medium" state="loading">
+          <Select>
+            <Select.Option value="a">A</Select.Option>
+            <Select.Option value="b">B</Select.Option>
+          </Select>
+        </Select.Container>
+      </Control>
+    </Field>
+    <Field kind="group" multiline>
+      <Control>
+        <Textarea color="info" size="medium" fixedSize state="hovered" />
+      </Control>
+      <Control>
+        <Checkbox />
+        <Radio />
+      </Control>
+    </Field>
+  </>
+);
diff --git a/bestax-migrate/fixtures/rbx-kitchen-sink/src/grid.tsx b/bestax-migrate/fixtures/rbx-kitchen-sink/src/grid.tsx
new file mode 100644
index 000000000..e2ee54c4b
--- /dev/null
+++ b/bestax-migrate/fixtures/rbx-kitchen-sink/src/grid.tsx
@@ -0,0 +1,13 @@
+import React from "react";
+import { Column } from "rbx";
+
+export const Grid = () => (
+  <Column.Group centered multiline vcentered gapless gapSize={4} tablet={{ gapSize: 2 }}>
+    <Column size={4} offset={1} tablet={{ size: 6, narrow: true }}>
+      one
+    </Column>
+    <Column narrow desktop={{ size: "one-third", offset: 2 }}>
+      two
+    </Column>
+  </Column.Group>
+);
diff --git a/bestax-migrate/fixtures/rbx-kitchen-sink/src/helpers.tsx b/bestax-migrate/fixtures/rbx-kitchen-sink/src/helpers.tsx
new file mode 100644
index 000000000..3c1c82454
--- /dev/null
+++ b/bestax-migrate/fixtures/rbx-kitchen-sink/src/helpers.tsx
@@ -0,0 +1,41 @@
+import React from "react";
+import { Box, Button, Image } from "rbx";
+
+export const Helpers = () => (
+  <Box
+    backgroundColor="primary"
+    textColor="grey-dark"
+    textAlign="centered"
+    textWeight="bold"
+    textSize={5}
+    textTransform="uppercase"
+    marginless
+    paddingless
+    radiusless
+    shadowless
+    relative
+    unselectable
+    clearfix
+    clipped
+    overlay
+    pull="left"
+    responsive={{
+      mobile: { hide: { value: true } },
+      tablet: { display: { value: "flex" }, textSize: { value: 6 } },
+    }}
+  >
+    <Button hidden>hidden</Button>
+    <Button invisible>invisible</Button>
+    <Button srOnly>sr only</Button>
+    <Button italic>italic</Button>
+    <Button badge="4" badgeColor="danger">
+      badge
+    </Button>
+    <Button tooltip="Help" tooltipPosition="right" tooltipColor="info" tooltipMultiline>
+      tooltip
+    </Button>
+    <Image.Container size={128}>
+      <Image src="/a.png" rounded />
+    </Image.Container>
+  </Box>
+);
diff --git a/bestax-migrate/fixtures/rbx-kitchen-sink/src/layout.tsx b/bestax-migrate/fixtures/rbx-kitchen-sink/src/layout.tsx
new file mode 100644
index 000000000..6b9636f2b
--- /dev/null
+++ b/bestax-migrate/fixtures/rbx-kitchen-sink/src/layout.tsx
@@ -0,0 +1,16 @@
+import React from "react";
+import { Container, Divider, Footer, Hero, Section } from "rbx";
+
+export const Layout = () => (
+  <Container fluid breakpoint="desktop">
+    <Section size="medium">
+      <Hero color="primary" size="large">
+        <Hero.Head>Head</Hero.Head>
+        <Hero.Body>Body</Hero.Body>
+        <Hero.Foot>Foot</Hero.Foot>
+      </Hero>
+    </Section>
+    <Divider />
+    <Footer as="footer">Footer</Footer>
+  </Container>
+);
diff --git a/bestax-migrate/fixtures/rbx-kitchen-sink/src/leftovers.tsx b/bestax-migrate/fixtures/rbx-kitchen-sink/src/leftovers.tsx
new file mode 100644
index 000000000..aa64642b4
--- /dev/null
+++ b/bestax-migrate/fixtures/rbx-kitchen-sink/src/leftovers.tsx
@@ -0,0 +1,83 @@
+// Everything the rbx codemod intentionally refuses to convert. This file is
+// EXCLUDED from the e2e's typecheck of the migrated output — a `todo`
+// PropAction deliberately leaves the original attribute in place next to its
+// TODO comment, so the result is not expected to compile. The e2e asserts the
+// TODO rules instead.
+import React from "react";
+import {
+  Divider,
+  Dropdown,
+  Fieldset,
+  File,
+  Generic,
+  Highlight,
+  Icon,
+  List,
+  Modal,
+  Numeric,
+  Tile,
+} from "rbx";
+import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
+import { faHome } from "@fortawesome/free-solid-svg-icons";
+
+export const Leftovers = ({ where }: { where: "left" | "right" }) => (
+  <Generic as="section">
+    {/* Bulma v1 removed tiles outright. */}
+    <Tile kind="ancestor">
+      <Tile kind="parent" vertical size={4}>
+        <Tile kind="child">tile</Tile>
+      </Tile>
+    </Tile>
+
+    {/* the bulma-list extension, which Bulma v1 does not ship */}
+    <List>
+      <List.Item active>item</List.Item>
+    </List>
+
+    {/* no bestax equivalents */}
+    <Fieldset disabled>fields</Fieldset>
+    <Numeric>{1000}</Numeric>
+    <Highlight>{"const a = 1;"}</Highlight>
+
+    {/* bestax's Icon needs a required `name`, unreadable from a component child */}
+    <Icon size="small">
+      <FontAwesomeIcon icon={faHome} />
+    </Icon>
+
+    {/* bestax's File renders this whole structure from its own props */}
+    <File hasName>
+      <File.Label>
+        <File.Input name="upload" />
+        <File.CTA>
+          <File.Icon>
+            <FontAwesomeIcon icon={faHome} />
+          </File.Icon>
+          <File.Label>Choose…</File.Label>
+        </File.CTA>
+        <File.Name>none</File.Name>
+      </File.Label>
+    </File>
+
+    {/* bestax's Dropdown takes a `label` and renders its own trigger */}
+    <Dropdown managed>
+      <Dropdown.Trigger>Open</Dropdown.Trigger>
+      <Dropdown.Menu>
+        <Dropdown.Content>
+          <Dropdown.Item active>one</Dropdown.Item>
+          <Dropdown.Divider />
+        </Dropdown.Content>
+      </Dropdown.Menu>
+    </Dropdown>
+
+    {/* bestax's Modal has no Escape handling, portal, or scroll lock; every conversion is flagged */}
+    <Modal active closeOnEsc closeOnBlur>
+      <Modal.Content>body</Modal.Content>
+    </Modal>
+
+    {/* rbx rendered the children as a label; bestax's Divider is a void <hr> */}
+    <Divider>OR</Divider>
+
+    {/* dynamic values are never best-guessed */}
+    <Generic as="div" textAlign={where === "left" ? "left" : "right"} />
+  </Generic>
+);
diff --git a/bestax-migrate/fixtures/rbx-kitchen-sink/src/styles.scss b/bestax-migrate/fixtures/rbx-kitchen-sink/src/styles.scss
new file mode 100644
index 000000000..6eb97b7a7
--- /dev/null
+++ b/bestax-migrate/fixtures/rbx-kitchen-sink/src/styles.scss
@@ -0,0 +1,11 @@
+@import "~bulma/sass/utilities/functions";
+
+$primary: #00d8ff !default;
+$family-primary: 'Nunito', sans-serif !default;
+
+@import "~bulma/bulma";
+@import "~rbx/rbx";
+
+.app-shell {
+  min-height: 100vh;
+}
diff --git a/bestax-migrate/package.json b/bestax-migrate/package.json
index 075f38405..7daf2fe08 100644
--- a/bestax-migrate/package.json
+++ b/bestax-migrate/package.json
@@ -18,6 +18,7 @@
     "lint": "eslint src e2e",
     "typecheck": "tsc --noEmit",
     "validate:corpus": "pnpm run build && node scripts/validate-corpus.mjs",
+    "validate:corpus:rbx": "pnpm run build && node scripts/validate-corpus-rbx.mjs",
     "format": "prettier --write \"src/**/*.{ts,tsx}\" \"e2e/**/*.ts\"",
     "format:check": "prettier --check \"src/**/*.{ts,tsx}\" \"e2e/**/*.ts\"",
     "clean": "rimraf dist",
diff --git a/bestax-migrate/scripts/validate-corpus-rbx.mjs b/bestax-migrate/scripts/validate-corpus-rbx.mjs
new file mode 100644
index 000000000..709ffda60
--- /dev/null
+++ b/bestax-migrate/scripts/validate-corpus-rbx.mjs
@@ -0,0 +1,216 @@
+/**
+ * Dev-time corpus validation: run the rbx transform over the library's OWN
+ * documentation examples — author-written, MIT-licensed JSX covering every
+ * component — and score the result.
+ *
+ * rbx's docs are docz, not Storybook: each `*.docs.mdx` page embeds its
+ * examples in `<Playground>` blocks. At the pinned SHA there are 43 such
+ * pages carrying 254 blocks, which is the closest thing to a real-world rbx
+ * corpus that exists under a licence we can use.
+ *
+ * The corpus is fetched as TEXT at a pinned commit into the gitignored
+ * .e2e-tmp/ directory; it is never installed, executed, typechecked, or
+ * committed (rbx must never become a dependency of this repo). Deliberately
+ * NOT wired into CI — no third-party fetches in the pipeline; run it locally
+ * before releases or after mapping changes:
+ *
+ *   pnpm --filter bestax-migrate validate:corpus:rbx
+ *
+ * Exit 1 on any transform crash or `unknown-component` TODO (the vendored rbx
+ * surface would be incomplete). Before/after copies land in
+ * .e2e-tmp/corpus-out-rbx/ for eyeball review.
+ */
+
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const REPO_URL = 'https://github.com/dfee/rbx.git';
+// master as of 2019-06-14 — rbx's final commit. The library is abandoned, so
+// this never moves; bump deliberately if it ever does.
+const PINNED_SHA = 'f2a55cf4e07f41d094433a746460f1d84a665d5b';
+
+const packageRoot = path.join(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '..'
+);
+const corpusDir = path.join(packageRoot, '.e2e-tmp', 'corpus', 'rbx');
+const outDir = path.join(packageRoot, '.e2e-tmp', 'corpus-out-rbx');
+const distTransform = path.join(
+  packageRoot,
+  'dist',
+  'sources',
+  'rbx',
+  'transform.js'
+);
+const distRunner = path.join(packageRoot, 'dist', 'runner.js');
+const distMapping = path.join(
+  packageRoot,
+  'dist',
+  'sources',
+  'rbx',
+  'mapping.js'
+);
+
+function fail(message) {
+  console.error(`✖ ${message}`);
+  process.exit(1);
+}
+
+if (!fs.existsSync(distTransform)) {
+  fail('dist/ not built — run `pnpm --filter bestax-migrate build` first');
+}
+
+// ---- fetch the corpus (text only) at the pinned commit --------------------
+if (!fs.existsSync(path.join(corpusDir, 'src'))) {
+  console.log(`Fetching rbx @ ${PINNED_SHA.slice(0, 12)} (text corpus)…`);
+  fs.rmSync(corpusDir, { recursive: true, force: true });
+  fs.mkdirSync(corpusDir, { recursive: true });
+  const run = args => {
+    const result = spawnSync('git', args, { cwd: corpusDir, encoding: 'utf8' });
+    if (result.status !== 0) fail(`git ${args.join(' ')}: ${result.stderr}`);
+  };
+  run(['init', '-q']);
+  run(['remote', 'add', 'origin', REPO_URL]);
+  run(['fetch', '-q', '--depth', '1', 'origin', PINNED_SHA]);
+  run(['checkout', '-q', 'FETCH_HEAD']);
+}
+
+// ---- collect the docs pages ----------------------------------------------
+const docsFiles = [];
+(function walk(dir) {
+  for (const entry of fs.readdirSync(dir).sort()) {
+    const full = path.join(dir, entry);
+    if (fs.statSync(full).isDirectory()) walk(full);
+    else if (entry.endsWith('.docs.mdx')) docsFiles.push(full);
+  }
+})(path.join(corpusDir, 'src'));
+
+if (docsFiles.length === 0) fail('no .docs.mdx files found in the corpus');
+
+const { RBX_EXPORTS } = await import(distMapping);
+const { default: transform } = await import(distTransform);
+const { runTransform } = await import(distRunner);
+
+/**
+ * Pull the `<Playground>…</Playground>` bodies out of one MDX page. Nesting is
+ * tracked by `<Playground>` tag depth, so a block containing another one
+ * cannot be ended early by the inner closing tag.
+ */
+function extractPlaygrounds(source) {
+  const blocks = [];
+  const open = /<Playground>/g;
+  while (open.exec(source) !== null) {
+    const start = open.lastIndex;
+    let depth = 1;
+    let i = start;
+    while (i < source.length && depth > 0) {
+      if (source.startsWith('<Playground>', i)) {
+        depth += 1;
+        i += 12;
+      } else if (source.startsWith('</Playground>', i)) {
+        depth -= 1;
+        if (depth === 0) break;
+        i += 13;
+      } else {
+        i += 1;
+      }
+    }
+    if (depth === 0) {
+      blocks.push(source.slice(start, i).trim());
+      open.lastIndex = i;
+    }
+  }
+  return blocks;
+}
+
+/** Every rbx export whose name appears as a JSX tag root in the snippet. */
+function referencedExports(body) {
+  const names = new Set();
+  for (const m of body.matchAll(/<([A-Z][A-Za-z0-9]*)/g)) {
+    if (m[1] in RBX_EXPORTS) names.add(m[1]);
+  }
+  return [...names].sort();
+}
+
+fs.rmSync(outDir, { recursive: true, force: true });
+fs.mkdirSync(outDir, { recursive: true });
+
+let blockCount = 0;
+let transformed = 0;
+const crashes = [];
+const todosByRule = new Map();
+const unknownComponents = [];
+
+for (const file of docsFiles) {
+  const rel = path.relative(path.join(corpusDir, 'src'), file);
+  const name = rel.replace(/[\\/]/g, '__').replace(/\.docs\.mdx$/, '');
+  const blocks = extractPlaygrounds(fs.readFileSync(file, 'utf8'));
+  if (blocks.length === 0) continue;
+  blockCount += blocks.length;
+
+  // Rebuild each page as one synthetic module written the way a real consumer
+  // writes rbx: named imports from the package root, one component per block.
+  const imported = new Set();
+  const parts = [];
+  blocks.forEach((body, index) => {
+    for (const n of referencedExports(body)) imported.add(n);
+    parts.push(
+      `export const Example${index + 1} = () => (\n<>\n${body}\n</>\n);`
+    );
+  });
+  const source =
+    (imported.size > 0
+      ? `import { ${[...imported].sort().join(', ')} } from "rbx";\n\n`
+      : '') +
+    parts.join('\n\n') +
+    '\n';
+
+  const todos = [];
+  let output;
+  try {
+    output = runTransform(transform, `${rel}.tsx`, source, {
+      add: entry => todos.push(entry),
+    }).output;
+  } catch (error) {
+    crashes.push({ rel, message: error.message });
+    continue;
+  }
+  if (output !== null) transformed += 1;
+  fs.writeFileSync(path.join(outDir, `${name}.before.jsx`), source);
+  fs.writeFileSync(path.join(outDir, `${name}.after.jsx`), output ?? source);
+  for (const todo of todos) {
+    todosByRule.set(todo.rule, (todosByRule.get(todo.rule) ?? 0) + 1);
+    if (todo.rule === 'unknown-component') {
+      unknownComponents.push(`${rel}:${todo.line} ${todo.message}`);
+    }
+  }
+}
+
+// ---- scorecard -------------------------------------------------------------
+console.log('\nbestax-migrate corpus validation — rbx docs Playgrounds');
+console.log(`  pages:        ${docsFiles.length}`);
+console.log(`  playgrounds:  ${blockCount}`);
+console.log(`  transformed:  ${transformed}`);
+console.log(`  crashes:      ${crashes.length}`);
+const rules = [...todosByRule.entries()].sort((a, b) => b[1] - a[1]);
+console.log(
+  `  TODOs:        ${rules.reduce((sum, [, count]) => sum + count, 0)}`
+);
+for (const [rule, count] of rules) {
+  console.log(`    ${rule}: ${count}`);
+}
+console.log(`  review dir:   ${path.relative(packageRoot, outDir)}`);
+
+for (const crash of crashes) {
+  console.error(`  ✖ crash in ${crash.rel}: ${crash.message}`);
+}
+for (const unknown of unknownComponents) {
+  console.error(`  ✖ unknown component: ${unknown}`);
+}
+
+if (crashes.length > 0 || unknownComponents.length > 0) {
+  fail('corpus validation found defects (see above)');
+}
+console.log('\n✓ corpus validation passed');
diff --git a/bestax-migrate/src/__tests__/cli.test.ts b/bestax-migrate/src/__tests__/cli.test.ts
index 72d82f9a8..533253c66 100644
--- a/bestax-migrate/src/__tests__/cli.test.ts
+++ b/bestax-migrate/src/__tests__/cli.test.ts
@@ -180,6 +180,78 @@ describe('findPackageJsons', () => {
   });
 });
 
+describe('the source-still-imported warning', () => {
+  /** A project whose ONLY remaining rbx reference is the given file/content. */
+  function projectWith(name: string, content: string): string {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'bestax-migrate-deep-'));
+    tempDirs.push(dir);
+    fs.mkdirSync(path.join(dir, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(dir, 'src', name), content);
+    fs.writeFileSync(
+      path.join(dir, 'package.json'),
+      `${JSON.stringify({ name: 'a', dependencies: { rbx: '^2.2.0' } }, null, 2)}\n`
+    );
+    return dir;
+  }
+
+  it.each([
+    [
+      'a retained DEEP import',
+      'App.tsx',
+      "import { ThemeContext } from 'rbx/base/theme';\nexport const A = 1;\n",
+    ],
+    ['an indented-Sass import', 'a.sass', '@import "~rbx/rbx"\n'],
+  ])('fires for %s', async (_label, file, content) => {
+    // These are the two forms the transforms deliberately PRESERVE, so if one
+    // is the last reference the package must not be removed silently.
+    const dir = projectWith(file, content);
+    const { logs } = await runCli(['rbx', path.join(dir, 'src'), '--dry']);
+    expect(logs.join('\n')).toMatch(
+      /still import it for components with no bestax/
+    );
+  });
+
+  it('fires for a bindingless side-effect import', async () => {
+    // `import 'rbx';` has nothing to rewrite, so the transform leaves the
+    // file alone — but the reference is still live, and removing the
+    // package from the manifest would strand it.
+    const dir = projectWith('App.tsx', "import 'rbx';\nexport const A = 1;\n");
+    const { logs } = await runCli(['rbx', path.join(dir, 'src'), '--dry']);
+    expect(logs.join('\n')).toMatch(
+      /still import it for components with no bestax/
+    );
+  });
+
+  it('fires for an unsupported file that imports the source', async () => {
+    // .vue/.astro files are reported but never rewritten, so the reference
+    // survives the run and the package must not be removed under it.
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'bestax-migrate-unsup-'));
+    tempDirs.push(dir);
+    fs.mkdirSync(path.join(dir, 'src'), { recursive: true });
+    fs.writeFileSync(
+      path.join(dir, 'src', 'App.vue'),
+      "<script>import { Box } from 'rbx';</script>\n"
+    );
+    fs.writeFileSync(
+      path.join(dir, 'package.json'),
+      `${JSON.stringify({ name: 'a', dependencies: { rbx: '^2.2.0' } }, null, 2)}\n`
+    );
+    const { logs } = await runCli(['rbx', path.join(dir, 'src'), '--dry']);
+    expect(logs.join('\n')).toMatch(
+      /still import it for components with no bestax/
+    );
+  });
+
+  it('does not fire for a lookalike package name', async () => {
+    const dir = projectWith(
+      'App.tsx',
+      "import { X } from 'rbx-other';\nexport const A = 1;\n"
+    );
+    const { logs } = await runCli(['rbx', path.join(dir, 'src'), '--dry']);
+    expect(logs.join('\n')).not.toMatch(/still import it for components/);
+  });
+});
+
 describe('CLI', () => {
   it('transforms files in place and reports', async () => {
     const dir = makeTempProject();
diff --git a/bestax-migrate/src/__tests__/source-import-re.test.ts b/bestax-migrate/src/__tests__/source-import-re.test.ts
new file mode 100644
index 000000000..b90bce9b5
--- /dev/null
+++ b/bestax-migrate/src/__tests__/source-import-re.test.ts
@@ -0,0 +1,136 @@
+/**
+ * The specifier matcher both CLI passes share. It decides two things that
+ * pull in opposite directions: whether a file still references the source
+ * package (so the manifest pass must not drop it), and whether an
+ * unparseable file is worth reporting. Too loose and prose pins a dependency
+ * forever; too tight and the package is removed out from under a live import.
+ */
+
+import { blankComments, makeSourceImportRe } from '../cli.js';
+
+describe('makeSourceImportRe', () => {
+  const matches = (src: string) =>
+    makeSourceImportRe('rbx').test(blankComments(src));
+
+  it.each([
+    ['named import', `import { Box } from 'rbx';`],
+    ['default import', `import rbx from 'rbx';`],
+    ['namespace import', `import * as R from 'rbx';`],
+    ['deep import', `import { Theme } from 'rbx/base/theme';`],
+    ['side-effect import', `import 'rbx/index.sass';`],
+    ['double-quoted', `import { Box } from "rbx";`],
+    ['require', `const x = require('rbx');`],
+    ['dynamic import', `const p = import('rbx');`],
+    ['sass tilde import', `@import '~rbx/rbx';`],
+    ['relative node_modules import', `@import '../node_modules/rbx/rbx';`],
+  ])('matches a %s', (_label, src) => {
+    expect(matches(src)).toBe(true);
+  });
+
+  it('matches through a webpack magic comment', () => {
+    // `import(/* webpackChunkName: "x" */ 'rbx')` puts a comment exactly
+    // where the matcher allowed only whitespace, so a lazily-loaded source
+    // import read as no import at all.
+    expect(
+      matches(`const p = import(/* webpackChunkName: "x" */ 'rbx');`)
+    ).toBe(true);
+    expect(matches(`import { Box } from /* pinned */ 'rbx';`)).toBe(true);
+  });
+
+  it.each([
+    [
+      'a longer package that shares the prefix',
+      `import { a } from 'rbx-utils';`,
+    ],
+    ['a longer package that shares the suffix', `import { a } from 'notrbx';`],
+    ['a scoped lookalike', `import { a } from '@acme/rbx-helpers';`],
+    ['prose in an mdx file', `This page explains how rbx handled themes.`],
+    ['an identifier that contains the name', `const rbxConfig = {};`],
+  ])('does not match %s', (_label, src) => {
+    expect(matches(src)).toBe(false);
+  });
+
+  it.each([
+    ['a commented-out import', `// import { Box } from 'rbx';`],
+    ['a commented-out require', `  // const x = require('rbx');`],
+    ['an identifier ending in require', `const x = myrequire('rbx');`],
+  ])('does not match %s', (_label, src) => {
+    expect(matches(src)).toBe(false);
+  });
+
+  it('matches an import that shares its line with a tag', () => {
+    // Single-file components put the import inside `<script>`, so anchoring
+    // to the start of the line would miss every .vue and .astro file.
+    expect(matches(`<script>import { Box } from 'rbx';</script>`)).toBe(true);
+  });
+
+  it('matches require.resolve, which is as live as require', () => {
+    expect(matches(`const p = require.resolve('rbx');`)).toBe(true);
+    expect(matches(`require.resolve('rbx/index.sass')`)).toBe(true);
+    expect(matches(`myrequire.resolve('rbx')`)).toBe(false);
+  });
+
+  it('matches a multi-line specifier list', () => {
+    expect(matches(`import {\n  Box,\n  Button\n} from 'rbx';`)).toBe(true);
+  });
+
+  it('escapes regex metacharacters in the package name', () => {
+    const re = makeSourceImportRe('react-bulma-components');
+    expect(re.test(`import { Box } from 'react-bulma-components';`)).toBe(true);
+    expect(re.test(`import { Box } from 'reactxbulmaxcomponents';`)).toBe(
+      false
+    );
+  });
+});
+
+describe('blankComments', () => {
+  // No lookbehind can do this job: `// import … from 'rbx'` is not an import,
+  // while the `//` inside `'http://x'` is not a comment.
+  it('blanks a line comment but keeps offsets and line breaks', () => {
+    const src = "a\n// import { Box } from 'rbx';\nb";
+    const out = blankComments(src);
+    expect(out).toHaveLength(src.length);
+    expect(out.split('\n')).toHaveLength(3);
+    expect(out).not.toContain('rbx');
+  });
+
+  it('blanks a block comment', () => {
+    expect(blankComments("/* import { Box } from 'rbx'; */")).not.toContain(
+      'rbx'
+    );
+  });
+
+  it('leaves a // inside a string alone', () => {
+    const out = blankComments("const u = 'http://x//y';");
+    expect(out).toContain("'http://x//y'");
+  });
+
+  it('handles an escaped quote without ending the string early', () => {
+    const out = blankComments("const s = 'a\\'b'; // gone");
+    expect(out).toContain("'a\\'b'");
+    expect(out).not.toContain('gone');
+  });
+
+  it('leaves code with no comments byte-identical', () => {
+    const src = "import { Box } from 'rbx';\nconst x = 1;";
+    expect(blankComments(src)).toBe(src);
+  });
+});
+
+describe('comment handling in the matcher', () => {
+  it('matches through a line comment inside a dynamic import', () => {
+    expect(matchesSrc("const p = import(\n// chunk\n'rbx');")).toBe(true);
+  });
+
+  it('matches a require after a string containing //', () => {
+    expect(matchesSrc("const u = 'http://x//y'; require('rbx')")).toBe(true);
+  });
+
+  it('does not match an import inside a block comment', () => {
+    expect(matchesSrc("/* import { Box } from 'rbx'; */")).toBe(false);
+  });
+});
+
+function matchesSrc(src: string): boolean {
+  return makeSourceImportRe('rbx').test(blankComments(src));
+}
diff --git a/bestax-migrate/src/cli.ts b/bestax-migrate/src/cli.ts
index 34c04c1e4..e7880c4c5 100644
--- a/bestax-migrate/src/cli.ts
+++ b/bestax-migrate/src/cli.ts
@@ -98,14 +98,141 @@ interface RunOptions {
   cssMode: CssMode;
 }
 
+/**
+ * Matches an import of `name` at a specifier boundary, in every form a
+ * retained reference can take: a root or DEEP JavaScript import
+ * (`from 'rbx'`, `from 'rbx/base/theme'` — deep ones are kept with a TODO), a
+ * bindingless side-effect `import 'rbx'` (which the transform leaves untouched
+ * because there is nothing to rewrite), the CommonJS / dynamic forms
+ * `require('rbx')` and `import('rbx')` — neither of which the jscodeshift
+ * transform rewrites, so both survive the run as live references — and the
+ * Sass forms the stylesheet transform preserves in indented `.sass` files
+ * (`@import '~rbx/rbx'`).
+ *
+ * Matching only `from '<pkg>'` meant a file whose ONLY remaining reference was
+ * a deep or Sass import let the manifest pass drop the package with no
+ * warning. Matching a bare substring is the opposite error, and worse for a
+ * name as short as `rbx`: prose and a sibling package like `rbx-utils` both
+ * counted as imports.
+ *
+ * Comments are allowed wherever whitespace is, because a webpack magic comment
+ * sits exactly there: `import(/* webpackChunkName: "x" *\/ 'rbx')`.
+ */
+/**
+ * Blank out comments while preserving strings, offsets, and line breaks.
+ *
+ * The import matcher needs to know whether a keyword is real code, and no
+ * lookbehind can tell it: `// import { Box } from 'rbx'` is not an import,
+ * while the `//` inside `const u = 'http://x'; require('rbx')` is not a
+ * comment. Comment bytes become spaces rather than being deleted so the
+ * caller's line lookup still lines up with the original text.
+ *
+ * Deliberately small: this is not a JavaScript lexer. It tracks quotes and the
+ * two comment forms, which is what the matcher needs, and it is applied to
+ * `.sass` and `.vue` files too, where `//` is also a comment.
+ */
+export function blankComments(text: string): string {
+  let out = '';
+  let quote: string | null = null;
+  let i = 0;
+  while (i < text.length) {
+    const c = text[i];
+    const next = text[i + 1];
+    if (quote) {
+      if (c === '\\' && i + 1 < text.length) {
+        out += c + next;
+        i += 2;
+        continue;
+      }
+      if (c === quote) quote = null;
+      out += c;
+      i += 1;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === '`') {
+      quote = c;
+      out += c;
+      i += 1;
+      continue;
+    }
+    if (c === '/' && next === '/') {
+      while (i < text.length && text[i] !== '\n') {
+        out += ' ';
+        i += 1;
+      }
+      continue;
+    }
+    if (c === '/' && next === '*') {
+      out += '  ';
+      i += 2;
+      while (i < text.length && !(text[i] === '*' && text[i + 1] === '/')) {
+        out += text[i] === '\n' ? '\n' : ' ';
+        i += 1;
+      }
+      if (i < text.length) {
+        out += '  ';
+        i += 2;
+      }
+      continue;
+    }
+    out += c;
+    i += 1;
+  }
+  return out;
+}
+
+/**
+ * Matches an import of `name` at a specifier boundary, in every form a
+ * retained reference can take: a root or DEEP JavaScript import
+ * (`from 'rbx'`, `from 'rbx/base/theme'`), a bindingless side-effect
+ * `import 'rbx'`, a re-export, the CommonJS and dynamic forms `require('rbx')`
+ * and `import('rbx')` — none of which the jscodeshift transform rewrites, so
+ * all survive the run as live references — and the Sass form the stylesheet
+ * transform preserves in indented `.sass` files (`@import '~rbx/rbx'`).
+ *
+ * Run it over `blankComments(text)`, not the raw text: the keyword alternatives
+ * carry no comment awareness of their own by design, because that job needs a
+ * scanner rather than a lookbehind.
+ *
+ * Matching only `from '<pkg>'` meant a file whose ONLY remaining reference was
+ * a deep or Sass import let the manifest pass drop the package with no warning.
+ * Matching a bare substring is the opposite error, and worse for a name as
+ * short as `rbx`: prose and a sibling package like `rbx-utils` both counted.
+ */
+export function makeSourceImportRe(name: string): RegExp {
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const spec = `['"](?:~|(?:\\.\\.?/)+node_modules/)?${escaped}(?:/[^'"]*)?['"]`;
+  // Not the tail of a longer identifier: `myrequire('rbx')` is not a require,
+  // and `foo.import(...)` is not an import.
+  const lead = String.raw`(?<![\w$.])`;
+  return new RegExp(
+    [
+      // A static import or re-export. The keyword is what separates a real
+      // specifier from a bare `from` in prose ("Migrated from 'rbx' in 2019").
+      // `[^;]` spans the newlines of a multi-line specifier list without
+      // running past the statement.
+      `${lead}(?:import|export)\\b[^;]*?\\bfrom\\s*${spec}`,
+      // A bindingless side-effect import, and the Sass form.
+      `${lead}import\\s*${spec}`,
+      `@import\\s*${spec}`,
+      // The dynamic and CommonJS forms, which appear mid-expression.
+      // `require.resolve('rbx')` is as live a reference as `require('rbx')`
+      // and is just as unrewritten by the transform.
+      `${lead}(?:import|require(?:\\.resolve)?)\\s*\\(\\s*${spec}`,
+    ].join('|')
+  );
+}
+
 function migrateFiles(
   source: MigrationSource,
   files: string[],
   reporter: Reporter,
   io: CliIo,
   options: RunOptions
-): boolean {
+): { bulmaReferenced: boolean; sourceStillImported: boolean } {
   let bulmaReferenced = false;
+  let sourceStillImported = false;
+  const sourceImportRe = makeSourceImportRe(source.name);
   for (const file of files) {
     const sourceText = fs.readFileSync(file, 'utf8');
     const collector = reporter.startFile();
@@ -126,19 +253,29 @@ function migrateFiles(
       }
     } catch (error) {
       io.error(chalk.red(`✖ ${file}: ${(error as Error).message}`));
+      // Read the signals off the ORIGINAL text before bailing. A parse
+      // failure in the only file importing the source library would
+      // otherwise let the manifest pass remove the package with no warning —
+      // the file still imports it, we just couldn't rewrite it.
+      if (/['"](?:~?bulma\/)/.test(sourceText)) bulmaReferenced = true;
+      if (sourceImportRe.test(blankComments(sourceText)))
+        sourceStillImported = true;
       reporter.finishFile(file, false, collector.entries);
       continue;
     }
     if (/['"](?:~?bulma\/)/.test(output ?? sourceText)) {
       bulmaReferenced = true;
     }
+    if (sourceImportRe.test(blankComments(output ?? sourceText))) {
+      sourceStillImported = true;
+    }
     if (output !== null) {
       if (options.print) io.log(output);
       if (!options.dry) fs.writeFileSync(file, output);
     }
     reporter.finishFile(file, output !== null, collector.entries);
   }
-  return bulmaReferenced;
+  return { bulmaReferenced, sourceStillImported };
 }
 
 /**
@@ -150,17 +287,28 @@ function reportUnsupportedFiles(
   targets: string[],
   reporter: Reporter,
   extensions: string[]
-): void {
+): boolean {
   const unsupported = UNSUPPORTED_EXTENSIONS.filter(
     ext => !extensions.includes(ext)
   );
-  if (unsupported.length === 0) return;
+  if (unsupported.length === 0) return false;
+  // Whether any unsupported file still references the source package. These
+  // are reported but never rewritten, so the reference survives the run —
+  // and the manifest pass must not remove the package out from under it.
+  let stillImported = false;
+  const importRe = makeSourceImportRe(source.name);
   for (const file of collectFiles(targets, unsupported)) {
     const text = fs.readFileSync(file, 'utf8');
-    if (!text.includes(source.name)) continue;
+    // A substring match is not evidence of an import. `rbx` is three
+    // characters: prose in an .mdx file and a sibling package like
+    // `rbx-utils` both matched, which reported a file that imports nothing
+    // and pinned the dependency the manifest pass would otherwise remove.
+    const scanned = blankComments(text);
+    if (!importRe.test(scanned)) continue;
+    stillImported = true;
     const collector = reporter.startFile();
     const line =
-      text.split('\n').findIndex(l => l.includes(source.name)) + 1 || null;
+      scanned.split('\n').findIndex(l => importRe.test(l)) + 1 || null;
     collector.add({
       file,
       line,
@@ -171,6 +319,7 @@ function reportUnsupportedFiles(
     });
     reporter.finishFile(file, false, collector.entries);
   }
+  return stillImported;
 }
 
 function migrateDependencies(
@@ -179,7 +328,7 @@ function migrateDependencies(
   reporter: Reporter,
   io: CliIo,
   options: RunOptions,
-  bulmaReferenced: boolean
+  deps: { bulmaReferenced: boolean; sourceStillImported: boolean }
 ): void {
   if (!options.deps || !source.updateDependencies) return;
   for (const pkgPath of findPackageJsons(targets)) {
@@ -190,7 +339,8 @@ function migrateDependencies(
       const pkg = JSON.parse(raw);
       const next = source.updateDependencies(pkgPath, pkg, collector, {
         cssMode: options.cssMode,
-        bulmaReferenced,
+        bulmaReferenced: deps.bulmaReferenced,
+        sourceStillImported: deps.sourceStillImported,
       });
       if (next !== null) {
         changed = true;
@@ -389,21 +539,21 @@ export function createCLI(
       };
 
       const reporter = new Reporter();
-      const bulmaReferenced = migrateFiles(
+      const depSignals = migrateFiles(source, files, reporter, io, runOptions);
+      const unsupportedImports = reportUnsupportedFiles(
         source,
-        files,
+        targets,
         reporter,
-        io,
-        runOptions
+        extensions
       );
-      reportUnsupportedFiles(source, targets, reporter, extensions);
+      if (unsupportedImports) depSignals.sourceStillImported = true;
       migrateDependencies(
         source,
         targets,
         reporter,
         io,
         runOptions,
-        bulmaReferenced
+        depSignals
       );
 
       io.log(
diff --git a/bestax-migrate/src/sources/_shared/__tests__/imports.test.ts b/bestax-migrate/src/sources/_shared/__tests__/imports.test.ts
new file mode 100644
index 000000000..9ed175af2
--- /dev/null
+++ b/bestax-migrate/src/sources/_shared/__tests__/imports.test.ts
@@ -0,0 +1,140 @@
+/**
+ * The import-aliasing escalation. `reserve` falls back to `Bulma<Name>` when
+ * the plain name is taken, then to `Bulma<Name>2`, `3`, … when that is taken
+ * too — the least-exercised branch in the shared helpers, and one the rbx
+ * work made MORE reachable: seeding `bound` with the locals of unmappable
+ * source imports (so a retained binding never loses its name) puts more
+ * names in the set that `reserve` has to route around.
+ */
+
+import transform from '../../rbx/transform.js';
+import { runTransform } from '../../../runner.js';
+
+function migrate(source: string): string {
+  const { output } = runTransform(transform, 'c.tsx', source, {
+    add: () => {},
+  });
+  return output ?? source;
+}
+
+describe('bestax import aliasing escalates past collisions', () => {
+  it('uses the plain name when it is free', () => {
+    const out = migrate(
+      'import { Button } from "rbx";\nexport const A = () => <Button>x</Button>;'
+    );
+    expect(out).toContain('import { Button } from "@allxsmith/bestax-bulma"');
+  });
+
+  it('falls back to Bulma<Name> when the plain name is bound', () => {
+    const out = migrate(
+      [
+        'import { Button as RbxBtn } from "rbx";',
+        'const Button = 1;',
+        'export const A = () => <RbxBtn>{Button}</RbxBtn>;',
+      ].join('\n')
+    );
+    expect(out).toMatch(/Button as BulmaButton\b/);
+  });
+
+  it('escalates to Bulma<Name>2 when Bulma<Name> is bound too', () => {
+    const out = migrate(
+      [
+        'import { Button as RbxBtn } from "rbx";',
+        'const Button = 1; const BulmaButton = 2;',
+        'export const A = () => <RbxBtn>{Button}{BulmaButton}</RbxBtn>;',
+      ].join('\n')
+    );
+    expect(out).toContain('Button as BulmaButton2');
+    expect(out).toContain('<BulmaButton2>');
+  });
+
+  it('keeps escalating past Bulma<Name>2', () => {
+    const out = migrate(
+      [
+        'import { Button as RbxBtn } from "rbx";',
+        'const Button = 1; const BulmaButton = 2; const BulmaButton2 = 3;',
+        'export const A = () => <RbxBtn>{Button}{BulmaButton}{BulmaButton2}</RbxBtn>;',
+      ].join('\n')
+    );
+    expect(out).toContain('Button as BulmaButton3');
+  });
+});
+
+describe('collectBoundNames sees every binding form', () => {
+  // Each destructuring shape binds names that a bestax import must not
+  // silently shadow. Exercised through the transform, since that is the only
+  // way these reach `reserve`.
+  it.each([
+    ['object pattern', 'const { Button } = props;'],
+    ['nested object pattern', 'const { a: { Button } } = props;'],
+    ['array pattern', 'const [Button] = list;'],
+    ['rest element', 'const [first, ...Button] = list;'],
+    ['default value', 'const { Button = 1 } = props;'],
+    ['function param', 'function f(Button) { return Button; }'],
+    ['arrow param', 'const g = (Button) => Button;'],
+    ['class declaration', 'class Button {}'],
+    [
+      'function expression param',
+      'const h = function (Button) { return Button; };',
+    ],
+  ])('aliases around a %s binding', (_label, binding) => {
+    const out = migrate(
+      [
+        'import { Button as RbxBtn } from "rbx";',
+        'const props: any = {}; const list: any[] = [];',
+        binding,
+        'export const A = () => <RbxBtn>x</RbxBtn>;',
+      ].join('\n')
+    );
+    // The local `Button` is taken, so the bestax import must be aliased.
+    expect(out).toMatch(/Button as Bulma\w+/);
+    expect(out).not.toMatch(/import \{ Button \} from "@allxsmith/);
+  });
+
+  it('does not alias when the imported name is free', () => {
+    const out = migrate(
+      [
+        'import { Button as RbxBtn } from "rbx";',
+        'const other = 1;',
+        'export const A = () => <RbxBtn>{other}</RbxBtn>;',
+      ].join('\n')
+    );
+    expect(out).toContain('import { Button } from "@allxsmith/bestax-bulma"');
+  });
+});
+
+describe('TypeScript declaration bindings', () => {
+  // A TS declaration occupies the name an added import would use. The alias
+  // pass could not see any of these forms, so a generated
+  // `import { Button }` landed beside an existing `enum Button` — a
+  // duplicate-identifier error that only surfaced at build time, well after
+  // the codemod reported success.
+  it.each([
+    ['enum', 'enum Button { A }'],
+    ['const enum', 'const enum Button { A }'],
+    ['namespace', 'namespace Button { export const a = 1; }'],
+    ['interface', 'interface Button { a: number }'],
+    ['type alias', 'type Button = { a: number };'],
+  ])('aliases around a %s named Button', (_label, decl) => {
+    const out = migrate(
+      [
+        'import { Button as RbxBtn } from "rbx";',
+        decl,
+        'export const A = () => <RbxBtn>x</RbxBtn>;',
+      ].join('\n')
+    );
+    expect(out).toMatch(/Button as Bulma\w+/);
+    expect(out).not.toMatch(/import \{ Button \} from "@allxsmith/);
+  });
+
+  it('does not alias when the declaration uses an unrelated name', () => {
+    const out = migrate(
+      [
+        'import { Button as RbxBtn } from "rbx";',
+        'enum Other { A }',
+        'export const A = () => <RbxBtn>x</RbxBtn>;',
+      ].join('\n')
+    );
+    expect(out).toContain('import { Button } from "@allxsmith/bestax-bulma"');
+  });
+});
diff --git a/bestax-migrate/src/sources/react-bulma-components/__tests__/jsx-utils.test.ts b/bestax-migrate/src/sources/_shared/__tests__/jsx-utils.test.ts
similarity index 100%
rename from bestax-migrate/src/sources/react-bulma-components/__tests__/jsx-utils.test.ts
rename to bestax-migrate/src/sources/_shared/__tests__/jsx-utils.test.ts
diff --git a/bestax-migrate/src/sources/_shared/imports.ts b/bestax-migrate/src/sources/_shared/imports.ts
new file mode 100644
index 000000000..b5a65e4e1
--- /dev/null
+++ b/bestax-migrate/src/sources/_shared/imports.ts
@@ -0,0 +1,166 @@
+/**
+ * Import-rewriting mechanics shared by every source transform: collecting the
+ * names a file already binds, and handing out non-colliding local names for
+ * the bestax imports a transform wants to add.
+ *
+ * Source-agnostic: nothing here knows which library is being migrated.
+ */
+
+import type { ASTPath, Collection, JSCodeshift } from 'jscodeshift';
+import type { TransformContext } from './jsx-utils.js';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export const nameOf = (node: any): string =>
+  typeof node === 'string' ? node : String(node?.name ?? '');
+
+/**
+ * Every identifier the file already binds — variables, function and class
+ * declarations, parameters (including destructured ones), and imports other
+ * than the source library's own (those are pruned by the caller).
+ *
+ * Importing a bestax component under a name the file already uses would
+ * redeclare it, so these names drive the aliasing in `makeReserve`.
+ */
+export function collectBoundNames(
+  j: JSCodeshift,
+  root: Collection<any>,
+  skipImportSource: string
+): Set<string> {
+  const bound = new Set<string>();
+
+  const collectPattern = (node: any): void => {
+    if (!node) return;
+    switch (node.type) {
+      case 'Identifier':
+        bound.add(node.name);
+        break;
+      case 'ObjectPattern':
+        for (const prop of node.properties ?? []) {
+          collectPattern(prop.value ?? prop.argument);
+        }
+        break;
+      case 'ArrayPattern':
+        for (const el of node.elements ?? []) collectPattern(el);
+        break;
+      case 'RestElement':
+        collectPattern(node.argument);
+        break;
+      case 'AssignmentPattern':
+        collectPattern(node.left);
+        break;
+    }
+  };
+
+  root.find(j.VariableDeclarator).forEach(path => collectPattern(path.node.id));
+  root.find(j.FunctionDeclaration).forEach(path => {
+    if (path.node.id) bound.add(nameOf(path.node.id));
+    for (const param of path.node.params ?? []) collectPattern(param);
+  });
+  root
+    .find(j.ClassDeclaration)
+    .forEach(path => path.node.id && bound.add(nameOf(path.node.id)));
+  // TypeScript declaration forms that occupy a name an import would collide
+  // with. An `enum Button` next to a generated `import { Button }` is a
+  // duplicate-identifier build break, and the alias pass could not see it.
+  // Interfaces and type aliases share the declaration space with an imported
+  // binding of the same name too, so they reserve as well — an unnecessary
+  // alias costs nothing, a missed one does not compile.
+  for (const kind of [
+    'TSEnumDeclaration',
+    'TSModuleDeclaration',
+    'TSInterfaceDeclaration',
+    'TSTypeAliasDeclaration',
+  ]) {
+    root.find(j[kind as 'TSEnumDeclaration']).forEach((path: ASTPath<any>) => {
+      const id = path.node.id;
+      if (id && (id.type === 'Identifier' || id.type === 'StringLiteral')) {
+        bound.add(nameOf(id));
+      }
+    });
+  }
+  root.find(j.FunctionExpression).forEach(path => {
+    for (const param of path.node.params ?? []) collectPattern(param);
+  });
+  root.find(j.ArrowFunctionExpression).forEach(path => {
+    for (const param of path.node.params ?? []) collectPattern(param);
+  });
+  root.find(j.ImportDeclaration).forEach(path => {
+    if (String(path.node.source.value) === skipImportSource) return;
+    for (const spec of path.node.specifiers ?? []) {
+      if (spec.local) bound.add(nameOf(spec.local));
+    }
+  });
+
+  return bound;
+}
+
+/**
+ * Build the `ctx.reserve` implementation: register a bestax import by its
+ * exported name and get back the local name to write in JSX — the plain name
+ * when it is free, otherwise `Bulma<Name>` (then `Bulma<Name>2`, …).
+ */
+export function makeReserve(
+  ctx: TransformContext,
+  bound: Set<string>
+): (importedName: string) => string {
+  return (importedName: string): string => {
+    const existing = ctx.needed.get(importedName);
+    if (existing) return existing;
+    let local = importedName;
+    if (bound.has(local)) {
+      local = `Bulma${importedName}`;
+      let suffix = 2;
+      const locals = new Set(ctx.needed.values());
+      while (bound.has(local) || locals.has(local)) {
+        local = `Bulma${importedName}${suffix}`;
+        suffix += 1;
+      }
+    }
+    ctx.needed.set(importedName, local);
+    return local;
+  };
+}
+
+/**
+ * Tab-indented sources keep tabs when reprinted, so recast's output does not
+ * drift from the untouched lines around it.
+ */
+export function prefersTabs(source: string): boolean {
+  let tabs = 0;
+  let spaces = 0;
+  for (const line of source.split('\n')) {
+    if (line.startsWith('\t')) tabs += 1;
+    else if (line.startsWith(' ')) spaces += 1;
+  }
+  return tabs > spaces;
+}
+
+/**
+ * True when the identifier `name` at `path` really resolves to the binding
+ * the import/alias passes recorded, rather than a local that shadows it.
+ *
+ * Both passes key on identifier TEXT, so a nested `function F({ Card })`
+ * parameter looked exactly like the source library's `Card`: its JSX was
+ * rewritten to bestax's `Card.FooterItem` and the destructured parameter was
+ * renamed alongside it, silently repointing the code at a different object.
+ *
+ * `expected` is the scope the binding was collected in — the program scope for
+ * an import (they are always top-level), or the declaring scope of a
+ * `const { Item } = Card` alias, which the alias pass records because it walks
+ * declarators at any depth.
+ */
+export function resolvesToBinding(
+  path: ASTPath<any>,
+  name: string,
+  expected: unknown
+): boolean {
+  if (!expected) return true;
+  const declaring = (
+    path as unknown as { scope?: { lookup(n: string): unknown } }
+  ).scope?.lookup(name);
+  // An unresolvable name keeps the old behaviour rather than silently
+  // skipping work: a miss here means no rewrite at all, which is worse than
+  // the shadowing case it guards against.
+  return !declaring || declaring === expected;
+}
diff --git a/bestax-migrate/src/sources/react-bulma-components/jsx-utils.ts b/bestax-migrate/src/sources/_shared/jsx-utils.ts
similarity index 84%
rename from bestax-migrate/src/sources/react-bulma-components/jsx-utils.ts
rename to bestax-migrate/src/sources/_shared/jsx-utils.ts
index 9dd28ada1..0af15fd7d 100644
--- a/bestax-migrate/src/sources/react-bulma-components/jsx-utils.ts
+++ b/bestax-migrate/src/sources/_shared/jsx-utils.ts
@@ -1,7 +1,11 @@
 /**
- * Small AST helpers shared by the react-bulma-components transform passes.
- * All functions operate on the babel/tsx AST that jscodeshift's `tsx` parser
- * produces, via the `j` builder API.
+ * Small AST helpers shared by every source's transform passes. All functions
+ * operate on the babel/tsx AST that jscodeshift's `tsx` parser produces, via
+ * the `j` builder API.
+ *
+ * Nothing here may know which source library is being migrated — this module
+ * is imported by all of them (`react-bulma-components`, `rbx`, …), so any
+ * library-specific table belongs in that source's own `mapping.ts`.
  */
 
 import type { JSCodeshift } from 'jscodeshift';
@@ -16,7 +20,7 @@ export interface TransformContext {
   j: JSCodeshift;
   file: string;
   collector: TodoCollector | undefined;
-  /** RBC top-level import names that must survive the import rewrite. */
+  /** Source-library top-level import names that must survive the rewrite. */
   retained: Set<string>;
   /** bestax-bulma imports: imported name → local name (aliased on conflict). */
   needed: Map<string, string>;
@@ -32,7 +36,10 @@ export interface TransformContext {
    * Navbar.Item becomes Navbar.DropdownMenu).
    */
   overrides: WeakMap<object, string>;
-  /** Resolves a JSX name node to its canonical RBC path (set by transform). */
+  /**
+   * Resolves a JSX name node to its canonical source-library path (set by the
+   * source's transform).
+   */
   resolve?: (name: any) => string[] | null;
   dirty: boolean;
 }
@@ -119,13 +126,14 @@ export function literalValueOf(attr: any): LiteralValue {
 export type Booleanish = 'truthy' | 'falsy' | 'expression';
 
 /**
- * Classify a JSX attribute by the truthiness RBC evaluates it with at
- * runtime (`!!value`): every statically-known literal (boolean, string, or
- * number) resolves to `'truthy'`/`'falsy'`; only a genuine expression is
- * `'expression'`. This is the single place the six call sites that branch on
- * a "booleanish" prop (Button `remove`, Heading `heading`/`subtitle`,
- * `booleanToProp`, the `active` ladders, Field `multiline`) agree on what
- * counts as resolvable, so they can't drift out of sync with each other.
+ * Classify a JSX attribute by the truthiness the source library evaluates it
+ * with at runtime (`!!value`): every statically-known literal (boolean,
+ * string, or number) resolves to `'truthy'`/`'falsy'`; only a genuine
+ * expression is `'expression'`. This is the single place every call site that
+ * branches on a "booleanish" prop (RBC's Button `remove`, Heading
+ * `heading`/`subtitle`, `booleanToProp`, the `active` ladders, Field
+ * `multiline`; rbx's bare-boolean modifiers) agrees on what counts as
+ * resolvable, so they can't drift out of sync with each other.
  */
 export function resolveBooleanish(attr: any): Booleanish {
   const literal = literalValueOf(attr);
diff --git a/bestax-migrate/src/sources/_shared/make-styles-transform.ts b/bestax-migrate/src/sources/_shared/make-styles-transform.ts
new file mode 100644
index 000000000..489175e6c
--- /dev/null
+++ b/bestax-migrate/src/sources/_shared/make-styles-transform.ts
@@ -0,0 +1,572 @@
+/**
+ * Stylesheet migration, shared by every source: Bulma 0.9-era Sass
+ * (`@import` + `$var !default` overrides, `_all` aggregator partials) →
+ * Bulma v1 modules (`@use "bulma/sass" with (…)`), plus the bestax extras.
+ *
+ * Sass has no jscodeshift parser, so this is a conservative line-based text
+ * transform: it only rewrites patterns it can prove safe and leaves a
+ * `// TODO(bestax-migrate): …` everywhere else (line comments are valid in
+ * both SCSS and indented Sass).
+ *
+ * Everything about Bulma itself is source-independent — the only per-source
+ * parts are which package's own stylesheet specifiers to retire and which
+ * migration guide to link, so those arrive through `StylesConfig`.
+ */
+
+import path from 'node:path';
+import type { StylesTransform, TodoCollector } from '../../types.js';
+
+export interface StylesConfig {
+  /** npm package name of the source library, e.g. `rbx`. */
+  packageName: string;
+  /** URL of that source's migration guide, linked from every TODO. */
+  guideUrl: string;
+  /**
+   * Regex fragments (not literals) for the path suffixes that, together with
+   * the bare package name, count as the package's *root* stylesheet rather
+   * than one of its partials — these are replaced with a Bulma v1 root
+   * instead of being dropped.
+   */
+  rootStylesheetSuffixes: string[];
+}
+
+const TODO = 'TODO(bestax-migrate)';
+const EXTRAS_USE = "@use '@allxsmith/bestax-bulma/scss/extras';";
+
+/** Bulma v1 sass tree — directories that replaced the 0.9 `_all` partials. */
+const V1_DIRS = new Set([
+  'utilities',
+  'base',
+  'elements',
+  'form',
+  'components',
+  'grid',
+  'layout',
+  'helpers',
+  'themes',
+]);
+
+/** Known Bulma v1 leaf partials (path after `bulma/sass/`). */
+const V1_LEAVES = new Set([
+  'utilities/initial-variables',
+  'utilities/derived-variables',
+  'utilities/css-variables',
+  'utilities/mixins',
+  'utilities/functions',
+  'utilities/controls',
+  'utilities/extends',
+  'themes/light',
+  'themes/dark',
+  'themes/setup',
+]);
+
+/**
+ * The 0.9 root imports that become `@use "bulma/sass"`. The specifier may be
+ * bare (`bulma/bulma`), tilde-prefixed (webpack), or a relative path into
+ * node_modules (`../../node_modules/bulma/bulma`, common under Parcel) —
+ * relative prefixes are preserved in the emitted `@use`.
+ */
+const ROOT_IMPORT =
+  /^(\s*)@import\s+(['"])((?:\.\.?\/)+node_modules\/|~)?bulma\/(?:bulma(?:\.sass|\.scss)?|css\/bulma(?:\.min)?\.css)\2\s*;?\s*$/;
+
+/** 0.9 partial imports under bulma/sass/… (same prefix forms as the root). */
+const PARTIAL_IMPORT =
+  /^(\s*)@import\s+(['"])((?:\.\.?\/)+node_modules\/|~)?bulma\/sass\/([\w/-]+)\2\s*;?\s*$/;
+
+/** A preserved path prefix for the rewritten `@use` (tilde never survives). */
+function keptPrefix(prefix: string | undefined): string {
+  return prefix && prefix !== '~' ? prefix : '';
+}
+
+/** Any other line that still `@import`s something bulma-ish. */
+const OTHER_BULMA_IMPORT = /^\s*@import\s+['"][^'"]*bulma[^'"]*['"]/;
+
+/**
+ * Third-party Bulma extension packages (`bulma-checkradio`, `bulma-switch`,
+ * …) — 0.9-era add-ons whose v1 compatibility varies; several are covered
+ * by the bestax extras. The `bulma-` package name must start at a specifier
+ * segment boundary (right after the quote/`~`, or after a `/`) so this does
+ * not also match a name that merely *contains* `bulma-`, like
+ * `react-bulma-components` (see EXTENSION_IMPORT's own regression test).
+ */
+const EXTENSION_IMPORT =
+  /^\s*@import\s+['"](?:~|[^'"]*\/)?bulma-([\w-]+?)(?:\/|\.|['"])/;
+
+/**
+ * The source library's own stylesheet. This is not a third-party extension:
+ * it is the library being migrated away from, and `deps.ts` removes its
+ * package.json entry in the same run, so leaving the import in place breaks
+ * the Sass build. Any `react-bulma-components/…` specifier is dead the same
+ * way — the documented v3 setup paths (the bundled CSS, the "advanced" Sass
+ * entry point), but also deep partials and extensionless forms — so, like
+ * `transform.ts`, we match on the package prefix rather than enumerating
+ * shapes. The prefix may be bare, `~`-prefixed, or a relative node_modules
+ * path (the Parcel form `ROOT_IMPORT` also supports).
+ */
+
+/**
+ * The subset of RBC stylesheet imports that are the library's own *root*: the
+ * bare package specifier, the documented Sass entry point (`src/index`), and
+ * the bundled v3 CSS (`dist/react-bulma-components(.min).css`). These pull in
+ * the whole library, which `bulma/sass` supersedes — so when the file already
+ * has a Bulma root, dropping one of these loses nothing. A deep RBC partial
+ * (`src/components/navbar.sass`) is NOT a root: `bulma/sass` doesn't carry a
+ * given partial's styles, so removing one silently would drop CSS. We flag
+ * those instead (the package's "never a silent skip" rule).
+ */
+
+/**
+ * A Bulma module root already pulled in via `@use` — the file's own
+ * `@use 'bulma/sass'` (any prefix, configured or not) or the bestax bundle
+ * (`scss/bestax`, which itself loads `bulma/sass with (…)`). When one is
+ * present we must not emit a second root: a duplicate `bulma/sass` namespace,
+ * or reconfiguring an already-loaded module, is a hard Sass error.
+ */
+const USE_BULMA_ROOT =
+  /^\s*@use\s+(['"])(?:~|(?:\.\.?\/)+node_modules\/)?(?:bulma\/sass|@allxsmith\/bestax-bulma\/(?:src\/)?scss\/bestax)\1/;
+
+/** Any `$name: value;` declaration (with or without `!default`). */
+const VAR_DECL = /^\s*\$([\w-]+)\s*:\s*(.+?)\s*(!default)?\s*;\s*$/;
+
+/**
+ * Strips Sass block comments (slash-star … star-slash spans) from a value
+ * before it is analyzed for foldability or top-level commas. A comment can
+ * carry an unbalanced quote (an apostrophe in `user's`) or a stray `(`/`$`
+ * that would otherwise fool the character scanners into mis-reading the
+ * value's structure; the comment is inert to Sass, so removing it for
+ * analysis is safe. The emitted value still carries the comment verbatim.
+ *
+ * The scan tracks quote state first and only recognizes a block comment
+ * outside a string, in one pass — a bare regex would treat a slash-star …
+ * star-slash-shaped span that straddles two quoted strings (opening marker in
+ * one string, closing marker in the next) as a comment and delete the real
+ * top-level comma between them, so a genuine list would fold unparenthesized.
+ * An unterminated comment consumes the rest of the value.
+ */
+function stripSassComments(value: string): string {
+  let result = '';
+  let quote: string | null = null;
+  let escaped = false;
+  for (let i = 0; i < value.length; i += 1) {
+    const char = value[i];
+    if (quote) {
+      result += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '/' && value[i + 1] === '*') {
+      const end = value.indexOf('*/', i + 2);
+      if (end === -1) break; // unterminated comment — drop the rest
+      i = end + 1; // resume after the closing */
+      continue;
+    }
+    if (char === '"' || char === "'") quote = char;
+    result += char;
+  }
+  return result;
+}
+
+/**
+ * A value is fold-safe for `with (…)` when it is a plain literal — no
+ * function calls, interpolation, variable references, or at-rules. Hex
+ * colors (`#ff6b35`) are fine; `#{…}` interpolation is not. Block comments are
+ * ignored for this test — their contents don't make the value non-literal.
+ */
+function isFoldableValue(value: string): boolean {
+  return !/[()$@]|#\{/.test(stripSassComments(value));
+}
+
+/**
+ * Whether `value` has a comma outside any quoted string — a bare Sass list
+ * (`'Nunito', sans-serif`) that must be parenthesized before it can sit
+ * inside `with (…)`, or Dart Sass reads the comma as an argument separator
+ * instead of a list delimiter. Block comments are stripped first so a quote or
+ * comma inside one (an apostrophe in `user's`) can't skew the scan.
+ */
+function hasTopLevelComma(value: string): boolean {
+  let quote: string | null = null;
+  let escaped = false;
+  for (const char of stripSassComments(value)) {
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === '\\') {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) quote = null;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+    } else if (char === ',') {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** Formats a folded value for the `with (…)` clause, parenthesizing a bare list. */
+function formatFoldedValue(value: string): string {
+  return hasTopLevelComma(value) ? `(${value})` : value;
+}
+
+function report(
+  collector: TodoCollector | undefined,
+  file: string,
+  line: number | null,
+  rule: string,
+  message: string
+): void {
+  collector?.add({ file, line, rule, message });
+}
+
+/**
+ * Build the stylesheet transform for one source library.
+ *
+ * `packageName` drives two regexes — one matching any `@import` of that
+ * package, one narrowing to its *root* stylesheet (which becomes a Bulma v1
+ * root rather than being dropped). Everything else is Bulma-side and shared.
+ */
+export function makeStylesTransform(config: StylesConfig): StylesTransform {
+  const { packageName, guideUrl: GUIDE } = config;
+  const pkg = packageName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  // Already regex fragments — see StylesConfig.
+  const roots = config.rootStylesheetSuffixes.join('|');
+
+  /**
+   * Any @import of the source package's own stylesheets. The path after the
+   * package name is optional: `@import '~rbx'` resolves through the package's
+   * `style`/`sass` field and is a plausible spelling for a short package name,
+   * and SOURCE_ROOT_STYLESHEET below already accepts that bare form — so
+   * requiring the slash here made the bare case unreachable.
+   */
+  const SOURCE_STYLE_IMPORT = new RegExp(
+    `^(\\s*)@import\\s+(['"])((?:\\.\\.?/)+node_modules/|~)?${pkg}(?:/[^'"]*)?\\2\\s*;?\\s*(?://[^\\n]*)?\\s*$`
+  );
+  /** Cheap "is this file even about us?" pre-filter (see the guard below). */
+  const SOURCE_MENTION = new RegExp(pkg);
+
+  /** …narrowed to the ones that stand in for a whole Bulma root. */
+  const SOURCE_ROOT_STYLESHEET = new RegExp(
+    `^\\s*@import\\s+(['"])(?:(?:\\.\\.?/)+node_modules/|~)?${pkg}${roots ? `(?:${roots})?` : ''}\\1\\s*;?\\s*(?://[^\\n]*)?\\s*$`
+  );
+
+  const transformStyles: StylesTransform = (
+    filePath,
+    source,
+    collector,
+    options
+  ) => {
+    const cssMode = options.cssMode ?? 'bestax';
+    // Cheap pre-filter. It must accept a file that names only the SOURCE
+    // package: rbx's documented Sass entry is `@import '~rbx/rbx'` and rbx
+    // pulls Bulma in itself, so such a file contains no "bulma" substring at
+    // all. Bailing on it left a dead import behind with no TODO and no report
+    // entry while deps.ts deleted the package in the same run — a silent
+    // build break, which is exactly what this package promises never to do.
+    if (!/bulma/.test(source) && !SOURCE_MENTION.test(source)) return null;
+
+    // Indented-syntax files: flag only — rewriting without a parser is unsafe.
+    if (path.extname(filePath) === '.sass') {
+      if (source.includes(`${TODO}`)) return null;
+      report(
+        collector,
+        filePath,
+        1,
+        'sass',
+        `indented-syntax file references Bulma; convert its @import lines to @use "bulma/sass" by hand — see ${GUIDE}`
+      );
+      return `// ${TODO}: convert Bulma 0.9 @import lines to @use "bulma/sass" with (…) — see ${GUIDE}\n${source}`;
+    }
+
+    const lines = source.split('\n');
+    const out: string[] = [];
+    let changed = false;
+    let extrasAdded = source.includes('@allxsmith/bestax-bulma/scss');
+
+    // Pass 1: locate the file's Bulma root and the safe leading variable
+    // overrides that fold into it. A real `bulma/…` @import root wins; otherwise
+    // the RBC stylesheet, which we rewrite into a root the same way — so a file
+    // that starts from RBC and one that starts from a bulma @import converge on
+    // the identical shape. A pre-existing `@use` root means we create no new one.
+    const rootImportIndex = lines.findIndex(line => ROOT_IMPORT.test(line));
+    // DELIBERATELY any source specifier, not just the root stylesheet. A
+    // reviewer flagged that a lone deep partial (`~rbx/base/helpers/badge`) is
+    // rewritten into a full `@use 'bulma/sass'` as though it were the whole
+    // framework. That is the intended behaviour, and it predates rbx: the
+    // react-bulma-components suite asserts it by name ("regardless of
+    // specifier shape"). The reasoning holds for both sources — every one of
+    // these imports is dead once deps.ts removes the package, and a file that
+    // styled itself from the library needs SOME Bulma root afterwards, so
+    // emitting one beats dropping it and leaving the file unstyled.
+    const sourceRootIndex = lines.findIndex(
+      line => SOURCE_STYLE_IMPORT.test(line) && !line.includes(TODO)
+    );
+    const hasUseBulmaRoot = lines.some(line => USE_BULMA_ROOT.test(line));
+    const foldTargetIndex = hasUseBulmaRoot
+      ? -1
+      : rootImportIndex !== -1
+        ? rootImportIndex
+        : sourceRootIndex;
+    const foldableVars: Array<{ index: number; name: string; value: string }> =
+      [];
+    const unsafeVarLines: number[] = [];
+    if (foldTargetIndex !== -1) {
+      for (let i = 0; i < foldTargetIndex; i += 1) {
+        const line = lines[i];
+        const match = line.match(VAR_DECL);
+        if (match && isFoldableValue(match[2])) {
+          foldableVars.push({
+            index: i,
+            name: match[1],
+            value: match[2].trim(),
+          });
+        } else if (/^\s*\$[\w-]+\s*:/.test(line)) {
+          unsafeVarLines.push(i);
+        }
+      }
+    }
+    const folded = new Set(foldableVars.map(v => v.index));
+
+    /**
+     * Emit a Bulma module root at `indent` (folding the leading var overrides
+     * gathered above into `with (…)`, flagging any unsafe ones), then, in
+     * bestax mode, the extras. `prefix` is a preserved relative-path prefix
+     * (raw-file toolchains resolve paths, not package specifiers) or ''.
+     */
+    const emitBulmaRoot = (
+      indent: string,
+      prefix: string,
+      lineNo: number
+    ): void => {
+      const bulmaSass = `${prefix}bulma/sass`;
+      if (foldableVars.length > 0) {
+        out.push(`${indent}@use '${bulmaSass}' with (`);
+        foldableVars.forEach(({ name, value }, index) => {
+          const comma = index < foldableVars.length - 1 ? ',' : '';
+          out.push(`${indent}  $${name}: ${formatFoldedValue(value)}${comma}`);
+        });
+        out.push(`${indent});`);
+      } else {
+        out.push(`${indent}@use '${bulmaSass}';`);
+      }
+      if (unsafeVarLines.length > 0) {
+        out.push(
+          `${indent}// ${TODO}: the variable override(s) above use computed values; move them into the @use "bulma/sass" with (…) configuration by hand`
+        );
+        report(
+          collector,
+          filePath,
+          lineNo,
+          'sass',
+          'variable overrides with computed values could not be folded into `with (…)`'
+        );
+      }
+      if (cssMode === 'bestax' && !extrasAdded) {
+        out.push(
+          prefix
+            ? `${indent}@use '${prefix}@allxsmith/bestax-bulma/src/scss/extras';`
+            : `${indent}${EXTRAS_USE}`
+        );
+        extrasAdded = true;
+      }
+    };
+
+    for (let i = 0; i < lines.length; i += 1) {
+      const line = lines[i];
+
+      if (i === rootImportIndex) {
+        const rootMatch = line.match(ROOT_IMPORT);
+        // A path-prefixed root import means the toolchain resolves raw file
+        // paths, not package specifiers — point at the shipped files directly.
+        emitBulmaRoot(rootMatch?.[1] ?? '', keptPrefix(rootMatch?.[3]), i + 1);
+        changed = true;
+        continue;
+      }
+
+      if (folded.has(i)) {
+        changed = true; // folded into with(...) above
+        continue;
+      }
+
+      const partial = line.match(PARTIAL_IMPORT);
+      if (partial) {
+        const [, indent, , rawPrefix, importPath] = partial;
+        const prefix = keptPrefix(rawPrefix);
+        // Partial-only files (modular builds with no root import) still need
+        // the extras for the bestax components' styling; the extras tree only
+        // reads Bulma utilities, never configures them, so this is load-safe.
+        const pushExtras = () => {
+          if (cssMode !== 'bestax' || extrasAdded || rootImportIndex !== -1) {
+            return;
+          }
+          out.push(
+            prefix
+              ? `${indent}@use '${prefix}@allxsmith/bestax-bulma/src/scss/extras';`
+              : `${indent}${EXTRAS_USE}`
+          );
+          extrasAdded = true;
+        };
+        const segments = importPath.split('/');
+        const last = segments[segments.length - 1].replace(/^_/, '');
+        const dir = segments[0];
+        if ((last === 'all' || last === 'index') && V1_DIRS.has(dir)) {
+          out.push(`${indent}@use '${prefix}bulma/sass/${dir}';`);
+          pushExtras();
+          changed = true;
+          continue;
+        }
+        const leaf = segments.map(s => s.replace(/^_/, '')).join('/');
+        if (V1_DIRS.has(leaf) || V1_LEAVES.has(leaf)) {
+          out.push(`${indent}@use '${prefix}bulma/sass/${leaf}';`);
+          pushExtras();
+          changed = true;
+          continue;
+        }
+        out.push(
+          `${indent}// ${TODO}: this Bulma 0.9 partial path no longer exists in Bulma v1; find its replacement under bulma/sass/ — see ${GUIDE}`
+        );
+        out.push(line);
+        report(
+          collector,
+          filePath,
+          i + 1,
+          'sass',
+          `Bulma 0.9 partial path \`bulma/sass/${importPath}\` has no direct v1 equivalent`
+        );
+        changed = true;
+        continue;
+      }
+
+      const sourceStyle = line.match(SOURCE_STYLE_IMPORT);
+      if (sourceStyle && !line.includes(TODO)) {
+        const indent = sourceStyle[1];
+        const prefix = keptPrefix(sourceStyle[3]);
+        if (
+          i === sourceRootIndex &&
+          rootImportIndex === -1 &&
+          !hasUseBulmaRoot
+        ) {
+          // The library's own stylesheet never resolves post-migration (deps.ts
+          // removes react-bulma-components in the same run), and it is this
+          // file's only Bulma root, so rewrite it into one — the same shape the
+          // @import root path emits, folding any leading var overrides. Emitting
+          // a real `bulma/sass` (+ extras) rather than the hard-configured
+          // bestax bundle keeps this convergent with the @import path and avoids
+          // reconfiguring `bulma/sass` if a themed root exists elsewhere.
+          emitBulmaRoot(indent, prefix, i + 1);
+          if (cssMode === 'keep') {
+            // The replacement is unavoidable even in keep mode: RBC's own
+            // stylesheet is a v3 (Bulma 0.9) asset the migrated v1 components
+            // can't use. What changed depends on whether the manifest step ran.
+            const depsRan = options.deps !== false;
+            const detail = depsRan
+              ? 'its package.json entry is removed, so the old import no longer resolves; install bulma@^1'
+              : 'it targets Bulma 0.9, not the v1 your components now use; --no-deps kept the dependency, so install bulma@^1 alongside it';
+            out.push(
+              `${indent}// ${TODO}: replaced ${packageName}'s own stylesheet with @use 'bulma/sass' — ${detail} — see ${GUIDE}`
+            );
+            report(
+              collector,
+              filePath,
+              i + 1,
+              'sass',
+              depsRan
+                ? `replaced ${packageName}'s stylesheet import with bulma/sass; the package is removed from dependencies, so the old import would not resolve`
+                : `replaced ${packageName}'s stylesheet import with bulma/sass; it is a Bulma 0.9 asset the migrated v1 components can't use (--no-deps left the package in place)`
+            );
+          } else {
+            // bestax/bulma modes rewrite the file's root without a TODO — still
+            // report it so the migration summary reflects the restructured root.
+            report(
+              collector,
+              filePath,
+              i + 1,
+              'sass',
+              `replaced ${packageName}'s stylesheet import with a Bulma v1 @use root`
+            );
+          }
+        } else {
+          // A Bulma root already covers this file (a `bulma/…` @import we
+          // convert, the file's own `@use` root, or an earlier RBC line we
+          // rewrote). In bestax mode keep that root and add only the extras —
+          // never a second root, never the configured bundle that would
+          // reconfigure an already-loaded module.
+          if (cssMode === 'bestax' && !extrasAdded) {
+            out.push(
+              prefix
+                ? `${indent}@use '${prefix}@allxsmith/bestax-bulma/src/scss/extras';`
+                : `${indent}${EXTRAS_USE}`
+            );
+            extrasAdded = true;
+          }
+          // Dropping the RBC line is only safe for its root/index stylesheet,
+          // which `bulma/sass` supersedes. A deep RBC partial can carry styles
+          // `bulma/sass` doesn't, so removing it silently would lose CSS — flag
+          // it with a TODO + report entry instead (never a silent skip).
+          if (!SOURCE_ROOT_STYLESHEET.test(line)) {
+            out.push(
+              `${indent}// ${TODO}: dropped a ${packageName} stylesheet partial that has no Bulma v1 root equivalent; port any styles it carried beyond Bulma's own by hand — see ${GUIDE}`
+            );
+            report(
+              collector,
+              filePath,
+              i + 1,
+              'sass',
+              `${packageName} stylesheet partial dropped; port any styles it carried beyond Bulma’s own by hand`
+            );
+          }
+        }
+        changed = true;
+        continue;
+      }
+
+      if (OTHER_BULMA_IMPORT.test(line) && !line.includes(TODO)) {
+        const extension = line.match(EXTENSION_IMPORT);
+        if (extension) {
+          out.push(
+            `// ${TODO}: bulma-${extension[1]} is a Bulma 0.9-era extension — check its Bulma v1 compatibility; the bestax extras already style Radio/Checkbox and the advanced form controls — see ${GUIDE}`
+          );
+          out.push(line);
+          report(
+            collector,
+            filePath,
+            i + 1,
+            'sass',
+            `third-party Bulma extension \`bulma-${extension[1]}\` left in place; verify it against Bulma v1 or replace it with the bestax extras`
+          );
+          changed = true;
+          continue;
+        }
+        out.push(
+          `// ${TODO}: Bulma v1 uses @use instead of @import — see ${GUIDE}`
+        );
+        out.push(line);
+        report(
+          collector,
+          filePath,
+          i + 1,
+          'sass',
+          'unrecognized Bulma @import left in place; convert to @use by hand'
+        );
+        changed = true;
+        continue;
+      }
+
+      out.push(line);
+    }
+
+    return changed ? out.join('\n') : null;
+  };
+
+  return transformStyles;
+}
diff --git a/bestax-migrate/src/sources/react-bulma-components/props.ts b/bestax-migrate/src/sources/_shared/props.ts
similarity index 88%
rename from bestax-migrate/src/sources/react-bulma-components/props.ts
rename to bestax-migrate/src/sources/_shared/props.ts
index 116ad5204..d35ec8c42 100644
--- a/bestax-migrate/src/sources/react-bulma-components/props.ts
+++ b/bestax-migrate/src/sources/_shared/props.ts
@@ -1,11 +1,14 @@
 /**
  * Prop-level conversion: applies a PropAction to a single attribute, plus the
  * universal modifier-prop pass shared by every mapped component.
+ *
+ * Source-agnostic — the universal table is passed in by the caller rather than
+ * imported, so each source keeps its own `UNIVERSAL_PROPS` in its `mapping.ts`
+ * while sharing this interpreter.
  */
 
 import type { ASTPath } from 'jscodeshift';
 import type { PropAction } from '../../types.js';
-import { UNIVERSAL_PROPS } from './mapping.js';
 import {
   addAttr,
   addTodo,
@@ -22,8 +25,8 @@ import {
 
 /**
  * Add a converted attribute unless the target name is already present — two
- * RBC props can map onto one bestax prop (e.g. `textTransform` + `italic`),
- * and a silent duplicate would be invalid JSX.
+ * source props can map onto one bestax prop (e.g. RBC's `textTransform` +
+ * `italic`), and a silent duplicate would be invalid JSX.
  */
 function addConverted(
   ctx: TransformContext,
@@ -180,19 +183,21 @@ export function applyPropAction(
 }
 
 /**
- * Apply the universal RBC modifier-prop conversions to every attribute that
- * was not already handled by the component's own prop map.
+ * Apply the source library's universal modifier-prop conversions to every
+ * attribute that was not already handled by the component's own prop map.
+ * `universalProps` is the calling source's `UNIVERSAL_PROPS` table.
  */
 export function applyUniversalProps(
   ctx: TransformContext,
   path: ASTPath<any>,
   element: any,
-  handled: Set<string>
+  handled: Set<string>,
+  universalProps: Record<string, PropAction>
 ): void {
   for (const attr of [...attributesOf(element)]) {
     const name: string = attr.name.name;
     if (handled.has(name)) continue;
-    const action = UNIVERSAL_PROPS[name];
+    const action = universalProps[name];
     if (!action) continue;
     applyPropAction(ctx, path, element, attr, action);
   }
diff --git a/bestax-migrate/src/sources/_shared/specials-utils.ts b/bestax-migrate/src/sources/_shared/specials-utils.ts
new file mode 100644
index 000000000..29a6a37ce
--- /dev/null
+++ b/bestax-migrate/src/sources/_shared/specials-utils.ts
@@ -0,0 +1,189 @@
+/**
+ * Building blocks shared by every source's structural handlers: picking a
+ * target from an align-style prop, stripping Bulma modifier props off an
+ * element on its way to becoming plain HTML, merging a consumed `className`,
+ * and reading an icon-font class string.
+ *
+ * Source-agnostic. `makeStripModifierProps` is a factory precisely because
+ * the modifier vocabulary is the one thing here that differs per source.
+ */
+
+import type { ASTPath } from 'jscodeshift';
+import type { PropAction } from '../../types.js';
+import {
+  addTodo,
+  findAttr,
+  literalValueOf,
+  removeAttr,
+  type TransformContext,
+} from './jsx-utils.js';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export interface SpecialResult {
+  /** Override the mapping's `target` for the rename step. */
+  target?: string;
+  /** The node was replaced outright — skip rename and prop passes. */
+  replaced?: boolean;
+  /** Prop names the handler consumed; skipped by the later prop passes. */
+  handledProps?: string[];
+}
+
+export type SpecialHandler = (
+  ctx: TransformContext,
+  path: ASTPath<any>,
+  element: any
+) => SpecialResult;
+
+/** Pick a target based on a literal align-style prop, removing the prop. */
+export function alignTarget(
+  ctx: TransformContext,
+  path: ASTPath<any>,
+  element: any,
+  prop: string,
+  targets: Record<string, string>,
+  fallback: string
+): SpecialResult {
+  const attr = findAttr(element, prop);
+  if (!attr) return { target: fallback };
+  const literal = literalValueOf(attr);
+  if (literal.kind === 'string' && targets[literal.value]) {
+    removeAttr(element, attr);
+    ctx.dirty = true;
+    return { target: targets[literal.value] };
+  }
+  if (literal.kind === 'string') {
+    removeAttr(element, attr);
+    ctx.dirty = true;
+    return { target: fallback };
+  }
+  addTodo(
+    ctx,
+    path,
+    `prop:${prop}`,
+    `\`${prop}\` has a dynamic value; pick between ${Object.values(targets).join(' / ')} by hand`
+  );
+  removeAttr(element, attr);
+  ctx.dirty = true;
+  return { target: fallback };
+}
+
+/**
+ * Build the modifier-prop filter for one source: it needs that source's own
+ * universal-prop and breakpoint tables to know what counts as a modifier.
+ *
+ * The returned function filters Bulma modifier props out of an attribute list
+ * bound for a plain HTML element (they only exist on bestax components),
+ * leaving a TODO when any were dropped.
+ */
+export function makeStripModifierProps(
+  universalProps: Record<string, PropAction>,
+  responsiveBreakpoints: Record<string, string | null>
+) {
+  return function stripModifierProps(
+    ctx: TransformContext,
+    path: ASTPath<any>,
+    attrs: any[],
+    where: string
+  ): any[] {
+    const kept: any[] = [];
+    const dropped: string[] = [];
+    for (const attr of attrs) {
+      const name = attr?.name?.name;
+      if (name && (universalProps[name] || name in responsiveBreakpoints)) {
+        dropped.push(name);
+      } else {
+        kept.push(attr);
+      }
+    }
+    if (dropped.length > 0) {
+      addTodo(
+        ctx,
+        path,
+        'plain-element',
+        `${where} became a plain element; the Bulma helper prop(s) ${dropped
+          .map(d => `\`${d}\``)
+          .join(', ')} were dropped — restyle with classes`
+      );
+    }
+    return kept;
+  };
+}
+
+/**
+ * Consume the element's `className` so a plain-element rewrite can merge it
+ * with its hard-coded Bulma class instead of dropping it. A dynamic value
+ * can't be merged safely — keep the base class and leave a TODO.
+ */
+export function mergeClassName(
+  ctx: TransformContext,
+  path: ASTPath<any>,
+  element: any,
+  base: string | undefined,
+  where: string
+): string | undefined {
+  const attr = findAttr(element, 'className');
+  if (!attr) return base;
+  const literal = literalValueOf(attr);
+  removeAttr(element, attr);
+  if (literal.kind === 'string') {
+    return base ? `${base} ${literal.value}` : literal.value;
+  }
+  addTodo(
+    ctx,
+    path,
+    'prop:className',
+    base
+      ? `dynamic ${where} className; merge it with the \`${base}\` class by hand`
+      : `dynamic ${where} className; re-apply it to the emitted element by hand`
+  );
+  return base;
+}
+
+/** Parse an icon-font <i className="..."> into bestax Icon name/library/variant. */
+export function parseIconClasses(
+  className: string
+): { name: string; library?: string; variant?: string } | null {
+  const tokens = className.trim().split(/\s+/);
+  const faVariant: Record<string, string> = {
+    fas: 'solid',
+    far: 'regular',
+    fab: 'brands',
+    fal: 'light',
+    fad: 'duotone',
+    fat: 'thin',
+    // Font Awesome 6 spells the style out, and has been the default since
+    // 2022 — matching only the v5 short forms meant the common case fell
+    // through to the "migrate this icon by hand" TODO.
+    'fa-solid': 'solid',
+    'fa-regular': 'regular',
+    'fa-brands': 'brands',
+    'fa-light': 'light',
+    'fa-duotone': 'duotone',
+    'fa-thin': 'thin',
+  };
+  const faStyle = tokens.find(t => faVariant[t]);
+  // Every `fa-*` that is a MODIFIER rather than an icon name — including
+  // v6's spelled-out style and family words, which are `fa-` prefixed and
+  // would otherwise be read as the icon (`fa-solid fa-home` → name="solid").
+  // The old list
+  // covered only sizing and spin, so a class string that puts a modifier
+  // first — `fas fa-rotate-90 fa-home`, which Font Awesome's own docs show —
+  // yielded name="rotate-90". Ordering is not guaranteed, so the filter has
+  // to be exhaustive rather than positional.
+  const FA_MODIFIER =
+    /^fa-(?:solid|regular|brands|light|duotone|thin|sharp|classic|2xs|xs|sm|lg|xl|2xl|\d{1,2}x|fw|ul|li|border|inverse|stack|stack-1x|stack-2x|pull-(?:left|right)|spin|spin-pulse|spin-reverse|pulse|beat|fade|beat-fade|bounce|flash|shake|swap-opacity|rotate-(?:90|180|270|by)|flip-(?:horizontal|vertical|both))$/;
+  const faName = tokens.find(t => /^fa-/.test(t) && !FA_MODIFIER.test(t));
+  if (faStyle && faName) {
+    return {
+      name: faName.replace(/^fa-/, ''),
+      library: 'fa',
+      variant: faVariant[faStyle],
+    };
+  }
+  if (tokens.includes('mdi')) {
+    const mdiName = tokens.find(t => /^mdi-/.test(t) && t !== 'mdi');
+    if (mdiName) return { name: mdiName.replace(/^mdi-/, ''), library: 'mdi' };
+  }
+  return null;
+}
diff --git a/bestax-migrate/src/sources/rbx/__testfixtures__/badge-tooltip.input.tsx b/bestax-migrate/src/sources/rbx/__testfixtures__/badge-tooltip.input.tsx
new file mode 100644
index 000000000..ef1aaaae4
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__testfixtures__/badge-tooltip.input.tsx
@@ -0,0 +1,23 @@
+import React from "react";
+import { Button, Box } from "rbx";
+
+export const Decorated = () => (
+  <Box>
+    <Button badge="3" badgeColor="danger">
+      Inbox
+    </Button>
+    <Button tooltip="Click me" tooltipPosition="bottom" tooltipColor="info" tooltipMultiline>
+      Hover
+    </Button>
+    <Button badge={7} tooltip="Both at once">
+      Combined
+    </Button>
+    <Button badge="9" badgeOutlined badgeRounded badgeSize="large">
+      Unsupported badge modifiers
+    </Button>
+    <Button tooltip="responsive" tooltipResponsive={{ tablet: "left" }}>
+      Unsupported tooltip modifier
+    </Button>
+    <Button badgeColor="info">Modifier with no badge</Button>
+  </Box>
+);
diff --git a/bestax-migrate/src/sources/rbx/__testfixtures__/badge-tooltip.output.tsx b/bestax-migrate/src/sources/rbx/__testfixtures__/badge-tooltip.output.tsx
new file mode 100644
index 000000000..90c6d06e0
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__testfixtures__/badge-tooltip.output.tsx
@@ -0,0 +1,28 @@
+import React from "react";
+import { Badge, Box, Button, Tooltip } from "@allxsmith/bestax-bulma";
+
+// TODO(bestax-migrate): bestax's `<Badge>` has no `badgeOutlined` equivalent; restyle by hand
+// TODO(bestax-migrate): bestax's `<Badge>` has no `badgeRounded` equivalent; restyle by hand
+// TODO(bestax-migrate): bestax's `<Badge>` has no `badgeSize` equivalent; restyle by hand
+// TODO(bestax-migrate): bestax's `<Tooltip>` has no `tooltipResponsive` equivalent; restyle by hand
+// TODO(bestax-migrate): `badgeColor` set without `badge`; bestax's `<Badge>` needs content — dropped
+export const Decorated = () => (
+  <Box>
+    <Badge content="3" color="danger"><Button>
+        Inbox
+      </Button></Badge>
+    <Tooltip label="Click me" position="bottom" color="info" multiline><Button>
+        Hover
+      </Button></Tooltip>
+    <Tooltip label="Both at once"><Badge content={7}><Button>
+          Combined
+        </Button></Badge></Tooltip>
+    <Badge content="9"><Button>
+        Unsupported badge modifiers
+      </Button></Badge>
+    <Tooltip label="responsive"><Button>
+        Unsupported tooltip modifier
+      </Button></Tooltip>
+    <Button>Modifier with no badge</Button>
+  </Box>
+);
diff --git a/bestax-migrate/src/sources/rbx/__testfixtures__/compounds.input.tsx b/bestax-migrate/src/sources/rbx/__testfixtures__/compounds.input.tsx
new file mode 100644
index 000000000..e0744e280
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__testfixtures__/compounds.input.tsx
@@ -0,0 +1,51 @@
+import React from "react";
+import { Card, Level, Media, Message, Table, Hero, Breadcrumb } from "rbx";
+
+export const Compounds = () => (
+  <>
+    <Card>
+      <Card.Header>
+        <Card.Header.Title align="centered">Title</Card.Header.Title>
+        <Card.Header.Icon>i</Card.Header.Icon>
+      </Card.Header>
+      <Card.Content>body</Card.Content>
+      <Card.Footer>
+        <Card.Footer.Item>one</Card.Footer.Item>
+      </Card.Footer>
+    </Card>
+    <Level breakpoint="mobile">
+      <Level.Item align="left">left</Level.Item>
+      <Level.Item align="right">right</Level.Item>
+      <Level.Item>middle</Level.Item>
+    </Level>
+    <Media>
+      <Media.Item align="left">avatar</Media.Item>
+      <Media.Item align="content">body</Media.Item>
+    </Media>
+    <Message color="info">
+      <Message.Header>head</Message.Header>
+      <Message.Body>body</Message.Body>
+    </Message>
+    <Table bordered striped hoverable fullwidth narrow>
+      <Table.Head>
+        <Table.Row>
+          <Table.Heading>h</Table.Heading>
+        </Table.Row>
+      </Table.Head>
+      <Table.Body>
+        <Table.Row>
+          <Table.Cell>c</Table.Cell>
+        </Table.Row>
+      </Table.Body>
+    </Table>
+    <Hero color="primary" size="large">
+      <Hero.Head>head</Hero.Head>
+      <Hero.Body>body</Hero.Body>
+      <Hero.Foot>foot</Hero.Foot>
+    </Hero>
+    <Breadcrumb align="centered" separator="arrow">
+      <Breadcrumb.Item href="/a">A</Breadcrumb.Item>
+      <Breadcrumb.Item active href="/b">B</Breadcrumb.Item>
+    </Breadcrumb>
+  </>
+);
diff --git a/bestax-migrate/src/sources/rbx/__testfixtures__/compounds.output.tsx b/bestax-migrate/src/sources/rbx/__testfixtures__/compounds.output.tsx
new file mode 100644
index 000000000..d8f3a76c2
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__testfixtures__/compounds.output.tsx
@@ -0,0 +1,51 @@
+import React from "react";
+import { Breadcrumb, Card, Hero, Level, Media, Message, Table } from "@allxsmith/bestax-bulma";
+
+export const Compounds = () => (
+  <>
+    <Card>
+      <Card.Header>
+        <Card.Header.Title centered>Title</Card.Header.Title>
+        <Card.Header.Icon>i</Card.Header.Icon>
+      </Card.Header>
+      <Card.Content>body</Card.Content>
+      <Card.Footer>
+        <Card.FooterItem>one</Card.FooterItem>
+      </Card.Footer>
+    </Card>
+    <Level isMobile>
+      <Level.Left>left</Level.Left>
+      <Level.Right>right</Level.Right>
+      <Level.Item>middle</Level.Item>
+    </Level>
+    <Media>
+      <Media.Left>avatar</Media.Left>
+      <Media.Content>body</Media.Content>
+    </Media>
+    <Message color="info">
+      <Message.Header>head</Message.Header>
+      <Message.Body>body</Message.Body>
+    </Message>
+    <Table isBordered isStriped isHoverable isFullwidth isNarrow>
+      <Table.Thead>
+        <Table.Tr>
+          <Table.Th>h</Table.Th>
+        </Table.Tr>
+      </Table.Thead>
+      <Table.Tbody>
+        <Table.Tr>
+          <Table.Td>c</Table.Td>
+        </Table.Tr>
+      </Table.Tbody>
+    </Table>
+    <Hero color="primary" size="large">
+      <Hero.Head>head</Hero.Head>
+      <Hero.Body>body</Hero.Body>
+      <Hero.Foot>foot</Hero.Foot>
+    </Hero>
+    <Breadcrumb alignment="centered" separator="arrow">
+      <li><a href="/a">A</a></li>
+      <li className="is-active"><a href="/b">B</a></li>
+    </Breadcrumb>
+  </>
+);
diff --git a/bestax-migrate/src/sources/rbx/__testfixtures__/form.input.tsx b/bestax-migrate/src/sources/rbx/__testfixtures__/form.input.tsx
new file mode 100644
index 000000000..20af5e0d7
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__testfixtures__/form.input.tsx
@@ -0,0 +1,40 @@
+import React from "react";
+import { Field, Control, Input, Label, Help, Select, Textarea, Checkbox, Radio, Icon, Image, PageLoader, Loader, Divider, Delete } from "rbx";
+
+export const Form = () => (
+  <>
+    <Field horizontal>
+      <Field.Label size="normal">
+        <Label size="small">Name</Label>
+      </Field.Label>
+      <Field.Body>
+        <Control expanded iconLeft loading>
+          <Input type="text" color="danger" size="small" rounded state="focused" />
+          <Icon size="small" align="left">
+            <i className="fas fa-user" />
+          </Icon>
+        </Control>
+        <Help color="danger">Required</Help>
+      </Field.Body>
+    </Field>
+    <Field kind="group" multiline>
+      <Control>
+        <Select.Container fullwidth rounded state="loading" size="medium">
+          <Select>
+            <Select.Option value="a">A</Select.Option>
+          </Select>
+        </Select.Container>
+      </Control>
+    </Field>
+    <Textarea color="info" size="medium" fixedSize state="hovered" />
+    <Checkbox />
+    <Radio />
+    <Image.Container size={64}>
+      <Image src="/a.png" rounded />
+    </Image.Container>
+    <PageLoader active color="info" direction="right-to-left" />
+    <Loader />
+    <Divider color="primary" vertical>OR</Divider>
+    <Delete size="small" />
+  </>
+);
diff --git a/bestax-migrate/src/sources/rbx/__testfixtures__/form.output.tsx b/bestax-migrate/src/sources/rbx/__testfixtures__/form.output.tsx
new file mode 100644
index 000000000..d69495907
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__testfixtures__/form.output.tsx
@@ -0,0 +1,51 @@
+import React from "react";
+import {
+  Checkbox,
+  Control,
+  Delete,
+  Divider,
+  Field,
+  Icon,
+  Image,
+  Input,
+  Loading,
+  Radio,
+  Select,
+  TextArea,
+} from "@allxsmith/bestax-bulma";
+
+// TODO(bestax-migrate): `direction` — bestax `Loading` has no directional variant; drop it or add a custom class
+// TODO(bestax-migrate): rbx `Divider` rendered its children as a centred label; bestax `Divider` is a bare `<hr>` and takes no children — move the label into surrounding markup, or drop it
+// TODO(bestax-migrate): `color` — bestax `Divider` takes only `bgColor`; set that or a custom class
+// TODO(bestax-migrate): `vertical` — bestax `Divider` has no vertical variant; use a bordered Column or custom CSS
+export const Form = () => (
+  <>
+    <Field horizontal>
+      <Field.Label size="normal">
+        <label className="label is-small">Name</label>
+      </Field.Label>
+      <Field.Body>
+        <Control isExpanded hasIconsLeft isLoading>
+          <Input type="text" color="danger" size="small" isRounded isFocused />
+          <Icon size="small" align="left" name="user" library="fa" variant="solid" />
+        </Control>
+        <p className="help is-danger">Required</p>
+      </Field.Body>
+    </Field>
+    <Field grouped="multiline">
+      <Control>
+        <Select size="medium" isFullwidth isRounded isLoading>
+          <option value="a">A</option>
+        </Select>
+      </Control>
+    </Field>
+    <TextArea color="info" size="medium" hasFixedSize isHovered />
+    <Checkbox />
+    <Radio />
+    <Image src="/a.png" size="64x64" isRounded />
+    <Loading active color="info" direction="right-to-left" isFullPage />
+    <div className="loader"></div>
+    <Divider color="primary" vertical>OR</Divider>
+    <Delete size="small" />
+  </>
+);
diff --git a/bestax-migrate/src/sources/rbx/__testfixtures__/helpers.input.tsx b/bestax-migrate/src/sources/rbx/__testfixtures__/helpers.input.tsx
new file mode 100644
index 000000000..c227bc61a
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__testfixtures__/helpers.input.tsx
@@ -0,0 +1,29 @@
+import React from "react";
+import { Box, Button } from "rbx";
+
+export const Helpers = () => (
+  <Box
+    backgroundColor="primary"
+    textColor="grey-dark"
+    textAlign="centered"
+    textWeight="semibold"
+    textSize={4}
+    textTransform="uppercase"
+    italic
+    marginless
+    paddingless
+    radiusless
+    shadowless
+    relative
+    unselectable
+    clearfix
+    clipped
+    overlay
+    pull="right"
+  >
+    <Button hidden>hidden</Button>
+    <Button invisible>invisible</Button>
+    <Button srOnly>screen readers only</Button>
+    <Button textColor="white-ter">unsupported shade</Button>
+  </Box>
+);
diff --git a/bestax-migrate/src/sources/rbx/__testfixtures__/helpers.output.tsx b/bestax-migrate/src/sources/rbx/__testfixtures__/helpers.output.tsx
new file mode 100644
index 000000000..5ebffbef0
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__testfixtures__/helpers.output.tsx
@@ -0,0 +1,29 @@
+import React from "react";
+import { Box, Button } from "@allxsmith/bestax-bulma";
+
+// TODO(bestax-migrate): `italic` maps to `textTransform="italic"`, but `textTransform` is already set on this element; reconcile by hand
+// TODO(bestax-migrate): `textColor="white-ter"` — `white-ter` is not a bestax colour; use `white` or a custom class (https://bestax.io/docs/api/helpers/usebulmaclasses)
+export const Helpers = () => (
+  <Box
+    bgColor="primary"
+    textColor="grey-dark"
+    textAlign="centered"
+    textWeight="semibold"
+    textSize="4"
+    textTransform="uppercase"
+    relative
+    clearfix
+    overlay
+    float="right"
+    m="0"
+    p="0"
+    radius="radiusless"
+    shadow="shadowless"
+    interaction="unselectable"
+    overflow="clipped">
+    <Button visibility="hidden">hidden</Button>
+    <Button visibility="invisible">invisible</Button>
+    <Button visibility="sr-only">screen readers only</Button>
+    <Button textColor="white-ter">unsupported shade</Button>
+  </Box>
+);
diff --git a/bestax-migrate/src/sources/rbx/__testfixtures__/imports-basic.input.tsx b/bestax-migrate/src/sources/rbx/__testfixtures__/imports-basic.input.tsx
new file mode 100644
index 000000000..e04a327b8
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__testfixtures__/imports-basic.input.tsx
@@ -0,0 +1,31 @@
+import React from "react";
+import { Block, Box, Button, Notification, Progress, Tag, Title } from "rbx";
+import "rbx/index.css";
+
+export const Basic = () => (
+  <Block>
+    <Box>
+      <Title size={2} spaced>
+        Heading
+      </Title>
+      <Title subtitle size={4}>
+        Sub
+      </Title>
+      <Button color="primary" size="medium" outlined rounded>
+        Go
+      </Button>
+      <Button state="loading" fullwidth>
+        Wait
+      </Button>
+      <Tag color="danger" rounded size="medium">
+        New
+      </Tag>
+      <Tag.Group gapless>
+        <Tag>a</Tag>
+        <Tag>b</Tag>
+      </Tag.Group>
+      <Notification color="warning">Careful</Notification>
+      <Progress color="info" value={30} max={100} size="small" />
+    </Box>
+  </Block>
+);
diff --git a/bestax-migrate/src/sources/rbx/__testfixtures__/imports-basic.output.tsx b/bestax-migrate/src/sources/rbx/__testfixtures__/imports-basic.output.tsx
new file mode 100644
index 000000000..28622b30d
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__testfixtures__/imports-basic.output.tsx
@@ -0,0 +1,31 @@
+import React from "react";
+import { Block, Box, Button, Notification, Progress, SubTitle, Tag, Tags, Title } from "@allxsmith/bestax-bulma";
+import "@allxsmith/bestax-bulma/bestax.css";
+
+export const Basic = () => (
+  <Block>
+    <Box>
+      <Title size={2} isSpaced>
+        Heading
+      </Title>
+      <SubTitle size={4}>
+        Sub
+      </SubTitle>
+      <Button color="primary" size="medium" isOutlined isRounded>
+        Go
+      </Button>
+      <Button isLoading isFullwidth>
+        Wait
+      </Button>
+      <Tag color="danger" size="medium" isRounded>
+        New
+      </Tag>
+      <Tags hasAddons>
+        <Tag>a</Tag>
+        <Tag>b</Tag>
+      </Tags>
+      <Notification color="warning">Careful</Notification>
+      <Progress color="info" value={30} max={100} size="small" />
+    </Box>
+  </Block>
+);
diff --git a/bestax-migrate/src/sources/rbx/__testfixtures__/responsive.input.tsx b/bestax-migrate/src/sources/rbx/__testfixtures__/responsive.input.tsx
new file mode 100644
index 000000000..4cb8064ee
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__testfixtures__/responsive.input.tsx
@@ -0,0 +1,30 @@
+import React from "react";
+import { Box, Column, Generic } from "rbx";
+
+export const Responsive = () => (
+  <Column.Group centered multiline gapSize={4} tablet={{ gapSize: 2 }}>
+    <Column size={4} offset={1} tablet={{ size: 6, narrow: true }}>
+      one
+    </Column>
+    <Column narrow desktop={{ size: "one-third" }} touch={{ size: 12 }}>
+      two
+    </Column>
+  </Column.Group>
+);
+
+export const Hidden = () => (
+  <Box
+    responsive={{
+      mobile: { hide: { value: true } },
+      tablet: { display: { value: "flex" }, textSize: { value: 5 } },
+      desktop: { textAlign: { value: "centered" }, display: { value: "block", only: true } },
+    }}
+  >
+    x
+  </Box>
+);
+
+// Generic is unmappable, so it short-circuits before the responsive pass.
+export const Untouched = () => (
+  <Generic responsive={{ mobile: { hide: { value: true } } }}>x</Generic>
+);
diff --git a/bestax-migrate/src/sources/rbx/__testfixtures__/responsive.output.tsx b/bestax-migrate/src/sources/rbx/__testfixtures__/responsive.output.tsx
new file mode 100644
index 000000000..c4e4b31fb
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__testfixtures__/responsive.output.tsx
@@ -0,0 +1,34 @@
+import React from "react";
+import { Box, Column, Columns } from "@allxsmith/bestax-bulma";
+// TODO(bestax-migrate): Generic has no bestax-bulma equivalent yet — migrate and remove this import
+import { Generic } from "rbx";
+
+// TODO(bestax-migrate): dropped `touch.size`: no bestax per-viewport equivalent — set it by hand
+export const Responsive = () => (
+  <Columns gap={4} gapTablet={2} isCentered isMultiline>
+    <Column size={4} offset={1} sizeTablet={6} isNarrowTablet>
+      one
+    </Column>
+    <Column sizeDesktop="one-third" isNarrow>
+      two
+    </Column>
+  </Columns>
+);
+
+// TODO(bestax-migrate): `responsive.desktop.display.only` (Bulma's `-only` classes) has no bestax prop; use className
+// TODO(bestax-migrate): dropped the `responsive` prop; the `desktop` settings above could not be converted and bestax's own `responsive` prop is unrelated (`'mobile' | 'narrow'`)
+export const Hidden = () => (
+  <Box
+    visibilityMobile="hidden"
+    displayTablet="flex"
+    textSizeTablet="5"
+    textAlignDesktop="centered">
+    x
+  </Box>
+);
+
+// Generic is unmappable, so it short-circuits before the responsive pass.
+// TODO(bestax-migrate): `Generic` — `Generic` is rbx's untyped base element; render the underlying HTML tag directly, or use a bestax component (https://bestax.io/docs/api)
+export const Untouched = () => (
+  <Generic responsive={{ mobile: { hide: { value: true } } }}>x</Generic>
+);
diff --git a/bestax-migrate/src/sources/rbx/__testfixtures__/todos-unmappable.input.tsx b/bestax-migrate/src/sources/rbx/__testfixtures__/todos-unmappable.input.tsx
new file mode 100644
index 000000000..713691d7c
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__testfixtures__/todos-unmappable.input.tsx
@@ -0,0 +1,19 @@
+import React from "react";
+import { Tile, List, Generic, Fieldset, Numeric, Highlight, Footer } from "rbx";
+
+export const Unmappable = () => (
+  <Footer>
+    <Tile kind="ancestor">
+      <Tile kind="parent" vertical>
+        tile
+      </Tile>
+    </Tile>
+    <List>
+      <List.Item active>item</List.Item>
+    </List>
+    <Generic as="section">generic</Generic>
+    <Fieldset disabled>fields</Fieldset>
+    <Numeric>{1000}</Numeric>
+    <Highlight>{"const a = 1;"}</Highlight>
+  </Footer>
+);
diff --git a/bestax-migrate/src/sources/rbx/__testfixtures__/todos-unmappable.output.tsx b/bestax-migrate/src/sources/rbx/__testfixtures__/todos-unmappable.output.tsx
new file mode 100644
index 000000000..406e13fab
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__testfixtures__/todos-unmappable.output.tsx
@@ -0,0 +1,28 @@
+import React from "react";
+import { Footer } from "@allxsmith/bestax-bulma";
+// TODO(bestax-migrate): Fieldset, Generic, Highlight, List, Numeric, Tile have no bestax-bulma equivalent yet — migrate and remove this import
+import { Tile, List, Generic, Fieldset, Numeric, Highlight } from "rbx";
+
+// TODO(bestax-migrate): `Tile` — Bulma v1 replaced tiles with the Grid/Cell components — see https://bestax.io/docs/api/grid and the migration guide https://bestax.io/docs/guides/getting-started/migration/bulma-0-9-to-1
+// TODO(bestax-migrate): `List` — rbx's `List` is the bulma-list extension, which Bulma v1 does not ship; use `<UnorderedList>` or `<Menu>` (https://bestax.io/docs/api/elements/unorderedlist)
+// TODO(bestax-migrate): `List.Item` — rbx's `List.Item` is the bulma-list extension, which Bulma v1 does not ship; use `<UnorderedList.Item>` or `<Menu.Item>` (https://bestax.io/docs/api/elements/unorderedlist)
+// TODO(bestax-migrate): `Generic` — `Generic` is rbx's untyped base element; render the underlying HTML tag directly, or use a bestax component (https://bestax.io/docs/api)
+// TODO(bestax-migrate): `Fieldset` — bestax has no `Fieldset` component; render a plain <fieldset> (its `disabled` attribute works natively)
+// TODO(bestax-migrate): `Numeric` — `Numeric` (locale number formatting) has no bestax equivalent; use Intl.NumberFormat directly
+// TODO(bestax-migrate): `Highlight` — `Highlight` (syntax-highlighted <pre>) has no bestax equivalent; use `<Pre>` plus your own highlighter (https://bestax.io/docs/api/elements/pre)
+export const Unmappable = () => (
+  <Footer>
+    <Tile kind="ancestor">
+      <Tile kind="parent" vertical>
+        tile
+      </Tile>
+    </Tile>
+    <List>
+      <List.Item active>item</List.Item>
+    </List>
+    <Generic as="section">generic</Generic>
+    <Fieldset disabled>fields</Fieldset>
+    <Numeric>{1000}</Numeric>
+    <Highlight>{"const a = 1;"}</Highlight>
+  </Footer>
+);
diff --git a/bestax-migrate/src/sources/rbx/__tests__/as-doc.test.ts b/bestax-migrate/src/sources/rbx/__tests__/as-doc.test.ts
new file mode 100644
index 000000000..d939ef6cc
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__tests__/as-doc.test.ts
@@ -0,0 +1,115 @@
+/**
+ * The `as` table in the shipped prop-map is guidance an agent follows, and
+ * `as` is the prop most likely to be wrong: rbx puts it on every component,
+ * bestax declares it on a subset, and three handlers resolve their target
+ * from a prop value so the answer depends on that value.
+ *
+ * Every earlier `as` defect on this PR was "the code and the doc disagreed"
+ * or "the code was right for one handler and wrong for its siblings". So
+ * this asserts the BEHAVIOUR each documented row promises, rather than
+ * comparing two lists that can drift together.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import transform from '../transform.js';
+import { runTransform } from '../../../runner.js';
+import type { TodoEntry } from '../../../types.js';
+
+const PROP_MAP = path.join(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '../../../../../skills/bestax-migrate/references/rbx/prop-map.md'
+);
+
+function migrate(source: string) {
+  const todos: TodoEntry[] = [];
+  const { output } = runTransform(transform, 'c.tsx', source, {
+    add: e => todos.push(e),
+  });
+  return { output: output ?? source, todos };
+}
+
+/**
+ * [rbx import, JSX, `as` survives?, the bestax name the prop-map must list]
+ * The fourth field is the bestax component the doc is expected to name — not
+ * the rbx tag, and not just its leaf, because leaves like `Item` collide.
+ */
+const CASES: Array<[string, string, boolean, string?]> = [
+  // Documented as accepting `as`.
+  ['Button', '<Button as="a">x</Button>', true, 'Button'],
+  ['Title', '<Title as="h2">x</Title>', true, 'Title'],
+  ['Title', '<Title subtitle as="h3">x</Title>', true, 'SubTitle'],
+  ['Image', '<Image as="div" src="/a.png" />', true, 'Image'],
+  ['Footer', '<Footer as="div">x</Footer>', true, 'Footer'],
+  ['Media', '<Media as="div">x</Media>', true, 'Media'],
+  [
+    'Media',
+    '<Media.Item align="left" as="figure">x</Media.Item>',
+    true,
+    'Media.Left',
+  ],
+  ['Level', '<Level.Item as="a">x</Level.Item>', true, 'Level.Item'],
+  ['Control', '<Control as="div">x</Control>', true, 'Control'],
+  ['Menu', '<Menu.List.Item as="a">x</Menu.List.Item>', true, 'Menu.Item'],
+  [
+    'Dropdown',
+    '<Dropdown.Item as="button">x</Dropdown.Item>',
+    true,
+    'Dropdown.Item',
+  ],
+  ['Navbar', '<Navbar.Item as="a">x</Navbar.Item>', true, 'Navbar.Item'],
+  ['Navbar', '<Navbar.Link as="a">x</Navbar.Link>', true, 'Navbar.Link'],
+
+  // Documented as NOT accepting it — including the target-dependent cases.
+  ['Dropdown', '<Dropdown as="div">x</Dropdown>', false],
+  ['Navbar', '<Navbar as="nav">x</Navbar>', false],
+  ['Media', '<Media.Item align="right" as="div">x</Media.Item>', false],
+  ['Media', '<Media.Item align="content" as="div">x</Media.Item>', false],
+  ['Level', '<Level.Item align="left" as="a">x</Level.Item>', false],
+  ['Level', '<Level.Item align="right" as="a">x</Level.Item>', false],
+  ['Navbar', '<Navbar.Item dropdown as="div">x</Navbar.Item>', false],
+  ['Box', '<Box as="section">x</Box>', false],
+  ['Tag', '<Tag as="span">x</Tag>', false],
+];
+
+describe('the documented `as` behaviour is the actual behaviour', () => {
+  test.each(CASES)('%s %s → survives=%s', (imp, jsx, shouldSurvive) => {
+    const { output, todos } = migrate(
+      `import { ${imp} } from "rbx";\nexport const A = () => ${jsx};`
+    );
+    const code = output
+      .split('\n')
+      .filter(l => !l.trim().startsWith('// TODO(bestax-migrate)'))
+      .join('\n');
+    if (shouldSurvive) {
+      expect(code).toMatch(/\sas="/);
+      expect(todos.some(t => t.rule === 'prop:as')).toBe(false);
+    } else {
+      expect(todos.some(t => t.rule === 'prop:as')).toBe(true);
+    }
+  });
+
+  it('the prop-map names every component whose `as` survives', () => {
+    // A component that accepts `as` but is missing from the table sends an
+    // agent to "restructure the element" for a prop that would have worked.
+    const doc = fs.readFileSync(PROP_MAP, 'utf8');
+    // The header is prettier-padded, so match it loosely — an indexOf miss
+    // here would silently pass everything.
+    const start = doc.search(/^\|\s*bestax component\s*\|/m);
+    expect(start).toBeGreaterThan(-1);
+    const documented = doc.slice(start);
+    for (const [, jsx, shouldSurvive, bestaxName] of CASES) {
+      if (!shouldSurvive) continue;
+      // Match the full bestax name inside a code span: leaves like `Item`
+      // collide across Dropdown/Menu/Level/Navbar, so a substring check on
+      // the leaf alone would pass even with the whole row deleted.
+      const needle = `\`${bestaxName}\``;
+      expect({ jsx, needle, inDoc: documented.includes(needle) }).toEqual({
+        jsx,
+        needle,
+        inDoc: true,
+      });
+    }
+  });
+});
diff --git a/bestax-migrate/src/sources/rbx/__tests__/component-map-doc.test.ts b/bestax-migrate/src/sources/rbx/__tests__/component-map-doc.test.ts
new file mode 100644
index 000000000..012b235f1
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__tests__/component-map-doc.test.ts
@@ -0,0 +1,100 @@
+/**
+ * The skill's component map is a SHIPPED product surface — served through the
+ * MCP index and bundled into create-bestax — so an agent follows it as
+ * instructions. When it disagrees with `MAPPING`, it does not merely mislead:
+ * it reproduces whatever bug the code was changed to fix.
+ *
+ * That is not hypothetical. The `Loader` fix (rbx's Loader always renders,
+ * bestax's Loading returns null unless `active`) changed the code and left
+ * three doc surfaces teaching the old mapping — so following the skill
+ * recreated the silent-disappearance bug the commit had just removed.
+ *
+ * `mapping-coverage.test.ts` holds `MAPPING` to rbx's export surface. This
+ * holds the shipped table to `MAPPING`.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { MAPPING, RBX_EXPORTS, resolveMapping } from '../mapping.js';
+import type { ComponentMapping } from '../../../types.js';
+
+const DOC = path.join(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '../../../../../skills/bestax-migrate/references/rbx/component-map.md'
+);
+
+/**
+ * Prettier rewrites markdown emphasis to underscores when it formats the
+ * shipped file, so compare on a normalised form rather than the literal
+ * asterisks the generator emits.
+ */
+const norm = (cell: string): string => cell.replace(/[*_]/g, '');
+
+/** How the generated table renders one entry's target column. */
+function renderTarget(entry: ComponentMapping): string {
+  if (entry.status === 'todo') return '— *(see unmappables)*';
+  if (entry.target) return `\`${entry.target}\``;
+  return entry.special ? '*structural*' : '*namespace*';
+}
+
+/** Every dotted path the table is expected to carry, in MAPPING order. */
+function expectedRows(): Array<[string, string, string]> {
+  const rows: Array<[string, string, string]> = [];
+  const walk = (entry: ComponentMapping, dotted: string): void => {
+    rows.push([dotted, renderTarget(entry), entry.status]);
+    for (const [name, sub] of Object.entries(entry.subs ?? {})) {
+      walk(sub, `${dotted}.${name}`);
+    }
+  };
+  for (const name of Object.keys(RBX_EXPORTS).sort()) {
+    if (MAPPING[name]) walk(MAPPING[name], name);
+  }
+  return rows;
+}
+
+describe('the shipped rbx component map matches MAPPING', () => {
+  // Only the FIRST table — the later "value-chosen targets" table is also
+  // three columns and would otherwise be parsed as mapping rows.
+  const full = fs.readFileSync(DOC, 'utf8');
+  const text = full.slice(0, full.indexOf('## The renames worth memorising'));
+
+  /** Parse that table's data rows into [rbx, target, status]. */
+  const parsed = text
+    .split('\n')
+    .filter(l => /^\|\s*`[A-Za-z]/.test(l))
+    .map(l =>
+      l
+        .replace(/^\||\|$/g, '')
+        .split('|')
+        .map(c => c.trim())
+    )
+    .filter(cells => cells.length === 3)
+    .map(cells => [cells[0].replace(/`/g, ''), cells[1], cells[2]] as const);
+
+  it('lists every mapping entry, and nothing else', () => {
+    const expected = expectedRows().map(r => r[0]);
+    const actual = parsed.map(r => r[0]);
+    expect(actual).toEqual(expected);
+  });
+
+  it('renders the right target and status for each', () => {
+    const expected = expectedRows();
+    for (const [dotted, target, status] of expected) {
+      const row = parsed.find(r => r[0] === dotted);
+      expect({ dotted, row: row && norm(row[1]) }).toEqual({
+        dotted,
+        row: norm(target),
+      });
+      expect({ dotted, status: row?.[2] }).toEqual({ dotted, status });
+    }
+  });
+
+  it('never claims Loader maps to Loading', () => {
+    // The specific regression this file exists for: `Loading` renders nothing
+    // unless `active`, so teaching that rewrite makes loaders disappear.
+    const loader = parsed.find(r => r[0] === 'Loader');
+    expect(loader && norm(loader[1])).not.toContain('Loading');
+    expect(resolveMapping(['Loader'])?.special).toBe('loader');
+  });
+});
diff --git a/bestax-migrate/src/sources/rbx/__tests__/deps.test.ts b/bestax-migrate/src/sources/rbx/__tests__/deps.test.ts
new file mode 100644
index 000000000..37fce1160
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__tests__/deps.test.ts
@@ -0,0 +1,212 @@
+/**
+ * package.json updater. The behaviour worth pinning down is the guard on the
+ * four Bulma extensions: they are only removed *alongside* rbx, because an
+ * app that added `bulma-tooltip` on its own may still be using it outside rbx
+ * components.
+ */
+
+import { updateDependencies } from '../deps.js';
+import type { TodoEntry } from '../../../types.js';
+
+function run(pkg: Record<string, unknown>, bulmaReferenced = false) {
+  const todos: TodoEntry[] = [];
+  const next = updateDependencies(
+    'package.json',
+    pkg,
+    { add: e => todos.push(e) },
+    { cssMode: 'bestax', bulmaReferenced }
+  ) as Record<string, Record<string, string>> | null;
+  return { next, messages: todos.map(t => t.message) };
+}
+
+describe('rbx deps', () => {
+  it('removes rbx and bumps Bulma, but only REPORTS the extensions', () => {
+    // rbx declares the four extensions as its own dependencies, so an app
+    // gets them through the lockfile. Their presence in the app's manifest
+    // means the author declared them deliberately — possibly to import their
+    // Sass directly — so deleting them would be a best-guess rewrite.
+    const { next, messages } = run({
+      dependencies: {
+        rbx: '^2.2.0',
+        bulma: '0.7.5',
+        'bulma-badge': '^3.0.1',
+        'bulma-divider': '^0.2.0',
+        'bulma-pageloader': '^2.1.0',
+        'bulma-tooltip': '^2.0.2',
+      },
+    });
+    expect(next!.dependencies.rbx).toBeUndefined();
+    expect(next!.dependencies['@allxsmith/bestax-bulma']).toBe('^5');
+    expect(next!.dependencies.bulma).toBe('^1.0.4');
+    // Reported, still present.
+    expect(next!.dependencies['bulma-badge']).toBe('^3.0.1');
+    expect(
+      messages.some(m => /are Bulma extensions rbx depended on/.test(m))
+    ).toBe(true);
+    expect(messages.some(m => /removed rbx and bumped bulma/.test(m))).toBe(
+      true
+    );
+  });
+
+  it('says nothing about the extensions when rbx was never there', () => {
+    const { next, messages } = run({
+      dependencies: { 'bulma-tooltip': '^2.0.2', bulma: '^1.0.4' },
+    });
+    expect(next?.dependencies['bulma-tooltip']).toBe('^2.0.2');
+    expect(
+      messages.some(m => /are Bulma extensions rbx depended on/.test(m))
+    ).toBe(false);
+  });
+
+  it('adds bulma only when sources reference it directly', () => {
+    const withRef = run({ dependencies: { rbx: '^2.2.0' } }, true);
+    expect(withRef.next!.dependencies.bulma).toBe('^1.0.4');
+    const without = run({ dependencies: { rbx: '^2.2.0' } }, false);
+    expect(without.next!.dependencies.bulma).toBeUndefined();
+  });
+
+  it('reports the React 16 peer gap rbx pinned', () => {
+    const { messages } = run({
+      dependencies: { rbx: '^2.2.0', react: '^16.8.6' },
+    });
+    expect(
+      messages.some(m => /predates bestax-bulma's peer range/.test(m))
+    ).toBe(true);
+  });
+
+  it('reports a Font Awesome 5 pin', () => {
+    const { messages } = run({
+      dependencies: {
+        rbx: '^2.2.0',
+        '@fortawesome/fontawesome-free': '^5.9.0',
+      },
+    });
+    expect(messages.some(m => /legacy-peer-deps/.test(m))).toBe(true);
+  });
+
+  it('swaps node-sass for dart sass', () => {
+    const { next } = run({
+      dependencies: { rbx: '^2.2.0' },
+      devDependencies: { 'node-sass': '^4.12.0' },
+    });
+    expect(next!.devDependencies['node-sass']).toBeUndefined();
+    expect(next!.devDependencies.sass).toBe('^1.79.0');
+  });
+
+  it('returns null when there is genuinely nothing to change', () => {
+    // bestax-bulma already present and no rbx to remove.
+    const { next } = run({
+      dependencies: { '@allxsmith/bestax-bulma': '^5', react: '^19.0.0' },
+    });
+    expect(next).toBeNull();
+  });
+
+  it('adds bestax-bulma even to a manifest with no rbx left', () => {
+    const { next } = run({ dependencies: { react: '^19.0.0' } });
+    expect(next!.dependencies['@allxsmith/bestax-bulma']).toBe('^5');
+  });
+
+  it('does not re-add bestax-bulma when it is already a devDependency', () => {
+    const { next } = run({
+      dependencies: { rbx: '^2.2.0' },
+      devDependencies: { '@allxsmith/bestax-bulma': '^5' },
+    });
+    expect(next!.dependencies['@allxsmith/bestax-bulma']).toBeUndefined();
+  });
+});
+
+describe('the headline describes what actually happened to bulma', () => {
+  // The report is the tool's primary deliverable, and this line claimed a
+  // manifest pin the user would not find. In the COMMON rbx-app shape bulma
+  // is neither bumped nor added -- it arrives transitively via bestax-bulma.
+  const headline = (messages: string[]) =>
+    messages.find(m => /^removed rbx( and| —)/.test(m)) ?? '';
+
+  it('claims no bump when bulma is neither declared nor referenced', () => {
+    const { next, messages } = run({ dependencies: { rbx: '^2.2.0' } });
+    expect(next?.dependencies.bulma).toBeUndefined();
+    expect(headline(messages)).toContain('arrives transitively');
+    expect(headline(messages)).not.toContain('bumped');
+  });
+
+  it('says bumped only when a pre-1.0 range was actually raised', () => {
+    const { next, messages } = run({
+      dependencies: { rbx: '^2.2.0', bulma: '^0.9.4' },
+    });
+    expect(next?.dependencies.bulma).toBe('^1.0.4');
+    expect(headline(messages)).toContain('bumped bulma');
+  });
+
+  it('says added when bulma was absent but sources import it', () => {
+    const { next, messages } = run({ dependencies: { rbx: '^2.2.0' } }, true);
+    expect(next?.dependencies.bulma).toBe('^1.0.4');
+    expect(headline(messages)).toContain('added bulma');
+    expect(headline(messages)).not.toContain('bumped');
+  });
+
+  it('does not claim a bump when the declared range is already v1', () => {
+    const { next, messages } = run({
+      dependencies: { rbx: '^2.2.0', bulma: '^1.0.2' },
+    });
+    // Left alone: the app already chose a v1 range.
+    expect(next?.dependencies.bulma).toBe('^1.0.2');
+    expect(headline(messages)).not.toContain('bumped');
+    expect(headline(messages)).toContain('left your declared bulma range');
+  });
+});
+
+describe('pre-1.0 bulma range detection', () => {
+  // The first version matched a leading `0` and nothing else, so a range
+  // written as comparators (`>=0.7 <1`) stayed on 0.x and was then reported
+  // as already v1. Conservative on purpose: anything it cannot prove is
+  // exclusively pre-v1 is left alone.
+  it.each([
+    '^0.9.4',
+    '~0.7.5',
+    '0.7.x',
+    '>=0.7 <1',
+    '>=0.7.0 <1.0.0',
+    '<1',
+    '0.7.0 - 0.9.4',
+    '^0.9 || ^0.8',
+  ])('bumps %s', range => {
+    const { next } = run({ dependencies: { rbx: '^2.2.0', bulma: range } });
+    expect(next?.dependencies.bulma).toBe('^1.0.4');
+  });
+
+  it.each(['^1.0.2', '>=0.9 <2', '^0.9 || ^1.0', '*', '>=0.9', '<=1.0.0'])(
+    'leaves %s alone because it admits a v1',
+    range => {
+      const { next } = run({ dependencies: { rbx: '^2.2.0', bulma: range } });
+      expect(next?.dependencies.bulma).toBe(range);
+    }
+  );
+});
+
+describe('range edge cases the deep review found', () => {
+  it.each(['>= 0.7.0 < 1.0.0', '>= 0.7 <1', '< 1'])(
+    'bumps a spaced-comparator range %s',
+    range => {
+      // npm allows whitespace between operator and version; tokenising on
+      // whitespace first made `>=` a token of its own and the range fell
+      // through as unrecognised -- then was reported as already v1.
+      const { next } = run({ dependencies: { rbx: '^2.2.0', bulma: range } });
+      expect(next?.dependencies.bulma).toBe('^1.0.4');
+    }
+  );
+
+  it.each(['latest', 'github:jgthms/bulma', 'file:../bulma'])(
+    'does not call the non-semver specifier %s "already v1"',
+    spec => {
+      const { next, messages } = run({
+        dependencies: { rbx: '^2.2.0', bulma: spec },
+      });
+      expect(next?.dependencies.bulma).toBe(spec);
+      // `( and| —)` skips the earlier `removed rbx from dependencies` note.
+      const headline =
+        messages.find(m => /^removed rbx( and| —)/.test(m)) ?? '';
+      expect(headline).not.toContain('already v1');
+      expect(headline).toContain('not a version range this tool can read');
+    }
+  );
+});
diff --git a/bestax-migrate/src/sources/rbx/__tests__/mapping-coverage.test.ts b/bestax-migrate/src/sources/rbx/__tests__/mapping-coverage.test.ts
new file mode 100644
index 000000000..30b03db41
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__tests__/mapping-coverage.test.ts
@@ -0,0 +1,59 @@
+/**
+ * Coverage guard: every rbx v2 export (top-level and compound) must have a
+ * mapping entry with a valid status. Extending the supported surface is a
+ * table edit in mapping.ts; forgetting one is a test failure, never a silent
+ * skip.
+ *
+ * `RBX_EXPORTS` is vendored from rbx's five `index.ts` barrels plus the
+ * `Object.assign(…, { Sub })` tails that build its dot-notation compounds, at
+ * the SHA `scripts/validate-corpus-rbx.mjs` pins.
+ */
+
+import { MAPPING, RBX_EXPORTS, resolveMapping } from '../mapping.js';
+
+const STATUSES = ['mapped', 'partial', 'todo'];
+
+describe('rbx mapping coverage', () => {
+  const allPaths: string[][] = Object.entries(RBX_EXPORTS).flatMap(
+    ([name, subs]) => [[name], ...subs.map(sub => [name, ...sub.split('.')])]
+  );
+
+  test.each(allPaths.map(p => [p.join('.'), p] as const))(
+    '%s has a mapping entry',
+    (_label, componentPath) => {
+      const mapping = resolveMapping(componentPath);
+      expect(mapping).toBeDefined();
+      expect(STATUSES).toContain(mapping!.status);
+    }
+  );
+
+  it('maps or annotates every top-level export', () => {
+    for (const name of Object.keys(RBX_EXPORTS)) {
+      const mapping = MAPPING[name];
+      expect(mapping).toBeDefined();
+      if (mapping.status === 'todo') {
+        expect(mapping.todo).toBeTruthy();
+      } else {
+        expect(mapping.target ?? mapping.special ?? mapping.subs).toBeTruthy();
+      }
+    }
+  });
+
+  it('has no mapping entries outside the vendored rbx surface', () => {
+    for (const name of Object.keys(MAPPING)) {
+      expect(RBX_EXPORTS).toHaveProperty(name);
+    }
+  });
+
+  it('gives every `todo` sub-mapping a hint', () => {
+    const walk = (entry: (typeof MAPPING)[string], dotted: string): void => {
+      if (entry.status === 'todo') {
+        expect([dotted, entry.todo]).toEqual([dotted, expect.any(String)]);
+      }
+      for (const [name, sub] of Object.entries(entry.subs ?? {})) {
+        walk(sub, `${dotted}.${name}`);
+      }
+    };
+    for (const [name, entry] of Object.entries(MAPPING)) walk(entry, name);
+  });
+});
diff --git a/bestax-migrate/src/sources/rbx/__tests__/responsive.test.ts b/bestax-migrate/src/sources/rbx/__tests__/responsive.test.ts
new file mode 100644
index 000000000..b92840453
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__tests__/responsive.test.ts
@@ -0,0 +1,202 @@
+/**
+ * Breakpoint-flattening coverage: the shapes a fixture can show once, but
+ * whose failure paths need one case each. rbx has three breakpoint shapes and
+ * every one of them can be handed something the codemod must refuse to guess
+ * at rather than silently mangle.
+ */
+
+import transform from '../transform.js';
+import { runTransform } from '../../../runner.js';
+import type { TodoEntry } from '../../../types.js';
+
+function migrate(source: string) {
+  const todos: TodoEntry[] = [];
+  const { output } = runTransform(transform, 'case.tsx', source, {
+    add: entry => todos.push(entry),
+  });
+  return { output: output ?? '', todos, rules: todos.map(t => t.rule) };
+}
+
+const box = (attrs: string) =>
+  `import { Box } from 'rbx';\nexport const A = (p: Record<string, unknown>) => <Box ${attrs}>x</Box>;`;
+const column = (attrs: string) =>
+  `import { Column } from 'rbx';\nexport const A = (p: Record<string, unknown>) => <Column ${attrs}>x</Column>;`;
+const group = (attrs: string) =>
+  `import { Column } from 'rbx';\nexport const A = (p: Record<string, unknown>) => <Column.Group ${attrs}>x</Column.Group>;`;
+
+describe('the universal `responsive` helper prop', () => {
+  it('flattens every helper it knows', () => {
+    const { output } = migrate(
+      box(
+        'responsive={{ mobile: { hide: { value: true } }, tablet: { display: { value: "flex" }, textSize: { value: 3 }, textAlign: { value: "centered" } } }}'
+      )
+    );
+    expect(output).toContain('visibilityMobile="hidden"');
+    expect(output).toContain('displayTablet="flex"');
+    expect(output).toContain('textSizeTablet="3"');
+    expect(output).toContain('textAlignTablet="centered"');
+  });
+
+  it('always removes the prop — bestax has its own unrelated `responsive`', () => {
+    const { output } = migrate(
+      box(
+        'responsive={{ desktop: { display: { value: "block", only: true } } }}'
+      )
+    );
+    expect(output).not.toContain('responsive=');
+  });
+
+  it('drops a `hide: { value: false }` as the no-op it is', () => {
+    const { output, todos } = migrate(
+      box('responsive={{ mobile: { hide: { value: false } } }}')
+    );
+    expect(output).not.toContain('visibilityMobile');
+    expect(todos).toHaveLength(0);
+  });
+
+  it('TODOs the touch breakpoint, which bestax has no viewport for', () => {
+    const { rules } = migrate(
+      box('responsive={{ touch: { hide: { value: true } } }}')
+    );
+    expect(rules).toContain('responsive');
+  });
+
+  it('TODOs a breakpoint bestax does not know', () => {
+    const { todos } = migrate(
+      box('responsive={{ nope: { hide: { value: true } } }}')
+    );
+    expect(todos.some(t => /is not a breakpoint/.test(t.message))).toBe(true);
+  });
+
+  it('TODOs a non-object responsive value', () => {
+    const { todos } = migrate(box('responsive={p.r as never}'));
+    expect(
+      todos.some(t => /must be an inline object literal/.test(t.message))
+    ).toBe(true);
+  });
+
+  it('TODOs a non-object breakpoint value', () => {
+    const { todos } = migrate(box('responsive={{ tablet: p.t as never }}'));
+    expect(
+      todos.some(t =>
+        /responsive\.tablet` must be an inline object/.test(t.message)
+      )
+    ).toBe(true);
+  });
+
+  it('TODOs a cell that is not the { value } shape', () => {
+    const { todos } = migrate(box('responsive={{ tablet: { display: 5 } }}'));
+    expect(todos.some(t => /the `\{ value \}` shape/.test(t.message))).toBe(
+      true
+    );
+  });
+
+  it('TODOs an unknown helper inside a breakpoint', () => {
+    const { todos } = migrate(
+      box('responsive={{ tablet: { nope: { value: 1 } } }}')
+    );
+    expect(todos.some(t => /could not be flattened/.test(t.message))).toBe(
+      true
+    );
+  });
+
+  it.each([
+    [
+      'display',
+      'responsive={{ tablet: { display: { value: p.d as never } } }}',
+    ],
+    [
+      'textAlign',
+      'responsive={{ tablet: { textAlign: { value: p.a as never } } }}',
+    ],
+    [
+      'textSize',
+      'responsive={{ tablet: { textSize: { value: p.s as never } } }}',
+    ],
+    ['hide', 'responsive={{ tablet: { hide: { value: p.h as never } } }}'],
+  ])('TODOs a dynamic %s value', (_name, attrs) => {
+    const { todos } = migrate(box(attrs));
+    expect(todos.some(t => /dynamic value/.test(t.message))).toBe(true);
+  });
+
+  it('names the breakpoints that could not carry when it drops the prop', () => {
+    const { todos } = migrate(
+      box('responsive={{ tablet: { nope: { value: 1 } } }}')
+    );
+    expect(
+      todos.some(t =>
+        /dropped the `responsive` prop; the `tablet`/.test(t.message)
+      )
+    ).toBe(true);
+  });
+});
+
+describe('Column and Column.Group breakpoint props', () => {
+  it('flattens Column sizing', () => {
+    const { output } = migrate(
+      column('tablet={{ size: 6, offset: 1, narrow: true }}')
+    );
+    expect(output).toContain('sizeTablet={6}');
+    expect(output).toContain('offsetTablet={1}');
+    expect(output).toContain('isNarrowTablet');
+  });
+
+  it('emits a bare string for a named column size', () => {
+    const { output } = migrate(column('desktop={{ size: "one-third" }}'));
+    expect(output).toContain('sizeDesktop="one-third"');
+    expect(output).not.toContain('sizeDesktop={"one-third"}');
+  });
+
+  it('drops a falsy narrow', () => {
+    const { output } = migrate(column('tablet={{ narrow: false }}'));
+    expect(output).not.toContain('isNarrowTablet');
+  });
+
+  it('drops a dynamic narrow, naming it', () => {
+    const { output, todos } = migrate(
+      column('tablet={{ narrow: p.n as never }}')
+    );
+    expect(output).not.toContain('tablet={{');
+    expect(todos.some(t => /narrow \(dynamic value\)/.test(t.message))).toBe(
+      true
+    );
+  });
+
+  it('drops a touch size, which bestax has no column variant for', () => {
+    const { output, todos } = migrate(column('touch={{ size: 12 }}'));
+    expect(output).not.toContain('touch=');
+    // bestax has `isNarrowTouch` but no `sizeTouch`, so the key is named
+    // rather than the whole breakpoint being written off.
+    expect(todos.some(t => /dropped `touch\.size`/.test(t.message))).toBe(true);
+  });
+
+  it('drops a non-object breakpoint on a Column', () => {
+    const { output, todos } = migrate(column('tablet={p.t as never}'));
+    expect(output).not.toContain('tablet=');
+    expect(
+      todos.some(t => /must be an inline object literal/.test(t.message))
+    ).toBe(true);
+  });
+
+  it('drops a key it cannot flatten on a Column, naming it', () => {
+    const { output, todos } = migrate(column('tablet={{ nope: 1 }}'));
+    expect(output).not.toContain('tablet={{');
+    expect(todos.some(t => /dropped `tablet\.nope`/.test(t.message))).toBe(
+      true
+    );
+  });
+
+  it('maps Column.Group gapSize onto bestax gap', () => {
+    const { output } = migrate(group('tablet={{ gapSize: 2 }} gapSize={4}'));
+    expect(output).toContain('gapTablet={2}');
+    expect(output).toContain('gap={4}');
+  });
+
+  it('drops a key it cannot flatten on a Column.Group, naming it', () => {
+    const { output, todos } = migrate(group('tablet={{ nope: 1 }}'));
+    expect(output).not.toContain('tablet={{');
+    expect(todos.some(t => /dropped `tablet\.nope`/.test(t.message))).toBe(
+      true
+    );
+  });
+});
diff --git a/bestax-migrate/src/sources/rbx/__tests__/review-fixes.test.ts b/bestax-migrate/src/sources/rbx/__tests__/review-fixes.test.ts
new file mode 100644
index 000000000..5c57afe7a
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__tests__/review-fixes.test.ts
@@ -0,0 +1,1208 @@
+/**
+ * Regression tests for the seven defects a high-effort code review found
+ * after the first pass. Each one was reachable from ordinary rbx input and
+ * produced either a silent build break or an unknown DOM attribute, so each
+ * gets a test that fails if the behaviour comes back.
+ */
+
+import transform from '../transform.js';
+import { rbx } from '../index.js';
+import { runTransform } from '../../../runner.js';
+import type { TodoEntry } from '../../../types.js';
+
+function migrate(source: string) {
+  const todos: TodoEntry[] = [];
+  const { output } = runTransform(transform, 'c.tsx', source, {
+    add: entry => todos.push(entry),
+  });
+  return { output: output ?? source, todos };
+}
+
+/** Output with `// TODO(bestax-migrate): …` lines removed. */
+function codeOf(output: string): string {
+  return output
+    .split('\n')
+    .filter(l => !l.trim().startsWith('// TODO(bestax-migrate)'))
+    .join('\n');
+}
+
+function migrateScss(source: string) {
+  const todos: TodoEntry[] = [];
+  const output = rbx.transformStyles!(
+    's.scss',
+    source,
+    { add: entry => todos.push(entry) },
+    { cssMode: 'bestax' }
+  );
+  return { output, todos };
+}
+
+describe('stylesheets that never mention Bulma by name', () => {
+  it('still migrates a sass entry that only imports rbx', () => {
+    // rbx pulls Bulma in itself, so `@import '~rbx/rbx'` — the spelling rbx's
+    // own customisation guide teaches — contains no "bulma" substring. The
+    // pre-filter used to bail here, leaving a dead import while deps.ts
+    // removed the package in the same run.
+    const { output, todos } = migrateScss(
+      '$primary: #00d8ff;\n@import "~rbx/rbx";\n.app { color: red; }\n'
+    );
+    expect(output).not.toBeNull();
+    expect(output).toContain("@use 'bulma/sass'");
+    expect(output).not.toContain('~rbx/rbx');
+    expect(todos.length).toBeGreaterThan(0);
+  });
+
+  it('matches the bare package specifier, not only `<pkg>/…`', () => {
+    const { output } = migrateScss(
+      '@import "~rbx";\n@import "~bulma/bulma";\n'
+    );
+    expect(output).not.toContain('~rbx');
+    expect(output).toContain("@use 'bulma/sass'");
+  });
+});
+
+describe('column breakpoint objects are always consumed', () => {
+  it('removes a breakpoint bestax cannot express at all', () => {
+    // ColumnProps spreads unrecognised props onto the <div>, so a leftover is
+    // both a TS excess-property error and a React unknown-attribute warning.
+    const { output, todos } = migrate(
+      'import { Column } from "rbx";\nexport const A = () => <Column touch={{ size: 6 }} />;'
+    );
+    expect(output).not.toContain('touch=');
+    expect(todos.some(t => t.rule === 'responsive')).toBe(true);
+  });
+
+  it('removes the object even when only some keys converted', () => {
+    const { output, todos } = migrate(
+      'import { Column } from "rbx";\nexport const A = () => <Column tablet={{ size: 6, foo: 1 }} />;'
+    );
+    expect(output).toContain('sizeTablet={6}');
+    expect(output).not.toContain('tablet={{');
+    expect(todos.some(t => /foo/.test(t.message))).toBe(true);
+  });
+
+  it('converts touch narrow, which bestax does support on Column', () => {
+    // `isNarrowTouch` exists on Column even though bestax has no `touch`
+    // viewport for the generic helper props — one shared table cannot give
+    // both consumers the right answer.
+    const { output, todos } = migrate(
+      'import { Column } from "rbx";\nexport const A = () => <Column touch={{ narrow: true }} />;'
+    );
+    expect(output).toContain('isNarrowTouch');
+    expect(todos).toHaveLength(0);
+  });
+});
+
+describe('namespace imports', () => {
+  it('keeps `import * as rbx` alive when a component is retained', () => {
+    // resolveJsxPath supports namespace imports, so `<rbx.Tile>` survives the
+    // run unconverted — pruning the import left `rbx is not defined`.
+    const { output } = migrate(
+      'import * as rbx from "rbx";\nexport const A = () => <rbx.Tile><rbx.Button>x</rbx.Button></rbx.Tile>;'
+    );
+    expect(output).toContain('import * as rbx from "rbx"');
+    expect(output).toContain('<rbx.Tile>');
+    expect(output).toContain('<Button>x</Button>');
+  });
+
+  it('still prunes the namespace import when nothing is retained', () => {
+    const { output } = migrate(
+      'import * as rbx from "rbx";\nexport const A = () => <rbx.Box>x</rbx.Box>;'
+    );
+    expect(output).not.toContain('from "rbx"');
+    expect(output).toContain('<Box>x</Box>');
+  });
+});
+
+describe('retained extension stylesheets are flagged in the file', () => {
+  it('leaves the import in place with a TODO on it, not only a report entry', () => {
+    const { output, todos } = migrate(
+      'import "bulma-tooltip/dist/css/bulma-tooltip.min.css";\nimport { Box } from "rbx";\nexport const A = () => <Box />;'
+    );
+    expect(output).toContain('TODO(bestax-migrate)');
+    expect(output).toContain(
+      'import "bulma-tooltip/dist/css/bulma-tooltip.min.css";'
+    );
+    expect(todos.some(t => t.rule === 'css')).toBe(true);
+  });
+});
+
+describe('badge/tooltip props on plain-element rewrites', () => {
+  it.each([
+    ['Heading', '<Heading tooltip="hi">x</Heading>'],
+    ['Help', '<Help badge="3">x</Help>'],
+  ])(
+    'strips them from a replaced %s instead of emitting a DOM attribute',
+    (name, jsx) => {
+      // The wrapping pass runs after the rename step, which a `replaced: true`
+      // special skips entirely.
+      const { output, todos } = migrate(
+        `import { ${name} } from "rbx";\nexport const A = () => ${jsx};`
+      );
+      expect(output).not.toMatch(/\s(tooltip|badge)=/);
+      expect(todos.some(t => t.rule === 'plain-element')).toBe(true);
+    }
+  );
+});
+
+// ---------------------------------------------------------------------------
+// Round 2: findings from Copilot and the Claude deep review on PR #613.
+// ---------------------------------------------------------------------------
+
+describe('`as` is opted in only where bestax really declares it', () => {
+  it.each([
+    ['Dropdown', '<Dropdown as="div">x</Dropdown>'],
+    ['Navbar', '<Navbar as="nav">x</Navbar>'],
+  ])('TODOs `as` on the %s root, which has no such prop', (name, jsx) => {
+    const { output, todos } = migrate(
+      `import { ${name} } from "rbx";\nexport const A = () => ${jsx};`
+    );
+    expect(todos.some(t => t.rule === 'prop:as')).toBe(true);
+    // A `todo` PropAction deliberately leaves the attribute next to its
+    // comment rather than silently dropping it; the TODO is the contract.
+    expect(output).toContain('TODO(bestax-migrate)');
+    expect(todos.find(t => t.rule === 'prop:as')?.message).toMatch(
+      /not one of them/
+    );
+  });
+
+  it.each([
+    ['Dropdown', '<Dropdown.Item as="button">x</Dropdown.Item>', 'as="button"'],
+    ['Navbar', '<Navbar.Link as="a">x</Navbar.Link>', 'as="a"'],
+  ])(
+    'passes `as` through on %s sub-components that accept it',
+    (name, jsx, expected) => {
+      const { output, todos } = migrate(
+        `import { ${name} } from "rbx";\nexport const A = () => ${jsx};`
+      );
+      expect(output).toContain(expected);
+      expect(todos.some(t => t.rule === 'prop:as')).toBe(false);
+    }
+  );
+
+  it('keeps `as` on Media.Left but drops it on Content/Right', () => {
+    // Media.Item resolves to a different bestax component per `align`, and
+    // only MediaLeftProps declares `as`.
+    const left = migrate(
+      'import { Media } from "rbx";\nexport const A = () => <Media.Item align="left" as="figure">x</Media.Item>;'
+    );
+    expect(left.output).toContain('<Media.Left as="figure">');
+    expect(left.todos).toHaveLength(0);
+
+    for (const align of ['right', 'content']) {
+      const other = migrate(
+        `import { Media } from "rbx";\nexport const A = () => <Media.Item align="${align}" as="div">x</Media.Item>;`
+      );
+      expect(other.output).not.toMatch(/\sas="/);
+      expect(other.todos.some(t => t.rule === 'prop:as')).toBe(true);
+    }
+  });
+});
+
+describe('a dynamic `only` is not `false`', () => {
+  it('refuses the cell instead of dropping the -only behaviour', () => {
+    const { output, todos } = migrate(
+      'import { Box } from "rbx";\nexport const A = (p: any) => <Box responsive={{ tablet: { display: { value: "flex", only: p.c } } }}>x</Box>;'
+    );
+    expect(output).not.toContain('displayTablet');
+    expect(todos.some(t => /\.only` has a dynamic value/.test(t.message))).toBe(
+      true
+    );
+  });
+});
+
+describe('a broken default import is kept, not stranded', () => {
+  it('retains the binding its references still need', () => {
+    // rbx has no default export, so the binding is already wrong — but
+    // deleting it turns a bad import into `RBX is not defined`.
+    const { output, todos } = migrate(
+      'import RBX, { Box } from "rbx";\nexport const A = () => <Box>{String(RBX)}</Box>;'
+    );
+    expect(output).toContain('import RBX from "rbx"');
+    expect(output).toContain('from "@allxsmith/bestax-bulma"');
+    expect(todos.some(t => t.rule === 'imports')).toBe(true);
+    // …and no empty "  have no bestax-bulma equivalent" comment.
+    expect(output).not.toMatch(/\):\s+have no bestax-bulma/);
+  });
+});
+
+describe('Navbar.Item still cleans up after picking a target', () => {
+  it('flags `up` even when `dropdown` selects Navbar.Dropdown', () => {
+    const { output, todos } = migrate(
+      'import { Navbar } from "rbx";\nexport const A = () => <Navbar.Item dropdown up>x</Navbar.Item>;'
+    );
+    // `up` and `hoverable` exist on bestax's NavbarDropdownProps, so they
+    // carry over; only the props with no home are flagged.
+    expect(output).toContain('<Navbar.Dropdown up>');
+    expect(todos.some(t => t.rule === 'prop:up')).toBe(false);
+  });
+});
+
+describe('Label `disabled` resolves by value', () => {
+  it('drops a literal false rather than baking in is-disabled', () => {
+    const { output } = migrate(
+      'import { Label } from "rbx";\nexport const A = () => <Label disabled={false}>x</Label>;'
+    );
+    expect(output).toContain('className="label"');
+    expect(output).not.toContain('is-disabled');
+  });
+
+  it('TODOs a dynamic value rather than forcing it true', () => {
+    const { output, todos } = migrate(
+      'import { Label } from "rbx";\nexport const A = (p: any) => <Label disabled={p.d}>x</Label>;'
+    );
+    expect(codeOf(output)).not.toContain('is-disabled');
+    expect(todos.some(t => t.rule === 'prop:disabled')).toBe(true);
+  });
+});
+
+describe('Breadcrumb.Item builds its anchor by hand', () => {
+  it('still strips badge/tooltip helper props from it', () => {
+    const { output, todos } = migrate(
+      'import { Breadcrumb } from "rbx";\nexport const A = () => <Breadcrumb.Item tooltip="Home" href="/">H</Breadcrumb.Item>;'
+    );
+    expect(output).toContain('<li><a href="/">H</a></li>');
+    expect(codeOf(output)).not.toContain('tooltip');
+    expect(todos.some(t => t.rule === 'plain-element')).toBe(true);
+  });
+});
+
+describe('Field multiline follows rbx runtime semantics', () => {
+  it('ignores multiline with kind="addons", as rbx does', () => {
+    // rbx: `[`${k}-multiline`]: k === "is-grouped" && multiline === true`
+    const { output } = migrate(
+      'import { Field } from "rbx";\nexport const A = () => <Field kind="addons" multiline>x</Field>;'
+    );
+    expect(output).toContain('hasAddons');
+    expect(output).not.toContain('multiline');
+  });
+
+  it('still folds multiline into grouped with kind="group"', () => {
+    const { output } = migrate(
+      'import { Field } from "rbx";\nexport const A = () => <Field kind="group" multiline>x</Field>;'
+    );
+    expect(output).toContain('grouped="multiline"');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Round 3: Copilot's second pass on PR #613.
+// ---------------------------------------------------------------------------
+
+describe('rbx Loader keeps rendering', () => {
+  it('emits the plain .loader element, not an inactive Loading', () => {
+    // rbx's Loader always renders `div.loader`. bestax's Loading is a
+    // different component — an overlay that defaults `active` to false and
+    // returns null — so mapping straight onto it made every migrated loader
+    // disappear with no diagnostic at all.
+    const { output } = migrate(
+      'import { Loader } from "rbx";\nexport const A = () => <Loader />;'
+    );
+    expect(output).toContain('className="loader"');
+    expect(output).not.toContain('Loading');
+  });
+
+  it('still maps PageLoader onto Loading, which is an overlay', () => {
+    const { output } = migrate(
+      'import { PageLoader } from "rbx";\nexport const A = () => <PageLoader active />;'
+    );
+    expect(output).toContain('<Loading active isFullPage />');
+  });
+});
+
+describe('an existing namespace import of bestax-bulma', () => {
+  it('gets a separate declaration rather than an invalid merge', () => {
+    // `import * as X, { Y } from '…'` is not valid JavaScript: a namespace
+    // specifier cannot share a declaration with named ones.
+    const { output } = migrate(
+      'import * as Bestax from "@allxsmith/bestax-bulma";\nimport { Button } from "rbx";\nexport const A = () => <div>{String(Bestax)}<Button>x</Button></div>;'
+    );
+    expect(output).not.toMatch(/import \* as \w+, \{/);
+    expect(output).toContain(
+      'import * as Bestax from "@allxsmith/bestax-bulma"'
+    );
+    expect(output).toContain(
+      'import { Button } from "@allxsmith/bestax-bulma"'
+    );
+  });
+
+  it('still merges into an existing NAMED bestax import', () => {
+    const { output } = migrate(
+      'import { Box } from "@allxsmith/bestax-bulma";\nimport { Button } from "rbx";\nexport const A = () => <Box><Button>x</Button></Box>;'
+    );
+    // recast preserves the existing declaration's quote style.
+    expect(output).toMatch(
+      /import \{ Box, Button \} from ["']@allxsmith\/bestax-bulma["']/
+    );
+  });
+});
+
+describe('a non-literal `responsive` value', () => {
+  it('is removed, not merely reported', () => {
+    // bestax's own `responsive` is `'mobile' | 'narrow'`, so leaving a
+    // dynamic rbx object behind is a guaranteed type error.
+    const { output, todos } = migrate(
+      'import { Box } from "rbx";\nexport const A = (p: any) => <Box responsive={p.layout}>x</Box>;'
+    );
+    expect(codeOf(output)).not.toContain('responsive=');
+    expect(todos.some(t => t.rule === 'responsive')).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Round 4: CodeRabbit's first pass and the deep review's second.
+// ---------------------------------------------------------------------------
+
+describe('Font Awesome modifier classes are not read as the icon name', () => {
+  it.each([
+    ['fas fa-rotate-90 fa-home', 'home'],
+    ['fas fa-flip-horizontal fa-star', 'star'],
+    ['fas fa-lg fa-spin fa-cog', 'cog'],
+    ['far fa-border fa-bell', 'bell'],
+  ])('%s → name="%s"', (className, expected) => {
+    // Class order is not guaranteed, so the modifier filter has to be
+    // exhaustive rather than positional.
+    const { output } = migrate(
+      `import { Icon } from "rbx";\nexport const A = () => (<Icon><i className="${className}" /></Icon>);`
+    );
+    expect(output).toContain(`name="${expected}"`);
+  });
+
+  it('keeps fa-rotate-left, which is an icon and not a modifier', () => {
+    const { output } = migrate(
+      'import { Icon } from "rbx";\nexport const A = () => (<Icon><i className="fas fa-rotate-left" /></Icon>);'
+    );
+    expect(output).toContain('name="rotate-left"');
+  });
+});
+
+describe('Field multiline without a kind', () => {
+  it('renders plain, because rbx applies multiline only to kind="group"', () => {
+    // rbx: `[`${k}-multiline`]: k === "is-grouped" && multiline === true`.
+    // With no `kind`, `k` is undefined and multiline is a no-op — treating it
+    // as group turned a plain block field into a grouped flex row.
+    const { output } = migrate(
+      'import { Field } from "rbx";\nexport const A = () => <Field multiline>x</Field>;'
+    );
+    expect(codeOf(output)).not.toContain('grouped');
+    expect(codeOf(output)).not.toContain('multiline');
+  });
+
+  it('TODOs a dynamic kind rather than deciding for it', () => {
+    const { todos } = migrate(
+      'import { Field } from "rbx";\nexport const A = (p: any) => <Field kind={p.k} multiline>x</Field>;'
+    );
+    expect(todos.some(t => t.rule === 'prop:multiline')).toBe(true);
+  });
+});
+
+describe('badge/tooltip wrapping and React keys', () => {
+  it('moves `key` to the wrapper, which is now the array member', () => {
+    // Left on the inner element, React sees a keyless child: a console
+    // warning plus index reconciliation that mis-reuses DOM on reorder.
+    const { output } = migrate(
+      'import { Button } from "rbx";\nexport const A = (items: any[]) => <>{items.map(i => <Button key={i.id} badge={i.n}>x</Button>)}</>;'
+    );
+    expect(output).toMatch(/<Badge key=\{i\.id\}/);
+    expect(output).not.toMatch(/<Button key=/);
+  });
+
+  it('moves `key` to the outermost wrapper when both badge and tooltip apply', () => {
+    const { output } = migrate(
+      'import { Button } from "rbx";\nexport const A = (items: any[]) => <>{items.map(i => <Button key={i.id} badge={i.n} tooltip="t">x</Button>)}</>;'
+    );
+    expect(output).toMatch(/<Tooltip key=\{i\.id\}/);
+    expect(output).not.toMatch(/<Badge key=/);
+    expect(output).not.toMatch(/<Button key=/);
+  });
+});
+
+describe('a namespace binding still used as a value', () => {
+  it('survives when the namespace itself is referenced', () => {
+    // JSX names like <rbx.Box> are rewritten away, but a bare reference to
+    // the namespace is not — and pruning the import under one leaves
+    // `rbx is not defined`. Reachable even when every component maps.
+    const { output } = migrate(
+      'import * as rbx from "rbx";\nexport const A = () => <rbx.Box>{String(rbx)}</rbx.Box>;'
+    );
+    expect(output).toContain('import * as rbx from "rbx"');
+    expect(output).toContain('<Box');
+  });
+
+  it('is pruned once its member references are migrated', () => {
+    // `rbx.Block` is a mappable component, so it becomes `Block` and the
+    // namespace has nothing left to bind — retaining it here would leave a
+    // dead import of a package deps.ts removes.
+    const { output } = migrate(
+      'import * as rbx from "rbx";\nexport const A = () => <rbx.Box as={rbx.Block}>x</rbx.Box>;'
+    );
+    expect(output).toContain('as={Block}');
+    expect(output).not.toContain('from "rbx"');
+  });
+
+  it('is still pruned when nothing references it', () => {
+    const { output } = migrate(
+      'import * as rbx from "rbx";\nexport const A = () => <rbx.Box>x</rbx.Box>;'
+    );
+    expect(output).not.toContain('from "rbx"');
+  });
+});
+
+describe('value references walk the whole member chain', () => {
+  it('rewrites Card.Footer.Item to bestax Card.FooterItem', () => {
+    // Resolving only the first level treated `Card.Footer` as unchanged and
+    // left `.Item` dangling on a compound bestax does not have.
+    const { output, todos } = migrate(
+      'import { Card } from "rbx";\nconst X = Card.Footer.Item;\nexport const A = () => <X>x</X>;'
+    );
+    expect(output).toContain('const X = Card.FooterItem;');
+    expect(output).not.toContain('from "rbx"');
+    expect(todos).toHaveLength(0);
+  });
+});
+
+describe('a retained rbx binding never loses its name to a bestax import', () => {
+  it('aliases the bestax local instead of dropping the retained specifier', () => {
+    // `Tile as Button` is unmappable and retained; another rbx component
+    // wants bestax's `Button`. Dropping the retained specifier made
+    // `<Button>` — which was a Tile — silently render a bestax Button.
+    const { output } = migrate(
+      'import { Tile as Button, Button as RealButton } from "rbx";\nexport const A = () => <><Button>tile</Button><RealButton>btn</RealButton></>;'
+    );
+    expect(output).toContain('import { Tile as Button } from "rbx"');
+    expect(output).toMatch(/Button as Bulma\w+/);
+    // The Tile usage still points at the retained rbx binding.
+    expect(output).toContain('<Button>tile</Button>');
+  });
+});
+
+describe('removing the source package while imports remain', () => {
+  it('warns rather than silently stranding the retained imports', async () => {
+    const { rbx } = await import('../index.js');
+    const todos: TodoEntry[] = [];
+    rbx.updateDependencies!(
+      'package.json',
+      { dependencies: { rbx: '^2.2.0' } },
+      { add: e => todos.push(e) },
+      { cssMode: 'bestax', sourceStillImported: true }
+    );
+    expect(
+      todos.some(t =>
+        /still import it for components with no bestax/.test(t.message)
+      )
+    ).toBe(true);
+  });
+
+  it('stays quiet when nothing still imports it', async () => {
+    const { rbx } = await import('../index.js');
+    const todos: TodoEntry[] = [];
+    rbx.updateDependencies!(
+      'package.json',
+      { dependencies: { rbx: '^2.2.0' } },
+      { add: e => todos.push(e) },
+      { cssMode: 'bestax', sourceStillImported: false }
+    );
+    expect(todos.some(t => /still import it/.test(t.message))).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Round 4: Copilot's third pass — target-dependent `as`, and the Navbar
+// dropdown container/menu distinction.
+// ---------------------------------------------------------------------------
+
+describe('rbx Navbar.Dropdown is the MENU, not the container', () => {
+  it('maps it to Navbar.DropdownMenu inside the Item-derived container', () => {
+    // bestax `Navbar.Dropdown` renders `navbar-item has-dropdown` (the outer
+    // container, which rbx's `<Navbar.Item dropdown>` becomes);
+    // `Navbar.DropdownMenu` renders `navbar-dropdown` (the menu, which rbx
+    // calls Navbar.Dropdown). Targeting the wrong one nested two containers
+    // and emitted no menu at all.
+    const { output } = migrate(
+      [
+        'import { Navbar } from "rbx";',
+        'export const A = () => (',
+        '  <Navbar.Item dropdown><Navbar.Link>M</Navbar.Link>',
+        '    <Navbar.Dropdown align="right"><Navbar.Item>one</Navbar.Item></Navbar.Dropdown>',
+        '  </Navbar.Item>);',
+      ].join('\n')
+    );
+    expect(output).toContain('<Navbar.Dropdown>');
+    expect(output).toContain('<Navbar.DropdownMenu right>');
+  });
+
+  it('TODOs `boxed`, which bestax has no prop for', () => {
+    const { todos } = migrate(
+      'import { Navbar } from "rbx";\nexport const A = () => <Navbar.Dropdown boxed>x</Navbar.Dropdown>;'
+    );
+    expect(todos.some(t => t.rule === 'prop:boxed')).toBe(true);
+  });
+});
+
+describe('`as` is checked against the target a handler actually picked', () => {
+  it.each([
+    ['Level', '<Level.Item align="left" as="a">x</Level.Item>', 'Level.Left'],
+    [
+      'Navbar',
+      '<Navbar.Item dropdown as="div">x</Navbar.Item>',
+      'Navbar.Dropdown',
+    ],
+    [
+      'Media',
+      '<Media.Item align="right" as="div">x</Media.Item>',
+      'Media.Right',
+    ],
+  ])('drops `as` when %s resolves to %s', (name, jsx, expectedTarget) => {
+    const { output, todos } = migrate(
+      `import { ${name} } from "rbx";\nexport const A = () => ${jsx};`
+    );
+    expect(output).toContain(`<${expectedTarget}`);
+    expect(codeOf(output)).not.toMatch(/\sas="/);
+    expect(todos.some(t => t.rule === 'prop:as')).toBe(true);
+  });
+
+  it.each([
+    ['Level', '<Level.Item as="a">x</Level.Item>'],
+    ['Navbar', '<Navbar.Item as="a">x</Navbar.Item>'],
+    ['Media', '<Media.Item align="left" as="figure">x</Media.Item>'],
+  ])(
+    'keeps `as` when %s resolves to a target that declares it',
+    (name, jsx) => {
+      const { output, todos } = migrate(
+        `import { ${name} } from "rbx";\nexport const A = () => ${jsx};`
+      );
+      expect(output).toMatch(/\sas="/);
+      expect(todos.some(t => t.rule === 'prop:as')).toBe(false);
+    }
+  );
+});
+
+describe('shorthand object properties are keys as well as references', () => {
+  it('expands rather than rewriting the public key', () => {
+    // `{ Textarea }` is `{ Textarea: <component> }`. Renaming in place
+    // changed the object's own key to `TextArea`, silently altering the API
+    // its callers use.
+    const { output } = migrate(
+      'import { Textarea } from "rbx";\nexport const registry = { Textarea };'
+    );
+    expect(output).toContain('{ Textarea: TextArea }');
+  });
+
+  it('leaves a shorthand alone when the name does not change', () => {
+    const { output } = migrate(
+      'import { Box } from "rbx";\nexport const registry = { Box };'
+    );
+    expect(output).toContain('{ Box }');
+  });
+
+  it('flags an unmappable component in shorthand rather than renaming it', () => {
+    const { output, todos } = migrate(
+      'import { Tile } from "rbx";\nexport const registry = { Tile };'
+    );
+    expect(output).toContain('{ Tile }');
+    expect(todos.some(t => t.rule === 'value-reference')).toBe(true);
+  });
+
+  it('does not touch a non-shorthand key that happens to match', () => {
+    const { output } = migrate(
+      'import { Textarea } from "rbx";\nexport const registry = { Textarea: Textarea };'
+    );
+    // The key stays; only the value reference migrates.
+    expect(output).toContain('Textarea: TextArea');
+  });
+});
+
+describe('the universal `responsive` prop on a plain-element rewrite', () => {
+  it.each([
+    [
+      'Heading',
+      '<Heading responsive={{ tablet: { hide: { value: true } } }}>x</Heading>',
+    ],
+    [
+      'Help',
+      '<Help responsive={{ mobile: { hide: { value: true } } }}>x</Help>',
+    ],
+  ])('is stripped from a replaced %s', (name, jsx) => {
+    // responsive.ts would have consumed it, but a `replaced: true` special
+    // skips that pass, and it is deliberately absent from UNIVERSAL_PROPS so
+    // stripModifierProps misses it too. Left behind it is an object literal
+    // on an intrinsic element — which does not compile.
+    const { output, todos } = migrate(
+      `import { ${name} } from "rbx";\nexport const A = () => ${jsx};`
+    );
+    expect(codeOf(output)).not.toContain('responsive=');
+    expect(todos.some(t => t.rule === 'plain-element')).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Round 6: CodeRabbit's first complete pass, and Copilot's fourth.
+// ---------------------------------------------------------------------------
+
+describe('containers collapse only onto the component they wrap', () => {
+  it('keeps the Image wrapper around a non-Image child', () => {
+    // rbx's Image.Container is also the ratio box for arbitrary children.
+    // Folding onto an <iframe> put `size` on an intrinsic element and lost
+    // the container the markup needs.
+    const { output } = migrate(
+      'import { Image } from "rbx";\nexport const A = () => <Image.Container size="16by9"><iframe src="/v" /></Image.Container>;'
+    );
+    expect(output).toContain('<Image size="16by9">');
+    expect(output).toContain('<iframe src="/v" />');
+  });
+
+  it('folds a native select INTO the bestax Select', () => {
+    // rbx allows Select.Container to wrap a native <select>, but bestax's
+    // Select renders its own — keeping both nested one inside the other, so
+    // the native element's attributes and options move up instead.
+    const { output } = migrate(
+      'import { Select } from "rbx";\nexport const A = () => <Select.Container fullwidth><select name="x"><option>a</option></select></Select.Container>;'
+    );
+    expect(output).toContain('<Select isFullwidth name="x">');
+    expect(output).toContain('<option>a</option>');
+    expect(output).not.toMatch(/<select[\s>]/);
+  });
+
+  it('still collapses when the child IS the wrapped component', () => {
+    const { output } = migrate(
+      'import { Image } from "rbx";\nexport const A = () => <Image.Container size={64}><Image src="/a.png" /></Image.Container>;'
+    );
+    expect(output).toContain('<Image src="/a.png" size="64x64" />');
+  });
+});
+
+describe('rbx types tooltip and badge as `number | string`', () => {
+  it('stringifies a numeric tooltip, since bestax label is a string', () => {
+    const { output } = migrate(
+      'import { Button } from "rbx";\nexport const A = () => <Button tooltip={7}>x</Button>;'
+    );
+    expect(output).toContain('label="7"');
+  });
+
+  it('leaves a numeric badge alone, since content is a ReactNode', () => {
+    const { output } = migrate(
+      'import { Button } from "rbx";\nexport const A = () => <Button badge={7}>x</Button>;'
+    );
+    expect(output).toContain('content={7}');
+  });
+
+  it('TODOs a dynamic tooltip that could be numeric', () => {
+    const { todos } = migrate(
+      'import { Button } from "rbx";\nexport const A = (p: any) => <Button tooltip={p.t}>x</Button>;'
+    );
+    expect(todos.some(t => /takes a string/.test(t.message))).toBe(true);
+  });
+});
+
+describe('the innerRef remediation is achievable', () => {
+  it('does not tell users to rename innerRef to ref', () => {
+    // bestax Dropdown/Modal/Navbar are plain function components: following
+    // "rename it to ref" just replaces a TODO with a type error.
+    const { todos } = migrate(
+      'import { Dropdown } from "rbx";\nexport const A = (r: any) => <Dropdown innerRef={r}>x</Dropdown>;'
+    );
+    const msg = todos.find(t => t.rule === 'prop:innerRef')?.message ?? '';
+    expect(msg).toMatch(/forwards no ref/);
+    expect(msg).not.toMatch(/rename .*to `ref`/);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Round 7: the first deep review to read the current head (0 blocking).
+// ---------------------------------------------------------------------------
+
+describe('component references through a namespace import', () => {
+  it('migrates a mappable one instead of silently skipping it', () => {
+    // `const C = rbx.Button` kept working (the import is pinned) but was
+    // never migrated and never flagged — a silent skip, which this package
+    // does not do.
+    const { output, todos } = migrate(
+      'import * as rbx from "rbx";\nconst C = rbx.Button;\nexport const A = () => <C>x</C>;'
+    );
+    expect(output).toContain('const C = Button;');
+    expect(output).toContain('from "@allxsmith/bestax-bulma"');
+    expect(output).not.toContain('from "rbx"');
+    expect(todos).toHaveLength(0);
+  });
+
+  it('resolves a compound to its flat bestax target', () => {
+    const { output } = migrate(
+      'import * as rbx from "rbx";\nconst C = rbx.Tag.Group;\nexport const A = () => <C>x</C>;'
+    );
+    expect(output).toContain('const C = Tags;');
+  });
+
+  it('flags an unmappable one and keeps the namespace import', () => {
+    const { output, todos } = migrate(
+      'import * as rbx from "rbx";\nconst C = rbx.Tile;\nexport const A = () => <C>x</C>;'
+    );
+    expect(output).toContain('import * as rbx from "rbx"');
+    expect(todos.some(t => t.rule === 'value-reference')).toBe(true);
+  });
+
+  it('still pins the import for a bare namespace reference', () => {
+    const { output } = migrate(
+      'import * as rbx from "rbx";\nexport const A = () => <rbx.Box>{String(rbx)}</rbx.Box>;'
+    );
+    expect(output).toContain('import * as rbx from "rbx"');
+    expect(output).toContain('<Box>');
+  });
+});
+
+describe('the three specifier retention rules interact correctly', () => {
+  // Named, default and namespace specifiers each have their own retention
+  // rule, added in three separate rounds. Nothing covered them TOGETHER, and
+  // an rbx import declaration can legally carry more than one.
+  it('keeps a default and a namespace in one valid declaration', () => {
+    const { output } = migrate(
+      'import RBX, * as rbx from "rbx";\nexport const A = () => <rbx.Box>{String(RBX)}{String(rbx)}</rbx.Box>;'
+    );
+    expect(output).toContain('import RBX, * as rbx from "rbx"');
+    expect(output).toContain('<Box>');
+  });
+
+  it('drops the namespace but keeps the default when only the default is used', () => {
+    const { output } = migrate(
+      'import RBX, * as rbx from "rbx";\nexport const A = () => <rbx.Box>{String(RBX)}</rbx.Box>;'
+    );
+    expect(output).toContain('import RBX from "rbx"');
+    expect(output).not.toContain('* as rbx');
+  });
+
+  it('handles a namespace retained alongside an alias collision', () => {
+    const { output } = migrate(
+      'import * as rbx from "rbx";\nimport { Tile as Button, Button as Real } from "rbx";\nexport const A = () => <><rbx.Tile/><Button/><Real/></>;'
+    );
+    expect(output).toContain('import * as rbx from "rbx"');
+    expect(output).toContain('import { Tile as Button } from "rbx"');
+    expect(output).toMatch(/Button as Bulma\w+/);
+    expect(output).toContain('<rbx.Tile/>');
+  });
+
+  it('keeps two separate rbx declarations independent', () => {
+    const { output } = migrate(
+      'import { Box } from "rbx";\nimport { Tile } from "rbx";\nexport const A = () => <Box><Tile>x</Tile></Box>;'
+    );
+    expect(output).toContain('import { Tile } from "rbx"');
+    expect(output).toContain('from "@allxsmith/bestax-bulma"');
+  });
+
+  it('prunes everything when nothing needs retaining', () => {
+    const { output } = migrate(
+      'import { Box, Button } from "rbx";\nexport const A = () => <Box><Button>x</Button></Box>;'
+    );
+    expect(output).not.toContain('from "rbx"');
+    expect(output).toContain(
+      'import { Box, Button } from "@allxsmith/bestax-bulma";'
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Round 8: CodeRabbit's second complete pass.
+// ---------------------------------------------------------------------------
+
+describe('an aliased rbx import never loses its name, whatever its status', () => {
+  it('protects a `partial` root retained through an unknown child', () => {
+    // `Icon` is status `partial`, so the earlier seeding skipped it — but
+    // `<Button.Unknown>` retains the root, and dropping `Icon as Button` made
+    // that JSX resolve to the bestax `Button` import instead.
+    const { output } = migrate(
+      'import { Icon as Button, Button as RbxButton } from "rbx";\nexport const A = () => <><Button.Unknown/><RbxButton>b</RbxButton></>;'
+    );
+    expect(output).toContain('import { Icon as Button } from "rbx"');
+    expect(output).toMatch(/Button as Bulma\w+/);
+    expect(output).toContain('<Button.Unknown/>');
+  });
+
+  it('leaves an unaliased import unaliased', () => {
+    // local === imported means the name already denotes the same component
+    // on both sides, so there is nothing to protect against.
+    const { output } = migrate(
+      'import { Button } from "rbx";\nexport const A = () => <Button>x</Button>;'
+    );
+    expect(output).toContain(
+      'import { Button } from "@allxsmith/bestax-bulma"'
+    );
+  });
+});
+
+describe('names bound by destructuring are value references too', () => {
+  it('resolves a member chain through the alias', () => {
+    // The destructuring pass deletes `const { Footer } = Card`, so skipping
+    // `Footer` here left `Footer.Item` referencing nothing.
+    const { output, todos } = migrate(
+      'import { Card } from "rbx";\nconst { Footer } = Card;\nconst value = Footer.Item;\nexport const A = () => <>{String(value)}</>;'
+    );
+    expect(output).toContain('const value = Card.FooterItem;');
+    expect(output).not.toContain('from "rbx"');
+    expect(todos).toHaveLength(0);
+  });
+
+  it('resolves a bare alias reference', () => {
+    const { output } = migrate(
+      'import { Tag } from "rbx";\nconst { Group } = Tag;\nconst V = Group;\nexport const A = () => <V>x</V>;'
+    );
+    expect(output).toContain('const V = Tags;');
+  });
+
+  it('still migrates destructured names used in JSX', () => {
+    const { output } = migrate(
+      'import { Card } from "rbx";\nconst { Content } = Card;\nexport const A = () => <Content>x</Content>;'
+    );
+    expect(output).toContain('<Card.Content>x</Card.Content>');
+  });
+});
+
+describe('Font Awesome sizing classes', () => {
+  it('treats fa-2xs as a modifier, not an icon name', () => {
+    const { output } = migrate(
+      'import { Icon } from "rbx";\nexport const A = () => (<Icon><i className="fas fa-2xs fa-home" /></Icon>);'
+    );
+    expect(output).toContain('name="home"');
+  });
+});
+
+describe('shorthand properties bound by destructuring', () => {
+  it('resolves through the alias path, not its root', () => {
+    // `const { Footer } = Card` makes `{ Footer }` mean `Card.Footer`.
+    // Reading the ROOT's mapping emitted `{ Footer: Card }` — the wrong
+    // component under the right key.
+    const { output, todos } = migrate(
+      'import { Card } from "rbx";\nconst { Footer } = Card;\nexport const reg = { Footer };'
+    );
+    expect(output).toContain('{ Footer: Card.Footer }');
+    expect(todos).toHaveLength(0);
+  });
+
+  it('resolves an alias whose target is flat', () => {
+    const { output } = migrate(
+      'import { Tag } from "rbx";\nconst { Group } = Tag;\nexport const reg = { Group };'
+    );
+    expect(output).toContain('{ Group: Tags }');
+  });
+
+  it('emits no spurious value-reference TODO', () => {
+    // ast-types keeps distinct key and value nodes even when `shorthand` is
+    // true, so the walker reaches the property twice; the second visit used
+    // to fall through to the generic branch and both warn and mark the root
+    // retained.
+    const { todos } = migrate(
+      'import { Card } from "rbx";\nconst { Footer } = Card;\nexport const reg = { Footer };'
+    );
+    expect(todos.map(t => t.rule)).toEqual([]);
+  });
+});
+
+describe('a destructured alias used as a bare value', () => {
+  it('resolves a dotted target to a member expression', () => {
+    // `const { Content } = Card` is deleted by the destructuring pass, so a
+    // bare `Content` reference has nothing to bind to. The flat-rename path
+    // could not express `Card.Content`, so it fell through to a TODO.
+    const { output, todos } = migrate(
+      'import { Card } from "rbx";\nconst { Content } = Card;\nconst V = Content;\nexport const A = () => <Content>{String(V)}</Content>;'
+    );
+    expect(output).toContain('const V = Card.Content;');
+    expect(output).toContain('<Card.Content>');
+    expect(todos).toHaveLength(0);
+  });
+
+  it('still renames when the target is flat', () => {
+    const { output } = migrate(
+      'import { Tag } from "rbx";\nconst { Group } = Tag;\nconst V = Group;\nexport const A = () => <V>x</V>;'
+    );
+    expect(output).toContain('const V = Tags;');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Round 12: the Copilot backlog I had not been draining.
+// ---------------------------------------------------------------------------
+
+describe('Field expanded is a Control modifier in Bulma', () => {
+  it('TODOs it rather than passing it to a prop bestax has not got', () => {
+    const { todos } = migrate(
+      'import { Field } from "rbx";\nexport const A = () => <Field expanded>x</Field>;'
+    );
+    expect(todos.find(t => t.rule === 'prop:expanded')?.message).toMatch(
+      /on the Control, not the Field/
+    );
+  });
+});
+
+describe('Tab.Group needs the list bestax does not render itself', () => {
+  it('wraps the items in Tabs.List', () => {
+    // rbx renders div.tabs > ul > li; bestax's Tabs renders only the div and
+    // leaves the ul to Tabs.List, so a straight rename put <li> directly
+    // inside the div.
+    const { output } = migrate(
+      'import { Tab } from "rbx";\nexport const A = () => (<Tab.Group><Tab active>One</Tab></Tab.Group>);'
+    );
+    expect(output).toContain('<Tabs><Tabs.List>');
+    expect(output).toContain('<Tabs.Item active>One</Tabs.Item>');
+  });
+
+  it('inserts exactly one list for bare Tab children', () => {
+    const { output } = migrate(
+      'import { Tab } from "rbx";\nexport const A = () => (<Tab.Group><Tab>One</Tab><Tab>Two</Tab></Tab.Group>);'
+    );
+    expect((output.match(/Tabs\.List/g) ?? []).length).toBe(2); // open + close
+  });
+
+  it('does not wrap again when a list is already there', () => {
+    // The previous version of this test used bare <Tab> children, so it never
+    // exercised the already-wrapped path it claimed to cover.
+    const { output } = migrate(
+      'import { Tabs } from "@allxsmith/bestax-bulma";\nimport { Tab } from "rbx";\nexport const A = () => (<Tab.Group><Tabs.List><Tab>One</Tab></Tabs.List></Tab.Group>);'
+    );
+    expect((output.match(/Tabs\.List/g) ?? []).length).toBe(2);
+  });
+});
+
+describe('Select.Container modifiers with dynamic values', () => {
+  it('renames rather than dropping the condition', () => {
+    const { output } = migrate(
+      'import { Select } from "rbx";\nexport const A = (w: any) => <Select.Container fullwidth={w}><Select/></Select.Container>;'
+    );
+    expect(output).toContain('isFullwidth={w}');
+  });
+});
+
+describe('a file whose only import is the extension stylesheet', () => {
+  it('is still flagged, with the TODO riding on the kept import', () => {
+    // Previously the import was pruned and the note had to be hung on the
+    // Program to survive an emptied file; with the import kept, the TODO
+    // rides on the import itself.
+    const { output, todos } = migrate(
+      'import "bulma-tooltip/dist/css/bulma-tooltip.min.css";\n'
+    );
+    expect(output).toContain('TODO(bestax-migrate)');
+    expect(output).toContain('bulma-tooltip.min.css');
+    expect(todos.some(t => t.rule === 'css')).toBe(true);
+  });
+});
+
+describe('the extras stylesheet dedup is order-independent', () => {
+  it('collapses extras that appear BEFORE the bulma import', () => {
+    const { output } = migrate(
+      'import "@allxsmith/bestax-bulma/extras.css";\nimport "bulma/css/bulma.min.css";\nexport const A = 1;'
+    );
+    expect(output).toContain('bestax.css');
+    expect(output).not.toContain('extras.css');
+  });
+});
+
+describe('findings that arrived during the backlog pass', () => {
+  it('carries up/hoverable onto Navbar.Dropdown, which declares both', () => {
+    const { output, todos } = migrate(
+      'import { Navbar } from "rbx";\nexport const A = () => <Navbar.Item dropdown up hoverable>x</Navbar.Item>;'
+    );
+    expect(output).toContain('<Navbar.Dropdown up hoverable>');
+    expect(todos).toHaveLength(0);
+  });
+
+  it('TODOs Container breakpoints bestax does not have', () => {
+    // bestax's ContainerBreakpoint is tablet|desktop|widescreen; rbx takes
+    // all six, so the other three were silent type errors.
+    for (const bp of ['mobile', 'fullhd', 'touch']) {
+      const { todos } = migrate(
+        `import { Container } from "rbx";\nexport const A = () => <Container breakpoint="${bp}">x</Container>;`
+      );
+      expect({
+        bp,
+        flagged: todos.some(t => t.rule === 'prop:breakpoint'),
+      }).toEqual({ bp, flagged: true });
+    }
+  });
+
+  it('passes through the Container breakpoints bestax does have', () => {
+    for (const bp of ['tablet', 'desktop', 'widescreen']) {
+      const { output, todos } = migrate(
+        `import { Container } from "rbx";\nexport const A = () => <Container breakpoint="${bp}">x</Container>;`
+      );
+      expect(output).toContain(`breakpoint="${bp}"`);
+      expect(todos).toHaveLength(0);
+    }
+  });
+});
+
+describe('rbx Modal behaviours bestax does not implement', () => {
+  it('flags every conversion, since none of them fail loudly', () => {
+    // rbx portals into document.body, closes on Escape and clips scroll by
+    // default; bestax does none of the three, so an unmodified Modal migrates
+    // to something that looks right and behaves differently.
+    const { todos } = migrate(
+      'import { Modal } from "rbx";\nexport const A = () => <Modal active><Modal.Content>x</Modal.Content></Modal>;'
+    );
+    expect(todos.find(t => t.rule === 'component:Modal')?.message).toMatch(
+      /portalling into document\.body/
+    );
+  });
+
+  it('does not claim bestax closes on Escape', () => {
+    const { todos } = migrate(
+      'import { Modal } from "rbx";\nexport const A = () => <Modal active closeOnEsc>x</Modal>;'
+    );
+    const msg = todos.find(t => t.rule === 'prop:closeOnEsc')?.message ?? '';
+    expect(msg).toMatch(/no Escape handling at all/);
+  });
+});
+
+describe('shorthand value-reference reporting', () => {
+  it('reports an unmappable shorthand once, not once per AST position', () => {
+    // The key and the value are distinct nodes, so the walker reaches the
+    // property twice. The AST comment dedupes, which hid the second report
+    // in the output while the collector still counted it twice.
+    const { todos } = migrate(
+      `import { Tile } from 'rbx';\nconst m = { Tile };\n`
+    );
+    expect(todos.filter(t => t.rule === 'value-reference')).toHaveLength(1);
+  });
+});
+
+describe('a dynamic modifier in the Select.Container fallback', () => {
+  it('is reported rather than dropped with its expression', () => {
+    const { todos } = migrate(
+      'import { Select } from "rbx";\nexport const A = (w: any) => (<Select.Container fullwidth={w}><Select/><Select/></Select.Container>);'
+    );
+    expect(todos.some(t => t.rule === 'prop:fullwidth')).toBe(true);
+  });
+});
+
+describe('binding resolution and import assembly', () => {
+  it('leaves a local that shadows the rbx import alone', () => {
+    const { output } = migrate(
+      [
+        `import { Card } from 'rbx';`,
+        'function F({ Card }) { return <Card.Footer.Item/>; }',
+        'export const G = () => <Card.Footer.Item/>;',
+      ].join('\n')
+    );
+    expect(output).toContain(
+      'function F({ Card }) { return <Card.Footer.Item/>; }'
+    );
+    expect(output).toMatch(/<Bulma?Card\.FooterItem\/>/);
+  });
+
+  it('still migrates an alias destructured inside a function', () => {
+    const { output } = migrate(
+      [
+        `import { Card } from 'rbx';`,
+        'export function F(){ const { Header } = Card; return <Header.Title/>; }',
+      ].join('\n')
+    );
+    expect(output).toContain('Card.Header.Title');
+  });
+
+  it('rebuilds the full chain through a destructured alias', () => {
+    const { output } = migrate(
+      [
+        `import { Card } from 'rbx';`,
+        'const { Header } = Card;',
+        'const T = Header.Title;',
+      ].join('\n')
+    );
+    expect(output).toContain('const T = Card.Header.Title;');
+  });
+
+  it('does not merge named specifiers into a namespace bestax import', () => {
+    const { output } = migrate(
+      [
+        `import * as Bulma from '@allxsmith/bestax-bulma';`,
+        `import { Box } from 'rbx';`,
+        'export const x = <><Bulma.Button/><Box/></>;',
+      ].join('\n')
+    );
+    expect(output).not.toMatch(/import \* as \w+,/);
+  });
+});
+
+describe('alias scoping and retained partial roots', () => {
+  it('keeps two same-named aliases in separate scopes apart', () => {
+    // A name-keyed alias map let the second declaration overwrite the first;
+    // both were then pruned and both `<Header…>` references left resolving to
+    // nothing at all -- a ReferenceError, not a type error.
+    const { output } = migrate(
+      [
+        `import { Card, Panel } from 'rbx';`,
+        'export function A(){ const { Header } = Card; return <Header.Title/>; }',
+        'export function B(){ const { Header } = Panel; return <Header/>; }',
+      ].join('\n')
+    );
+    expect(output).toContain('Card.Header.Title');
+    // B's alias is unmappable, so its declaration must survive rather than
+    // leaving `<Header/>` dangling.
+    expect(output).toContain('const { Header } = Panel');
+  });
+
+  it('keeps the declaration when an alias cannot be mapped', () => {
+    const { output } = migrate(
+      [
+        `import { Panel } from 'rbx';`,
+        'const { Header } = Panel;',
+        'export const x = <Header/>;',
+      ].join('\n')
+    );
+    expect(output).toContain('const { Header } = Panel');
+  });
+
+  it('aliases the bestax root when a partial root is retained', () => {
+    // `Icon` maps, but `<Icon.Unknown>` retains the rbx import. Letting the
+    // bestax import take the plain local dropped the retained specifier on
+    // the collision, silently repointing `<Icon.Unknown>` at bestax's Icon.
+    const { output } = migrate(
+      [
+        `import { Icon } from 'rbx';`,
+        'export const a = <Icon/>;',
+        'export const b = <Icon.Unknown/>;',
+      ].join('\n')
+    );
+    expect(output).toMatch(/Icon as Bulma\w+/);
+    expect(output).toMatch(/import \{ Icon \} from ["']rbx["']/);
+  });
+
+  it('does not alias a partial root that is not retained', () => {
+    const { output } = migrate(
+      [`import { Icon } from 'rbx';`, 'export const a = <Icon/>;'].join('\n')
+    );
+    expect(output).toContain('import { Icon } from "@allxsmith/bestax-bulma"');
+    expect(output).not.toContain('BulmaIcon');
+  });
+});
+
+describe('labelled Divider', () => {
+  it('flags children, which bestax Divider (a void <hr>) cannot take', () => {
+    // rbx rendered the children as a centred label through `data-content`.
+    // Passing them straight through put children on an <hr>, which React
+    // rejects at runtime, with no TODO reporting the lost label.
+    const { todos } = migrate(
+      `import { Divider } from 'rbx';\nexport const a = <Divider>OR</Divider>;\n`
+    );
+    expect(todos.some(t => t.rule === 'component:Divider')).toBe(true);
+  });
+
+  it('leaves a bare Divider alone', () => {
+    const { todos } = migrate(
+      `import { Divider } from 'rbx';\nexport const a = <Divider/>;\n`
+    );
+    expect(todos.some(t => t.rule === 'component:Divider')).toBe(false);
+  });
+});
+
+describe('an alias shadowed by a nearer binding', () => {
+  it('leaves a parameter that shadows a module-level alias alone', () => {
+    // The ancestor walk found the module-level owner from inside F and
+    // rewrote the PARAMETER to `F(Card.Header)` -- invalid syntax. A nearer
+    // binding must win over the alias it shadows.
+    const { output } = migrate(
+      [
+        `import { Card } from 'rbx';`,
+        'const { Header } = Card;',
+        'export const A = () => <Header.Title/>;',
+        'export function F(Header) { return <Header.Title/>; }',
+      ].join('\n')
+    );
+    expect(output).toContain('<Card.Header.Title/>');
+    expect(output).toContain('function F(Header) { return <Header.Title/>; }');
+  });
+});
diff --git a/bestax-migrate/src/sources/rbx/__tests__/specials.test.ts b/bestax-migrate/src/sources/rbx/__tests__/specials.test.ts
new file mode 100644
index 000000000..c3f0df385
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__tests__/specials.test.ts
@@ -0,0 +1,366 @@
+/**
+ * Structural-handler coverage beyond the fixture pairs: the branches a
+ * fixture would have to contort itself to reach — dynamic prop values, the
+ * fall-back paths of the container collapses, and the handlers whose whole
+ * job is to emit a TODO.
+ */
+
+import transform from '../transform.js';
+import { runTransform } from '../../../runner.js';
+import type { TodoEntry } from '../../../types.js';
+
+function migrate(source: string) {
+  const todos: TodoEntry[] = [];
+  const { output } = runTransform(transform, 'case.tsx', source, {
+    add: entry => todos.push(entry),
+  });
+  return { output: output ?? '', todos, rules: todos.map(t => t.rule) };
+}
+
+const imp = (names: string) => `import { ${names} } from 'rbx';\n`;
+
+describe('rbx plain-element handlers', () => {
+  it('turns Heading into a plain .heading paragraph', () => {
+    const { output } = migrate(
+      imp('Heading') + 'export const A = () => <Heading>x</Heading>;'
+    );
+    expect(output).toContain('<p className="heading">x</p>');
+  });
+
+  it('turns Help into a plain .help paragraph with its colour class', () => {
+    const { output } = migrate(
+      imp('Help') + 'export const A = () => <Help color="danger">x</Help>;'
+    );
+    expect(output).toContain('<p className="help is-danger">x</p>');
+  });
+
+  it('flags a dynamic Help colour instead of guessing a class', () => {
+    const { output, rules } = migrate(
+      imp('Help') +
+        'export const A = ({ c }: { c: string }) => <Help color={c}>x</Help>;'
+    );
+    expect(rules).toContain('prop:color');
+    expect(output).toContain('className="help"');
+  });
+
+  it('turns Label into a plain .label with size and disabled classes', () => {
+    const { output } = migrate(
+      imp('Label') +
+        'export const A = () => <Label size="small" disabled>x</Label>;'
+    );
+    expect(output).toContain('<label className="label is-small is-disabled">');
+  });
+
+  it('merges an existing className into the plain element', () => {
+    const { output } = migrate(
+      imp('Help') + 'export const A = () => <Help className="mine">x</Help>;'
+    );
+    expect(output).toContain('className="help mine"');
+  });
+
+  it('flags a dynamic className it cannot merge', () => {
+    const { output, rules } = migrate(
+      imp('Help') +
+        'export const A = ({ c }: { c: string }) => <Help className={c}>x</Help>;'
+    );
+    expect(rules).toContain('prop:className');
+    expect(output).toContain('className="help"');
+  });
+
+  it('reports helper props dropped by a plain-element rewrite', () => {
+    const { rules } = migrate(
+      imp('Help') + 'export const A = () => <Help marginless>x</Help>;'
+    );
+    expect(rules).toContain('plain-element');
+  });
+
+  it('turns Select.Option into a plain option', () => {
+    const { output } = migrate(
+      imp('Select') +
+        'export const A = () => <Select.Option value="a">A</Select.Option>;'
+    );
+    expect(output).toContain('<option value="a">A</option>');
+  });
+
+  it('turns Panel.Tab into a plain anchor, keeping is-active', () => {
+    const { output } = migrate(
+      imp('Panel') + 'export const A = () => <Panel.Tab active>All</Panel.Tab>;'
+    );
+    expect(output).toContain('<a className="is-active">All</a>');
+  });
+
+  it('flags a dynamic Panel.Tab active', () => {
+    const { rules } = migrate(
+      imp('Panel') +
+        'export const A = ({ on }: { on: boolean }) => <Panel.Tab active={on}>x</Panel.Tab>;'
+    );
+    expect(rules).toContain('prop:active');
+  });
+});
+
+describe('rbx value-chosen targets', () => {
+  it.each([
+    ['Level', 'Level.Item', 'align="left"', '<Level.Left>'],
+    ['Level', 'Level.Item', 'align="right"', '<Level.Right>'],
+    ['Level', 'Level.Item', '', '<Level.Item>'],
+    ['Media', 'Media.Item', 'align="left"', '<Media.Left>'],
+    ['Media', 'Media.Item', 'align="right"', '<Media.Right>'],
+    ['Media', 'Media.Item', 'align="content"', '<Media.Content>'],
+    ['Navbar', 'Navbar.Segment', 'align="start"', '<Navbar.Start>'],
+    ['Navbar', 'Navbar.Segment', 'align="end"', '<Navbar.End>'],
+    ['Pagination', 'Pagination.Step', 'align="next"', '<Pagination.Next>'],
+    [
+      'Pagination',
+      'Pagination.Step',
+      'align="previous"',
+      '<Pagination.Previous>',
+    ],
+  ])('%s %s with %s → %s', (root, tag, attr, expected) => {
+    const { output } = migrate(
+      imp(root) +
+        `export const A = () => <${[tag, attr].filter(Boolean).join(' ')}>x</${tag}>;`
+    );
+    expect(output).toContain(expected);
+  });
+
+  it('flags a dynamic align and falls back', () => {
+    const { output, rules } = migrate(
+      imp('Level') +
+        'export const A = ({ s }: { s: "left" }) => <Level.Item align={s}>x</Level.Item>;'
+    );
+    expect(rules).toContain('prop:align');
+    expect(output).toContain('<Level.Item>');
+  });
+
+  it('falls back on an unrecognised literal align', () => {
+    const { output } = migrate(
+      imp('Media') +
+        'export const A = () => <Media.Item align="nope">x</Media.Item>;'
+    );
+    expect(output).toContain('<Media.Content>');
+  });
+});
+
+describe('rbx container collapsing', () => {
+  it('folds Select.Container onto its single Select child', () => {
+    const { output } = migrate(
+      imp('Select') +
+        'export const A = () => (<Select.Container rounded fullwidth state="focused"><Select /></Select.Container>);'
+    );
+    expect(output).toContain('<Select isFullwidth isRounded isFocused />');
+    expect(output).not.toMatch(/<Select[^/>]*>\s*<Select/);
+  });
+
+  it('falls back to plain Bulma markup when there is not a single child', () => {
+    // bestax's Select renders exactly one <select>, so a container holding
+    // several cannot become one; emit rbx's own div.select wrapper instead,
+    // with the modifiers as classes rather than props on an intrinsic tag.
+    const { output, rules } = migrate(
+      imp('Select') +
+        'export const A = () => (<Select.Container rounded><Select /><Select /></Select.Container>);'
+    );
+    expect(output).toContain('className="select is-rounded"');
+    expect(output).not.toMatch(/<div[^>]*\sisRounded/);
+    expect(rules).toContain('component:Select.Container');
+  });
+
+  it('flags a prop the child already sets when folding', () => {
+    const { rules } = migrate(
+      imp('Select') +
+        'export const A = () => (<Select.Container size="small"><Select size="medium" /></Select.Container>);'
+    );
+    expect(rules).toContain('prop:size');
+  });
+
+  it('folds Image.Container and squares its numeric size', () => {
+    const { output } = migrate(
+      imp('Image') +
+        'export const A = () => (<Image.Container size={64}><Image src="/a.png" /></Image.Container>);'
+    );
+    expect(output).toContain('size="64x64"');
+    expect(output).not.toMatch(/<Image[^/>]*>\s*<Image/);
+  });
+
+  it('passes an Image.Container ratio string through unchanged', () => {
+    const { output } = migrate(
+      imp('Image') +
+        'export const A = () => (<Image.Container size="16by9"><Image src="/a.png" /></Image.Container>);'
+    );
+    expect(output).toContain('size="16by9"');
+  });
+
+  it('flags a dynamic Image.Container size', () => {
+    const { rules } = migrate(
+      imp('Image') +
+        'export const A = ({ n }: { n: number }) => (<Image.Container size={n}><Image src="/a.png" /></Image.Container>);'
+    );
+    expect(rules).toContain('prop:size');
+  });
+
+  it('maps Modal.Container onto Modal', () => {
+    const { output } = migrate(
+      imp('Modal') +
+        'export const A = () => <Modal.Container active>x</Modal.Container>;'
+    );
+    expect(output).toContain('<Modal active>');
+  });
+});
+
+describe('rbx Title / Icon / PageLoader / Navbar / Field', () => {
+  it('splits Title and SubTitle, dropping spaced on a subtitle', () => {
+    const { output } = migrate(
+      imp('Title') + 'export const A = () => <Title subtitle spaced>x</Title>;'
+    );
+    expect(output).toContain('<SubTitle>x</SubTitle>');
+    expect(output).not.toContain('isSpaced');
+  });
+
+  it('keeps a dynamic spaced as isSpaced on a Title', () => {
+    const { output } = migrate(
+      imp('Title') +
+        'export const A = ({ s }: { s: boolean }) => <Title spaced={s}>x</Title>;'
+    );
+    expect(output).toContain('isSpaced={s}');
+  });
+
+  it('drops a falsy spaced', () => {
+    const { output } = migrate(
+      imp('Title') + 'export const A = () => <Title spaced={false}>x</Title>;'
+    );
+    expect(output).not.toContain('spaced');
+  });
+
+  it('flags a dynamic subtitle and stays on Title', () => {
+    const { output, rules } = migrate(
+      imp('Title') +
+        'export const A = ({ s }: { s: boolean }) => <Title subtitle={s}>x</Title>;'
+    );
+    expect(rules).toContain('prop:subtitle');
+    expect(output).toContain('<Title>');
+  });
+
+  it('reads an icon-font child into Icon name/library/variant', () => {
+    const { output } = migrate(
+      imp('Icon') +
+        'export const A = () => (<Icon><i className="fas fa-home" /></Icon>);'
+    );
+    expect(output).toContain('name="home"');
+    expect(output).toContain('library="fa"');
+    expect(output).toContain('variant="solid"');
+  });
+
+  it('reads an mdi icon-font child', () => {
+    const { output } = migrate(
+      imp('Icon') +
+        'export const A = () => (<Icon><i className="mdi mdi-home" /></Icon>);'
+    );
+    expect(output).toContain('name="home"');
+    expect(output).toContain('library="mdi"');
+  });
+
+  it('flags an Icon whose child it cannot read', () => {
+    const { rules } = migrate(
+      imp('Icon') + 'export const A = () => (<Icon><Thing /></Icon>);'
+    );
+    expect(rules).toContain('component:Icon');
+  });
+
+  it('adds isFullPage to a PageLoader', () => {
+    const { output } = migrate(
+      imp('PageLoader') + 'export const A = () => <PageLoader active />;'
+    );
+    expect(output).toContain('<Loading active isFullPage />');
+  });
+
+  it('turns a dropdown Navbar.Item into Navbar.Dropdown', () => {
+    const { output } = migrate(
+      imp('Navbar') +
+        'export const A = () => <Navbar.Item dropdown>x</Navbar.Item>;'
+    );
+    expect(output).toContain('<Navbar.Dropdown>');
+  });
+
+  it('flags a dynamic Navbar.Item dropdown', () => {
+    const { rules } = migrate(
+      imp('Navbar') +
+        'export const A = ({ d }: { d: boolean }) => <Navbar.Item dropdown={d}>x</Navbar.Item>;'
+    );
+    expect(rules).toContain('prop:dropdown');
+  });
+
+  it('flags Navbar.Item props bestax has no home for', () => {
+    const { rules } = migrate(
+      imp('Navbar') +
+        'export const A = () => <Navbar.Item up tab expanded>x</Navbar.Item>;'
+    );
+    expect(rules).toEqual(
+      expect.arrayContaining(['prop:up', 'prop:tab', 'prop:expanded'])
+    );
+  });
+
+  it('flags Navbar.Dropdown boxed and the Navbar containers', () => {
+    const { rules } = migrate(
+      imp('Navbar') +
+        'export const A = () => (<Navbar.Container><Navbar.Dropdown boxed>x</Navbar.Dropdown></Navbar.Container>);'
+    );
+    expect(rules).toContain('prop:boxed');
+    expect(rules).toContain('component:Navbar.Container');
+  });
+
+  it('flags every part of an rbx Dropdown', () => {
+    const { rules } = migrate(
+      imp('Dropdown') +
+        'export const A = () => (<Dropdown><Dropdown.Trigger>t</Dropdown.Trigger><Dropdown.Menu><Dropdown.Content><Dropdown.Item>i</Dropdown.Item></Dropdown.Content></Dropdown.Menu></Dropdown>);'
+    );
+    expect(rules).toEqual(
+      expect.arrayContaining([
+        'component:Dropdown',
+        'component:Dropdown.Trigger',
+        'component:Dropdown.Menu',
+        'component:Dropdown.Content',
+      ])
+    );
+  });
+
+  it('folds Field multiline into grouped="multiline", replacing kind', () => {
+    const { output } = migrate(
+      imp('Field') +
+        'export const A = () => <Field kind="group" multiline>x</Field>;'
+    );
+    expect(output).toContain('grouped="multiline"');
+    expect((output.match(/grouped/g) ?? []).length).toBe(1);
+  });
+
+  it('drops a falsy Field multiline', () => {
+    const { output } = migrate(
+      imp('Field') +
+        'export const A = () => <Field kind="addons" multiline={false}>x</Field>;'
+    );
+    expect(output).toContain('hasAddons');
+    expect(output).not.toContain('multiline');
+  });
+
+  it('flags a dynamic Field multiline', () => {
+    const { rules } = migrate(
+      imp('Field') +
+        'export const A = ({ m }: { m: boolean }) => <Field multiline={m}>x</Field>;'
+    );
+    expect(rules).toContain('prop:multiline');
+  });
+
+  it('turns a Breadcrumb.Item into li > a', () => {
+    const { output } = migrate(
+      imp('Breadcrumb') +
+        'export const A = () => <Breadcrumb.Item href="/a">A</Breadcrumb.Item>;'
+    );
+    expect(output).toContain('<li><a href="/a">A</a></li>');
+  });
+
+  it('flags a dynamic Breadcrumb.Item active', () => {
+    const { rules } = migrate(
+      imp('Breadcrumb') +
+        'export const A = ({ on }: { on: boolean }) => <Breadcrumb.Item active={on}>A</Breadcrumb.Item>;'
+    );
+    expect(rules).toContain('prop:active');
+  });
+});
diff --git a/bestax-migrate/src/sources/rbx/__tests__/transform.test.ts b/bestax-migrate/src/sources/rbx/__tests__/transform.test.ts
new file mode 100644
index 000000000..996f3c07c
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__tests__/transform.test.ts
@@ -0,0 +1,321 @@
+/**
+ * Fixture-pair tests: every __testfixtures__/<case>.input.tsx must transform
+ * into the committed <case>.output.tsx byte-for-byte (modulo trailing
+ * whitespace). Fixtures are read as text — rbx is never installed in this
+ * repository.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import transform from '../transform.js';
+import { runTransform } from '../../../runner.js';
+import type { TodoEntry } from '../../../types.js';
+
+const fixturesDir = path.join(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '..',
+  '__testfixtures__'
+);
+
+const cases = fs
+  .readdirSync(fixturesDir)
+  .filter(file => file.endsWith('.input.tsx'))
+  .map(file => file.replace(/\.input\.tsx$/, ''))
+  .sort();
+
+describe('rbx transform fixtures', () => {
+  it('has at least one fixture pair', () => {
+    expect(cases.length).toBeGreaterThan(0);
+  });
+
+  test.each(cases)('%s', name => {
+    const input = fs.readFileSync(
+      path.join(fixturesDir, `${name}.input.tsx`),
+      'utf8'
+    );
+    const expected = fs.readFileSync(
+      path.join(fixturesDir, `${name}.output.tsx`),
+      'utf8'
+    );
+    const todos: TodoEntry[] = [];
+    const { output } = runTransform(transform, `${name}.input.tsx`, input, {
+      add: entry => todos.push(entry),
+    });
+    expect((output ?? input).trimEnd()).toBe(expected.trimEnd());
+  });
+
+  it('returns null for files without rbx imports', () => {
+    const source =
+      "import { Button } from 'other-library';\nexport const A = () => <Button />;\n";
+    const { output } = runTransform(transform, 'untouched.tsx', source);
+    expect(output).toBeNull();
+  });
+});
+
+describe('rbx imports', () => {
+  it('flags default imports from rbx', () => {
+    const source = "import RBX from 'rbx';\nexport const A = 1;\n";
+    const todos: TodoEntry[] = [];
+    const { output } = runTransform(transform, 'default.tsx', source, {
+      add: entry => todos.push(entry),
+    });
+    expect(output).toContain('TODO(bestax-migrate)');
+    expect(todos[0].rule).toBe('imports');
+  });
+
+  it('points deep rbx imports at the bestax theming helpers', () => {
+    const source = [
+      "import { ThemeContext } from 'rbx/base/theme';",
+      "import { Box } from 'rbx';",
+      'export const A = () => <Box />;',
+    ].join('\n');
+    const todos: TodoEntry[] = [];
+    runTransform(transform, 'deep.tsx', source, {
+      add: entry => todos.push(entry),
+    });
+    expect(todos.some(t => t.message.includes('ConfigProvider'))).toBe(true);
+  });
+
+  it('resolves `const { Item } = Card` destructuring', () => {
+    const source = [
+      "import { Card } from 'rbx';",
+      'const { Content } = Card;',
+      'export const A = () => <Content>x</Content>;',
+    ].join('\n');
+    const { output } = runTransform(transform, 'destructure.tsx', source);
+    expect(output).toContain('<Card.Content>x</Card.Content>');
+    expect(output).not.toContain('= Card');
+  });
+
+  it('flags destructuring it cannot fully resolve', () => {
+    const source = [
+      "import { Card } from 'rbx';",
+      'const { Content, ...rest } = Card;',
+      'export const A = () => <Content>x</Content>;',
+    ].join('\n');
+    const todos: TodoEntry[] = [];
+    runTransform(transform, 'rest.tsx', source, {
+      add: entry => todos.push(entry),
+    });
+    expect(todos.some(t => t.rule === 'imports')).toBe(true);
+  });
+
+  it('prunes only the rbx declarator from multi-declarator statements', () => {
+    const source = [
+      "import { Card } from 'rbx';",
+      'const { Content } = Card,',
+      '  other = 1;',
+      'export const A = () => <Content>{other}</Content>;',
+    ].join('\n');
+    const { output } = runTransform(transform, 'multi.tsx', source);
+    expect(output).toContain('other = 1');
+    expect(output).not.toContain('= Card');
+  });
+
+  it('aliases imports that collide with local bindings', () => {
+    const source = [
+      "import { Box } from 'rbx';",
+      'export const Box2 = 1;',
+      'class Button {}',
+      "import { Button as RbxButton } from 'rbx';",
+      'export const A = () => <RbxButton>{String(Button)}</RbxButton>;',
+    ].join('\n');
+    const { output } = runTransform(transform, 'collision.tsx', source);
+    expect(output).toContain('Button as BulmaButton');
+    expect(output).toContain('<BulmaButton>');
+  });
+
+  it('merges needed names into an existing bestax-bulma import', () => {
+    const source = [
+      "import { Box } from '@allxsmith/bestax-bulma';",
+      "import { Button } from 'rbx';",
+      'export const A = () => (',
+      '  <Box>',
+      '    <Button color="primary">Go</Button>',
+      '  </Box>',
+      ');',
+    ].join('\n');
+    const { output } = runTransform(transform, 'merge.tsx', source);
+    expect(output).toContain(
+      "import { Box, Button } from '@allxsmith/bestax-bulma';"
+    );
+    expect(output).not.toContain("from 'rbx'");
+  });
+
+  it('handles namespace imports', () => {
+    const source = [
+      "import * as Rbx from 'rbx';",
+      'export const A = () => <Rbx.Box>x</Rbx.Box>;',
+    ].join('\n');
+    const { output } = runTransform(transform, 'namespace.tsx', source);
+    expect(output).toContain('<Box>x</Box>');
+  });
+
+  it('keeps tabs in tab-indented sources', () => {
+    const source = [
+      "import { Button } from 'rbx';",
+      'export function App() {',
+      '\treturn (',
+      '\t\t<Button color="primary" outlined>',
+      '\t\t\tGo',
+      '\t\t</Button>',
+      '\t);',
+      '}',
+      '',
+    ].join('\n');
+    const { output } = runTransform(transform, 'tabbed.tsx', source);
+    expect(output).toContain('\t\t<Button color="primary" isOutlined>');
+  });
+});
+
+describe('rbx value references', () => {
+  it('rewrites flat-target member values (Tag.Group → Tags)', () => {
+    const source = [
+      "import { Tag } from 'rbx';",
+      'const Group = Tag.Group;',
+      'export const A = () => <Group>x</Group>;',
+    ].join('\n');
+    const { output } = runTransform(transform, 'member.tsx', source);
+    expect(output).toContain('const Group = Tags;');
+  });
+
+  it('keeps same-compound member values on the bestax root', () => {
+    const source = [
+      "import { Card } from 'rbx';",
+      'const Body = Card.Content;',
+      'export const A = () => <Body>x</Body>;',
+    ].join('\n');
+    const { output } = runTransform(transform, 'compound.tsx', source);
+    expect(output).toContain('const Body = Card.Content;');
+  });
+
+  it('flags member values whose target needs restructuring', () => {
+    const source = [
+      "import { Media } from 'rbx';",
+      'const Item = Media.Item;',
+      'export const A = () => <Item>x</Item>;',
+    ].join('\n');
+    const todos: TodoEntry[] = [];
+    const { output } = runTransform(transform, 'special.tsx', source, {
+      add: entry => todos.push(entry),
+    });
+    expect(todos.some(t => t.rule === 'value-reference')).toBe(true);
+    expect(output).toContain("from 'rbx'");
+  });
+
+  it('flags a bare component used as a value when it has no flat target', () => {
+    const source = [
+      "import { Tile } from 'rbx';",
+      'const X = Tile;',
+      'export const A = () => String(X);',
+    ].join('\n');
+    const todos: TodoEntry[] = [];
+    runTransform(transform, 'bare.tsx', source, {
+      add: entry => todos.push(entry),
+    });
+    expect(todos.some(t => t.rule === 'value-reference')).toBe(true);
+  });
+
+  it('rewrites a bare component used as a value when it maps flatly', () => {
+    const source = [
+      "import { Box } from 'rbx';",
+      'const X = Box;',
+      'export const A = () => String(X);',
+    ].join('\n');
+    const { output } = runTransform(transform, 'bare-ok.tsx', source);
+    expect(output).toContain('from "@allxsmith/bestax-bulma"');
+  });
+});
+
+describe('rbx stylesheet imports', () => {
+  const RBX_CSS = "import 'rbx/index.css';\n";
+  const BULMA_CSS_IMPORT = "import 'bulma/css/bulma.min.css';\n";
+
+  it('default (bestax): converges on the combined bestax.css bundle', () => {
+    const { output } = runTransform(transform, 'styles.ts', RBX_CSS);
+    expect(output).toContain('import "@allxsmith/bestax-bulma/bestax.css";');
+    expect(output).not.toContain('TODO');
+  });
+
+  it('bestax: dedupes when both rbx and bulma css imports exist', () => {
+    const { output } = runTransform(
+      transform,
+      'styles.ts',
+      RBX_CSS + BULMA_CSS_IMPORT
+    );
+    const matches = (output ?? '').match(/bestax\.css/g) ?? [];
+    expect(matches).toHaveLength(1);
+  });
+
+  it('bestax: collapses a separate extras import', () => {
+    const source =
+      BULMA_CSS_IMPORT + "import '@allxsmith/bestax-bulma/extras.css';\n";
+    const { output } = runTransform(transform, 'styles.ts', source);
+    expect(output).toContain('import "@allxsmith/bestax-bulma/bestax.css";');
+    expect(output).not.toContain('extras.css');
+  });
+
+  it('keeps the Bulma extension stylesheets rbx pinned, with a TODO each', () => {
+    // Kept, not dropped: the rbx JSX that needed them becomes bestax
+    // components with their own styles, but markup outside rbx may use the
+    // extension classes directly, and the manifest pass reports rather than
+    // removes the same packages for that reason. Deleting the import here
+    // contradicted that and was a silent best-guess.
+    const source =
+      "import 'bulma-tooltip/dist/css/bulma-tooltip.min.css';\n" +
+      "import 'bulma-badge/dist/css/bulma-badge.min.css';\n";
+    const todos: TodoEntry[] = [];
+    const { output } = runTransform(transform, 'ext.ts', source, {
+      add: entry => todos.push(entry),
+    });
+    const code = (output ?? '')
+      .split('\n')
+      .filter(l => !l.trim().startsWith('// TODO(bestax-migrate)'))
+      .join('\n');
+    expect(code).toContain("'bulma-tooltip/dist/css/bulma-tooltip.min.css'");
+    expect(code).toContain("'bulma-badge/dist/css/bulma-badge.min.css'");
+    expect(todos.filter(t => t.rule === 'css')).toHaveLength(2);
+    expect(todos.every(t => t.rule !== 'css' || /^kept /.test(t.message))).toBe(
+      true
+    );
+  });
+
+  it('bulma mode: rewrites the rbx css and adds the extras import', () => {
+    const { output } = runTransform(
+      transform,
+      'styles.ts',
+      RBX_CSS,
+      undefined,
+      { cssMode: 'bulma' }
+    );
+    expect(output).toContain('import "bulma/css/bulma.min.css";');
+    expect(output).toContain('import "@allxsmith/bestax-bulma/extras.css";');
+  });
+
+  it('bulma mode: keeps plain bulma css and adds the extras import', () => {
+    const { output } = runTransform(
+      transform,
+      'styles.ts',
+      BULMA_CSS_IMPORT,
+      undefined,
+      { cssMode: 'bulma' }
+    );
+    expect(output).toContain("import 'bulma/css/bulma.min.css';");
+    expect(output).toContain('import "@allxsmith/bestax-bulma/extras.css";');
+  });
+
+  it('keep mode: only retargets the rbx css, with a TODO', () => {
+    const todos: TodoEntry[] = [];
+    const { output } = runTransform(
+      transform,
+      'styles.ts',
+      RBX_CSS,
+      { add: entry => todos.push(entry) },
+      { cssMode: 'keep' }
+    );
+    expect(output).toContain('import "bulma/css/bulma.min.css";');
+    expect(output).not.toContain('bestax.css');
+    expect(todos.some(t => t.rule === 'css')).toBe(true);
+  });
+});
diff --git a/bestax-migrate/src/sources/rbx/__tests__/value-unions.test.ts b/bestax-migrate/src/sources/rbx/__tests__/value-unions.test.ts
new file mode 100644
index 000000000..e4259e778
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/__tests__/value-unions.test.ts
@@ -0,0 +1,96 @@
+/**
+ * The mapping table asserts that most rbx helper values pass through to
+ * bestax unchanged — `textAlign="centered"`, `display="flex"`,
+ * `textWeight="semibold"` and so on are the same string on both sides. That
+ * assertion is invisible to every other check on this package: the fixtures
+ * only use a handful of values, the corpus only parses, and the e2e
+ * typecheck only sees the values its fixture happens to write.
+ *
+ * So this diffs rbx's own DEFAULTS against bestax's `valid*` constants
+ * directly. If a future bestax release drops or renames a value, the
+ * pass-through mappings become silently wrong and this is what catches it.
+ *
+ * rbx's table is vendored rather than read from disk: rbx is never installed
+ * in this repository, and the values are frozen at its final release.
+ */
+
+import {
+  validAlignments,
+  validColors,
+  validDisplays,
+  validTextSizes,
+  validTextTransforms,
+  validTextWeights,
+} from '@allxsmith/bestax-bulma';
+
+/** rbx v2.2.0 `src/base/helpers/variables.ts` — DEFAULTS, verbatim. */
+const RBX = {
+  colors: [
+    'primary',
+    'success',
+    'info',
+    'warning',
+    'danger',
+    'light',
+    'dark',
+    'white',
+    'black',
+    'link',
+  ],
+  shades: [
+    'black-bis',
+    'black-ter',
+    'grey-darker',
+    'grey-dark',
+    'grey',
+    'grey-light',
+    'grey-lighter',
+    'white-ter',
+    'white-bis',
+  ],
+  textAlignments: ['centered', 'justified', 'left', 'right'],
+  textSizes: [1, 2, 3, 4, 5, 6, 7],
+  textTransforms: ['capitalized', 'lowercase', 'uppercase'],
+  textWeights: ['light', 'medium', 'normal', 'semibold', 'bold'],
+  displays: ['block', 'flex', 'inline', 'inline-block', 'inline-flex'],
+} as const;
+
+/** The two rbx shades bestax has no counterpart for — mapping.ts TODOs both. */
+const KNOWN_UNSUPPORTED_SHADES = ['white-ter', 'white-bis'];
+
+describe('rbx helper values that the mapping passes through unchanged', () => {
+  it.each([
+    ['textAlign', RBX.textAlignments, validAlignments as readonly string[]],
+    [
+      'textTransform',
+      RBX.textTransforms,
+      validTextTransforms as readonly string[],
+    ],
+    ['textWeight', RBX.textWeights, validTextWeights as readonly string[]],
+    ['display', RBX.displays, validDisplays as readonly string[]],
+    ['color', RBX.colors, validColors as readonly string[]],
+  ])(
+    'every rbx %s value exists in bestax',
+    (_name, rbxValues, bestaxValues) => {
+      const missing = rbxValues.filter(v => !bestaxValues.includes(String(v)));
+      expect(missing).toEqual([]);
+    }
+  );
+
+  it('every rbx textSize maps to the string bestax expects', () => {
+    // rbx types these as numbers; the mapping stringifies them.
+    const missing = RBX.textSizes
+      .map(String)
+      .filter(v => !(validTextSizes as readonly string[]).includes(v));
+    expect(missing).toEqual([]);
+  });
+
+  it('only the two known shades are unsupported', () => {
+    // If this list grows, mapping.ts's SHADE_TODO must grow with it —
+    // otherwise an unsupported shade passes through as a silent type error.
+    const missing = RBX.shades.filter(
+      v => !(validColors as readonly string[]).includes(v)
+    );
+    expect(missing.sort()).toEqual([...KNOWN_UNSUPPORTED_SHADES].sort());
+  });
+});
diff --git a/bestax-migrate/src/sources/rbx/deps.ts b/bestax-migrate/src/sources/rbx/deps.ts
new file mode 100644
index 000000000..17e8a0698
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/deps.ts
@@ -0,0 +1,310 @@
+/**
+ * package.json migration: swap rbx for @allxsmith/bestax-bulma and clear out
+ * the stylesheet dependencies rbx dragged in with it. Pure data-in/data-out —
+ * the CLI owns file IO, and no package manager is ever invoked (the report
+ * tells the user to install).
+ *
+ * This is the step with the biggest visible payoff for an rbx app. Unlike
+ * react-bulma-components, which peer-depends on Bulma and lets the app pick a
+ * version, rbx ships `bulma@0.7.5` as a *direct* dependency plus four Bulma
+ * extensions — so an rbx app cannot move to Bulma v1 at all while rbx is
+ * installed. Removing rbx is what frees that, and the report says so; its
+ * four Bulma extensions are reported for the user to remove, not deleted —
+ * see the note on that below.
+ * says so by name.
+ */
+
+import type { DependenciesUpdate } from '../../types.js';
+
+const BESTAX_RANGE = '^5';
+const BULMA_RANGE = '^1.0.4';
+// Bulma v1's sass tree uses `color.channel(…)` — needs dart-sass ≥ 1.79.
+const SASS_RANGE = '^1.79.0';
+
+/**
+ * The Bulma extensions rbx depends on directly. Bulma v1 and bestax cover all
+ * four: badge and tooltip became bestax components, the page loader became
+ * `Loading`, and the divider became `Divider`.
+ */
+const RBX_STYLE_DEPS = [
+  'bulma-badge',
+  'bulma-divider',
+  'bulma-pageloader',
+  'bulma-tooltip',
+] as const;
+
+const DEP_SECTIONS = ['dependencies', 'devDependencies'] as const;
+
+/**
+ * True only when `range` PROVABLY admits no version >= 1.0.0.
+ *
+ * The first version matched a leading `0` and nothing else, so a range written
+ * as comparators (`>=0.7 <1`) was left on 0.x and then reported as already v1.
+ * This walks each `||` alternative and its comparators: a set is pre-v1 when
+ * some comparator caps it below 1.0.0 and none of them opens it at 1 or above.
+ *
+ * Conservative by design: an unrecognised shape returns false and the range is
+ * left alone (and reported as such). Bumping a range that might already admit
+ * v1 would be the best-guess rewrite this package refuses to make.
+ */
+function isPreV1(range: string): boolean {
+  const alternatives = range.trim().split(/\s*\|\|\s*/);
+  return alternatives.length > 0 && alternatives.every(setIsPreV1);
+}
+
+function setIsPreV1(set: string): boolean {
+  // npm accepts whitespace between an operator and its version
+  // (`>= 0.7.0 < 1.0.0`); splitting on whitespace first made the operator a
+  // token of its own, so the range parsed as unrecognised and was left alone.
+  const text = glueOperators(set);
+  if (text === '' || /^(\*|x|X|latest)$/.test(text)) return false;
+  const hyphen = text.match(/^(\S+)\s+-\s+(\S+)$/);
+  if (hyphen) return majorOf(hyphen[2]) === 0;
+
+  let cappedBelowOne = false;
+  for (const token of text.split(/\s+/)) {
+    const match = token.match(/^(>=|<=|>|<|=)?\s*v?(.*)$/);
+    if (!match) return false;
+    const [, op = '', version] = match;
+    const major = majorOf(version);
+    if (major === null) return false;
+    switch (op) {
+      case '>':
+      case '>=':
+        if (major >= 1) return false;
+        break;
+      case '<':
+        // `<1`, `<1.0`, `<1.0.0` exclude every v1; `<0.9` does too.
+        if (major === 0 || (major === 1 && /^1(\.0)*$/.test(version))) {
+          cappedBelowOne = true;
+        } else {
+          return false;
+        }
+        break;
+      case '<=':
+        if (major === 0) cappedBelowOne = true;
+        else return false;
+        break;
+      default:
+        // `0.9.4`, `=0.9.4`, `^0.9`, `~0.7.5`, `0.x`: caret and tilde never
+        // cross a major, so major 0 stays below 1.
+        if (major === 0) cappedBelowOne = true;
+        else return false;
+    }
+  }
+  return cappedBelowOne;
+}
+
+function glueOperators(set: string): string {
+  return set.trim().replace(/(>=|<=|>|<|=)\s+/g, '$1');
+}
+
+/**
+ * True when every comparator in every alternative parses to a semver major,
+ * so the headline can tell "already v1" apart from "not a version range at
+ * all" (`latest`, a git URL) rather than calling both v1.
+ */
+function isRecognisedRange(range: string): boolean {
+  return range
+    .trim()
+    .split(/\s*\|\|\s*/)
+    .every(alt => {
+      const text = glueOperators(alt);
+      if (/^(\*|x|X)$/.test(text)) return true;
+      const hyphen = text.match(/^(\S+)\s+-\s+(\S+)$/);
+      if (hyphen) {
+        return majorOf(hyphen[1]) !== null && majorOf(hyphen[2]) !== null;
+      }
+      return text
+        .split(/\s+/)
+        .every(tok => majorOf(tok.replace(/^(>=|<=|>|<|=)/, '')) !== null);
+    });
+}
+
+function majorOf(version: string): number | null {
+  const m = version.replace(/^[~^=v]+/, '').match(/^(\d+)(?:\.|$)/);
+  return m ? Number(m[1]) : null;
+}
+
+export const updateDependencies: DependenciesUpdate = (
+  filePath,
+  pkg,
+  collector,
+  options
+) => {
+  const changes: string[] = [];
+  const next = pkg as Record<string, Record<string, string> | unknown>;
+  const section = (name: (typeof DEP_SECTIONS)[number]) =>
+    (next[name] ?? undefined) as Record<string, string> | undefined;
+
+  const note = (message: string) => {
+    changes.push(message);
+    collector?.add({ file: filePath, line: null, rule: 'deps', message });
+  };
+
+  // rbx goes away entirely.
+  const removed: string[] = [];
+  for (const name of DEP_SECTIONS) {
+    const deps = section(name);
+    if (deps && 'rbx' in deps) {
+      delete deps.rbx;
+      removed.push('rbx');
+      note(`removed rbx from ${name}`);
+    }
+  }
+
+  // The four Bulma extensions are REPORTED, not removed.
+  //
+  // rbx declares them as its own dependencies, so an app gets them
+  // transitively through the lockfile — they do not appear in the app's
+  // manifest unless the author put them there deliberately. A manifest entry
+  // is therefore a direct declaration, and an app may well be importing
+  // `bulma-tooltip`'s Sass on its own, outside anything rbx rendered.
+  // Deleting it because rbx happens to be present is precisely the
+  // best-guess rewrite this package refuses to make.
+  const extensions: string[] = [];
+  if (removed.includes('rbx')) {
+    for (const name of DEP_SECTIONS) {
+      const deps = section(name);
+      if (!deps) continue;
+      for (const extension of RBX_STYLE_DEPS) {
+        if (extension in deps) extensions.push(extension);
+      }
+    }
+  }
+  if (extensions.length > 0) {
+    collector?.add({
+      file: filePath,
+      line: null,
+      rule: 'deps',
+      message: `${extensions.join(', ')} ${extensions.length === 1 ? 'is a Bulma extension' : 'are Bulma extensions'} rbx depended on, and bestax ships ${extensions.length === 1 ? 'its' : 'their'} equivalent${extensions.length === 1 ? '' : 's'} (Badge, Divider, Loading, Tooltip). Declared in this manifest, so removing ${extensions.length === 1 ? 'it' : 'them'} is your call — drop ${extensions.length === 1 ? 'it' : 'them'} unless your own Sass imports ${extensions.length === 1 ? 'it' : 'them'} directly`,
+    });
+  }
+
+  // @allxsmith/bestax-bulma comes in (runtime dependency).
+  const dependencies = (next.dependencies ??= {}) as Record<string, string>;
+  if (
+    !dependencies['@allxsmith/bestax-bulma'] &&
+    !section('devDependencies')?.['@allxsmith/bestax-bulma']
+  ) {
+    dependencies['@allxsmith/bestax-bulma'] = BESTAX_RANGE;
+    note(`added @allxsmith/bestax-bulma ${BESTAX_RANGE} to dependencies`);
+  }
+
+  // Bulma: rbx pinned 0.7.5 as a direct dependency, so this almost always
+  // fires. Add it back only when sources still reference bulma/… directly —
+  // otherwise it arrives transitively via bestax-bulma.
+  let bulmaDeclared = false;
+  let declaredBulma = '';
+  let bulmaBumped = false;
+  let bulmaAdded = false;
+  for (const name of DEP_SECTIONS) {
+    const deps = section(name);
+    if (deps?.bulma) {
+      bulmaDeclared = true;
+      declaredBulma = deps.bulma;
+      if (isPreV1(deps.bulma)) {
+        deps.bulma = BULMA_RANGE;
+        bulmaBumped = true;
+        note(`bumped bulma to ${BULMA_RANGE} in ${name} (was pre-1.0)`);
+      }
+    }
+  }
+  if (!bulmaDeclared && options.bulmaReferenced) {
+    dependencies.bulma = BULMA_RANGE;
+    bulmaAdded = true;
+    note(
+      `added bulma ${BULMA_RANGE} to dependencies (sources import bulma/… directly)`
+    );
+  }
+
+  // The transform deliberately keeps a trimmed rbx import for components
+  // with no bestax equivalent (Tile, Generic, List, …) so a partially
+  // migrated app still runs. Removing the package from the manifest strands
+  // exactly those imports once the user runs the install the report asks for,
+  // so say so rather than letting them find out at build time.
+  if (removed.includes('rbx') && options.sourceStillImported) {
+    collector?.add({
+      file: filePath,
+      line: null,
+      rule: 'deps',
+      message:
+        'rbx was removed from package.json, but some files still import it for components with no bestax equivalent — resolve those `TODO(bestax-migrate)` imports before installing, or re-add rbx until you have',
+    });
+  }
+
+  // The headline result: rbx pinned Bulma 0.7.5 as a DIRECT dependency, so
+  // removing rbx is what frees the app to choose its own Bulma version.
+  //
+  // What it must NOT claim is a manifest change that did not happen. In the
+  // common rbx-app shape — `{ "dependencies": { "rbx": "^2.2.0" } }` with no
+  // direct `bulma/…` imports — bulma is neither bumped nor added, because it
+  // arrives transitively via bestax-bulma. Saying "bumped bulma" there
+  // described a pin the user would not find in their manifest.
+  if (removed.includes('rbx')) {
+    collector?.add({
+      file: filePath,
+      line: null,
+      rule: 'deps',
+      message: `removed rbx ${
+        bulmaBumped
+          ? `and bumped bulma to ${BULMA_RANGE}`
+          : bulmaAdded
+            ? `and added bulma ${BULMA_RANGE}`
+            : bulmaDeclared
+              ? isRecognisedRange(declaredBulma)
+                ? 'and left your declared bulma range alone (already v1)'
+                : `and left your declared bulma specifier alone (${JSON.stringify(declaredBulma)} is not a version range this tool can read; make sure it resolves to Bulma 1.x)`
+              : '— bulma now arrives transitively via @allxsmith/bestax-bulma'
+      } — rbx pinned Bulma 0.7.5 as a direct dependency, so the app can now choose its own Bulma version${extensions.length > 0 ? `; ${extensions.length} Bulma extension(s) are reported above for you to remove` : ''}`,
+    });
+  }
+
+  // bestax-bulma requires React 18/19; rbx peer-depends on ^16.8.6, and React
+  // 19 removed the `defaultProps` its forwardRefAs base is built on — so this
+  // is the other half of why an rbx app is stuck. Report only: a React major
+  // upgrade is the app's own migration step.
+  for (const name of DEP_SECTIONS) {
+    const range = section(name)?.react;
+    if (range && /^[~^]?(?:[0-9]|1[0-7])(?:[.x]|$)/.test(range.trim())) {
+      collector?.add({
+        file: filePath,
+        line: null,
+        rule: 'peer-deps',
+        message: `react ${range} predates bestax-bulma's peer range (^18 || ^19) — upgrade react and react-dom to 18 or 19 before installing`,
+      });
+    }
+  }
+
+  // Font Awesome older than 6 conflicts with bestax-bulma's optional peer
+  // range and makes `npm install` fail with ERESOLVE. Report only — icon
+  // names change across FA majors, so upgrading is the app's decision.
+  for (const name of DEP_SECTIONS) {
+    const range = section(name)?.['@fortawesome/fontawesome-free'];
+    if (range && /^[~^]?[0-5](?:[.x]|$)/.test(range.trim())) {
+      collector?.add({
+        file: filePath,
+        line: null,
+        rule: 'peer-deps',
+        message: `@fortawesome/fontawesome-free ${range} predates bestax-bulma's optional peer range (^6.7.2 || ^7.0.0) — upgrade it, or install with \`npm install --legacy-peer-deps\``,
+      });
+    }
+  }
+
+  // node-sass is dead; dart-sass replaces it in the same section. rbx's own
+  // customisation guide told people to install node-sass, so this is common.
+  for (const name of DEP_SECTIONS) {
+    const deps = section(name);
+    if (deps && 'node-sass' in deps) {
+      delete deps['node-sass'];
+      note(`removed node-sass from ${name}`);
+      const sassDeclared = DEP_SECTIONS.some(s => section(s)?.sass);
+      if (!sassDeclared) {
+        deps.sass = SASS_RANGE;
+        note(`added sass ${SASS_RANGE} to ${name} (replaces node-sass)`);
+      }
+    }
+  }
+
+  return changes.length > 0 ? (next as Record<string, unknown>) : null;
+};
diff --git a/bestax-migrate/src/sources/rbx/index.ts b/bestax-migrate/src/sources/rbx/index.ts
new file mode 100644
index 000000000..c8c3c38f8
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/index.ts
@@ -0,0 +1,12 @@
+import type { MigrationSource } from '../../types.js';
+import transform from './transform.js';
+import { transformStyles } from './styles.js';
+import { updateDependencies } from './deps.js';
+
+export const rbx: MigrationSource = {
+  name: 'rbx',
+  label: 'rbx (v2) → @allxsmith/bestax-bulma',
+  transform,
+  transformStyles,
+  updateDependencies,
+};
diff --git a/bestax-migrate/src/sources/rbx/mapping.ts b/bestax-migrate/src/sources/rbx/mapping.ts
new file mode 100644
index 000000000..d3465ff87
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/mapping.ts
@@ -0,0 +1,955 @@
+/**
+ * rbx (v2) → @allxsmith/bestax-bulma mapping tables.
+ *
+ * Data only — no AST work. `MAPPING` is the single source of truth for what
+ * the transform does with each rbx export; `RBX_EXPORTS` vendors rbx's public
+ * surface so `mapping-coverage.test.ts` can close it in both directions.
+ *
+ * rbx and bestax both target Bulma, and rbx's helper vocabulary lines up with
+ * `useBulmaClasses` far more closely than react-bulma-components' did — most
+ * of the value unions below are identical on both sides, so they pass through
+ * rather than being value-mapped. Where they diverge it is because Bulma v1
+ * itself changed (`is-marginless` became `m-0`), and those are recorded as
+ * explicit conversions rather than guesses.
+ */
+
+import type { ComponentMapping, PropAction } from '../../types.js';
+
+const DOCS = 'https://bestax.io/docs';
+
+/**
+ * rbx's `shades` union that bestax's `validColors` does not carry. Every other
+ * rbx colour and shade name exists in bestax verbatim.
+ */
+const SHADE_TODO = {
+  'white-ter': `\`white-ter\` is not a bestax colour; use \`white\` or a custom class (${DOCS}/api/helpers/usebulmaclasses)`,
+  'white-bis': `\`white-bis\` is not a bestax colour; use \`white\` or a custom class (${DOCS}/api/helpers/usebulmaclasses)`,
+};
+
+/** rbx sizes are numbers; every bestax size prop takes the string form. */
+const numeric: PropAction = { numberToString: true };
+
+/**
+ * `as` is universal in rbx — `forwardRefAs` puts it on every component — but
+ * bestax declares it on only ~16 components, several of them constrained to a
+ * narrow literal union (`Footer` is `'footer' | 'div'`). So the default is a
+ * TODO, and the components that really do accept `as` opt in with `AS_OK` in
+ * their own prop map, which runs first and wins.
+ */
+const FILE_PART_TODO = `bestax's \`<File>\` renders the whole file structure from its own props — drop this element and set \`label\`, \`hasName\`, \`isBoxed\` etc. on \`<File>\` (${DOCS}/api/form/file)`;
+
+const AS_TODO: PropAction = {
+  todo: `bestax declares \`as\` on only some components, and this is not one of them; restructure the element or render the tag directly (${DOCS}/api)`,
+};
+/**
+ * Components whose bestax counterpart really does accept `as`. An empty
+ * action passes the prop through untouched; its job is to claim the name so
+ * the universal `AS_TODO` never sees it.
+ *
+ * Several of these narrow `as` to a literal union (`Footer` is
+ * `'footer' | 'div'`, `Control` is `'div'`), so an `as={SomeComponent}` still
+ * surfaces — as a type error the user can see, rather than a silent rewrite.
+ */
+const AS_OK: PropAction = {};
+
+/**
+ * Helper props rbx mixes into every component via `HelpersProps`. Applied
+ * after each component's own prop map, to whatever attributes are left.
+ *
+ * `badge*`, `tooltip*` and `responsive` are deliberately absent: they are
+ * consumed structurally (see specials.ts / responsive.ts) before this pass
+ * runs, and letting them fall through here would be wrong — bestax has its
+ * own unrelated `responsive` prop (`'mobile' | 'narrow'`), so a pass-through
+ * would silently produce a type error rather than a TODO.
+ */
+export const UNIVERSAL_PROPS: Record<string, PropAction> = {
+  // --- typography: values are identical on both sides ---------------------
+  backgroundColor: { rename: 'bgColor', valueTodo: SHADE_TODO },
+  textColor: { valueTodo: SHADE_TODO },
+  textAlign: {}, // centered | justified | left | right — same union
+  textTransform: {}, // capitalized | lowercase | uppercase — bestax adds italic
+  textWeight: {}, // light | medium | normal | semibold | bold — same union
+  textSize: numeric, // rbx 1–7 as numbers, bestax as strings
+  italic: { booleanToProp: { name: 'textTransform', value: 'italic' } },
+
+  // --- float / overflow / overlay -----------------------------------------
+  clearfix: {},
+  pull: { rename: 'float' }, // left | right — same union
+  clipped: { booleanToProp: { name: 'overflow', value: 'clipped' } },
+  overlay: {}, // boolean on both sides
+
+  // --- visibility ----------------------------------------------------------
+  hidden: { booleanToProp: { name: 'visibility', value: 'hidden' } },
+  invisible: { booleanToProp: { name: 'visibility', value: 'invisible' } },
+  srOnly: { booleanToProp: { name: 'visibility', value: 'sr-only' } },
+
+  // --- Bulma v1 dropped the `is-*less` spacing helpers ---------------------
+  marginless: { booleanToProp: { name: 'm', value: '0' } },
+  paddingless: { booleanToProp: { name: 'p', value: '0' } },
+  radiusless: { booleanToProp: { name: 'radius', value: 'radiusless' } },
+  shadowless: { booleanToProp: { name: 'shadow', value: 'shadowless' } },
+  unselectable: {
+    booleanToProp: { name: 'interaction', value: 'unselectable' },
+  },
+  relative: {}, // boolean on both sides
+
+  // Per-component maps override this with AS_OK where bestax has an `as`.
+  as: AS_TODO,
+};
+
+/** rbx badge helper props → bestax `<Badge>` props. */
+export const BADGE_PROPS: Record<string, string | null> = {
+  badge: 'content',
+  badgeColor: 'color',
+  // bestax's Badge has no outline, pill or size variants.
+  badgeOutlined: null,
+  badgeRounded: null,
+  badgeSize: null,
+};
+
+/** rbx tooltip helper props → bestax `<Tooltip>` props. */
+export const TOOLTIP_PROPS: Record<string, string | null> = {
+  tooltip: 'label',
+  tooltipActive: 'active',
+  tooltipColor: 'color',
+  tooltipMultiline: 'multiline',
+  tooltipPosition: 'position',
+  // A breakpoint→position object; bestax has one position for all viewports.
+  tooltipResponsive: null,
+};
+
+/**
+ * rbx breakpoints → the suffix bestax uses on its viewport-aware helper props
+ * (`displayTablet`, `textSizeDesktop`, …). `null` means bestax has no
+ * equivalent viewport, so the value becomes a TODO rather than a guess.
+ */
+export const RESPONSIVE_BREAKPOINTS: Record<string, string | null> = {
+  mobile: 'Mobile',
+  tablet: 'Tablet',
+  desktop: 'Desktop',
+  widescreen: 'Widescreen',
+  fullhd: 'Fullhd',
+  // Bulma v1 keeps `is-hidden-touch`, but bestax's validViewports does not
+  // include it, so there is no prop to write.
+  touch: null,
+};
+
+export const MAPPING: Record<string, ComponentMapping> = {
+  // ---- base ---------------------------------------------------------------
+  Generic: {
+    status: 'todo',
+    todo: `\`Generic\` is rbx's untyped base element; render the underlying HTML tag directly, or use a bestax component (${DOCS}/api)`,
+  },
+  forwardRefAs: {
+    status: 'todo',
+    todo: '`forwardRefAs` is rbx-internal and has no counterpart. Only the bestax form controls and a few components (Dialog, Sidebar, Toast, Carousel) forward refs; most, Button and Box included, are plain function components that do not — put the ref on a wrapping element you control',
+  },
+
+  // ---- elements -----------------------------------------------------------
+  Block: { status: 'mapped', target: 'Block' },
+  Box: { status: 'mapped', target: 'Box' },
+  Button: {
+    status: 'mapped',
+    target: 'Button',
+    props: {
+      as: AS_OK,
+      color: {},
+      size: {},
+      outlined: { booleanToProp: { name: 'isOutlined' } },
+      rounded: { booleanToProp: { name: 'isRounded' } },
+      inverted: { booleanToProp: { name: 'isInverted' } },
+      fullwidth: { booleanToProp: { name: 'isFullwidth' } },
+      static: { booleanToProp: { name: 'isStatic' } },
+      state: {
+        valueMap: {
+          hovered: 'isHovered',
+          focused: 'isFocused',
+          active: 'isActive',
+          loading: 'isLoading',
+        },
+        valueToProp: true,
+      },
+      selected: {
+        todo: 'no bestax equivalent (Bulma is-selected in button groups)',
+      },
+      text: {
+        todo: `no bestax equivalent for the \`is-text\` button; use \`<Button color="ghost">\` or a link (${DOCS}/api/elements/button)`,
+      },
+    },
+    subs: {
+      Group: {
+        status: 'mapped',
+        target: 'Buttons',
+        props: {
+          hasAddons: {},
+          align: {
+            valueMap: { centered: 'isCentered', right: 'isRight' },
+            valueToProp: true,
+          },
+          size: {
+            todo: 'bestax `Buttons` has no size prop; set `size` on each Button instead',
+          },
+        },
+      },
+    },
+  },
+  Container: {
+    status: 'mapped',
+    target: 'Container',
+    props: {
+      fluid: {},
+      // bestax's ContainerBreakpoint is 'tablet' | 'desktop' | 'widescreen';
+      // rbx accepts all six, so the other three are type errors if passed on.
+      breakpoint: {
+        valueTodo: {
+          mobile:
+            "bestax's Container has no mobile breakpoint (Bulma containers start at tablet); drop it",
+          fullhd:
+            "bestax's Container breakpoint stops at widescreen; use `isMax` or a custom class for fullhd",
+          touch:
+            "bestax's Container has no touch breakpoint; drop it or use a custom class",
+        },
+      },
+    },
+  },
+  Content: {
+    status: 'mapped',
+    target: 'Content',
+    props: { size: {} },
+    subs: {
+      OrderedList: {
+        status: 'mapped',
+        target: 'OrderedList',
+        props: {
+          type: {
+            todo: 'bestax `OrderedList` has no `type` prop; set the `type` attribute on the underlying <ol> or a custom class',
+          },
+        },
+        subs: {
+          Item: { status: 'mapped', target: 'OrderedList.Item' },
+        },
+      },
+    },
+  },
+  Delete: { status: 'mapped', target: 'Delete', props: { size: {} } },
+  Divider: {
+    status: 'partial',
+    target: 'Divider',
+    special: 'divider',
+    props: {
+      color: {
+        todo: 'bestax `Divider` takes only `bgColor`; set that or a custom class',
+      },
+      vertical: {
+        todo: 'bestax `Divider` has no vertical variant; use a bordered Column or custom CSS',
+      },
+    },
+  },
+  Heading: { status: 'mapped', special: 'heading' },
+  Highlight: {
+    status: 'todo',
+    todo: `\`Highlight\` (syntax-highlighted <pre>) has no bestax equivalent; use \`<Pre>\` plus your own highlighter (${DOCS}/api/elements/pre)`,
+  },
+  Icon: { status: 'partial', target: 'Icon', special: 'icon' },
+  Image: {
+    status: 'mapped',
+    target: 'Image',
+    props: { as: AS_OK, rounded: { booleanToProp: { name: 'isRounded' } } },
+    subs: {
+      // rbx nests <Image> inside <Image.Container>; bestax's Image renders the
+      // figure itself, so the container collapses into it.
+      Container: { status: 'mapped', special: 'image-container' },
+    },
+  },
+  Notification: {
+    status: 'mapped',
+    target: 'Notification',
+    props: { color: {} },
+  },
+  Numeric: {
+    status: 'todo',
+    todo: '`Numeric` (locale number formatting) has no bestax equivalent; use Intl.NumberFormat directly',
+  },
+  // NOT `Loading`: rbx's Loader always renders `div.loader`, while bestax's
+  // Loading is an overlay that defaults `active` to false and returns null —
+  // so a direct map made every migrated loader disappear. Bulma's `.loader`
+  // is a plain element, and the react-bulma-components source already
+  // emits exactly that for its own `Loader`.
+  Loader: { status: 'mapped', special: 'loader' },
+  PageLoader: {
+    status: 'mapped',
+    target: 'Loading',
+    special: 'page-loader',
+    props: {
+      active: {},
+      color: {},
+      direction: {
+        todo: 'bestax `Loading` has no directional variant; drop it or add a custom class',
+      },
+    },
+  },
+  Progress: {
+    status: 'mapped',
+    target: 'Progress',
+    props: { color: {}, size: {}, max: {}, value: {} },
+  },
+  Table: {
+    status: 'mapped',
+    target: 'Table',
+    props: {
+      bordered: { booleanToProp: { name: 'isBordered' } },
+      striped: { booleanToProp: { name: 'isStriped' } },
+      narrow: { booleanToProp: { name: 'isNarrow' } },
+      hoverable: { booleanToProp: { name: 'isHoverable' } },
+      fullwidth: { booleanToProp: { name: 'isFullwidth' } },
+    },
+    subs: {
+      Body: { status: 'mapped', target: 'Table.Tbody' },
+      Cell: { status: 'mapped', target: 'Table.Td' },
+      Foot: { status: 'mapped', target: 'Table.Tfoot' },
+      Head: { status: 'mapped', target: 'Table.Thead' },
+      Heading: { status: 'mapped', target: 'Table.Th' },
+      Row: {
+        status: 'mapped',
+        target: 'Table.Tr',
+        props: {
+          selected: {
+            todo: 'bestax `Table.Tr` has no `selected` prop; add className="is-selected"',
+          },
+        },
+      },
+    },
+  },
+  Tag: {
+    status: 'mapped',
+    target: 'Tag',
+    props: {
+      color: {},
+      size: {},
+      rounded: { booleanToProp: { name: 'isRounded' } },
+      delete: { booleanToProp: { name: 'isDelete' } },
+    },
+    subs: {
+      Group: {
+        status: 'mapped',
+        target: 'Tags',
+        props: {
+          gapless: { booleanToProp: { name: 'hasAddons' } },
+          size: {
+            todo: 'bestax `Tags` has no size prop; set `size` on each Tag instead',
+          },
+        },
+      },
+    },
+  },
+  Title: { status: 'mapped', special: 'title', props: { as: AS_OK } },
+  Tile: {
+    status: 'todo',
+    todo: `Bulma v1 replaced tiles with the Grid/Cell components — see ${DOCS}/api/grid and the migration guide ${DOCS}/guides/getting-started/migration/bulma-0-9-to-1`,
+  },
+
+  // ---- form ---------------------------------------------------------------
+  Checkbox: { status: 'mapped', target: 'Checkbox' },
+  Control: {
+    status: 'mapped',
+    target: 'Control',
+    props: {
+      as: AS_OK,
+      size: {},
+      expanded: { booleanToProp: { name: 'isExpanded' } },
+      loading: { booleanToProp: { name: 'isLoading' } },
+      // rbx's iconLeft/iconRight are booleans; bestax's same-named props take
+      // an IconProps object, so they map onto the has* booleans instead.
+      iconLeft: { booleanToProp: { name: 'hasIconsLeft' } },
+      iconRight: { booleanToProp: { name: 'hasIconsRight' } },
+    },
+  },
+  Field: {
+    status: 'mapped',
+    target: 'Field',
+    special: 'field',
+    props: {
+      horizontal: {},
+      // rbx accepts `expanded` on the Field, but Bulma's `is-expanded` is a
+      // Control modifier and bestax follows Bulma: `FieldProps` has no such
+      // prop, so passing it through was a silent type error.
+      expanded: {
+        todo: 'bestax follows Bulma in putting `is-expanded` on the Control, not the Field; move this to the `<Control isExpanded>` inside it',
+      },
+      narrow: {},
+      align: {
+        todo: 'rbx\'s `align` on a Field is Bulma\'s grouped alignment; bestax\'s `grouped` takes it as its value — use `grouped="centered"` or `grouped="right"`',
+      },
+      kind: {
+        valueMap: { addons: 'hasAddons', group: 'grouped' },
+        valueToProp: true,
+      },
+      multiline: {},
+    },
+    subs: {
+      Label: { status: 'mapped', target: 'Field.Label', props: { size: {} } },
+      Body: { status: 'mapped', target: 'Field.Body' },
+    },
+  },
+  Fieldset: {
+    status: 'todo',
+    todo: 'bestax has no `Fieldset` component; render a plain <fieldset> (its `disabled` attribute works natively)',
+  },
+  File: {
+    status: 'mapped',
+    target: 'File',
+    props: {
+      color: {},
+      size: {},
+      boxed: { booleanToProp: { name: 'isBoxed' } },
+      fullwidth: { booleanToProp: { name: 'isFullwidth' } },
+      hasName: {},
+      align: {
+        valueMap: { centered: 'isCentered', right: 'isRight' },
+        valueToProp: true,
+      },
+    },
+    // bestax's `<File>` renders the whole Bulma file structure itself from
+    // props (`label`, `hasName`, `isBoxed`, …), so rbx's structural pieces
+    // have no counterpart to become. Collapsing them automatically would mean
+    // guessing which prop each one was standing in for.
+    subs: {
+      CTA: { status: 'todo', todo: FILE_PART_TODO },
+      Icon: { status: 'todo', todo: FILE_PART_TODO },
+      Input: { status: 'todo', todo: FILE_PART_TODO },
+      Label: { status: 'todo', todo: FILE_PART_TODO },
+      Name: { status: 'todo', todo: FILE_PART_TODO },
+    },
+  },
+  Help: { status: 'mapped', special: 'help' },
+  Input: {
+    status: 'mapped',
+    target: 'Input',
+    props: {
+      color: {},
+      size: {},
+      type: {},
+      readOnly: {},
+      rounded: { booleanToProp: { name: 'isRounded' } },
+      static: { booleanToProp: { name: 'isStatic' } },
+      state: {
+        valueMap: { focused: 'isFocused', hovered: 'isHovered' },
+        valueToProp: true,
+      },
+    },
+  },
+  Label: { status: 'mapped', special: 'label' },
+  Radio: { status: 'mapped', target: 'Radio' },
+  Select: {
+    status: 'mapped',
+    target: 'Select',
+    props: { size: {} },
+    subs: {
+      // rbx wraps <Select> in <Select.Container>; bestax's Select renders the
+      // wrapper itself.
+      Container: { status: 'mapped', special: 'select-container' },
+      Option: { status: 'mapped', special: 'plain-option' },
+    },
+  },
+  Textarea: {
+    status: 'mapped',
+    target: 'TextArea',
+    props: {
+      color: {},
+      size: {},
+      fixedSize: { booleanToProp: { name: 'hasFixedSize' } },
+      state: {
+        valueMap: { focused: 'isFocused', hovered: 'isHovered' },
+        valueToProp: true,
+      },
+    },
+  },
+
+  // ---- components ---------------------------------------------------------
+  Breadcrumb: {
+    status: 'mapped',
+    target: 'Breadcrumb',
+    props: {
+      // rbx's alignments and separators are already bestax's unions.
+      align: { rename: 'alignment' },
+      separator: {},
+      size: {},
+    },
+    subs: { Item: { status: 'mapped', special: 'breadcrumb-item' } },
+  },
+  Card: {
+    status: 'mapped',
+    target: 'Card',
+    subs: {
+      Content: { status: 'mapped', target: 'Card.Content' },
+      Image: { status: 'mapped', target: 'Card.Image' },
+      Header: {
+        status: 'mapped',
+        target: 'Card.Header',
+        subs: {
+          Title: {
+            status: 'mapped',
+            target: 'Card.Header.Title',
+            props: {
+              align: {
+                valueMap: { centered: 'centered' },
+                valueToProp: true,
+              },
+            },
+          },
+          Icon: { status: 'mapped', target: 'Card.Header.Icon' },
+        },
+      },
+      Footer: {
+        status: 'mapped',
+        target: 'Card.Footer',
+        subs: { Item: { status: 'mapped', target: 'Card.FooterItem' } },
+      },
+    },
+  },
+  Dropdown: {
+    status: 'partial',
+    target: 'Dropdown',
+    special: 'dropdown',
+    props: {
+      active: {},
+      hoverable: {},
+      up: {},
+      align: { valueMap: { right: 'right' }, valueToProp: true },
+      managed: {
+        todo: 'bestax `Dropdown` is uncontrolled by default; use `active` + `onActiveChange` for controlled behaviour',
+      },
+      innerRef: {
+        todo: 'this bestax component is a plain function component and forwards no ref; drop `innerRef`, or put the ref on a wrapping element you control',
+      },
+    },
+    subs: {
+      Container: { status: 'mapped', special: 'dropdown-container' },
+      Content: { status: 'mapped', special: 'dropdown-content' },
+      Menu: { status: 'mapped', special: 'dropdown-menu' },
+      Trigger: { status: 'mapped', special: 'dropdown-trigger' },
+      Item: {
+        status: 'mapped',
+        target: 'Dropdown.Item',
+        // `as` lives on DropdownItemProps ('a' | 'div' | 'button'), not on
+        // the Dropdown root.
+        props: { as: AS_OK, active: {}, onClick: {} },
+      },
+      Divider: { status: 'mapped', target: 'Dropdown.Divider' },
+      Context: {
+        status: 'todo',
+        todo: '`Dropdown.Context` is rbx-internal; bestax exposes `active`/`onActiveChange` on `<Dropdown>` instead',
+      },
+    },
+  },
+  Level: {
+    status: 'mapped',
+    target: 'Level',
+    props: {
+      breakpoint: {
+        valueMap: { mobile: 'isMobile' },
+        valueToProp: true,
+        valueTodo: {
+          tablet: 'bestax `Level` only supports the mobile breakpoint',
+          desktop: 'bestax `Level` only supports the mobile breakpoint',
+          widescreen: 'bestax `Level` only supports the mobile breakpoint',
+          fullhd: 'bestax `Level` only supports the mobile breakpoint',
+          touch: 'bestax `Level` only supports the mobile breakpoint',
+        },
+      },
+    },
+    subs: {
+      Item: { status: 'mapped', special: 'level-item', props: { as: AS_OK } },
+    },
+  },
+  List: {
+    status: 'todo',
+    todo: `rbx's \`List\` is the bulma-list extension, which Bulma v1 does not ship; use \`<UnorderedList>\` or \`<Menu>\` (${DOCS}/api/elements/unorderedlist)`,
+    subs: {
+      Item: {
+        status: 'todo',
+        todo: `rbx's \`List.Item\` is the bulma-list extension, which Bulma v1 does not ship; use \`<UnorderedList.Item>\` or \`<Menu.Item>\` (${DOCS}/api/elements/unorderedlist)`,
+      },
+    },
+  },
+  Media: {
+    status: 'mapped',
+    target: 'Media',
+    props: { as: AS_OK },
+    subs: {
+      // `as` is NOT opted in here: Media.Item resolves to Media.Left,
+      // Media.Content or Media.Right by its `align` value, and only
+      // MediaLeftProps declares `as`. The special decides per target.
+      Item: { status: 'mapped', special: 'media-item' },
+    },
+  },
+  Menu: {
+    status: 'mapped',
+    target: 'Menu',
+    subs: {
+      Label: { status: 'mapped', target: 'Menu.Label' },
+      List: {
+        status: 'mapped',
+        target: 'Menu.List',
+        subs: {
+          Item: {
+            status: 'mapped',
+            target: 'Menu.Item',
+            props: {
+              as: AS_OK,
+              active: {},
+              menu: {
+                todo: 'bestax `Menu.Item` has no `menu` prop; nest a `<Menu.List>` as a child instead',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  Message: {
+    status: 'mapped',
+    target: 'Message',
+    props: {
+      color: {},
+      size: {
+        todo: 'bestax `Message` has no size prop; use the `size` helper on its children',
+      },
+    },
+    subs: {
+      Body: { status: 'mapped', target: 'Message.Body' },
+      Header: { status: 'mapped', target: 'Message.Header' },
+    },
+  },
+  Modal: {
+    status: 'partial',
+    target: 'Modal',
+    special: 'modal',
+    props: {
+      active: {},
+      onClose: {},
+      closeOnEsc: {
+        todo: 'bestax `Modal` implements no Escape handling at all; add your own keydown listener, or drop the prop if the behaviour is not needed',
+      },
+      closeOnBlur: {
+        todo: "bestax `Modal` has no built-in background-click close; wire it through `Modal.Background`'s onClick and `onClose`",
+      },
+      document: {
+        todo: 'bestax `Modal` renders inline where you place it rather than portalling into a document at all; drop this prop, and see the advisory the codemod adds on every Modal',
+      },
+      containerClassName: { rename: 'className' },
+      innerRef: {
+        todo: 'this bestax component is a plain function component and forwards no ref; drop `innerRef`, or put the ref on a wrapping element you control',
+      },
+    },
+    subs: {
+      Background: { status: 'mapped', target: 'Modal.Background' },
+      Close: { status: 'mapped', target: 'Modal.Close' },
+      Content: { status: 'mapped', target: 'Modal.Content' },
+      Container: { status: 'mapped', special: 'modal-container' },
+      Card: {
+        status: 'mapped',
+        target: 'Modal.Card',
+        subs: {
+          Body: { status: 'mapped', target: 'Modal.Card.Body' },
+          Foot: { status: 'mapped', target: 'Modal.Card.Foot' },
+          Head: { status: 'mapped', target: 'Modal.Card.Head' },
+          Title: { status: 'mapped', target: 'Modal.Card.Title' },
+        },
+      },
+      Context: {
+        status: 'todo',
+        todo: '`Modal.Context` is rbx-internal; bestax exposes `active`/`onClose` on `<Modal>` instead',
+      },
+      Portal: {
+        status: 'todo',
+        todo: '`Modal.Portal` is rbx-internal; bestax `<Modal>` renders inline and does not portal at all — wrap it in `createPortal` yourself if you relied on that (see the advisory the codemod adds on every Modal)',
+      },
+    },
+  },
+  Navbar: {
+    status: 'mapped',
+    target: 'Navbar',
+    props: {
+      color: {},
+      fixed: {},
+      transparent: {},
+      active: {
+        todo: 'bestax `Navbar` manages burger state itself; drop `active` or control the burger directly',
+      },
+      managed: {
+        todo: 'bestax `Navbar` is uncontrolled; drop `managed`',
+      },
+      document: { todo: 'bestax `Navbar` has no `document` prop; drop it' },
+      innerRef: {
+        todo: 'this bestax component is a plain function component and forwards no ref; drop `innerRef`, or put the ref on a wrapping element you control',
+      },
+    },
+    subs: {
+      Brand: { status: 'mapped', target: 'Navbar.Brand' },
+      Burger: { status: 'mapped', target: 'Navbar.Burger' },
+      Divider: { status: 'mapped', target: 'Navbar.Divider' },
+      Menu: { status: 'mapped', target: 'Navbar.Menu' },
+      Link: {
+        status: 'mapped',
+        target: 'Navbar.Link',
+        props: {
+          as: AS_OK,
+          arrowless: {},
+          onClick: {},
+        },
+      },
+      Item: {
+        status: 'mapped',
+        special: 'navbar-item',
+        props: { active: {}, onClick: {}, as: AS_OK },
+        subs: { Container: { status: 'mapped', special: 'navbar-container' } },
+      },
+      Dropdown: { status: 'mapped', special: 'navbar-dropdown' },
+      Segment: { status: 'mapped', special: 'navbar-segment' },
+      Container: { status: 'mapped', special: 'navbar-container' },
+      Context: {
+        status: 'todo',
+        todo: '`Navbar.Context` is rbx-internal; bestax `<Navbar>` manages its own state',
+      },
+    },
+  },
+  Pagination: {
+    status: 'mapped',
+    target: 'Pagination',
+    props: {
+      align: {},
+      size: {},
+      rounded: {},
+    },
+    subs: {
+      Link: { status: 'mapped', target: 'Pagination.Link' },
+      List: { status: 'mapped', target: 'Pagination.List' },
+      Ellipsis: { status: 'mapped', target: 'Pagination.Ellipsis' },
+      Step: { status: 'mapped', special: 'pagination-step' },
+    },
+  },
+  Panel: {
+    status: 'mapped',
+    target: 'Panel',
+    props: { color: {} },
+    subs: {
+      Heading: { status: 'mapped', target: 'Panel.Heading' },
+      Block: { status: 'mapped', target: 'Panel.Block', props: { active: {} } },
+      Icon: { status: 'partial', target: 'Panel.Icon', special: 'icon' },
+      Tab: {
+        status: 'mapped',
+        special: 'panel-tab',
+        subs: { Group: { status: 'mapped', target: 'Panel.Tabs' } },
+      },
+    },
+  },
+  Tab: {
+    // bestax's `Tabs.Tab` is the controlled API and requires an `index` that
+    // cannot be derived from rbx's markup; `Tabs.Item` is the plain <li> that
+    // rbx's `Tab` actually is.
+    status: 'mapped',
+    target: 'Tabs.Item',
+    props: { active: {} },
+    subs: {
+      Group: {
+        status: 'mapped',
+        special: 'tab-group',
+        target: 'Tabs',
+        props: {
+          align: {},
+          size: {},
+          fullwidth: { booleanToProp: { name: 'isFullwidth' } },
+          kind: {
+            valueMap: {
+              boxed: 'boxed',
+              toggle: 'toggle',
+              'toggle-rounded': 'toggle rounded',
+            },
+            valueToProp: true,
+          },
+        },
+      },
+    },
+  },
+
+  // ---- grid ---------------------------------------------------------------
+  Column: {
+    status: 'mapped',
+    target: 'Column',
+    special: 'column',
+    props: {
+      // bestax's BulmaColumnSize accepts numbers as well as the named
+      // strings, so rbx's numeric sizes carry over untouched.
+      size: {},
+      offset: {},
+      narrow: { booleanToProp: { name: 'isNarrow' } },
+    },
+    subs: {
+      Group: {
+        status: 'mapped',
+        target: 'Columns',
+        special: 'column-group',
+        props: {
+          centered: { booleanToProp: { name: 'isCentered' } },
+          gapless: { booleanToProp: { name: 'isGapless' } },
+          multiline: { booleanToProp: { name: 'isMultiline' } },
+          vcentered: { booleanToProp: { name: 'isVCentered' } },
+          // bestax's `gapSize*` props are deprecated aliases of `gap*`, and
+          // both take the same numeric 0-8 scale — so this is a rename, not
+          // a value conversion.
+          gapSize: { rename: 'gap' },
+          breakpoint: {
+            valueMap: { mobile: 'isMobile', desktop: 'isDesktop' },
+            valueToProp: true,
+            valueTodo: {
+              tablet:
+                'bestax `Columns` supports only the mobile and desktop breakpoints',
+              widescreen:
+                'bestax `Columns` supports only the mobile and desktop breakpoints',
+              fullhd:
+                'bestax `Columns` supports only the mobile and desktop breakpoints',
+              touch:
+                'bestax `Columns` supports only the mobile and desktop breakpoints',
+            },
+          },
+        },
+      },
+    },
+  },
+
+  // ---- layout -------------------------------------------------------------
+  Footer: { status: 'mapped', target: 'Footer', props: { as: AS_OK } },
+  Hero: {
+    status: 'mapped',
+    target: 'Hero',
+    props: {
+      color: {},
+      size: {
+        valueTodo: {
+          'fullheight-with-navbar':
+            'set `size="fullheight"` plus `fullheightWithNavbar` on the bestax Hero',
+        },
+      },
+      gradient: {
+        todo: 'bestax `Hero` has no gradient variant; add a custom class or `bgColor`',
+      },
+    },
+    subs: {
+      Body: { status: 'mapped', target: 'Hero.Body' },
+      Foot: { status: 'mapped', target: 'Hero.Foot' },
+      Head: { status: 'mapped', target: 'Hero.Head' },
+    },
+  },
+  Section: { status: 'mapped', target: 'Section', props: { size: {} } },
+};
+
+/**
+ * rbx's public export surface, vendored from its five `index.ts` barrels at
+ * the pinned SHA. Values are the dot-notation sub-paths each export carries.
+ *
+ * `mapping-coverage.test.ts` walks this against `MAPPING` in both directions,
+ * so rbx coverage cannot silently regress and `MAPPING` cannot grow an entry
+ * for something rbx never exported.
+ */
+export const RBX_EXPORTS: Record<string, string[]> = {
+  Block: [],
+  Box: [],
+  Breadcrumb: ['Item'],
+  Button: ['Group'],
+  Card: [
+    'Content',
+    'Footer',
+    'Footer.Item',
+    'Header',
+    'Header.Icon',
+    'Header.Title',
+    'Image',
+  ],
+  Checkbox: [],
+  Column: ['Group'],
+  Container: [],
+  Content: ['OrderedList', 'OrderedList.Item'],
+  Control: [],
+  Delete: [],
+  Divider: [],
+  Dropdown: [
+    'Container',
+    'Content',
+    'Context',
+    'Divider',
+    'Item',
+    'Menu',
+    'Trigger',
+  ],
+  Field: ['Body', 'Label'],
+  Fieldset: [],
+  File: ['CTA', 'Icon', 'Input', 'Label', 'Name'],
+  Footer: [],
+  Generic: [],
+  Heading: [],
+  Help: [],
+  Hero: ['Body', 'Foot', 'Head'],
+  Highlight: [],
+  Icon: [],
+  Image: ['Container'],
+  Input: [],
+  Label: [],
+  Level: ['Item'],
+  List: ['Item'],
+  Loader: [],
+  Media: ['Item'],
+  Menu: ['Label', 'List', 'List.Item'],
+  Message: ['Body', 'Header'],
+  Modal: [
+    'Background',
+    'Card',
+    'Card.Body',
+    'Card.Foot',
+    'Card.Head',
+    'Card.Title',
+    'Close',
+    'Container',
+    'Content',
+    'Context',
+    'Portal',
+  ],
+  Navbar: [
+    'Brand',
+    'Burger',
+    'Container',
+    'Context',
+    'Divider',
+    'Dropdown',
+    'Item',
+    'Item.Container',
+    'Link',
+    'Menu',
+    'Segment',
+  ],
+  Notification: [],
+  Numeric: [],
+  PageLoader: [],
+  Pagination: ['Ellipsis', 'Link', 'List', 'Step'],
+  Panel: ['Block', 'Heading', 'Icon', 'Tab', 'Tab.Group'],
+  Progress: [],
+  Radio: [],
+  Section: [],
+  Select: ['Container', 'Option'],
+  Tab: ['Group'],
+  Table: ['Body', 'Cell', 'Foot', 'Head', 'Heading', 'Row'],
+  Tag: ['Group'],
+  Textarea: [],
+  Tile: [],
+  Title: [],
+  forwardRefAs: [],
+};
+
+/** Walk a dotted component path through `MAPPING`. */
+export function resolveMapping(path: string[]): ComponentMapping | undefined {
+  let current: ComponentMapping | undefined = MAPPING[path[0]];
+  for (const segment of path.slice(1)) {
+    current = current?.subs?.[segment];
+  }
+  return current;
+}
diff --git a/bestax-migrate/src/sources/rbx/responsive.ts b/bestax-migrate/src/sources/rbx/responsive.ts
new file mode 100644
index 000000000..1a686f7dd
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/responsive.ts
@@ -0,0 +1,398 @@
+/**
+ * Flattens rbx's breakpoint objects into bestax-bulma's flat per-viewport
+ * props. rbx has three distinct shapes and this module handles all of them:
+ *
+ *   1. the universal `responsive` helper prop, nested two levels deep —
+ *      breakpoint → helper → `{ value, only }`:
+ *        <Generic responsive={{ tablet: { display: { value: "flex" } } }} />
+ *          → displayTablet="flex"
+ *   2. Column's per-breakpoint sizing props:
+ *        <Column tablet={{ size: 6, narrow: true }} />
+ *          → sizeTablet={6} isNarrowTablet
+ *   3. Column.Group's per-breakpoint gap prop:
+ *        <Column.Group tablet={{ gapSize: 4 }} />
+ *          → gapTablet={4}
+ *
+ * `touch` has no bestax viewport and `only` has no `-only` prop, so both get a
+ * TODO rather than a guess. Non-object or dynamic values get a TODO too.
+ *
+ * rbx's value unions for display/textAlign/textSize are identical to bestax's,
+ * so unlike the react-bulma-components flattener there is no value mapping
+ * here — only the shape changes.
+ */
+
+import type { ASTPath } from 'jscodeshift';
+import { RESPONSIVE_BREAKPOINTS } from './mapping.js';
+import {
+  addAttr,
+  addTodo,
+  attributesOf,
+  makeAttr,
+  removeAttr,
+  type TransformContext,
+} from '../_shared/jsx-utils.js';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export type ResponsiveKind = 'generic' | 'column' | 'column-group';
+
+/** Which specials opt their element into the extra breakpoint shapes. */
+export const RESPONSIVE_KINDS: Record<string, ResponsiveKind> = {
+  column: 'column',
+  'column-group': 'column-group',
+};
+
+function literalOf(node: any): string | number | boolean | undefined {
+  if (!node) return undefined;
+  if (node.type === 'StringLiteral') return node.value;
+  if (node.type === 'NumericLiteral') return node.value;
+  if (node.type === 'BooleanLiteral') return node.value;
+  return undefined;
+}
+
+/**
+ * Reuse a value node as a JSX attribute value: a string literal can sit bare
+ * (`size="one-third"`), anything else needs an expression container.
+ */
+function attrValue(j: any, node: any): any {
+  return node?.type === 'StringLiteral'
+    ? j.stringLiteral(node.value)
+    : j.jsxExpressionContainer(node);
+}
+
+function propKey(prop: any): string | undefined {
+  const key = prop.key?.name ?? prop.key?.value;
+  return typeof key === 'string' ? key : undefined;
+}
+
+function objectExpressionOf(value: any): any | null {
+  return value?.type === 'JSXExpressionContainer' &&
+    value.expression?.type === 'ObjectExpression'
+    ? value.expression
+    : null;
+}
+
+/**
+ * One `{ value, only }` cell of the universal `responsive` prop. Returns the
+ * inner `value` node, or undefined when the cell isn't the expected shape.
+ * `only: true` is reported as a TODO by the caller.
+ */
+function readCell(
+  cell: any
+): { value: any; only: boolean | 'dynamic' } | undefined {
+  const obj =
+    cell?.type === 'ObjectExpression'
+      ? cell
+      : cell?.type === 'JSXExpressionContainer' &&
+          cell.expression?.type === 'ObjectExpression'
+        ? cell.expression
+        : null;
+  if (!obj) return undefined;
+  let value: any;
+  let only: boolean | 'dynamic' = false;
+  for (const prop of obj.properties) {
+    const key = propKey(prop);
+    if (key === 'value') {
+      value = prop.value;
+    } else if (key === 'only') {
+      // A dynamic `only` is a third state, not `false`: collapsing it to
+      // false silently converted `{ value: 'flex', only: cond }` into an
+      // unconditional `displayTablet="flex"`, dropping the conditional
+      // `-only` behaviour with no TODO.
+      const literal = literalOf(prop.value);
+      only = typeof literal === 'boolean' ? literal : 'dynamic';
+    }
+  }
+  return value === undefined ? undefined : { value, only };
+}
+
+/**
+ * Pass 1 — the universal `responsive={{ <breakpoint>: { … } }}` prop.
+ *
+ * The whole prop always goes, even when some cells could not be converted.
+ * bestax has an unrelated `responsive` prop (`'mobile' | 'narrow'`), so a
+ * partially-emptied rbx object left behind is not a harmless leftover — it is
+ * a guaranteed type error on every migrated component. Each cell that could
+ * not be carried over gets its own TODO naming it, which is where that
+ * information belongs.
+ */
+function flattenResponsiveHelper(
+  ctx: TransformContext,
+  path: ASTPath<any>,
+  element: any
+): void {
+  const { j } = ctx;
+  const attr = attributesOf(element).find(
+    (a: any) => a.name.name === 'responsive'
+  );
+  if (!attr) return;
+
+  const objectExpr = objectExpressionOf(attr.value);
+  if (!objectExpr) {
+    // Still remove it. bestax's `responsive` is an unrelated string union
+    // (`'mobile' | 'narrow'`), so leaving a dynamic rbx value behind is a
+    // guaranteed type error, not a leftover — the same contract the
+    // convertible path keeps.
+    addTodo(
+      ctx,
+      path,
+      'responsive',
+      'dropped the `responsive` prop: it must be an inline object literal to flatten to bestax per-viewport props, and bestax has its own unrelated `responsive` prop, so it could not be left in place — reapply it by hand'
+    );
+    removeAttr(element, attr);
+    ctx.dirty = true;
+    return;
+  }
+
+  const remainingBreakpoints: string[] = [];
+  for (const bpProp of objectExpr.properties) {
+    const breakpoint = propKey(bpProp);
+    if (breakpoint === undefined || !(breakpoint in RESPONSIVE_BREAKPOINTS)) {
+      remainingBreakpoints.push(String(breakpoint));
+      addTodo(
+        ctx,
+        path,
+        'responsive',
+        `\`responsive.${String(breakpoint)}\` is not a breakpoint bestax knows; convert it by hand`
+      );
+      continue;
+    }
+
+    const suffix = RESPONSIVE_BREAKPOINTS[breakpoint];
+    if (suffix === null) {
+      remainingBreakpoints.push(breakpoint);
+      addTodo(
+        ctx,
+        path,
+        'responsive',
+        `no bestax-bulma helper variants for the \`${breakpoint}\` breakpoint; restyle with CSS or drop it`
+      );
+      continue;
+    }
+
+    const cells = objectExpressionOf(bpProp.value) ?? bpProp.value;
+    if (cells?.type !== 'ObjectExpression') {
+      remainingBreakpoints.push(breakpoint);
+      addTodo(
+        ctx,
+        path,
+        'responsive',
+        `\`responsive.${breakpoint}\` must be an inline object literal to flatten; convert it by hand`
+      );
+      continue;
+    }
+
+    const remainingCells: any[] = [];
+    for (const cellProp of cells.properties) {
+      const helper = propKey(cellProp);
+      const cell = readCell(cellProp.value);
+      if (!helper || !cell) {
+        remainingCells.push(cellProp);
+        addTodo(
+          ctx,
+          path,
+          'responsive',
+          `\`responsive.${breakpoint}.${String(helper)}\` is not the \`{ value }\` shape rbx documents; convert it by hand`
+        );
+        continue;
+      }
+      if (cell.only) {
+        remainingCells.push(cellProp);
+        addTodo(
+          ctx,
+          path,
+          'responsive',
+          cell.only === 'dynamic'
+            ? `\`responsive.${breakpoint}.${helper}.only\` has a dynamic value; Bulma's \`-only\` classes have no bestax prop, so apply it with className by hand`
+            : `\`responsive.${breakpoint}.${helper}.only\` (Bulma's \`-only\` classes) has no bestax prop; use className`
+        );
+        continue;
+      }
+
+      const literal = literalOf(cell.value);
+      if (helper === 'hide') {
+        if (literal === true) {
+          addAttr(element, makeAttr(j, `visibility${suffix}`, 'hidden'));
+        } else if (literal !== false) {
+          remainingCells.push(cellProp);
+          addTodo(
+            ctx,
+            path,
+            'responsive',
+            `\`responsive.${breakpoint}.hide\` has a dynamic value; set \`visibility${suffix}="hidden"\` conditionally by hand`
+          );
+          continue;
+        }
+        // hide: { value: false } is a no-op — drop it.
+      } else if (helper === 'display' || helper === 'textAlign') {
+        // rbx's displays and textAlignments are bestax's unions verbatim.
+        if (typeof literal === 'string') {
+          addAttr(element, makeAttr(j, `${helper}${suffix}`, literal));
+        } else {
+          remainingCells.push(cellProp);
+          addTodo(
+            ctx,
+            path,
+            'responsive',
+            `\`responsive.${breakpoint}.${helper}\` has a dynamic value; set \`${helper}${suffix}\` by hand`
+          );
+          continue;
+        }
+      } else if (helper === 'textSize') {
+        if (literal !== undefined && typeof literal !== 'boolean') {
+          // bestax text sizes are strings; rbx's are numbers.
+          addAttr(element, makeAttr(j, `textSize${suffix}`, String(literal)));
+        } else {
+          remainingCells.push(cellProp);
+          addTodo(
+            ctx,
+            path,
+            'responsive',
+            `\`responsive.${breakpoint}.textSize\` has a dynamic value; set \`textSize${suffix}\` by hand`
+          );
+          continue;
+        }
+      } else {
+        remainingCells.push(cellProp);
+        addTodo(
+          ctx,
+          path,
+          'responsive',
+          `\`responsive.${breakpoint}.${helper}\` could not be flattened to a bestax per-viewport prop`
+        );
+        continue;
+      }
+    }
+
+    if (remainingCells.length > 0) {
+      remainingBreakpoints.push(breakpoint);
+    }
+  }
+
+  if (remainingBreakpoints.length > 0) {
+    addTodo(
+      ctx,
+      path,
+      'responsive',
+      `dropped the \`responsive\` prop; the ${remainingBreakpoints
+        .map(b => `\`${b}\``)
+        .join(
+          ', '
+        )} settings above could not be converted and bestax's own \`responsive\` prop is unrelated (\`'mobile' | 'narrow'\`)`
+    );
+  }
+  removeAttr(element, attr);
+  ctx.dirty = true;
+}
+
+/**
+ * Pass 2 — Column / Column.Group per-breakpoint props, which sit directly on
+ * the element (`<Column tablet={{ size: 6 }} />`) rather than under
+ * `responsive`.
+ */
+function flattenColumnBreakpoints(
+  ctx: TransformContext,
+  path: ASTPath<any>,
+  element: any,
+  kind: 'column' | 'column-group'
+): void {
+  const { j } = ctx;
+  for (const attr of [...attributesOf(element)]) {
+    const name: string = attr.name.name;
+    if (!(name in RESPONSIVE_BREAKPOINTS)) continue;
+
+    // bestax's viewport-suffixed helper props have no `touch` variant — but
+    // Column is the one exception: `isNarrowTouch` does exist. So the column
+    // pass resolves `touch` itself rather than taking the shared table's
+    // `null`, and only the keys that genuinely have no counterpart
+    // (`sizeTouch`, `offsetTouch`, `gapTouch`) become TODOs.
+    const suffix = name === 'touch' ? 'Touch' : RESPONSIVE_BREAKPOINTS[name];
+    const touchOnlyNarrow = name === 'touch';
+
+    const objectExpr = objectExpressionOf(attr.value);
+    if (suffix === null || !objectExpr) {
+      // Nothing can be salvaged from this attribute, and leaving it behind is
+      // not harmless: `ColumnProps` spreads unrecognised props onto the
+      // `<div>`, so a leftover is both a TS excess-property error and a React
+      // unknown-attribute warning. Drop it and say so — the same contract
+      // `flattenResponsiveHelper` keeps.
+      addTodo(
+        ctx,
+        path,
+        'responsive',
+        objectExpr
+          ? `dropped \`${name}\`: bestax has no column variants for the \`${name}\` breakpoint — restyle with CSS`
+          : `dropped \`${name}\`: it must be an inline object literal to flatten to bestax per-viewport props — convert it by hand`
+      );
+      removeAttr(element, attr);
+      ctx.dirty = true;
+      continue;
+    }
+
+    const unconverted: string[] = [];
+    for (const prop of objectExpr.properties) {
+      const key = propKey(prop);
+      const literal = literalOf(prop.value);
+
+      if (
+        kind === 'column' &&
+        (key === 'size' || key === 'offset') &&
+        !touchOnlyNarrow
+      ) {
+        // Column sizes take numbers and named strings alike; reuse the node.
+        addAttr(
+          element,
+          j.jsxAttribute(
+            j.jsxIdentifier(`${key}${suffix}`),
+            attrValue(j, prop.value)
+          )
+        );
+      } else if (kind === 'column' && key === 'narrow') {
+        if (literal === true) {
+          addAttr(element, makeAttr(j, `isNarrow${suffix}`));
+        } else if (literal !== false) {
+          unconverted.push(`${key} (dynamic value)`);
+        }
+      } else if (
+        kind === 'column-group' &&
+        key === 'gapSize' &&
+        !touchOnlyNarrow
+      ) {
+        // bestax `gap*` supersedes the deprecated `gapSize*`, same 0-8 scale.
+        addAttr(
+          element,
+          j.jsxAttribute(
+            j.jsxIdentifier(`gap${suffix}`),
+            attrValue(j, prop.value)
+          )
+        );
+      } else {
+        unconverted.push(String(key));
+      }
+    }
+
+    if (unconverted.length > 0) {
+      addTodo(
+        ctx,
+        path,
+        'responsive',
+        `dropped \`${name}.${unconverted.join('`, `' + name + '.')}\`: no bestax per-viewport equivalent — set it by hand`
+      );
+    }
+    removeAttr(element, attr);
+    ctx.dirty = true;
+  }
+}
+
+/** Run every breakpoint pass that applies to this element. */
+export function flattenResponsiveProps(
+  ctx: TransformContext,
+  path: ASTPath<any>,
+  element: any,
+  kind: ResponsiveKind
+): void {
+  flattenResponsiveHelper(ctx, path, element);
+  if (kind === 'column' || kind === 'column-group') {
+    flattenColumnBreakpoints(ctx, path, element, kind);
+  }
+}
diff --git a/bestax-migrate/src/sources/rbx/specials.ts b/bestax-migrate/src/sources/rbx/specials.ts
new file mode 100644
index 000000000..7b8ef0874
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/specials.ts
@@ -0,0 +1,1025 @@
+/**
+ * Structural handlers for rbx → bestax conversions a rename table cannot
+ * express: targets chosen by a prop's value (Level.Item align, Pagination.Step
+ * align), container collapsing (Select.Container, Image.Container,
+ * Modal.Container), and replacement with plain HTML where bestax has no
+ * component (Heading, Help, Label, Select.Option).
+ *
+ * The two genuinely new families relative to react-bulma-components are here
+ * too, though they are driven from transform.ts rather than the mapping table
+ * because they are helper *props* that can sit on any element at all:
+ * `badge*` and `tooltip*` become wrapping bestax components.
+ *
+ * A handler may return a `target` override for the rename step, or mark the
+ * element `replaced` when it substituted the node itself.
+ */
+
+import type { ASTPath } from 'jscodeshift';
+import {
+  BADGE_PROPS,
+  RESPONSIVE_BREAKPOINTS,
+  TOOLTIP_PROPS,
+  UNIVERSAL_PROPS,
+} from './mapping.js';
+import {
+  addAttr,
+  addTodo,
+  buildJsxName,
+  attributesOf,
+  findAttr,
+  jsxNameParts,
+  literalValueOf,
+  makeAttr,
+  plainElement,
+  removeAttr,
+  resolveBooleanish,
+  type TransformContext,
+} from '../_shared/jsx-utils.js';
+import {
+  alignTarget,
+  makeStripModifierProps,
+  mergeClassName,
+  parseIconClasses,
+  type SpecialHandler,
+  type SpecialResult,
+} from '../_shared/specials-utils.js';
+
+export type { SpecialResult };
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+const stripModifierProps = makeStripModifierProps(
+  UNIVERSAL_PROPS,
+  RESPONSIVE_BREAKPOINTS
+);
+
+/**
+ * Turn a literal modifier prop into an `is-*` class fragment for an element
+ * on its way to becoming plain HTML. Returns the class (or undefined) and
+ * always removes the attribute.
+ */
+function modifierClass(
+  ctx: TransformContext,
+  path: ASTPath<any>,
+  element: any,
+  prop: string,
+  base: string,
+  where: string
+): string {
+  const attr = findAttr(element, prop);
+  if (!attr) return base;
+  const literal = literalValueOf(attr);
+  removeAttr(element, attr);
+  if (literal.kind === 'string' || literal.kind === 'number') {
+    return `${base} is-${literal.value}`;
+  }
+  addTodo(
+    ctx,
+    path,
+    `prop:${prop}`,
+    `dynamic ${where} \`${prop}\`; add the matching is-* class by hand`
+  );
+  return base;
+}
+
+/**
+ * Also strips the universal `responsive` object: responsive.ts would have
+ * consumed it, but a `replaced: true` special skips that pass too, and it is
+ * deliberately absent from UNIVERSAL_PROPS so stripModifierProps misses it.
+ * Left behind it is an object literal on an intrinsic element — which does
+ * not compile, unlike the badge/tooltip case which merely warns.
+ *
+ * rbx's badge/tooltip helper props become wrapping components in
+ * transform.ts, but that pass runs after the rename step — which a
+ * `replaced: true` special skips. So a plain-element rewrite has to account
+ * for them itself, or they ride onto the HTML tag as unknown DOM attributes.
+ */
+function stripHelperComponentProps(
+  ctx: TransformContext,
+  path: ASTPath<any>,
+  attrs: any[],
+  where: string
+): any[] {
+  const kept: any[] = [];
+  const dropped: string[] = [];
+  for (const attr of attrs) {
+    const name = attr?.name?.name;
+    if (
+      name &&
+      (name in BADGE_PROPS || name in TOOLTIP_PROPS || name === 'responsive')
+    ) {
+      dropped.push(name);
+    } else {
+      kept.push(attr);
+    }
+  }
+  if (dropped.length > 0) {
+    addTodo(
+      ctx,
+      path,
+      'plain-element',
+      `${where} became a plain element, so the ${dropped
+        .map(d => `\`${d}\``)
+        .join(
+          ', '
+        )} helper prop(s) were dropped — re-apply by hand (badge/tooltip as a wrapping \`<Badge>\`/\`<Tooltip>\`, responsive settings as classes)`
+    );
+  }
+  return kept;
+}
+
+/**
+ * rbx puts `as` on every component, but a handler that chooses its target from
+ * a prop value can land on a bestax component that has no `as` — Media.Item
+ * resolves to Left/Content/Right where only Left declares one, Level.Item to
+ * Left/Right/Item where only Item does, Navbar.Item to Item/Dropdown where
+ * only Item does. Opting into `as` in the mapping table cannot express that,
+ * so the target has to be checked after it is picked.
+ */
+function restrictAsToTargets(
+  ctx: TransformContext,
+  path: ASTPath<any>,
+  element: any,
+  target: string | undefined,
+  allowed: string[]
+): void {
+  const asAttr = findAttr(element, 'as');
+  if (!asAttr || (target && allowed.includes(target))) return;
+  removeAttr(element, asAttr);
+  addTodo(
+    ctx,
+    path,
+    'prop:as',
+    `bestax's \`${target}\` has no \`as\` prop (of the targets this can resolve to, only ${allowed
+      .map(a => `\`${a}\``)
+      .join(' / ')} does); render the tag directly or restructure`
+  );
+  ctx.dirty = true;
+}
+
+/** Replace the element with a plain HTML tag carrying `className`. */
+function replaceWithPlain(
+  ctx: TransformContext,
+  path: ASTPath<any>,
+  element: any,
+  tag: string,
+  className: string | undefined,
+  where: string
+): SpecialResult {
+  const merged = mergeClassName(ctx, path, element, className, where);
+  const rest = stripHelperComponentProps(
+    ctx,
+    path,
+    stripModifierProps(ctx, path, attributesOf(element), where),
+    where
+  );
+  path.replace(plainElement(ctx.j, tag, merged, rest, element.children ?? []));
+  ctx.dirty = true;
+  return { replaced: true };
+}
+
+/**
+ * rbx wraps several components in a `*.Container` that owns the modifiers,
+ * where bestax's component renders that wrapper itself. Move the container's
+ * (already-converted) attributes onto its single child and replace the
+ * container with it — otherwise both would rename to the same bestax
+ * component and nest, which is invalid.
+ *
+ * Returns null when the element isn't the single-JSX-child shape, so the
+ * caller can fall back to keeping the container.
+ */
+function collapseOntoChild(
+  ctx: TransformContext,
+  path: ASTPath<any>,
+  element: any,
+  where: string,
+  expected: string
+): SpecialResult | null {
+  const children = (element.children ?? []).filter(
+    (c: any) => !(c.type === 'JSXText' && c.value.trim() === '')
+  );
+  if (children.length !== 1 || children[0].type !== 'JSXElement') return null;
+  const child = children[0];
+  // The child must be the component this container exists to wrap. rbx lets
+  // both of these containers hold something else — an `<iframe>` for a ratio
+  // box, a native `<select>` — and folding onto that put Bulma modifier props
+  // on an intrinsic element and dropped the wrapper the markup needs.
+  const childPath = ctx.resolve?.(child.openingElement?.name);
+  if (!childPath || childPath.join('.') !== expected) return null;
+
+  for (const attr of [...attributesOf(element)]) {
+    const name: string = attr.name.name;
+    if (findAttr(child, name)) {
+      addTodo(
+        ctx,
+        path,
+        `prop:${name}`,
+        `\`${where}\` folded into its child, but both set \`${name}\`; the child's value was kept — reconcile by hand`
+      );
+      continue;
+    }
+    removeAttr(element, attr);
+    addAttr(child, attr);
+  }
+
+  path.replace(child);
+  ctx.dirty = true;
+  return { replaced: true };
+}
+
+const SPECIALS: Record<string, SpecialHandler> = {
+  /**
+   * rbx's `Heading` is Bulma's `.heading` label (small caps), not a title —
+   * bestax has no component for it, so it becomes a plain <p>.
+   */
+  heading(ctx, path, element) {
+    return replaceWithPlain(ctx, path, element, 'p', 'heading', 'Heading');
+  },
+
+  /**
+   * rbx folds title and subtitle into one component behind a `subtitle`
+   * boolean; bestax splits them into `Title` and `SubTitle`. rbx also ignores
+   * `spaced` when `subtitle` is set, so a subtitle never carries isSpaced.
+   */
+  title(ctx, path, element) {
+    const subtitleAttr = findAttr(element, 'subtitle');
+    let target = 'Title';
+    let isSubtitle = false;
+    if (subtitleAttr) {
+      const resolved = resolveBooleanish(subtitleAttr);
+      if (resolved === 'expression') {
+        addTodo(
+          ctx,
+          path,
+          'prop:subtitle',
+          'dynamic `subtitle`; bestax splits these into `<Title>` and `<SubTitle>` — pick one by hand'
+        );
+      } else if (resolved === 'truthy') {
+        target = 'SubTitle';
+        isSubtitle = true;
+      }
+      removeAttr(element, subtitleAttr);
+      ctx.dirty = true;
+    }
+
+    const spacedAttr = findAttr(element, 'spaced');
+    if (spacedAttr) {
+      const resolved = resolveBooleanish(spacedAttr);
+      // rbx ignores `spaced` on a subtitle, so a SubTitle drops it outright.
+      if (isSubtitle) {
+        removeAttr(element, spacedAttr);
+      } else if (resolved === 'truthy') {
+        removeAttr(element, spacedAttr);
+        addAttr(element, makeAttr(ctx.j, 'isSpaced'));
+      } else if (resolved === 'falsy') {
+        removeAttr(element, spacedAttr);
+      } else {
+        // Dynamic: keep the expression, just rename the prop.
+        spacedAttr.name = ctx.j.jsxIdentifier('isSpaced');
+      }
+      ctx.dirty = true;
+    }
+
+    return { target, handledProps: ['subtitle', 'spaced'] };
+  },
+
+  /**
+   * bestax's Icon takes a `name` (plus `library`/`variant`) instead of an
+   * icon-font <i> child. Parse the child when we can read it, otherwise keep
+   * the element and explain.
+   */
+  icon(ctx, path, element) {
+    const children = (element.children ?? []).filter(
+      (c: any) => !(c.type === 'JSXText' && c.value.trim() === '')
+    );
+    const iChild = children.find(
+      (c: any) =>
+        c.type === 'JSXElement' &&
+        c.openingElement?.name?.type === 'JSXIdentifier' &&
+        (c.openingElement.name.name === 'i' ||
+          c.openingElement.name.name === 'span')
+    );
+    if (children.length === 1 && iChild) {
+      const classAttr = (iChild.openingElement.attributes ?? []).find(
+        (a: any) => a.type === 'JSXAttribute' && a.name.name === 'className'
+      );
+      const literal = classAttr ? literalValueOf(classAttr) : undefined;
+      if (literal?.kind === 'string') {
+        const parsed = parseIconClasses(literal.value);
+        if (parsed) {
+          addAttr(element, makeAttr(ctx.j, 'name', parsed.name));
+          if (parsed.library) {
+            addAttr(element, makeAttr(ctx.j, 'library', parsed.library));
+          }
+          if (parsed.variant) {
+            addAttr(element, makeAttr(ctx.j, 'variant', parsed.variant));
+          }
+          element.children = [];
+          if (element.openingElement) {
+            element.openingElement.selfClosing = true;
+            element.closingElement = null;
+          }
+          ctx.dirty = true;
+          return {};
+        }
+      }
+    }
+    // rbx's own docs teach `<Icon><FontAwesomeIcon icon={faHome} /></Icon>`,
+    // so this is the shape most rbx code is in. There is no icon name to read
+    // out of a component reference, and `name` is required on bestax's Icon.
+    addTodo(
+      ctx,
+      path,
+      'component:Icon',
+      'bestax `Icon` takes a required `name` (plus optional `library`/`variant`) instead of an icon child — e.g. `<FontAwesomeIcon icon={faHome} />` becomes `<Icon name="home" library="fa" variant="solid" />`'
+    );
+    return {};
+  },
+
+  /**
+   * rbx's Divider rendered its children as a centred label (`div.is-divider`
+   * with the text in `data-content`). bestax's Divider is a bare `<hr>` and
+   * takes no children -- React rejects children on a void element at runtime,
+   * so passing them through produced a crash with no TODO naming the lost
+   * label. The children are left in place so nothing is discarded silently;
+   * the TODO tells the user where the label has to go instead.
+   */
+  divider(ctx, path, element) {
+    const children = (element.children ?? []).filter(
+      (c: any) => !(c.type === 'JSXText' && c.value.trim() === '')
+    );
+    if (children.length > 0) {
+      addTodo(
+        ctx,
+        path,
+        'component:Divider',
+        'rbx `Divider` rendered its children as a centred label; bestax `Divider` is a bare `<hr>` and takes no children — move the label into surrounding markup, or drop it'
+      );
+    }
+    return {};
+  },
+
+  /**
+   * rbx nests <Image> inside <Image.Container>, which carries the size; the
+   * bestax Image renders the <figure> itself, so the container collapses and
+   * hands its size down.
+   */
+  'image-container'(ctx, path, element) {
+    const sizeAttr = findAttr(element, 'size');
+    if (sizeAttr) {
+      const literal = literalValueOf(sizeAttr);
+      if (literal.kind === 'number') {
+        // rbx takes a pixel dimension (64); bestax takes Bulma's `is-64x64`
+        // square form, so the number becomes "NxN".
+        sizeAttr.value = ctx.j.stringLiteral(
+          `${literal.value}x${literal.value}`
+        );
+        ctx.dirty = true;
+      } else if (literal.kind !== 'string') {
+        addTodo(
+          ctx,
+          path,
+          'prop:size',
+          'dynamic `Image.Container` size; set `size` on the bestax `<Image>` by hand'
+        );
+      }
+      // A string literal is already a ratio like "16by9" — pass it through.
+    }
+    const collapsed = collapseOntoChild(
+      ctx,
+      path,
+      element,
+      'Image.Container',
+      'Image'
+    );
+    if (collapsed) return collapsed;
+    // No single child to fold into — keep the container as the Image itself.
+    return { target: 'Image', handledProps: ['size'] };
+  },
+
+  /**
+   * rbx's `Loader` is Bulma's plain `.loader` spinner, which always renders.
+   * bestax's `Loading` is a different thing — a dismissible overlay that
+   * returns null unless `active` — so this emits the element rbx did.
+   */
+  loader(ctx, path, element) {
+    return replaceWithPlain(ctx, path, element, 'div', 'loader', 'Loader');
+  },
+
+  /** rbx's full-screen PageLoader is bestax's Loading with isFullPage. */
+  'page-loader'(ctx, _path, element) {
+    if (!findAttr(element, 'isFullPage')) {
+      addAttr(element, makeAttr(ctx.j, 'isFullPage'));
+      ctx.dirty = true;
+    }
+    return { target: 'Loading' };
+  },
+
+  /**
+   * rbx's Field `multiline` only means anything alongside `kind="group"`, and
+   * bestax folds both into one prop: `grouped="multiline"`. So this has to
+   * win over the `kind` mapping rather than sit beside it — `grouped` set
+   * twice would be invalid JSX.
+   */
+  field(ctx, path, element) {
+    const multilineAttr = findAttr(element, 'multiline');
+    if (!multilineAttr) return {};
+    const resolved = resolveBooleanish(multilineAttr);
+    removeAttr(element, multilineAttr);
+    if (resolved === 'truthy') {
+      // rbx applies `is-grouped-multiline` only when kind === "group"
+      // (`[`${k}-multiline`]: k === "is-grouped" && multiline === true`), so
+      // consuming `kind` unconditionally dropped `has-addons` from
+      // `<Field kind="addons" multiline>` and added a modifier rbx would not
+      // have rendered.
+      const kindAttr = findAttr(element, 'kind');
+      const kindLiteral = kindAttr ? literalValueOf(kindAttr) : undefined;
+      const isGroup =
+        kindLiteral?.kind === 'string' && kindLiteral.value === 'group';
+      // Note `!kindAttr` is NOT grouped in here: with no `kind` at all, rbx's
+      // `k` is undefined, so `multiline` renders nothing and the field stays a
+      // plain block. Treating it as group turned it into a flex row.
+      if (isGroup) {
+        if (kindAttr) removeAttr(element, kindAttr);
+        const existing = findAttr(element, 'grouped');
+        if (existing) removeAttr(element, existing);
+        addAttr(element, makeAttr(ctx.j, 'grouped', 'multiline'));
+        ctx.dirty = true;
+        return { handledProps: ['multiline', 'kind'] };
+      }
+      // kind="addons", a dynamic kind, or no kind at all: rbx ignores
+      // multiline in every one of those, so the codemod does too and leaves
+      // `kind` for the mapping table.
+      if (kindAttr && kindLiteral?.kind === 'expression') {
+        addTodo(
+          ctx,
+          path,
+          'prop:multiline',
+          'dynamic Field `kind` alongside `multiline`; rbx applies multiline only when kind is "group" — set `grouped="multiline"` by hand if that branch is reachable'
+        );
+      }
+      ctx.dirty = true;
+      return { handledProps: ['multiline'] };
+    }
+    if (resolved === 'expression') {
+      addTodo(
+        ctx,
+        path,
+        'prop:multiline',
+        'dynamic Field `multiline`; set `grouped="multiline"` conditionally by hand'
+      );
+    }
+    ctx.dirty = true;
+    return { handledProps: ['multiline'] };
+  },
+
+  /** bestax has no Help component; Bulma's markup is a plain <p class="help">. */
+  help(ctx, path, element) {
+    const className = modifierClass(
+      ctx,
+      path,
+      element,
+      'color',
+      'help',
+      'Help'
+    );
+    return replaceWithPlain(ctx, path, element, 'p', className, 'Help');
+  },
+
+  /** bestax has no standalone Label; Bulma's markup is <label class="label">. */
+  label(ctx, path, element) {
+    let className = modifierClass(ctx, path, element, 'size', 'label', 'Label');
+    const disabledAttr = findAttr(element, 'disabled');
+    if (disabledAttr) {
+      // By value, not by presence: `disabled={false}` must not become a
+      // permanent `is-disabled`, and a dynamic value cannot be baked into a
+      // static class string.
+      const resolved = resolveBooleanish(disabledAttr);
+      removeAttr(element, disabledAttr);
+      if (resolved === 'truthy') {
+        className = `${className} is-disabled`;
+      } else if (resolved === 'expression') {
+        addTodo(
+          ctx,
+          path,
+          'prop:disabled',
+          "dynamic Label `disabled`; set className={disabled ? 'label is-disabled' : 'label'} by hand"
+        );
+      }
+      ctx.dirty = true;
+    }
+    return replaceWithPlain(ctx, path, element, 'label', className, 'Label');
+  },
+
+  /**
+   * rbx wraps <Select> in <Select.Container>, which owns the modifiers; the
+   * bestax Select renders its own wrapper, so the container collapses onto it.
+   */
+  'select-container'(ctx, path, element) {
+    // Decide the plain-markup fallback FIRST, while the props are still rbx's
+    // own — converting them to bestax booleans and then emitting a <div>
+    // stranded things like `isRounded` on an intrinsic element.
+    const allKids = (element.children ?? []).filter(
+      (c: any) => !(c.type === 'JSXText' && c.value.trim() === '')
+    );
+    if (allKids.length !== 1) {
+      // bestax's `Select` renders exactly one `<select>`, so a container
+      // holding several has no direct equivalent. rbx's own markup — a
+      // `div.select` wrapper — is valid whatever the children are.
+      let cls = 'select';
+      for (const prop of ['size', 'color', 'state'] as const) {
+        cls = modifierClass(ctx, path, element, prop, cls, 'Select.Container');
+      }
+      for (const [prop, klass] of [
+        ['fullwidth', 'is-fullwidth'],
+        ['rounded', 'is-rounded'],
+      ] as const) {
+        const attr = findAttr(element, prop);
+        if (!attr) continue;
+        const resolved = resolveBooleanish(attr);
+        if (resolved === 'truthy') {
+          cls = `${cls} ${klass}`;
+        } else if (resolved === 'expression') {
+          // A plain element cannot carry the condition, so say so rather than
+          // dropping the styling along with its expression.
+          addTodo(
+            ctx,
+            path,
+            `prop:${prop}`,
+            `dynamic \`${prop}\` on a Select.Container that became plain markup; apply \`${klass}\` conditionally via className by hand`
+          );
+        }
+        removeAttr(element, attr);
+        ctx.dirty = true;
+      }
+      addTodo(
+        ctx,
+        path,
+        'component:Select.Container',
+        "bestax's `Select` renders a single `<select>`, so a container holding more than one has no direct equivalent; emitted the plain Bulma wrapper instead"
+      );
+      return replaceWithPlain(
+        ctx,
+        path,
+        element,
+        'div',
+        cls,
+        'Select.Container'
+      );
+    }
+
+    // A dynamic value must not simply disappear: rename it so the condition
+    // survives, rather than dropping the modifier along with its expression.
+    for (const [from, to] of [
+      ['fullwidth', 'isFullwidth'],
+      ['rounded', 'isRounded'],
+    ] as const) {
+      const attr = findAttr(element, from);
+      if (!attr) continue;
+      const resolved = resolveBooleanish(attr);
+      if (resolved === 'truthy') {
+        removeAttr(element, attr);
+        addAttr(element, makeAttr(ctx.j, to));
+      } else if (resolved === 'falsy') {
+        removeAttr(element, attr);
+      } else {
+        attr.name = ctx.j.jsxIdentifier(to);
+      }
+      ctx.dirty = true;
+    }
+    const stateAttr = findAttr(element, 'state');
+    if (stateAttr) {
+      const literal = literalValueOf(stateAttr);
+      removeAttr(element, stateAttr);
+      if (literal.kind === 'string') {
+        const mapped: Record<string, string> = {
+          focused: 'isFocused',
+          hovered: 'isHovered',
+          loading: 'isLoading',
+        };
+        if (mapped[literal.value]) {
+          addAttr(element, makeAttr(ctx.j, mapped[literal.value]));
+        }
+      } else {
+        addTodo(
+          ctx,
+          path,
+          'prop:state',
+          'dynamic `Select.Container` state; set the matching bestax boolean by hand'
+        );
+      }
+      ctx.dirty = true;
+    }
+    const collapsed = collapseOntoChild(
+      ctx,
+      path,
+      element,
+      'Select.Container',
+      'Select'
+    );
+    if (collapsed) return collapsed;
+
+    // rbx also lets the container wrap a NATIVE <select>. bestax's Select
+    // renders its own <select>, so keeping both nested one inside the other.
+    // Fold the native element's attributes and options up instead.
+    const kids = (element.children ?? []).filter(
+      (c: any) => !(c.type === 'JSXText' && c.value.trim() === '')
+    );
+    const native =
+      kids.length === 1 &&
+      kids[0].type === 'JSXElement' &&
+      kids[0].openingElement?.name?.type === 'JSXIdentifier' &&
+      kids[0].openingElement.name.name === 'select'
+        ? kids[0]
+        : null;
+    if (native) {
+      for (const attr of attributesOf(native)) {
+        if (!findAttr(element, attr.name.name)) addAttr(element, attr);
+      }
+      element.children = native.children ?? [];
+      ctx.dirty = true;
+      return {
+        target: 'Select',
+        handledProps: ['fullwidth', 'rounded', 'state'],
+      };
+    }
+
+    return {
+      target: 'Select',
+      handledProps: ['fullwidth', 'rounded', 'state'],
+    };
+  },
+
+  /** rbx's Select.Option is a plain <option>. */
+  'plain-option'(ctx, path, element) {
+    return replaceWithPlain(
+      ctx,
+      path,
+      element,
+      'option',
+      undefined,
+      'Select.Option'
+    );
+  },
+
+  /** bestax Breadcrumb renders <ul>{children}</ul>; items are plain <li><a>. */
+  'breadcrumb-item'(ctx, path, element) {
+    const j = ctx.j;
+    const activeAttr = findAttr(element, 'active');
+    let liClass: string | undefined;
+    if (activeAttr) {
+      const resolved = resolveBooleanish(activeAttr);
+      if (resolved === 'truthy') liClass = 'is-active';
+      else if (resolved === 'expression') {
+        addTodo(
+          ctx,
+          path,
+          'prop:active',
+          "dynamic Breadcrumb.Item active; set the li className={active ? 'is-active' : undefined} by hand"
+        );
+      }
+      removeAttr(element, activeAttr);
+    }
+    liClass = mergeClassName(ctx, path, element, liClass, 'Breadcrumb.Item');
+    // This handler builds its <a> by hand rather than going through
+    // replaceWithPlain, so it has to layer the helper-prop strip itself —
+    // otherwise rbx's badge*/tooltip* ride onto the intrinsic <a>.
+    const anchorAttrs = stripHelperComponentProps(
+      ctx,
+      path,
+      stripModifierProps(ctx, path, attributesOf(element), 'Breadcrumb.Item'),
+      'Breadcrumb.Item'
+    );
+    const children = element.children ?? [];
+    const anchor = plainElement(j, 'a', undefined, anchorAttrs, children);
+    path.replace(plainElement(j, 'li', liClass, [], [anchor]));
+    ctx.dirty = true;
+    return { replaced: true };
+  },
+
+  /**
+   * rbx's Dropdown owns both the trigger and the menu; bestax's takes a
+   * `label` and renders the trigger itself, so the shape differs enough that
+   * a mechanical rewrite would be a guess.
+   */
+  dropdown(ctx, path, _element) {
+    addTodo(
+      ctx,
+      path,
+      'component:Dropdown',
+      'bestax `Dropdown` takes a `label` and renders its own trigger; move the `<Dropdown.Trigger>` content into `label` and drop the wrapper elements'
+    );
+    return {};
+  },
+  'dropdown-container'(ctx, path, _element) {
+    addTodo(
+      ctx,
+      path,
+      'component:Dropdown.Container',
+      'bestax `Dropdown` is the container itself; drop this wrapper'
+    );
+    return {};
+  },
+  'dropdown-content'(ctx, path, _element) {
+    addTodo(
+      ctx,
+      path,
+      'component:Dropdown.Content',
+      'bestax `Dropdown` renders its own menu content; drop this wrapper and keep the `<Dropdown.Item>`s'
+    );
+    return {};
+  },
+  'dropdown-menu'(ctx, path, _element) {
+    addTodo(
+      ctx,
+      path,
+      'component:Dropdown.Menu',
+      'bestax `Dropdown` renders its own menu; drop this wrapper and keep the `<Dropdown.Item>`s'
+    );
+    return {};
+  },
+  'dropdown-trigger'(ctx, path, _element) {
+    addTodo(
+      ctx,
+      path,
+      'component:Dropdown.Trigger',
+      'bestax `Dropdown` renders its own trigger; move this content into the `label` prop'
+    );
+    return {};
+  },
+
+  /** rbx Level.Item align=left|right → bestax Level.Left / Level.Right. */
+  'level-item'(ctx, path, element) {
+    const result = alignTarget(
+      ctx,
+      path,
+      element,
+      'align',
+      { left: 'Level.Left', right: 'Level.Right' },
+      'Level.Item'
+    );
+    restrictAsToTargets(ctx, path, element, result.target, ['Level.Item']);
+    return { ...result, handledProps: ['align', 'as'] };
+  },
+
+  /**
+   * rbx Media.Item align=content|left|right → bestax Media.{Content,Left,Right}.
+   *
+   * Only `MediaLeftProps` declares `as` ('figure' | 'div'); Content and Right
+   * do not. rbx puts `as` on every component, so it has to be resolved here,
+   * against the target the align value actually selected, rather than opted
+   * into once in the mapping table.
+   */
+  'media-item'(ctx, path, element) {
+    const result = alignTarget(
+      ctx,
+      path,
+      element,
+      'align',
+      {
+        content: 'Media.Content',
+        left: 'Media.Left',
+        right: 'Media.Right',
+      },
+      'Media.Content'
+    );
+    restrictAsToTargets(ctx, path, element, result.target, ['Media.Left']);
+    return { ...result, handledProps: ['align', 'as'] };
+  },
+
+  /**
+   * The markup maps cleanly, but three rbx behaviours do not exist in bestax
+   * and none of them fail loudly: rbx portals the modal into `document.body`,
+   * closes it on Escape by default, and clips document scroll while it is
+   * open. bestax renders inline and implements none of the three. An
+   * unmodified `<Modal>` therefore migrates to something that looks right and
+   * behaves differently, so every conversion is flagged.
+   */
+  modal(ctx, path, _element) {
+    addTodo(
+      ctx,
+      path,
+      'component:Modal',
+      'bestax `Modal` renders inline rather than portalling into document.body, and implements neither Escape-to-close nor scroll locking — rbx did all three by default. Re-add whichever your UI relied on'
+    );
+    return {};
+  },
+
+  /** rbx Modal.Container is the modal itself in bestax. */
+  'modal-container'(_ctx, _path, _element) {
+    return { target: 'Modal' };
+  },
+
+  /**
+   * rbx's Navbar.Item carries `dropdown`/`up`/`tab` variants that bestax
+   * splits across Navbar.Item and Navbar.Dropdown.
+   */
+  'navbar-item'(ctx, path, element) {
+    // Resolve the target FIRST, then fall through to the cleanup loop —
+    // returning early here left `<Navbar.Item dropdown up>` as
+    // `<Navbar.Dropdown up>`, with `up` neither removed nor flagged.
+    let target: string | undefined;
+    const dropdownAttr = findAttr(element, 'dropdown');
+    if (dropdownAttr) {
+      const resolved = resolveBooleanish(dropdownAttr);
+      removeAttr(element, dropdownAttr);
+      ctx.dirty = true;
+      if (resolved === 'truthy') {
+        target = 'Navbar.Dropdown';
+      } else if (resolved === 'expression') {
+        addTodo(
+          ctx,
+          path,
+          'prop:dropdown',
+          'dynamic Navbar.Item `dropdown`; pick between `<Navbar.Item>` and `<Navbar.Dropdown>` by hand'
+        );
+      }
+    }
+    // `up` and `hoverable` exist on bestax's NavbarDropdownProps, so when the
+    // dropdown target was selected they carry straight over; discarding them
+    // lost working modifiers. On a plain Navbar.Item they have no home.
+    const unsupported =
+      target === 'Navbar.Dropdown'
+        ? ['tab', 'expanded', 'managed']
+        : ['up', 'tab', 'expanded', 'hoverable', 'managed'];
+    for (const prop of unsupported) {
+      const attr = findAttr(element, prop);
+      if (!attr) continue;
+      removeAttr(element, attr);
+      addTodo(
+        ctx,
+        path,
+        `prop:${prop}`,
+        `bestax \`Navbar.Item\` has no \`${prop}\` prop; restructure or add a class by hand`
+      );
+      ctx.dirty = true;
+    }
+    restrictAsToTargets(ctx, path, element, target ?? 'Navbar.Item', [
+      'Navbar.Item',
+    ]);
+    return {
+      target,
+      handledProps: [
+        'as',
+        'dropdown',
+        'up',
+        'tab',
+        'expanded',
+        'hoverable',
+        'managed',
+      ],
+    };
+  },
+
+  /** rbx's Navbar.Container / Navbar.Item.Container have no bestax analogue. */
+  'navbar-container'(ctx, path, _element) {
+    addTodo(
+      ctx,
+      path,
+      'component:Navbar.Container',
+      'bestax `Navbar` renders its own container; drop this wrapper'
+    );
+    return {};
+  },
+
+  /**
+   * rbx's `Navbar.Dropdown` is the MENU (`div.navbar-dropdown`); bestax calls
+   * that `Navbar.DropdownMenu` and reserves `Navbar.Dropdown` for the outer
+   * `navbar-item has-dropdown` container — which is what rbx's
+   * `<Navbar.Item dropdown>` becomes. Targeting `Navbar.Dropdown` here nested
+   * two containers and emitted no menu at all. The react-bulma-components
+   * source already makes this distinction for the same reason.
+   */
+  'navbar-dropdown'(ctx, path, element) {
+    const boxedAttr = findAttr(element, 'boxed');
+    if (boxedAttr) {
+      removeAttr(element, boxedAttr);
+      addTodo(
+        ctx,
+        path,
+        'prop:boxed',
+        'bestax `Navbar.DropdownMenu` has no `boxed` prop; add className="is-boxed"'
+      );
+      ctx.dirty = true;
+    }
+    const alignAttr = findAttr(element, 'align');
+    if (alignAttr) {
+      const literal = literalValueOf(alignAttr);
+      removeAttr(element, alignAttr);
+      if (literal.kind === 'string' && literal.value === 'right') {
+        addAttr(element, makeAttr(ctx.j, 'right'));
+      } else if (literal.kind !== 'string') {
+        addTodo(
+          ctx,
+          path,
+          'prop:align',
+          'dynamic `Navbar.Dropdown` align; set the bestax `right` boolean by hand'
+        );
+      }
+      ctx.dirty = true;
+    }
+    return {
+      target: 'Navbar.DropdownMenu',
+      handledProps: ['boxed', 'align'],
+    };
+  },
+
+  /** rbx Navbar.Segment align=start|end → bestax Navbar.Start / Navbar.End. */
+  'navbar-segment'(ctx, path, element) {
+    return alignTarget(
+      ctx,
+      path,
+      element,
+      'align',
+      { start: 'Navbar.Start', end: 'Navbar.End' },
+      'Navbar.Start'
+    );
+  },
+
+  /** rbx Pagination.Step align=next|previous → bestax Pagination.{Next,Previous}. */
+  'pagination-step'(ctx, path, element) {
+    return alignTarget(
+      ctx,
+      path,
+      element,
+      'align',
+      { next: 'Pagination.Next', previous: 'Pagination.Previous' },
+      'Pagination.Next'
+    );
+  },
+
+  /**
+   * rbx's Panel.Tab is one tab inside a Panel.Tab.Group; bestax's Panel.Tabs
+   * is the group and its children are plain anchors.
+   */
+  'panel-tab'(ctx, path, element) {
+    const activeAttr = findAttr(element, 'active');
+    let className: string | undefined;
+    if (activeAttr) {
+      const resolved = resolveBooleanish(activeAttr);
+      if (resolved === 'truthy') className = 'is-active';
+      else if (resolved === 'expression') {
+        addTodo(
+          ctx,
+          path,
+          'prop:active',
+          "dynamic Panel.Tab active; set className={active ? 'is-active' : undefined} by hand"
+        );
+      }
+      removeAttr(element, activeAttr);
+    }
+    return replaceWithPlain(ctx, path, element, 'a', className, 'Panel.Tab');
+  },
+
+  /**
+   * rbx's `Tab.Group` renders `div.tabs > ul > li`; bestax's `Tabs` renders
+   * only the `div.tabs` and leaves the `<ul>` to `Tabs.List`. Renaming
+   * straight across put the `<li>` items directly inside the div, which is
+   * not valid Bulma tabs markup. Wrap the children in a `Tabs.List`.
+   */
+  'tab-group'(ctx, _path, element) {
+    const children = element.children ?? [];
+    const solid = children.filter(
+      (c: any) => !(c.type === 'JSXText' && c.value.trim() === '')
+    );
+    // Already wrapped by hand, or nothing to wrap.
+    const alreadyList =
+      solid.length === 1 &&
+      solid[0].type === 'JSXElement' &&
+      /(^|\.)List$/.test(
+        (jsxNameParts(solid[0].openingElement?.name) ?? []).join('.')
+      );
+    if (solid.length === 0 || alreadyList) return { target: 'Tabs' };
+
+    const local = ctx.reserve('Tabs');
+    const listName = `${local}.List`;
+    element.children = [
+      ctx.j.jsxElement(
+        ctx.j.jsxOpeningElement(buildJsxName(ctx.j, listName), [], false),
+        ctx.j.jsxClosingElement(buildJsxName(ctx.j, listName)),
+        children
+      ),
+    ];
+    ctx.dirty = true;
+    return { target: 'Tabs' };
+  },
+
+  /** Marks the element for the column breakpoint pass in responsive.ts. */
+  column() {
+    return {};
+  },
+  'column-group'() {
+    return {};
+  },
+};
+
+export function runSpecial(
+  name: string,
+  ctx: TransformContext,
+  path: ASTPath<any>,
+  element: any
+): SpecialResult {
+  const handler = SPECIALS[name];
+  if (!handler) return {};
+  return handler(ctx, path, element);
+}
diff --git a/bestax-migrate/src/sources/rbx/styles.ts b/bestax-migrate/src/sources/rbx/styles.ts
new file mode 100644
index 000000000..0aeaadb56
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/styles.ts
@@ -0,0 +1,31 @@
+/**
+ * Stylesheet migration for rbx apps.
+ *
+ * Same shared factory as every other source — the Bulma 0.9 → v1 rewriting is
+ * identical.
+ *
+ * Note what it does NOT do: a `bulma-*` extension import in Sass is left in
+ * place with a TODO, not removed. Only the JS/CSS-import side of rbx's
+ * extension cleanup is automatic (transform.ts prunes
+ * `bulma-badge`/`bulma-divider`/`bulma-pageloader`/`bulma-tooltip` CSS
+ * imports outright, since bestax ships all four as components). A Sass
+ * `@import` of one may be pulling in customisation the codemod cannot see,
+ * so it is flagged for a human instead.
+ *
+ * rbx's own stylesheet is `rbx/rbx` (its Sass entry, usually imported as
+ * `~rbx/rbx` after `~bulma/bulma`) or the prebuilt `rbx/index.css`. Both
+ * carry rbx's fixes on top of a full Bulma root, so they are replaced with a
+ * Bulma v1 root rather than dropped.
+ */
+
+import { makeStylesTransform } from '../_shared/make-styles-transform.js';
+
+export const transformStyles = makeStylesTransform({
+  packageName: 'rbx',
+  guideUrl: 'https://bestax.io/docs/guides/getting-started/migration/rbx',
+  rootStylesheetSuffixes: [
+    '/rbx(?:\\.s[ac]ss)?',
+    '/index(?:\\.min)?\\.css',
+    '/dist/rbx(?:\\.min)?\\.css',
+  ],
+});
diff --git a/bestax-migrate/src/sources/rbx/transform.ts b/bestax-migrate/src/sources/rbx/transform.ts
new file mode 100644
index 000000000..e7e817a2c
--- /dev/null
+++ b/bestax-migrate/src/sources/rbx/transform.ts
@@ -0,0 +1,1101 @@
+/**
+ * The rbx (v2) → @allxsmith/bestax-bulma transform.
+ *
+ * Passes, in order:
+ *   1. resolve imports (named/namespace) and `const { Item } = Card`-style
+ *      destructuring into canonical rbx component paths
+ *   2. per-element: structural special → rename → responsive flattening →
+ *      component prop map → universal helper props → badge/tooltip wrapping
+ *   3. rewrite imports: drop rbx, add one merged bestax-bulma import; keep a
+ *      trimmed rbx import (with a TODO) only for components that have no
+ *      bestax equivalent (Generic, Tile, List, …)
+ *
+ * Anything unsafe gets a `// TODO(bestax-migrate)` comment on the enclosing
+ * statement plus an entry in the run report.
+ *
+ * The pass that has no react-bulma-components counterpart is the last one.
+ * rbx exposes badges and tooltips as *helper props on any element*, backed by
+ * the bulma-badge / bulma-tooltip extensions; bestax has real `Badge` and
+ * `Tooltip` components. So `<Button tooltip="hi" />` is a wrapping rewrite,
+ * not a rename.
+ */
+
+import type { API, FileInfo } from 'jscodeshift';
+import type { TransformOptions } from '../../types.js';
+import {
+  BADGE_PROPS,
+  MAPPING,
+  TOOLTIP_PROPS,
+  UNIVERSAL_PROPS,
+  resolveMapping,
+} from './mapping.js';
+import {
+  addTodo,
+  attributesOf,
+  findAttr,
+  jsxNameParts,
+  literalValueOf,
+  removeAttr,
+  renameElement,
+  type TransformContext,
+} from '../_shared/jsx-utils.js';
+import { applyPropAction, applyUniversalProps } from '../_shared/props.js';
+import {
+  collectBoundNames,
+  makeReserve,
+  nameOf,
+  prefersTabs,
+  resolvesToBinding,
+} from '../_shared/imports.js';
+import { flattenResponsiveProps, RESPONSIVE_KINDS } from './responsive.js';
+import { runSpecial } from './specials.js';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+const RBX = 'rbx';
+const BESTAX = '@allxsmith/bestax-bulma';
+const BULMA_CSS = 'bulma/css/bulma.min.css';
+const BESTAX_CSS = '@allxsmith/bestax-bulma/bestax.css';
+const EXTRAS_CSS = '@allxsmith/bestax-bulma/extras.css';
+
+const BULMA_CSS_SPECIFIERS = new Set([
+  'bulma/css/bulma.css',
+  'bulma/css/bulma.min.css',
+]);
+const BESTAX_CSS_SPECIFIERS = new Set([
+  BESTAX_CSS,
+  '@allxsmith/bestax-bulma/bestax.min.css',
+  '@allxsmith/bestax-bulma/dist/bestax.css',
+  '@allxsmith/bestax-bulma/dist/bestax.min.css',
+]);
+const EXTRAS_CSS_SPECIFIERS = new Set([
+  EXTRAS_CSS,
+  '@allxsmith/bestax-bulma/dist/extras.css',
+]);
+
+/**
+ * The four Bulma extensions rbx pinned. An app that imported their CSS
+ * directly no longer needs to: bestax ships Badge/Tooltip/Loading/Divider.
+ */
+const RBX_EXTENSION_CSS = /^bulma-(badge|divider|pageloader|tooltip)(\/|$)/;
+
+export default function transform(
+  fileInfo: FileInfo,
+  api: API,
+  options: TransformOptions = {}
+): string | undefined {
+  const j = api.jscodeshift;
+  const root = j(fileInfo.source);
+
+  const ctx: TransformContext = {
+    j,
+    file: fileInfo.path,
+    collector: options.collector,
+    retained: new Set<string>(),
+    needed: new Map<string, string>(),
+    reserve: root => root, // replaced below once local bindings are known
+    overrides: new WeakMap<object, string>(),
+    dirty: false,
+  };
+
+  // ---- 1. Collect rbx imports -------------------------------------------
+  /** local identifier → imported rbx name ('*' for namespace imports). */
+  const imports = new Map<string, string>();
+  /** local identifier → canonical rbx path (from destructuring). */
+  const aliases = new Map<string, string[]>();
+
+  const rbxImportPaths: any[] = [];
+  /** Whether any rbx import declaration carried a (broken) default binding. */
+  let sawDefaultImport = false;
+  /**
+   * Whether a namespace binding (`import * as rbx`) is still referenced as a
+   * VALUE after the JSX pass. JSX names like `<rbx.Box>` are rewritten away,
+   * but `as={rbx.Block}` or a bare `String(rbx)` are not — and pruning the
+   * import under them leaves `rbx is not defined`.
+   */
+  let namespaceStillReferenced = false;
+
+  root.find(j.ImportDeclaration).forEach(path => {
+    const source = String(path.node.source.value);
+    if (source === RBX) {
+      rbxImportPaths.push(path);
+      for (const spec of path.node.specifiers ?? []) {
+        if (spec.type === 'ImportSpecifier' && spec.local) {
+          imports.set(nameOf(spec.local), nameOf(spec.imported));
+        } else if (spec.type === 'ImportNamespaceSpecifier' && spec.local) {
+          imports.set(nameOf(spec.local), '*');
+        } else if (spec.type === 'ImportDefaultSpecifier') {
+          // rbx has no default export, so this binding is already broken —
+          // but it may still be referenced, and dropping it turns a bad
+          // import into `X is not defined`. Flag it and keep it.
+          sawDefaultImport = true;
+          addTodo(
+            ctx,
+            path,
+            'imports',
+            'rbx has no default export; convert to named imports first'
+          );
+        }
+      }
+    } else if (source.startsWith(`${RBX}/`) && source.endsWith('.css')) {
+      // rbx/index.css — handled by the CSS pass below.
+    } else if (source.startsWith(`${RBX}/`)) {
+      // Deep imports reach rbx internals with no bestax counterpart —
+      // `rbx/base/theme` (the ThemeContext its customisation guide teaches)
+      // is the common one.
+      addTodo(
+        ctx,
+        path,
+        'imports',
+        `\`${source}\` reaches into rbx's internals; bestax's equivalents are its \`Theme\` and \`ConfigProvider\` helpers (https://bestax.io/docs/api/helpers/theme)`
+      );
+    }
+  });
+
+  // ---- 1a. Stylesheet imports (mode-driven) -----------------------------
+  // `bestax` (default): everything converges on the recommended combined
+  // bundle. `bulma`: plain Bulma v1 CSS plus the separate extras file.
+  // `keep`: only the dead rbx CSS import is retargeted.
+  const cssMode = options.cssMode ?? 'bestax';
+  let sawBestaxCss = root
+    .find(j.ImportDeclaration)
+    .paths()
+    .some(p => BESTAX_CSS_SPECIFIERS.has(String(p.node.source.value)));
+
+  // Whether some import in this file will become bestax.css, regardless of
+  // where it sits relative to an existing extras import.
+  const willAdoptBestaxCss =
+    cssMode === 'bestax' &&
+    root
+      .find(j.ImportDeclaration)
+      .paths()
+      .some(p => {
+        const v = String(p.node.source.value);
+        return (
+          (v.startsWith(`${RBX}/`) && v.endsWith('.css')) ||
+          BULMA_CSS_SPECIFIERS.has(v)
+        );
+      });
+
+  root.find(j.ImportDeclaration).forEach(path => {
+    const source = String(path.node.source.value);
+    const isRbxCss = source.startsWith(`${RBX}/`) && source.endsWith('.css');
+    const isBulmaCss = BULMA_CSS_SPECIFIERS.has(source);
+    const isExtrasCss = EXTRAS_CSS_SPECIFIERS.has(source);
+    // The four extensions rbx pinned; bestax covers all of them.
+    const isExtensionCss =
+      RBX_EXTENSION_CSS.test(source) && source.endsWith('.css');
+    if (!isRbxCss && !isBulmaCss && !isExtrasCss && !isExtensionCss) return;
+
+    if (isExtensionCss) {
+      // Kept, with a TODO, rather than dropped. The rbx JSX that needed this
+      // stylesheet becomes bestax components that carry their own styles, so
+      // for THAT markup it is dead -- but an app can also use the extension's
+      // classes directly (`has-tooltip-*`, `is-divider`) outside anything rbx
+      // rendered, and bestax's components style none of that. Deleting the
+      // import on the strength of a component mapping is the best-guess
+      // rewrite this package refuses to make, and it would contradict the
+      // manifest pass, which reports the same extensions rather than removing
+      // them for exactly this reason.
+      addTodo(
+        ctx,
+        path,
+        'css',
+        `kept \`${source}\`: bestax ships Badge, Tooltip, Loading and Divider with their own styles, so this is only still needed by markup outside rbx that uses the extension's classes directly — drop the import once nothing does`
+      );
+      return;
+    }
+
+    if (cssMode === 'bestax') {
+      if (isRbxCss || isBulmaCss) {
+        if (sawBestaxCss) {
+          path.prune(); // bestax.css already imported elsewhere in this file
+        } else {
+          path.node.source = j.stringLiteral(BESTAX_CSS);
+          sawBestaxCss = true;
+        }
+        ctx.dirty = true;
+      } else if (isExtrasCss && (sawBestaxCss || willAdoptBestaxCss)) {
+        // bestax.css already contains the extras. `willAdoptBestaxCss` covers
+        // the case where the extras import comes FIRST in the file and the
+        // bulma/rbx import that becomes bestax.css has not been visited yet —
+        // previously the extras survived alongside it and double-loaded.
+        path.prune();
+        ctx.dirty = true;
+      }
+    } else if (cssMode === 'bulma') {
+      if (isRbxCss) {
+        path.node.source = j.stringLiteral(BULMA_CSS);
+        ctx.dirty = true;
+      }
+      if ((isRbxCss || isBulmaCss) && !sawBestaxCss) {
+        const hasExtras = root
+          .find(j.ImportDeclaration)
+          .paths()
+          .some(p => EXTRAS_CSS_SPECIFIERS.has(String(p.node.source.value)));
+        if (!hasExtras) {
+          // Themed Radio/Checkbox need the bestax extras next to plain Bulma.
+          path.insertAfter(
+            j.importDeclaration([], j.stringLiteral(EXTRAS_CSS))
+          );
+          ctx.dirty = true;
+        }
+      }
+    } else if (isRbxCss) {
+      // keep: minimal fix — rbx's CSS carries Bulma 0.7.5.
+      path.node.source = j.stringLiteral(BULMA_CSS);
+      addTodo(
+        ctx,
+        path,
+        'css',
+        `replaced rbx's CSS import with '${BULMA_CSS}'; install bulma@^1 (see https://bestax.io/docs/guides/getting-started/installation)`
+      );
+    }
+  });
+
+  if (imports.size === 0 && !ctx.dirty) {
+    return undefined;
+  }
+
+  // The scope each binding was collected in, so a reference can be checked
+  // against the binding it actually resolves to rather than matched by name.
+  const programScope: unknown = root.find(j.Program).paths()[0]?.scope;
+  // Aliases are keyed by the AST node that owns the declaring scope, not by
+  // bare name. Two functions can each destructure `Header` from a different
+  // component; a name-keyed map let the second overwrite the first, and both
+  // declarations were then pruned while both `<Header…>` references were left
+  // resolving to nothing.
+  //
+  // Resolution walks the reference's ANCESTORS rather than consulting
+  // `scope.lookup`, because by the time references are rewritten the alias
+  // pass has already pruned the declaration -- so the binding is gone from
+  // the scope table, and `path.scope` objects are not identity-stable across
+  // traversals either.
+  const aliasesByOwner = new Map<unknown, Map<string, string[]>>();
+  const ownersFor = (name: string): unknown[] => {
+    const owners: unknown[] = [];
+    for (const [owner, perScope] of aliasesByOwner) {
+      if (perScope.has(name)) owners.push(owner);
+    }
+    return owners;
+  };
+  const aliasAt = (name: string, at?: unknown): string[] | undefined => {
+    const owners = ownersFor(name);
+    if (owners.length === 0) return undefined;
+    // Without a reference location there is nothing to walk, so the only
+    // owner is the best answer available. WITH one, always walk: an unrelated
+    // `Header` parameter in another function must not resolve to the alias
+    // merely because the alias is the only one by that name. A single-owner
+    // shortcut here rewrote such a parameter to `{ Header: Card.Header }`,
+    // which is not even valid syntax.
+    if (at === undefined) {
+      return owners.length === 1
+        ? aliasesByOwner.get(owners[0])!.get(name)
+        : undefined;
+    }
+    type Anc = { parent?: Anc; node?: unknown };
+    let cursor = at as Anc | undefined;
+    while (cursor) {
+      if (cursor.node !== undefined) {
+        const hit = aliasesByOwner.get(cursor.node)?.get(name);
+        if (hit) {
+          // The walk finds the nearest OWNER, but a binding can intervene
+          // between the reference and that owner: `function F(Header)` under
+          // a module-level `const { Header } = Card` shadows the alias, and
+          // resolving through it rewrote the parameter itself to
+          // `F(Card.Header)`. If the scope table still binds the name
+          // somewhere other than the owner, that nearer binding wins. (After
+          // the alias declaration is pruned the lookup returns nothing for
+          // the alias itself, which is the case this must keep allowing.)
+          const declaring = (
+            at as {
+              scope?: {
+                lookup(n: string): { path?: { node?: unknown } } | null;
+              };
+            }
+          ).scope?.lookup(name)?.path?.node;
+          if (
+            declaring !== undefined &&
+            declaring !== null &&
+            declaring !== cursor.node
+          ) {
+            return undefined;
+          }
+          return hit;
+        }
+      }
+      cursor = cursor.parent;
+    }
+    return undefined;
+  };
+  const anyAlias = (name: string): boolean => ownersFor(name).length > 0;
+
+  // ---- 1b. Resolve `const { Item } = Card` destructuring -----------------
+  root.find(j.VariableDeclarator).forEach(path => {
+    const node = path.node;
+    if (node.id?.type !== 'ObjectPattern' || node.init?.type !== 'Identifier')
+      return;
+    const base = node.init.name;
+    const baseAlias = aliasAt(base, path);
+    const imported = imports.get(base) ?? baseAlias?.join('.');
+    if (!imported || imported === '*') return;
+    if (!imports.has(base) && !baseAlias) return;
+    const basePath = imports.has(base)
+      ? [imports.get(base) as string]
+      : (baseAlias as string[]);
+
+    let allResolved = true;
+    for (const prop of node.id.properties) {
+      if (
+        (prop.type === 'ObjectProperty' || prop.type === 'Property') &&
+        prop.key?.type === 'Identifier' &&
+        prop.value?.type === 'Identifier'
+      ) {
+        const owner = (path.scope as unknown as { path?: { node?: unknown } })
+          ?.path?.node;
+        let perScope = aliasesByOwner.get(owner);
+        if (!perScope) {
+          perScope = new Map<string, string[]>();
+          aliasesByOwner.set(owner, perScope);
+        }
+        const target = [...basePath, prop.key.name];
+        perScope.set(prop.value.name, target);
+        aliases.set(prop.value.name, target);
+        // Pruning the declaration is only safe if every use of the alias will
+        // actually be rewritten. For a name the table cannot map, the JSX is
+        // left as written -- so dropping `const { Header } = Panel` left
+        // `<Header/>` referencing nothing at all.
+        // A `special` handler rewrites the element without naming a plain
+        // target (`Form.Label` becomes a bare <label>), so it counts as
+        // resolved just as a target does. Requiring `target` alone kept every
+        // declaration that mentioned one.
+        const targetMapping = resolveMapping(target);
+        if (
+          !targetMapping ||
+          targetMapping.status === 'todo' ||
+          !(targetMapping.target || targetMapping.special)
+        ) {
+          allResolved = false;
+        }
+      } else {
+        allResolved = false;
+      }
+    }
+    if (allResolved) {
+      const declaration = path.parent;
+      if (
+        declaration?.node?.type === 'VariableDeclaration' &&
+        declaration.node.declarations.length === 1
+      ) {
+        declaration.prune();
+      } else {
+        path.prune();
+      }
+      ctx.dirty = true;
+    } else {
+      addTodo(
+        ctx,
+        path,
+        'imports',
+        `could not resolve every name destructured from \`${base}\`; migrate the leftovers by hand`
+      );
+    }
+  });
+
+  /** Resolve a JSX name into a canonical rbx component path, or null. */
+  function resolveJsxPath(name: any, at?: unknown): string[] | null {
+    const parts = jsxNameParts(name);
+    if (!parts) return null;
+    const [head, ...rest] = parts;
+    const alias = aliasAt(head, at);
+    if (alias) return [...alias, ...rest];
+    // An alias exists under this name but not for THIS reference's binding,
+    // so the reference is not ours to rewrite.
+    if (anyAlias(head) && !imports.has(head)) return null;
+    const imported = imports.get(head);
+    if (imported === undefined) return null;
+    if (imported === '*') return rest.length > 0 ? rest : null;
+    return [imported, ...rest];
+  }
+
+  ctx.resolve = resolveJsxPath;
+
+  // ---- 1c. Collect local bindings so new imports never collide -----------
+  const bound = collectBoundNames(j, root, RBX);
+  // Seed the reserved set with the local names of rbx imports that CANNOT be
+  // migrated, so a bestax import never claims one of them. Without this, an
+  // unmappable component aliased to a name bestax also wants
+  // (`import { Tile as Button }`) had its retained specifier dropped on the
+  // collision — and its `<Button>` JSX then silently resolved to the bestax
+  // Button. A component quietly became a different component.
+  //
+  // Keyed on the mapping status so only genuinely unmappable names force an
+  // alias; the common case (`Button` → `Button`) stays un-aliased.
+  for (const [local, imported] of imports) {
+    if (imported === '*') continue;
+    const entry = MAPPING[imported];
+    // Unmappable roots, plus ANY aliased import. A root can be retained by an
+    // unknown or `todo` child even when the root itself maps (`Icon` is
+    // `partial`, but `<Icon.Unknown>` retains it), and when the local name
+    // differs from the imported one that retained binding can collide with a
+    // bestax local for a completely different component. An unaliased import
+    // is safe: its name already means the same component on both sides.
+    if (!entry || entry.status === 'todo' || local !== imported) {
+      bound.add(local);
+    }
+  }
+  // A root that DOES map can still be retained by a child the table cannot
+  // (`Icon` is `partial`, but `<Icon.Unknown>` keeps the source import alive).
+  // The status check above misses that case whenever the local name equals the
+  // imported one, so the bestax import took the plain local, the retained
+  // specifier was dropped on the collision, and `<Icon.Unknown>` silently
+  // resolved to the bestax component instead.
+  //
+  // Scanned rather than reserved wholesale: adding every partial root to
+  // `bound` would alias them in every file that uses one, whether or not
+  // anything is actually retained.
+  root.find(j.JSXElement).forEach(path => {
+    const head = jsxNameParts(path.node.openingElement.name)?.[0];
+    if (!head || !imports.has(head)) return;
+    const parts = resolveJsxPath(path.node.openingElement.name, path);
+    const mapping = parts ? resolveMapping(parts) : undefined;
+    if (!mapping || mapping.status === 'todo') bound.add(head);
+  });
+  // The same root can be retained by a VALUE chain -- `const X = Icon.Unknown`
+  // -- which only the value-reference pass discovers, after `reserve` has
+  // already handed the plain local to bestax. Scan those chains here too.
+  root.find(j.Identifier).forEach(path => {
+    if (path.node.type !== 'Identifier') return;
+    const head: string = path.node.name;
+    const imported = imports.get(head);
+    if (imported === undefined || imported === '*') return;
+    const parent = path.parent?.node;
+    if (
+      parent?.type !== 'MemberExpression' ||
+      parent.object !== path.node ||
+      parent.computed
+    ) {
+      return;
+    }
+    const chain = [imported];
+    let outer: any = path.parent;
+    while (
+      outer?.node?.type === 'MemberExpression' &&
+      !outer.node.computed &&
+      outer.node.property?.type === 'Identifier'
+    ) {
+      chain.push(nameOf(outer.node.property));
+      const next = outer.parent;
+      if (
+        next?.node?.type === 'MemberExpression' &&
+        next.node.object === outer.node
+      ) {
+        outer = next;
+      } else {
+        break;
+      }
+    }
+    const mapping = resolveMapping(chain);
+    if (!mapping || mapping.status === 'todo') bound.add(head);
+  });
+
+  ctx.reserve = makeReserve(ctx, bound);
+
+  // Merge with an existing bestax import: reuse its locals verbatim.
+  // Only a declaration that already uses NAMED specifiers can absorb more of
+  // them. `import * as Bestax from '…'` cannot: a namespace specifier may not
+  // share a declaration with named ones, and appending to it emits a file
+  // that does not parse.
+  const existingBestax = root
+    .find(j.ImportDeclaration, { source: { value: BESTAX } })
+    .paths()
+    .find(p =>
+      (p.node.specifiers ?? []).every(
+        (spec: any) => spec.type === 'ImportSpecifier'
+      )
+    );
+  const preExistingImports = new Set<string>();
+  if (existingBestax) {
+    for (const spec of existingBestax.node.specifiers ?? []) {
+      if (spec.type === 'ImportSpecifier' && spec.local) {
+        ctx.needed.set(nameOf(spec.imported), nameOf(spec.local));
+        preExistingImports.add(nameOf(spec.imported));
+      }
+    }
+  }
+
+  /**
+   * Move one family of rbx helper props onto a wrapping bestax component.
+   * Returns the wrapper element, or null when the element carries none of
+   * them. Props with no bestax counterpart are dropped with a TODO rather
+   * than guessed at.
+   */
+  function buildWrapper(
+    path: any,
+    element: any,
+    child: any,
+    propMap: Record<string, string | null>,
+    componentName: string,
+    triggerProp: string
+  ): any | null {
+    const present = attributesOf(element).filter(
+      (a: any) => a.name.name in propMap
+    );
+    if (present.length === 0) return null;
+
+    // The trigger prop is what carries the content; without it the rest are
+    // modifiers with nothing to modify.
+    if (!findAttr(element, triggerProp)) {
+      for (const attr of present) removeAttr(element, attr);
+      addTodo(
+        ctx,
+        path,
+        `prop:${triggerProp}`,
+        `\`${present
+          .map((a: any) => a.name.name)
+          .join(
+            '`, `'
+          )}\` set without \`${triggerProp}\`; bestax's \`<${componentName}>\` needs content — dropped`
+      );
+      ctx.dirty = true;
+      return null;
+    }
+
+    const wrapperAttrs: any[] = [];
+    for (const attr of present) {
+      const name: string = attr.name.name;
+      const target = propMap[name];
+      removeAttr(element, attr);
+      if (target === null) {
+        addTodo(
+          ctx,
+          path,
+          `prop:${name}`,
+          `bestax's \`<${componentName}>\` has no \`${name}\` equivalent; restyle by hand`
+        );
+        continue;
+      }
+      attr.name = j.jsxIdentifier(target);
+      // rbx types both `badge` and `tooltip` as `number | string`. bestax's
+      // `Badge.content` is a ReactNode and takes either, but `Tooltip.label`
+      // is `string` — so a numeric tooltip has to be stringified or it fails
+      // to typecheck after migration.
+      if (target === 'label') {
+        const literal = literalValueOf(attr);
+        if (literal.kind === 'number') {
+          attr.value = j.stringLiteral(String(literal.value));
+        } else if (literal.kind === 'expression') {
+          addTodo(
+            ctx,
+            path,
+            `prop:${name}`,
+            "`tooltip` is `number | string` in rbx but bestax's `label` takes a string; wrap a dynamic value in String(...) if it can be numeric"
+          );
+        }
+      }
+      wrapperAttrs.push(attr);
+    }
+
+    // `key` is only meaningful in the parent's child position, and the
+    // wrapper is what becomes the array member now. Leaving it on the inner
+    // element gives React a keyless child: a console warning, and index-based
+    // reconciliation that mis-reuses DOM on reorder.
+    const keyAttr = findAttr(child, 'key');
+    if (keyAttr) {
+      removeAttr(child, keyAttr);
+      wrapperAttrs.unshift(keyAttr);
+    }
+
+    const local = ctx.reserve(componentName);
+    const wrapper = j.jsxElement(
+      j.jsxOpeningElement(j.jsxIdentifier(local), wrapperAttrs, false),
+      j.jsxClosingElement(j.jsxIdentifier(local)),
+      [child]
+    );
+    ctx.dirty = true;
+    return wrapper;
+  }
+
+  // ---- 2. Transform JSX elements ----------------------------------------
+  root.find(j.JSXElement).forEach(path => {
+    const element = path.node;
+    const rbxPath = resolveJsxPath(element.openingElement.name, path);
+    if (!rbxPath) return;
+    // Resolve by BINDING, not by name. `function F({ Card })` shadows the
+    // import with the caller's object, and rewriting its JSX to bestax's
+    // `Card.FooterItem` changed which component rendered.
+    const jsxHead = jsxNameParts(element.openingElement.name)?.[0];
+    if (
+      jsxHead &&
+      !resolvesToBinding(
+        path,
+        jsxHead,
+        anyAlias(jsxHead) ? undefined : programScope
+      )
+    ) {
+      return;
+    }
+
+    const mapping = resolveMapping(rbxPath);
+    const dotted = rbxPath.join('.');
+
+    if (!mapping) {
+      ctx.retained.add(rbxPath[0]);
+      addTodo(
+        ctx,
+        path,
+        'unknown-component',
+        `\`${dotted}\` is not a known rbx v2 export; migrate it by hand`
+      );
+      return;
+    }
+
+    if (mapping.status === 'todo') {
+      ctx.retained.add(rbxPath[0]);
+      addTodo(
+        ctx,
+        path,
+        `component:${dotted}`,
+        `\`${dotted}\` — ${mapping.todo ?? 'migrate by hand'}`
+      );
+      return;
+    }
+
+    // Structural special first — it may pick the target or replace the node.
+    let target = mapping.target;
+    const handled = new Set<string>();
+    if (mapping.special) {
+      const result = runSpecial(mapping.special, ctx, path, element);
+      if (result.replaced) return;
+      if (result.target) target = result.target;
+      for (const prop of result.handledProps ?? []) handled.add(prop);
+    }
+    // A parent's structural handler may have picked this element's target.
+    const override = ctx.overrides.get(element);
+    if (override) target = override;
+
+    if (!target) return;
+
+    // Rename to the bestax name, aliasing the import root on collision.
+    const [targetRoot, ...targetRest] = target.split('.');
+    const localTarget = [ctx.reserve(targetRoot), ...targetRest].join('.');
+    const currentParts = jsxNameParts(element.openingElement.name);
+    if (!currentParts || currentParts.join('.') !== localTarget) {
+      renameElement(j, element, localTarget);
+      ctx.dirty = true;
+    }
+
+    // Breakpoint objects: the universal `responsive` prop, plus the Column
+    // and Column.Group per-breakpoint shapes.
+    const kind = mapping.special
+      ? (RESPONSIVE_KINDS[mapping.special] ?? 'generic')
+      : 'generic';
+    flattenResponsiveProps(ctx, path, element, kind);
+
+    // Component-specific prop actions, then the universal helper pass.
+    if (mapping.props) {
+      for (const attr of [...attributesOf(element)]) {
+        const name = attr.name.name;
+        const action = mapping.props[name];
+        if (!action || handled.has(name)) continue;
+        handled.add(name);
+        applyPropAction(ctx, path, element, attr, action);
+      }
+    }
+    applyUniversalProps(ctx, path, element, handled, UNIVERSAL_PROPS);
+
+    // ---- 2a. badge/tooltip helper props → wrapping components ------------
+    // Last, so the inner element is already fully migrated. Both families are
+    // read off `element` — the props live there whichever wrapper is built
+    // first — while each wrapper takes the current outermost node as its
+    // child. Tooltip ends up outside Badge when both are present: the badge
+    // is positioned against the element it decorates, and the tooltip covers
+    // the pair.
+    let wrapped: any = element;
+    const badge = buildWrapper(
+      path,
+      element,
+      wrapped,
+      BADGE_PROPS,
+      'Badge',
+      'badge'
+    );
+    if (badge) wrapped = badge;
+    const tooltip = buildWrapper(
+      path,
+      element,
+      wrapped,
+      TOOLTIP_PROPS,
+      'Tooltip',
+      'tooltip'
+    );
+    if (tooltip) wrapped = tooltip;
+    if (wrapped !== element) path.replace(wrapped);
+  });
+
+  // ---- 2b. Value references to rbx components ---------------------------
+  // Components can be referenced as plain values too (`as={Block}`, passed to
+  // helpers, …). JSX usages were renamed above; map the leftover identifier
+  // references so the pruned rbx import doesn't strand them.
+  // A shorthand property's key and value are the SAME node, so the walker
+  // reaches it twice. The first visit rewrites it and detaches the original;
+  // the second then matched neither key nor value and fell through to the
+  // generic "referenced as a value" branch, emitting a spurious TODO and
+  // marking the root retained when it was not.
+  const handledValueRefs = new WeakSet<object>();
+
+  root.find(j.Identifier).forEach(path => {
+    // find(Identifier) also matches JSXIdentifier (a subtype) — JSX names
+    // were already handled by the element walker above.
+    if (path.node.type !== 'Identifier') return;
+    if (handledValueRefs.has(path.node)) return;
+    const name = path.node.name;
+    // A name bound by `const { Footer } = Card` is in `aliases`, not
+    // `imports` — and the destructuring pass has already deleted the
+    // declaration that bound it. Skipping those left `Footer.Item` in the
+    // output with its `Card` import pruned: a reference to nothing.
+    const aliasPath = aliasAt(name, path);
+    const imported = aliasPath ? aliasPath[0] : imports.get(name);
+    if (imported === undefined) return;
+    // Resolve by BINDING, not by name: a local that shadows the import is a
+    // different object, and rewriting it repoints the code at bestax's
+    // component.
+    if (!resolvesToBinding(path, name, aliasPath ? undefined : programScope)) {
+      return;
+    }
+    const parentNode = path.parent?.node;
+    const parentType = parentNode?.type;
+    if (
+      parentType === 'ImportSpecifier' ||
+      parentType === 'ImportDefaultSpecifier' ||
+      parentType === 'ImportNamespaceSpecifier' ||
+      parentType === 'JSXOpeningElement' ||
+      parentType === 'JSXClosingElement' ||
+      parentType === 'JSXMemberExpression'
+    ) {
+      return;
+    }
+    // A namespace binding in a real value position. `rbx.Button` is still a
+    // mappable component reference, so fall through to the member-expression
+    // branch below with an empty prefix (the namespace itself is not part of
+    // the rbx path). Anything else — a bare `rbx` — just pins the import.
+    const isNamespace = imported === '*';
+    if (
+      isNamespace &&
+      !(
+        parentType === 'MemberExpression' &&
+        parentNode.object === path.node &&
+        !parentNode.computed
+      )
+    ) {
+      namespaceStillReferenced = true;
+      return;
+    }
+    // Non-reference positions: member property names and object keys.
+    if (
+      parentType === 'MemberExpression' &&
+      parentNode.property === path.node &&
+      !parentNode.computed
+    ) {
+      return;
+    }
+    // Member-expression value references (`Card.Header`, `Tag.Group` used as
+    // expressions): resolve the full chain; when the bestax target is the same
+    // dotted chain the runtime compound still exists — only flag (or rewrite,
+    // for flat single-name targets) when it differs.
+    if (
+      parentType === 'MemberExpression' &&
+      parentNode.object === path.node &&
+      !parentNode.computed
+    ) {
+      // Walk the full chain: `Card.Footer.Item` is one path, not
+      // `Card.Footer` with a stray `.Item`. Resolving only the first level
+      // left the tail pointing at a compound bestax does not have
+      // (bestax exposes `Card.FooterItem`).
+      const memberPath = isNamespace ? [] : [...(aliasPath ?? [imported])];
+      let outer: any = path.parent;
+      while (
+        outer?.node?.type === 'MemberExpression' &&
+        !outer.node.computed &&
+        outer.node.property?.type === 'Identifier'
+      ) {
+        memberPath.push(nameOf(outer.node.property));
+        const next = outer.parent;
+        if (
+          next?.node?.type === 'MemberExpression' &&
+          next.node.object === outer.node
+        ) {
+          outer = next;
+        } else {
+          break;
+        }
+      }
+      const memberMapping = resolveMapping(memberPath);
+      const dotted = memberPath.join('.');
+      if (
+        memberMapping &&
+        memberMapping.status !== 'todo' &&
+        memberMapping.target &&
+        !memberMapping.special
+      ) {
+        if (memberMapping.target === dotted) {
+          if (isNamespace) {
+            // `rbx.Button` → `Button`: the namespace prefix has to go, so
+            // rebuild the chain from the target rather than renaming the
+            // namespace identifier in place (there is no MAPPING['*'] root
+            // to rename it to).
+            const [root, ...rest] = memberMapping.target.split('.');
+            let rebuilt: any = j.identifier(ctx.reserve(root));
+            for (const part of rest) {
+              rebuilt = j.memberExpression(rebuilt, j.identifier(part));
+            }
+            outer.replace(rebuilt);
+            ctx.dirty = true;
+            return;
+          }
+          if (aliasPath) {
+            // A destructured alias stands for MORE than one segment of the
+            // chain (`const { Header } = Card` makes `Header` mean
+            // `Card.Header`), so renaming the identifier drops every segment
+            // but the last: `Header.Title` became `Card.Title`. Rebuild the
+            // whole chain from the target instead.
+            const [aliasRoot, ...aliasRest] = memberMapping.target.split('.');
+            let rebuilt: any = j.identifier(ctx.reserve(aliasRoot));
+            for (const part of aliasRest) {
+              rebuilt = j.memberExpression(rebuilt, j.identifier(part));
+            }
+            outer.replace(rebuilt);
+            ctx.dirty = true;
+            return;
+          }
+          const rootMapping = MAPPING[imported];
+          if (rootMapping?.target) {
+            const local = ctx.reserve(rootMapping.target);
+            if (local !== name) path.node.name = local;
+            ctx.dirty = true;
+          }
+          return;
+        }
+        if (!memberMapping.target.includes('.')) {
+          // Flat target (Column.Group → Columns): swap the whole chain.
+          const local = ctx.reserve(memberMapping.target);
+          outer.replace(j.identifier(local));
+          ctx.dirty = true;
+          return;
+        }
+        // Dotted target that differs from the source chain
+        // (Card.Footer.Item → Card.FooterItem): rebuild the chain against the
+        // bestax path rather than flagging something the table can answer.
+        const [targetRoot, ...targetRest] = memberMapping.target.split('.');
+        const rootLocal = ctx.reserve(targetRoot);
+        let rebuilt: any = j.identifier(rootLocal);
+        for (const part of targetRest) {
+          rebuilt = j.memberExpression(rebuilt, j.identifier(part));
+        }
+        outer.replace(rebuilt);
+        ctx.dirty = true;
+        return;
+      }
+      addTodo(
+        ctx,
+        outer,
+        'value-reference',
+        `\`${isNamespace ? `${name}.` : ''}${dotted}\` is referenced as a value; migrate this usage by hand`
+      );
+      if (isNamespace) namespaceStillReferenced = true;
+      else ctx.retained.add(imported);
+      return;
+    }
+    if (
+      (parentType === 'ObjectProperty' || parentType === 'Property') &&
+      parentNode.key === path.node &&
+      !parentNode.shorthand
+    ) {
+      return;
+    }
+    // A shorthand property is both the key and the reference. Renaming the
+    // node in place rewrote the object's PUBLIC key
+    // (`{ Textarea }` → `{ TextArea }`), so expand it instead: the key keeps
+    // the name callers use, the value points at the migrated binding.
+    if (
+      (parentType === 'ObjectProperty' || parentType === 'Property') &&
+      parentNode.shorthand
+    ) {
+      // Resolve through the alias path when there is one: `const { Footer } =
+      // Card` makes `{ Footer }` mean `Card.Footer`, not `Card`. Reading the
+      // root's mapping here emitted `{ Footer: Card }` — the wrong component
+      // under the right key.
+      const shorthandMapping = aliasPath
+        ? resolveMapping(aliasPath)
+        : MAPPING[imported];
+      if (
+        shorthandMapping &&
+        shorthandMapping.status !== 'todo' &&
+        shorthandMapping.target &&
+        !shorthandMapping.special
+      ) {
+        const [root, ...rest] = shorthandMapping.target.split('.');
+        const local = ctx.reserve(root);
+        let value: any = j.identifier(local);
+        for (const part of rest) {
+          value = j.memberExpression(value, j.identifier(part));
+        }
+        if (rest.length > 0 || local !== name) {
+          // ast-types keeps DISTINCT key and value nodes even when
+          // `shorthand` is true, so both positions are visited. Mark both, or
+          // the second visit sees a node that matches neither the (new) key
+          // nor the (new) value and falls through to the generic branch.
+          handledValueRefs.add(parentNode.key);
+          handledValueRefs.add(parentNode.value);
+          parentNode.shorthand = false;
+          parentNode.key = j.identifier(name);
+          parentNode.value = value;
+          ctx.dirty = true;
+        }
+      } else {
+        // Mark both positions before reporting: the key and the value are
+        // distinct nodes, so an unmarked branch reports the same property
+        // twice. The AST comment dedupes, which hid this in the output while
+        // the report still double-counted it.
+        handledValueRefs.add(parentNode.key);
+        handledValueRefs.add(parentNode.value);
+        ctx.retained.add(imported);
+        addTodo(
+          ctx,
+          path,
+          'value-reference',
+          `\`${name}\` is referenced as a value; migrate this usage by hand`
+        );
+      }
+      return;
+    }
+    const mapping = aliasPath ? resolveMapping(aliasPath) : MAPPING[imported];
+    if (
+      mapping &&
+      mapping.status !== 'todo' &&
+      mapping.target &&
+      !mapping.special
+    ) {
+      const [root, ...rest] = mapping.target.split('.');
+      const local = ctx.reserve(root);
+      if (rest.length > 0) {
+        // A dotted target needs a member expression, not a rename. Without
+        // this, a destructured alias used as a bare value
+        // (`const { Content } = Card; const V = Content`) fell through to the
+        // TODO branch and was left referencing a binding the destructuring
+        // pass had already deleted.
+        let value: any = j.identifier(local);
+        for (const part of rest) {
+          value = j.memberExpression(value, j.identifier(part));
+        }
+        path.replace(value);
+      } else if (local !== name) {
+        path.node.name = local;
+      }
+      ctx.dirty = true;
+    } else {
+      ctx.retained.add(imported);
+      addTodo(
+        ctx,
+        path,
+        'value-reference',
+        `\`${name}\` is referenced as a value; migrate this usage by hand`
+      );
+    }
+  });
+
+  // ---- 3. Rewrite imports -----------------------------------------------
+  if (imports.size > 0) {
+    const retainedNames = [...ctx.retained].sort((a, b) => a.localeCompare(b));
+
+    const freshNames = [...ctx.needed.entries()]
+      .filter(([imported]) => !preExistingImports.has(imported))
+      .sort((a, b) => a[0].localeCompare(b[0]));
+    const bestaxImport =
+      freshNames.length > 0
+        ? j.importDeclaration(
+            freshNames.map(([imported, local]) =>
+              j.importSpecifier(j.identifier(imported), j.identifier(local))
+            ),
+            j.stringLiteral(BESTAX)
+          )
+        : null;
+
+    let inserted = false;
+    // A retained rbx specifier must never collide with a bestax import local
+    // (possible when one component is both JSX-migrated and value-retained).
+    const bestaxLocals = new Set(ctx.needed.values());
+    for (const path of rbxImportPaths) {
+      const node = path.node;
+      const keepSpecifiers = (node.specifiers ?? []).filter((spec: any) => {
+        // `import * as rbx` reaches every export at once, so it has to
+        // survive whenever ANY component is retained — the JSX still says
+        // `<rbx.Tile>`, and pruning the import leaves `rbx is not defined`.
+        if (spec.type === 'ImportNamespaceSpecifier') {
+          return ctx.retained.size > 0 || namespaceStillReferenced;
+        }
+        // Keep a default binding rather than stranding its references.
+        if (spec.type === 'ImportDefaultSpecifier') return sawDefaultImport;
+        return (
+          spec.type === 'ImportSpecifier' &&
+          ctx.retained.has(nameOf(spec.imported)) &&
+          !bestaxLocals.has(nameOf(spec.local))
+        );
+      });
+      if (!inserted) {
+        if (existingBestax && bestaxImport) {
+          existingBestax.node.specifiers = [
+            ...(existingBestax.node.specifiers ?? []),
+            ...bestaxImport.specifiers!,
+          ];
+        } else if (bestaxImport) {
+          path.insertBefore(bestaxImport);
+        }
+        inserted = true;
+      }
+      const droppedOnCollision = (node.specifiers ?? []).filter(
+        (spec: any) =>
+          spec.type === 'ImportSpecifier' &&
+          ctx.retained.has(nameOf(spec.imported)) &&
+          bestaxLocals.has(nameOf(spec.local))
+      );
+      for (const spec of droppedOnCollision) {
+        addTodo(
+          ctx,
+          path,
+          'imports',
+          `\`${nameOf(spec.imported)}\` is retained but its local name \`${nameOf(spec.local)}\` is also a bestax import in this file; rename one of them by hand — its JSX would otherwise resolve to the bestax component`
+        );
+      }
+      if (keepSpecifiers.length > 0) {
+        node.specifiers = keepSpecifiers;
+        // Only when named/namespace bindings are being retained. An import
+        // kept solely for a broken default binding has no names to list, and
+        // already carries its own "rbx has no default export" TODO.
+        if (retainedNames.length > 0) {
+          node.comments = node.comments ?? [];
+          const text = ` TODO(bestax-migrate): ${retainedNames.join(', ')} ${
+            retainedNames.length === 1 ? 'has' : 'have'
+          } no bestax-bulma equivalent yet — migrate and remove this import`;
+          if (!node.comments.some((c: any) => c.value === text)) {
+            node.comments.push(j.commentLine(text, true, false));
+          }
+        }
+      } else {
+        path.prune();
+      }
+      ctx.dirty = true;
+    }
+  }
+
+  // Flush the deferred stylesheet notes onto the first node that survived the
+  // import rewrite, so the drop is visible in the file and not only the report.
+  if (!ctx.dirty) return undefined;
+  // Double quotes match the dominant JSX-attribute convention; users run
+  // their own formatter afterwards anyway. Tab-indented sources keep tabs so
+  // reprinted nodes don't drift from the untouched lines around them.
+  return root.toSource({
+    quote: 'double',
+    useTabs: prefersTabs(fileInfo.source),
+  });
+}
diff --git a/bestax-migrate/src/sources/react-bulma-components/__tests__/deps.test.ts b/bestax-migrate/src/sources/react-bulma-components/__tests__/deps.test.ts
index 8e6cd3b6d..919f93ae1 100644
--- a/bestax-migrate/src/sources/react-bulma-components/__tests__/deps.test.ts
+++ b/bestax-migrate/src/sources/react-bulma-components/__tests__/deps.test.ts
@@ -117,3 +117,31 @@ describe('updateDependencies', () => {
     expect(next).toBeNull();
   });
 });
+
+describe('retained-import warning', () => {
+  // The transform retains Element/Tile imports so a partly migrated app still
+  // runs, while this updater removes the package -- so the install the report
+  // asks for strands exactly those imports. rbx has warned about this since it
+  // shipped; this source retains imports the same way and did not.
+  it('warns when files still import the source after removal', () => {
+    const todos: TodoEntry[] = [];
+    updateDependencies(
+      'package.json',
+      { name: 'a', dependencies: { 'react-bulma-components': '^4.1.0' } },
+      { add: e => todos.push(e) },
+      { cssMode: 'bestax', bulmaReferenced: false, sourceStillImported: true }
+    );
+    expect(todos.map(t => t.message).join('\n')).toMatch(/still import it/);
+  });
+
+  it('stays quiet when nothing still imports it', () => {
+    const todos: TodoEntry[] = [];
+    updateDependencies(
+      'package.json',
+      { name: 'a', dependencies: { 'react-bulma-components': '^4.1.0' } },
+      { add: e => todos.push(e) },
+      { cssMode: 'bestax', bulmaReferenced: false, sourceStillImported: false }
+    );
+    expect(todos.map(t => t.message).join('\n')).not.toMatch(/still import it/);
+  });
+});
diff --git a/bestax-migrate/src/sources/react-bulma-components/__tests__/styles.test.ts b/bestax-migrate/src/sources/react-bulma-components/__tests__/styles.test.ts
index 7225e67b8..3d1ce8d3c 100644
--- a/bestax-migrate/src/sources/react-bulma-components/__tests__/styles.test.ts
+++ b/bestax-migrate/src/sources/react-bulma-components/__tests__/styles.test.ts
@@ -486,3 +486,32 @@ describe('transformStyles (.sass indented syntax)', () => {
     expect(run('main.sass', first).output).toBeNull();
   });
 });
+
+describe('shared styles factory changes from the rbx work', () => {
+  it('rewrites a BARE react-bulma-components @import, not only `<pkg>/…`', () => {
+    // The shared factory made the path after the package name optional. That
+    // was added for `@import '~rbx'`, but it reaches RBC's bare form too and
+    // no RBC fixture covered it.
+    const out = transformStyles(
+      'styles.scss',
+      '@import "react-bulma-components";\n',
+      { add: () => {} },
+      { cssMode: 'bestax' }
+    );
+    expect(out).toContain("@use 'bulma/sass'");
+    expect(out).not.toContain('react-bulma-components');
+  });
+});
+
+describe('a trailing line comment on a source import', () => {
+  it('does not defeat the full-line match', () => {
+    const out = transformStyles(
+      'styles.scss',
+      '@import "react-bulma-components"; // legacy root\n',
+      { add: () => {} },
+      { cssMode: 'bestax' }
+    );
+    expect(out).toContain("@use 'bulma/sass'");
+    expect(out).not.toContain('react-bulma-components');
+  });
+});
diff --git a/bestax-migrate/src/sources/react-bulma-components/__tests__/transform.test.ts b/bestax-migrate/src/sources/react-bulma-components/__tests__/transform.test.ts
index 680bf7bfb..dc9125078 100644
--- a/bestax-migrate/src/sources/react-bulma-components/__tests__/transform.test.ts
+++ b/bestax-migrate/src/sources/react-bulma-components/__tests__/transform.test.ts
@@ -607,6 +607,108 @@ describe('react-bulma-components transform fixtures', () => {
     });
   });
 
+  describe('names bound by destructuring are value references too', () => {
+    it('resolves a member chain through the alias', () => {
+      // `const { Field } = Form` is deleted by the destructuring pass, so
+      // skipping `Field` here left `Field.Label` referencing nothing once the
+      // Form import was pruned.
+      const source = [
+        "import { Form } from 'react-bulma-components';",
+        'const { Field } = Form;',
+        'const value = Field.Label;',
+        'export const A = () => <>{String(value)}</>;',
+      ].join('\n');
+      const { output } = runTransform(transform, 'alias-value.tsx', source);
+      expect(output).toContain('const value = FieldLabel;');
+      expect(output).not.toContain('react-bulma-components');
+    });
+  });
+
+  describe('a destructured alias used as a bare value', () => {
+    it('resolves a dotted target to a member expression', () => {
+      const source = [
+        "import { Card } from 'react-bulma-components';",
+        'const { Header } = Card;',
+        'const V = Header;',
+        'export const A = () => <Header>{String(V)}</Header>;',
+      ].join('\n');
+      const { output } = runTransform(transform, 'bare-alias.tsx', source);
+      expect(output).toContain('const V = Card.Header;');
+      expect(output).not.toContain('react-bulma-components');
+    });
+  });
+
+  describe('a namespace import survives when something still needs it', () => {
+    it('keeps it when a retained component references it', () => {
+      // `<RBC.Tile>` stays in the JSX (Tile is unmappable), so pruning the
+      // import leaves `RBC is not defined`.
+      const source = [
+        "import * as RBC from 'react-bulma-components';",
+        'export const A = () => <RBC.Tile><RBC.Box>x</RBC.Box></RBC.Tile>;',
+      ].join('\n');
+      const { output } = runTransform(transform, 'ns.tsx', source);
+      expect(output).toContain("import * as RBC from 'react-bulma-components'");
+      expect(output).toContain('<RBC.Tile>');
+      expect(output).toContain('<Box>');
+    });
+
+    it('keeps it when the namespace is referenced as a value', () => {
+      const source = [
+        "import * as RBC from 'react-bulma-components';",
+        'export const A = () => <RBC.Box>{String(RBC)}</RBC.Box>;',
+      ].join('\n');
+      const { output } = runTransform(transform, 'ns-value.tsx', source);
+      expect(output).toContain("import * as RBC from 'react-bulma-components'");
+    });
+
+    it('still prunes it when nothing does', () => {
+      const source = [
+        "import * as RBC from 'react-bulma-components';",
+        'export const A = () => <RBC.Box>x</RBC.Box>;',
+      ].join('\n');
+      const { output } = runTransform(transform, 'ns-clean.tsx', source);
+      expect(output).not.toContain('react-bulma-components');
+      expect(output).toContain('<Box>x</Box>');
+    });
+  });
+
+  describe('a retained RBC binding never loses its name to a bestax import', () => {
+    it('aliases the bestax local instead of dropping the retained specifier', () => {
+      // `Element as Button` is unmappable and retained; another RBC component
+      // wants bestax's `Button`. Dropping the retained specifier made
+      // `<Button>` — which was an Element — silently render a bestax Button.
+      const source = [
+        "import { Element as Button, Button as RealButton } from 'react-bulma-components';",
+        'export const A = () => (',
+        '  <><Button>element</Button><RealButton>button</RealButton></>',
+        ');',
+      ].join('\n');
+      const { output } = runTransform(transform, 'alias.tsx', source);
+      expect(output).toContain(
+        "import { Element as Button } from 'react-bulma-components'"
+      );
+      expect(output).toMatch(/Button as Bulma\w+/);
+      expect(output).toContain('<Button>element</Button>');
+    });
+  });
+
+  describe('shared helpers that changed under the rbx work', () => {
+    // `_shared/specials-utils.ts` is used by both sources, so a fix made for
+    // rbx changes react-bulma-components output too. These lock in the two
+    // that did, which no RBC fixture previously covered.
+    it('does not read a Font Awesome modifier as the icon name', () => {
+      const source = [
+        "import { Icon } from 'react-bulma-components';",
+        'export const A = () => (',
+        '  <Icon><i className="fas fa-rotate-90 fa-home" /></Icon>',
+        ');',
+      ].join('\n');
+      const { output } = runTransform(transform, 'icon-modifier.tsx', source);
+      expect(output).toContain('name="home"');
+      expect(output).not.toContain('rotate-90"');
+    });
+  });
+
   describe('stylesheet imports', () => {
     const RBC_CSS =
       "import 'react-bulma-components/dist/react-bulma-components.min.css';\n";
diff --git a/bestax-migrate/src/sources/react-bulma-components/__tests__/value-references.test.ts b/bestax-migrate/src/sources/react-bulma-components/__tests__/value-references.test.ts
new file mode 100644
index 000000000..f0de571e3
--- /dev/null
+++ b/bestax-migrate/src/sources/react-bulma-components/__tests__/value-references.test.ts
@@ -0,0 +1,245 @@
+/**
+ * Value-reference regressions found by review of the rbx source: three
+ * defects the rbx transform had already been fixed for, which this source
+ * still carried. Each produced a silent break — a chain bestax does not
+ * expose, a stranded import, or a renamed object key — with no TODO to warn
+ * the user, and none of the 17 fixture pairs reached the code path.
+ */
+
+import transform from '../transform.js';
+import { runTransform } from '../../../runner.js';
+import type { TodoEntry } from '../../../types.js';
+
+function migrate(source: string) {
+  const todos: TodoEntry[] = [];
+  const { output } = runTransform(transform, 'c.tsx', source, {
+    add: entry => todos.push(entry),
+  });
+  return { output: output ?? source, todos };
+}
+
+describe('member-expression value references', () => {
+  it('resolves the whole chain, not just its first valid prefix', () => {
+    // `Card.Footer` resolves on its own, so stopping there left the tail
+    // `.Item` pointing at a compound bestax has no such thing as.
+    const { output } = migrate(
+      `import { Card } from 'react-bulma-components';\nconst C = Card.Footer.Item;\n`
+    );
+    expect(output).toContain('const C = Card.FooterItem;');
+    expect(output).not.toContain('Card.Footer.Item');
+  });
+
+  it('rewrites a flat target across the whole chain', () => {
+    const { output } = migrate(
+      `import { Icon } from 'react-bulma-components';\nconst C = Icon.Text;\n`
+    );
+    expect(output).toContain('const C = IconText;');
+  });
+
+  it('maps a namespace member instead of stranding the import', () => {
+    // `const C = RBC.Box` used to be treated as an opaque namespace value:
+    // the reference stayed, the import was retained, and dependency migration
+    // then removed the package out from under it.
+    const { output } = migrate(
+      `import * as RBC from 'react-bulma-components';\nconst C = RBC.Box;\n`
+    );
+    expect(output).toContain('from "@allxsmith/bestax-bulma"');
+    expect(output).toContain('const C = Box;');
+    expect(output).not.toContain('RBC.Box');
+    expect(output).not.toContain("'react-bulma-components'");
+  });
+
+  it('still pins the import for a bare namespace reference', () => {
+    const { output } = migrate(
+      `import * as RBC from 'react-bulma-components';\nconsole.log(RBC);\n`
+    );
+    expect(output).toContain("'react-bulma-components'");
+  });
+
+  it('flags an unmappable namespace member rather than rewriting it', () => {
+    const { todos } = migrate(
+      `import * as RBC from 'react-bulma-components';\nconst C = RBC.NotAThing;\n`
+    );
+    expect(todos.some(t => t.rule === 'value-reference')).toBe(true);
+  });
+});
+
+describe('object shorthand properties', () => {
+  it('expands rather than renaming the object key', () => {
+    // `{ Textarea }` became `{ TextArea }`, silently changing the object's
+    // public shape: every `m.Textarea` caller started reading undefined.
+    const { output } = migrate(
+      `import { Form } from 'react-bulma-components';\nconst { Textarea } = Form;\nconst m = { Textarea };\n`
+    );
+    expect(output).toContain('{ Textarea: TextArea }');
+  });
+
+  it('expands a shorthand whose alias maps to a renamed component', () => {
+    const { output } = migrate(
+      `import { Button } from 'react-bulma-components';\nconst { Group } = Button;\nconst m = { Group };\n`
+    );
+    expect(output).toContain('{ Group: Buttons }');
+  });
+
+  it('resolves the shorthand through its alias path, not the root', () => {
+    // Reading the root's mapping here emitted `{ Footer: Card }` — the wrong
+    // component under the right key.
+    const { output } = migrate(
+      `import { Card } from 'react-bulma-components';\nconst { Footer } = Card;\nconst m = { Footer };\n`
+    );
+    expect(output).toContain('{ Footer: Card.Footer }');
+  });
+
+  it('leaves a shorthand alone when the name needs no rewrite', () => {
+    const { output } = migrate(
+      `import { Box } from 'react-bulma-components';\nconst m = { Box };\n`
+    );
+    expect(output).toContain('{ Box }');
+  });
+
+  it('emits exactly one TODO for an unmappable shorthand', () => {
+    // The key and value are distinct nodes, so the walker reaches the
+    // property twice; without the handled-set the second visit emitted a
+    // spurious second TODO and retained a root that needed no retaining.
+    const { todos } = migrate(
+      `import { Tile } from 'react-bulma-components';\nconst m = { Tile };\n`
+    );
+    expect(todos.filter(t => t.rule === 'value-reference')).toHaveLength(1);
+  });
+
+  it('does not touch a non-shorthand key that merely shares the name', () => {
+    const { output } = migrate(
+      `import { Box } from 'react-bulma-components';\nconst m = { Box: 1 };\n`
+    );
+    expect(output).toContain('{ Box: 1 }');
+  });
+});
+
+describe('binding resolution', () => {
+  it('leaves a local that shadows the import alone', () => {
+    // Resolving by identifier text rewrote a shadowing parameter as though it
+    // were the library's component, repointing the code at a different
+    // object -- and renamed the destructured parameter alongside it.
+    const { output } = migrate(
+      [
+        `import { Card } from 'react-bulma-components';`,
+        'function F({ Card }) { return <Card.Footer.Item/>; }',
+        'export const G = () => <Card.Footer.Item/>;',
+      ].join('\n')
+    );
+    expect(output).toContain(
+      'function F({ Card }) { return <Card.Footer.Item/>; }'
+    );
+    // The module-level reference still migrates.
+    expect(output).toMatch(/<Bulma?Card\.FooterItem\/>/);
+  });
+
+  it('leaves a shadowing local const alone', () => {
+    const { output } = migrate(
+      [
+        `import { Box } from 'react-bulma-components';`,
+        'function F() { const Box = 1; return Box; }',
+        'export const G = () => <Box/>;',
+      ].join('\n')
+    );
+    expect(output).toContain('const Box = 1;');
+  });
+
+  it('still migrates an alias destructured inside a function', () => {
+    // The alias pass walks declarators at any depth, so the scope guard must
+    // compare against the scope the alias was collected in, not the module.
+    const { output } = migrate(
+      [
+        `import { Card } from 'react-bulma-components';`,
+        'export function F(){ const { Header } = Card; return <Header.Title/>; }',
+      ].join('\n')
+    );
+    expect(output).toContain('Card.Header.Title');
+  });
+
+  it('rebuilds the full chain through a destructured alias', () => {
+    // The equal-target branch renamed `Header` to `Card`, so `Header.Title`
+    // collapsed to `Card.Title` -- a segment silently dropped.
+    const { output } = migrate(
+      [
+        `import { Card } from 'react-bulma-components';`,
+        'const { Header } = Card;',
+        'const T = Header.Title;',
+      ].join('\n')
+    );
+    expect(output).toContain('const T = Card.Header.Title;');
+  });
+});
+
+describe('bestax import assembly', () => {
+  it('does not merge named specifiers into a namespace import', () => {
+    // `import * as Bulma, { Box } from ...` is not valid JavaScript, so the
+    // whole file stopped parsing after a migration that reported success.
+    const { output } = migrate(
+      [
+        `import * as Bulma from '@allxsmith/bestax-bulma';`,
+        `import * as RBC from 'react-bulma-components';`,
+        'const C = RBC.Box;',
+        'export const x = <Bulma.Button/>;',
+      ].join('\n')
+    );
+    expect(output).not.toMatch(/import \* as \w+,/);
+    expect(output).toContain('const C = Box;');
+  });
+
+  it('still merges into an existing all-named bestax import', () => {
+    const { output } = migrate(
+      [
+        `import { Button } from '@allxsmith/bestax-bulma';`,
+        `import { Box } from 'react-bulma-components';`,
+        'export const x = <><Button/><Box/></>;',
+      ].join('\n')
+    );
+    expect(output.match(/from ["']@allxsmith\/bestax-bulma["']/g)).toHaveLength(
+      1
+    );
+  });
+});
+
+describe('alias scoping and retained partial roots', () => {
+  it('keeps two same-named aliases in separate scopes apart', () => {
+    const { output } = migrate(
+      [
+        `import { Card, Panel } from 'react-bulma-components';`,
+        'export function A(){ const { Header } = Card; return <Header.Title/>; }',
+        'export function B(){ const { Header } = Panel; return <Header/>; }',
+      ].join('\n')
+    );
+    expect(output).toContain('Card.Header.Title');
+    expect(output).toContain('Panel.Heading');
+  });
+
+  it('aliases the bestax root when a partial root is retained', () => {
+    const { output } = migrate(
+      [
+        `import { Icon } from 'react-bulma-components';`,
+        'export const a = <Icon/>;',
+        'export const b = <Icon.Unknown/>;',
+      ].join('\n')
+    );
+    expect(output).toMatch(/Icon as Bulma\w+/);
+    expect(output).toMatch(
+      /import \{ Icon \} from ["']react-bulma-components["']/
+    );
+  });
+});
+
+describe('an alias shadowed by a nearer binding', () => {
+  it('leaves a parameter that shadows a module-level alias alone', () => {
+    const { output } = migrate(
+      [
+        `import { Card } from 'react-bulma-components';`,
+        'const { Header } = Card;',
+        'export const A = () => <Header.Title/>;',
+        'export function F(Header) { return <Header.Title/>; }',
+      ].join('\n')
+    );
+    expect(output).toContain('<Card.Header.Title/>');
+    expect(output).toContain('function F(Header) { return <Header.Title/>; }');
+  });
+});
diff --git a/bestax-migrate/src/sources/react-bulma-components/deps.ts b/bestax-migrate/src/sources/react-bulma-components/deps.ts
index e870ef564..eb37f2963 100644
--- a/bestax-migrate/src/sources/react-bulma-components/deps.ts
+++ b/bestax-migrate/src/sources/react-bulma-components/deps.ts
@@ -35,14 +35,32 @@ export const updateDependencies: DependenciesUpdate = (
   };
 
   // react-bulma-components goes away entirely.
+  let removedSource = false;
   for (const name of DEP_SECTIONS) {
     const deps = section(name);
     if (deps && 'react-bulma-components' in deps) {
       delete deps['react-bulma-components'];
+      removedSource = true;
       note(`removed react-bulma-components from ${name}`);
     }
   }
 
+  // The transform deliberately RETAINS imports for components with no bestax
+  // equivalent (Element, Tile) so a partially migrated app still runs.
+  // Removing the package from the manifest strands exactly those imports once
+  // the user runs the install the report asks for, so say so rather than
+  // letting them find out at build time. rbx has carried this warning since
+  // it shipped; this source retains imports the same way and did not.
+  if (removedSource && options.sourceStillImported) {
+    collector?.add({
+      file: filePath,
+      line: null,
+      rule: 'deps',
+      message:
+        'react-bulma-components was removed from package.json, but some files still import it for components with no bestax equivalent — resolve those `TODO(bestax-migrate)` imports before installing, or re-add react-bulma-components until you have',
+    });
+  }
+
   // @allxsmith/bestax-bulma comes in (runtime dependency).
   const dependencies = (next.dependencies ??= {}) as Record<string, string>;
   if (
diff --git a/bestax-migrate/src/sources/react-bulma-components/responsive.ts b/bestax-migrate/src/sources/react-bulma-components/responsive.ts
index 856534261..1d8388997 100644
--- a/bestax-migrate/src/sources/react-bulma-components/responsive.ts
+++ b/bestax-migrate/src/sources/react-bulma-components/responsive.ts
@@ -20,7 +20,7 @@ import {
   makeAttr,
   removeAttr,
   type TransformContext,
-} from './jsx-utils.js';
+} from '../_shared/jsx-utils.js';
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
diff --git a/bestax-migrate/src/sources/react-bulma-components/specials.ts b/bestax-migrate/src/sources/react-bulma-components/specials.ts
index 69ecab22e..553180e8e 100644
--- a/bestax-migrate/src/sources/react-bulma-components/specials.ts
+++ b/bestax-migrate/src/sources/react-bulma-components/specials.ts
@@ -22,151 +22,24 @@ import {
   removeAttr,
   resolveBooleanish,
   type TransformContext,
-} from './jsx-utils.js';
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-export interface SpecialResult {
-  /** Override the mapping's `target` for the rename step. */
-  target?: string;
-  /** The node was replaced outright — skip rename and prop passes. */
-  replaced?: boolean;
-  /** Prop names the handler consumed; skipped by the later prop passes. */
-  handledProps?: string[];
-}
-
-type SpecialHandler = (
-  ctx: TransformContext,
-  path: ASTPath<any>,
-  element: any
-) => SpecialResult;
-
-/** Pick a target based on a literal align-style prop, removing the prop. */
-function alignTarget(
-  ctx: TransformContext,
-  path: ASTPath<any>,
-  element: any,
-  prop: string,
-  targets: Record<string, string>,
-  fallback: string
-): SpecialResult {
-  const attr = findAttr(element, prop);
-  if (!attr) return { target: fallback };
-  const literal = literalValueOf(attr);
-  if (literal.kind === 'string' && targets[literal.value]) {
-    removeAttr(element, attr);
-    ctx.dirty = true;
-    return { target: targets[literal.value] };
-  }
-  if (literal.kind === 'string') {
-    removeAttr(element, attr);
-    ctx.dirty = true;
-    return { target: fallback };
-  }
-  addTodo(
-    ctx,
-    path,
-    `prop:${prop}`,
-    `\`${prop}\` has a dynamic value; pick between ${Object.values(targets).join(' / ')} by hand`
-  );
-  removeAttr(element, attr);
-  ctx.dirty = true;
-  return { target: fallback };
-}
+} from '../_shared/jsx-utils.js';
+import {
+  alignTarget,
+  makeStripModifierProps,
+  mergeClassName,
+  parseIconClasses,
+  type SpecialHandler,
+  type SpecialResult,
+} from '../_shared/specials-utils.js';
 
-/**
- * Filter Bulma modifier props out of an attribute list bound for a plain HTML
- * element (they only exist on bestax components), leaving a TODO when any
- * were dropped.
- */
-function stripModifierProps(
-  ctx: TransformContext,
-  path: ASTPath<any>,
-  attrs: any[],
-  where: string
-): any[] {
-  const kept: any[] = [];
-  const dropped: string[] = [];
-  for (const attr of attrs) {
-    const name = attr?.name?.name;
-    if (name && (UNIVERSAL_PROPS[name] || name in RESPONSIVE_BREAKPOINTS)) {
-      dropped.push(name);
-    } else {
-      kept.push(attr);
-    }
-  }
-  if (dropped.length > 0) {
-    addTodo(
-      ctx,
-      path,
-      'plain-element',
-      `${where} became a plain element; the Bulma helper prop(s) ${dropped
-        .map(d => `\`${d}\``)
-        .join(', ')} were dropped — restyle with classes`
-    );
-  }
-  return kept;
-}
+export type { SpecialResult };
 
-/**
- * Consume the element's `className` so a plain-element rewrite can merge it
- * with its hard-coded Bulma class instead of dropping it. A dynamic value
- * can't be merged safely — keep the base class and leave a TODO.
- */
-function mergeClassName(
-  ctx: TransformContext,
-  path: ASTPath<any>,
-  element: any,
-  base: string | undefined,
-  where: string
-): string | undefined {
-  const attr = findAttr(element, 'className');
-  if (!attr) return base;
-  const literal = literalValueOf(attr);
-  removeAttr(element, attr);
-  if (literal.kind === 'string') {
-    return base ? `${base} ${literal.value}` : literal.value;
-  }
-  addTodo(
-    ctx,
-    path,
-    'prop:className',
-    base
-      ? `dynamic ${where} className; merge it with the \`${base}\` class by hand`
-      : `dynamic ${where} className; re-apply it to the emitted element by hand`
-  );
-  return base;
-}
+/* eslint-disable @typescript-eslint/no-explicit-any */
 
-/** Parse an icon-font <i className="..."> into bestax Icon name/library/variant. */
-function parseIconClasses(
-  className: string
-): { name: string; library?: string; variant?: string } | null {
-  const tokens = className.trim().split(/\s+/);
-  const faVariant: Record<string, string> = {
-    fas: 'solid',
-    far: 'regular',
-    fab: 'brands',
-    fal: 'light',
-    fad: 'duotone',
-  };
-  const faStyle = tokens.find(t => faVariant[t]);
-  const faName = tokens.find(
-    t => /^fa-/.test(t) && !/^fa-(lg|xs|sm|\dx|fw|spin|pulse)$/.test(t)
-  );
-  if (faStyle && faName) {
-    return {
-      name: faName.replace(/^fa-/, ''),
-      library: 'fa',
-      variant: faVariant[faStyle],
-    };
-  }
-  if (tokens.includes('mdi')) {
-    const mdiName = tokens.find(t => /^mdi-/.test(t) && t !== 'mdi');
-    if (mdiName) return { name: mdiName.replace(/^mdi-/, ''), library: 'mdi' };
-  }
-  return null;
-}
+const stripModifierProps = makeStripModifierProps(
+  UNIVERSAL_PROPS,
+  RESPONSIVE_BREAKPOINTS
+);
 
 const SPECIALS: Record<string, SpecialHandler> = {
   /**
diff --git a/bestax-migrate/src/sources/react-bulma-components/styles.ts b/bestax-migrate/src/sources/react-bulma-components/styles.ts
index be21ffe6b..aaf4b13f2 100644
--- a/bestax-migrate/src/sources/react-bulma-components/styles.ts
+++ b/bestax-migrate/src/sources/react-bulma-components/styles.ts
@@ -1,503 +1,23 @@
 /**
- * Stylesheet migration for react-bulma-components apps: Bulma 0.9 Sass
- * (`@import` + `$var !default` overrides, `_all` aggregator partials) →
- * Bulma v1 modules (`@use "bulma/sass" with (…)`), plus the bestax extras.
+ * Stylesheet migration for react-bulma-components apps.
  *
- * Sass has no jscodeshift parser, so this is a conservative line-based text
- * transform: it only rewrites patterns it can prove safe and leaves a
- * `// TODO(bestax-migrate): …` everywhere else (line comments are valid in
- * both SCSS and indented Sass).
- */
-
-import path from 'node:path';
-import type { StylesTransform, TodoCollector } from '../../types.js';
-
-const TODO = 'TODO(bestax-migrate)';
-const GUIDE =
-  'https://bestax.io/docs/guides/getting-started/migration/react-bulma-components';
-const EXTRAS_USE = "@use '@allxsmith/bestax-bulma/scss/extras';";
-
-/** Bulma v1 sass tree — directories that replaced the 0.9 `_all` partials. */
-const V1_DIRS = new Set([
-  'utilities',
-  'base',
-  'elements',
-  'form',
-  'components',
-  'grid',
-  'layout',
-  'helpers',
-  'themes',
-]);
-
-/** Known Bulma v1 leaf partials (path after `bulma/sass/`). */
-const V1_LEAVES = new Set([
-  'utilities/initial-variables',
-  'utilities/derived-variables',
-  'utilities/css-variables',
-  'utilities/mixins',
-  'utilities/functions',
-  'utilities/controls',
-  'utilities/extends',
-  'themes/light',
-  'themes/dark',
-  'themes/setup',
-]);
-
-/**
- * The 0.9 root imports that become `@use "bulma/sass"`. The specifier may be
- * bare (`bulma/bulma`), tilde-prefixed (webpack), or a relative path into
- * node_modules (`../../node_modules/bulma/bulma`, common under Parcel) —
- * relative prefixes are preserved in the emitted `@use`.
- */
-const ROOT_IMPORT =
-  /^(\s*)@import\s+(['"])((?:\.\.?\/)+node_modules\/|~)?bulma\/(?:bulma(?:\.sass|\.scss)?|css\/bulma(?:\.min)?\.css)\2\s*;?\s*$/;
-
-/** 0.9 partial imports under bulma/sass/… (same prefix forms as the root). */
-const PARTIAL_IMPORT =
-  /^(\s*)@import\s+(['"])((?:\.\.?\/)+node_modules\/|~)?bulma\/sass\/([\w/-]+)\2\s*;?\s*$/;
-
-/** A preserved path prefix for the rewritten `@use` (tilde never survives). */
-function keptPrefix(prefix: string | undefined): string {
-  return prefix && prefix !== '~' ? prefix : '';
-}
-
-/** Any other line that still `@import`s something bulma-ish. */
-const OTHER_BULMA_IMPORT = /^\s*@import\s+['"][^'"]*bulma[^'"]*['"]/;
-
-/**
- * Third-party Bulma extension packages (`bulma-checkradio`, `bulma-switch`,
- * …) — 0.9-era add-ons whose v1 compatibility varies; several are covered
- * by the bestax extras. The `bulma-` package name must start at a specifier
- * segment boundary (right after the quote/`~`, or after a `/`) so this does
- * not also match a name that merely *contains* `bulma-`, like
- * `react-bulma-components` (see EXTENSION_IMPORT's own regression test).
- */
-const EXTENSION_IMPORT =
-  /^\s*@import\s+['"](?:~|[^'"]*\/)?bulma-([\w-]+?)(?:\/|\.|['"])/;
-
-/**
- * The source library's own stylesheet. This is not a third-party extension:
- * it is the library being migrated away from, and `deps.ts` removes its
- * package.json entry in the same run, so leaving the import in place breaks
- * the Sass build. Any `react-bulma-components/…` specifier is dead the same
- * way — the documented v3 setup paths (the bundled CSS, the "advanced" Sass
- * entry point), but also deep partials and extensionless forms — so, like
- * `transform.ts`, we match on the package prefix rather than enumerating
- * shapes. The prefix may be bare, `~`-prefixed, or a relative node_modules
- * path (the Parcel form `ROOT_IMPORT` also supports).
- */
-const RBC_STYLE_IMPORT =
-  /^(\s*)@import\s+(['"])((?:\.\.?\/)+node_modules\/|~)?react-bulma-components\/[^'"]*\2\s*;?\s*$/;
-
-/**
- * The subset of RBC stylesheet imports that are the library's own *root*: the
- * bare package specifier, the documented Sass entry point (`src/index`), and
- * the bundled v3 CSS (`dist/react-bulma-components(.min).css`). These pull in
- * the whole library, which `bulma/sass` supersedes — so when the file already
- * has a Bulma root, dropping one of these loses nothing. A deep RBC partial
- * (`src/components/navbar.sass`) is NOT a root: `bulma/sass` doesn't carry a
- * given partial's styles, so removing one silently would drop CSS. We flag
- * those instead (the package's "never a silent skip" rule).
- */
-const RBC_ROOT_STYLESHEET =
-  /^\s*@import\s+(['"])(?:(?:\.\.?\/)+node_modules\/|~)?react-bulma-components(?:\/src\/index(?:\.s[ac]ss)?|\/dist\/react-bulma-components(?:\.min)?\.css)?\1\s*;?\s*$/;
-
-/**
- * A Bulma module root already pulled in via `@use` — the file's own
- * `@use 'bulma/sass'` (any prefix, configured or not) or the bestax bundle
- * (`scss/bestax`, which itself loads `bulma/sass with (…)`). When one is
- * present we must not emit a second root: a duplicate `bulma/sass` namespace,
- * or reconfiguring an already-loaded module, is a hard Sass error.
- */
-const USE_BULMA_ROOT =
-  /^\s*@use\s+(['"])(?:~|(?:\.\.?\/)+node_modules\/)?(?:bulma\/sass|@allxsmith\/bestax-bulma\/(?:src\/)?scss\/bestax)\1/;
-
-/** Any `$name: value;` declaration (with or without `!default`). */
-const VAR_DECL = /^\s*\$([\w-]+)\s*:\s*(.+?)\s*(!default)?\s*;\s*$/;
-
-/**
- * Strips Sass block comments (slash-star … star-slash spans) from a value
- * before it is analyzed for foldability or top-level commas. A comment can
- * carry an unbalanced quote (an apostrophe in `user's`) or a stray `(`/`$`
- * that would otherwise fool the character scanners into mis-reading the
- * value's structure; the comment is inert to Sass, so removing it for
- * analysis is safe. The emitted value still carries the comment verbatim.
+ * All of the work — Bulma 0.9 `@import` → v1 `@use "bulma/sass" with (…)`,
+ * `$var !default` folding, `_all` partial mapping, the bestax extras — lives
+ * in the shared factory. Only the package's own specifiers differ per source.
  *
- * The scan tracks quote state first and only recognizes a block comment
- * outside a string, in one pass — a bare regex would treat a slash-star …
- * star-slash-shaped span that straddles two quoted strings (opening marker in
- * one string, closing marker in the next) as a comment and delete the real
- * top-level comma between them, so a genuine list would fold unparenthesized.
- * An unterminated comment consumes the rest of the value.
- */
-function stripSassComments(value: string): string {
-  let result = '';
-  let quote: string | null = null;
-  let escaped = false;
-  for (let i = 0; i < value.length; i += 1) {
-    const char = value[i];
-    if (quote) {
-      result += char;
-      if (escaped) {
-        escaped = false;
-      } else if (char === '\\') {
-        escaped = true;
-      } else if (char === quote) {
-        quote = null;
-      }
-      continue;
-    }
-    if (char === '/' && value[i + 1] === '*') {
-      const end = value.indexOf('*/', i + 2);
-      if (end === -1) break; // unterminated comment — drop the rest
-      i = end + 1; // resume after the closing */
-      continue;
-    }
-    if (char === '"' || char === "'") quote = char;
-    result += char;
-  }
-  return result;
-}
-
-/**
- * A value is fold-safe for `with (…)` when it is a plain literal — no
- * function calls, interpolation, variable references, or at-rules. Hex
- * colors (`#ff6b35`) are fine; `#{…}` interpolation is not. Block comments are
- * ignored for this test — their contents don't make the value non-literal.
- */
-function isFoldableValue(value: string): boolean {
-  return !/[()$@]|#\{/.test(stripSassComments(value));
-}
-
-/**
- * Whether `value` has a comma outside any quoted string — a bare Sass list
- * (`'Nunito', sans-serif`) that must be parenthesized before it can sit
- * inside `with (…)`, or Dart Sass reads the comma as an argument separator
- * instead of a list delimiter. Block comments are stripped first so a quote or
- * comma inside one (an apostrophe in `user's`) can't skew the scan.
- */
-function hasTopLevelComma(value: string): boolean {
-  let quote: string | null = null;
-  let escaped = false;
-  for (const char of stripSassComments(value)) {
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (char === '\\') {
-      escaped = true;
-      continue;
-    }
-    if (quote) {
-      if (char === quote) quote = null;
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      quote = char;
-    } else if (char === ',') {
-      return true;
-    }
-  }
-  return false;
-}
-
-/** Formats a folded value for the `with (…)` clause, parenthesizing a bare list. */
-function formatFoldedValue(value: string): string {
-  return hasTopLevelComma(value) ? `(${value})` : value;
-}
-
-function report(
-  collector: TodoCollector | undefined,
-  file: string,
-  line: number | null,
-  rule: string,
-  message: string
-): void {
-  collector?.add({ file, line, rule, message });
-}
-
-export const transformStyles: StylesTransform = (
-  filePath,
-  source,
-  collector,
-  options
-) => {
-  const cssMode = options.cssMode ?? 'bestax';
-  if (!/bulma/.test(source)) return null;
-
-  // Indented-syntax files: flag only — rewriting without a parser is unsafe.
-  if (path.extname(filePath) === '.sass') {
-    if (source.includes(`${TODO}`)) return null;
-    report(
-      collector,
-      filePath,
-      1,
-      'sass',
-      `indented-syntax file references Bulma; convert its @import lines to @use "bulma/sass" by hand — see ${GUIDE}`
-    );
-    return `// ${TODO}: convert Bulma 0.9 @import lines to @use "bulma/sass" with (…) — see ${GUIDE}\n${source}`;
-  }
-
-  const lines = source.split('\n');
-  const out: string[] = [];
-  let changed = false;
-  let extrasAdded = source.includes('@allxsmith/bestax-bulma/scss');
-
-  // Pass 1: locate the file's Bulma root and the safe leading variable
-  // overrides that fold into it. A real `bulma/…` @import root wins; otherwise
-  // the RBC stylesheet, which we rewrite into a root the same way — so a file
-  // that starts from RBC and one that starts from a bulma @import converge on
-  // the identical shape. A pre-existing `@use` root means we create no new one.
-  const rootImportIndex = lines.findIndex(line => ROOT_IMPORT.test(line));
-  const rbcRootIndex = lines.findIndex(
-    line => RBC_STYLE_IMPORT.test(line) && !line.includes(TODO)
-  );
-  const hasUseBulmaRoot = lines.some(line => USE_BULMA_ROOT.test(line));
-  const foldTargetIndex = hasUseBulmaRoot
-    ? -1
-    : rootImportIndex !== -1
-      ? rootImportIndex
-      : rbcRootIndex;
-  const foldableVars: Array<{ index: number; name: string; value: string }> =
-    [];
-  const unsafeVarLines: number[] = [];
-  if (foldTargetIndex !== -1) {
-    for (let i = 0; i < foldTargetIndex; i += 1) {
-      const line = lines[i];
-      const match = line.match(VAR_DECL);
-      if (match && isFoldableValue(match[2])) {
-        foldableVars.push({ index: i, name: match[1], value: match[2].trim() });
-      } else if (/^\s*\$[\w-]+\s*:/.test(line)) {
-        unsafeVarLines.push(i);
-      }
-    }
-  }
-  const folded = new Set(foldableVars.map(v => v.index));
-
-  /**
-   * Emit a Bulma module root at `indent` (folding the leading var overrides
-   * gathered above into `with (…)`, flagging any unsafe ones), then, in
-   * bestax mode, the extras. `prefix` is a preserved relative-path prefix
-   * (raw-file toolchains resolve paths, not package specifiers) or ''.
-   */
-  const emitBulmaRoot = (
-    indent: string,
-    prefix: string,
-    lineNo: number
-  ): void => {
-    const bulmaSass = `${prefix}bulma/sass`;
-    if (foldableVars.length > 0) {
-      out.push(`${indent}@use '${bulmaSass}' with (`);
-      foldableVars.forEach(({ name, value }, index) => {
-        const comma = index < foldableVars.length - 1 ? ',' : '';
-        out.push(`${indent}  $${name}: ${formatFoldedValue(value)}${comma}`);
-      });
-      out.push(`${indent});`);
-    } else {
-      out.push(`${indent}@use '${bulmaSass}';`);
-    }
-    if (unsafeVarLines.length > 0) {
-      out.push(
-        `${indent}// ${TODO}: the variable override(s) above use computed values; move them into the @use "bulma/sass" with (…) configuration by hand`
-      );
-      report(
-        collector,
-        filePath,
-        lineNo,
-        'sass',
-        'variable overrides with computed values could not be folded into `with (…)`'
-      );
-    }
-    if (cssMode === 'bestax' && !extrasAdded) {
-      out.push(
-        prefix
-          ? `${indent}@use '${prefix}@allxsmith/bestax-bulma/src/scss/extras';`
-          : `${indent}${EXTRAS_USE}`
-      );
-      extrasAdded = true;
-    }
-  };
-
-  for (let i = 0; i < lines.length; i += 1) {
-    const line = lines[i];
-
-    if (i === rootImportIndex) {
-      const rootMatch = line.match(ROOT_IMPORT);
-      // A path-prefixed root import means the toolchain resolves raw file
-      // paths, not package specifiers — point at the shipped files directly.
-      emitBulmaRoot(rootMatch?.[1] ?? '', keptPrefix(rootMatch?.[3]), i + 1);
-      changed = true;
-      continue;
-    }
-
-    if (folded.has(i)) {
-      changed = true; // folded into with(...) above
-      continue;
-    }
-
-    const partial = line.match(PARTIAL_IMPORT);
-    if (partial) {
-      const [, indent, , rawPrefix, importPath] = partial;
-      const prefix = keptPrefix(rawPrefix);
-      // Partial-only files (modular builds with no root import) still need
-      // the extras for the bestax components' styling; the extras tree only
-      // reads Bulma utilities, never configures them, so this is load-safe.
-      const pushExtras = () => {
-        if (cssMode !== 'bestax' || extrasAdded || rootImportIndex !== -1) {
-          return;
-        }
-        out.push(
-          prefix
-            ? `${indent}@use '${prefix}@allxsmith/bestax-bulma/src/scss/extras';`
-            : `${indent}${EXTRAS_USE}`
-        );
-        extrasAdded = true;
-      };
-      const segments = importPath.split('/');
-      const last = segments[segments.length - 1].replace(/^_/, '');
-      const dir = segments[0];
-      if ((last === 'all' || last === 'index') && V1_DIRS.has(dir)) {
-        out.push(`${indent}@use '${prefix}bulma/sass/${dir}';`);
-        pushExtras();
-        changed = true;
-        continue;
-      }
-      const leaf = segments.map(s => s.replace(/^_/, '')).join('/');
-      if (V1_DIRS.has(leaf) || V1_LEAVES.has(leaf)) {
-        out.push(`${indent}@use '${prefix}bulma/sass/${leaf}';`);
-        pushExtras();
-        changed = true;
-        continue;
-      }
-      out.push(
-        `${indent}// ${TODO}: this Bulma 0.9 partial path no longer exists in Bulma v1; find its replacement under bulma/sass/ — see ${GUIDE}`
-      );
-      out.push(line);
-      report(
-        collector,
-        filePath,
-        i + 1,
-        'sass',
-        `Bulma 0.9 partial path \`bulma/sass/${importPath}\` has no direct v1 equivalent`
-      );
-      changed = true;
-      continue;
-    }
-
-    const rbcStyle = line.match(RBC_STYLE_IMPORT);
-    if (rbcStyle && !line.includes(TODO)) {
-      const indent = rbcStyle[1];
-      const prefix = keptPrefix(rbcStyle[3]);
-      if (i === rbcRootIndex && rootImportIndex === -1 && !hasUseBulmaRoot) {
-        // The library's own stylesheet never resolves post-migration (deps.ts
-        // removes react-bulma-components in the same run), and it is this
-        // file's only Bulma root, so rewrite it into one — the same shape the
-        // @import root path emits, folding any leading var overrides. Emitting
-        // a real `bulma/sass` (+ extras) rather than the hard-configured
-        // bestax bundle keeps this convergent with the @import path and avoids
-        // reconfiguring `bulma/sass` if a themed root exists elsewhere.
-        emitBulmaRoot(indent, prefix, i + 1);
-        if (cssMode === 'keep') {
-          // The replacement is unavoidable even in keep mode: RBC's own
-          // stylesheet is a v3 (Bulma 0.9) asset the migrated v1 components
-          // can't use. What changed depends on whether the manifest step ran.
-          const depsRan = options.deps !== false;
-          const detail = depsRan
-            ? 'its package.json entry is removed, so the old import no longer resolves; install bulma@^1'
-            : 'it targets Bulma 0.9, not the v1 your components now use; --no-deps kept the dependency, so install bulma@^1 alongside it';
-          out.push(
-            `${indent}// ${TODO}: replaced react-bulma-components's own stylesheet with @use 'bulma/sass' — ${detail} — see ${GUIDE}`
-          );
-          report(
-            collector,
-            filePath,
-            i + 1,
-            'sass',
-            depsRan
-              ? "replaced react-bulma-components's stylesheet import with bulma/sass; the package is removed from dependencies, so the old import would not resolve"
-              : "replaced react-bulma-components's stylesheet import with bulma/sass; it is a Bulma 0.9 asset the migrated v1 components can't use (--no-deps left the package in place)"
-          );
-        } else {
-          // bestax/bulma modes rewrite the file's root without a TODO — still
-          // report it so the migration summary reflects the restructured root.
-          report(
-            collector,
-            filePath,
-            i + 1,
-            'sass',
-            "replaced react-bulma-components's stylesheet import with a Bulma v1 @use root"
-          );
-        }
-      } else {
-        // A Bulma root already covers this file (a `bulma/…` @import we
-        // convert, the file's own `@use` root, or an earlier RBC line we
-        // rewrote). In bestax mode keep that root and add only the extras —
-        // never a second root, never the configured bundle that would
-        // reconfigure an already-loaded module.
-        if (cssMode === 'bestax' && !extrasAdded) {
-          out.push(
-            prefix
-              ? `${indent}@use '${prefix}@allxsmith/bestax-bulma/src/scss/extras';`
-              : `${indent}${EXTRAS_USE}`
-          );
-          extrasAdded = true;
-        }
-        // Dropping the RBC line is only safe for its root/index stylesheet,
-        // which `bulma/sass` supersedes. A deep RBC partial can carry styles
-        // `bulma/sass` doesn't, so removing it silently would lose CSS — flag
-        // it with a TODO + report entry instead (never a silent skip).
-        if (!RBC_ROOT_STYLESHEET.test(line)) {
-          out.push(
-            `${indent}// ${TODO}: dropped a react-bulma-components stylesheet partial that has no Bulma v1 root equivalent; port any styles it carried beyond Bulma's own by hand — see ${GUIDE}`
-          );
-          report(
-            collector,
-            filePath,
-            i + 1,
-            'sass',
-            'react-bulma-components stylesheet partial dropped; port any styles it carried beyond Bulma’s own by hand'
-          );
-        }
-      }
-      changed = true;
-      continue;
-    }
-
-    if (OTHER_BULMA_IMPORT.test(line) && !line.includes(TODO)) {
-      const extension = line.match(EXTENSION_IMPORT);
-      if (extension) {
-        out.push(
-          `// ${TODO}: bulma-${extension[1]} is a Bulma 0.9-era extension — check its Bulma v1 compatibility; the bestax extras already style Radio/Checkbox and the advanced form controls — see ${GUIDE}`
-        );
-        out.push(line);
-        report(
-          collector,
-          filePath,
-          i + 1,
-          'sass',
-          `third-party Bulma extension \`bulma-${extension[1]}\` left in place; verify it against Bulma v1 or replace it with the bestax extras`
-        );
-        changed = true;
-        continue;
-      }
-      out.push(
-        `// ${TODO}: Bulma v1 uses @use instead of @import — see ${GUIDE}`
-      );
-      out.push(line);
-      report(
-        collector,
-        filePath,
-        i + 1,
-        'sass',
-        'unrecognized Bulma @import left in place; convert to @use by hand'
-      );
-      changed = true;
-      continue;
-    }
-
-    out.push(line);
-  }
-
-  return changed ? out.join('\n') : null;
-};
+ * RBC's root stylesheets are its Sass entry (`src/index`) and the bundled v3
+ * CSS (`dist/react-bulma-components(.min).css`); both stand in for a whole
+ * Bulma root, so they are replaced rather than dropped.
+ */
+
+import { makeStylesTransform } from '../_shared/make-styles-transform.js';
+
+export const transformStyles = makeStylesTransform({
+  packageName: 'react-bulma-components',
+  guideUrl:
+    'https://bestax.io/docs/guides/getting-started/migration/react-bulma-components',
+  rootStylesheetSuffixes: [
+    '/src/index(?:\\.s[ac]ss)?',
+    '/dist/react-bulma-components(?:\\.min)?\\.css',
+  ],
+});
diff --git a/bestax-migrate/src/sources/react-bulma-components/transform.ts b/bestax-migrate/src/sources/react-bulma-components/transform.ts
index d8ac7246e..e7f18079a 100644
--- a/bestax-migrate/src/sources/react-bulma-components/transform.ts
+++ b/bestax-migrate/src/sources/react-bulma-components/transform.ts
@@ -16,15 +16,22 @@
 
 import type { API, FileInfo } from 'jscodeshift';
 import type { TransformOptions } from '../../types.js';
-import { MAPPING, resolveMapping } from './mapping.js';
+import { MAPPING, UNIVERSAL_PROPS, resolveMapping } from './mapping.js';
 import {
   addTodo,
   attributesOf,
   jsxNameParts,
   renameElement,
   type TransformContext,
-} from './jsx-utils.js';
-import { applyPropAction, applyUniversalProps } from './props.js';
+} from '../_shared/jsx-utils.js';
+import { applyPropAction, applyUniversalProps } from '../_shared/props.js';
+import {
+  collectBoundNames,
+  makeReserve,
+  nameOf,
+  prefersTabs,
+  resolvesToBinding,
+} from '../_shared/imports.js';
 import { flattenResponsiveProps } from './responsive.js';
 import { RESPONSIVE_KINDS, runSpecial } from './specials.js';
 
@@ -77,8 +84,12 @@ export default function transform(
   const aliases = new Map<string, string[]>();
 
   const rbcImportPaths: any[] = [];
-  const nameOf = (node: any): string =>
-    typeof node === 'string' ? node : String(node?.name ?? '');
+  /**
+   * Whether a namespace binding (`import * as RBC`) is still referenced after
+   * the JSX pass — either by a retained component (`<RBC.Tile>`) or as a bare
+   * value. Pruning the import under one leaves `RBC is not defined`.
+   */
+  let namespaceStillReferenced = false;
 
   root.find(j.ImportDeclaration).forEach(path => {
     const source = String(path.node.source.value);
@@ -175,17 +186,92 @@ export default function transform(
     return undefined;
   }
 
+  // The scope each binding was collected in, so a reference can be checked
+  // against the binding it actually resolves to rather than matched by name.
+  const programScope: unknown = root.find(j.Program).paths()[0]?.scope;
+  // Aliases are keyed by the AST node that owns the declaring scope, not by
+  // bare name. Two functions can each destructure `Header` from a different
+  // component; a name-keyed map let the second overwrite the first, and both
+  // declarations were then pruned while both `<Header…>` references were left
+  // resolving to nothing.
+  //
+  // Resolution walks the reference's ANCESTORS rather than consulting
+  // `scope.lookup`, because by the time references are rewritten the alias
+  // pass has already pruned the declaration -- so the binding is gone from
+  // the scope table, and `path.scope` objects are not identity-stable across
+  // traversals either.
+  const aliasesByOwner = new Map<unknown, Map<string, string[]>>();
+  const ownersFor = (name: string): unknown[] => {
+    const owners: unknown[] = [];
+    for (const [owner, perScope] of aliasesByOwner) {
+      if (perScope.has(name)) owners.push(owner);
+    }
+    return owners;
+  };
+  const aliasAt = (name: string, at?: unknown): string[] | undefined => {
+    const owners = ownersFor(name);
+    if (owners.length === 0) return undefined;
+    // Without a reference location there is nothing to walk, so the only
+    // owner is the best answer available. WITH one, always walk: an unrelated
+    // `Header` parameter in another function must not resolve to the alias
+    // merely because the alias is the only one by that name. A single-owner
+    // shortcut here rewrote such a parameter to `{ Header: Card.Header }`,
+    // which is not even valid syntax.
+    if (at === undefined) {
+      return owners.length === 1
+        ? aliasesByOwner.get(owners[0])!.get(name)
+        : undefined;
+    }
+    type Anc = { parent?: Anc; node?: unknown };
+    let cursor = at as Anc | undefined;
+    while (cursor) {
+      if (cursor.node !== undefined) {
+        const hit = aliasesByOwner.get(cursor.node)?.get(name);
+        if (hit) {
+          // The walk finds the nearest OWNER, but a binding can intervene
+          // between the reference and that owner: `function F(Header)` under
+          // a module-level `const { Header } = Card` shadows the alias, and
+          // resolving through it rewrote the parameter itself to
+          // `F(Card.Header)`. If the scope table still binds the name
+          // somewhere other than the owner, that nearer binding wins. (After
+          // the alias declaration is pruned the lookup returns nothing for
+          // the alias itself, which is the case this must keep allowing.)
+          const declaring = (
+            at as {
+              scope?: {
+                lookup(n: string): { path?: { node?: unknown } } | null;
+              };
+            }
+          ).scope?.lookup(name)?.path?.node;
+          if (
+            declaring !== undefined &&
+            declaring !== null &&
+            declaring !== cursor.node
+          ) {
+            return undefined;
+          }
+          return hit;
+        }
+      }
+      cursor = cursor.parent;
+    }
+    return undefined;
+  };
+  const anyAlias = (name: string): boolean => ownersFor(name).length > 0;
+
   // ---- 1b. Resolve `const { Input, Field: F } = Form` destructuring -----
   root.find(j.VariableDeclarator).forEach(path => {
     const node = path.node;
     if (node.id?.type !== 'ObjectPattern' || node.init?.type !== 'Identifier')
       return;
     const base = node.init.name;
-    const imported = imports.get(base) ?? aliases.get(base)?.join('.');
+    const baseAlias = aliasAt(base, path);
+    const imported = imports.get(base) ?? baseAlias?.join('.');
     if (!imported || imported === '*') return;
+    if (!imports.has(base) && !baseAlias) return;
     const basePath = imports.has(base)
       ? [imports.get(base) as string]
-      : aliases.get(base)!;
+      : (baseAlias as string[]);
 
     let allResolved = true;
     for (const prop of node.id.properties) {
@@ -194,7 +280,32 @@ export default function transform(
         prop.key?.type === 'Identifier' &&
         prop.value?.type === 'Identifier'
       ) {
-        aliases.set(prop.value.name, [...basePath, prop.key.name]);
+        const owner = (path.scope as unknown as { path?: { node?: unknown } })
+          ?.path?.node;
+        let perScope = aliasesByOwner.get(owner);
+        if (!perScope) {
+          perScope = new Map<string, string[]>();
+          aliasesByOwner.set(owner, perScope);
+        }
+        const target = [...basePath, prop.key.name];
+        perScope.set(prop.value.name, target);
+        aliases.set(prop.value.name, target);
+        // Pruning the declaration is only safe if every use of the alias will
+        // actually be rewritten. For a name the table cannot map, the JSX is
+        // left as written -- so dropping `const { Header } = Panel` left
+        // `<Header/>` referencing nothing at all.
+        // A `special` handler rewrites the element without naming a plain
+        // target (`Form.Label` becomes a bare <label>), so it counts as
+        // resolved just as a target does. Requiring `target` alone kept every
+        // declaration that mentioned one.
+        const targetMapping = resolveMapping(target);
+        if (
+          !targetMapping ||
+          targetMapping.status === 'todo' ||
+          !(targetMapping.target || targetMapping.special)
+        ) {
+          allResolved = false;
+        }
       } else {
         allResolved = false;
       }
@@ -221,11 +332,15 @@ export default function transform(
   });
 
   /** Resolve a JSX name into a canonical RBC component path, or null. */
-  function resolveJsxPath(name: any): string[] | null {
+  function resolveJsxPath(name: any, at?: unknown): string[] | null {
     const parts = jsxNameParts(name);
     if (!parts) return null;
     const [head, ...rest] = parts;
-    if (aliases.has(head)) return [...aliases.get(head)!, ...rest];
+    const alias = aliasAt(head, at);
+    if (alias) return [...alias, ...rest];
+    // An alias exists under this name but not for THIS reference's binding,
+    // so the reference is not ours to rewrite.
+    if (anyAlias(head) && !imports.has(head)) return null;
     const imported = imports.get(head);
     if (imported === undefined) return null;
     if (imported === '*') return rest.length > 0 ? rest : null;
@@ -238,71 +353,98 @@ export default function transform(
   // A file may already bind names like `Field` or `Control` (components,
   // variables, function params); importing the bestax component under the
   // same name would redeclare it, so those imports get a Bulma* alias.
-  const bound = new Set<string>();
-  const collectPattern = (node: any): void => {
-    if (!node) return;
-    switch (node.type) {
-      case 'Identifier':
-        bound.add(node.name);
-        break;
-      case 'ObjectPattern':
-        for (const prop of node.properties ?? []) {
-          collectPattern(prop.value ?? prop.argument);
-        }
-        break;
-      case 'ArrayPattern':
-        for (const el of node.elements ?? []) collectPattern(el);
-        break;
-      case 'RestElement':
-        collectPattern(node.argument);
-        break;
-      case 'AssignmentPattern':
-        collectPattern(node.left);
-        break;
+  const bound = collectBoundNames(j, root, RBC);
+  // Seed the reserved set with the locals of RBC imports that CANNOT be
+  // migrated, so a bestax import never claims one of them. Without this, an
+  // unmappable component aliased to a name bestax also wants
+  // (`import { Element as Button }`) had its retained specifier dropped on
+  // the collision, and its `<Button>` JSX then silently resolved to the
+  // bestax Button — one component quietly becoming another.
+  for (const [local, imported] of imports) {
+    if (imported === '*') continue;
+    const entry = MAPPING[imported];
+    // Unmappable roots, plus ANY aliased import. A root can be retained by an
+    // unknown or `todo` child even when the root itself maps (`Icon` is
+    // `partial`, but `<Icon.Unknown>` retains it), and when the local name
+    // differs from the imported one that retained binding can collide with a
+    // bestax local for a completely different component. An unaliased import
+    // is safe: its name already means the same component on both sides.
+    if (!entry || entry.status === 'todo' || local !== imported) {
+      bound.add(local);
     }
-  };
-  root.find(j.VariableDeclarator).forEach(path => collectPattern(path.node.id));
-  root.find(j.FunctionDeclaration).forEach(path => {
-    if (path.node.id) bound.add(nameOf(path.node.id));
-    for (const param of path.node.params ?? []) collectPattern(param);
-  });
-  root
-    .find(j.ClassDeclaration)
-    .forEach(path => path.node.id && bound.add(nameOf(path.node.id)));
-  root.find(j.FunctionExpression).forEach(path => {
-    for (const param of path.node.params ?? []) collectPattern(param);
-  });
-  root.find(j.ArrowFunctionExpression).forEach(path => {
-    for (const param of path.node.params ?? []) collectPattern(param);
+  }
+
+  // A root that DOES map can still be retained by a child the table cannot
+  // (`Icon` is `partial`, but `<Icon.Unknown>` keeps the source import alive).
+  // The status check above misses that case whenever the local name equals the
+  // imported one, so the bestax import took the plain local, the retained
+  // specifier was dropped on the collision, and `<Icon.Unknown>` silently
+  // resolved to the bestax component instead.
+  //
+  // Scanned rather than reserved wholesale: adding every partial root to
+  // `bound` would alias them in every file that uses one, whether or not
+  // anything is actually retained.
+  root.find(j.JSXElement).forEach(path => {
+    const head = jsxNameParts(path.node.openingElement.name)?.[0];
+    if (!head || !imports.has(head)) return;
+    const parts = resolveJsxPath(path.node.openingElement.name, path);
+    const mapping = parts ? resolveMapping(parts) : undefined;
+    if (!mapping || mapping.status === 'todo') bound.add(head);
   });
-  root.find(j.ImportDeclaration).forEach(path => {
-    if (String(path.node.source.value) === RBC) return; // pruned later
-    for (const spec of path.node.specifiers ?? []) {
-      if (spec.local) bound.add(nameOf(spec.local));
+  // The same root can be retained by a VALUE chain -- `const X = Icon.Unknown`
+  // -- which only the value-reference pass discovers, after `reserve` has
+  // already handed the plain local to bestax. Scan those chains here too.
+  root.find(j.Identifier).forEach(path => {
+    if (path.node.type !== 'Identifier') return;
+    const head: string = path.node.name;
+    const imported = imports.get(head);
+    if (imported === undefined || imported === '*') return;
+    const parent = path.parent?.node;
+    if (
+      parent?.type !== 'MemberExpression' ||
+      parent.object !== path.node ||
+      parent.computed
+    ) {
+      return;
     }
-  });
-
-  ctx.reserve = (importedName: string): string => {
-    const existing = ctx.needed.get(importedName);
-    if (existing) return existing;
-    let local = importedName;
-    if (bound.has(local)) {
-      local = `Bulma${importedName}`;
-      let suffix = 2;
-      const locals = new Set(ctx.needed.values());
-      while (bound.has(local) || locals.has(local)) {
-        local = `Bulma${importedName}${suffix}`;
-        suffix += 1;
+    const chain = [imported];
+    let outer: any = path.parent;
+    while (
+      outer?.node?.type === 'MemberExpression' &&
+      !outer.node.computed &&
+      outer.node.property?.type === 'Identifier'
+    ) {
+      chain.push(nameOf(outer.node.property));
+      const next = outer.parent;
+      if (
+        next?.node?.type === 'MemberExpression' &&
+        next.node.object === outer.node
+      ) {
+        outer = next;
+      } else {
+        break;
       }
     }
-    ctx.needed.set(importedName, local);
-    return local;
-  };
+    const mapping = resolveMapping(chain);
+    if (!mapping || mapping.status === 'todo') bound.add(head);
+  });
+
+  ctx.reserve = makeReserve(ctx, bound);
 
   // Merge with an existing bestax import: reuse its locals verbatim.
+  // Only a declaration made entirely of NAMED specifiers can be merged into.
+  // `import * as Bulma from '@allxsmith/bestax-bulma'` matches the source too,
+  // and appending named specifiers to it emitted
+  // `import * as Bulma, { Box } from …` — not valid JavaScript, so the whole
+  // file failed to parse after a migration that reported success.
   const existingBestax = root
     .find(j.ImportDeclaration, { source: { value: BESTAX } })
-    .paths()[0];
+    .paths()
+    .find(path =>
+      (path.node.specifiers ?? []).every(
+        (spec: any) => spec.type === 'ImportSpecifier'
+      )
+    );
   const preExistingImports = new Set<string>();
   if (existingBestax) {
     for (const spec of existingBestax.node.specifiers ?? []) {
@@ -316,8 +458,22 @@ export default function transform(
   // ---- 2. Transform JSX elements ----------------------------------------
   root.find(j.JSXElement).forEach(path => {
     const element = path.node;
-    const rbcPath = resolveJsxPath(element.openingElement.name);
+    const rbcPath = resolveJsxPath(element.openingElement.name, path);
     if (!rbcPath) return;
+    // Resolve by BINDING, not by name. `function F({ Card })` shadows the
+    // import with the caller's object, and rewriting its JSX to bestax's
+    // `Card.FooterItem` changed which component rendered.
+    const jsxHead = jsxNameParts(element.openingElement.name)?.[0];
+    if (
+      jsxHead &&
+      !resolvesToBinding(
+        path,
+        jsxHead,
+        anyAlias(jsxHead) ? undefined : programScope
+      )
+    ) {
+      return;
+    }
 
     const mapping = resolveMapping(rbcPath);
     const dotted = rbcPath.join('.');
@@ -384,20 +540,39 @@ export default function transform(
         applyPropAction(ctx, path, element, attr, action);
       }
     }
-    applyUniversalProps(ctx, path, element, handled);
+    applyUniversalProps(ctx, path, element, handled, UNIVERSAL_PROPS);
   });
 
   // ---- 2b. Value references to RBC components ---------------------------
   // Components can be referenced as plain values too (`renderAs={Block}`,
   // passed to helpers, …). JSX usages were renamed above; map the leftover
   // identifier references so the pruned RBC import doesn't strand them.
+  // A shorthand property's key and value are distinct nodes, so the walker
+  // reaches the property twice. The first visit rewrites it and detaches the
+  // original; the second then matched neither key nor value and fell through
+  // to the generic "referenced as a value" branch, emitting a spurious TODO
+  // and marking the root retained when it was not.
+  const handledValueRefs = new WeakSet<object>();
+
   root.find(j.Identifier).forEach(path => {
     // find(Identifier) also matches JSXIdentifier (a subtype) — JSX names
     // were already handled by the element walker above.
     if (path.node.type !== 'Identifier') return;
+    if (handledValueRefs.has(path.node)) return;
     const name = path.node.name;
-    const imported = imports.get(name);
-    if (imported === undefined || imported === '*') return;
+    // A name bound by `const { Field } = Form` lives in `aliases`, not
+    // `imports`, and the destructuring pass has already deleted the
+    // declaration that bound it. Skipping those left `Field.Label` in the
+    // output with its `Form` import pruned: a reference to nothing.
+    const aliasPath = aliasAt(name, path);
+    const imported = aliasPath ? aliasPath[0] : imports.get(name);
+    if (imported === undefined) return;
+    // Resolve by BINDING, not by name: a local that shadows the import is a
+    // different object, and rewriting it repoints the code at bestax's
+    // component.
+    if (!resolvesToBinding(path, name, aliasPath ? undefined : programScope)) {
+      return;
+    }
     const parentNode = path.parent?.node;
     const parentType = parentNode?.type;
     if (
@@ -410,6 +585,24 @@ export default function transform(
     ) {
       return;
     }
+    // A namespace binding in a real value position. `RBC.Box` is still a
+    // mappable component reference, so fall through to the member-expression
+    // branch below with an empty prefix (the namespace itself is not part of
+    // the RBC path). Anything else — a bare `RBC` — just pins the import.
+    // Treating every namespace member as opaque left `const C = RBC.Box`
+    // referencing an import that dependency migration then removed.
+    const isNamespace = imported === '*';
+    if (
+      isNamespace &&
+      !(
+        parentType === 'MemberExpression' &&
+        parentNode.object === path.node &&
+        !parentNode.computed
+      )
+    ) {
+      namespaceStillReferenced = true;
+      return;
+    }
     // Non-reference positions: member property names and object keys.
     if (
       parentType === 'MemberExpression' &&
@@ -427,7 +620,28 @@ export default function transform(
       parentNode.object === path.node &&
       !parentNode.computed
     ) {
-      const memberPath = [imported, nameOf(parentNode.property)];
+      // Walk the full chain: `Card.Footer.Item` is one path, not
+      // `Card.Footer` with a stray `.Item`. Resolving only the first level
+      // left the tail pointing at a compound bestax does not have
+      // (bestax exposes `Card.FooterItem`).
+      const memberPath = isNamespace ? [] : [...(aliasPath ?? [imported])];
+      let outer: any = path.parent;
+      while (
+        outer?.node?.type === 'MemberExpression' &&
+        !outer.node.computed &&
+        outer.node.property?.type === 'Identifier'
+      ) {
+        memberPath.push(nameOf(outer.node.property));
+        const next = outer.parent;
+        if (
+          next?.node?.type === 'MemberExpression' &&
+          next.node.object === outer.node
+        ) {
+          outer = next;
+        } else {
+          break;
+        }
+      }
       const memberMapping = resolveMapping(memberPath);
       const dotted = memberPath.join('.');
       if (
@@ -437,7 +651,36 @@ export default function transform(
         !memberMapping.special
       ) {
         if (memberMapping.target === dotted) {
+          if (isNamespace) {
+            // `RBC.Card.Header` → `Card.Header`: the namespace prefix has to
+            // go, so rebuild the chain from the target rather than renaming
+            // the namespace identifier in place (there is no MAPPING['*']
+            // root to rename it to).
+            const [root, ...rest] = memberMapping.target.split('.');
+            let rebuilt: any = j.identifier(ctx.reserve(root));
+            for (const part of rest) {
+              rebuilt = j.memberExpression(rebuilt, j.identifier(part));
+            }
+            outer.replace(rebuilt);
+            ctx.dirty = true;
+            return;
+          }
           // Same compound exists on the bestax component at runtime.
+          if (aliasPath) {
+            // A destructured alias stands for MORE than one segment of the
+            // chain (`const { Header } = Card` makes `Header` mean
+            // `Card.Header`), so renaming the identifier drops every segment
+            // but the last: `Header.Title` became `Card.Title`. Rebuild the
+            // whole chain from the target instead.
+            const [aliasRoot, ...aliasRest] = memberMapping.target.split('.');
+            let rebuilt: any = j.identifier(ctx.reserve(aliasRoot));
+            for (const part of aliasRest) {
+              rebuilt = j.memberExpression(rebuilt, j.identifier(part));
+            }
+            outer.replace(rebuilt);
+            ctx.dirty = true;
+            return;
+          }
           const rootMapping = MAPPING[imported];
           if (rootMapping?.target) {
             const local = ctx.reserve(rootMapping.target);
@@ -447,20 +690,33 @@ export default function transform(
           return;
         }
         if (!memberMapping.target.includes('.')) {
-          // Flat target (Icon.Text → IconText): swap the member expression.
+          // Flat target (Icon.Text → IconText): swap the whole chain.
           const local = ctx.reserve(memberMapping.target);
-          path.parent.replace(j.identifier(local));
+          outer.replace(j.identifier(local));
           ctx.dirty = true;
           return;
         }
+        // Dotted target that differs from the source chain
+        // (Card.Footer.Item → Card.FooterItem): rebuild the chain against the
+        // bestax path rather than flagging something the table can answer.
+        const [targetRoot, ...targetRest] = memberMapping.target.split('.');
+        const rootLocal = ctx.reserve(targetRoot);
+        let rebuilt: any = j.identifier(rootLocal);
+        for (const part of targetRest) {
+          rebuilt = j.memberExpression(rebuilt, j.identifier(part));
+        }
+        outer.replace(rebuilt);
+        ctx.dirty = true;
+        return;
       }
       addTodo(
         ctx,
-        path.parent,
+        outer,
         'value-reference',
-        `\`${dotted}\` is referenced as a value; migrate this usage by hand`
+        `\`${isNamespace ? `${name}.` : ''}${dotted}\` is referenced as a value; migrate this usage by hand`
       );
-      ctx.retained.add(imported);
+      if (isNamespace) namespaceStillReferenced = true;
+      else ctx.retained.add(imported);
       return;
     }
     if (
@@ -470,15 +726,84 @@ export default function transform(
     ) {
       return;
     }
-    const mapping = MAPPING[imported];
+    // A shorthand property is both the key and the reference. Renaming the
+    // node in place rewrote the object's PUBLIC key
+    // (`{ Textarea }` → `{ TextArea }`), so expand it instead: the key keeps
+    // the name callers use, the value points at the migrated binding.
+    if (
+      (parentType === 'ObjectProperty' || parentType === 'Property') &&
+      parentNode.shorthand
+    ) {
+      // Resolve through the alias path when there is one: `const { Footer } =
+      // Card` makes `{ Footer }` mean `Card.Footer`, not `Card`. Reading the
+      // root's mapping here emitted `{ Footer: Card }` — the wrong component
+      // under the right key.
+      const shorthandMapping = aliasPath
+        ? resolveMapping(aliasPath)
+        : MAPPING[imported];
+      if (
+        shorthandMapping &&
+        shorthandMapping.status !== 'todo' &&
+        shorthandMapping.target &&
+        !shorthandMapping.special
+      ) {
+        const [root, ...rest] = shorthandMapping.target.split('.');
+        const local = ctx.reserve(root);
+        let value: any = j.identifier(local);
+        for (const part of rest) {
+          value = j.memberExpression(value, j.identifier(part));
+        }
+        if (rest.length > 0 || local !== name) {
+          // ast-types keeps DISTINCT key and value nodes even when
+          // `shorthand` is true, so both positions are visited. Mark both, or
+          // the second visit sees a node that matches neither the (new) key
+          // nor the (new) value and falls through to the generic branch.
+          handledValueRefs.add(parentNode.key);
+          handledValueRefs.add(parentNode.value);
+          parentNode.shorthand = false;
+          parentNode.key = j.identifier(name);
+          parentNode.value = value;
+          ctx.dirty = true;
+        }
+      } else {
+        // Mark both positions before reporting: the key and the value are
+        // distinct nodes, so an unmarked branch reports the same property
+        // twice. The AST comment dedupes, which hid this in the output while
+        // the report still double-counted it.
+        handledValueRefs.add(parentNode.key);
+        handledValueRefs.add(parentNode.value);
+        ctx.retained.add(imported);
+        addTodo(
+          ctx,
+          path,
+          'value-reference',
+          `\`${name}\` is referenced as a value; migrate this usage by hand`
+        );
+      }
+      return;
+    }
+    const mapping = aliasPath ? resolveMapping(aliasPath) : MAPPING[imported];
     if (
       mapping &&
       mapping.status !== 'todo' &&
       mapping.target &&
-      !mapping.target.includes('.')
+      !mapping.special
     ) {
-      const local = ctx.reserve(mapping.target);
-      if (local !== name) path.node.name = local;
+      const [root, ...rest] = mapping.target.split('.');
+      const local = ctx.reserve(root);
+      if (rest.length > 0) {
+        // A dotted target needs a member expression, not a rename — otherwise
+        // a destructured alias used as a bare value (`const { Header } = Card;
+        // const V = Header`) fell through to the TODO branch, left referencing
+        // a binding the destructuring pass had already deleted.
+        let value: any = j.identifier(local);
+        for (const part of rest) {
+          value = j.memberExpression(value, j.identifier(part));
+        }
+        path.replace(value);
+      } else if (local !== name) {
+        path.node.name = local;
+      }
       ctx.dirty = true;
     } else {
       ctx.retained.add(imported);
@@ -514,12 +839,19 @@ export default function transform(
     const bestaxLocals = new Set(ctx.needed.values());
     for (const path of rbcImportPaths) {
       const node = path.node;
-      const keepSpecifiers = (node.specifiers ?? []).filter(
-        (spec: any) =>
+      const keepSpecifiers = (node.specifiers ?? []).filter((spec: any) => {
+        // `import * as RBC` reaches every export at once, so it must survive
+        // whenever a component is retained (`<RBC.Tile>` stays in the JSX) or
+        // the namespace is referenced as a value.
+        if (spec.type === 'ImportNamespaceSpecifier') {
+          return ctx.retained.size > 0 || namespaceStillReferenced;
+        }
+        return (
           spec.type === 'ImportSpecifier' &&
           ctx.retained.has(nameOf(spec.imported)) &&
           !bestaxLocals.has(nameOf(spec.local))
-      );
+        );
+      });
       if (!inserted) {
         if (existingBestax && bestaxImport) {
           existingBestax.node.specifiers = [
@@ -556,13 +888,3 @@ export default function transform(
     useTabs: prefersTabs(fileInfo.source),
   });
 }
-
-function prefersTabs(source: string): boolean {
-  let tabs = 0;
-  let spaces = 0;
-  for (const line of source.split('\n')) {
-    if (line.startsWith('\t')) tabs += 1;
-    else if (line.startsWith(' ')) spaces += 1;
-  }
-  return tabs > spaces;
-}
diff --git a/bestax-migrate/src/sources/registry.ts b/bestax-migrate/src/sources/registry.ts
index d0ae15f8b..376bc4e50 100644
--- a/bestax-migrate/src/sources/registry.ts
+++ b/bestax-migrate/src/sources/registry.ts
@@ -5,9 +5,11 @@
 
 import type { MigrationSource } from '../types.js';
 import { reactBulmaComponents } from './react-bulma-components/index.js';
+import { rbx } from './rbx/index.js';
 
 export const SOURCES: Record<string, MigrationSource> = {
   [reactBulmaComponents.name]: reactBulmaComponents,
+  [rbx.name]: rbx,
 };
 
 export function getSource(name: string): MigrationSource | undefined {
diff --git a/bestax-migrate/src/types.ts b/bestax-migrate/src/types.ts
index 4a04bd3fd..d50e79a45 100644
--- a/bestax-migrate/src/types.ts
+++ b/bestax-migrate/src/types.ts
@@ -116,6 +116,14 @@ export interface DepsOptions {
   cssMode?: CssMode;
   /** True when migrated sources still reference `bulma/…` specifiers. */
   bulmaReferenced?: boolean;
+  /**
+   * True when at least one migrated file still imports the SOURCE library —
+   * the trimmed, TODO-annotated import the transform deliberately keeps for
+   * components with no bestax equivalent. Removing the package from the
+   * manifest while those remain leaves them unresolvable after the install
+   * step the report tells the user to run.
+   */
+  sourceStillImported?: boolean;
 }
 
 /** The standard jscodeshift transform contract. */
diff --git a/create-bestax/src/constants.ts b/create-bestax/src/constants.ts
index 1b6929aef..e499a825d 100644
--- a/create-bestax/src/constants.ts
+++ b/create-bestax/src/constants.ts
@@ -224,7 +224,7 @@ automatically when the task matches:
 - **bestax-layout-scaffold** — scaffold full pages (app shell, landing, centered, card grid).
 - **bestax-icons** — icons via \`Icon\`/\`IconText\`: library setup, name formats, variants, a11y.
 - **bestax-optimize** — shrink the built CSS: measure raw+gzip, then flavor switch or a modular Sass build.
-- **bestax-migrate** — migrate code off react-bulma-components (v4): run the codemod, resolve its TODOs.
+- **bestax-migrate** — migrate code off react-bulma-components (v4) or rbx (v2): run the codemod, resolve its TODOs.
 
 Prefer the library's components and these skills over hand-written Bulma markup or custom CSS.
 Read skill \`references/\` files with absolute paths — the shell's cwd is not stable between commands.
diff --git a/docs/docs/guides/getting-started/migration/index.md b/docs/docs/guides/getting-started/migration/index.md
index ecd0d5b06..657e922f6 100644
--- a/docs/docs/guides/getting-started/migration/index.md
+++ b/docs/docs/guides/getting-started/migration/index.md
@@ -48,3 +48,9 @@ The HTML stays identical between Bulma 0.9 and 1, but Bulma v1 swaps Node Sass f
 Coming from the (unmaintained) `react-bulma-components` library? The **`bestax-migrate`** codemod converts imports, component names, props, and responsive objects to bestax-bulma automatically, and flags everything it can't convert with `TODO(bestax-migrate)` comments plus a report. An [Agent Skill](/docs/skills/migrate) packages the whole workflow for coding agents.
 
 [Read the react-bulma-components guide →](./react-bulma-components.md)
+
+## [Migrating from rbx](./rbx.md)
+
+Coming from the (abandoned since 2019) `rbx` library? The **`bestax-migrate`** codemod handles it too — and here it does more than rename things: rbx pinned `bulma@0.7.5` as a _direct_ dependency, so migrating finally lets your app choose its own Bulma version — and it flags the four Bulma extensions rbx dragged along, all of which bestax now replaces. It also unblocks React 19, which removed the `defaultProps` rbx is built on.
+
+[Read the rbx guide →](./rbx.md)
diff --git a/docs/docs/guides/getting-started/migration/rbx.md b/docs/docs/guides/getting-started/migration/rbx.md
new file mode 100644
index 000000000..a7631ef82
--- /dev/null
+++ b/docs/docs/guides/getting-started/migration/rbx.md
@@ -0,0 +1,132 @@
+---
+title: Migrating from rbx
+sidebar_label: From rbx
+sidebar_position: 6
+---
+
+# Migrating from rbx
+
+[`rbx`](https://github.com/dfee/rbx) was a well-built, fully typed React wrapper for Bulma — its
+last commit was **June 2019**. `@allxsmith/bestax-bulma` is actively maintained, targets
+**Bulma v1** (CSS variables, dark mode, Grid), and covers the same component surface.
+
+rbx users are stuck in a way most legacy-library users are not, for two reasons:
+
+- **rbx pins Bulma itself.** It ships `bulma@0.7.5` as a _direct_ dependency, plus
+  `bulma-badge`, `bulma-divider`, `bulma-pageloader` and `bulma-tooltip`. Your app cannot pick
+  its own Bulma version while rbx is installed, so there is no incremental path to Bulma v1.
+- **React 19 removed `defaultProps` on function components**, which is what rbx's
+  `forwardRefAs` base is built on.
+
+Migrating clears both at once. The codemod removes **rbx** and moves you to Bulma v1 with
+`@allxsmith/bestax-bulma`. It also **reports** the four Bulma extensions rbx pulled in —
+`bulma-badge`, `bulma-divider`, `bulma-pageloader`, `bulma-tooltip` — which bestax replaces with
+real components; those it flags rather than deletes, because a manifest entry is something you
+declared and your own Sass may still import it.
+
+:::tip See how they compare
+For a capability-by-capability comparison of bestax against the other major React libraries, see
+the latest edition of [**The State of React**](/blog/tags/state-of-react).
+:::
+
+## Run the codemod
+
+```bash
+# Preview the changes and the TODO report without writing anything
+pnpm dlx bestax-migrate rbx src/ --dry
+
+# Apply it
+pnpm dlx bestax-migrate rbx src/
+```
+
+(`npx bestax-migrate …` works the same.) Useful flags: `--print` echoes transformed files to
+stdout; `--extensions` controls which files are considered (default
+`js,jsx,ts,tsx,scss,sass`); `--css bestax|bulma|keep` picks the stylesheet target
+(default `bestax`); `--no-deps` skips the package.json update.
+
+The codemod uses [jscodeshift](https://github.com/facebook/jscodeshift) to rewrite your source
+in place:
+
+- **Imports** — `rbx` → `@allxsmith/bestax-bulma`, including namespace imports and
+  `const { Item } = Card;` destructuring. Deep imports like `rbx/base/theme` are flagged with a
+  pointer to bestax's `Theme` and `ConfigProvider`.
+- **Components** — every rbx export and its dot-notation compounds are mapped, e.g.
+  `Card.Footer.Item` → `Card.FooterItem`, `Tag.Group` → `Tags`, `Column.Group` → `Columns`,
+  `Table.Cell` → `Table.Td`, `PageLoader` → `Loading` (with `isFullPage`), `Navbar.Dropdown` → `Navbar.DropdownMenu` (bestax's `Navbar.Dropdown` is the outer container,
+  which `<Navbar.Item dropdown>` becomes), `Level.Item align="right"` →
+  `Level.Right`, `Navbar.Segment align="end"` → `Navbar.End`, and `Title subtitle` → `SubTitle`.
+- **Props** — bare boolean modifiers gain their bestax prefixes (`outlined` → `isOutlined`,
+  `rounded` → `isRounded`), `state="loading"` → `isLoading`, and the Bulma v1 spacing helpers
+  replace the removed `is-*less` classes (`marginless` → `m="0"`, `radiusless` →
+  `radius="radiusless"`). Most of rbx's helper values need no remapping at all — its
+  `textAlign`, `textWeight` and `display` unions are already bestax's.
+- **Breakpoint objects** — all three rbx shapes flatten:
+  `responsive={{ tablet: { display: { value: 'flex' } } }}` → `displayTablet="flex"`,
+  `<Column tablet={{ size: 6 }}>` → `sizeTablet={6}`, and
+  `<Column.Group tablet={{ gapSize: 2 }}>` → `gapTablet={2}`.
+- **`Loader`** — becomes a plain `<div className="loader">`, **not** bestax's `Loading`. They
+  are different components: rbx's `Loader` is Bulma's inline spinner and always renders, while
+  `Loading` is a dismissible overlay that renders nothing unless `active`. (`PageLoader` _is_
+  `Loading`, with `isFullPage`.)
+- **Structure** — rbx's badge and tooltip _helper props_ become real wrapping components
+  (`<Button tooltip="Hi" />` → `<Tooltip label="Hi"><Button /></Tooltip>`), `Select.Container`
+  and `Image.Container` fold onto the component they wrap, and `Help`/`Label` become the plain
+  Bulma markup bestax expects.
+- **Stylesheets** — Bulma 0.9-era `@import` lines become `@use "bulma/sass" with (…)`. The
+  `bulma-badge` / `bulma-divider` / `bulma-pageloader` / `bulma-tooltip` CSS imports are kept,
+  each with a TODO: bestax ships `Badge`, `Divider`, `Loading` and `Tooltip` with their own
+  styles, so the import is only still needed by markup outside rbx that uses the extension's
+  classes directly. Drop it once nothing does.
+
+## The TODO report
+
+Anything the codemod cannot convert safely is left in place with a
+`// TODO(bestax-migrate): …` comment on the enclosing statement, and summarised in a report at
+the end of the run. Nothing is ever silently dropped or best-guessed.
+
+The four you are most likely to see, in the order they show up when the codemod is run over
+rbx's own documentation examples:
+
+| What               | Why                                                                                                                       | What to do                                                                              |
+| ------------------ | ------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- |
+| `component:Icon`   | bestax's `Icon` takes a required `name`, which cannot be read out of an rbx `<FontAwesomeIcon icon={faHome} />` child     | `<Icon name="home" library="fa" variant="solid" />`                                     |
+| `component:Tile`   | Bulma v1 removed Tiles                                                                                                    | Use [Grid and Cell](/docs/api/grid); see the [Bulma 0.9 → 1 guide](./bulma-0-9-to-1.md) |
+| `component:File.*` | bestax's `<File>` renders the whole file-input structure from its own props                                               | Drop the parts; set `label`, `hasName`, `isBoxed` on `<File>`                           |
+| `prop:as`          | rbx's `forwardRefAs` puts `as` on every component; bestax declares it on a smaller set, several narrowed to specific tags | Restructure, or render the tag directly                                                 |
+
+`Generic`, `Tile`, `List`, `Fieldset`, `Numeric` and `Highlight` have no bestax counterpart, so
+their imports are kept (trimmed and TODO-annotated) — your app still runs while you migrate
+them by hand.
+
+## Finish the migration
+
+1. **Install** — the codemod already rewrote `package.json`; apply it with `npm install` (or
+   pnpm/yarn). Expect a `peer-deps` report entry: rbx peer-depended on React `^16.8.6` and
+   bestax-bulma needs **React 18 or 19**, so upgrade `react`/`react-dom` first. If you were on
+   Font Awesome 5, bestax's optional peer wants **FA ≥ 6.7** — upgrade, or install with
+   `npm install --legacy-peer-deps`.
+2. **Styling follow-ups** — pick a different [CSS flavor](../installation.md) if you need
+   prefixed/no-helpers/light-only builds, and read the
+   [Bulma 0.9 → 1 guide](./bulma-0-9-to-1.md) for the styling changes that aren't code-level.
+   Because rbx pinned Bulma **0.7.5**, you are crossing two Bulma majors — expect more visual
+   drift than the guide's 0.9 → 1 baseline describes. One deliberate change:
+   `bestax.css` ships `$primary` as bestax blue (`#1e6b99`) rather than Bulma's stock
+   turquoise — keep the stock look with `--css bulma`, or set your own brand color via the
+   `--bulma-primary-*` CSS variables.
+3. **Theming** — rbx's `ThemeContext` (`rbx/base/theme`) has no direct equivalent. bestax
+   splits that job between [`Theme`](/docs/api/helpers/theme) for CSS-variable overrides and
+   `ConfigProvider` for the class prefix and icon library.
+4. **Verify** — typecheck, build, and compare the rendered app against the pre-migration UI.
+
+## Version support
+
+The codemod maps the rbx **v2** API (v2.2.0 is the final release). The mapping table is checked
+against rbx's own export surface in both directions, so a component it does not know about is
+reported as `unknown-component` rather than being silently skipped.
+
+## Coming from a different library?
+
+If you're using a specific React Bulma package that isn't supported by the migration tool yet,
+[open a feature request](https://github.com/allxsmith/bestax/issues/new?template=feature-request.md)
+naming the package and the components you use — the codemod platform is built to grow new
+source libraries.
diff --git a/docs/docs/guides/getting-started/migration/react-bulma-components.md b/docs/docs/guides/getting-started/migration/react-bulma-components.md
index 355761436..3b43f1ad6 100644
--- a/docs/docs/guides/getting-started/migration/react-bulma-components.md
+++ b/docs/docs/guides/getting-started/migration/react-bulma-components.md
@@ -140,6 +140,8 @@ named-import style first.
 
 ## Coming from a different library?
 
+Already supported: [**rbx**](./rbx.md) (`bestax-migrate rbx src/`).
+
 If you're using a specific React Bulma package that isn't supported by the migration tool yet,
 [open a feature request](https://github.com/allxsmith/bestax/issues/new?template=feature-request.md)
 naming the package and the components you use — the codemod platform is built to grow new
diff --git a/docs/docs/skills/migrate.mdx b/docs/docs/skills/migrate.mdx
index 0d8df17d9..2960c3bb5 100644
--- a/docs/docs/skills/migrate.mdx
+++ b/docs/docs/skills/migrate.mdx
@@ -7,14 +7,21 @@ sidebar_position: 7
 # Migrate skill
 
 The [`bestax-migrate`](https://github.com/allxsmith/bestax/blob/main/skills/bestax-migrate/SKILL.md)
-skill teaches an agent to move an existing app from
-[`react-bulma-components`](https://github.com/couds/react-bulma-components) (unmaintained since
-2022, Bulma 0.9.x) to `@allxsmith/bestax-bulma` on Bulma v1. It drives the
-[`bestax-migrate` codemod](../guides/getting-started/migration/react-bulma-components.md) and then
-resolves everything the codemod flags.
+skill teaches an agent to move an existing app off an unmaintained React Bulma library and onto
+`@allxsmith/bestax-bulma` on Bulma v1. Two sources are supported:
+
+- [`react-bulma-components`](https://github.com/couds/react-bulma-components) v4 — unmaintained
+  since 2022, Bulma 0.9.x —
+  [guide](../guides/getting-started/migration/react-bulma-components.md)
+- [`rbx`](https://github.com/dfee/rbx) v2 — abandoned in 2019, and it pins `bulma@0.7.5` as a
+  direct dependency, so migrating is what frees an app to choose its own Bulma version. The
+  four Bulma extensions it pulled in are reported for you to remove, not deleted —
+  [guide](../guides/getting-started/migration/rbx.md)
+
+It drives the `bestax-migrate` codemod and then resolves everything the codemod flags.
 
 Like the rest of the bundle, `create-bestax` offers to preinstall this skill; it stays idle
-until the agent meets code that still imports `react-bulma-components`.
+until the agent meets code that still imports one of those libraries.
 
 ## Install
 
@@ -24,10 +31,11 @@ npx skills add https://github.com/allxsmith/bestax --skill bestax-migrate
 
 ## What the agent does with it
 
-1. Runs `pnpm dlx bestax-migrate react-bulma-components src/ --dry`, reviews the report, then
-   applies the codemod for real — that rewrites the components, the stylesheets (CSS/SCSS onto
-   Bulma v1 + the bestax extras), **and** `package.json` (`react-bulma-components` removed,
-   `@allxsmith/bestax-bulma` added, `bulma` → `^1`, `node-sass` → `sass`).
+1. Picks the source library from the app's imports, runs
+   `pnpm dlx bestax-migrate <source> src/ --dry`, reviews the report, then applies the codemod
+   for real — that rewrites the components, the stylesheets (CSS/SCSS onto Bulma v1 + the
+   bestax extras), **and** `package.json` (the old library removed, `@allxsmith/bestax-bulma`
+   added, `bulma` → `^1`, `node-sass` → `sass`).
 2. Installs the rewritten dependencies (`npm install` / `pnpm install`) — the codemod never runs
    a package manager itself, and its `peer-deps` report entries call out React (older than 18)
    or Font Awesome (older than 6) blockers first.
@@ -41,18 +49,23 @@ npx skills add https://github.com/allxsmith/bestax --skill bestax-migrate
 ## Example prompt
 
 ```text
-This app uses react-bulma-components. Migrate it to @allxsmith/bestax-bulma
-following the bestax-migrate skill, and make sure the build passes when you're done.
+This app uses rbx. Migrate it to @allxsmith/bestax-bulma following the
+bestax-migrate skill, and make sure the build passes when you're done.
 ```
 
 ## References bundled with the skill
 
-- `references/component-map.md` — all 32 react-bulma-components components (and every compound
-  sub-component) with their bestax targets.
-- `references/prop-map.md` — the universal modifier-prop conversions and responsive
-  breakpoint-object flattening.
-- `references/unmappables.md` — a recipe for every `TODO(bestax-migrate)` the codemod can leave.
-- `references/css-migration.md` — the Bulma 0.9 → 1 CSS step.
+The mapping tables are per source — `references/react-bulma-components/` and `references/rbx/` —
+each holding the same three files:
+
+- `component-map.md` — every component of that library (and every compound sub-component) with
+  its bestax target.
+- `prop-map.md` — the modifier-prop conversions and breakpoint-object flattening.
+- `unmappables.md` — a recipe for every `TODO(bestax-migrate)` the codemod can leave.
+
+- `references/css-migration.md` — the Bulma 0.9 → 1 CSS step, shared by both: the stylesheet
+  work is about Bulma, not about which wrapper you came from.
 
-See the full [migration guide](../guides/getting-started/migration/react-bulma-components.md) for
-the codemod itself.
+See the full migration guides for the codemod itself:
+[react-bulma-components](../guides/getting-started/migration/react-bulma-components.md) ·
+[rbx](../guides/getting-started/migration/rbx.md).
diff --git a/scripts/gen-mcp-index.mjs b/scripts/gen-mcp-index.mjs
index 549f9f376..f9154357d 100644
--- a/scripts/gen-mcp-index.mjs
+++ b/scripts/gen-mcp-index.mjs
@@ -352,18 +352,60 @@ async function readSkills() {
     const skillFile = join(SKILLS_DIR, name, 'SKILL.md');
     const src = await readFile(skillFile, 'utf8');
     const fm = frontmatter(src);
+    // Walks nested directories, not just the top level. A skill that serves
+    // more than one subject groups its references per subject
+    // (`references/rbx/component-map.md`), and a flat readdir dropped every
+    // one of those from the index silently — the file simply stopped being
+    // served, with `gen:mcp:check` still green because the output it compared
+    // was consistently wrong.
+    //
+    // `id` is the lookup key behind `bestax://skills/{name}/references/{ref}`,
+    // so it has to stay unique and free of slashes: a nested file is keyed by
+    // its path with separators replaced (`rbx-component-map`). Top-level files
+    // keep exactly the id they had.
+    //
+    // Moving a file INTO a subdirectory therefore changes its id — when
+    // bestax-migrate's references were split per source, `component-map`
+    // became `react-bulma-components-component-map`. That is unavoidable once
+    // two subjects each have a `component-map`, and it is a real (small) break
+    // for anyone who pinned the old resource URI. Nothing in this repo pins
+    // one, and agents discover ids through `get_skill` rather than hardcoding
+    // them, so the rename is accepted rather than aliased.
     const listing = async sub => {
-      const dir = join(SKILLS_DIR, name, sub);
-      if (!existsSync(dir)) return [];
-      const entries = await readdir(dir, { withFileTypes: true });
+      const root = join(SKILLS_DIR, name, sub);
+      if (!existsSync(root)) return [];
       const files = [];
-      for (const e of entries.filter(x => x.isFile())) {
-        const body = await readFile(join(dir, e.name), 'utf8');
-        files.push({
-          id: basename(e.name, extname(e.name)),
-          file: `${sub}/${e.name}`,
-          bytes: Buffer.byteLength(body),
-        });
+      const walk = async rel => {
+        const entries = await readdir(join(root, rel), { withFileTypes: true });
+        for (const e of entries.sort((a, b) => byCodePoint(a.name, b.name))) {
+          const next = rel ? `${rel}/${e.name}` : e.name;
+          if (e.isDirectory()) {
+            await walk(next);
+            continue;
+          }
+          if (!e.isFile()) continue;
+          const body = await readFile(join(root, next), 'utf8');
+          files.push({
+            id: next.replace(extname(e.name), '').replace(/\//g, '-'),
+            file: `${sub}/${next}`,
+            bytes: Buffer.byteLength(body),
+          });
+        }
+      };
+      await walk('');
+      // `a-b/x.md` and `a/b-x.md` both flatten to `a-b-x`, and `id` is the
+      // MCP resource lookup key — two files answering to one key would make
+      // the served content depend on ordering. No such pair exists today;
+      // fail loudly rather than let one appear silently.
+      const seen = new Map();
+      for (const f of files) {
+        if (seen.has(f.id)) {
+          throw new Error(
+            `[gen-mcp-index] duplicate reference id "${f.id}" in ${name}/${sub}: ` +
+              `${seen.get(f.id)} and ${f.file} flatten to the same key`
+          );
+        }
+        seen.set(f.id, f.file);
       }
       return files.sort((a, b) => byCodePoint(a.id, b.id));
     };
diff --git a/scripts/gen-mcp-index.test.mjs b/scripts/gen-mcp-index.test.mjs
index c1ff447aa..14fb29f4a 100644
--- a/scripts/gen-mcp-index.test.mjs
+++ b/scripts/gen-mcp-index.test.mjs
@@ -162,6 +162,43 @@ test('the skills roster is read from the directory, not a hardcoded list', () =>
   assert.ok(theming.references.some(r => r.id === 'css-variables'));
 });
 
+test('references nested one level per subject still reach the index', () => {
+  // A skill that serves more than one subject groups its references into
+  // subdirectories. A flat readdir dropped every one of those silently — the
+  // file stopped being served while the staleness gate stayed green, because
+  // the output it compared was consistently wrong. Keyed by path so two
+  // subjects can each have a `component-map`.
+  const migrate = skills.skills.find(s => s.name === 'bestax-migrate');
+  assert.ok(migrate, 'bestax-migrate skill missing');
+  for (const id of [
+    'rbx-component-map',
+    'rbx-prop-map',
+    'rbx-unmappables',
+    'react-bulma-components-component-map',
+    'react-bulma-components-prop-map',
+    'react-bulma-components-unmappables',
+  ]) {
+    const ref = migrate.references.find(r => r.id === id);
+    assert.ok(ref, `${id} is not indexed`);
+    assert.match(ref.file, /^references\/[^/]+\/[^/]+\.md$/);
+    assert.ok(ref.bytes > 0, `${id} indexed as empty`);
+  }
+  // `id` is the lookup key behind bestax://skills/{name}/references/{ref},
+  // so a slash in it would not resolve.
+  for (const s of skills.skills) {
+    for (const r of [...s.references, ...s.examples]) {
+      assert.ok(!r.id.includes('/'), `${s.name}/${r.id} has a slash in its id`);
+    }
+  }
+});
+
+test('every skill reference id is unique within its skill', () => {
+  for (const s of skills.skills) {
+    const ids = [...s.references, ...s.examples].map(r => r.id);
+    assert.equal(new Set(ids).size, ids.length, `${s.name} has duplicate ids`);
+  }
+});
+
 test('output is deterministic and code-point sorted', () => {
   const names = catalog.components.map(c => c.name);
   assert.deepEqual(
diff --git a/skills/bestax-migrate/SKILL.md b/skills/bestax-migrate/SKILL.md
index c2464878d..2cfefe0e5 100644
--- a/skills/bestax-migrate/SKILL.md
+++ b/skills/bestax-migrate/SKILL.md
@@ -1,15 +1,30 @@
 ---
 name: bestax-migrate
-description: Migrate an existing app from react-bulma-components (v4) to @allxsmith/bestax-bulma on Bulma v1 — run the bestax-migrate codemod, then resolve every TODO(bestax-migrate) comment it leaves using the mapping references. Use when a repo imports react-bulma-components and wants to move to bestax-bulma, when TODO(bestax-migrate) comments are present in a codebase, or when asked to migrate off an unmaintained React Bulma library.
+description: Migrate an existing app from an unmaintained React Bulma library — react-bulma-components (v4) or rbx (v2) — to @allxsmith/bestax-bulma on Bulma v1. Run the bestax-migrate codemod, then resolve every TODO(bestax-migrate) comment it leaves using the per-source mapping references. Use when a repo imports react-bulma-components or rbx and wants to move to bestax-bulma, when TODO(bestax-migrate) comments are present in a codebase, or when asked to migrate off an unmaintained React Bulma library.
 license: MIT
 ---
 
-# Migrating from react-bulma-components to bestax-bulma
+# Migrating to bestax-bulma
 
-`react-bulma-components` is unmaintained (last release 2022, Bulma 0.9.x).
 `@allxsmith/bestax-bulma` is an actively maintained React library for **Bulma v1**. The
-`bestax-migrate` codemod automates most of the conversion; this skill drives the codemod and
-finishes what it flags.
+`bestax-migrate` codemod automates most of the conversion from an unmaintained predecessor;
+this skill drives the codemod and finishes what it flags.
+
+## Pick the source
+
+The codemod's first argument names the library you are migrating _from_. Check the app's
+`package.json` and imports:
+
+| Source                                                               | Argument                 | References                                                                                 |
+| -------------------------------------------------------------------- | ------------------------ | ------------------------------------------------------------------------------------------ |
+| `react-bulma-components` v4 (unmaintained since 2022, Bulma 0.9.x)   | `react-bulma-components` | [`references/react-bulma-components/`](references/react-bulma-components/component-map.md) |
+| `rbx` v2 (abandoned 2019, pins Bulma **0.7.5** plus four extensions) | `rbx`                    | [`references/rbx/`](references/rbx/component-map.md)                                       |
+
+Everything below is written as `<source>`; substitute the argument from that table. The
+reference paths follow the same split — `references/<source>/component-map.md`,
+`prop-map.md`, `unmappables.md` — while
+[`references/css-migration.md`](references/css-migration.md) is shared, because the stylesheet
+work is about Bulma, not about which wrapper you came from.
 
 ## Workflow
 
@@ -18,15 +33,14 @@ Run these steps in order. Don't hand-convert what the codemod converts automatic
 1. **Dry-run the codemod** on the source directory and review the report:
 
    ```sh
-   pnpm dlx bestax-migrate react-bulma-components src/ --dry
+   pnpm dlx bestax-migrate <source> src/ --dry
    ```
 
 2. **Apply it** (same command without `--dry`), then run the project's formatter — the
    codemod preserves surrounding formatting but doesn't prettify what it rewrites.
    Besides the components, it also migrates **stylesheets** (CSS imports →
    `@allxsmith/bestax-bulma/bestax.css`; SCSS `@import 'bulma/bulma'` + `$var` overrides
-   → `@use 'bulma/sass' with (…)` plus the bestax extras) and **package.json**
-   (react-bulma-components removed, bestax-bulma added, bulma → ^1, node-sass → sass).
+   → `@use 'bulma/sass' with (…)` plus the bestax extras) and **package.json**.
    Flags: `--css bulma|keep` for other stylesheet targets, `--no-deps` to leave
    package.json alone.
 
@@ -36,16 +50,25 @@ Run these steps in order. Don't hand-convert what the codemod converts automatic
    npm install   # or pnpm/yarn
    ```
 
+   The report groups its entries by rule. `deps` covers every package.json edit —
+   what was removed, added, or left for you to decide; `imports` covers a source
+   import the codemod could not rewrite and left in place; `unsupported-file` names
+   a file type it cannot parse (`.vue`, `.astro`) that still imports the source;
+   `value-reference` marks a component used as a value rather than as JSX. Rules
+   named `component:X` and `prop:y` are per-component and per-prop, and each is
+   documented in the per-source `references/` pages.
+
    The report's `peer-deps` entries predict install failures: bestax-bulma needs
-   **React 18/19** (RBC also ran on 17 — upgrade react/react-dom first) and its optional
-   Font Awesome peer wants **FA ≥ 6.7** (an app pinned to FA 5 either upgrades or
-   installs with `npm install --legacy-peer-deps`).
+   **React 18/19** (react-bulma-components also ran on 17, and rbx peer-depended on
+   **React 16** — upgrade react/react-dom first) and its optional Font Awesome peer wants
+   **FA ≥ 6.7** (an app pinned to FA 5 either upgrades or installs with
+   `npm install --legacy-peer-deps`).
 
 4. **Resolve every TODO**: `grep -rn "TODO(bestax-migrate)" src/`. Each comment names the
    prop/component and a hint. Recipes for every recurring case are in
-   [references/unmappables.md](references/unmappables.md); the full component and prop
-   tables are in [references/component-map.md](references/component-map.md) and
-   [references/prop-map.md](references/prop-map.md). Delete each comment as you resolve it.
+   `references/<source>/unmappables.md`; the full tables are in
+   `references/<source>/component-map.md` and `references/<source>/prop-map.md`. Delete each
+   comment as you resolve it.
 
 5. **Finish the stylesheet layer** — flagged Sass cases (computed variables,
    indented-syntax `.sass` files), CSS flavor choice, and Bulma 0.9→1 styling changes:
@@ -56,23 +79,34 @@ Run these steps in order. Don't hand-convert what the codemod converts automatic
 
 ## What the codemod handles vs. flags
 
-All 32 react-bulma-components v4 components have a mapping. Imports (named, namespace, and
-`const { Input } = Form` destructuring), component renames, prop renames/value conversions,
-responsive breakpoint objects, CSS/SCSS stylesheet imports, and package.json dependencies
-convert automatically. It flags with
-`TODO(bestax-migrate)` instead of guessing: `Element` and `Tile` (no bestax equivalent —
-Tile is replaced by Bulma v1's Grid), controlled `Dropdown`/`Dropdown.Item value`,
-`touch`/`until*` breakpoints, dynamic prop values it can't rewrite, and props with no
-bestax counterpart. Files in formats it can't parse (`.astro`, `.vue`, `.svelte`, `.mdx`)
-that import react-bulma-components are reported as `unsupported-file` — migrate those by
-hand with the component map. Never "fix" a TODO by silencing it — convert the code per the
-references, or deliberately keep the old markup with `className` styling.
+Every export of every supported source has a mapping entry, held to that library's real export
+surface by a coverage test. Imports (named, namespace, and destructuring), component renames,
+prop renames and value conversions, breakpoint objects, CSS/SCSS stylesheet imports, and
+package.json dependencies convert automatically.
+
+It flags with `TODO(bestax-migrate)` instead of guessing: components with no bestax equivalent,
+controlled APIs whose shape differs, breakpoints bestax has no prop for, dynamic prop values it
+can't rewrite, and props with no counterpart. Files in formats it can't parse (`.astro`,
+`.vue`, `.svelte`, `.mdx`) that import the source library are reported as `unsupported-file` —
+migrate those by hand with the component map. Never "fix" a TODO by silencing it — convert the
+code per the references, or deliberately keep the old markup with `className` styling.
+
+### Source-specific headlines
+
+- **react-bulma-components**: all 32 v4 components are mapped. `Element` and `Tile` have no
+  bestax equivalent; `renderAs` becomes `as` where supported.
+- **rbx**: migrating removes rbx itself — it pinned `bulma@0.7.5` as a direct
+  dependency plus `bulma-badge`, `bulma-divider`, `bulma-pageloader` and `bulma-tooltip`, so
+  the app can finally choose its own Bulma version. rbx's badge and tooltip _helper props_
+  become real wrapping `<Badge>` / `<Tooltip>` components. Its `as` is universal, bestax's is
+  not. Because rbx pinned Bulma 0.7.5, you cross **two** Bulma majors — expect more visual
+  drift than the 0.9 → 1 guide alone describes.
 
 ## Rules
 
-- The codemod is idempotent on already-migrated files (it only touches files importing
-  `react-bulma-components`) — safe to re-run after partial manual work.
-- Don't downgrade converted props back to RBC names; bestax uses `is*` booleans
-  (`isLoading`), string size unions (`textSize="4"`), and `as` instead of `renderAs`.
-- If a component the app uses isn't in the component map, it wasn't part of RBC v4 —
-  check for a local wrapper component and migrate its internals instead.
+- The codemod is idempotent on already-migrated files (it only touches files importing the
+  source library) — safe to re-run after partial manual work.
+- Don't downgrade converted props back to the old names; bestax uses `is*` booleans
+  (`isLoading`), string size unions (`textSize="4"`), and `as` rather than `renderAs`.
+- If a component the app uses isn't in the component map, it wasn't part of that library's
+  public API — check for a local wrapper component and migrate its internals instead.
diff --git a/skills/bestax-migrate/references/css-migration.md b/skills/bestax-migrate/references/css-migration.md
index 6882ea802..2fb06116c 100644
--- a/skills/bestax-migrate/references/css-migration.md
+++ b/skills/bestax-migrate/references/css-migration.md
@@ -1,13 +1,17 @@
-# Stylesheets: Bulma 0.9 → Bulma v1 + bestax
+# Stylesheets: pre-1 Bulma → Bulma v1 + bestax
 
-react-bulma-components apps style with Bulma 0.9.x; bestax-bulma targets Bulma v1. The
-codemod automates most of this layer — this reference explains what it did and how to
-finish what it flagged.
+Every library `bestax-migrate` migrates from is pinned to a pre-1 Bulma: react-bulma-components
+to 0.9.x, rbx to 0.7.5. bestax-bulma targets Bulma v1. The codemod automates most of that
+stylesheet layer; this reference explains what it did and how to finish what it flagged.
+
+Coming from rbx you are crossing **two** Bulma majors rather than one, so expect more visual
+drift than the 0.9 → 1 notes below describe on their own.
 
 ## What the codemod already did (default `--css bestax`)
 
 - **CSS imports**: `bulma/css/bulma(.min).css` and v3-era
-  `react-bulma-components/dist/*.css` imports became the recommended combined bundle
+  the source library's own CSS imports (`react-bulma-components/dist/*.css`,
+  `rbx/index.css`) became the recommended combined bundle
   `@allxsmith/bestax-bulma/bestax.css` (Bulma v1 + the bestax extras that themed
   Radio/Checkbox and the advanced form controls need). A separate `extras.css` import
   next to it is collapsed.
@@ -43,9 +47,9 @@ finish what it flagged.
   **dart-sass ≥ 1.79** — the codemod's node-sass replacement installs that, but check
   bundler-pinned older versions (Parcel's sass transformer pins 1.66).
 
-  react-bulma-components' own stylesheet — any `react-bulma-components/…` specifier,
+  the source library's own stylesheet — any `react-bulma-components/…` or `rbx/…` specifier,
   bare, `~`-prefixed, or a relative `node_modules/` path, covering the documented v3
-  entry points (`src/index.sass`, `dist/react-bulma-components(.min).css`) as well as
+  entry points (`src/index.sass`, `dist/react-bulma-components(.min).css`, `rbx/rbx`) as well as
   deep partials and extensionless forms — is not a third-party extension; it's the
   library being migrated away from. It targets Bulma 0.9, not the v1 your components now
   use, and (unless `--no-deps` is passed) `package.json` no longer lists it, so the
@@ -68,8 +72,11 @@ finish what it flagged.
   given partial's styles, so it gets a `// TODO(bestax-migrate)` and a report entry
   ("port any styles it carried beyond Bulma's own by hand") rather than vanishing silently.
 
-- **package.json**: `react-bulma-components` removed, `@allxsmith/bestax-bulma` added,
-  `bulma` bumped to `^1.0.4` (or added when sources still import `bulma/…` directly),
+- **package.json**: the source library removed, `@allxsmith/bestax-bulma` added, a declared
+  pre-1.0 `bulma` raised to `^1.0.4` (or `bulma` added when sources still import `bulma/…`
+  directly). For rbx, the four `bulma-*` extensions it pinned are **reported** for you to
+  remove, not deleted — a manifest entry is a deliberate declaration, and the same goes for
+  their CSS imports in source files (kept, with a TODO each),
   and dead `node-sass` replaced with dart `sass`. Run the package manager's install
   afterwards — the codemod never installs anything.
 
@@ -93,7 +100,7 @@ elements,form,components,grid,layout,helpers,themes}` with leaf partials like
   compatibility. Class-based usage (`className="is-checkradio"`) keeps needing the
   extension; usage that migrated to bestax components (Radio, Checkbox, the advanced
   form controls) is already styled by the bestax extras, so the import can go.
-  react-bulma-components' own stylesheet is never flagged this way (see above) — only
+  the source library's own stylesheet is never flagged this way (see above) — only
   packages actually named `bulma-*` are.
 
 ## Choosing a CSS flavor (optional)
diff --git a/skills/bestax-migrate/references/rbx/component-map.md b/skills/bestax-migrate/references/rbx/component-map.md
new file mode 100644
index 000000000..fd454f58b
--- /dev/null
+++ b/skills/bestax-migrate/references/rbx/component-map.md
@@ -0,0 +1,171 @@
+# rbx → bestax-bulma component map
+
+Every rbx v2 export and its dot-notation compounds. `structural` means the codemod rewrites the
+element's shape rather than renaming it (see [unmappables.md](unmappables.md) for what each one
+produces). A `todo` row has no bestax counterpart — the codemod keeps the rbx import, annotated,
+so the app still runs while you convert it.
+
+This table mirrors `MAPPING` in `bestax-migrate/src/sources/rbx/mapping.ts`, which a coverage
+test holds to rbx's own export surface in both directions.
+
+| rbx                        | bestax-bulma          | status  |
+| -------------------------- | --------------------- | ------- |
+| `Block`                    | `Block`               | mapped  |
+| `Box`                      | `Box`                 | mapped  |
+| `Breadcrumb`               | `Breadcrumb`          | mapped  |
+| `Breadcrumb.Item`          | _structural_          | mapped  |
+| `Button`                   | `Button`              | mapped  |
+| `Button.Group`             | `Buttons`             | mapped  |
+| `Card`                     | `Card`                | mapped  |
+| `Card.Content`             | `Card.Content`        | mapped  |
+| `Card.Image`               | `Card.Image`          | mapped  |
+| `Card.Header`              | `Card.Header`         | mapped  |
+| `Card.Header.Title`        | `Card.Header.Title`   | mapped  |
+| `Card.Header.Icon`         | `Card.Header.Icon`    | mapped  |
+| `Card.Footer`              | `Card.Footer`         | mapped  |
+| `Card.Footer.Item`         | `Card.FooterItem`     | mapped  |
+| `Checkbox`                 | `Checkbox`            | mapped  |
+| `Column`                   | `Column`              | mapped  |
+| `Column.Group`             | `Columns`             | mapped  |
+| `Container`                | `Container`           | mapped  |
+| `Content`                  | `Content`             | mapped  |
+| `Content.OrderedList`      | `OrderedList`         | mapped  |
+| `Content.OrderedList.Item` | `OrderedList.Item`    | mapped  |
+| `Control`                  | `Control`             | mapped  |
+| `Delete`                   | `Delete`              | mapped  |
+| `Divider`                  | `Divider`             | partial |
+| `Dropdown`                 | `Dropdown`            | partial |
+| `Dropdown.Container`       | _structural_          | mapped  |
+| `Dropdown.Content`         | _structural_          | mapped  |
+| `Dropdown.Menu`            | _structural_          | mapped  |
+| `Dropdown.Trigger`         | _structural_          | mapped  |
+| `Dropdown.Item`            | `Dropdown.Item`       | mapped  |
+| `Dropdown.Divider`         | `Dropdown.Divider`    | mapped  |
+| `Dropdown.Context`         | — _(see unmappables)_ | todo    |
+| `Field`                    | `Field`               | mapped  |
+| `Field.Label`              | `Field.Label`         | mapped  |
+| `Field.Body`               | `Field.Body`          | mapped  |
+| `Fieldset`                 | — _(see unmappables)_ | todo    |
+| `File`                     | `File`                | mapped  |
+| `File.CTA`                 | — _(see unmappables)_ | todo    |
+| `File.Icon`                | — _(see unmappables)_ | todo    |
+| `File.Input`               | — _(see unmappables)_ | todo    |
+| `File.Label`               | — _(see unmappables)_ | todo    |
+| `File.Name`                | — _(see unmappables)_ | todo    |
+| `Footer`                   | `Footer`              | mapped  |
+| `Generic`                  | — _(see unmappables)_ | todo    |
+| `Heading`                  | _structural_          | mapped  |
+| `Help`                     | _structural_          | mapped  |
+| `Hero`                     | `Hero`                | mapped  |
+| `Hero.Body`                | `Hero.Body`           | mapped  |
+| `Hero.Foot`                | `Hero.Foot`           | mapped  |
+| `Hero.Head`                | `Hero.Head`           | mapped  |
+| `Highlight`                | — _(see unmappables)_ | todo    |
+| `Icon`                     | `Icon`                | partial |
+| `Image`                    | `Image`               | mapped  |
+| `Image.Container`          | _structural_          | mapped  |
+| `Input`                    | `Input`               | mapped  |
+| `Label`                    | _structural_          | mapped  |
+| `Level`                    | `Level`               | mapped  |
+| `Level.Item`               | _structural_          | mapped  |
+| `List`                     | — _(see unmappables)_ | todo    |
+| `List.Item`                | — _(see unmappables)_ | todo    |
+| `Loader`                   | _structural_          | mapped  |
+| `Media`                    | `Media`               | mapped  |
+| `Media.Item`               | _structural_          | mapped  |
+| `Menu`                     | `Menu`                | mapped  |
+| `Menu.Label`               | `Menu.Label`          | mapped  |
+| `Menu.List`                | `Menu.List`           | mapped  |
+| `Menu.List.Item`           | `Menu.Item`           | mapped  |
+| `Message`                  | `Message`             | mapped  |
+| `Message.Body`             | `Message.Body`        | mapped  |
+| `Message.Header`           | `Message.Header`      | mapped  |
+| `Modal`                    | `Modal`               | partial |
+| `Modal.Background`         | `Modal.Background`    | mapped  |
+| `Modal.Close`              | `Modal.Close`         | mapped  |
+| `Modal.Content`            | `Modal.Content`       | mapped  |
+| `Modal.Container`          | _structural_          | mapped  |
+| `Modal.Card`               | `Modal.Card`          | mapped  |
+| `Modal.Card.Body`          | `Modal.Card.Body`     | mapped  |
+| `Modal.Card.Foot`          | `Modal.Card.Foot`     | mapped  |
+| `Modal.Card.Head`          | `Modal.Card.Head`     | mapped  |
+| `Modal.Card.Title`         | `Modal.Card.Title`    | mapped  |
+| `Modal.Context`            | — _(see unmappables)_ | todo    |
+| `Modal.Portal`             | — _(see unmappables)_ | todo    |
+| `Navbar`                   | `Navbar`              | mapped  |
+| `Navbar.Brand`             | `Navbar.Brand`        | mapped  |
+| `Navbar.Burger`            | `Navbar.Burger`       | mapped  |
+| `Navbar.Divider`           | `Navbar.Divider`      | mapped  |
+| `Navbar.Menu`              | `Navbar.Menu`         | mapped  |
+| `Navbar.Link`              | `Navbar.Link`         | mapped  |
+| `Navbar.Item`              | _structural_          | mapped  |
+| `Navbar.Item.Container`    | _structural_          | mapped  |
+| `Navbar.Dropdown`          | _structural_          | mapped  |
+| `Navbar.Segment`           | _structural_          | mapped  |
+| `Navbar.Container`         | _structural_          | mapped  |
+| `Navbar.Context`           | — _(see unmappables)_ | todo    |
+| `Notification`             | `Notification`        | mapped  |
+| `Numeric`                  | — _(see unmappables)_ | todo    |
+| `PageLoader`               | `Loading`             | mapped  |
+| `Pagination`               | `Pagination`          | mapped  |
+| `Pagination.Link`          | `Pagination.Link`     | mapped  |
+| `Pagination.List`          | `Pagination.List`     | mapped  |
+| `Pagination.Ellipsis`      | `Pagination.Ellipsis` | mapped  |
+| `Pagination.Step`          | _structural_          | mapped  |
+| `Panel`                    | `Panel`               | mapped  |
+| `Panel.Heading`            | `Panel.Heading`       | mapped  |
+| `Panel.Block`              | `Panel.Block`         | mapped  |
+| `Panel.Icon`               | `Panel.Icon`          | partial |
+| `Panel.Tab`                | _structural_          | mapped  |
+| `Panel.Tab.Group`          | `Panel.Tabs`          | mapped  |
+| `Progress`                 | `Progress`            | mapped  |
+| `Radio`                    | `Radio`               | mapped  |
+| `Section`                  | `Section`             | mapped  |
+| `Select`                   | `Select`              | mapped  |
+| `Select.Container`         | _structural_          | mapped  |
+| `Select.Option`            | _structural_          | mapped  |
+| `Tab`                      | `Tabs.Item`           | mapped  |
+| `Tab.Group`                | `Tabs`                | mapped  |
+| `Table`                    | `Table`               | mapped  |
+| `Table.Body`               | `Table.Tbody`         | mapped  |
+| `Table.Cell`               | `Table.Td`            | mapped  |
+| `Table.Foot`               | `Table.Tfoot`         | mapped  |
+| `Table.Head`               | `Table.Thead`         | mapped  |
+| `Table.Heading`            | `Table.Th`            | mapped  |
+| `Table.Row`                | `Table.Tr`            | mapped  |
+| `Tag`                      | `Tag`                 | mapped  |
+| `Tag.Group`                | `Tags`                | mapped  |
+| `Textarea`                 | `TextArea`            | mapped  |
+| `Tile`                     | — _(see unmappables)_ | todo    |
+| `Title`                    | _structural_          | mapped  |
+| `forwardRefAs`             | — _(see unmappables)_ | todo    |
+
+## The renames worth memorising
+
+| rbx                                | bestax-bulma                                                                                               |
+| ---------------------------------- | ---------------------------------------------------------------------------------------------------------- |
+| `Tag.Group`                        | `Tags`                                                                                                     |
+| `Button.Group`                     | `Buttons`                                                                                                  |
+| `Column.Group`                     | `Columns`                                                                                                  |
+| `Card.Footer.Item`                 | `Card.FooterItem`                                                                                          |
+| `Table.Head` / `.Body` / `.Foot`   | `Table.Thead` / `.Tbody` / `.Tfoot`                                                                        |
+| `Table.Row` / `.Cell` / `.Heading` | `Table.Tr` / `.Td` / `.Th`                                                                                 |
+| `Textarea`                         | `TextArea`                                                                                                 |
+| `PageLoader`                       | `Loading` with `isFullPage`                                                                                |
+| `Loader`                           | a plain `<div className="loader">` — bestax's `Loading` is an overlay that renders nothing unless `active` |
+| `Menu.List.Item`                   | `Menu.Item`                                                                                                |
+| `Tab` / `Tab.Group`                | `Tabs.Item` / `Tabs`                                                                                       |
+| `Panel.Tab.Group`                  | `Panel.Tabs`                                                                                               |
+| `Title subtitle`                   | `SubTitle`                                                                                                 |
+
+## Value-chosen targets
+
+These pick a bestax component from a literal prop value; a dynamic value gets a TODO instead.
+
+| rbx               | value                                    | bestax-bulma                                   |
+| ----------------- | ---------------------------------------- | ---------------------------------------------- |
+| `Level.Item`      | `align="left"` / `"right"`               | `Level.Left` / `Level.Right`                   |
+| `Media.Item`      | `align="left"` / `"content"` / `"right"` | `Media.Left` / `Media.Content` / `Media.Right` |
+| `Navbar.Segment`  | `align="start"` / `"end"`                | `Navbar.Start` / `Navbar.End`                  |
+| `Pagination.Step` | `align="previous"` / `"next"`            | `Pagination.Previous` / `Pagination.Next`      |
+| `Navbar.Item`     | `dropdown`                               | `Navbar.Dropdown`                              |
diff --git a/skills/bestax-migrate/references/rbx/prop-map.md b/skills/bestax-migrate/references/rbx/prop-map.md
new file mode 100644
index 000000000..592c48ab8
--- /dev/null
+++ b/skills/bestax-migrate/references/rbx/prop-map.md
@@ -0,0 +1,116 @@
+# rbx → bestax-bulma prop map
+
+rbx and bestax both target Bulma, so most helper _values_ are already identical — the shapes
+differ, not the vocabulary. What follows is only what actually changes.
+
+## Universal helper props
+
+rbx mixes these into every component via `HelpersProps`.
+
+| rbx                               | bestax-bulma                 | note                                                       |
+| --------------------------------- | ---------------------------- | ---------------------------------------------------------- |
+| `backgroundColor`                 | `bgColor`                    | rename only                                                |
+| `textColor`                       | `textColor`                  | unchanged                                                  |
+| `textAlign`                       | `textAlign`                  | unchanged — both use `centered`/`justified`/`left`/`right` |
+| `textWeight`                      | `textWeight`                 | unchanged                                                  |
+| `textTransform`                   | `textTransform`              | unchanged                                                  |
+| `textSize={4}`                    | `textSize="4"`               | number → string                                            |
+| `italic`                          | `textTransform="italic"`     |                                                            |
+| `pull="left"`                     | `float="left"`               |                                                            |
+| `clearfix`, `overlay`, `relative` | same                         | unchanged booleans                                         |
+| `clipped`                         | `overflow="clipped"`         |                                                            |
+| `hidden`                          | `visibility="hidden"`        |                                                            |
+| `invisible`                       | `visibility="invisible"`     |                                                            |
+| `srOnly`                          | `visibility="sr-only"`       |                                                            |
+| `marginless`                      | `m="0"`                      | Bulma v1 removed `is-marginless`                           |
+| `paddingless`                     | `p="0"`                      | Bulma v1 removed `is-paddingless`                          |
+| `radiusless`                      | `radius="radiusless"`        |                                                            |
+| `shadowless`                      | `shadow="shadowless"`        |                                                            |
+| `unselectable`                    | `interaction="unselectable"` |                                                            |
+
+Two rbx colour names have no bestax equivalent: **`white-ter`** and **`white-bis`**. Everything
+else in rbx's `colors` and `shades` unions exists in bestax verbatim.
+
+## Bare boolean modifiers → `is*`
+
+`outlined` → `isOutlined`, `rounded` → `isRounded`, `inverted` → `isInverted`,
+`fullwidth` → `isFullwidth`, `static` → `isStatic`, `narrow` → `isNarrow`,
+`bordered`/`striped`/`hoverable` on `Table` → `isBordered`/`isStriped`/`isHoverable`,
+`delete` on `Tag` → `isDelete`.
+
+## State props → booleans
+
+| rbx                                                 | bestax-bulma                           |
+| --------------------------------------------------- | -------------------------------------- |
+| `Button state="loading"`                            | `isLoading`                            |
+| `Button state="hovered"` / `"focused"` / `"active"` | `isHovered` / `isFocused` / `isActive` |
+| `Input state="focused"` / `"hovered"`               | `isFocused` / `isHovered`              |
+| `Select.Container state="loading"`                  | `isLoading`                            |
+
+## Form grouping
+
+bestax folds rbx's `kind` + `multiline` + `align` into two value-taking props.
+
+| rbx                                     | bestax-bulma                                                                                                            |
+| --------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| `Field kind="addons"`                   | `hasAddons`                                                                                                             |
+| `Field kind="group"`                    | `grouped`                                                                                                               |
+| `Field multiline` (with `kind="group"`) | `grouped="multiline"`                                                                                                   |
+| `Field align="centered"`                | ambiguous — TODO; set `grouped`/`hasAddons` to `"centered"` by hand                                                     |
+| `Control expanded` / `loading`          | `isExpanded` / `isLoading`                                                                                              |
+| `Control iconLeft` / `iconRight`        | `hasIconsLeft` / `hasIconsRight` — note bestax's own `iconLeft` takes an `IconProps` object, which is a different thing |
+| `Textarea fixedSize`                    | `hasFixedSize`                                                                                                          |
+
+## Breakpoint objects
+
+rbx has three shapes; all three flatten to bestax's per-viewport props.
+
+```jsx
+// 1. the universal `responsive` helper prop
+<Box responsive={{ tablet: { display: { value: "flex" }, textSize: { value: 5 } } }} />
+<Box displayTablet="flex" textSizeTablet="5" />
+
+// 2. Column sizing
+<Column tablet={{ size: 6, narrow: true }} />
+<Column sizeTablet={6} isNarrowTablet />
+
+// 3. Column.Group gaps
+<Column.Group tablet={{ gapSize: 2 }} />
+<Columns gapTablet={2} />
+```
+
+`hide: { value: true }` becomes `visibility<Viewport>="hidden"`. The **`touch`** breakpoint and
+`{ only: true }` have no bestax props — both are TODOs.
+
+## `as`
+
+rbx's `forwardRefAs` puts `as` on **every** component. bestax declares it on a smaller set, and
+several of those narrow it to specific tags (`Footer` is `'footer' | 'div'`, `Control` is
+`'div'`). The codemod passes `as` through only where bestax really accepts it, and TODOs it
+everywhere else:
+
+| bestax component             | `as` accepts               |
+| ---------------------------- | -------------------------- |
+| `Button`                     | any element type           |
+| `Title`, `SubTitle`          | `h1`–`h6`, `p`             |
+| `Image`                      | `'figure' \| 'div' \| 'p'` |
+| `Footer`                     | `'footer' \| 'div'`        |
+| `Media`                      | `'article' \| 'div'`       |
+| `Media.Left`                 | `'figure' \| 'div'`        |
+| `Level.Item`                 | `'div' \| 'p' \| 'a'`      |
+| `Control`                    | `'div'`                    |
+| `Menu.Item`                  | any element type           |
+| `Dropdown.Item`              | `'a' \| 'div' \| 'button'` |
+| `Navbar.Item`, `Navbar.Link` | any element type           |
+
+Three traps worth naming, because rbx supplies `as` universally and the obvious guesses are
+wrong:
+
+- The **`Dropdown` and `Navbar` roots do not take `as`** — only their `.Item` / `.Link`
+  sub-components do.
+- **`Media.Item` depends on its `align`.** It resolves to `Media.Left`, `Media.Content` or
+  `Media.Right`, and only `Media.Left` declares `as`; the codemod drops it with a TODO on the
+  other two.
+- Several of the accepted props are **narrow literal unions**, so `as={SomeComponent}` still
+  fails to typecheck even where `as` is allowed — which is deliberate: a visible type error
+  beats a silent rewrite.
diff --git a/skills/bestax-migrate/references/rbx/unmappables.md b/skills/bestax-migrate/references/rbx/unmappables.md
new file mode 100644
index 000000000..2120aa510
--- /dev/null
+++ b/skills/bestax-migrate/references/rbx/unmappables.md
@@ -0,0 +1,169 @@
+# Recipes for every TODO(bestax-migrate) the rbx codemod leaves
+
+Ordered by how often they appear when the codemod runs over rbx's own documentation examples.
+Resolve the comment, then delete it. Never silence a TODO without converting the code.
+
+## `component:Icon` — the icon child
+
+bestax's `Icon` takes a **required `name`** instead of an icon child, and rbx's docs teach the
+FontAwesome component form, which carries no readable name.
+
+```jsx
+<Icon size="small"><FontAwesomeIcon icon={faHome} /></Icon>
+<Icon name="home" library="fa" variant="solid" size="small" />
+```
+
+`library` is `fa` | `mdi` | `ion` | `material-icons` | `material-symbols`; `variant` is the style
+(`solid`, `regular`, `brands`, …). Icon-font children the parser _can_ read
+(`<i className="fas fa-home" />`) are converted automatically.
+
+## `component:Tile` — Bulma v1 removed tiles
+
+Use Grid and Cell. `Tile kind="ancestor"` becomes `<Grid>`, `kind="parent"`/`kind="child"`
+become `<Cell>`, and `size={n}` becomes a column span.
+
+```jsx
+<Tile kind="ancestor"><Tile kind="parent" size={4}><Tile kind="child">x</Tile></Tile></Tile>
+<Grid><Cell colSpan={4}>x</Cell></Grid>
+```
+
+## `component:File.*` — the file-input parts
+
+bestax's `<File>` renders the whole Bulma structure itself, so `File.Label`, `File.Input`,
+`File.CTA`, `File.Icon` and `File.Name` have nothing to become.
+
+```jsx
+<File hasName>
+  <File.Label>
+    <File.Input name="upload" />
+    <File.CTA><File.Label>Choose…</File.Label></File.CTA>
+    <File.Name>none</File.Name>
+  </File.Label>
+</File>
+
+<File name="upload" label="Choose…" hasName />
+```
+
+## `prop:as` — polymorphism
+
+rbx puts `as` on everything; bestax does not. Either render the tag directly, or restructure.
+See the `as` section of [prop-map.md](prop-map.md) for the components that do accept it.
+
+## `component:Generic` — rbx's base element
+
+`Generic` is rbx's untyped passthrough. Render the underlying tag, and move its helper props to
+the nearest bestax component (or a `className`).
+
+## `component:Dropdown` and its parts
+
+bestax's `Dropdown` takes a `label` and renders its own trigger and menu, so rbx's four-element
+structure collapses to one.
+
+```jsx
+<Dropdown>
+  <Dropdown.Trigger>Open</Dropdown.Trigger>
+  <Dropdown.Menu><Dropdown.Content>
+    <Dropdown.Item active>one</Dropdown.Item>
+  </Dropdown.Content></Dropdown.Menu>
+</Dropdown>
+
+<Dropdown label="Open">
+  <Dropdown.Item active>one</Dropdown.Item>
+</Dropdown>
+```
+
+## `Navbar.Item dropdown` — open/close state is not carried over
+
+The structural rewrite is automatic (`<Navbar.Item dropdown>` becomes
+`<Navbar.Dropdown>`, and rbx's `<Navbar.Dropdown>` becomes `<Navbar.DropdownMenu>`), but the
+**behaviour is not the same**. rbx's dropdown owns its own click and outside-click state; bestax's
+`Navbar.Dropdown` is presentational and opens from `hoverable` or a controlled `active`.
+
+So a migrated dropdown renders correctly and does nothing on click. Pick one:
+
+```jsx
+<Navbar.Dropdown hoverable>…</Navbar.Dropdown>          // opens on hover
+<Navbar.Dropdown active={open}>…</Navbar.Dropdown>      // you own the state
+```
+
+Nothing flags this — the markup is valid either way — so audit your navbars after migrating.
+
+## `component:List` — the bulma-list extension
+
+Bulma v1 does not ship it. Use `<UnorderedList>`/`<UnorderedList.Item>` for a plain list, or
+`<Menu>`/`<Menu.Item>` when the items are navigation.
+
+## `component:Fieldset`, `component:Numeric`, `component:Highlight`
+
+No bestax equivalents, and none needed: render a plain `<fieldset>` (its `disabled` attribute
+works natively), use `Intl.NumberFormat` directly, and use `<Pre>` with your own highlighter.
+
+## `responsive` — `touch` and `{ only: true }`
+
+bestax's viewports are `mobile`/`tablet`/`desktop`/`widescreen`/`fullhd`, with no `touch` and no
+`-only` variants. Reach for a `className` with the Bulma class, or restyle in CSS.
+
+The codemod always removes the whole `responsive` prop, even when part of it could not be
+converted — bestax has its own unrelated `responsive` prop (`'mobile' | 'narrow'`), so leaving a
+half-emptied rbx object behind would be a type error rather than a leftover. The TODO names
+which breakpoints did not carry.
+
+## Props with no counterpart
+
+| TODO                                               | What to do                                                                                                                                                                                                                                               |
+| -------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `prop:closeOnEsc` on `Modal`                       | bestax implements no Escape handling at all; add your own keydown listener, or drop the prop                                                                                                                                                             |
+| `prop:closeOnBlur` on `Modal`                      | the migrated compound form renders `Modal.Background` as you wrote it; wire its `onClick` to your `onClose`                                                                                                                                              |
+| `prop:selected`, `prop:text` on `Button`           | `className="is-selected"`; for `is-text` use `color="ghost"` or a link                                                                                                                                                                                   |
+| `prop:size` on `Button.Group` / `Tags` / `Message` | set `size` on each child instead                                                                                                                                                                                                                         |
+| `prop:gradient` on `Hero`                          | Bulma v1 removed `is-bold` gradients; use `bgColor` or a custom class                                                                                                                                                                                    |
+| `prop:color`, `prop:vertical` on `Divider`         | bestax's `Divider` takes only `bgColor` and renders an `<hr>`                                                                                                                                                                                            |
+| `component:Divider` (a labelled divider)           | rbx rendered `<Divider>OR</Divider>`'s children as a centred label via `data-content`; bestax's `Divider` is a bare `<hr>` and takes no children -- React rejects children on a void element at runtime. Put the label in surrounding markup, or drop it |
+| `prop:direction` on `PageLoader`                   | no directional variant; drop it or add a class                                                                                                                                                                                                           |
+| `prop:innerRef`                                    | the affected roots (`Dropdown`, `Modal`, `Navbar`) are plain function components and forward no ref — drop it, or put the ref on a wrapping element you control                                                                                          |
+| `prop:managed`                                     | bestax components are uncontrolled; drive the `Modal` with `active` and `onClose`                                                                                                                                                                        |
+| `prop:document` on `Modal`                         | bestax renders the Modal inline rather than portalling into any document — see [Modal behaviours bestax does not implement](#modal-behaviours-bestax-does-not-implement)                                                                                 |
+| `prop:document` on `Navbar`                        | bestax's `Navbar` has no `document` prop; drop it                                                                                                                                                                                                        |
+| `badgeOutlined`, `badgeRounded`, `badgeSize`       | bestax's `Badge` has no outline, pill or size variant                                                                                                                                                                                                    |
+| `tooltipResponsive`                                | bestax's `Tooltip` has one `position` for all viewports                                                                                                                                                                                                  |
+
+## Modal behaviours bestax does not implement
+
+`component:Modal` — emitted on **every** Modal the codemod converts, whether or not you passed
+any of the props above.
+
+rbx's Modal did three things by default that bestax's does not do at all:
+
+| rbx default                      | bestax                                              |
+| -------------------------------- | --------------------------------------------------- |
+| portals into `document.body`     | renders inline, exactly where you place it          |
+| closes on Escape                 | no keydown handling of any kind                     |
+| clips document scroll while open | no scroll locking; the page behind stays scrollable |
+
+The markup migrates cleanly, so nothing fails to compile and nothing looks wrong in a
+screenshot — which is why this one is flagged unconditionally rather than left to review. Re-add
+whichever your UI actually relied on:
+
+- **Portal** — wrap the render in `createPortal(…, document.body)` yourself. This matters most if
+  an ancestor has `overflow: hidden`, `filter`, or a `transform`, any of which will now clip or
+  re-parent the modal that used to escape them.
+- **Escape** — add a `keydown` listener while the modal is open and call your `onClose`.
+- **Scroll lock** — Bulma still ships `.is-clipped`; put it on `<html>` while the modal is open.
+
+Background click is the one that does carry over, but only because you write it: the migrated
+compound form renders your `Modal.Background`, so wire its `onClick` to the same `onClose`.
+
+## `prop:textColor="white-ter"` / `"white-bis"`
+
+The only two rbx colour names bestax does not carry. Use `white`, or a custom class.
+
+## `value-reference` — a component used as a value
+
+`const X = Card.Header;` and similar. The codemod rewrites what it can prove safe and flags the
+rest; convert the usage by hand.
+
+## Dynamic values
+
+Anything the codemod cannot read statically (`state={x}`, `align={side}`,
+`subtitle={isSub}`) is left in place with a TODO. Split the branch by hand — the codemod never
+guesses at a runtime value.
diff --git a/skills/bestax-migrate/references/component-map.md b/skills/bestax-migrate/references/react-bulma-components/component-map.md
similarity index 100%
rename from skills/bestax-migrate/references/component-map.md
rename to skills/bestax-migrate/references/react-bulma-components/component-map.md
diff --git a/skills/bestax-migrate/references/prop-map.md b/skills/bestax-migrate/references/react-bulma-components/prop-map.md
similarity index 100%
rename from skills/bestax-migrate/references/prop-map.md
rename to skills/bestax-migrate/references/react-bulma-components/prop-map.md
diff --git a/skills/bestax-migrate/references/unmappables.md b/skills/bestax-migrate/references/react-bulma-components/unmappables.md
similarity index 100%
rename from skills/bestax-migrate/references/unmappables.md
rename to skills/bestax-migrate/references/react-bulma-components/unmappables.md
diff --git a/telemetry-worker/src/schema.ts b/telemetry-worker/src/schema.ts
index bdf80e781..a340a25cd 100644
--- a/telemetry-worker/src/schema.ts
+++ b/telemetry-worker/src/schema.ts
@@ -39,7 +39,7 @@ const ICON_LIBRARY_VALUES = [
   'material-symbols',
 ] as const;
 // bestax-migrate/src/sources/registry.ts → SOURCES
-const MIGRATE_SOURCE_VALUES = ['react-bulma-components'] as const;
+const MIGRATE_SOURCE_VALUES = ['react-bulma-components', 'rbx'] as const;
 // bestax-migrate/src/cli.ts → CSS_MODES
 const CSS_MODE_VALUES = ['bestax', 'bulma', 'keep'] as const;
 const PACKAGE_MANAGER_VALUES = ['npm', 'pnpm', 'yarn', 'bun'] as const;