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

package/scanner/story-dimensioning-regression.ts

@@ -0,0 +1,298 @@
+import assert from 'node:assert/strict';
+import {
+  MOBILE_ONLY_DEFAULT_WIDTH,
+  VIEWPORT_HEIGHTS,
+  collectLeadingSpineClasses,
+  detectViewportHeightPattern,
+  mobileOnlyRootWidth,
+  treeHasDescendantClass,
+  treeHasPortalWithFullHeight,
+} from '../src/design-system/story-dimensioning';
+import type { JsxNode } from '../src/tailwind';
+import type { ComponentStory } from '../src/components';
+
+/**
+ * Regression: the story-dimensioning helpers decide the desktop width and
+ * height of every Story Layout frame. Drift here resizes every story
+ * differently — mobile-only nav stretches to 900px again (the "empty strip"
+ * bug), drawer sheets collapse to 0 height, full-page shells lose their
+ * synthetic viewport. Lock the heuristics.
+ *
+ * Extracted from `src/design-system/story-builder.ts` into
+ * `src/design-system/story-dimensioning.ts`. The Figma-API-touching entry
+ * points (resolveStoryLayoutWidth / Height) are exercised in real Figma
+ * during plugin runs — this fixture covers the pure detectors that decide
+ * which width/height bucket a story lands in.
+ */
+
+function el(props: Record<string, unknown>, children: JsxNode[] = []): JsxNode {
+  return { type: 'element', tagName: 'div', props, children } as unknown as JsxNode;
+}
+
+function story(jsxTree: JsxNode | null): ComponentStory {
+  return { name: 'TestStory', jsxTree } as unknown as ComponentStory;
+}
+
+// ---------------------------------------------------------------------------
+// collectLeadingSpineClasses — walks single-child spine, stops on fan-out
+// ---------------------------------------------------------------------------
+
+// Single-element spine: classes appear in the output.
+{
+  const out: string[] = [];
+  collectLeadingSpineClasses(el({ className: 'flex flex-col h-full' }), out);
+  assert.deepEqual(out, ['flex', 'flex-col', 'h-full'], 'root classes split + collected');
+}
+
+// Multi-level spine — each parent has exactly one element child.
+{
+  const out: string[] = [];
+  const tree = el({ className: 'outer' }, [el({ className: 'middle' }, [el({ className: 'inner' })])]);
+  collectLeadingSpineClasses(tree, out);
+  assert.deepEqual(out, ['outer', 'middle', 'inner'], 'spine walks through single-child wrappers');
+}
+
+// Fan-out stops the walk — siblings are body, not spine.
+{
+  const out: string[] = [];
+  const tree = el({ className: 'root' }, [
+    el({ className: 'child-a' }),
+    el({ className: 'child-b' }),
+  ]);
+  collectLeadingSpineClasses(tree, out);
+  assert.deepEqual(out, ['root'], 'fan-out stops the walk — sibling classes are body, not spine');
+}
+
+// Depth limit (>4) caps the walk so pathological deep wrappers don't hang.
+{
+  const out: string[] = [];
+  // Build 6 levels of single-child wrappers.
+  let leaf: JsxNode = el({ className: 'L5' });
+  for (let i = 4; i >= 0; i--) leaf = el({ className: 'L' + i }, [leaf]);
+  collectLeadingSpineClasses(leaf, out);
+  // 4 levels max → L0..L3 collected, L4/L5 dropped.
+  assert.deepEqual(out, ['L0', 'L1', 'L2', 'L3'], 'depth limit caps spine walk at 4 levels');
+}
+
+// Non-element / null / no className → no-op, no throw.
+{
+  const out: string[] = [];
+  collectLeadingSpineClasses(el({}), out);
+  assert.deepEqual(out, [], 'element without className contributes nothing');
+}
+
+// ---------------------------------------------------------------------------
+// treeHasDescendantClass — depth-limited descendant scan
+// ---------------------------------------------------------------------------
+
+assert.equal(
+  treeHasDescendantClass(el({ className: 'flex-1' }), 'flex-1'),
+  true,
+  'class on the root counts',
+);
+
+assert.equal(
+  treeHasDescendantClass(el({ className: 'flex' }, [el({ className: 'flex-1' })]), 'flex-1'),
+  true,
+  'class on a direct child is found',
+);
+
+assert.equal(
+  treeHasDescendantClass(el({ className: 'flex' }), 'flex-1'),
+  false,
+  'class absent — returns false (not undefined)',
+);
+
+// Depth limit (>6) — pathological deep tree without the class returns false
+// without throwing or hanging.
+{
+  let deep: JsxNode = el({ className: 'flex-1' });
+  for (let i = 0; i < 10; i++) deep = el({ className: 'wrapper' }, [deep]);
+  // The flex-1 is buried 10 levels deep; we cap at 6 so it should not be found.
+  assert.equal(
+    treeHasDescendantClass(deep, 'flex-1'),
+    false,
+    'depth limit (>6) prevents pathological deep scans from finding deeply-nested matches',
+  );
+}
+
+// ---------------------------------------------------------------------------
+// treeHasPortalWithFullHeight — portal anchor detection
+// ---------------------------------------------------------------------------
+
+// Portal with h-full + descendant flex-1 → true (Sheet content shape)
+{
+  const tree = el({}, [
+    el(
+      { __fromPortal: true, className: 'h-full' },
+      [el({ className: 'flex-1' })],
+    ),
+  ]);
+  assert.equal(
+    treeHasPortalWithFullHeight(tree),
+    true,
+    'portal subtree with h-full + descendant flex-1 must trigger drawer-height pattern',
+  );
+}
+
+// inset-y-0 also qualifies (sheet content variant)
+{
+  const tree = el({}, [
+    el(
+      { __fromPortal: true, className: 'inset-y-0 absolute' },
+      [el({ className: 'flex-1' })],
+    ),
+  ]);
+  assert.equal(
+    treeHasPortalWithFullHeight(tree),
+    true,
+    'portal subtree with inset-y-0 + descendant flex-1 also triggers drawer-height',
+  );
+}
+
+// Portal without flex-1 descendant → false (no grow cascade to fill)
+{
+  const tree = el({}, [
+    el({ __fromPortal: true, className: 'h-full' }, [el({ className: 'p-4' })]),
+  ]);
+  assert.equal(
+    treeHasPortalWithFullHeight(tree),
+    false,
+    'portal without descendant flex-1 must not trigger drawer-height — nothing would fill',
+  );
+}
+
+// Portal without h-full → false (no anchor intent)
+{
+  const tree = el({}, [
+    el({ __fromPortal: true, className: 'p-4' }, [el({ className: 'flex-1' })]),
+  ]);
+  assert.equal(
+    treeHasPortalWithFullHeight(tree),
+    false,
+    'portal without h-full/h-screen/inset-y-0 is not a viewport anchor',
+  );
+}
+
+// Non-portal h-full + flex-1 → false (this case is handled by the spine-h-full
+// path in detectViewportHeightPattern, not the portal path)
+{
+  const tree = el({ className: 'h-full' }, [el({ className: 'flex-1' })]);
+  assert.equal(
+    treeHasPortalWithFullHeight(tree),
+    false,
+    '__fromPortal must be true — spine h-full is a separate signal path',
+  );
+}
+
+// ---------------------------------------------------------------------------
+// detectViewportHeightPattern — bucket selection
+// ---------------------------------------------------------------------------
+
+// h-screen on the spine → FULL_PAGE (900).
+assert.equal(
+  detectViewportHeightPattern(story(el({ className: 'h-screen' })), []),
+  VIEWPORT_HEIGHTS.FULL_PAGE,
+  'h-screen on the spine triggers FULL_PAGE (900)',
+);
+
+// min-h-screen on the spine → FULL_PAGE.
+assert.equal(
+  detectViewportHeightPattern(story(el({ className: 'min-h-screen' })), []),
+  VIEWPORT_HEIGHTS.FULL_PAGE,
+  'min-h-screen on the spine triggers FULL_PAGE',
+);
+
+// h-full + flex-col on spine + descendant flex-1 → DRAWER (700).
+{
+  const tree = el({ className: 'h-full flex flex-col' }, [
+    el({ className: 'h-12' }),
+    el({ className: 'flex-1' }),
+  ]);
+  assert.equal(
+    detectViewportHeightPattern(story(tree), []),
+    VIEWPORT_HEIGHTS.DRAWER,
+    'h-full + flex-col + descendant flex-1 triggers DRAWER (700)',
+  );
+}
+
+// h-full alone without flex-col → null (not a drawer)
+assert.equal(
+  detectViewportHeightPattern(
+    story(el({ className: 'h-full' }, [el({ className: 'flex-1' })])),
+    [],
+  ),
+  null,
+  'h-full without flex-col on the spine does not trigger drawer height — needs the vertical-flex commitment',
+);
+
+// Layout classes (decorator wrapper) also contribute to spine detection.
+assert.equal(
+  detectViewportHeightPattern(story(el({})), ['h-screen']),
+  VIEWPORT_HEIGHTS.FULL_PAGE,
+  'layoutClasses from the story decorator wrapper feed into spine detection',
+);
+
+// No viewport anchor → null.
+assert.equal(
+  detectViewportHeightPattern(story(el({ className: 'p-4' })), []),
+  null,
+  'plain story without viewport-anchor classes returns null — natural content height',
+);
+
+// Null jsxTree → null without throw.
+assert.equal(
+  detectViewportHeightPattern(story(null), []),
+  null,
+  'null tree is tolerated (no jsxTree from scanner) — returns null',
+);
+
+// ---------------------------------------------------------------------------
+// mobileOnlyRootWidth — {bp}:hidden detection
+// ---------------------------------------------------------------------------
+
+// md:hidden on the root → mobile width
+assert.equal(
+  mobileOnlyRootWidth(story(el({ className: 'md:hidden flex' })), []),
+  MOBILE_ONLY_DEFAULT_WIDTH,
+  'md:hidden on the root signals mobile-only design',
+);
+
+// sm/lg/xl/2xl:hidden all qualify
+for (const bp of ['sm', 'lg', 'xl', '2xl'] as const) {
+  assert.equal(
+    mobileOnlyRootWidth(story(el({ className: bp + ':hidden' })), []),
+    MOBILE_ONLY_DEFAULT_WIDTH,
+    `${bp}:hidden on the root signals mobile-only design`,
+  );
+}
+
+// Layout classes alone qualify (decorator-only mobile-only design)
+assert.equal(
+  mobileOnlyRootWidth(story(el({})), ['md:hidden']),
+  MOBILE_ONLY_DEFAULT_WIDTH,
+  'mobile-only signal can come from layoutClasses too',
+);
+
+// No hidden class → null
+assert.equal(
+  mobileOnlyRootWidth(story(el({ className: 'flex' })), []),
+  null,
+  'no breakpoint-hidden class returns null — desktop default applies',
+);
+
+// `hidden` alone (no breakpoint) → null (that's a full hide, not mobile-only)
+assert.equal(
+  mobileOnlyRootWidth(story(el({ className: 'hidden' })), []),
+  null,
+  'plain `hidden` (no breakpoint prefix) is not a mobile-only signal',
+);
+
+// Null tree but layoutClasses present → still works
+assert.equal(
+  mobileOnlyRootWidth(story(null), ['xl:hidden']),
+  MOBILE_ONLY_DEFAULT_WIDTH,
+  'null tree falls back to layoutClasses scan',
+);
+
+console.log('story-dimensioning-regression: PASS');

package/scanner/story-render-strategy-regression.ts

@@ -0,0 +1,205 @@
+import assert from 'node:assert/strict';
+import {
+  INSTANCE_FALLBACK_COMPONENTS,
+  exceedsStoryJsxComplexityLimits,
+  shouldPreferInstanceRendering,
+  shouldSkipStoryJsxTree,
+} from '../src/design-system/story-render-strategy';
+import type { JsxNode } from '../src/tailwind';
+import type { ComponentDef, ComponentStory } from '../src/components';
+
+/**
+ * Regression: the story-render-strategy module decides whether each story
+ * renders as a tree (full JSX expansion) or as a symbol instance. Three
+ * decision points:
+ *
+ *  - `exceedsStoryJsxComplexityLimits` — the budget guard (320 nodes / 36
+ *    depth / 1800 class tokens). Blowing one of these silently in a refactor
+ *    would make the plugin chew on pathological trees and freeze Figma.
+ *  - `shouldSkipStoryJsxTree` — combines the budget guard with the explicit
+ *    fallback list (currently just `switch`).
+ *  - `shouldPreferInstanceRendering` — CVA / state matrix preference.
+ *
+ * Extracted from `src/design-system/story-builder.ts` into
+ * `src/design-system/story-render-strategy.ts`.
+ */
+
+function el(props: Record<string, unknown> = {}, children: JsxNode[] = []): JsxNode {
+  return { type: 'element', tagName: 'div', props, children } as unknown as JsxNode;
+}
+
+function story(jsxTree: JsxNode | null, instances?: unknown[]): ComponentStory {
+  return { name: 'TestStory', jsxTree, instances: instances ?? [] } as unknown as ComponentStory;
+}
+
+function def(overrides: Partial<ComponentDef> & { name: string }): ComponentDef {
+  return { type: 'simple', stories: [], ...overrides } as ComponentDef;
+}
+
+// ---------------------------------------------------------------------------
+// INSTANCE_FALLBACK_COMPONENTS — the explicit fallback list
+// ---------------------------------------------------------------------------
+
+assert.equal(
+  INSTANCE_FALLBACK_COMPONENTS.has('switch'),
+  true,
+  'switch must be on the fallback list — its indicator slot is hard to reconstruct from a JSX tree',
+);
+
+// Membership is canonical (no other accidental entries that would change rendering for unrelated components).
+assert.equal(
+  INSTANCE_FALLBACK_COMPONENTS.size,
+  1,
+  'fallback list size — adding a new entry is an intentional decision; bump this assertion alongside the addition',
+);
+
+// ---------------------------------------------------------------------------
+// exceedsStoryJsxComplexityLimits — node / depth / class-token limits
+// ---------------------------------------------------------------------------
+
+// Null / undefined / non-tree inputs return false (defensive).
+assert.equal(exceedsStoryJsxComplexityLimits(null), false, 'null tree is under budget');
+assert.equal(exceedsStoryJsxComplexityLimits(undefined), false, 'undefined tree is under budget');
+
+// Simple small tree → under budget.
+{
+  const tree = el({}, [el({ className: 'p-4' }), el({ className: 'text-sm' })]);
+  assert.equal(
+    exceedsStoryJsxComplexityLimits(tree),
+    false,
+    'a 3-node tree with 2 class tokens is well under budget',
+  );
+}
+
+// Tree with >320 nodes → exceeds budget.
+{
+  const root = el({}, []);
+  const rootChildren = (root as unknown as { children: JsxNode[] }).children;
+  for (let i = 0; i < 400; i++) rootChildren.push(el({ className: 'x' }));
+  assert.equal(
+    exceedsStoryJsxComplexityLimits(root),
+    true,
+    'tree with 400+ nodes exceeds STORY_JSX_NODE_LIMIT (320)',
+  );
+}
+
+// Tree depth >36 → exceeds budget.
+{
+  let deep: JsxNode = el({});
+  for (let i = 0; i < 40; i++) deep = el({}, [deep]);
+  assert.equal(
+    exceedsStoryJsxComplexityLimits(deep),
+    true,
+    'tree depth >36 exceeds STORY_JSX_DEPTH_LIMIT',
+  );
+}
+
+// Tree with >1800 class tokens → exceeds budget.
+{
+  // 5 children each with a className containing ~400 tokens → 2000 total tokens.
+  const wideClass = Array.from({ length: 400 }, (_, i) => `c${i}`).join(' ');
+  const root = el({ className: 'root' }, [
+    el({ className: wideClass }),
+    el({ className: wideClass }),
+    el({ className: wideClass }),
+    el({ className: wideClass }),
+    el({ className: wideClass }),
+  ]);
+  assert.equal(
+    exceedsStoryJsxComplexityLimits(root),
+    true,
+    'tree with >1800 class tokens exceeds STORY_JSX_CLASS_TOKEN_LIMIT',
+  );
+}
+
+// Modest tree right at the edge → under budget.
+{
+  // 100 children with 10 class tokens each = 1000 class tokens — well under 1800.
+  const root = el({}, []);
+  const rootChildren = (root as unknown as { children: JsxNode[] }).children;
+  for (let i = 0; i < 100; i++) {
+    rootChildren.push(el({ className: 'a b c d e f g h i j' }));
+  }
+  assert.equal(
+    exceedsStoryJsxComplexityLimits(root),
+    false,
+    'a 101-node tree with 1000 class tokens is under all three limits',
+  );
+}
+
+// ---------------------------------------------------------------------------
+// shouldSkipStoryJsxTree — fallback list + complexity guard combined
+// ---------------------------------------------------------------------------
+
+// No tree → no skip needed (the tree path won't run anyway).
+assert.equal(
+  shouldSkipStoryJsxTree(def({ name: 'Button' }), story(null)),
+  false,
+  'no jsxTree → no skip decision needed',
+);
+
+// Tree present, def on fallback list → skip.
+assert.equal(
+  shouldSkipStoryJsxTree(def({ name: 'switch' }), story(el({}))),
+  true,
+  'fallback-list def with tree must skip tree rendering',
+);
+
+// Tree present, simple component, small tree → do not skip.
+assert.equal(
+  shouldSkipStoryJsxTree(def({ name: 'Button' }), story(el({ className: 'p-4' }))),
+  false,
+  'simple component with small tree must NOT skip — tree rendering wins for fidelity',
+);
+
+// Tree present, simple component, oversized tree → skip due to complexity.
+{
+  const root = el({}, []);
+  const rootChildren = (root as unknown as { children: JsxNode[] }).children;
+  for (let i = 0; i < 400; i++) rootChildren.push(el({}));
+  assert.equal(
+    shouldSkipStoryJsxTree(def({ name: 'Button' }), story(root)),
+    true,
+    'oversized tree must skip even for normal components',
+  );
+}
+
+// ---------------------------------------------------------------------------
+// shouldPreferInstanceRendering — CVA / state matrix preference
+// ---------------------------------------------------------------------------
+
+// No def or no story → false (defensive).
+assert.equal(
+  shouldPreferInstanceRendering(null as unknown as ComponentDef, story(null)),
+  false,
+  'null def returns false defensively',
+);
+
+// Empty defName → false.
+assert.equal(
+  shouldPreferInstanceRendering(def({ name: '' }), story(null)),
+  false,
+  'def without name returns false',
+);
+
+// CVA component with no matching instance → false (nothing to render as instance).
+assert.equal(
+  shouldPreferInstanceRendering(
+    def({ name: 'Button', type: 'cva' }),
+    story(null, [{ componentName: 'OtherComponent' }]),
+  ),
+  false,
+  'CVA def whose story has no matching instance returns false (no instance to render)',
+);
+
+// Switch is on the fallback list — even with matching instance, preference is false (uses different path).
+assert.equal(
+  shouldPreferInstanceRendering(
+    def({ name: 'switch', type: 'state' }),
+    story(null, [{ componentName: 'switch', props: {} }]),
+  ),
+  false,
+  'switch is on the fallback list and should never prefer instance rendering — uses its own path',
+);
+
+console.log('story-render-strategy-regression: PASS');

package/scanner/stretch-to-parent-width-regression.ts

@@ -0,0 +1,147 @@
+import assert from 'node:assert/strict';
+
+import { shouldStretchToParentWidth } from '../src/layout/width-solver';
+
+/**
+ * Regression: `shouldStretchToParentWidth(tag, classes)` decides whether a
+ * block-level element should layoutAlign=STRETCH inside a VERTICAL parent
+ * — the rule that turns a `<section>` into a full-width hero banner.
+ *
+ * The bug class: every "explicit width" predicate in the plugin must agree
+ * on what counts as explicit. `hasExplicitSize` understood `size-N` /
+ * `size-full`. `shouldStretchToParentWidth` didn't — so a `<div
+ * className="size-10 rounded-full">` (the shadcn Avatar.Root) got
+ * STRETCH'd to 900px-wide-pill inside a VERTICAL story root, while the
+ * generic-element depth=0 override correctly left it alone. Two
+ * independent predicates, two different answers, one broken Avatar.
+ *
+ * This file locks the predicate so any future drift triggers a fixture
+ * failure instead of a Figma rendering regression.
+ */
+
+// Block tag with no width signal → STRETCH (default block behaviour).
+assert.equal(
+  shouldStretchToParentWidth('div', ['flex', 'gap-4']),
+  true,
+  'plain div with layout classes → stretches to parent width',
+);
+assert.equal(
+  shouldStretchToParentWidth('section', ['bg-card']),
+  true,
+  'plain section → stretches',
+);
+
+// Inline tags — never stretch.
+assert.equal(
+  shouldStretchToParentWidth('span', ['flex']),
+  false,
+  'span (non-BLOCK_TAG) does not stretch',
+);
+
+// Out-of-flow positioning — never stretch.
+assert.equal(
+  shouldStretchToParentWidth('div', ['absolute', 'inset-0']),
+  false,
+  'absolute-positioned div does not stretch',
+);
+
+// Explicit width — never stretch.
+assert.equal(
+  shouldStretchToParentWidth('div', ['w-10']),
+  false,
+  'w-N suppresses stretch',
+);
+assert.equal(
+  shouldStretchToParentWidth('div', ['w-[200px]']),
+  false,
+  'arbitrary w-[N] suppresses stretch',
+);
+assert.equal(
+  shouldStretchToParentWidth('div', ['max-w-md']),
+  false,
+  'max-w-* suppresses stretch (caps width)',
+);
+assert.equal(
+  shouldStretchToParentWidth('div', ['min-w-0']),
+  false,
+  'min-w-* suppresses stretch',
+);
+
+// self-* — never stretch (explicit alignment trumps).
+assert.equal(
+  shouldStretchToParentWidth('div', ['self-start']),
+  false,
+  'self-* alignment suppresses stretch',
+);
+
+// size-N (the regression case) — must NOT stretch. This used to slip
+// through because the bailout only checked `w-*`. Result: shadcn
+// `<Avatar className="size-10 ...">` rendered as a 900-wide pill at
+// story root.
+assert.equal(
+  shouldStretchToParentWidth('div', ['relative', 'flex', 'size-10', 'shrink-0', 'overflow-hidden', 'rounded-full']),
+  false,
+  'size-N (Avatar.Root pattern) must suppress stretch — was the FallbackOnly bug',
+);
+assert.equal(
+  shouldStretchToParentWidth('div', ['size-8']),
+  false,
+  'size-8 alone suppresses stretch',
+);
+assert.equal(
+  shouldStretchToParentWidth('div', ['size-[40px]']),
+  false,
+  'arbitrary size-[N] suppresses stretch',
+);
+
+// Inline displays — never stretch.
+assert.equal(
+  shouldStretchToParentWidth('div', ['inline-flex']),
+  false,
+  'inline-flex suppresses stretch',
+);
+
+// Note: `size-full` is normalised by `splitClassName` into `w-full h-full`
+// before it reaches this predicate, so it never appears here as a token.
+// Its suppression is exercised via the `w-full` case below.
+assert.equal(
+  shouldStretchToParentWidth('div', ['w-full', 'h-full']),
+  false,
+  'w-full suppresses stretch (the post-normalisation form of size-full)',
+);
+
+// DropdownMenuItem class shape: scanner emits these wrappers as
+// `kind: 'component'` with tagName `DropdownMenuPrimitive.Item`. The
+// ui-builder wrapperFrame branch calls `shouldStretchToParentWidth('div',
+// classes)` to mirror the kind:'element' decision — without it, items
+// inside a `w-56` Content stay HUG-width. Lock the predicate so the call
+// site keeps producing true for the canonical Item / Label class lists.
+assert.equal(
+  shouldStretchToParentWidth('div', [
+    'focus:bg-accent', 'focus:text-accent-foreground',
+    'relative', 'flex', 'cursor-default', 'items-center', 'gap-2',
+    'rounded-sm', 'px-2', 'py-1.5', 'text-sm',
+    'data-[disabled]:opacity-50', 'data-[inset]:pl-8',
+  ]),
+  true,
+  'DropdownMenuItem class list → stretches in vertical block-flow parent',
+);
+assert.equal(
+  shouldStretchToParentWidth('div', [
+    'px-2', 'py-1.5', 'text-sm', 'font-medium', 'data-[inset]:pl-8',
+  ]),
+  true,
+  'DropdownMenuLabel class list → stretches in vertical block-flow parent',
+);
+// DropdownMenuContent itself has `min-w-[8rem]` which IS a width signal —
+// so Content does NOT stretch (the consumer's `w-56` sets its width
+// instead). Lock that boundary.
+assert.equal(
+  shouldStretchToParentWidth('div', [
+    'bg-popover', 'min-w-[8rem]', 'rounded-md', 'border', 'p-1', 'shadow-md',
+  ]),
+  false,
+  'DropdownMenuContent (min-w-* present) → does NOT stretch — consumer width wins',
+);
+
+console.log('stretch-to-parent-width-regression: PASS (17 cases)');