@oxyhq/bloom 0.89.0 → 1.0.0

package/src/__tests__/design-tokens-json.test.ts

@@ -1,112 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-import {
-  bloomDesignTokens,
-  renderBloomTokensJson,
-  resolvedColorToHex,
-  type PresetGroup,
-} from '../design-tokens/tokens-json';
-import { APP_COLOR_NAMES, APP_COLOR_PRESETS } from '../theme/color-presets';
-import { CANONICAL_TOKENS, getResolvedTokens } from '../theme/token-registry';
-
-const TOKENS_PATH = join(__dirname, '..', 'design-tokens', 'tokens.json');
-
-describe('the shipped tokens.json is generated, not maintained', () => {
-  it('is byte-identical to a fresh render', () => {
-    // The whole guarantee: a token changed in the engine and not regenerated
-    // fails here rather than shipping a JSON that describes a palette Bloom no
-    // longer paints.
-    expect(readFileSync(TOKENS_PATH, 'utf8')).toBe(renderBloomTokensJson());
-  });
-
-  it('says so in its own $description', () => {
-    expect(bloomDesignTokens().$description).toContain('AUTO-GENERATED');
-  });
-});
-
-describe('tokens.json shape contract', () => {
-  /* Astro codegens C++ SkColor tables from these paths, so the shape is a
-   * published interface: new groups may be added, existing paths may not move. */
-  const tokens = bloomDesignTokens();
-
-  it('covers every preset Bloom ships, and nothing else', () => {
-    const presets = Object.keys(tokens.color).filter((key) => !key.startsWith('$'));
-    expect(presets.sort()).toEqual([...APP_COLOR_NAMES].sort());
-  });
-
-  it('carries both schemes and every canonical token, for every preset', () => {
-    for (const name of APP_COLOR_NAMES) {
-      const preset = tokens.color[name] as PresetGroup;
-      for (const scheme of ['light', 'dark'] as const) {
-        expect(Object.keys(preset[scheme]).sort()).toEqual([...CANONICAL_TOKENS].sort());
-      }
-    }
-  });
-
-  it('names tokens as the CSS custom property without the leading --', () => {
-    // What makes the mapping mechanical for a consumer. A token renamed on one
-    // side only would break it silently.
-    const preset = tokens.color.oxy as PresetGroup;
-    for (const token of Object.keys(preset.light)) {
-      expect(token.startsWith('--')).toBe(false);
-      expect(getResolvedTokens('oxy', 'light')[`--${token}`]).toBeDefined();
-    }
-  });
-
-  it('resolves every colour to an sRGB hex string', () => {
-    for (const name of APP_COLOR_NAMES) {
-      const preset = tokens.color[name] as PresetGroup;
-      for (const scheme of ['light', 'dark'] as const) {
-        for (const [token, entry] of Object.entries(preset[scheme])) {
-          expect(`${name}.${scheme}.${token} = ${String(entry.$value)}`).toMatch(
-            /= #[0-9a-f]{6}([0-9a-f]{2})?$/,
-          );
-        }
-      }
-    }
-  });
-
-  it('records each preset’s seed and variant', () => {
-    for (const name of APP_COLOR_NAMES) {
-      const preset = tokens.color[name] as PresetGroup;
-      expect(preset.$extensions['so.oxy.bloom']).toMatchObject({
-        seed: APP_COLOR_PRESETS[name].hex,
-        variant: APP_COLOR_PRESETS[name].variant,
-      });
-    }
-  });
-
-  it('emits the numeric scales as px dimensions', () => {
-    expect(tokens.spacing['space-8']).toEqual({ $value: '8px' });
-    expect(tokens.radius['radius-max']).toEqual({ $value: '9999px' });
-    expect(tokens.borderWidth['hairline']).toEqual({ $value: '0.5px' });
-    expect(tokens.typography['body']).toMatchObject({
-      fontSize: { $value: '15px' },
-      fontWeight: { $value: 400 },
-    });
-  });
-});
-
-describe('resolvedColorToHex', () => {
-  it('converts the engine’s two output forms', () => {
-    expect(resolvedColorToHex('rgb(255 239 253)')).toBe('#ffeffd');
-    expect(resolvedColorToHex('rgb(0 0 0)')).toBe('#000000');
-    // 0.13 × 255 = 33.15 → 33 → 0x21. An 8-bit alpha is exactly what an SkColor
-    // holds, so nothing is lost downstream.
-    expect(resolvedColorToHex('rgba(213, 86, 255, 0.13)')).toBe('#d556ff21');
-  });
-
-  it('drops a fully opaque alpha rather than emitting #rrggbbff', () => {
-    expect(resolvedColorToHex('rgba(1, 2, 3, 1)')).toBe('#010203');
-  });
-
-  /* The engine emitting a third form — an oklch(), a bare hex, a named colour —
-   * would otherwise reach a C++ colour table as an unparseable string. Failing
-   * at generation time is the only place anyone would notice. */
-  it('throws on anything that is not an rgb()/rgba() colour', () => {
-    expect(() => resolvedColorToHex('oklch(0.7 0.1 300)')).toThrow(/not an rgb/);
-    expect(() => resolvedColorToHex('#ffeffd')).toThrow(/not an rgb/);
-    expect(() => resolvedColorToHex('0.5rem')).toThrow(/not an rgb/);
-  });
-});

package/src/__tests__/design-tokens.test.ts

@@ -1,343 +0,0 @@
-import { existsSync, readFileSync, statSync } from 'node:fs';
-import { dirname, join, relative } from 'node:path';
-
-import {
-  bloomTailwindPreset,
-  bloomThemeCss,
-  bloomThemeBlock,
-  getPresetVars,
-  buildSeedScopeVars,
-  FILL_ROLES,
-  TEXT_ROLES,
-  BORDER_ROLES,
-  SPACING,
-  RADIUS,
-  BORDER_WIDTH,
-  TYPOGRAPHY,
-  FONT_FAMILY_VARS,
-  SHADOW_BOX,
-  bloomShadowStyle,
-} from '../design-tokens';
-import { APP_COLOR_PRESETS } from '../theme/color-presets';
-import { buildScopeVars } from '../theme/color-scope/style-builder';
-import { CANONICAL_TOKENS } from '../theme/token-registry';
-
-describe('design-tokens color roles', () => {
-  const allRoles = { ...FILL_ROLES, ...TEXT_ROLES, ...BORDER_ROLES };
-
-  it('every color role is a var(--canonical) reference (no hardcoded color)', () => {
-    for (const [role, value] of Object.entries(allRoles)) {
-      expect(value).toMatch(/^var\(--[a-z-]+\)$/);
-      // Never wrap a base token in hsl() — bloom base tokens are full rgb colors.
-      expect(value).not.toContain('hsl(');
-    }
-  });
-
-  it('every color role aliases an existing canonical theme token', () => {
-    for (const value of Object.values(allRoles)) {
-      const token = value.replace(/^var\(--/, '').replace(/\)$/, '');
-      expect(CANONICAL_TOKENS).toContain(token as never);
-    }
-  });
-});
-
-describe('design-tokens numeric scales', () => {
-  it('exposes the spec spacing scale + screen-margin', () => {
-    expect(SPACING).toMatchObject({
-      'space-2': 2,
-      'space-4': 4,
-      'space-8': 8,
-      'space-12': 12,
-      'space-16': 16,
-      'space-20': 20,
-      'space-24': 24,
-      'space-32': 32,
-      'screen-margin': 20,
-    });
-  });
-
-  it('exposes the spec radius scale', () => {
-    expect(RADIUS).toMatchObject({
-      'radius-8': 8,
-      'radius-12': 12,
-      'radius-20': 20,
-      'radius-28': 28,
-      'radius-max': 9999,
-    });
-  });
-
-  it('exposes the 0.5px hairline border width', () => {
-    expect(BORDER_WIDTH.hairline).toBe(0.5);
-  });
-});
-
-describe('design-tokens typography', () => {
-  it('covers every spec type role', () => {
-    const names = Object.keys(TYPOGRAPHY).sort();
-    expect(names).toEqual(
-      [
-        'body',
-        'bodySmall',
-        'bodyTitleSmall',
-        'buttonLarge',
-        'caption',
-        'headerBold',
-        'sectionTitle',
-        'subtitle',
-      ].sort(),
-    );
-  });
-
-  it('each role has a valid size/lineHeight/weight/family', () => {
-    for (const role of Object.values(TYPOGRAPHY)) {
-      expect(role.size).toBeGreaterThan(0);
-      expect(role.lineHeight).toBeGreaterThanOrEqual(role.size);
-      expect(['400', '500', '600', '700']).toContain(role.weight);
-      expect(FONT_FAMILY_VARS[role.family]).toBeDefined();
-    }
-  });
-});
-
-describe('design-tokens Tailwind preset', () => {
-  const ext = bloomTailwindPreset.theme.extend;
-
-  it('only extends theme (additive, no top-level theme override)', () => {
-    expect(Object.keys(bloomTailwindPreset)).toEqual(['theme']);
-    expect(Object.keys(bloomTailwindPreset.theme)).toEqual(['extend']);
-  });
-
-  it('color roles reach background/text/border buckets', () => {
-    expect(ext.backgroundColor['fill']).toBe('var(--card)');
-    expect(ext.textColor['text-tertiary']).toBe('var(--muted-foreground)');
-    expect(ext.borderColor['border-input-active']).toBe('var(--ring)');
-  });
-
-  it('spacing/radius are emitted in px', () => {
-    expect(ext.spacing['space-8']).toBe('8px');
-    expect(ext.spacing['screen-margin']).toBe('20px');
-    expect(ext.borderRadius['radius-20']).toBe('20px');
-    expect(ext.borderWidth['hairline']).toBe('0.5px');
-  });
-
-  it('fontSize entries are [size, { lineHeight }] tuples', () => {
-    expect(ext.fontSize['body']).toEqual(['15px', { lineHeight: '22px' }]);
-    expect(ext.fontSize['headerBold']).toEqual(['28px', { lineHeight: '34px' }]);
-  });
-
-  it('fontFamily entries are [family, { fontWeight }] tuples', () => {
-    expect(ext.fontFamily['body']).toEqual([
-      'var(--bloom-font-sans)',
-      { fontWeight: '400' },
-    ]);
-    expect(ext.fontFamily['headerBold']).toEqual([
-      'var(--bloom-font-display)',
-      { fontWeight: '700' },
-    ]);
-  });
-
-  it('registers shadow-s and shadow-m box shadows', () => {
-    expect(ext.boxShadow['s']).toBe(SHADOW_BOX.s);
-    expect(ext.boxShadow['m']).toBe(SHADOW_BOX.m);
-  });
-
-  it('is frozen so consumer config merges cannot mutate it', () => {
-    expect(Object.isFrozen(bloomTailwindPreset)).toBe(true);
-  });
-});
-
-describe('design-tokens v4 @theme css', () => {
-  const css = bloomThemeCss();
-
-  it('emits --color-<role> aliases as direct var(--x) (never hsl-wrapped)', () => {
-    expect(css).toContain('--color-fill: var(--card);');
-    expect(css).toContain('--color-text-tertiary: var(--muted-foreground);');
-    expect(css).not.toContain('hsl(var(');
-  });
-
-  it('emits spacing, radius, typography and shadow vars', () => {
-    expect(css).toContain('--spacing-space-8: 8px;');
-    expect(css).toContain('--radius-radius-20: 20px;');
-    expect(css).toContain('--text-body: 15px;');
-    expect(css).toContain('--text-body--line-height: 22px;');
-    expect(css).toContain('--font-body: var(--bloom-font-sans);');
-    expect(css).toContain('--shadow-s:');
-  });
-
-  it('wraps the body in a @theme block', () => {
-    expect(bloomThemeBlock()).toMatch(/^@theme \{[\s\S]*\}$/);
-  });
-});
-
-describe('design-tokens shipped theme.css', () => {
-  // The static artifact consumers `@import`. Generated by
-  // scripts/generate-theme-css.ts from the SAME source as bloomThemeCss(),
-  // so this guards against JS/CSS drift.
-  const themeCss = readFileSync(
-    join(__dirname, '..', 'design-tokens', 'theme.css'),
-    'utf8',
-  );
-
-  it('the @theme block equals bloomThemeBlock() (no drift)', () => {
-    const block = themeCss.slice(themeCss.indexOf('@theme')).trimEnd();
-    expect(block).toBe(bloomThemeBlock());
-  });
-
-  it('carries the auto-generated / do-not-edit header', () => {
-    expect(themeCss).toContain('AUTO-GENERATED');
-    expect(themeCss).toContain('bun run generate:theme-css');
-  });
-});
-
-describe('design-tokens shadow style (web default)', () => {
-  it('returns a boxShadow style on the web/default fork', () => {
-    const style = bloomShadowStyle('m');
-    expect(style).toHaveProperty('boxShadow', SHADOW_BOX.m);
-  });
-});
-
-describe('design-tokens resolved token values', () => {
-  it('getPresetVars resolves a preset to canonical tokens only', () => {
-    const vars = getPresetVars('oxy', 'dark');
-    expect(vars['--background']).toMatch(/^rgb/);
-    // A document root needs the canonical tokens alone — the `--color-x` alias
-    // layer comes from theme.css / bloomThemeCss().
-    expect(Object.keys(vars).some((k) => k.startsWith('--color-'))).toBe(false);
-  });
-
-  it('buildSeedScopeVars also emits the --color-x aliases a scope needs', () => {
-    const vars = buildSeedScopeVars({ seed: '#7c5aed', mode: 'dark' });
-    // Every canonical token gets a same-named alias. The role vocabulary
-    // (`--color-fill` → `--card`) is checked against theme.css further down,
-    // where the mapping comes from rather than being restated here.
-    const canonical = Object.keys(vars).filter((k) => !k.startsWith('--color-'));
-    expect(canonical.length).toBeGreaterThan(0);
-    for (const token of canonical) {
-      expect(vars[`--color-${token.slice(2)}`]).toBe(vars[token]);
-    }
-  });
-
-  it("a preset's own seed reproduces that preset exactly", () => {
-    // What lets a consumer theme a brand scope and the document root through one
-    // code path: the seed form is not an approximation of the preset form.
-    const preset = APP_COLOR_PRESETS.oxy;
-    for (const mode of ['light', 'dark'] as const) {
-      const fromPreset = getPresetVars('oxy', mode);
-      const fromSeed = buildSeedScopeVars({
-        seed: preset.hex,
-        mode,
-        variant: preset.variant,
-      });
-      for (const [token, value] of Object.entries(fromPreset)) {
-        expect(fromSeed[token]).toBe(value);
-      }
-    }
-  });
-});
-
-describe('a scope re-declares every alias theme.css points at a token', () => {
-  /* The failure this guards is silent and mode-dependent: a scope overrides
-   * `--foreground`, but `--color-text: var(--foreground)` was computed at the
-   * document root, so `text-text` inside the scope keeps painting the app-wide
-   * colour. It looks correct in whichever mode the root happens to match.
-   *
-   * The list is read out of `bloomThemeCss()` rather than written here, so an
-   * alias added there is covered the day it lands. */
-  const rootAliases = bloomThemeCss()
-    .split('\n')
-    .map((line) => /^\s*--color-([a-z0-9-]+):\s*var\(--([a-z0-9-]+)\);\s*$/.exec(line))
-    .filter((match): match is RegExpExecArray => match !== null)
-    .map((match) => ({ alias: match[1] as string, canonical: match[2] as string }))
-
-  it('covers a meaningful number of aliases', () => {
-    // A regex that stopped matching would otherwise leave every case below
-    // passing over an empty list.
-    expect(rootAliases.length).toBeGreaterThan(20)
-  })
-
-  for (const [label, scope] of [
-    ['seed', buildSeedScopeVars({ seed: '#7c5aed', mode: 'dark' })],
-    ['preset', buildScopeVars('faircoin', 'dark')],
-  ] as const) {
-    it(`resolves them against the scope's own tokens (${label})`, () => {
-      const wrong = rootAliases
-        .filter(({ canonical }) => scope[`--${canonical}`] !== undefined)
-        .filter(({ alias, canonical }) => scope[`--color-${alias}`] !== scope[`--${canonical}`])
-        .map(({ alias, canonical }) => `--color-${alias} != --${canonical}`)
-      expect(wrong).toEqual([])
-    })
-  }
-})
-
-describe('design-tokens entry stays free of react / react-native', () => {
-  /* Build scripts import this entry from plain node/bun to emit a static theme
-   * stylesheet (see the export's doc comment). A `react-native` import anywhere
-   * in its transitive graph makes that throw at import time — in the CONSUMER's
-   * build, with a parse error inside node_modules and nothing pointing back
-   * here. Jest cannot catch it by importing the module: this suite runs in the
-   * RN preset, where both packages resolve. So walk the graph statically. */
-  const SOURCE_ROOT = join(__dirname, '..');
-  /* Captures the clause of every `import`/`export … from '…'`, so a type-only
-   * one can be told apart from a value one. `import { type ViewStyle } from
-   * 'react-native'` is erased by the compiler and is FINE here; a value import
-   * of the same module is not. A scanner blind to the difference reports the
-   * shipped `shadows.ts` as a violation. */
-  const IMPORT_RE = /(?:import|export)\s+([\s\S]*?)\s*from\s*['"]([^'"]+)['"]/g;
-
-  function isValueImport(clause: string): boolean {
-    const trimmed = clause.trim();
-    if (trimmed.startsWith('type ') || trimmed === 'type') return false;
-    const named = /^\{([\s\S]*)\}$/.exec(trimmed)?.[1];
-    if (named === undefined) return true; // default or namespace import — always a value
-    return named
-      .split(',')
-      .map((specifier) => specifier.trim())
-      .filter(Boolean)
-      .some((specifier) => !specifier.startsWith('type '));
-  }
-
-  function resolve(specifier: string, fromFile: string): string | null {
-    const base = join(dirname(fromFile), specifier);
-    for (const candidate of [
-      base,
-      `${base}.ts`,
-      `${base}.tsx`,
-      join(base, 'index.ts'),
-      join(base, 'index.tsx'),
-    ]) {
-      if (existsSync(candidate) && statSync(candidate).isFile()) return candidate;
-    }
-    return null;
-  }
-
-  const entry = join(SOURCE_ROOT, 'design-tokens', 'index.ts');
-  const visited = new Set<string>();
-  const offenders: string[] = [];
-  const queue = [entry];
-
-  for (let file = queue.pop(); file !== undefined; file = queue.pop()) {
-    if (visited.has(file)) continue;
-    visited.add(file);
-    const source = readFileSync(file, 'utf8');
-    for (const match of source.matchAll(IMPORT_RE)) {
-      const [, clause = '', specifier = ''] = match;
-      if (!isValueImport(clause)) continue;
-      if (specifier === 'react' || specifier === 'react-native' || specifier.startsWith('react-native/')) {
-        offenders.push(`${relative(SOURCE_ROOT, file)} imports ${specifier}`);
-        continue;
-      }
-      if (!specifier.startsWith('.')) continue;
-      const resolved = resolve(specifier, file);
-      if (resolved) queue.push(resolved);
-    }
-  }
-
-  it('imports neither react nor react-native anywhere in its graph', () => {
-    expect(offenders).toEqual([]);
-  });
-
-  it('actually walked the graph', () => {
-    // Without a floor, a resolver that silently returns null for everything
-    // would report a clean graph of one file.
-    expect(visited.size).toBeGreaterThan(8);
-  });
-});

package/src/__tests__/dropdown-placement.test.ts

@@ -1,90 +0,0 @@
-import {
-  resolveDropdownPlacement,
-  type DropdownPlacementInput,
-} from '../overlay/dropdown-placement';
-
-const VIEWPORT = { width: 1000, height: 500 };
-const GUTTER = 8;
-
-/** A 200x40 trigger at (400, y), the shape the web `Menu` anchors against. */
-function trigger(y: number) {
-  return { top: y, bottom: y + 40, left: 400, right: 600 };
-}
-
-function place(overrides: Partial<DropdownPlacementInput>): { top: number; left: number } {
-  return resolveDropdownPlacement({
-    anchor: trigger(100),
-    size: { width: 180, height: 100 },
-    viewport: VIEWPORT,
-    offset: 6,
-    gutter: GUTTER,
-    align: 'end',
-    ...overrides,
-  });
-}
-
-describe('resolveDropdownPlacement', () => {
-  describe('vertical', () => {
-    it('sits below the anchor when it fits', () => {
-      // Trigger 100..140, surface 100 tall, offset 6 → 146..246, well inside 500.
-      expect(place({}).top).toBe(146);
-    });
-
-    it('flips above the anchor when there is no room below', () => {
-      // Trigger 420..460: below would end at 566, past 500 - 8. Above starts at
-      // 420 - 6 - 100 = 314, which clears the top gutter.
-      expect(place({ anchor: trigger(420) }).top).toBe(314);
-    });
-
-    it('prefers below when BOTH sides fit — flipping is a fallback, not a preference', () => {
-      expect(place({ anchor: trigger(200), size: { width: 180, height: 100 } }).top).toBe(246);
-    });
-
-    it('clamps into the viewport when neither side fits', () => {
-      // 460 tall against a 500 viewport: nothing fits either side of a
-      // mid-screen trigger, so it pins to 500 - 8 - 460 = 32.
-      expect(place({ anchor: trigger(200), size: { width: 180, height: 460 } }).top).toBe(32);
-    });
-
-    it('pins to the top gutter when the surface is taller than the viewport', () => {
-      // Overflowing the BOTTOM keeps the first rows reachable; the opposite
-      // choice would push the surface's start off-screen and strand every row.
-      expect(place({ anchor: trigger(200), size: { width: 180, height: 900 } }).top).toBe(GUTTER);
-    });
-
-    it('treats a zero-area anchor (a right-click point) as its own edge', () => {
-      const point = { top: 300, bottom: 300, left: 900, right: 900 };
-      expect(place({ anchor: point, offset: 0, align: 'start' }).top).toBe(300);
-      // 300 + 250 = 550 > 500 - 8, so it flips to 300 - 250 = 50.
-      expect(
-        place({ anchor: point, offset: 0, align: 'start', size: { width: 180, height: 250 } }).top,
-      ).toBe(50);
-    });
-  });
-
-  describe('horizontal', () => {
-    it("align 'end' lines the surface's right edge up with the anchor's", () => {
-      expect(place({ size: { width: 180, height: 100 } }).left).toBe(420);
-    });
-
-    it("align 'start' lines the surface's left edge up with the anchor's", () => {
-      expect(place({ align: 'start' }).left).toBe(400);
-    });
-
-    it('clamps a surface that would overflow the right edge', () => {
-      const point = { top: 100, bottom: 100, left: 980, right: 980 };
-      // 980 + 180 would reach 1160; pinned to 1000 - 8 - 180.
-      expect(place({ anchor: point, align: 'start' }).left).toBe(812);
-    });
-
-    it('clamps a surface that would overflow the left edge', () => {
-      const narrow = { top: 100, bottom: 140, left: 0, right: 20 };
-      // Right-aligning to x=20 would start at -160.
-      expect(place({ anchor: narrow }).left).toBe(GUTTER);
-    });
-
-    it('pins to the left gutter when the surface is wider than the viewport', () => {
-      expect(place({ size: { width: 1200, height: 100 } }).left).toBe(GUTTER);
-    });
-  });
-});

package/src/__tests__/exports-map-contract.test.ts

@@ -1,116 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-/**
- * The `react-native` export condition must stay SPLIT into `types` + `default`.
- *
- * Metro compiles Bloom from source, so `default` points at `src/`. TypeScript
- * honours `react-native` as well (expo/tsconfig.base sets
- * `customConditions: ["react-native"]`), and if the condition were a bare
- * string every native-targeted consumer would type-check Bloom's own `.tsx`
- * files — pulling `react-dom` (from the web forks) and optional peers like
- * `expo-haptics` / `@react-native-community/netinfo` into a program that never
- * declared them. Measured against a consumer fixture with no
- * `@types/react-dom`, the string form produces TS7016 on
- * `src/portal/index.web.tsx`, TS2307 on `src/hooks/useHaptics.tsx` and
- * `src/connection-status/index.tsx`, plus a nativewind TS2769 on
- * `src/dialog/DialogHeader.tsx`. `skipLibCheck` cannot suppress any of them —
- * a `.tsx` is not a declaration file.
- *
- * Splitting the condition means tsc asks for `types` and gets the built
- * declarations, while Metro (which never requests `types`) still falls through
- * to `default` and bundles source. Verified end to end with a real
- * `expo export --platform ios`.
- *
- * `package.json#exports` is generated by `scripts/generate-platform-exports.mjs`
- * — fix a failure there, never by hand-editing `package.json`.
- */
-
-type ExportEntry = Record<string, unknown>;
-
-// Read rather than `import` the manifest: tsconfig pins `rootDir` to `src`, so
-// a JSON import from outside it would drag package.json into the build program.
-const PKG_PATH = join(__dirname, '..', '..', 'package.json');
-const pkg = JSON.parse(readFileSync(PKG_PATH, 'utf8')) as {
-  exports: Record<string, ExportEntry | string>;
-};
-const exportsMap = pkg.exports;
-
-/** Non-subpath entries that are legitimately plain strings (static assets). */
-const STRING_ENTRIES = [
-  './design-tokens/theme.css',
-  './design-tokens/tokens.json',
-  './package.json',
-];
-
-/**
- * Vacuity floor. `SUBPATHS` in the generator is 86 entries today; a traversal
- * bug that silently found none must not read as a pass.
- */
-const MIN_SUBPATHS = 80;
-
-const subpathEntries = Object.entries(exportsMap).filter(
-  (entry): entry is [string, ExportEntry] => typeof entry[1] !== 'string',
-);
-
-describe('package.json#exports — react-native condition', () => {
-  it(`declares at least ${MIN_SUBPATHS} conditional subpaths`, () => {
-    expect(subpathEntries.length).toBeGreaterThanOrEqual(MIN_SUBPATHS);
-  });
-
-  it('exposes only the known static assets as string exports', () => {
-    const strings = Object.entries(exportsMap)
-      .filter(([, value]) => typeof value === 'string')
-      .map(([name]) => name);
-    expect(strings.sort()).toEqual([...STRING_ENTRIES].sort());
-  });
-
-  it('splits every react-native condition into types + default, in that order', () => {
-    const offenders: string[] = [];
-    for (const [name, entry] of subpathEntries) {
-      const condition = entry['react-native'];
-      if (typeof condition !== 'object' || condition === null) {
-        offenders.push(`${name}: react-native is ${JSON.stringify(condition)}, expected an object`);
-        continue;
-      }
-      const keys = Object.keys(condition);
-      if (keys.join(',') !== 'types,default') {
-        offenders.push(`${name}: react-native keys are [${keys.join(', ')}], expected [types, default]`);
-      }
-    }
-    expect(offenders).toEqual([]);
-  });
-
-  it('points react-native.default at src and react-native.types at the built declarations', () => {
-    const offenders: string[] = [];
-    for (const [name, entry] of subpathEntries) {
-      const condition = entry['react-native'];
-      if (typeof condition !== 'object' || condition === null) continue;
-      const { types, default: def } = condition as { types?: unknown; default?: unknown };
-
-      if (typeof def !== 'string' || !def.startsWith('./src/')) {
-        offenders.push(`${name}: react-native.default is ${JSON.stringify(def)}, expected a ./src/ path`);
-      }
-      if (typeof types !== 'string' || !types.startsWith('./lib/typescript/')) {
-        offenders.push(
-          `${name}: react-native.types is ${JSON.stringify(types)}, expected a ./lib/typescript/ path`,
-        );
-      }
-    }
-    expect(offenders).toEqual([]);
-  });
-
-  it('resolves react-native.types to the same declarations as the import condition', () => {
-    const offenders: string[] = [];
-    for (const [name, entry] of subpathEntries) {
-      const condition = entry['react-native'] as { types?: unknown } | undefined;
-      const importCondition = entry.import as { types?: unknown } | undefined;
-      if (condition?.types !== importCondition?.types) {
-        offenders.push(
-          `${name}: react-native.types (${String(condition?.types)}) !== import.types (${String(importCondition?.types)})`,
-        );
-      }
-    }
-    expect(offenders).toEqual([]);
-  });
-});