@1agh/maude 0.45.2 → 0.47.0

package/apps/studio/test/acp-session-allowed-tools.test.ts

@@ -0,0 +1,187 @@
+// DDR-184 (+ DDR-185, hardened per its security addendum) — the curated tool
+// allow-list the bridge auto-approves so the design workflow never stalls on
+// a per-edit / per-`maude` permission prompt (the "Manual mode blocks every
+// edit" complaint). Three things under test:
+//
+//   (1) WIRE contract — the list lands on `_meta.claudeCode.options.allowedTools`
+//       (SDK `allowedTools`, sdk.d.ts:1331), coexisting with the DDR-144
+//       `settingSources` narrowing and the DDR-143 `plugins` carrier. Same
+//       adapter/SDK-INTERNAL `_meta` path as acp-session-plugins.test.ts — a
+//       bump that stops forwarding it must fail HERE, not silently re-prompt.
+//   (2) SOURCE-OF-TRUTH guard — the Bash rules are EXACTLY `Bash(maude:*)`
+//       plus a closed read-only fs verb set (DDR-185) — nothing else. A
+//       security fan-out found the ORIGINAL DDR-185 cut's `Bash(agent-browser:*)`
+//       entry was a zero-confirmation session-hijack primitive (agent-browser's
+//       own bundled skill recommends a persistent, real-login Chrome profile)
+//       and `Bash(find:*)` was unrestricted command execution via `-exec`, not
+//       "mutation" as first characterized — both are cut, not patched, because
+//       neither residual is fixable via prefix-matching. `agent-browser` is
+//       now reached ONLY through the hardened `agent-browser-safe` verb
+//       (`Bash(maude:*)` covers it — no separate allow-list entry). If any of
+//       this drifts, this test fails loudly.
+//   (3) `WebSearch`/`WebFetch` (DDR-185) are present as bare native tool names
+//       — no prefix-matching involved, so no source-of-truth guard needed the
+//       way the Bash rules need one.
+
+import { describe, expect, test } from 'bun:test';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+import { MAUDE_DEFAULT_ALLOWED_TOOLS, newSessionParams } from '../acp/bridge.ts';
+import type { SdkPluginConfig } from '../acp/plugin-bootstrap.ts';
+
+type Meta = {
+  systemPrompt?: { append?: string };
+  claudeCode?: {
+    options?: {
+      allowedTools?: string[];
+      plugins?: SdkPluginConfig[];
+      settingSources?: string[];
+    };
+  };
+};
+
+const PLUGINS: SdkPluginConfig[] = [
+  { type: 'local', path: '/bundle/plugins/design', skipMcpDiscovery: true },
+];
+
+describe('newSessionParams — allowedTools carrier shape (DDR-184)', () => {
+  test('the allow-list rides _meta.claudeCode.options.allowedTools', () => {
+    const opts = (newSessionParams('/repo', undefined)._meta as Meta).claudeCode?.options;
+    expect(opts?.allowedTools).toEqual([...MAUDE_DEFAULT_ALLOWED_TOOLS]);
+  });
+
+  test('allowedTools is a COPY, not the shared module constant (no accidental mutation)', () => {
+    const opts = (newSessionParams('/repo')._meta as Meta).claudeCode?.options;
+    expect(opts?.allowedTools).not.toBe(MAUDE_DEFAULT_ALLOWED_TOOLS);
+  });
+
+  test('coexists with settingSources (DDR-144) and plugins (DDR-143) under one options', () => {
+    const opts = (newSessionParams('/repo', 'BRIEF', PLUGINS)._meta as Meta).claudeCode?.options;
+    expect(opts?.settingSources).toEqual(['user']);
+    expect(opts?.plugins).toEqual(PLUGINS);
+    expect(opts?.allowedTools).toEqual([...MAUDE_DEFAULT_ALLOWED_TOOLS]);
+  });
+
+  test('present even with no plugins (npm / web / power-user path)', () => {
+    const opts = (newSessionParams('/repo', 'BRIEF', [])._meta as Meta).claudeCode?.options;
+    expect(opts?.plugins).toBeUndefined();
+    expect(opts?.allowedTools).toEqual([...MAUDE_DEFAULT_ALLOWED_TOOLS]);
+  });
+});
+
+describe('MAUDE_DEFAULT_ALLOWED_TOOLS — source-of-truth guard (DDR-184 / DDR-062)', () => {
+  const bashRules = MAUDE_DEFAULT_ALLOWED_TOOLS.filter((t) => t.startsWith('Bash'));
+
+  test('the canvas-editing file tools are all present', () => {
+    for (const t of ['Read', 'Edit', 'Write', 'Glob', 'Grep', 'NotebookEdit']) {
+      expect(MAUDE_DEFAULT_ALLOWED_TOOLS).toContain(t);
+    }
+  });
+
+  test('WebSearch and WebFetch are present (DDR-185)', () => {
+    for (const t of ['WebSearch', 'WebFetch']) {
+      expect(MAUDE_DEFAULT_ALLOWED_TOOLS).toContain(t);
+    }
+  });
+
+  test('the Bash rules are EXACTLY this closed set — never a bare/un-scoped Bash', () => {
+    // A bare `Bash` (or `Bash(*)`) would auto-approve arbitrary command execution
+    // — exactly the blanket surface DDR-179 kept behind the prompt. Guard against
+    // anyone widening it: the list may auto-approve `maude` and the closed
+    // read-only fs verb set (DDR-185) — nothing else. In particular:
+    //   - `Bash(curl:*)` must NEVER appear — curl is routed through the
+    //     `curl-local` verb (covered by `Bash(maude:*)`) instead.
+    //   - `Bash(agent-browser:*)` must NEVER appear — a security fan-out found
+    //     it was a zero-confirmation session-hijack primitive; agent-browser is
+    //     routed through the `agent-browser-safe` verb instead.
+    //   - `Bash(find:*)` must NEVER appear — `find -exec` is unrestricted
+    //     command execution, not "mutation"; there is no verb substitute, it
+    //     is simply cut.
+    expect(bashRules).toEqual([
+      'Bash(maude:*)',
+      'Bash(ls:*)',
+      'Bash(cat:*)',
+      'Bash(pwd:*)',
+      'Bash(head:*)',
+      'Bash(tail:*)',
+      'Bash(wc:*)',
+      'Bash(tree:*)',
+      'Bash(file:*)',
+      'Bash(stat:*)',
+    ]);
+  });
+
+  test('the `maude` Bash rule is load-bearing on DDR-062: every design helper is a `maude design <verb>`', () => {
+    // Resolve cli/commands/design.mjs relative to this test file's real path
+    // (mirrors acp-session-plugins.test.ts's realpath dance for compiled roots).
+    const here = dirname(realpathSync(import.meta.url.replace('file://', '')));
+    const designCli = join(here, '..', '..', '..', 'cli', 'commands', 'design.mjs');
+    expect(existsSync(designCli)).toBe(true);
+    const src = readFileSync(designCli, 'utf8');
+    // The dispatch table the `Bash(maude:*)` scope rests on — helpers reached via
+    // `maude design <verb>`, not raw `bash <path>.sh` (DDR-062). If this marker
+    // disappears, the one-rule assumption needs re-checking.
+    expect(src).toContain('BIN_VERBS');
+    expect(src).toMatch(/maude design <verb>/);
+  });
+
+  test('the `curl-local` verb exists and is reached via `maude design <verb>` (DDR-185)', () => {
+    // The mechanism the `Bash(agent-browser:*)`/fs-list comment in bridge.ts
+    // promises for curl: real host enforcement via a first-party verb, not a
+    // Bash prefix rule. If this verb disappears from BIN_VERBS, the DDR-185
+    // curl story (and the bootstrap-brief nudge pointing at it) goes stale.
+    const here = dirname(realpathSync(import.meta.url.replace('file://', '')));
+    const designCli = join(here, '..', '..', '..', 'cli', 'commands', 'design.mjs');
+    const src = readFileSync(designCli, 'utf8');
+    expect(src).toMatch(/'curl-local'/);
+  });
+
+  test('the `agent-browser-safe` verb exists and is reached via `maude design <verb>` (DDR-185 security addendum)', () => {
+    // The replacement for the reverted `Bash(agent-browser:*)` entry — real
+    // subcommand/flag enforcement via a first-party verb, not a Bash prefix
+    // rule. If this verb disappears from BIN_VERBS, motion-critic.md/edit.md's
+    // documented raw agent-browser calls go back to prompting (not silently
+    // insecure — but the friction-reduction this DDR promises goes stale).
+    const here = dirname(realpathSync(import.meta.url.replace('file://', '')));
+    const designCli = join(here, '..', '..', '..', 'cli', 'commands', 'design.mjs');
+    const src = readFileSync(designCli, 'utf8');
+    expect(src).toMatch(/'agent-browser-safe'/);
+  });
+
+  test('plugin markdown no longer documents a RAW agent-browser SCREENSHOT/OPEN/NAVIGATE call (DDR-185 security addendum)', () => {
+    // motion-critic.md and edit.md are the two files that originally justified
+    // `Bash(agent-browser:*)` (raw calls not reached via `maude design <verb>`).
+    // screenshot/open/navigate now go through the hardened wrapper — a
+    // regression here means either those calls silently went back to
+    // prompting every time, or (worse) someone re-introduced a raw call the
+    // allow-list no longer covers. `eval` is the deliberate exception (round
+    // 3: removed from the wrapper's own allow-list entirely — arbitrary JS
+    // execution can't be argv-constrained — so it's EXPECTED to stay a raw,
+    // prompting `agent-browser eval` call; see both files' own comments).
+    const here = dirname(realpathSync(import.meta.url.replace('file://', '')));
+    const pluginsDir = join(here, '..', '..', '..', 'plugins', 'design');
+    for (const rel of ['agents/motion-critic.md', 'commands/edit.md']) {
+      const src = readFileSync(join(pluginsDir, rel), 'utf8');
+      expect(src).not.toMatch(/(?<!maude design )agent-browser (screenshot|open|navigate)\b/);
+      expect(src).toContain('agent-browser eval'); // deliberately raw — see comment above
+    }
+    // Only motion-critic.md actually calls the wrapper (for `screenshot`) —
+    // edit.md's sole agent-browser use was `eval`, which reverted fully to
+    // raw, so it has no `agent-browser-safe` invocation left at all.
+    const motionCritic = readFileSync(join(pluginsDir, 'agents/motion-critic.md'), 'utf8');
+    expect(motionCritic).toContain('maude design agent-browser-safe');
+  });
+
+  test('agent-browser-safe does NOT support eval (DDR-185 round-3 security addendum)', () => {
+    // A future accidental re-add of eval to the wrapper's own allow-list
+    // would silently reopen the zero-click session-hijack chain (ethical-
+    // hacker Finding 1: eval's fetch()/window.location defeat
+    // --allowed-domains entirely, and no argv check can constrain arbitrary
+    // JS execution). Source-of-truth guard against bridge.ts's own wrapper.
+    const here = dirname(realpathSync(import.meta.url.replace('file://', '')));
+    const wrapperPath = join(here, '..', 'bin', '_agent-browser-safe.mjs');
+    const src = readFileSync(wrapperPath, 'utf8');
+    expect(src).not.toMatch(/^\s*eval:\s*\[/m);
+  });
+});

package/apps/studio/test/annotations-snap.test.ts

@@ -5,6 +5,7 @@ import { describe, expect, test } from 'bun:test';
 import {
   computeSnap,
   GRID_PITCH_PX,
+  type GuideLineCandidate,
   SNAP_THRESHOLD_PX,
   type SnapBox,
 } from '../annotations-snap.ts';
@@ -77,3 +78,58 @@ describe('computeSnap', () => {
     expect(res.dy).toBe(0);
   });
 });
+
+// feature-1-artboard-kinds-foundation, T7 — generic-layout-guide lines feed
+// the same candidate pool as stroke/artboard bboxes.
+describe('computeSnap / guide lines (T7)', () => {
+  test('leading edge snaps to a guide line within threshold', () => {
+    const guideLines: GuideLineCandidate[] = [{ axis: 'x', at: 100, from: 0, to: 1000 }];
+    const res = computeSnap(box(104, 300), [], SNAP_THRESHOLD_PX, { guideLines });
+    expect(res.dx).toBe(-4);
+    expect(res.guides).toHaveLength(1);
+    expect(res.guides[0]).toMatchObject({ axis: 'x', at: 100, from: 0, to: 1000 });
+  });
+
+  test('center also tests against a guide line', () => {
+    // moving center x = 153, guide at 150 → dx -3.
+    const guideLines: GuideLineCandidate[] = [{ axis: 'y', at: 350, from: 0, to: 1000 }];
+    const res = computeSnap(box(103, 300), [], SNAP_THRESHOLD_PX, { guideLines });
+    // center y = 350, guide at 350 → dy 0 (exact), still emits a guide.
+    expect(res.dy).toBe(0);
+    expect(res.guides.find((g) => g.axis === 'y')).toMatchObject({ at: 350 });
+  });
+
+  test('nearest-wins applies across BOTH sources — a closer guide beats a farther candidate', () => {
+    const guideLines: GuideLineCandidate[] = [{ axis: 'x', at: 105, from: 0, to: 1000 }];
+    const res = computeSnap(box(104, 300), [box(100, 0)], SNAP_THRESHOLD_PX, { guideLines });
+    // candidate edge (100) is 4 away; guide (105) is 1 away — guide wins.
+    expect(res.dx).toBe(1);
+  });
+
+  test('a closer stroke/artboard candidate beats a farther guide line', () => {
+    // candidate edge (100) is 4 away from x=104; guide (110) is 6 away — the
+    // candidate is strictly closer, so it wins even though the guide is
+    // still within the 6px threshold.
+    const guideLines: GuideLineCandidate[] = [{ axis: 'x', at: 110, from: 0, to: 1000 }];
+    const res = computeSnap(box(104, 300), [box(100, 0)], SNAP_THRESHOLD_PX, { guideLines });
+    expect(res.dx).toBe(-4);
+  });
+
+  test('outside threshold, a guide line is ignored', () => {
+    const guideLines: GuideLineCandidate[] = [{ axis: 'x', at: 500, from: 0, to: 1000 }];
+    const res = computeSnap(box(104, 300), [], SNAP_THRESHOLD_PX, { guideLines });
+    expect(res.dx).toBe(0);
+    expect(res.guides).toHaveLength(0);
+  });
+
+  test('guide-line snap composes with the grid fallback on the OTHER axis', () => {
+    // x snaps to the guide line; y has no candidate → grid fallback fires.
+    const guideLines: GuideLineCandidate[] = [{ axis: 'x', at: 100, from: 0, to: 1000 }];
+    const res = computeSnap(box(104, 50), [], SNAP_THRESHOLD_PX, {
+      guideLines,
+      grid: GRID_PITCH_PX,
+    });
+    expect(res.dx).toBe(-4);
+    expect(res.dy).toBe(-2);
+  });
+});

package/apps/studio/test/artboard-guides-overlay.test.tsx

@@ -0,0 +1,152 @@
+// artboard-guides-overlay — feature-1-artboard-kinds-foundation, T4.
+// Registry contract + generic guides rendering. Pure renderToStaticMarkup —
+// this component has no hooks/context, so (unlike DCArtboard's own overlays)
+// it renders fully outside a live DesignCanvas.
+
+import { afterEach, describe, expect, test } from 'bun:test';
+
+import { renderToStaticMarkup } from 'react-dom/server';
+
+import {
+  __resetKindOverlayRegistryForTests,
+  ArtboardGuidesOverlay,
+  registerKindOverlay,
+} from '../artboard-guides-overlay.tsx';
+
+const RECT = { x: 10, y: 20, w: 400, h: 200 };
+
+afterEach(() => {
+  __resetKindOverlayRegistryForTests();
+});
+
+describe('ArtboardGuidesOverlay — generic guides', () => {
+  test('renders nothing with no guides and no registered kind content', () => {
+    const html = renderToStaticMarkup(
+      <ArtboardGuidesOverlay rect={RECT} kind="digital" visibility={{}} />
+    );
+    expect(html).toBe('');
+  });
+
+  test('positions the overlay at the artboard world rect', () => {
+    const html = renderToStaticMarkup(
+      <ArtboardGuidesOverlay
+        rect={RECT}
+        kind="print"
+        guides={{ grid: { size: 40 } }}
+        visibility={{ guides: true }}
+      />
+    );
+    expect(html).toMatch(/left:\s*10px/);
+    expect(html).toMatch(/top:\s*20px/);
+    expect(html).toMatch(/width:\s*400px/);
+    expect(html).toMatch(/height:\s*200px/);
+    expect(html).toContain('aria-hidden="true"');
+    expect(html).toContain('pointer-events:none');
+  });
+
+  test('visibility.guides === false suppresses the generic guides', () => {
+    const html = renderToStaticMarkup(
+      <ArtboardGuidesOverlay
+        rect={RECT}
+        kind="print"
+        guides={{ grid: { size: 40 } }}
+        visibility={{ guides: false }}
+      />
+    );
+    expect(html).toBe('');
+  });
+
+  test('columns render as one band per column, respecting margin/gutter', () => {
+    const html = renderToStaticMarkup(
+      <ArtboardGuidesOverlay
+        rect={RECT}
+        kind="web"
+        guides={{ columns: { count: 4, gutter: 10, margin: 20 } }}
+        visibility={{ guides: true }}
+      />
+    );
+    // usable = 400 - 2*20 = 360; (360 - 3*10) / 4 = 82.5px per column, 4 bands.
+    const bandCount = (html.match(/width:82\.5px/g) || []).length;
+    expect(bandCount).toBe(4);
+  });
+
+  // Security review (defender + adversarial pass, /flow:done on 0e001da7) —
+  // columns/rows `count` had no cap, unlike the grid path: a malicious/
+  // poisoned canvas (guides is an authored JSX prop, part of the DDR-054
+  // untrusted-canvas surface) could set `columns.count` to a huge number and
+  // mount one <div> per band, freezing the viewer's tab. Regression-tests the
+  // MAX_BANDS_PER_AXIS clamp both independent reviews confirmed as the fix.
+  test('a pathologically large column count is clamped, never a runaway render', () => {
+    const html = renderToStaticMarkup(
+      <ArtboardGuidesOverlay
+        rect={RECT}
+        kind="web"
+        guides={{ columns: { count: 1_000_000_000, gutter: 0, margin: 0 } }}
+        visibility={{ guides: true }}
+      />
+    );
+    const bandCount = (html.match(/position:absolute/g) || []).length - 1; // minus the wrapper div
+    expect(bandCount).toBeLessThanOrEqual(64);
+    expect(bandCount).toBeGreaterThan(0);
+  });
+
+  test('a pathologically large row count is clamped the same way', () => {
+    const html = renderToStaticMarkup(
+      <ArtboardGuidesOverlay
+        rect={RECT}
+        kind="web"
+        guides={{ rows: { count: 999_999_999, gutter: 0, margin: 0 } }}
+        visibility={{ guides: true }}
+      />
+    );
+    const bandCount = (html.match(/position:absolute/g) || []).length - 1;
+    expect(bandCount).toBeLessThanOrEqual(64);
+    expect(bandCount).toBeGreaterThan(0);
+  });
+
+  test('grid lines are capped, never runaway for a degenerate small size', () => {
+    const html = renderToStaticMarkup(
+      <ArtboardGuidesOverlay
+        rect={{ x: 0, y: 0, w: 5000, h: 5000 }}
+        kind="digital"
+        guides={{ grid: { size: 2 } }}
+        visibility={{ guides: true }}
+      />
+    );
+    const lineCount = (html.match(/width:1px/g) || []).length;
+    expect(lineCount).toBeLessThanOrEqual(400);
+  });
+});
+
+describe('ArtboardGuidesOverlay — per-kind registry', () => {
+  test('registered kind renderer is invoked with rect/kind/guides/visibility', () => {
+    let seen: unknown;
+    registerKindOverlay('print', (props) => {
+      seen = props;
+      return <div data-testid="print-bleed" />;
+    });
+    const html = renderToStaticMarkup(
+      <ArtboardGuidesOverlay rect={RECT} kind="print" visibility={{ bleed: true }} />
+    );
+    expect(html).toContain('data-testid="print-bleed"');
+    expect(seen).toMatchObject({ rect: RECT, kind: 'print', visibility: { bleed: true } });
+  });
+
+  test('a renderer registered for one kind does not fire for another', () => {
+    registerKindOverlay('web', () => <div data-testid="breakpoint-band" />);
+    const html = renderToStaticMarkup(
+      <ArtboardGuidesOverlay rect={RECT} kind="print" visibility={{}} />
+    );
+    expect(html).not.toContain('breakpoint-band');
+  });
+
+  test('re-registering the same kind replaces the previous renderer (HMR-safe)', () => {
+    registerKindOverlay('print', () => <div data-testid="v1" />);
+    registerKindOverlay('print', () => <div data-testid="v2" />);
+    const html = renderToStaticMarkup(
+      <ArtboardGuidesOverlay rect={RECT} kind="print" visibility={{}} />
+    );
+    expect(html).not.toContain('v1');
+    expect(html).toContain('v2');
+  });
+});

package/apps/studio/test/artboard-kinds.test.tsx

@@ -0,0 +1,83 @@
+// artboard-kinds — feature-1-artboard-kinds-foundation, T1/T2.
+//
+// DCArtboard rendered OUTSIDE a DesignCanvas (no WorldContext, no rect) takes
+// the specimen/legacy early-return branch — it still computes + emits the
+// resolved `data-dc-kind` attribute (readBackAttrs is built before the
+// `!ctx || !rect` check), so that resolution logic is testable via
+// renderToStaticMarkup without a live DOM/layout pass. The label-strip kind
+// chip (T3) only renders in the full DesignCanvas layout path (like the
+// video corner badge it sits beside) — covered by /design:smoke, not here
+// (see use-canvas-activity.test.tsx's header comment for the same split).
+
+import { describe, expect, test } from 'bun:test';
+
+import { renderToStaticMarkup } from 'react-dom/server';
+
+import { DCArtboard } from '../canvas-lib.tsx';
+
+// Minimal displayName-only stand-in for VideoComp — subtreeHasVideoComp
+// identity-matches OR falls back to `displayName === 'VideoComp'` (the same
+// fallback minified builds rely on), so this exercises the fallback path
+// without pulling in the real VideoComp's rendering/registration machinery.
+function FakeVideoComp() {
+  return null;
+}
+FakeVideoComp.displayName = 'VideoComp';
+
+describe('DCArtboard kind resolution (data-dc-kind readback)', () => {
+  test('absent kind, no video subtree ⇒ digital', () => {
+    const html = renderToStaticMarkup(
+      <DCArtboard id="a" label="A" width={100} height={100}>
+        hi
+      </DCArtboard>
+    );
+    expect(html).toContain('data-dc-kind="digital"');
+  });
+
+  test('explicit kind="print" is emitted verbatim', () => {
+    const html = renderToStaticMarkup(
+      <DCArtboard id="a" label="A" width={100} height={100} kind="print">
+        hi
+      </DCArtboard>
+    );
+    expect(html).toContain('data-dc-kind="print"');
+  });
+
+  test('explicit kind="web" is emitted verbatim', () => {
+    const html = renderToStaticMarkup(
+      <DCArtboard id="a" label="A" width={100} height={100} kind="web">
+        hi
+      </DCArtboard>
+    );
+    expect(html).toContain('data-dc-kind="web"');
+  });
+
+  test('absent kind + VideoComp subtree ⇒ video fallback (Design Decision 1)', () => {
+    const html = renderToStaticMarkup(
+      <DCArtboard id="a" label="A" width={100} height={100}>
+        <FakeVideoComp />
+      </DCArtboard>
+    );
+    expect(html).toContain('data-dc-kind="video"');
+  });
+
+  test('explicit kind="digital" supersedes a VideoComp subtree', () => {
+    const html = renderToStaticMarkup(
+      <DCArtboard id="a" label="A" width={100} height={100} kind="digital">
+        <FakeVideoComp />
+      </DCArtboard>
+    );
+    expect(html).toContain('data-dc-kind="digital"');
+  });
+
+  test('digital kind (default) carries no other resolved-kind attribute value', () => {
+    const html = renderToStaticMarkup(
+      <DCArtboard id="a" label="A" width={100} height={100}>
+        hi
+      </DCArtboard>
+    );
+    expect(html).not.toContain('data-dc-kind="print"');
+    expect(html).not.toContain('data-dc-kind="web"');
+    expect(html).not.toContain('data-dc-kind="video"');
+  });
+});

package/apps/studio/test/artboard-selection-attrs.test.ts

@@ -0,0 +1,69 @@
+// Dogfood follow-up (print artboards) — whole-ARTBOARD selections must carry
+// the DCArtboard readBack attrs (`data-dc-kind`, `data-dc-print`, `data-dc-
+// fixed`, `data-dc-bg`, …) in `Selection.attrs`, because the Inspector's
+// ArtboardKnobs panel pre-fills its Kind picker / paper preset / Hug toggle /
+// Style fields from exactly these. ATTR_SKIP deliberately hides `data-dc-*`
+// from the generic custom-attributes surface on ORDINARY elements — the bug
+// was that the blanket skip also applied to the artboard element itself, so
+// every readback silently fell back to its default ('digital', screen
+// presets, Hug, empty Bg) no matter what the artboard actually was.
+//
+// Same happy-dom + hoverTargetToSelection harness as knob-props-authored.
+
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import { GlobalRegistrator } from '@happy-dom/global-registrator';
+
+beforeAll(() => {
+  GlobalRegistrator.register();
+});
+afterAll(() => {
+  GlobalRegistrator.unregister();
+});
+
+import { hoverTargetToSelection } from '../dom-selection.ts';
+import type { HoverTarget } from '../input-router.tsx';
+
+function artboardSelection(attrsHtml: string) {
+  document.body.innerHTML = `<article class="dc-artboard" data-dc-screen="ab-1" ${attrsHtml}><div>content</div></article>`;
+  const el = document.querySelector('[data-dc-screen]') as HTMLElement;
+  const target: HoverTarget = { el, cdId: null, artboardId: 'ab-1' };
+  return hoverTargetToSelection(target);
+}
+
+describe('whole-artboard selection — data-dc-* readback attrs', () => {
+  test('data-dc-kind + data-dc-print reach Selection.attrs (the ArtboardKnobs payload)', () => {
+    const sel = artboardSelection(
+      'data-dc-kind="print" data-dc-print=\'{"paper":"a4","bleedMm":3}\''
+    );
+    expect(sel.attrs?.['data-dc-kind']).toBe('print');
+    expect(sel.attrs?.['data-dc-print']).toBe('{"paper":"a4","bleedMm":3}');
+  });
+
+  test('the other readback attrs come through too (fixed/bg/padding/layout/gap)', () => {
+    const sel = artboardSelection(
+      'data-dc-kind="digital" data-dc-fixed="true" data-dc-bg="var(--bg-1)" data-dc-padding="16" data-dc-layout="flex-col" data-dc-gap="8"'
+    );
+    expect(sel.attrs?.['data-dc-fixed']).toBe('true');
+    expect(sel.attrs?.['data-dc-bg']).toBe('var(--bg-1)');
+    expect(sel.attrs?.['data-dc-padding']).toBe('16');
+    expect(sel.attrs?.['data-dc-layout']).toBe('flex-col');
+    expect(sel.attrs?.['data-dc-gap']).toBe('8');
+  });
+
+  test('an ORDINARY element (no data-dc-screen) keeps the data-dc-* filter', () => {
+    document.body.innerHTML =
+      '<div data-cd-id="bbbbbbbb" data-dc-kind="print" data-custom="yes">x</div>';
+    const el = document.querySelector('[data-cd-id]') as HTMLElement;
+    const target: HoverTarget = { el, cdId: 'bbbbbbbb', artboardId: null };
+    const sel = hoverTargetToSelection(target);
+    // Engine plumbing stays hidden from the generic custom-attributes panel…
+    expect(sel.attrs?.['data-dc-kind']).toBeUndefined();
+    // …while genuinely custom attributes still surface.
+    expect(sel.attrs?.['data-custom']).toBe('yes');
+  });
+
+  test('data-dc-screen itself is included for the artboard (harmless, self-describing)', () => {
+    const sel = artboardSelection('data-dc-kind="print"');
+    expect(sel.attrs?.['data-dc-screen']).toBe('ab-1');
+  });
+});

package/apps/studio/test/browse-posture.test.tsx

@@ -0,0 +1,107 @@
+// browse-posture — feature-4 (browse/move split, DDR-187). The LOAD-BEARING
+// gate: a DOM-level proof that the boot-default `browse` tool is a pure native
+// pass-through (a real click handler under the cursor fires, nothing is
+// claimed), while the `move` (select) tool CLAIMS the same bare click (native
+// handler suppressed, onSelect dispatched). This promotes the input-router
+// comment-invariant ("bare clicks pass through") into an enforced test — the
+// canvas-origin-gate equivalent for the input posture.
+//
+// Needs a live DOM (capture-phase listeners + event dispatch + a real React
+// effect) — register happy-dom + drive a createRoot, same convention as
+// canvas-hmr-runtime.test.tsx / specimen-select.test.ts.
+
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import { GlobalRegistrator } from '@happy-dom/global-registrator';
+
+beforeAll(() => {
+  GlobalRegistrator.register();
+  (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+});
+afterAll(() => {
+  GlobalRegistrator.unregister();
+});
+
+import { act, useRef } from 'react';
+import { createRoot, type Root } from 'react-dom/client';
+
+import { type RouterCallbacks, type Tool, useInputRouter } from '../input-router.tsx';
+
+// A minimal host that mounts the router over a single native <button>. The
+// active tool is read fresh at event time via `getActiveTool` (a ref-backed
+// getter), so a test can flip the tool without re-rendering.
+function Harness({ getTool, callbacks }: { getTool: () => Tool; callbacks: RouterCallbacks }) {
+  const hostRef = useRef<HTMLDivElement | null>(null);
+  useInputRouter({ hostRef, getActiveTool: getTool, callbacks });
+  return (
+    <div ref={hostRef} className="dc-canvas">
+      <button type="button" id="native-btn">
+        Click me
+      </button>
+    </div>
+  );
+}
+
+function fireBareLeftClick(el: Element): void {
+  // The full native sequence the router gates: pointerdown → mousedown → click.
+  el.dispatchEvent(new MouseEvent('pointerdown', { bubbles: true, cancelable: true, button: 0 }));
+  el.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, cancelable: true, button: 0 }));
+  el.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, button: 0 }));
+}
+
+describe('browse tool — native pass-through (boot default)', () => {
+  test('bare click: native button handler FIRES, onSelect NOT dispatched', () => {
+    const el = document.createElement('div');
+    document.body.appendChild(el);
+    const root: Root = createRoot(el);
+    let selectCalls = 0;
+    let nativeClicks = 0;
+
+    act(() => {
+      root.render(
+        <Harness getTool={() => 'browse'} callbacks={{ onSelect: () => (selectCalls += 1) }} />
+      );
+    });
+
+    const btn = el.querySelector('#native-btn') as HTMLButtonElement;
+    btn.addEventListener('click', () => (nativeClicks += 1));
+    act(() => {
+      fireBareLeftClick(btn);
+    });
+
+    expect(selectCalls).toBe(0); // browse never selects
+    expect(nativeClicks).toBe(1); // the mock stays alive
+
+    act(() => root.unmount());
+    el.remove();
+  });
+});
+
+describe('move (select) tool — claims the bare click', () => {
+  test('bare click: native button handler SUPPRESSED, onSelect dispatched', () => {
+    const el = document.createElement('div');
+    document.body.appendChild(el);
+    const root: Root = createRoot(el);
+    let selectCalls = 0;
+    let nativeClicks = 0;
+
+    act(() => {
+      root.render(
+        <Harness getTool={() => 'move'} callbacks={{ onSelect: () => (selectCalls += 1) }} />
+      );
+    });
+
+    const btn = el.querySelector('#native-btn') as HTMLButtonElement;
+    btn.addEventListener('click', () => (nativeClicks += 1));
+    act(() => {
+      fireBareLeftClick(btn);
+    });
+
+    // Router claims the pointerdown (dispatches select) and swallows the
+    // synthetic click so the button under the cursor never activates.
+    expect(selectCalls).toBe(1);
+    expect(nativeClicks).toBe(0);
+
+    act(() => root.unmount());
+    el.remove();
+  });
+});