inkbridge 0.1.0-beta.2 → 0.1.0-beta.21

package/scanner/render-prop-parser-regression.ts

@@ -0,0 +1,161 @@
+import assert from 'node:assert/strict';
+import { parseRenderPropToSyntheticInstance } from '../src/design-system/render-prop-parser';
+
+/**
+ * Regression: parseRenderPropToSyntheticInstance turns a Storybook
+ * `render="<Foo bar=\"x\">y</Foo>"` string literal into a synthetic
+ * ComponentInstance the renderer can treat like a real scanner output.
+ * Stories that declare their JSX as a literal string instead of a render
+ * function depend on this — if the parser drifts, those stories silently
+ * render as nothing.
+ *
+ * Extracted from `src/design-system/story-builder.ts` into
+ * `src/design-system/render-prop-parser.ts`.
+ */
+
+// ---------------------------------------------------------------------------
+// Defensive: non-string / empty / falsy inputs return null without throwing
+// ---------------------------------------------------------------------------
+
+assert.equal(parseRenderPropToSyntheticInstance(null), null, 'null returns null');
+assert.equal(parseRenderPropToSyntheticInstance(undefined), null, 'undefined returns null');
+assert.equal(parseRenderPropToSyntheticInstance(42), null, 'number returns null');
+assert.equal(parseRenderPropToSyntheticInstance({}), null, 'object returns null');
+assert.equal(parseRenderPropToSyntheticInstance(''), null, 'empty string returns null');
+assert.equal(parseRenderPropToSyntheticInstance('   '), null, 'whitespace-only string returns null');
+
+// ---------------------------------------------------------------------------
+// Tagname extraction
+// ---------------------------------------------------------------------------
+
+{
+  const out = parseRenderPropToSyntheticInstance('<Button>Click me</Button>');
+  assert.ok(out, 'simple tag must parse');
+  assert.equal(out.componentName, 'Button', 'componentName captures the opening tag');
+  assert.equal(out.children, 'Click me', 'inner text becomes children');
+  assert.deepEqual(out.props, {}, 'no attrs → empty props');
+}
+
+// Component naming preserved (PascalCase, hyphens, dots — namespaced
+// components like `Form.Item` are captured as written).
+for (const tag of ['Button', 'PrimaryButton', 'form-item', 'Form.Item', 'My_Custom_123']) {
+  const out = parseRenderPropToSyntheticInstance(`<${tag}>x</${tag}>`);
+  assert.ok(out, `tag "${tag}" must parse`);
+  assert.equal(out.componentName, tag, `tag "${tag}" preserved verbatim`);
+}
+
+// ---------------------------------------------------------------------------
+// Attribute extraction
+// ---------------------------------------------------------------------------
+
+// Single attr
+{
+  const out = parseRenderPropToSyntheticInstance('<Button variant="primary">Go</Button>');
+  assert.ok(out);
+  assert.deepEqual(out.props, { variant: 'primary' }, 'single attr extracted');
+}
+
+// Multiple attrs
+{
+  const out = parseRenderPropToSyntheticInstance(
+    '<Button variant="primary" size="lg" disabled="true">Submit</Button>',
+  );
+  assert.ok(out);
+  assert.deepEqual(
+    out.props,
+    { variant: 'primary', size: 'lg', disabled: 'true' },
+    'all attrs extracted',
+  );
+}
+
+// Attr names support letters, digits, underscore, hyphen, colon
+{
+  const out = parseRenderPropToSyntheticInstance(
+    '<Foo aria-label="x" data-test="y" my_attr="z" ns:attr="w">x</Foo>',
+  );
+  assert.ok(out);
+  assert.deepEqual(out.props, {
+    'aria-label': 'x',
+    'data-test': 'y',
+    my_attr: 'z',
+    'ns:attr': 'w',
+  });
+}
+
+// Boolean shorthand (no =) is ignored — non-goal documented in the module.
+{
+  const out = parseRenderPropToSyntheticInstance('<Button disabled>x</Button>');
+  assert.ok(out);
+  assert.deepEqual(out.props, {}, 'boolean shorthand attrs are deliberately ignored');
+}
+
+// Empty attr values are kept (designers may want to detect their presence).
+{
+  const out = parseRenderPropToSyntheticInstance('<Foo bar="">x</Foo>');
+  assert.ok(out);
+  assert.deepEqual(out.props, { bar: '' }, 'empty-string attr value preserved');
+}
+
+// ---------------------------------------------------------------------------
+// Children handling
+// ---------------------------------------------------------------------------
+
+// Empty children → undefined (not empty string) so the renderer can treat
+// it as "no content" rather than "explicit empty text".
+{
+  const out = parseRenderPropToSyntheticInstance('<Button></Button>');
+  assert.ok(out);
+  assert.equal(out.children, undefined, 'empty children become undefined, not ""');
+}
+
+// Whitespace-only children → undefined (trimmed before falsy check).
+{
+  const out = parseRenderPropToSyntheticInstance('<Button>   </Button>');
+  assert.ok(out);
+  assert.equal(out.children, undefined, 'whitespace-only children become undefined');
+}
+
+// Inner content can contain markup (regex is non-greedy) — first matching
+// closing tag wins.
+{
+  const out = parseRenderPropToSyntheticInstance(
+    '<Card><span>Inner</span></Card>',
+  );
+  assert.ok(out);
+  assert.equal(out.componentName, 'Card');
+  assert.equal(out.children, '<span>Inner</span>', 'nested markup kept as raw text');
+}
+
+// ---------------------------------------------------------------------------
+// Invalid inputs return null (no partial matches)
+// ---------------------------------------------------------------------------
+
+// Self-closing tag isn't matched — non-goal documented in module.
+assert.equal(
+  parseRenderPropToSyntheticInstance('<Button />'),
+  null,
+  'self-closing tag not supported — parser stays strict',
+);
+
+// Mismatched tags return null (backref \1 enforces equality).
+assert.equal(
+  parseRenderPropToSyntheticInstance('<Button>x</Span>'),
+  null,
+  'mismatched closing tag returns null',
+);
+
+// Just a string without tags returns null.
+assert.equal(
+  parseRenderPropToSyntheticInstance('hello world'),
+  null,
+  'plain text (no tags) returns null',
+);
+
+// Truncated / unclosed tag returns null.
+assert.equal(
+  parseRenderPropToSyntheticInstance('<Button>missing close'),
+  null,
+  'unclosed tag returns null',
+);
+
+console.log('render-prop-parser-regression: PASS');

package/scanner/ring-utility-regression.ts

@@ -0,0 +1,153 @@
+import assert from 'node:assert/strict';
+
+import { parseRingWidth, parseRingColor, getRingInfoFromClasses } from '../src/layout/ring-utils';
+
+/**
+ * Regression: `applyTailwindStylesToFrame` in tailwind.ts now delegates
+ * ring rendering to `applyRingEffect` (overlay-frame approach in
+ * `layout/ring-utils.ts`) instead of pushing a Figma DROP_SHADOW with
+ * `spread > 0`.
+ *
+ * Why this matters: Figma surfaces
+ *   "The 'spread' parameter is not supported when frames or components
+ *    have no visible fills"
+ * for every transparent frame that gets a spread-based ring — i.e. every
+ * structural layout frame in the design system. The console fills with
+ * the warning for the duration of a build, and the workaround
+ * `clipsContent = true` from a prior round (for a different Figma spread
+ * constraint about clipping) is now redundant: the overlay path doesn't
+ * touch effects or fills.
+ *
+ * This file locks the ring-utils parser inputs that `applyRingEffect`
+ * relies on. If a future refactor re-introduces an inline DROP_SHADOW
+ * path or weakens the parser, these assertions catch it.
+ */
+
+const colorGroup: Record<string, string> = {
+  ring: '#3b82f6',
+  primary: '#1d4ed8',
+  destructive: '#ef4444',
+};
+
+// ---------------------------------------------------------------------------
+// parseRingWidth — width-only utilities.
+// ---------------------------------------------------------------------------
+
+assert.equal(parseRingWidth('ring'), 3, 'bare `ring` → default 3px');
+assert.equal(parseRingWidth('ring-2'), 2, '`ring-2` → 2px');
+assert.equal(parseRingWidth('ring-0'), 0, '`ring-0` → 0px (caller must filter zero)');
+assert.equal(parseRingWidth('ring-[3px]'), 3, '`ring-[3px]` → 3px arbitrary');
+assert.equal(parseRingWidth('ring-[1rem]'), 16, '`ring-[1rem]` → 16px (1rem = 16px)');
+assert.equal(parseRingWidth('ring-inset'), null, '`ring-inset` is a modifier, not a width');
+assert.equal(parseRingWidth('ring-offset-2'), null, '`ring-offset-N` is a separate utility');
+assert.equal(parseRingWidth('ring-primary'), null, 'color utilities do not parse as width');
+assert.equal(parseRingWidth('hover:ring-2'), null, 'variant-prefixed classes return null');
+assert.equal(parseRingWidth('border-2'), null, 'unrelated utilities return null');
+
+// ---------------------------------------------------------------------------
+// parseRingColor — color and color/opacity utilities.
+// ---------------------------------------------------------------------------
+
+{
+  const color = parseRingColor('ring-primary', colorGroup);
+  assert.ok(color, '`ring-primary` resolves to a color');
+  assert.equal(color!.r, parseInt('1d', 16) / 255, 'primary R');
+  assert.equal(color!.g, parseInt('4e', 16) / 255, 'primary G');
+  assert.equal(color!.b, parseInt('d8', 16) / 255, 'primary B');
+}
+
+{
+  const color = parseRingColor('ring-primary/50', colorGroup);
+  assert.ok(color, '`ring-primary/50` resolves with opacity');
+  assert.equal(color!.a, 0.5, 'opacity 50 → 0.5');
+}
+
+{
+  const color = parseRingColor('ring-destructive', colorGroup);
+  assert.ok(color, '`ring-destructive` resolves');
+  assert.equal(color!.r, parseInt('ef', 16) / 255, 'destructive R');
+}
+
+assert.equal(parseRingColor('ring-2', colorGroup), null, 'width is not a color');
+assert.equal(parseRingColor('ring', colorGroup), null, 'bare `ring` is width-only, not a color');
+assert.equal(parseRingColor('ring-inset', colorGroup), null, '`ring-inset` is a modifier');
+assert.equal(parseRingColor('ring-offset-primary', colorGroup), null, '`ring-offset-*` is a separate utility');
+assert.equal(parseRingColor('ring-unknown', colorGroup), null, 'unknown token returns null');
+assert.equal(parseRingColor('ring-[3px]', colorGroup), null, 'arbitrary widths are not colors');
+
+// ---------------------------------------------------------------------------
+// getRingInfoFromClasses — the helper applyRingEffect calls.
+// ---------------------------------------------------------------------------
+
+{
+  const ring = getRingInfoFromClasses(['ring-2', 'ring-primary'], colorGroup);
+  assert.ok(ring, 'width + color → ring');
+  assert.equal(ring!.width, 2, 'width 2');
+  assert.equal(ring!.color.r, parseInt('1d', 16) / 255, 'primary R');
+}
+
+{
+  // Bare `ring` defaults to 3px and uses the `ring` token color when no
+  // explicit color class is present.
+  const ring = getRingInfoFromClasses(['ring'], colorGroup);
+  assert.ok(ring, 'bare ring resolves with token fallback');
+  assert.equal(ring!.width, 3, 'default 3px');
+  assert.equal(ring!.color.r, parseInt('3b', 16) / 255, 'ring token R');
+}
+
+{
+  // Color WITHOUT an explicit width is a CSS no-op — Tailwind's
+  // `ring-COLOR` sets `--tw-ring-color` but the ring stays
+  // invisible until a width utility is added. shadcn's
+  // invalid-input pattern relies on this:
+  //   `aria-invalid:ring-destructive/20 focus-visible:ring-[3px]`
+  // → tinted ring when invalid, only visible (3px) when focused.
+  // Previously this helper defaulted to width 3 when ANY ring color
+  // was present — so the State Matrix `error` variant rendered with
+  // a doubled red ring outside the destructive border instead of
+  // just the border. Now: color-only → null (no ring).
+  const ring = getRingInfoFromClasses(['ring-primary'], colorGroup);
+  assert.equal(ring, null, 'color without width → null (no ring)');
+}
+
+{
+  // Same contract for the shadcn invalid-input pattern: tinted color,
+  // no width, no visible ring.
+  const ring = getRingInfoFromClasses(['ring-destructive', 'border-destructive'], colorGroup);
+  assert.equal(ring, null, 'color + non-ring class without width → null');
+}
+
+{
+  // Color + explicit width DOES render the ring.
+  const ring = getRingInfoFromClasses(['ring-destructive', 'ring-[3px]'], colorGroup);
+  assert.ok(ring, 'color + arbitrary width → ring renders');
+  assert.equal(ring!.width, 3, '3px from `ring-[3px]`');
+}
+
+{
+  // No ring classes → null.
+  const ring = getRingInfoFromClasses(['border-2', 'rounded-md'], colorGroup);
+  assert.equal(ring, null, 'no ring classes → null');
+}
+
+{
+  // ring-0 explicitly disables — width <= 0 returns null.
+  const ring = getRingInfoFromClasses(['ring-0'], colorGroup);
+  assert.equal(ring, null, '`ring-0` → null (no effect)');
+}
+
+{
+  // Color group without `ring` falls back to `primary`.
+  const minimalGroup: Record<string, string> = { primary: '#000000' };
+  const ring = getRingInfoFromClasses(['ring'], minimalGroup);
+  assert.ok(ring, 'falls back to primary when ring token is absent');
+  assert.equal(ring!.color.r, 0, 'fallback color R');
+}
+
+{
+  // Empty color group → null (no fallback available).
+  const ring = getRingInfoFromClasses(['ring'], {});
+  assert.equal(ring, null, 'no color group → null');
+}
+
+console.log('ring-utility-regression: PASS (parseRingWidth + parseRingColor + getRingInfoFromClasses)');

package/scanner/sandbox-spread-regression.ts

@@ -0,0 +1,125 @@
+import assert from 'node:assert/strict';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { Project, SyntaxKind, type Node } from 'ts-morph';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Regression: the Figma plugin sandbox (where code.js runs) chokes on
+// value-side **spread** in function calls and array literals — that is
+// the form documented in .ai/behaviour.md and the one that bit Slider
+// (Math.min(...arr) silently threw and the whole render bailed). Object
+// spread (esbuild down-compiles to Object.assign at target=es2017) and
+// function rest parameters / destructuring rest are well-supported by
+// the sandbox's engine and are NOT flagged here.
+//
+// We walk the AST and flag the dangerous form only:
+//
+//   DANGEROUS (flagged):
+//     - SpreadElement       (call args / array literal: fn(...x), [...x])
+//
+//   SAFE (not flagged):
+//     - SpreadAssignment    (object literal spread: { ...obj, k: v })
+//     - Parameter+rest      (function rest param: function(...args))
+//     - BindingElement+rest (destructuring rest: const [a, ...rest] = arr)
+//     - Type-position rest  (TS types are erased at compile time)
+//
+// Replacements when a flag fires (mirroring patches already shipped in
+// the codebase):
+//   Math.min(...arr) / Math.max(...arr)   → manual for-loop computing min/max
+//   arr.push(...other)                    → for (let i = 0; i < other.length; i++) arr.push(other[i])
+//   [...set] / [...arr, item]             → Array.from(set) / arr.concat([item])
+//   const [a, ...rest] = arr              → arr.slice(1)
+//   function (...args)                    → explicit array param
+
+const SRC_DIR = path.resolve(__dirname, '..', 'src');
+
+function gatherSrcFiles(dir: string, out: string[]): void {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      gatherSrcFiles(full, out);
+    } else if (entry.isFile() && entry.name.endsWith('.ts') && !entry.name.endsWith('.d.ts')) {
+      out.push(full);
+    }
+  }
+}
+
+const files: string[] = [];
+gatherSrcFiles(SRC_DIR, files);
+
+assert.ok(files.length > 0, 'expected to find .ts files under tools/figma-plugin/src/');
+
+const project = new Project({
+  tsConfigFilePath: path.resolve(__dirname, '..', 'tsconfig.json'),
+  skipAddingFilesFromTsConfig: true,
+});
+for (const f of files) project.addSourceFileAtPath(f);
+
+type Violation = { file: string; line: number; col: number; kind: string; snippet: string };
+const violations: Violation[] = [];
+
+function isInTypeContext(node: Node): boolean {
+  // Walk up; if we cross into a TypeNode / TypeReference / TypeLiteral
+  // (anything erased at compile time), the spread is type-only and safe.
+  let parent = node.getParent();
+  while (parent) {
+    const k = parent.getKind();
+    if (
+      k === SyntaxKind.TypeReference
+      || k === SyntaxKind.TypeLiteral
+      || k === SyntaxKind.IntersectionType
+      || k === SyntaxKind.UnionType
+      || k === SyntaxKind.TupleType
+      || k === SyntaxKind.FunctionType
+      || k === SyntaxKind.ConstructorType
+      || k === SyntaxKind.TypeAliasDeclaration
+      || k === SyntaxKind.InterfaceDeclaration
+      || k === SyntaxKind.RestType
+      || k === SyntaxKind.NamedTupleMember
+    ) {
+      return true;
+    }
+    parent = parent.getParent();
+  }
+  return false;
+}
+
+for (const sf of project.getSourceFiles()) {
+  const relative = path.relative(SRC_DIR, sf.getFilePath());
+
+  sf.forEachDescendant((node) => {
+    const k = node.getKind();
+    // DANGEROUS: SpreadElement in a call or array literal.
+    if (k === SyntaxKind.SpreadElement) {
+      if (isInTypeContext(node)) return;
+      const { line, column } = sf.getLineAndColumnAtPos(node.getStart());
+      violations.push({
+        file: relative,
+        line,
+        col: column,
+        kind: 'SpreadElement',
+        snippet: node.getText().slice(0, 80),
+      });
+      return;
+    }
+    // SpreadAssignment (object-literal spread), Parameter(rest), and
+    // BindingElement(rest) are INTENTIONALLY NOT flagged — they all
+    // compile to forms the sandbox engine supports. Keep an eye on
+    // this if the build target ever changes.
+  });
+}
+
+if (violations.length > 0) {
+  console.error('sandbox-spread-regression: FAIL — dangerous spread/rest leaked into src/');
+  for (const v of violations) {
+    console.error(`  ${v.file}:${v.line}:${v.col}  ${v.kind}  ${v.snippet}`);
+  }
+  console.error('');
+  console.error('Replace each with Array.from / .concat / .slice / manual loop. See header of this file.');
+  process.exit(1);
+}
+
+console.log(`sandbox-spread-regression: PASS (scanned ${files.length} files, 0 dangerous spread/rest in src/)`);

package/scanner/selection-pressed-regression.ts

@@ -0,0 +1,241 @@
+import assert from 'node:assert/strict';
+import * as path from 'node:path';
+import { ComponentScanner } from './component-scanner';
+
+/**
+ * Regression: a group element with a static `defaultValue` (or `value`)
+ * array/string must inject `defaultPressed="true"` on each child whose
+ * own `value` prop matches one of the group's values.
+ *
+ * The variant engine's `data-pressed` alias then activates
+ * `data-[pressed]:*` classes at render time, so e.g. ToggleGroup's
+ * selected item visibly toggles its `data-[pressed]:bg-accent` style.
+ *
+ * Statically models base-ui's ToggleGroup/RadioGroup runtime behaviour,
+ * which compares the group's value(s) against each item's value and
+ * pushes `data-pressed`/`data-checked` to the matching items. The Context
+ * cascade only carries variant/size — selection state lives on the group
+ * primitive's own `defaultValue` prop.
+ */
+
+interface JsxTextNode { type: 'text'; content: string }
+interface JsxElementNode {
+  type: 'element';
+  tagName?: string;
+  props?: Record<string, string>;
+  children?: JsxNodeLike[];
+}
+type JsxNodeLike = JsxTextNode | JsxElementNode;
+
+interface TestScannerView {
+  project: import('ts-morph').Project;
+  extractComponentJsxTree: (
+    sourceFile: import('ts-morph').SourceFile,
+    componentName: string
+  ) => JsxNodeLike | null;
+}
+
+function makeScanner(): TestScannerView {
+  const scanner = new ComponentScanner({
+    componentPaths: [],
+    filePattern: '*.tsx',
+    exclude: [],
+  });
+  return scanner as unknown as TestScannerView;
+}
+
+function fixturePath(relative: string): string {
+  return path.resolve(process.cwd(), 'tools/figma-plugin/scanner/__fixtures__', relative);
+}
+
+function findElementsByTag(
+  node: JsxNodeLike | null | undefined,
+  tagName: string,
+  out: JsxElementNode[] = []
+): JsxElementNode[] {
+  if (!node || node.type !== 'element') return out;
+  if (node.tagName === tagName) out.push(node);
+  if (node.children) for (const c of node.children) findElementsByTag(c, tagName, out);
+  return out;
+}
+
+const scanner = makeScanner();
+
+// ---------------------------------------------------------------------------
+// Case 1: array `defaultValue` — match injects defaultPressed on the
+// matching item, leaves others untouched.
+// ---------------------------------------------------------------------------
+{
+  const file = scanner.project.createSourceFile(
+    fixturePath('toggle-group-array-default.tsx'),
+    `
+      function Story() {
+        return (
+          <div defaultValue={["center"]}>
+            <button value="left" />
+            <button value="center" />
+            <button value="right" />
+          </div>
+        );
+      }
+      export { Story };
+    `,
+    { overwrite: true }
+  );
+
+  const tree = scanner.extractComponentJsxTree(file, 'Story');
+  assert.ok(tree && tree.type === 'element', 'Story tree must build');
+  const buttons = findElementsByTag(tree, 'button');
+  assert.equal(buttons.length, 3, `expected 3 buttons, got ${buttons.length}`);
+  assert.equal(buttons[0].props?.defaultPressed, undefined, 'left: not selected, no injection');
+  assert.equal(buttons[1].props?.defaultPressed, 'true', 'center: matches, defaultPressed=true');
+  assert.equal(buttons[2].props?.defaultPressed, undefined, 'right: not selected, no injection');
+}
+
+// ---------------------------------------------------------------------------
+// Case 2: multi-value `defaultValue` array — all matching children pressed.
+// ---------------------------------------------------------------------------
+{
+  const file = scanner.project.createSourceFile(
+    fixturePath('toggle-group-multi-default.tsx'),
+    `
+      function Story() {
+        return (
+          <div defaultValue={["bold", "italic"]}>
+            <span value="bold" />
+            <span value="italic" />
+            <span value="underline" />
+          </div>
+        );
+      }
+      export { Story };
+    `,
+    { overwrite: true }
+  );
+
+  const tree = scanner.extractComponentJsxTree(file, 'Story');
+  assert.ok(tree && tree.type === 'element', 'Story tree must build');
+  const spans = findElementsByTag(tree, 'span');
+  assert.equal(spans.length, 3, `expected 3 spans, got ${spans.length}`);
+  assert.equal(spans[0].props?.defaultPressed, 'true', 'bold: matches');
+  assert.equal(spans[1].props?.defaultPressed, 'true', 'italic: matches');
+  assert.equal(spans[2].props?.defaultPressed, undefined, 'underline: no match');
+}
+
+// ---------------------------------------------------------------------------
+// Case 3: scalar `defaultValue` string — single match works.
+// ---------------------------------------------------------------------------
+{
+  const file = scanner.project.createSourceFile(
+    fixturePath('toggle-group-scalar-default.tsx'),
+    `
+      function Story() {
+        return (
+          <ul defaultValue="b">
+            <li value="a" />
+            <li value="b" />
+            <li value="c" />
+          </ul>
+        );
+      }
+      export { Story };
+    `,
+    { overwrite: true }
+  );
+
+  const tree = scanner.extractComponentJsxTree(file, 'Story');
+  assert.ok(tree && tree.type === 'element', 'Story tree must build');
+  const items = findElementsByTag(tree, 'li');
+  assert.equal(items[0].props?.defaultPressed, undefined, 'a: no match');
+  assert.equal(items[1].props?.defaultPressed, 'true', 'b: scalar string match');
+  assert.equal(items[2].props?.defaultPressed, undefined, 'c: no match');
+}
+
+// ---------------------------------------------------------------------------
+// Case 4: `value` (not `defaultValue`) also works — controlled-mode in
+// the runtime maps to the same selection-match logic statically.
+// ---------------------------------------------------------------------------
+{
+  const file = scanner.project.createSourceFile(
+    fixturePath('toggle-group-value-default.tsx'),
+    `
+      function Story() {
+        return (
+          <section value={["x"]}>
+            <article value="x" />
+            <article value="y" />
+          </section>
+        );
+      }
+      export { Story };
+    `,
+    { overwrite: true }
+  );
+
+  const tree = scanner.extractComponentJsxTree(file, 'Story');
+  assert.ok(tree && tree.type === 'element', 'Story tree must build');
+  const articles = findElementsByTag(tree, 'article');
+  assert.equal(articles[0].props?.defaultPressed, 'true', 'first: matches "value" prop');
+  assert.equal(articles[1].props?.defaultPressed, undefined, 'second: no match');
+}
+
+// ---------------------------------------------------------------------------
+// Case 5: explicit `defaultPressed` on the child wins — selection-match
+// MUST NOT override a deliberate consumer setting.
+// ---------------------------------------------------------------------------
+{
+  const file = scanner.project.createSourceFile(
+    fixturePath('toggle-group-explicit-pressed.tsx'),
+    `
+      function Story() {
+        return (
+          <div defaultValue={["a"]}>
+            <button value="a" defaultPressed={false} />
+            <button value="b" />
+          </div>
+        );
+      }
+      export { Story };
+    `,
+    { overwrite: true }
+  );
+
+  const tree = scanner.extractComponentJsxTree(file, 'Story');
+  assert.ok(tree && tree.type === 'element', 'Story tree must build');
+  const buttons = findElementsByTag(tree, 'button');
+  assert.equal(
+    String(buttons[0].props?.defaultPressed),
+    'false',
+    'explicit defaultPressed=false stays — selection-match must not override',
+  );
+  assert.equal(buttons[1].props?.defaultPressed, undefined, 'second: no match, no injection');
+}
+
+// ---------------------------------------------------------------------------
+// Case 6: no defaultValue/value on parent — no injection on any child.
+// ---------------------------------------------------------------------------
+{
+  const file = scanner.project.createSourceFile(
+    fixturePath('no-default-value.tsx'),
+    `
+      function Story() {
+        return (
+          <div>
+            <button value="a" />
+            <button value="b" />
+          </div>
+        );
+      }
+      export { Story };
+    `,
+    { overwrite: true }
+  );
+
+  const tree = scanner.extractComponentJsxTree(file, 'Story');
+  assert.ok(tree && tree.type === 'element', 'Story tree must build');
+  const buttons = findElementsByTag(tree, 'button');
+  assert.equal(buttons[0].props?.defaultPressed, undefined);
+  assert.equal(buttons[1].props?.defaultPressed, undefined);
+}
+
+console.log('selection-pressed-regression: PASS (6 cases)');