@adia-ai/web-components 0.8.19 → 0.8.21

package/core/element.test.js

@@ -1,389 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { UIElement, signal, effect } from './element.js';
-
-// ── Shared helpers ──
-
-let registrationCounter = 0;
-function registerTestElement(BaseImpl) {
-  const tag = `test-el-${++registrationCounter}`;
-  customElements.define(tag, BaseImpl);
-  return tag;
-}
-
-function mount(tag, attrs = {}) {
-  const el = document.createElement(tag);
-  for (const [k, v] of Object.entries(attrs)) el.setAttribute(k, v);
-  document.body.appendChild(el);
-  return el;
-}
-
-// Signals flush via queueMicrotask — await one tick to let reactive
-// effects settle after a mutation.
-const tick = () => new Promise((r) => queueMicrotask(r));
-
-describe('UIElement — construction + lifecycle', () => {
-  beforeEach(() => { document.body.innerHTML = ''; });
-
-  it('instantiates and calls connected() on mount, disconnected() on remove', () => {
-    const events = [];
-    class El extends UIElement {
-      connected()    { events.push('connected'); }
-      disconnected() { events.push('disconnected'); }
-    }
-    const tag = registerTestElement(El);
-    const el = mount(tag);
-    expect(events).toEqual(['connected']);
-    el.remove();
-    expect(events).toEqual(['connected', 'disconnected']);
-  });
-
-  it('remount after disconnect re-runs connected()', () => {
-    const events = [];
-    class El extends UIElement {
-      connected()    { events.push('connected'); }
-      disconnected() { events.push('disconnected'); }
-    }
-    const tag = registerTestElement(El);
-    const el = mount(tag);
-    el.remove();
-    document.body.appendChild(el);
-    expect(events).toEqual(['connected', 'disconnected', 'connected']);
-  });
-});
-
-describe('UIElement — properties', () => {
-  beforeEach(() => { document.body.innerHTML = ''; });
-
-  it('reads default value from static properties', () => {
-    class El extends UIElement {
-      static properties = { label: { type: String, default: 'hi' } };
-    }
-    const tag = registerTestElement(El);
-    const el = mount(tag);
-    expect(el.label).toBe('hi');
-  });
-
-  // FEEDBACK-99 (color-app, 2026-06-07): a property assigned on the instance
-  // BEFORE upgrade — template engines set `.prop=${v}` during stamp, possibly
-  // before the element is defined (see template.js property-binding path) —
-  // must survive upgrade, not be clobbered by the signal default. WHATWG
-  // "upgrade a property" pattern, here in installProps. Fixes input-ui `.value`.
-  it('reifies a property set on the instance before upgrade (lazy upgrade)', () => {
-    const tag = `test-el-${++registrationCounter}`;
-    const el = document.createElement(tag);   // undefined tag → un-upgraded
-    document.body.appendChild(el);
-    el.value = 'pre-upgrade';                  // own data-property, no accessor yet
-    class El extends UIElement {
-      static properties = { value: { type: String, default: '' } };
-    }
-    customElements.define(tag, El);            // upgrade → installProps runs
-    expect(el.value).toBe('pre-upgrade');      // reified, not clobbered to ''
-  });
-
-  it('reflects Boolean properties to HTML attributes when reflect: true', () => {
-    class El extends UIElement {
-      static properties = { disabled: { type: Boolean, default: false, reflect: true } };
-    }
-    const tag = registerTestElement(El);
-    const el = mount(tag);
-    expect(el.hasAttribute('disabled')).toBe(false);
-    el.disabled = true;
-    expect(el.hasAttribute('disabled')).toBe(true);
-    el.disabled = false;
-    expect(el.hasAttribute('disabled')).toBe(false);
-  });
-
-  it('reflects String properties as attribute values', () => {
-    class El extends UIElement {
-      static properties = { variant: { type: String, default: 'neutral', reflect: true } };
-    }
-    const tag = registerTestElement(El);
-    const el = mount(tag);
-    el.variant = 'accent';
-    expect(el.getAttribute('variant')).toBe('accent');
-  });
-
-  it('parses incoming attributes back into typed properties', () => {
-    class El extends UIElement {
-      static properties = {
-        count:    { type: Number,  default: 0 },
-        active:   { type: Boolean, default: false },
-      };
-    }
-    const tag = registerTestElement(El);
-    const el = mount(tag, { count: '42', active: '' });
-    expect(el.count).toBe(42);
-    expect(el.active).toBe(true);
-  });
-
-  it('does NOT reflect when reflect: false / omitted', () => {
-    class El extends UIElement {
-      static properties = { internal: { type: String, default: 'x' } };
-    }
-    const tag = registerTestElement(El);
-    const el = mount(tag);
-    el.internal = 'y';
-    expect(el.hasAttribute('internal')).toBe(false);
-  });
-});
-
-describe('UIElement — reactive effect', () => {
-  beforeEach(() => { document.body.innerHTML = ''; });
-
-  it('calls render() on mount and when a reactive property changes', async () => {
-    let renders = 0;
-    class El extends UIElement {
-      static properties = { label: { type: String, default: 'a' } };
-      render() { renders++; void this.label; }
-    }
-    const tag = registerTestElement(El);
-    const el = mount(tag);
-    expect(renders).toBeGreaterThan(0);
-    const before = renders;
-    el.label = 'b';
-    await tick();
-    expect(renders).toBeGreaterThan(before);
-  });
-
-  it('stops re-rendering after disconnect', async () => {
-    let renders = 0;
-    class El extends UIElement {
-      static properties = { label: { type: String, default: 'a' } };
-      render() { renders++; void this.label; }
-    }
-    const tag = registerTestElement(El);
-    const el = mount(tag);
-    el.remove();
-    const frozen = renders;
-    el.label = 'c';
-    await tick();
-    expect(renders).toBe(frozen);
-  });
-});
-
-describe('UIElement — subscription-leak guard (0.0.10 regression)', () => {
-  beforeEach(() => { document.body.innerHTML = ''; });
-
-  it('child connected() reads do NOT subscribe an outer effect', async () => {
-    // The bug: when a parent effect called appendChild(child) while running,
-    // child.connectedCallback would synchronously call connected(), and any
-    // template-literal reads of child's reactive properties would subscribe
-    // the OUTER effect to the CHILD's signals. A later change to a child
-    // prop would spuriously re-run the parent effect.
-    //
-    // Fix: connected() is now wrapped in untracked(…).
-    class Child extends UIElement {
-      static properties = { value: { type: String, default: 'initial', reflect: true } };
-      connected() {
-        // Read our own reactive prop exactly the way template-literal
-        // interpolation would — this read must not subscribe an ancestor
-        // effect.
-        void this.value;
-      }
-    }
-    const tag = registerTestElement(Child);
-
-    const trigger = signal(0);
-    let outerRuns = 0;
-    let childRef = null;
-
-    const dispose = effect(() => {
-      outerRuns++;
-      void trigger.value;
-      if (!childRef) {
-        childRef = document.createElement(tag);
-        document.body.appendChild(childRef);
-      }
-    });
-
-    const outerRunsAfterMount = outerRuns;
-    expect(childRef).not.toBeNull();
-
-    // Now mutate the CHILD's signal — the outer effect MUST NOT re-run.
-    childRef.value = 'changed';
-    await tick();
-    expect(outerRuns).toBe(outerRunsAfterMount);
-
-    // Sanity check: mutating the trigger signal the outer effect DID
-    // subscribe to re-runs the effect, proving the effect is alive.
-    trigger.value = 1;
-    await tick();
-    expect(outerRuns).toBe(outerRunsAfterMount + 1);
-
-    dispose();
-  });
-});
-
-describe('UIElement — addTrait', () => {
-  beforeEach(() => { document.body.innerHTML = ''; });
-
-  it('applies a trait once, idempotent on repeat', () => {
-    let connects = 0;
-    const myTrait = () => ({
-      connect() { connects++; },
-      disconnect() {},
-    });
-
-    class El extends UIElement {}
-    const tag = registerTestElement(El);
-    const el = mount(tag);
-    el.addTrait(myTrait);
-    el.addTrait(myTrait);
-    expect(connects).toBe(1);
-  });
-
-  it('disconnects all applied traits on remove', () => {
-    let connects = 0, disconnects = 0;
-    const myTrait = () => ({
-      connect()    { connects++; },
-      disconnect() { disconnects++; },
-    });
-    class El extends UIElement {
-      static traits = [myTrait];
-    }
-    const tag = registerTestElement(El);
-    const el = mount(tag);
-    expect(connects).toBe(1);
-    expect(disconnects).toBe(0);
-    el.remove();
-    expect(disconnects).toBe(1);
-  });
-});
-
-// gh#285 — SSR DOM shims (linkedom et al.) implement no ElementInternals
-// and no document.adoptedStyleSheets. These tests simulate that absence
-// directly (deleting the real APIs) rather than trusting a mock — the
-// bug was an unconditional call crashing the CONSTRUCTOR, before any
-// subclass code ran, so the only real proof is exercising construction
-// with the API genuinely gone.
-describe('UIElement — SSR browser-API absence (gh#285)', () => {
-  beforeEach(() => { document.body.innerHTML = ''; });
-
-  it('constructs without throwing when attachInternals does not exist', () => {
-    const original = HTMLElement.prototype.attachInternals;
-    delete HTMLElement.prototype.attachInternals;
-    try {
-      class El extends UIElement {}
-      const tag = registerTestElement(El);
-      expect(() => mount(tag)).not.toThrow();
-    } finally {
-      HTMLElement.prototype.attachInternals = original;
-    }
-  });
-
-  it('the no-op internals shim answers every call site the framework actually makes', () => {
-    const original = HTMLElement.prototype.attachInternals;
-    delete HTMLElement.prototype.attachInternals;
-    let el;
-    try {
-      class El extends UIElement {}
-      const tag = registerTestElement(El);
-      el = mount(tag);
-    } finally {
-      HTMLElement.prototype.attachInternals = original;
-    }
-    expect(() => el.internals.setFormValue('x')).not.toThrow();
-    expect(() => el.internals.setValidity({})).not.toThrow();
-    expect(el.internals.checkValidity()).toBe(true);
-    expect(el.internals.reportValidity()).toBe(true);
-    expect(el.internals.form).toBeNull();
-    expect(el.internals.labels).toEqual([]);
-    expect(el.internals.validity).toEqual({});
-    expect(el.internals.validationMessage).toBe('');
-    expect(el.internals.willValidate).toBe(false);
-  });
-
-  it('a real attachInternals is still used when the browser provides one (no regression)', () => {
-    class El extends UIElement {}
-    const tag = registerTestElement(El);
-    const el = mount(tag);
-    // happy-dom's real attachInternals — not the shim.
-    expect(el.internals).not.toBe(null);
-    expect(typeof el.internals.setFormValue).toBe('function');
-  });
-
-  it('adoptStyles no-ops instead of throwing when adoptedStyleSheets does not exist', () => {
-    const desc = Object.getOwnPropertyDescriptor(Document.prototype, 'adoptedStyleSheets');
-    delete Document.prototype.adoptedStyleSheets;
-    try {
-      class El extends UIElement {
-        static styles = ['/* fake sheet */'];
-      }
-      const tag = registerTestElement(El);
-      expect(() => mount(tag)).not.toThrow();
-    } finally {
-      if (desc) Object.defineProperty(Document.prototype, 'adoptedStyleSheets', desc);
-    }
-  });
-});
-
-// gh#284 — the custom-elements spec's "upgrade an element" algorithm
-// (§4.13.5 step 6) requires replaying attributeChangedCallback for every
-// attribute already present on an element BEFORE connectedCallback fires
-// on upgrade. happy-dom (this repo's own test DOM) skips that replay —
-// confirmed directly: a bare custom element upgraded with a pre-existing
-// observed attribute gets connectedCallback but never the matching
-// attributeChangedCallback. linkedom (the real SSR consumer's DOM shim,
-// per adia-ssr) is a similarly from-scratch custom-elements registry, so
-// the same gap is expected there too. Simulating the absence directly
-// (a real late-upgrade sequence, not a mock) rather than trusting that
-// happy-dom already reproduces the SSR shape — it does, which is exactly
-// how this was found.
-describe('UIElement — SSR attribute-upgrade replay (gh#284)', () => {
-  beforeEach(() => { document.body.innerHTML = ''; });
-
-  // Parses markup into an UNDEFINED custom element (so its attributes land
-  // on the element the way a server-rendered / pre-parsed document would),
-  // THEN defines the tag — matching the "define after parse" shape SSR
-  // hydration and lazy client registration both produce.
-  function mountLateUpgrade(tag, BaseImpl, html) {
-    const container = document.createElement('div');
-    container.innerHTML = html;
-    document.body.appendChild(container);
-    customElements.define(tag, BaseImpl);
-    return container.querySelector(tag);
-  }
-
-  it('confirms the environment gap this fix compensates for', () => {
-    const tag = `test-plain-${++registrationCounter}`;
-    const calls = [];
-    class Plain extends HTMLElement {
-      static get observedAttributes() { return ['foo']; }
-      attributeChangedCallback(name, oldV, newV) { calls.push([name, oldV, newV]); }
-      connectedCallback() { calls.push(['connected']); }
-    }
-    mountLateUpgrade(tag, Plain, `<${tag} foo="bar"></${tag}>`);
-    expect(calls).toEqual([['connected']]); // NOT ['foo', null, 'bar'] first, per spec
-  });
-
-  it('a reflected property set only via pre-parsed HTML is not stuck at its class default', () => {
-    const tag = `test-late-${++registrationCounter}`;
-    class El extends UIElement {
-      static properties = { label: { type: String, default: '', reflect: true } };
-    }
-    const el = mountLateUpgrade(tag, El, `<${tag} label="Profile"></${tag}>`);
-    expect(el.label).toBe('Profile');
-  });
-
-  it('a reflected boolean attribute present-with-no-value resolves true, not the class default', () => {
-    const tag = `test-late-bool-${++registrationCounter}`;
-    class El extends UIElement {
-      static properties = { active: { type: Boolean, default: false, reflect: true } };
-    }
-    const el = mountLateUpgrade(tag, El, `<${tag} active></${tag}>`);
-    expect(el.active).toBe(true);
-  });
-
-  it('no regression: normal define-before-parse still gets attributeChangedCallback (no extra render)', async () => {
-    let renders = 0;
-    class El extends UIElement {
-      static properties = { label: { type: String, default: '', reflect: true } };
-      render() { renders++; }
-    }
-    const tag = registerTestElement(El);
-    const el = mount(tag, { label: 'Profile' });
-    await tick();
-    expect(el.label).toBe('Profile');
-    expect(renders).toBe(1); // the connectedCallback re-sync is a no-op here, not a second render
-  });
-});

package/core/icons.test.js

@@ -1,187 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import {
-  installIconLoaders,
-  registerIcon,
-  hasIcon,
-  isIconName,
-  getIcon,
-  listIcons,
-} from './icons.js';
-
-// Tests for `installIconLoaders` + `resolveLoader` + the §140 suffix-
-// fallback fix for FEEDBACK-06 (color-app's `installIconLoaders` →
-// `warnMissingIcon` failures on `caret-right` / `x` / `caret-up-down`
-// when the consumer's `modules` keys didn't match the canonical
-// `/node_modules/@phosphor-icons/core/assets/<weight>/<name>.svg` path.
-//
-// `isIconName` is the SYNC probe — it calls `resolveLoader` without
-// triggering an async load. That's what we need to assert the fallback
-// logic finds the loader regardless of path shape.
-
-const CARET_RIGHT_SVG = '<svg data-icon="caret-right"/>';
-const X_SVG = '<svg data-icon="x"/>';
-const CARET_UP_DOWN_SVG = '<svg data-icon="caret-up-down"/>';
-
-describe('installIconLoaders + resolveLoader (§140 suffix fallback)', () => {
-  beforeEach(() => {
-    // Reset to a known state. Note: the registry Map itself is module-
-    // singleton + doesn't reset between tests, so we keep test SVG
-    // contents distinct from any real phosphor names just in case.
-    installIconLoaders({ regular: {}, thin: {}, light: {}, bold: {}, fill: {}, duotone: {} });
-  });
-
-  it('resolves by canonical phosphor path (fast path)', () => {
-    installIconLoaders({
-      regular: {
-        '/node_modules/@phosphor-icons/core/assets/regular/caret-right.svg': CARET_RIGHT_SVG,
-        '/node_modules/@phosphor-icons/core/assets/regular/x.svg': X_SVG,
-      },
-    });
-
-    expect(isIconName('caret-right')).toBe(true);
-    expect(isIconName('x')).toBe(true);
-  });
-
-  it('resolves by filename suffix when key has a pnpm-style prefix', () => {
-    // pnpm hoists phosphor inside `.pnpm/<pkg>@<ver>/node_modules/...`
-    installIconLoaders({
-      regular: {
-        '/node_modules/.pnpm/@phosphor-icons+core@2.1.1/node_modules/@phosphor-icons/core/assets/regular/caret-right.svg':
-          CARET_RIGHT_SVG,
-      },
-    });
-
-    expect(isIconName('caret-right')).toBe(true);
-  });
-
-  it('resolves by filename suffix when key is a custom Vite-root absolute path', () => {
-    // Custom Vite root puts node_modules at a deeper location.
-    installIconLoaders({
-      regular: {
-        '/packages/my-app/node_modules/@phosphor-icons/core/assets/regular/caret-up-down.svg':
-          CARET_UP_DOWN_SVG,
-      },
-    });
-
-    expect(isIconName('caret-up-down')).toBe(true);
-  });
-
-  it('resolves by filename suffix for an arbitrary manually-built loader map', () => {
-    // Manual loader maps may have any keys at all — only the filename matters.
-    installIconLoaders({
-      regular: {
-        '/anywhere/at/all/caret-right.svg': CARET_RIGHT_SVG,
-        '/another/path/entirely/x.svg': X_SVG,
-      },
-    });
-
-    expect(isIconName('caret-right')).toBe(true);
-    expect(isIconName('x')).toBe(true);
-  });
-
-  it('returns false on miss across both paths', () => {
-    installIconLoaders({
-      regular: {
-        '/node_modules/@phosphor-icons/core/assets/regular/caret-right.svg': CARET_RIGHT_SVG,
-      },
-    });
-
-    expect(isIconName('not-a-real-icon-name')).toBe(false);
-  });
-
-  it('resolves `-fill` back-compat suffix in name via fast path', () => {
-    const STAR_FILL_SVG = '<svg data-icon="star-fill"/>';
-    installIconLoaders({
-      regular: {},
-      fill: {
-        '/node_modules/@phosphor-icons/core/assets/fill/star-fill.svg': STAR_FILL_SVG,
-      },
-    });
-
-    // `name="star-fill"` with default weight=regular falls back to fill weight.
-    expect(isIconName('star-fill')).toBe(true);
-  });
-
-  it('resolves `-fill` back-compat suffix in name via suffix fallback', () => {
-    const STAR_FILL_SVG = '<svg data-icon="star-fill"/>';
-    installIconLoaders({
-      regular: {},
-      fill: {
-        '/anywhere/star-fill.svg': STAR_FILL_SVG,
-      },
-    });
-
-    expect(isIconName('star-fill')).toBe(true);
-  });
-
-  it('resolves non-regular weights (bold, fill, etc.) via suffix fallback', () => {
-    const HEART_BOLD_SVG = '<svg data-icon="heart-bold"/>';
-    installIconLoaders({
-      regular: {},
-      bold: {
-        '/anywhere/heart-bold.svg': HEART_BOLD_SVG,
-      },
-    });
-
-    expect(isIconName('heart', 'bold')).toBe(true);
-  });
-
-  it('isIconName returns true via alias resolution + suffix fallback', () => {
-    // `send` → `paper-plane-right` in ICON_ALIASES. Suffix fallback should
-    // still match the aliased filename.
-    const PAPER_PLANE_SVG = '<svg data-icon="paper-plane-right"/>';
-    installIconLoaders({
-      regular: {
-        '/anywhere/paper-plane-right.svg': PAPER_PLANE_SVG,
-      },
-    });
-
-    expect(isIconName('send')).toBe(true);
-  });
-
-  it('end-to-end via DOM re-stamp: installIconLoaders auto-loads existing <icon-ui[name]>', async () => {
-    // The §140 fix's primary symptom: `installIconLoaders` walks existing
-    // `<icon-ui[name]>` elements + calls `loadIcon` for each. Without the
-    // suffix fallback, `loadIcon` → `resolveLoader` returns null →
-    // `warnMissingIcon` fires. With the fix, the load completes.
-    const PAW_SVG = '<svg data-icon="paw"/>';
-
-    // Plant an `<icon-ui[name="paw"]>` element. We don't need it to
-    // actually upgrade; we just need `querySelectorAll('icon-ui[name]')`
-    // to find it.
-    const el = document.createElement('icon-ui');
-    el.setAttribute('name', 'paw');
-    document.body.appendChild(el);
-
-    // Install a loader map with a pnpm-style path (suffix fallback exercise).
-    installIconLoaders({
-      regular: {
-        '/some/non-canonical/prefix/paw.svg': PAW_SVG,
-      },
-    });
-
-    // `loadIcon` runs sync (loader is a string, not a function), so the
-    // registry is written by the time `installIconLoaders` returns.
-    expect(hasIcon('paw')).toBe(true);
-
-    document.body.removeChild(el);
-  });
-});
-
-describe('registerIcon / hasIcon — unchanged by §140', () => {
-  it('registerIcon adds an icon by name without needing a loader map', () => {
-    const CUSTOM_SVG = '<svg data-icon="custom-§140-marker"/>';
-    registerIcon('my-§140-custom-icon', CUSTOM_SVG);
-
-    expect(hasIcon('my-§140-custom-icon')).toBe(true);
-    expect(getIcon('my-§140-custom-icon')).toBe(CUSTOM_SVG);
-  });
-
-  it('listIcons returns registered names', () => {
-    registerIcon('§140-listIcons-marker-one', '<svg/>');
-    registerIcon('§140-listIcons-marker-two', '<svg/>');
-
-    expect(listIcons().some((k) => k.includes('§140-listIcons-marker-one'))).toBe(true);
-    expect(listIcons().some((k) => k.includes('§140-listIcons-marker-two'))).toBe(true);
-  });
-});

package/core/logical-children.test.js

@@ -1,54 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { logicalChildren, logicalSlotted } from './logical-children.js';
-
-function host(html) {
-  const el = document.createElement('div');
-  el.innerHTML = html;
-  return el;
-}
-
-describe('logical-children', () => {
-  beforeEach(() => { document.body.innerHTML = ''; });
-
-  it('returns static direct children as-is', () => {
-    const h = host(`<button slot="primary">A</button><p>body</p><button slot="secondary">B</button>`);
-    expect(logicalChildren(h).map((e) => e.tagName)).toEqual(['BUTTON', 'P', 'BUTTON']);
-    expect(logicalSlotted(h, 'primary').length).toBe(1);
-    expect(logicalSlotted(h, 'secondary')[0].textContent).toBe('B');
-    expect(logicalSlotted(h, 'missing').length).toBe(0);
-  });
-
-  it('pierces a single display:contents/role=presentation wrapper', () => {
-    const h = host(`
-      <span style="display:contents" role="presentation"><button slot="primary">A</button></span>
-      <p>body</p>
-    `);
-    // Without piercing, h.querySelector(':scope > [slot="primary"]') would be null:
-    expect(h.querySelector(':scope > [slot="primary"]')).toBeNull();
-    // With the helper, it's found:
-    expect(logicalSlotted(h, 'primary').length).toBe(1);
-    expect(logicalChildren(h).map((e) => e.tagName)).toEqual(['BUTTON', 'P']);
-  });
-
-  it('pierces NESTED wrappers (the .map() shape)', () => {
-    const h = host(`
-      <span style="display:contents" role="presentation">
-        <span style="display:contents" role="presentation"><button slot="act">A</button></span>
-        <span style="display:contents" role="presentation"><button slot="act">B</button></span>
-      </span>
-    `);
-    expect(logicalSlotted(h, 'act').map((e) => e.textContent)).toEqual(['A', 'B']);
-  });
-
-  it('does NOT pierce non-wrapper elements (logical = direct, wrappers aside)', () => {
-    const h = host(`<div><button slot="primary">nested-in-real-div</button></div>`);
-    // The button is inside a real <div>, not a transparent wrapper → not a logical child.
-    expect(logicalSlotted(h, 'primary').length).toBe(0);
-    expect(logicalChildren(h).map((e) => e.tagName)).toEqual(['DIV']);
-  });
-
-  it('tolerates a null host', () => {
-    expect(logicalChildren(null)).toEqual([]);
-    expect(logicalSlotted(null, 'x')).toEqual([]);
-  });
-});

package/core/markdown.test.js

@@ -1,47 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { renderMarkdown } from './markdown.js';
-
-// ── inline() protect-verbatim-regions regression (site-a2ui/FINDINGS.md
-//    "No inline-flow construct" — root cause: emphasis regexes ran BEFORE
-//    code-span extraction, so any code span containing `*`/`_` mangled) ──
-
-describe('renderMarkdown — inline code spans survive markdown-unsafe content', () => {
-  it('code span containing an asterisk is not treated as emphasis', () => {
-    const html = renderMarkdown('Use `--a-chrome-*` for chrome tokens.');
-    expect(html).toContain('<code>--a-chrome-*</code>');
-    expect(html).not.toContain('<em>');
-    expect(html).not.toContain('<strong>');
-  });
-
-  it('code span containing underscores is not treated as emphasis', () => {
-    const html = renderMarkdown('Call `foo_bar_baz()` to run it.');
-    expect(html).toContain('<code>foo_bar_baz()</code>');
-    expect(html).not.toContain('<em>');
-  });
-
-  it('code span containing double-asterisks is not treated as bold', () => {
-    const html = renderMarkdown('The pattern `**not-bold**` is literal.');
-    expect(html).toContain('<code>**not-bold**</code>');
-    expect(html).not.toContain('<strong>');
-  });
-
-  it('bold, italic, code, and link combine correctly within one run', () => {
-    const html = renderMarkdown('This is **bold**, this is *italic*, this is `code_with_*` and this is [a link](https://example.com).');
-    expect(html).toContain('<strong>bold</strong>');
-    expect(html).toContain('<em>italic</em>');
-    expect(html).toContain('<code>code_with_*</code>');
-    expect(html).toContain('<a href="https://example.com">a link</a>');
-  });
-
-  it('adjacent code spans do not bleed into each other', () => {
-    const html = renderMarkdown('First `a_b` then `c*d` then plain _italic_ text.');
-    expect(html).toContain('<code>a_b</code>');
-    expect(html).toContain('<code>c*d</code>');
-    expect(html).toContain('<em>italic</em>');
-  });
-
-  it('HTML-unsafe characters inside a code span are still escaped', () => {
-    const html = renderMarkdown('Use `<script>` tags carefully.');
-    expect(html).toContain('<code>&lt;script&gt;</code>');
-  });
-});