@adia-ai/web-components 0.8.18 → 0.8.20

package/components/text/text.test.js

@@ -1,202 +0,0 @@
-/**
- * text-ui variant rendering tests — §210 (v0.5.7, FEEDBACK-17 §1).
- *
- * Verifies the 12 documented enum values in `text.yaml`/`text.d.ts`/
- * `text.a2ui.json` all render distinctly per the `:scope[variant=…]`
- * rules in `text.css`. Pre-§210 the three token-backed variants
- * `subsection` / `deck` / `metric` silently rendered as `body`
- * defaults because the matching `:scope` rules were missing — the
- * yaml + d.ts advertised them but the CSS didn't consume the tokens.
- *
- * Plus a guard: the 6 phantom enum entries removed in §210
- * (`subheading`, `h1`-`h6`) must NOT be in the .d.ts type union or
- * the a2ui.json enum — they had no shipped tokens and rendering them
- * was always body-defaults.
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, resolve } from 'node:path';
-import '../../core/element.js';
-import './text.js';
-
-const tick = () => new Promise((r) => queueMicrotask(r));
-
-function mount(html) {
-  const wrap = document.createElement('div');
-  wrap.innerHTML = html;
-  document.body.appendChild(wrap);
-  return wrap.firstElementChild;
-}
-
-// jsdom doesn't evaluate @scope rules in `getComputedStyle()`. We
-// validate the CSS by reading the rule out of text.css text and
-// asserting the variant-specific properties are present — coarse
-// but catches the §210 regression class (rule missing entirely).
-const HERE = dirname(fileURLToPath(import.meta.url));
-const TEXT_CSS = readFileSync(resolve(HERE, 'text.css'), 'utf8');
-const TEXT_DTS = readFileSync(resolve(HERE, 'text.d.ts'), 'utf8');
-const TEXT_A2UI = JSON.parse(readFileSync(resolve(HERE, 'text.a2ui.json'), 'utf8'));
-
-describe('text-ui §210 — variant enum vs CSS rule completeness', () => {
-  beforeEach(() => { document.body.innerHTML = ''; });
-
-  // ── Mounting smoke — every documented variant constructs without crash ──
-  const documentedVariants = [
-    'body', 'heading', 'title', 'subsection', 'display', 'caption',
-    'label', 'kicker', 'deck', 'section', 'metric', 'code',
-  ];
-
-  it.each(documentedVariants)('mounts <text-ui variant="%s"> without error', async (variant) => {
-    const t = mount(`<text-ui variant="${variant}">Sample</text-ui>`);
-    await tick();
-    expect(t).toBeDefined();
-    expect(t.getAttribute('variant')).toBe(variant);
-  });
-
-  // ── CSS-side: every documented variant has a :scope rule ──
-  it.each(documentedVariants)('text.css ships a :scope[variant="%s"] rule', (variant) => {
-    expect(TEXT_CSS).toMatch(new RegExp(`:scope\\[variant="${variant}"\\]`));
-  });
-
-  // ── Three token-backed variants restored in §210 ──
-  it.each(['subsection', 'deck', 'metric'])(
-    'text.css :scope[variant="%s"] consumes role tokens (not body defaults)',
-    (variant) => {
-      // The rule must reference the role-specific token, not fall through
-      // to var(--a-body-*) defaults.
-      const ruleMatch = TEXT_CSS.match(
-        new RegExp(`:scope\\[variant="${variant}"\\]\\s*\\{([^}]+)\\}`)
-      );
-      expect(ruleMatch, `rule missing for variant="${variant}"`).toBeTruthy();
-      const rule = ruleMatch[1];
-      expect(rule).toMatch(new RegExp(`var\\(--a-${variant}-family\\)`));
-      expect(rule).toMatch(new RegExp(`var\\(--a-${variant}-weight\\)`));
-      expect(rule).toMatch(new RegExp(`var\\(--a-${variant}-size\\)`));
-    }
-  );
-
-  // ── Type-side: 6 phantom entries removed in §210 ──
-  const removedPhantoms = ['subheading', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6'];
-
-  it.each(removedPhantoms)('text.d.ts variant union does NOT contain phantom "%s"', (variant) => {
-    expect(TEXT_DTS).not.toMatch(new RegExp(`'${variant}'`));
-  });
-
-  it.each(removedPhantoms)('text.a2ui.json variant enum does NOT contain phantom "%s"', (variant) => {
-    expect(TEXT_A2UI.properties.variant.enum).not.toContain(variant);
-  });
-
-  // ── a2ui.json enum and .d.ts union and CSS rules are mutually consistent ──
-  it('a2ui.json variant enum matches .d.ts union and CSS rules 1:1', () => {
-    const a2uiVariants = TEXT_A2UI.properties.variant.enum;
-    // §247b (v0.5.10): text.d.ts was hand-authored to use a named type alias
-    // `UITextVariant` instead of an inline union (per-variant JSDoc + ARIA-role
-    // disclaimer). Match either the type-alias body OR an inline union; both
-    // forms expose the same set of string-literal members.
-    const dtsAliasMatch = TEXT_DTS.match(/export\s+type\s+UITextVariant\s*=\s*((?:[\s\S]*?))(?:;|\n\n)/);
-    const dtsUnionMatch = TEXT_DTS.match(/variant:\s*((?:'[^']+'\s*\|?\s*)+);/);
-    const variantsSource = dtsAliasMatch?.[1] ?? dtsUnionMatch?.[1];
-    expect(variantsSource).toBeTruthy();
-    const dtsVariants = [...variantsSource.matchAll(/'([^']+)'/g)].map(m => m[1]);
-
-    expect(a2uiVariants.sort()).toEqual(dtsVariants.sort());
-    expect(a2uiVariants.sort()).toEqual([...documentedVariants].sort());
-
-    // Every variant has a CSS rule.
-    for (const v of a2uiVariants) {
-      expect(TEXT_CSS).toMatch(new RegExp(`:scope\\[variant="${v}"\\]`));
-    }
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────
-// v0.6.18 (FB-10) — overlay attributes on top of `variant`
-// ─────────────────────────────────────────────────────────────────────
-
-describe('text-ui v0.6.18 — overlay props (FB-10)', () => {
-  beforeEach(() => { document.body.innerHTML = ''; });
-
-  // ── Attribute reflection: each new prop reflects to the host ──
-  it.each([
-    ['size', 'sm'],
-    ['size', 'md'],
-    ['size', 'lg'],
-    ['color', 'subtle'],
-    ['color', 'strong'],
-    ['color', 'accent'],
-    ['color', 'danger'],
-    ['color', 'success'],
-    ['color', 'warning'],
-    ['color', 'default'],
-    ['weight', 'regular'],
-    ['weight', 'medium'],
-    ['weight', 'semibold'],
-    ['weight', 'bold'],
-    ['text-align', 'start'],
-    ['text-align', 'center'],
-    ['text-align', 'end'],
-    ['text-align', 'justify'],
-  ])('<text-ui %s="%s"> reflects the attribute', async (prop, value) => {
-    const el = mount(`<text-ui ${prop}="${value}">x</text-ui>`);
-    await tick();
-    expect(el.getAttribute(prop)).toBe(value);
-  });
-
-  // ── CSS-side: every documented value has a :scope[attr="value"] rule ──
-  const sizes = ['sm', 'md', 'lg'];
-  const colors = ['default', 'subtle', 'strong', 'accent', 'danger', 'success', 'warning'];
-  const weights = ['regular', 'medium', 'semibold', 'bold'];
-  const aligns = ['start', 'center', 'end', 'justify'];
-
-  it.each(sizes)('text.css ships :scope[size="%s"] rule', (s) => {
-    expect(TEXT_CSS).toMatch(new RegExp(`:scope\\[size="${s}"\\]`));
-  });
-
-  it.each(colors)('text.css ships :scope[color="%s"] rule', (c) => {
-    expect(TEXT_CSS).toMatch(new RegExp(`:scope\\[color="${c}"\\]`));
-  });
-
-  it.each(weights)('text.css ships :scope[weight="%s"] rule', (w) => {
-    expect(TEXT_CSS).toMatch(new RegExp(`:scope\\[weight="${w}"\\]`));
-  });
-
-  it.each(aligns)('text.css ships :scope[text-align="%s"] rule', (a) => {
-    expect(TEXT_CSS).toMatch(new RegExp(`:scope\\[text-align="${a}"\\]`));
-  });
-
-  // ── yaml-vs-impl consistency: every prop in the a2ui enum has a CSS rule ──
-  it('a2ui.json color enum matches CSS rules 1:1', () => {
-    const colorEnum = TEXT_A2UI.properties.color?.enum ?? [];
-    expect(colorEnum.sort()).toEqual([...colors].sort());
-    for (const c of colorEnum) {
-      expect(TEXT_CSS).toMatch(new RegExp(`:scope\\[color="${c}"\\]`));
-    }
-  });
-
-  it('a2ui.json size enum matches CSS rules 1:1', () => {
-    const sizeEnum = TEXT_A2UI.properties.size?.enum ?? [];
-    expect(sizeEnum.sort()).toEqual([...sizes].sort());
-    for (const s of sizeEnum) {
-      expect(TEXT_CSS).toMatch(new RegExp(`:scope\\[size="${s}"\\]`));
-    }
-  });
-
-  it('a2ui.json weight enum matches CSS rules 1:1', () => {
-    const weightEnum = TEXT_A2UI.properties.weight?.enum ?? [];
-    expect(weightEnum.sort()).toEqual([...weights].sort());
-    for (const w of weightEnum) {
-      expect(TEXT_CSS).toMatch(new RegExp(`:scope\\[weight="${w}"\\]`));
-    }
-  });
-
-  // ── Permissive fallback: unknown values are no-ops (no JS error) ──
-  it('unknown color value renders without throwing', async () => {
-    const el = mount('<text-ui color="banana">x</text-ui>');
-    await tick();
-    expect(el.getAttribute('color')).toBe('banana');
-    // The variant default wins; no CSS rule matches "banana". Test the
-    // shape: no thrown error during mount, no console.error.
-  });
-});

package/components/theme-provider/theme-provider.test.js

@@ -1,94 +0,0 @@
-/**
- * <theme-provider> tests
- *
- * The provider adopts the AdiaUI foundation (a constructable stylesheet) into
- * `document.adoptedStyleSheets` — once, deduped — and renders `display: contents`
- * + `role=presentation`. The real foundation sheet (`web-components.sheet.js`,
- * ~512 KB of LightningCSS output) is mocked here with a 1-rule stub so the test
- * exercises the ELEMENT's contract (adopt-once, dedup, transparency), not the
- * bundle's CSS. Byte-parity of the real sheet is covered by `check:css-bundles-fresh`.
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-
-// Stub the heavy foundation sheet — same default-export shape as the generated
-// module: a constructSheet() returning a memoized CSSStyleSheet singleton.
-vi.mock('../../dist/web-components.sheet.js', () => {
-  let sheet = null;
-  return {
-    default: () => {
-      if (typeof CSSStyleSheet === 'undefined') return null;
-      if (!sheet) { sheet = new CSSStyleSheet(); sheet.replaceSync('theme-provider{display:contents}'); }
-      return sheet;
-    },
-  };
-});
-
-// Stub the opt-in twins — the element dynamic-imports these when theme=/scale= is
-// set. We test the attribute contract (sync), not the adopted CSS. (Factories are
-// inlined because vi.mock hoists above any shared `const`.)
-vi.mock('../../dist/themes.sheet.js', () => ({ default: () => { const s = new CSSStyleSheet(); s.replaceSync(':root{}'); return s; } }));
-vi.mock('../../dist/verse.sheet.js', () => ({ default: () => { const s = new CSSStyleSheet(); s.replaceSync(':root{}'); return s; } }));
-vi.mock('../../dist/prose.sheet.js', () => ({ default: () => { const s = new CSSStyleSheet(); s.replaceSync(':root{}'); return s; } }));
-
-import '../../core/element.js';
-import './theme-provider.js'; // registers the tag + adopts the (mocked) foundation at module-eval
-
-const tick = () => new Promise((r) => queueMicrotask(r));
-
-function mount(html) {
-  const wrap = document.createElement('div');
-  wrap.innerHTML = html;
-  document.body.appendChild(wrap);
-  return wrap.firstElementChild;
-}
-
-describe('<theme-provider>', () => {
-  beforeEach(() => { document.body.innerHTML = ''; });
-
-  it('adopts the foundation sheet at import (module-eval side effect)', () => {
-    expect(document.adoptedStyleSheets.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('is display:contents + role=presentation on connect', async () => {
-    const el = mount('<theme-provider><span>hi</span></theme-provider>');
-    await tick();
-    expect(el.style.display).toBe('contents');
-    expect(el.getAttribute('role')).toBe('presentation');
-  });
-
-  it('does not clobber an author-set role', async () => {
-    const el = mount('<theme-provider role="group"><span>hi</span></theme-provider>');
-    await tick();
-    expect(el.getAttribute('role')).toBe('group');
-  });
-
-  it('dedupes — N instances adopt the foundation exactly once', async () => {
-    const before = document.adoptedStyleSheets.length; // singleton already adopted at import
-    mount('<theme-provider></theme-provider>');
-    mount('<theme-provider></theme-provider>');
-    mount('<theme-provider></theme-provider>');
-    await tick();
-    expect(document.adoptedStyleSheets.length).toBe(before);
-  });
-
-  it('reflects theme= to the [theme] attribute hook', async () => {
-    const el = mount('<theme-provider theme="ocean"><span>x</span></theme-provider>');
-    await tick();
-    expect(el.getAttribute('theme')).toBe('ocean');
-  });
-
-  it('scale="verse" maps to the [verse] register attribute', async () => {
-    const el = mount('<theme-provider scale="verse"><span>x</span></theme-provider>');
-    await tick();
-    expect(el.hasAttribute('verse')).toBe(true);
-    expect(el.hasAttribute('prose')).toBe(false);
-  });
-
-  it('scale="prose" maps to the [prose] register attribute', async () => {
-    const el = mount('<theme-provider scale="prose"><span>x</span></theme-provider>');
-    await tick();
-    expect(el.hasAttribute('prose')).toBe(true);
-    expect(el.hasAttribute('verse')).toBe(false);
-  });
-});

package/components/time-picker/time-picker.test.js

@@ -1,287 +0,0 @@
-/**
- * time-picker-ui — SPEC-043
- *
- * Coverage:
- *   - Stamp shape (precision × hour-cycle)
- *   - Segment text sync from value
- *   - Arrow Up / Down increments
- *   - Page Up / Down + Home / End
- *   - Tab equivalents (ArrowLeft / ArrowRight)
- *   - Digit typing + auto-advance
- *   - Form participation (name + ISO value)
- *   - min / max → invalid event
- *   - disabled / readonly behavior
- *   - precision toggle re-stamps without losing hh/mm
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import '../../core/element.js';
-import './time-picker.js';
-
-const tick = () => new Promise((r) => queueMicrotask(r));
-
-function mount(html) {
-  const wrap = document.createElement('div');
-  wrap.innerHTML = html;
-  document.body.appendChild(wrap);
-  return wrap.firstElementChild;
-}
-
-function segText(el, key) {
-  return el.querySelector(`[data-segment="${key}"]`)?.textContent || '';
-}
-
-function fireKey(el, key) {
-  el.dispatchEvent(new KeyboardEvent('keydown', { key, bubbles: true }));
-}
-
-describe('time-picker-ui', () => {
-  beforeEach(() => { document.body.innerHTML = ''; });
-
-  it('renders with empty segments when no value is set', async () => {
-    const el = mount('<time-picker-ui></time-picker-ui>');
-    await tick();
-    expect(el.querySelector('[data-segment="hour"]')).not.toBeNull();
-    expect(el.querySelector('[data-segment="minute"]')).not.toBeNull();
-    expect(segText(el, 'hour')).toBe('');
-    expect(segText(el, 'minute')).toBe('');
-  });
-
-  it('populates hour/minute segments from value="09:30"', async () => {
-    const el = mount('<time-picker-ui value="09:30"></time-picker-ui>');
-    await tick();
-    expect(segText(el, 'hour')).toBe('09');
-    expect(segText(el, 'minute')).toBe('30');
-  });
-
-  it('precision="second" stamps a seconds segment + separator', async () => {
-    const el = mount('<time-picker-ui precision="second" value="14:30:45"></time-picker-ui>');
-    await tick();
-    expect(el.querySelector('[data-segment="second"]')).not.toBeNull();
-    expect(segText(el, 'second')).toBe('45');
-  });
-
-  it('hour-cycle="h12" stamps a meridiem segment + 12h display', async () => {
-    const el = mount('<time-picker-ui hour-cycle="h12" value="14:30"></time-picker-ui>');
-    await tick();
-    const meridiem = el.querySelector('[data-segment="meridiem"]');
-    expect(meridiem).not.toBeNull();
-    expect(segText(el, 'hour')).toBe('02');
-    expect(segText(el, 'meridiem')).toBe('PM');
-  });
-
-  it('hour-cycle="h12" displays midnight as 12 AM', async () => {
-    const el = mount('<time-picker-ui hour-cycle="h12" value="00:15"></time-picker-ui>');
-    await tick();
-    expect(segText(el, 'hour')).toBe('12');
-    expect(segText(el, 'meridiem')).toBe('AM');
-  });
-
-  it('Arrow Up on hour segment increments by 1', async () => {
-    const el = mount('<time-picker-ui value="09:30"></time-picker-ui>');
-    await tick();
-    const hour = el.querySelector('[data-segment="hour"]');
-    hour.focus();
-    fireKey(hour, 'ArrowUp');
-    await tick();
-    expect(el.value).toBe('10:30');
-  });
-
-  it('Arrow Down on minute segment decrements by step/60 minutes', async () => {
-    const el = mount('<time-picker-ui value="09:30" step="60"></time-picker-ui>');
-    await tick();
-    const min = el.querySelector('[data-segment="minute"]');
-    min.focus();
-    fireKey(min, 'ArrowDown');
-    await tick();
-    expect(el.value).toBe('09:29');
-  });
-
-  it('step="900" increments minute by 15 on Arrow Up', async () => {
-    const el = mount('<time-picker-ui value="09:30" step="900"></time-picker-ui>');
-    await tick();
-    const min = el.querySelector('[data-segment="minute"]');
-    min.focus();
-    fireKey(min, 'ArrowUp');
-    await tick();
-    expect(el.value).toBe('09:45');
-  });
-
-  it('Page Up increments by 10× the small step', async () => {
-    const el = mount('<time-picker-ui value="09:00"></time-picker-ui>');
-    await tick();
-    const min = el.querySelector('[data-segment="minute"]');
-    min.focus();
-    fireKey(min, 'PageUp');
-    await tick();
-    expect(el.value).toBe('09:10');
-  });
-
-  it('Home jumps to segment min; End jumps to segment max', async () => {
-    const el = mount('<time-picker-ui value="09:30"></time-picker-ui>');
-    await tick();
-    const hour = el.querySelector('[data-segment="hour"]');
-    hour.focus();
-    fireKey(hour, 'Home');
-    await tick();
-    expect(el.value).toBe('00:30');
-    fireKey(hour, 'End');
-    await tick();
-    expect(el.value).toBe('23:30');
-  });
-
-  it('ArrowRight moves focus to next segment; ArrowLeft to previous', async () => {
-    const el = mount('<time-picker-ui value="09:30"></time-picker-ui>');
-    await tick();
-    const hour = el.querySelector('[data-segment="hour"]');
-    const minute = el.querySelector('[data-segment="minute"]');
-    hour.focus();
-    fireKey(hour, 'ArrowRight');
-    await tick();
-    expect(document.activeElement).toBe(minute);
-    fireKey(minute, 'ArrowLeft');
-    await tick();
-    expect(document.activeElement).toBe(hour);
-  });
-
-  it('disabled prop blocks Arrow-key step', async () => {
-    const el = mount('<time-picker-ui value="09:30" disabled></time-picker-ui>');
-    await tick();
-    const hour = el.querySelector('[data-segment="hour"]');
-    fireKey(hour, 'ArrowUp');
-    await tick();
-    expect(el.value).toBe('09:30');
-  });
-
-  it('readonly prop blocks edits but keeps segments focusable', async () => {
-    const el = mount('<time-picker-ui value="09:30" readonly></time-picker-ui>');
-    await tick();
-    const hour = el.querySelector('[data-segment="hour"]');
-    expect(hour.getAttribute('tabindex')).toBe('0');
-    expect(hour.contentEditable).toBe('false');
-    hour.focus();
-    fireKey(hour, 'ArrowUp');
-    await tick();
-    expect(el.value).toBe('09:30');
-  });
-
-  it('min violation fires invalid + does not mutate value', async () => {
-    const el = mount('<time-picker-ui value="08:00" min="08:00" max="18:00"></time-picker-ui>');
-    await tick();
-    let captured = null;
-    el.addEventListener('invalid', (e) => { captured = e; });
-    const hour = el.querySelector('[data-segment="hour"]');
-    hour.focus();
-    fireKey(hour, 'ArrowDown');
-    await tick();
-    expect(captured).not.toBeNull();
-    expect(captured.detail.reason).toBe('min');
-    expect(el.value).toBe('08:00');
-  });
-
-  it('max violation fires invalid', async () => {
-    const el = mount('<time-picker-ui value="18:00" min="08:00" max="18:00"></time-picker-ui>');
-    await tick();
-    let captured = null;
-    el.addEventListener('invalid', (e) => { captured = e; });
-    const hour = el.querySelector('[data-segment="hour"]');
-    hour.focus();
-    fireKey(hour, 'ArrowUp');
-    await tick();
-    expect(captured).not.toBeNull();
-    expect(captured.detail.reason).toBe('max');
-    expect(el.value).toBe('18:00');
-  });
-
-  it('emits change with detail.segment on Arrow step', async () => {
-    const el = mount('<time-picker-ui value="09:30"></time-picker-ui>');
-    await tick();
-    let captured = null;
-    el.addEventListener('change', (e) => { captured = e; });
-    const hour = el.querySelector('[data-segment="hour"]');
-    hour.focus();
-    fireKey(hour, 'ArrowUp');
-    await tick();
-    expect(captured).not.toBeNull();
-    expect(captured.detail).toEqual({ value: '10:30', segment: 'hour' });
-  });
-
-  it('precision="minute" → "second" re-stamps without losing hh/mm', async () => {
-    const el = mount('<time-picker-ui value="09:30"></time-picker-ui>');
-    await tick();
-    expect(el.querySelector('[data-segment="second"]')).toBeNull();
-    el.precision = 'second';
-    await tick();
-    expect(el.querySelector('[data-segment="second"]')).not.toBeNull();
-    expect(segText(el, 'hour')).toBe('09');
-    expect(segText(el, 'minute')).toBe('30');
-  });
-
-  it('aria-valuemax matches segment max (h23 → 23 for hour)', async () => {
-    const el = mount('<time-picker-ui hour-cycle="h23"></time-picker-ui>');
-    await tick();
-    const hour = el.querySelector('[data-segment="hour"]');
-    expect(hour.getAttribute('aria-valuemax')).toBe('23');
-  });
-
-  it('aria-valuemax for hour is 12 in h12 cycle', async () => {
-    const el = mount('<time-picker-ui hour-cycle="h12"></time-picker-ui>');
-    await tick();
-    const hour = el.querySelector('[data-segment="hour"]');
-    expect(hour.getAttribute('aria-valuemax')).toBe('12');
-  });
-
-  it('aria-valuenow + aria-valuetext are populated from value', async () => {
-    const el = mount('<time-picker-ui value="09:30"></time-picker-ui>');
-    await tick();
-    const hour = el.querySelector('[data-segment="hour"]');
-    const minute = el.querySelector('[data-segment="minute"]');
-    expect(hour.getAttribute('aria-valuenow')).toBe('9');
-    expect(minute.getAttribute('aria-valuenow')).toBe('30');
-    expect(hour.getAttribute('aria-valuetext')).toContain('hour');
-    expect(minute.getAttribute('aria-valuetext')).toContain('minute');
-  });
-
-  it('host role="group" + aria-label default', async () => {
-    const el = mount('<time-picker-ui></time-picker-ui>');
-    await tick();
-    expect(el.getAttribute('role')).toBe('group');
-    expect(el.hasAttribute('aria-label')).toBe(true);
-  });
-
-  it('clear() resets value to empty', async () => {
-    const el = mount('<time-picker-ui value="09:30"></time-picker-ui>');
-    await tick();
-    el.clear();
-    await tick();
-    expect(el.value).toBe('');
-    expect(segText(el, 'hour')).toBe('');
-  });
-
-  it('stepUp() increments programmatically', async () => {
-    const el = mount('<time-picker-ui value="09:30"></time-picker-ui>');
-    await tick();
-    el.stepUp('hour');
-    await tick();
-    expect(el.value).toBe('10:30');
-  });
-
-  it('value setter syncs segments', async () => {
-    const el = mount('<time-picker-ui value="09:30"></time-picker-ui>');
-    await tick();
-    el.value = '11:45';
-    await tick();
-    expect(segText(el, 'hour')).toBe('11');
-    expect(segText(el, 'minute')).toBe('45');
-  });
-
-  it('focusing a segment sets [editing] + [segment="…"] on host', async () => {
-    const el = mount('<time-picker-ui value="09:30"></time-picker-ui>');
-    await tick();
-    const minute = el.querySelector('[data-segment="minute"]');
-    minute.focus();
-    await tick();
-    expect(el.hasAttribute('editing')).toBe(true);
-    expect(el.getAttribute('segment')).toBe('minute');
-  });
-});

package/components/timeline/timeline.test.js

@@ -1,31 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import '../../core/element.js';
-import './timeline.js';
-
-const tick = () => new Promise((r) => queueMicrotask(r));
-function mount(html) {
-  const w = document.createElement('div');
-  w.innerHTML = html;
-  document.body.appendChild(w);
-  return w.firstElementChild;
-}
-
-describe('timeline-item-ui — label stamp-if-absent (wrapper trap)', () => {
-  beforeEach(() => { document.body.innerHTML = ''; });
-
-  it('stamps the label structure when the consumer provides none', async () => {
-    const el = mount('<timeline-item-ui text="Shipped"></timeline-item-ui>');
-    await tick();
-    expect(el.querySelectorAll('[slot="label"]').length).toBe(1);
-  });
-
-  // Regression (audit-wrapper-trap arm 2): a WRAPPED consumer [slot="label"]
-  // must suppress the default-structure stamp, not produce a duplicate label.
-  it('does NOT stamp a duplicate when a WRAPPED consumer label is present', async () => {
-    const el = mount(`<timeline-item-ui text="Shipped"><span style="display:contents" role="presentation"><span slot="label" data-test="l">Custom</span></span></timeline-item-ui>`);
-    await tick();
-    const labels = el.querySelectorAll('[slot="label"]');
-    expect(labels.length).toBe(1);
-    expect(labels[0].dataset.test).toBe('l');
-  });
-});