@1agh/maude 0.45.2 → 0.47.0

package/apps/studio/test/canvas-hide-chrome.test.ts

@@ -0,0 +1,58 @@
+// canvas-hide-chrome.test.ts — regression guard for RCA
+// issue-pdf-print-export-marks-missing (Bug A). `_shell.html`'s
+// `#canvas-hide-chrome` style block is the sanctioned "never leaks into an
+// export" list every exporter relies on (`?hide-chrome=1` flips it from
+// `media="not all"` to `media="all"` — see exporters/index.ts
+// canvasShellUrl()). `.dc-artboard-guides` (the print bleed/trim/margin guide
+// overlay, artboard-guides-overlay.tsx) was never added to this list when
+// feature-2-print-artboards shipped, so it rendered straight into every PDF/
+// PNG/SVG capture whenever a canvas had it toggled on. Grep-based, mirrors
+// shell-importmap.test.ts's own style for the same file.
+
+import { describe, expect, test } from 'bun:test';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { DEV_SERVER_ROOT } from '../paths.ts';
+
+const SHELL_HTML_PATH = join(
+  DEV_SERVER_ROOT,
+  '..',
+  '..',
+  'plugins',
+  'design',
+  'templates',
+  '_shell.html'
+);
+
+describe('_shell.html #canvas-hide-chrome covers every overlay mount class', () => {
+  const shellHtml = readFileSync(SHELL_HTML_PATH, 'utf8');
+  const blockMatch = shellHtml.match(/<style id="canvas-hide-chrome"[^>]*>([\s\S]*?)<\/style>/);
+
+  test('the #canvas-hide-chrome style block exists', () => {
+    expect(blockMatch).not.toBeNull();
+  });
+
+  const block = blockMatch?.[1] ?? '';
+
+  // Every editor-chrome overlay class that must never leak into a capture
+  // render. `.dc-artboard-guides` is the one this RCA adds; the rest already
+  // guard against the same class of regression for their own overlays.
+  const REQUIRED_SELECTORS = [
+    '.dc-mm',
+    '.dc-tool-palette',
+    '.dc-participants',
+    '.dc-cv-halo',
+    '.dc-snap-guide',
+    '.dc-annot-svg',
+    '.cm-layer',
+    '.dc-artboard-label',
+    '.dc-artboard-guides',
+  ];
+
+  for (const selector of REQUIRED_SELECTORS) {
+    test(`"${selector}" is hidden during capture`, () => {
+      expect(block.includes(selector)).toBe(true);
+    });
+  }
+});

package/apps/studio/test/canvas-meta-api.test.ts

@@ -357,3 +357,240 @@ describe('/_api/canvas-meta — GET/PATCH (DDR-115 camera split)', () => {
     }
   });
 });
+
+// feature-1-artboard-kinds-foundation, T6 — per-user overlay-visibility lane.
+// Same camera-split contract as `viewport` above: `overlays` lives ONLY in the
+// gitignored per-machine view file, never the versioned `.meta.json`.
+describe('/_api/canvas-meta — overlays lane (T6)', () => {
+  test('PATCH overlays leaves meta byte-unchanged + writes the view file', async () => {
+    const { root, designRoot } = makeSandbox();
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      mkdirSync(join(designRoot, 'ui'), { recursive: true });
+      const tsxAbs = join(designRoot, 'ui', 'Overlays.tsx');
+      writeFileSync(tsxAbs, 'export default function O(){return <main/>}\n');
+      const metaAbs = tsxAbs.replace(/\.tsx$/, '.meta.json');
+      writeFileSync(metaAbs, JSON.stringify({ title: 'Overlays', sections: [] }));
+      const before = readFileSync(metaAbs, 'utf8');
+      const file = repoRel(designRoot, tsxAbs);
+
+      const r = await fetch(`http://localhost:${port}/_api/canvas-meta`, {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ file, patch: { overlays: { guides: true } } }),
+      });
+      expect(r.status).toBe(200);
+      const merged = (await r.json()) as MetaShape;
+      expect(merged.overlays).toEqual({ guides: true });
+
+      // KEYSTONE — versioned meta is byte-identical; no last_modified bump.
+      expect(readFileSync(metaAbs, 'utf8')).toBe(before);
+
+      const vAbs = viewPath(designRoot, 'ui-overlays');
+      expect(existsSync(vAbs)).toBe(true);
+      const view = JSON.parse(readFileSync(vAbs, 'utf8'));
+      expect(view.overlays).toEqual({ guides: true });
+    } finally {
+      await killProc(proc);
+    }
+  });
+
+  test('absent overlays key resolves to hidden (T6 Gotcha — old view files default off)', async () => {
+    const { root, designRoot } = makeSandbox();
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      mkdirSync(join(designRoot, 'ui'), { recursive: true });
+      const tsxAbs = join(designRoot, 'ui', 'NoOverlays.tsx');
+      writeFileSync(tsxAbs, 'export default function N(){return <main/>}\n');
+      writeFileSync(tsxAbs.replace(/\.tsx$/, '.meta.json'), JSON.stringify({ title: 'N' }));
+      const file = repoRel(designRoot, tsxAbs);
+
+      const r = await fetch(
+        `http://localhost:${port}/_api/canvas-meta?file=${encodeURIComponent(file)}`
+      );
+      const m = (await r.json()) as MetaShape;
+      expect(m.overlays).toBeUndefined();
+    } finally {
+      await killProc(proc);
+    }
+  });
+
+  test('PATCH overlays merges with an existing viewport in the SAME view file', async () => {
+    const { root, designRoot } = makeSandbox();
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      mkdirSync(join(designRoot, 'ui'), { recursive: true });
+      const tsxAbs = join(designRoot, 'ui', 'Both.tsx');
+      writeFileSync(tsxAbs, 'export default function B(){return <main/>}\n');
+      writeFileSync(tsxAbs.replace(/\.tsx$/, '.meta.json'), JSON.stringify({ title: 'B' }));
+      const file = repoRel(designRoot, tsxAbs);
+
+      await fetch(`http://localhost:${port}/_api/canvas-meta`, {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ file, patch: { viewport: { x: 3, y: 4, zoom: 1 } } }),
+      });
+      const r = await fetch(`http://localhost:${port}/_api/canvas-meta`, {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ file, patch: { overlays: { guides: true } } }),
+      });
+      const merged = (await r.json()) as MetaShape;
+      // Both lanes present — writing overlays didn't clobber the viewport.
+      expect(merged.viewport).toEqual({ x: 3, y: 4, zoom: 1 });
+      expect(merged.overlays).toEqual({ guides: true });
+
+      const view = JSON.parse(readFileSync(viewPath(designRoot, 'ui-both'), 'utf8'));
+      expect(view.viewport).toEqual({ x: 3, y: 4, zoom: 1 });
+      expect(view.overlays).toEqual({ guides: true });
+    } finally {
+      await killProc(proc);
+    }
+  });
+
+  test('PATCH overlays shallow-merges keys — a later patch keeps an earlier key', async () => {
+    const { root, designRoot } = makeSandbox();
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      mkdirSync(join(designRoot, 'ui'), { recursive: true });
+      const tsxAbs = join(designRoot, 'ui', 'Merge2.tsx');
+      writeFileSync(tsxAbs, 'export default function M(){return <main/>}\n');
+      writeFileSync(tsxAbs.replace(/\.tsx$/, '.meta.json'), JSON.stringify({ title: 'M' }));
+      const file = repoRel(designRoot, tsxAbs);
+
+      await fetch(`http://localhost:${port}/_api/canvas-meta`, {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ file, patch: { overlays: { guides: true } } }),
+      });
+      const r = await fetch(`http://localhost:${port}/_api/canvas-meta`, {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        // A downstream plan (print) toggling ITS OWN key shouldn't erase `guides`.
+        body: JSON.stringify({ file, patch: { overlays: { bleed: true } } }),
+      });
+      const merged = (await r.json()) as MetaShape;
+      expect(merged.overlays).toEqual({ guides: true, bleed: true });
+    } finally {
+      await killProc(proc);
+    }
+  });
+
+  test('PATCH ignores a malformed overlays bag (non-boolean value) — silent no-op', async () => {
+    const { root, designRoot } = makeSandbox();
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      mkdirSync(join(designRoot, 'ui'), { recursive: true });
+      const tsxAbs = join(designRoot, 'ui', 'Malformed.tsx');
+      writeFileSync(tsxAbs, 'export default function X(){return <main/>}\n');
+      writeFileSync(tsxAbs.replace(/\.tsx$/, '.meta.json'), JSON.stringify({ title: 'X' }));
+      const file = repoRel(designRoot, tsxAbs);
+
+      const r = await fetch(`http://localhost:${port}/_api/canvas-meta`, {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ file, patch: { overlays: { guides: 'yes' } } }),
+      });
+      expect(r.status).toBe(200);
+      const merged = (await r.json()) as MetaShape;
+      expect(merged.overlays).toBeUndefined();
+      expect(existsSync(viewPath(designRoot, 'ui-malformed'))).toBe(false);
+    } finally {
+      await killProc(proc);
+    }
+  });
+
+  test('PATCH overlays on a non-existent canvas is refused (404), mints no file', async () => {
+    const { root, designRoot } = makeSandbox();
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      mkdirSync(join(designRoot, 'ui'), { recursive: true });
+      const file = '.design/ui/GhostOverlays.tsx';
+      const r = await fetch(`http://localhost:${port}/_api/canvas-meta`, {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ file, patch: { overlays: { guides: true } } }),
+      });
+      expect(r.status).toBe(404);
+      expect(existsSync(viewPath(designRoot, 'ui-ghostoverlays'))).toBe(false);
+    } finally {
+      await killProc(proc);
+    }
+  });
+});
+
+// feature-4 T7b — `locked` (per-user locked layer keys) is the third view-file
+// lane: same split contract as viewport/overlays (never the versioned meta),
+// REPLACE semantics (the client sends the full set), bounded shape.
+describe('/_api/canvas-meta — locked lane (feature-4 T7b)', () => {
+  test('PATCH locked leaves meta byte-unchanged + writes the view file; GET merges it back', async () => {
+    const { root, designRoot } = makeSandbox();
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      mkdirSync(join(designRoot, 'ui'), { recursive: true });
+      const tsxAbs = join(designRoot, 'ui', 'Locked.tsx');
+      writeFileSync(tsxAbs, 'export default function L(){return <main/>}\n');
+      const metaAbs = tsxAbs.replace(/\.tsx$/, '.meta.json');
+      writeFileSync(metaAbs, JSON.stringify({ title: 'Locked', sections: [] }));
+      const before = readFileSync(metaAbs, 'utf8');
+      const file = repoRel(designRoot, tsxAbs);
+
+      const r = await fetch(`http://localhost:${port}/_api/canvas-meta`, {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ file, patch: { locked: ['aabbccdd:0', 'deadbeef:2'] } }),
+      });
+      expect(r.status).toBe(200);
+      const merged = (await r.json()) as MetaShape;
+      expect(merged.locked).toEqual(['aabbccdd:0', 'deadbeef:2']);
+      // Versioned meta byte-identical (runtime state never lands there).
+      expect(readFileSync(metaAbs, 'utf8')).toBe(before);
+      const view = JSON.parse(readFileSync(viewPath(designRoot, 'ui-locked'), 'utf8'));
+      expect(view.locked).toEqual(['aabbccdd:0', 'deadbeef:2']);
+
+      // REPLACE semantics — a smaller set unlocks the dropped key.
+      await fetch(`http://localhost:${port}/_api/canvas-meta`, {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ file, patch: { locked: ['aabbccdd:0'] } }),
+      });
+      const g = await fetch(
+        `http://localhost:${port}/_api/canvas-meta?file=${encodeURIComponent(file)}`
+      );
+      expect(((await g.json()) as MetaShape).locked).toEqual(['aabbccdd:0']);
+    } finally {
+      await killProc(proc);
+    }
+  });
+
+  test('malformed locked keys are a silent no-op (shape-gated)', async () => {
+    const { root, designRoot } = makeSandbox();
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    try {
+      mkdirSync(join(designRoot, 'ui'), { recursive: true });
+      const tsxAbs = join(designRoot, 'ui', 'BadLock.tsx');
+      writeFileSync(tsxAbs, 'export default function B(){return <main/>}\n');
+      writeFileSync(tsxAbs.replace(/\.tsx$/, '.meta.json'), JSON.stringify({ title: 'B' }));
+      const file = repoRel(designRoot, tsxAbs);
+      await fetch(`http://localhost:${port}/_api/canvas-meta`, {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ file, patch: { locked: ['../../etc/passwd', 'not-a-key'] } }),
+      });
+      const g = await fetch(
+        `http://localhost:${port}/_api/canvas-meta?file=${encodeURIComponent(file)}`
+      );
+      expect(((await g.json()) as MetaShape).locked).toBeUndefined();
+    } finally {
+      await killProc(proc);
+    }
+  });
+});

package/apps/studio/test/canvas-origin-gate.test.ts

@@ -111,6 +111,10 @@ describe('canvas-origin gate — A1/A2 traversal + privilege containment', () =>
         '/_api/insert-artboard',
         '/_api/resize-artboard',
         '/_api/delete-artboard',
+        // feature-3-web-artboards T3 — "Duplicate at width…" is a source-write,
+        // same MAIN-ORIGIN-ONLY posture as the other artboard structural ops
+        // right above.
+        '/_api/duplicate-artboard',
         // Stage F1 — the AssetPicker's asset-listing GET is a shell (main-origin)
         // concern; the untrusted canvas iframe must not enumerate project media.
         '/_api/assets',

package/apps/studio/test/comment-mount.test.ts

@@ -39,7 +39,8 @@ describe('comment-mount / MaybeToolProvider dedup', () => {
     const html = renderToStaticMarkup(
       createElement(MaybeToolProvider, null, createElement(ToolReader))
     );
-    expect(html).toContain('data-tool="move"');
+    // feature-4 (browse/move split) — the default boot tool is `browse`.
+    expect(html).toContain('data-tool="browse"');
   });
 });
 

package/apps/studio/test/component-map.test.ts

@@ -0,0 +1,48 @@
+// component-map — feature-4 T7a. The Layers panel's purple-instance source:
+// `componentMapForCanvas` reports every element that renders through an
+// INSTANTIATED component (`<Card/>` referenced as JSX in the file), keyed by
+// cd-id. The top-level canvas component (exported/mounted, never referenced as
+// JSX here) must NOT mark its elements as instances.
+
+import { describe, expect, test } from 'bun:test';
+
+import { componentMapForCanvas } from '../canvas-edit.ts';
+import { transpileCanvasSource } from '../canvas-pipeline.ts';
+
+const CANVAS = '/abs/Canvas.tsx';
+
+function idsOf(source: string): Record<string, string> {
+  const { withIds } = transpileCanvasSource(CANVAS, source);
+  const out: Record<string, string> = {};
+  for (const m of withIds.matchAll(/<(\w+)([^>]*?)data-cd-id="([0-9a-f]{8})"/g)) {
+    if (!out[m[1] as string]) out[m[1] as string] = m[3] as string;
+  }
+  return out;
+}
+
+describe('canvas-edit / componentMapForCanvas', () => {
+  test('elements of an instantiated component are instances; the canvas root is not', () => {
+    const src = `
+      function Card() { return <article className="card"><h2>Hi</h2></article>; }
+      function Demo() { return <div><Card /><Card /><p>plain</p></div>; }
+    `;
+    const ids = idsOf(src);
+    const map = componentMapForCanvas(CANVAS, src);
+    // Card's own elements → instances of Card (2 usages); article is the root.
+    expect(map[ids.article as string]).toEqual({ component: 'Card', root: true, usages: 2 });
+    expect(map[ids.h2 as string]).toEqual({ component: 'Card', root: false, usages: 2 });
+    // Demo (the canvas component, never referenced as JSX) → NOT in the map.
+    expect(map[ids.div as string]).toBeUndefined();
+    expect(map[ids.p as string]).toBeUndefined();
+  });
+
+  test('no components → empty map', () => {
+    const src = `function Demo() { return <div><h1>T</h1></div>; }`;
+    const map = componentMapForCanvas(CANVAS, src);
+    expect(Object.keys(map)).toHaveLength(0);
+  });
+
+  test('unparsable source → empty map (no throw)', () => {
+    expect(componentMapForCanvas(CANVAS, 'function {{{')).toEqual({});
+  });
+});