@astryxdesign/core 0.7.6-canary.f73623d → 0.7.6-canary.f77aaf2

package/src/postinstall.test.mjs

@@ -1,216 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file Guardrail tests for the @astryxdesign/core postinstall nudge (layer 1).
- *
- * Core cannot import the CLI, so it ships scripts/agent-doc-state.mjs — a
- * GENERATED, byte-for-byte copy of the CLI's dependency-free leaf. These tests
- * cover the behaviour core depends on (marker detection across EVERY agent-doc
- * location, legacy markers, the nudge decision matrix) and pin the copy to its
- * source by BYTES, so semantic drift is impossible rather than merely unlikely.
- */
-
-import {describe, it, expect, beforeEach, afterEach} from 'vitest';
-import {spawnSync} from 'node:child_process';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import {fileURLToPath} from 'node:url';
-// Core's own package-local contract copy — what actually runs at install time.
-import {
-  isAstryxInitialized,
-  isAstryxPromptInReach,
-  shouldNudge,
-  AGENT_DOC_PATHS,
-  INIT_MARKERS,
-  SETUP_NUDGE,
-  setupNudge,
-} from '../scripts/agent-doc-state.mjs';
-import {cliInvocation} from '../scripts/postinstall.mjs';
-// Dev-only, monorepo-relative: core must not depend on the CLI at runtime (the
-// CLI peer-depends on core), but the test can read the source and the generator.
-import * as cliLeaf from '../../cli/foundation/agent-docs/agent-doc-state.mjs';
-import {
-  renderCoreCopy,
-  checkCorePackaging,
-  CORE_TARGET,
-  CORE_TARGET_REL,
-  CLI_SOURCE_REL,
-} from '../../../scripts/generate-setup-contract.mjs';
-
-const MARKER = '<!-- ASTRYX:START -->';
-
-let tmp;
-beforeEach(() => {
-  tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'astryx-core-postinstall-'));
-});
-afterEach(() => {
-  fs.rmSync(tmp, {recursive: true, force: true});
-});
-function write(rel, body) {
-  const p = path.join(tmp, rel);
-  fs.mkdirSync(path.dirname(p), {recursive: true});
-  fs.writeFileSync(p, body);
-}
-
-describe('core postinstall — isAstryxInitialized (shared contract)', () => {
-  it('is false in an empty project', () => {
-    expect(isAstryxInitialized(tmp)).toBe(false);
-  });
-
-  it.each(['AGENTS.md', 'CLAUDE.md', '.claude/CLAUDE.md', '.cursorrules', '.hermes.md', 'HERMES.md'])(
-    'detects the marker in %s',
-    file => {
-      write(file, `# doc\n${MARKER}\nbody`);
-      expect(isAstryxInitialized(tmp)).toBe(true);
-    },
-  );
-
-  it('detects the legacy XDS marker', () => {
-    write('AGENTS.md', '<!-- XDS:START -->');
-    expect(isAstryxInitialized(tmp)).toBe(true);
-  });
-});
-
-describe('core postinstall — one authoritative source, no drift', () => {
-  // The previous guard compared two hand-edited constant lists, so a change to
-  // the PREDICATE (or to shouldNudge) could still make the two layers disagree
-  // about "is this project set up?" while the test stayed green. Core's copy is
-  // now generated from the CLI leaf, so the guard is byte equality: nothing in
-  // the contract — paths, markers, predicate or nudge decision — can diverge.
-  it('is byte-identical to what the generator produces from the CLI leaf', () => {
-    expect(fs.readFileSync(CORE_TARGET, 'utf-8')).toBe(renderCoreCopy());
-  });
-
-  it('names its source, so an editor of the copy is sent to the right file', () => {
-    const copy = fs.readFileSync(CORE_TARGET, 'utf-8');
-    expect(copy).toContain('GENERATED FILE');
-    expect(copy).toContain(CLI_SOURCE_REL);
-  });
-
-  it(`publishes ${CORE_TARGET_REL} in core's tarball`, () => {
-    // A copy core does not ship is a copy core's postinstall cannot import.
-    expect(checkCorePackaging()).toBeNull();
-  });
-
-  it('exposes the same contract values as the CLI leaf', () => {
-    expect(AGENT_DOC_PATHS).toEqual(cliLeaf.AGENT_DOC_PATHS);
-    expect(INIT_MARKERS).toEqual(cliLeaf.INIT_MARKERS);
-    expect(SETUP_NUDGE).toBe(cliLeaf.SETUP_NUDGE);
-    expect(setupNudge('pnpm exec astryx')).toBe(
-      cliLeaf.setupNudge('pnpm exec astryx'),
-    );
-  });
-
-  it('agrees with the CLI leaf on a real project', () => {
-    write('AGENTS.md', `# doc\n${MARKER}\nbody`);
-    expect(isAstryxInitialized(tmp)).toBe(cliLeaf.isAstryxInitialized(tmp));
-  });
-
-  it('agrees with the CLI leaf on a monorepo package', () => {
-    fs.mkdirSync(path.join(tmp, '.git'));
-    write('AGENTS.md', MARKER);
-    write('packages/app/package.json', '{"name":"app"}');
-    const app = path.join(tmp, 'packages/app');
-    expect(isAstryxPromptInReach(app)).toBe(true);
-    expect(isAstryxPromptInReach(app)).toBe(cliLeaf.isAstryxPromptInReach(app));
-  });
-});
-
-// Install time, end to end: core's real script and its contract copy, installed
-// under a monorepo's node_modules, run the way npm runs them for a package.
-describe('core postinstall — inside a monorepo package', () => {
-  const CORE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-  const install = () => {
-    const installed = path.join(tmp, 'node_modules/@astryxdesign/core/scripts');
-    fs.mkdirSync(installed, {recursive: true});
-    for (const file of ['postinstall.mjs', 'agent-doc-state.mjs']) {
-      fs.copyFileSync(path.join(CORE, 'scripts', file), path.join(installed, file));
-    }
-    return spawnSync(process.execPath, [path.join(installed, 'postinstall.mjs')], {
-      env: {...process.env, INIT_CWD: path.join(tmp, 'packages/app'), npm_command: 'install'},
-      encoding: 'utf8',
-    });
-  };
-  beforeEach(() => {
-    fs.mkdirSync(path.join(tmp, '.git'));
-    write('packages/app/package.json', '{"name":"app"}');
-  });
-
-  it('stays quiet when init ran at the repository root', () => {
-    write('AGENTS.md', MARKER);
-    const r = install();
-    expect(r.status).toBe(0);
-    expect(r.stdout).toBe('');
-  });
-
-  it('still nudges when no folder up to the repository root ran init', () => {
-    const r = install();
-    expect(r.status).toBe(0);
-    expect(r.stdout).toMatch(/finish setup and install the Astryx agent prompt/);
-  });
-});
-
-describe('core postinstall — shouldNudge', () => {
-  const DEP = '/proj/node_modules/@astryxdesign/core/scripts/postinstall.mjs';
-  const NPX = '/Users/x/.npm/_npx/a1/node_modules/@astryxdesign/core/scripts/postinstall.mjs';
-  const REPO = '/repo/packages/core/scripts/postinstall.mjs';
-
-  it('nudges for a real dependency install when not set up', () => {
-    expect(shouldNudge({scriptPath: DEP, npmCommand: 'install', isSetUp: false})).toBe(true);
-  });
-  it('quiet in the monorepo/source', () => {
-    expect(shouldNudge({scriptPath: REPO, npmCommand: 'install', isSetUp: false})).toBe(false);
-  });
-  it('quiet during npx transient install (_npx path)', () => {
-    expect(shouldNudge({scriptPath: NPX, npmCommand: 'install', isSetUp: false})).toBe(false);
-  });
-  it('quiet during npx (npm_command=exec)', () => {
-    expect(shouldNudge({scriptPath: DEP, npmCommand: 'exec', isSetUp: false})).toBe(false);
-  });
-  it('quiet once set up', () => {
-    expect(shouldNudge({scriptPath: DEP, npmCommand: 'install', isSetUp: true})).toBe(false);
-  });
-  it('quiet with no arguments at all', () => {
-    expect(shouldNudge({})).toBe(false);
-  });
-  it('is the same decision the CLI layer makes', () => {
-    for (const scriptPath of [DEP, NPX, REPO]) {
-      for (const npmCommand of ['install', 'exec']) {
-        for (const isSetUp of [true, false]) {
-          expect(shouldNudge({scriptPath, npmCommand, isSetUp})).toBe(
-            cliLeaf.shouldNudge({scriptPath, npmCommand, isSetUp}),
-          );
-        }
-      }
-    }
-  });
-});
-
-describe('core postinstall — the nudge names the command the CLI would print', () => {
-  it('words the nudge around the stem it is given', () => {
-    expect(setupNudge('pnpm exec astryx')).toContain(
-      'run `pnpm exec astryx init` to finish setup',
-    );
-    expect(SETUP_NUDGE).toContain('run `npx @astryxdesign/cli init`');
-  });
-
-  it("asks the project's installed CLI for its stem", async () => {
-    write('package.json', '{"name":"app"}');
-    write('pnpm-lock.yaml', '');
-    write('node_modules/.bin/astryx', '');
-    fs.mkdirSync(path.join(tmp, 'node_modules/@astryxdesign'), {
-      recursive: true,
-    });
-    fs.symlinkSync(
-      path.resolve(import.meta.dirname, '../../cli'),
-      path.join(tmp, 'node_modules/@astryxdesign/cli'),
-    );
-    expect(await cliInvocation(tmp)).toBe('pnpm exec astryx');
-  });
-
-  it('has no stem to offer when the CLI is not installed', async () => {
-    write('package.json', '{"name":"app"}');
-    expect(await cliInvocation(tmp)).toBeUndefined();
-  });
-});

package/src/reset.a11y.chromium.spec.ts

@@ -1,238 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-// @pr-a11y release-only
-
-/**
- * @file reset.a11y.chromium.spec.ts
- * @input packages/core/src/reset.css, alone on a blank Chromium page
- * @output Browser evidence that the reset reaches ::before, ::after,
- *   ::placeholder, the search field's cancel button and the dropdown marker
- *   of a field with a list
- * @position reset.css integration proof. A pseudo-element inside :where() is
- *   invalid, and the forgiving list drops it without an error, so only a
- *   shipping engine shows which of the reset's rules still match.
- */
-
-import * as fs from 'node:fs';
-import {fileURLToPath} from 'node:url';
-import {expect, test, type Page} from '@playwright/test';
-// @ts-expect-error -- pngjs ships no declarations; runtime support is pinned.
-import {PNG} from 'pngjs';
-
-const RESET_CSS = fs.readFileSync(
-  fileURLToPath(new URL('./reset.css', import.meta.url)),
-  'utf8',
-);
-
-// No Astryx CSS is loaded, so --color-text-secondary is undefined and a
-// placeholder takes the reset's fallback: the token's own light-dark() default.
-const PLACEHOLDER_FALLBACK = {
-  light: 'rgb(78, 96, 111)',
-  dark: 'rgb(170, 175, 181)',
-};
-
-/** Every style rule's selector, in source order, comments stripped. */
-function sourceSelectors(css: string): string[] {
-  const stripped = css.replace(/\/\*[\s\S]*?\*\//g, '');
-  return [...stripped.matchAll(/([^{}]+)\{[^{}]*\}/g)].map(([, selector]) =>
-    selector.trim(),
-  );
-}
-
-/** Whitespace and quote style are the only differences serialization adds. */
-function normalize(selector: string): string {
-  return selector.replace(/\s+/g, '').replace(/'/g, '"');
-}
-
-async function loadReset(page: Page) {
-  await page.setContent(`
-    <div id="probe"></div>
-    <input id="name" placeholder="Name">
-    <textarea id="notes" placeholder="Notes"></textarea>
-    <input id="query" type="search" value="query" style="width: 200px">
-  `);
-  await page.addStyleTag({content: RESET_CSS});
-  // Width 100 plus 10px padding a side: 100 wide under border-box, 120
-  // under content-box. The ::before border sets only its width.
-  await page.addStyleTag({
-    content: `
-      #probe { display: inline-block; }
-      #probe::before, #probe::after {
-        content: '';
-        display: block;
-        width: 100px;
-        height: 20px;
-        padding: 10px;
-      }
-      #probe::before { border-width: 5px; }
-    `,
-  });
-}
-
-test.beforeEach(async ({page}) => {
-  await loadReset(page);
-});
-
-test('Chromium keeps every selector the reset writes', async ({page}) => {
-  // A forgiving list drops an invalid entry instead of the whole rule, so a
-  // dropped pseudo-element shows up as a shorter serialized selector.
-  const parsed = await page.evaluate(() => {
-    // The sheet opens with the `@layer` order statement; the rules live in
-    // the `reset` layer block after it.
-    const layer = [...document.styleSheets[0].cssRules].find(
-      (rule): rule is CSSLayerBlockRule =>
-        rule instanceof CSSLayerBlockRule && rule.name === 'reset',
-    );
-    if (layer == null) {
-      throw new Error('reset.css has no @layer reset block');
-    }
-    return [...layer.cssRules].map(rule => (rule as CSSStyleRule).selectorText);
-  });
-  expect(parsed.map(normalize)).toEqual(
-    sourceSelectors(RESET_CSS).map(normalize),
-  );
-});
-
-test('::before and ::after are border-box and take the border reset', async ({
-  page,
-}) => {
-  const measured = await page.evaluate(() => {
-    const probe = document.getElementById('probe');
-    if (!probe) {
-      throw new Error('missing probe');
-    }
-    const before = getComputedStyle(probe, '::before');
-    const after = getComputedStyle(probe, '::after');
-    return {
-      beforeBoxSizing: before.boxSizing,
-      afterBoxSizing: after.boxSizing,
-      beforeBorderStyle: before.borderTopStyle,
-      beforeBorderWidth: before.borderTopWidth,
-      afterBorderWidth: after.borderTopWidth,
-      width: probe.getBoundingClientRect().width,
-    };
-  });
-  expect(measured).toEqual({
-    beforeBoxSizing: 'border-box',
-    afterBoxSizing: 'border-box',
-    beforeBorderStyle: 'solid',
-    beforeBorderWidth: '5px',
-    afterBorderWidth: '0px',
-    width: 100,
-  });
-});
-
-test('input and textarea placeholders take the reset color in both schemes', async ({
-  page,
-}) => {
-  const readPlaceholders = async () =>
-    page.evaluate(() =>
-      ['name', 'notes'].map(id => {
-        const field = document.getElementById(id);
-        if (!field) {
-          throw new Error(`missing #${id}`);
-        }
-        const placeholder = getComputedStyle(field, '::placeholder');
-        return {color: placeholder.color, opacity: placeholder.opacity};
-      }),
-    );
-  for (const scheme of ['light', 'dark'] as const) {
-    await page.emulateMedia({colorScheme: scheme});
-    const color = PLACEHOLDER_FALLBACK[scheme];
-    expect(await readPlaceholders(), scheme).toEqual([
-      {color, opacity: '1'},
-      {color, opacity: '1'},
-    ]);
-  }
-});
-
-test('a search field has no cancel button to clear it', async ({page}) => {
-  // Chromium draws the cancel button at the inline end of a focused search
-  // field that has a value, and a click on it empties the field.
-  const query = page.locator('#query');
-  await query.focus();
-  const box = await query.boundingBox();
-  if (!box) {
-    throw new Error('missing search field box');
-  }
-  await page.mouse.click(box.x + box.width - 8, box.y + box.height / 2);
-  await expect(query).toHaveValue('query');
-});
-
-test('the dropdown marker of a field with a list sits in its middle', async ({
-  page,
-}) => {
-  // Chromium shows the marker while the pointer is over the field and draws
-  // it as a glyph set on the field's line-height, the 1.5 the reset inherits.
-  await page.evaluate(() => {
-    const field = document.createElement('input');
-    field.id = 'fruit';
-    field.setAttribute('list', 'fruits');
-    const options = document.createElement('datalist');
-    options.id = 'fruits';
-    options.append(new Option('Apple'));
-    document.body.append(field, options);
-  });
-  await page.addStyleTag({
-    content: `
-      #fruit {
-        display: block;
-        width: 240px;
-        padding: 7px 11px;
-        border: 1px solid;
-        line-height: 1.5;
-      }
-    `,
-  });
-  const field = page.locator('#fruit');
-  await field.hover();
-  const png = PNG.sync.read(await field.screenshot({caret: 'hide'}));
-  // The marker is the only ink in the field's last 32px, inside the border.
-  const inkRows: number[] = [];
-  for (let y = 2; y < png.height - 2; y++) {
-    for (let x = png.width - 32; x < png.width - 2; x++) {
-      const offset = (y * png.width + x) * 4;
-      const luminance =
-        (png.data[offset] + png.data[offset + 1] + png.data[offset + 2]) / 3;
-      if (luminance < 160) {
-        inkRows.push(y);
-        break;
-      }
-    }
-  }
-  expect(inkRows.length, 'the hovered field shows its marker').toBeGreaterThan(
-    0,
-  );
-  const markerMiddle = (inkRows[0] + inkRows[inkRows.length - 1] + 1) / 2;
-  expect(Math.abs(markerMiddle - png.height / 2)).toBeLessThanOrEqual(1);
-});
-
-test('a later layer and an unlayered rule still override the reset', async ({
-  page,
-}) => {
-  // Same 0,0,1 specificity as the reset's own selectors, so only the cascade
-  // layer decides.
-  await page.addStyleTag({
-    content: `
-      @layer reset, astryx-base;
-      @layer astryx-base {
-        :where(textarea)::placeholder { color: rgb(0, 128, 0); }
-      }
-      :where(#probe)::after { box-sizing: content-box; }
-    `,
-  });
-  const overridden = await page.evaluate(() => {
-    const probe = document.getElementById('probe');
-    const notes = document.getElementById('notes');
-    if (!probe || !notes) {
-      throw new Error('missing probe or textarea');
-    }
-    return {
-      placeholderColor: getComputedStyle(notes, '::placeholder').color,
-      afterBoxSizing: getComputedStyle(probe, '::after').boxSizing,
-    };
-  });
-  expect(overridden).toEqual({
-    placeholderColor: 'rgb(0, 128, 0)',
-    afterBoxSizing: 'content-box',
-  });
-});

package/src/reset.test.ts

@@ -1,205 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * Tests for reset.css invariants that components rely on.
- *
- * reset.css is a plain stylesheet, so these tests assert on its source
- * text (same approach as the reset.css baseline checks in
- * theme/onMediaTokens.test.ts and AspectRatio/AspectRatio.test.tsx).
- */
-
-import fs from 'fs';
-import path from 'path';
-
-import {beforeAll, describe, expect, it} from 'vitest';
-
-describe('reset.css accessibility invariants', () => {
-  let ruleBlocks: {selector: string; body: string}[];
-
-  beforeAll(() => {
-    const resetCSS = fs.readFileSync(
-      path.resolve(__dirname, './reset.css'),
-      'utf-8',
-    );
-    // Strip comments, then collect every innermost `selector { body }`
-    // block. `[^{}]` keeps at-rule preludes (@media, @layer) out of the
-    // selector capture, since their own `{` terminates any earlier match.
-    const stripped = resetCSS.replace(/\/\*[\s\S]*?\*\//g, '');
-    ruleBlocks = [...stripped.matchAll(/([^{}]+)\{([^{}]*)\}/g)].map(
-      ([, selector, body]) => ({selector: selector.trim(), body}),
-    );
-  });
-
-  it('parses rule blocks out of reset.css', () => {
-    // Guards the WCAG assertion below against silently passing if the
-    // block parsing ever breaks.
-    expect(ruleBlocks.length).toBeGreaterThan(20);
-    expect(
-      ruleBlocks.some(({body}) => body.includes('box-sizing: border-box')),
-    ).toBe(true);
-  });
-
-  /**
-   * WCAG 2.4.7 (Focus Visible, Level AA): keyboard focus indicators must
-   * not be suppressed. `:focus-visible` only matches keyboard-style focus,
-   * so any `outline: none` on it removes the focus indicator for keyboard
-   * users — and a `@media (hover: none) and (pointer: coarse)` guard does
-   * not exempt keyboard users on coarse-pointer devices (iPad/phone with a
-   * Bluetooth keyboard, switch-control users).
-   */
-  it('does not suppress :focus-visible outlines (WCAG 2.4.7)', () => {
-    const focusVisibleBlocks = ruleBlocks.filter(({selector}) =>
-      selector.includes(':focus-visible'),
-    );
-    for (const {selector, body} of focusVisibleBlocks) {
-      expect
-        .soft(body, `":focus-visible" rule "${selector}" must keep the outline`)
-        .not.toMatch(/outline(?:-style|-width)?\s*:\s*(?:none|0)/);
-    }
-  });
-
-  /**
-   * A disabled control must not answer the pointer with an interactive
-   * cursor. The reset is the floor for any element that declares no cursor of
-   * its own — components declare theirs under the `disabled-cursor` lint
-   * rule, and the Chromium sweep measures the rendered result.
-   */
-  it('gives disabled elements the disabled cursor', () => {
-    const disabledBlocks = ruleBlocks.filter(
-      ({selector}) =>
-        selector.includes(':disabled') && !selector.includes(':not('),
-    );
-    expect(disabledBlocks.length).toBeGreaterThan(0);
-    for (const {selector, body} of disabledBlocks) {
-      expect(body, `disabled rule "${selector}"`).toMatch(/cursor:\s*default/);
-    }
-    // aria-disabled is how astryx keeps a disabled control focusable, so the
-    // reset has to cover it alongside the native state.
-    expect(
-      disabledBlocks.some(({selector}) => selector.includes('aria-disabled')),
-    ).toBe(true);
-  });
-});
-
-/** The argument of every `:where()` and `:is()`, nested ones included. */
-function forgivingListArguments(selector: string): string[] {
-  return [...selector.matchAll(/:(?:where|is)\(/g)].map(match => {
-    const start = match.index + match[0].length;
-    let depth = 1;
-    let end = start;
-    for (; end < selector.length && depth > 0; end++) {
-      if (selector[end] === '(') {
-        depth++;
-      } else if (selector[end] === ')') {
-        depth--;
-      }
-    }
-    return selector.slice(start, end - 1);
-  });
-}
-
-/** A selector list split on its top-level commas. */
-function topLevelSelectors(list: string): string[] {
-  const selectors: string[] = [];
-  let depth = 0;
-  let start = 0;
-  for (let index = 0; index < list.length; index++) {
-    if (list[index] === '(') {
-      depth++;
-    } else if (list[index] === ')') {
-      depth--;
-    } else if (list[index] === ',' && depth === 0) {
-      selectors.push(list.slice(start, index).trim());
-      start = index + 1;
-    }
-  }
-  selectors.push(list.slice(start).trim());
-  return selectors;
-}
-
-/**
- * A pseudo-element is not valid inside :where() or :is() (Selectors Level 4).
- * Both take a forgiving selector list, so the browser drops that entry rather
- * than the rule, and the declarations silently stop reaching the
- * pseudo-element. It goes after the :where(), as in `:where(*)::before`.
- * reset.a11y.chromium.spec.ts measures the result in Chromium.
- */
-describe('reset.css pseudo-element rules', () => {
-  let ruleBlocks: {selector: string; body: string}[];
-
-  beforeAll(() => {
-    const stripped = fs
-      .readFileSync(path.resolve(__dirname, './reset.css'), 'utf-8')
-      .replace(/\/\*[\s\S]*?\*\//g, '');
-    ruleBlocks = [...stripped.matchAll(/([^{}]+)\{([^{}]*)\}/g)].map(
-      ([, selector, body]) => ({selector: selector.trim(), body}),
-    );
-  });
-
-  it('keeps every pseudo-element outside :where() and :is()', () => {
-    for (const {selector} of ruleBlocks) {
-      for (const argument of forgivingListArguments(selector)) {
-        expect
-          .soft(argument, `"${selector}" puts a pseudo-element in a list`)
-          .not.toMatch(/::|:(?:before|after|first-line|first-letter)\b/);
-      }
-    }
-  });
-
-  it('targets ::before, ::after, ::placeholder and the search field parts', () => {
-    const selectorsFor = (declaration: string) =>
-      ruleBlocks
-        .filter(({body}) => body.includes(declaration))
-        .flatMap(({selector}) => topLevelSelectors(selector));
-    const endsWith = (declaration: string, pseudoElement: string) =>
-      selectorsFor(declaration).some(selector =>
-        selector.endsWith(pseudoElement),
-      );
-
-    for (const declaration of [
-      'box-sizing: border-box',
-      'border-style: solid',
-    ]) {
-      expect(endsWith(declaration, '::before'), declaration).toBe(true);
-      expect(endsWith(declaration, '::after'), declaration).toBe(true);
-    }
-    expect(endsWith('opacity: 1', '::placeholder')).toBe(true);
-    expect(
-      endsWith('-webkit-appearance: none', '::-webkit-search-decoration'),
-    ).toBe(true);
-    expect(
-      endsWith('-webkit-appearance: none', '::-webkit-search-cancel-button'),
-    ).toBe(true);
-  });
-
-  it('sets the dropdown marker of a field with a list on a single line', () => {
-    const marker = ruleBlocks.filter(({selector}) =>
-      topLevelSelectors(selector).some(entry =>
-        entry.endsWith('::-webkit-calendar-picker-indicator'),
-      ),
-    );
-    expect(marker.map(({body}) => body).join('\n')).toMatch(
-      /line-height:\s*1;/,
-    );
-  });
-
-  it('falls back to the --color-text-secondary default for placeholders', () => {
-    // A page that loads only the reset never defines the token. The fallback
-    // repeats the token's own default, so that page shows the placeholder an
-    // Astryx page does, at the contrast the token was chosen for.
-    const tokens = fs.readFileSync(
-      path.resolve(__dirname, './theme/tokens.stylex.ts'),
-      'utf-8',
-    );
-    const tokenDefault = tokens.match(
-      /'--color-text-secondary':\s*'([^']+)'/,
-    )?.[1];
-    expect(tokenDefault).toMatch(/^light-dark\(/);
-    const placeholder = ruleBlocks.find(({selector}) =>
-      selector.endsWith('::placeholder'),
-    );
-    expect(placeholder?.body).toContain(
-      `color: var(--color-text-secondary, ${tokenDefault});`,
-    );
-  });
-});