@1agh/maude 0.45.2 → 0.46.0

package/apps/studio/test/print-marks.test.ts

@@ -0,0 +1,113 @@
+// feature-2-print-artboards T5 — print/marks.ts pure geometry unit tests.
+
+import { describe, expect, test } from 'bun:test';
+
+import { computeMarksGeometry, MARK_STROKE_PT, requiredSlugPt } from '../print/marks.ts';
+import { mmToPt } from '../print/units.ts';
+
+const PAGE_W = 600; // pt, arbitrary
+const PAGE_H = 800;
+const BLEED = mmToPt(3);
+
+describe('print/marks — requiredSlugPt', () => {
+  test('neither crop nor registration → 0', () => {
+    expect(requiredSlugPt({})).toBe(0);
+  });
+
+  test('crop only → the mark length', () => {
+    expect(requiredSlugPt({ crop: true })).toBeCloseTo(mmToPt(3.5), 6);
+  });
+
+  test('registration reaches further than crop alone', () => {
+    const cropOnly = requiredSlugPt({ crop: true });
+    const both = requiredSlugPt({ crop: true, registration: true });
+    expect(both).toBeGreaterThan(cropOnly);
+  });
+});
+
+describe('print/marks — computeMarksGeometry', () => {
+  test('crop:false, registration:false → both arrays empty', () => {
+    const g = computeMarksGeometry({ pageWidthPt: PAGE_W, pageHeightPt: PAGE_H, bleedPt: BLEED });
+    expect(g.cropMarks).toEqual([]);
+    expect(g.registrationMarks).toEqual([]);
+  });
+
+  test('crop:true → exactly 8 segments (2 per corner × 4 corners)', () => {
+    const g = computeMarksGeometry({
+      pageWidthPt: PAGE_W,
+      pageHeightPt: PAGE_H,
+      bleedPt: BLEED,
+      crop: true,
+    });
+    expect(g.cropMarks.length).toBe(8);
+  });
+
+  test('every crop-mark segment lies OUTSIDE the bleed box (page) bounds', () => {
+    const g = computeMarksGeometry({
+      pageWidthPt: PAGE_W,
+      pageHeightPt: PAGE_H,
+      bleedPt: BLEED,
+      crop: true,
+    });
+    for (const seg of g.cropMarks) {
+      const outside = (x: number, y: number) => x < 0 || x > PAGE_W || y < 0 || y > PAGE_H;
+      // At least one endpoint of every mark segment must be outside the page —
+      // the whole point of a crop mark is to be visible in the bleed/slug area.
+      expect(outside(seg.x1, seg.y1) || outside(seg.x2, seg.y2)).toBe(true);
+    }
+  });
+
+  test('crop-mark segments align to the trim line (bleed inset)', () => {
+    const g = computeMarksGeometry({
+      pageWidthPt: PAGE_W,
+      pageHeightPt: PAGE_H,
+      bleedPt: BLEED,
+      crop: true,
+    });
+    const trimX0 = BLEED;
+    const trimX1 = PAGE_W - BLEED;
+    const trimY0 = BLEED;
+    const trimY1 = PAGE_H - BLEED;
+    const xs = g.cropMarks.filter((s) => s.x1 === s.x2).map((s) => s.x1);
+    const ys = g.cropMarks.filter((s) => s.y1 === s.y2).map((s) => s.y1);
+    expect(new Set(xs)).toEqual(new Set([trimX0, trimX1]));
+    expect(new Set(ys)).toEqual(new Set([trimY0, trimY1]));
+  });
+
+  test('registration:true → 4 marks, each a circle + 2-segment crosshair', () => {
+    const g = computeMarksGeometry({
+      pageWidthPt: PAGE_W,
+      pageHeightPt: PAGE_H,
+      bleedPt: BLEED,
+      registration: true,
+    });
+    expect(g.registrationMarks.length).toBe(4);
+    for (const m of g.registrationMarks) {
+      expect(m.crosshair.length).toBe(2);
+      expect(m.circle.r).toBeGreaterThan(0);
+    }
+  });
+
+  test('registration marks sit beyond the crop marks (no visual collision)', () => {
+    const g = computeMarksGeometry({
+      pageWidthPt: PAGE_W,
+      pageHeightPt: PAGE_H,
+      bleedPt: BLEED,
+      crop: true,
+      registration: true,
+    });
+    const topCenterReg = g.registrationMarks.find((m) => m.circle.cy > PAGE_H);
+    expect(topCenterReg).toBeDefined();
+    const topCropTip = Math.max(
+      ...g.cropMarks.filter((s) => s.y1 > PAGE_H || s.y2 > PAGE_H).map((s) => Math.max(s.y1, s.y2))
+    );
+    expect((topCenterReg?.circle.cy ?? 0) - (topCenterReg?.circle.r ?? 0)).toBeGreaterThan(
+      topCropTip
+    );
+  });
+});
+
+test('MARK_STROKE_PT is a small positive value (0.25mm)', () => {
+  expect(MARK_STROKE_PT).toBeCloseTo(mmToPt(0.25), 6);
+  expect(MARK_STROKE_PT).toBeGreaterThan(0);
+});

package/apps/studio/test/print-units.test.ts

@@ -0,0 +1,173 @@
+// feature-2-print-artboards T1 — print/units.ts unit tests + the single-source
+// lint guard (no `25.4` outside this module — see the plan's T1 gotcha).
+
+import { describe, expect, test } from 'bun:test';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+
+import {
+  CSS_DPI,
+  defaultBleedMm,
+  getPaperPreset,
+  MM_PER_INCH,
+  mmToPt,
+  mmToPx,
+  PAPER_PRESETS,
+  pxToMm,
+  pxToPt,
+  resolvePrintArtboard,
+  trimSizeMm,
+} from '../print/units.ts';
+
+describe('print/units — conversions', () => {
+  test('mmToPx / pxToMm are inverses at 96dpi', () => {
+    expect(mmToPx(MM_PER_INCH)).toBeCloseTo(CSS_DPI, 10);
+    expect(pxToMm(CSS_DPI)).toBeCloseTo(MM_PER_INCH, 10);
+    expect(pxToMm(mmToPx(37))).toBeCloseTo(37, 10);
+  });
+
+  test('mmToPt: 25.4mm === 72pt (1 inch)', () => {
+    expect(mmToPt(MM_PER_INCH)).toBeCloseTo(72, 10);
+  });
+
+  test('pxToPt: 96px @96dpi === 72pt (1 inch)', () => {
+    expect(pxToPt(96)).toBeCloseTo(72, 10);
+  });
+});
+
+describe('print/units — PAPER_PRESETS', () => {
+  test('every ISO A-series preset id resolves', () => {
+    for (const id of ['a6', 'a5', 'a4', 'a3', 'a2', 'a1', 'a0']) {
+      expect(getPaperPreset(id)).toBeDefined();
+    }
+  });
+
+  test('A4 is 210×297mm portrait', () => {
+    const a4 = getPaperPreset('a4');
+    expect(a4?.width).toBe(210);
+    expect(a4?.height).toBe(297);
+    expect(a4?.unit).toBe('mm');
+  });
+
+  test('Letter is a US in-unit preset', () => {
+    const letter = getPaperPreset('letter');
+    expect(letter?.unit).toBe('in');
+    expect(letter?.width).toBe(8.5);
+    expect(letter?.height).toBe(11);
+  });
+
+  test('unknown id is undefined', () => {
+    expect(getPaperPreset('nope')).toBeUndefined();
+  });
+
+  test('no duplicate ids', () => {
+    const ids = PAPER_PRESETS.map((p) => p.id);
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+});
+
+describe('print/units — orientation', () => {
+  test('landscape swaps width/height', () => {
+    const a4 = getPaperPreset('a4');
+    expect(a4).toBeDefined();
+    const portrait = trimSizeMm(a4 as NonNullable<typeof a4>, 'portrait');
+    const landscape = trimSizeMm(a4 as NonNullable<typeof a4>, 'landscape');
+    expect(portrait.widthMm).toBe(210);
+    expect(portrait.heightMm).toBe(297);
+    expect(landscape.widthMm).toBe(297);
+    expect(landscape.heightMm).toBe(210);
+  });
+});
+
+describe('print/units — default bleed', () => {
+  test('mm-unit presets default to 3mm bleed', () => {
+    const a4 = getPaperPreset('a4');
+    expect(a4).toBeDefined();
+    expect(defaultBleedMm(a4 as NonNullable<typeof a4>)).toBe(3);
+  });
+
+  test('in-unit presets default to 0.125in bleed, expressed in mm', () => {
+    const letter = getPaperPreset('letter');
+    expect(letter).toBeDefined();
+    expect(defaultBleedMm(letter as NonNullable<typeof letter>)).toBeCloseTo(
+      0.125 * MM_PER_INCH,
+      10
+    );
+  });
+});
+
+describe('print/units — resolvePrintArtboard', () => {
+  test('throws on unknown paper', () => {
+    expect(() => resolvePrintArtboard({ paper: 'nope' })).toThrow(/unknown paper preset/);
+  });
+
+  test('A4 portrait, default bleed — artboard px = trim + 2×bleed exactly', () => {
+    const r = resolvePrintArtboard({ paper: 'a4' });
+    expect(r.bleedMm).toBe(3);
+    expect(r.widthPx).toBe(r.trimWidthPx + 2 * r.bleedPx);
+    expect(r.heightPx).toBe(r.trimHeightPx + 2 * r.bleedPx);
+    // Sanity band around the nominal A4-at-96dpi size (~794×1123px trim).
+    expect(r.trimWidthPx).toBeGreaterThan(790);
+    expect(r.trimWidthPx).toBeLessThan(798);
+    expect(r.trimHeightPx).toBeGreaterThan(1118);
+    expect(r.trimHeightPx).toBeLessThan(1128);
+  });
+
+  test('landscape orientation swaps the resolved trim dimensions', () => {
+    const portrait = resolvePrintArtboard({ paper: 'a4', orientation: 'portrait' });
+    const landscape = resolvePrintArtboard({ paper: 'a4', orientation: 'landscape' });
+    expect(landscape.trimWidthPx).toBe(portrait.trimHeightPx);
+    expect(landscape.trimHeightPx).toBe(portrait.trimWidthPx);
+  });
+
+  test('explicit bleedMm=0 removes the bleed border entirely', () => {
+    const r = resolvePrintArtboard({ paper: 'a4', bleedMm: 0 });
+    expect(r.bleedPx).toBe(0);
+    expect(r.widthPx).toBe(r.trimWidthPx);
+    expect(r.heightPx).toBe(r.trimHeightPx);
+  });
+
+  test('margins default to 5mm on all sides when unset', () => {
+    const r = resolvePrintArtboard({ paper: 'a4' });
+    expect(r.marginsMm).toEqual({ top: 5, right: 5, bottom: 5, left: 5 });
+  });
+
+  test('partial margin override only replaces the given sides', () => {
+    const r = resolvePrintArtboard({ paper: 'a4', marginsMm: { top: 10 } });
+    expect(r.marginsMm).toEqual({ top: 10, right: 5, bottom: 5, left: 5 });
+  });
+});
+
+describe('print/units — single-source lint guard', () => {
+  const STUDIO_ROOT = join(import.meta.dir, '..');
+  const SKIP_DIRS = new Set(['node_modules', 'dist', '.git', '_history']);
+
+  function walk(dir: string, out: string[]): string[] {
+    for (const entry of readdirSync(dir)) {
+      if (SKIP_DIRS.has(entry)) continue;
+      const full = join(dir, entry);
+      const st = statSync(full);
+      if (st.isDirectory()) walk(full, out);
+      else if (/\.(ts|tsx|mjs|jsx)$/.test(entry)) out.push(full);
+    }
+    return out;
+  }
+
+  test('the mm-per-inch conversion constant (25.4 in arithmetic) appears ONLY in print/units.ts', () => {
+    // Matches `25.4` used as a division/multiplication operand (the shape a
+    // hand-rolled mm↔px conversion would take, e.g. `mm * 96 / 25.4`) — NOT
+    // any bare occurrence of the substring, which also shows up coincidentally
+    // in unrelated numeric data (e.g. SVG path coordinates in canvas-cursors.ts).
+    const CONVERSION_SHAPE = /[*/]\s*25\.4\b|\b25\.4\s*[*/]/;
+    const files = walk(STUDIO_ROOT, []);
+    const offenders: string[] = [];
+    for (const file of files) {
+      const rel = relative(STUDIO_ROOT, file);
+      if (rel === join('print', 'units.ts')) continue;
+      if (rel === join('test', 'print-units.test.ts')) continue;
+      const text = readFileSync(file, 'utf8');
+      if (CONVERSION_SHAPE.test(text)) offenders.push(rel);
+    }
+    expect(offenders).toEqual([]);
+  });
+});

package/apps/studio/test/use-snap-guides.test.ts

@@ -188,3 +188,84 @@ describe('computeSnap / no candidates', () => {
     expect(r.guides).toEqual([]);
   });
 });
+
+// feature-1-artboard-kinds-foundation, T7 — generic-layout-guide-line candidates.
+describe('computeSnap / guide lines (T5 guides fed in as snap candidates)', () => {
+  test('left edge snaps to a guide line within tolerance, kind "guide"', () => {
+    const r = computeSnap(rect(503, 200), [], {
+      ...DEFAULTS,
+      guideLines: [{ axis: 'x', pos: 500, from: 0, to: 1000 }],
+    });
+    expect(r.x).toBe(500);
+    expect(r.guides.find((g) => g.axis === 'x')).toMatchObject({ pos: 500, kind: 'guide' });
+  });
+
+  test('right edge and center also test against the same guide line', () => {
+    // proposed right edge (137+100=237) is within tolerance of the guide at 240.
+    const r = computeSnap(rect(137, 200), [], {
+      ...DEFAULTS,
+      guideLines: [{ axis: 'x', pos: 240, from: 0, to: 1000 }],
+    });
+    expect(r.x).toBe(140); // shifted so right edge lands exactly on 240
+    expect(r.guides.find((g) => g.axis === 'x')).toMatchObject({ pos: 240, kind: 'guide' });
+  });
+
+  test('a closer sibling wins over a farther guide line on the same axis', () => {
+    const r = computeSnap(rect(503, 200), [rect(500, 500)], {
+      ...DEFAULTS,
+      guideLines: [{ axis: 'x', pos: 507, from: 0, to: 1000 }],
+    });
+    // sibling delta = -3 (|3|), guide delta = +4 (|4|) — sibling is closer.
+    expect(r.guides.find((g) => g.axis === 'x')).toMatchObject({ kind: 'sibling', pos: 500 });
+  });
+
+  test('outside tolerance, a guide line is ignored', () => {
+    const r = computeSnap(rect(100, 200), [], {
+      ...DEFAULTS,
+      guideLines: [{ axis: 'x', pos: 500, from: 0, to: 1000 }],
+    });
+    expect(r.x).toBe(100);
+  });
+
+  test('y-axis guide lines snap independently of x-axis', () => {
+    const r = computeSnap(rect(200, 303), [], {
+      ...DEFAULTS,
+      guideLines: [{ axis: 'y', pos: 300, from: 0, to: 1000 }],
+    });
+    expect(r.y).toBe(300);
+    expect(r.x).toBe(200);
+  });
+});
+
+describe('computeSnap / intent presets (T7 Design Decision 4)', () => {
+  test('"pixel" intent ignores siblings AND guide lines — grid only', () => {
+    const r = computeSnap(rect(503, 201), [rect(500, 500)], {
+      ...DEFAULTS,
+      intent: 'pixel',
+      guideLines: [{ axis: 'x', pos: 502, from: 0, to: 1000 }],
+    });
+    // Neither the sibling (delta -3) nor the guide (delta -1) fire under
+    // "pixel" — only the grid pass, out of tolerance from both 503 and 201.
+    expect(r.x).toBe(503);
+    expect(r.guides.some((g) => g.kind === 'sibling' || g.kind === 'guide')).toBe(false);
+  });
+
+  test('"pixel" intent still snaps to the grid', () => {
+    const r = computeSnap(rect(37, 200), [], { ...DEFAULTS, intent: 'pixel' });
+    expect(r.x).toBe(40);
+  });
+
+  test('omitting `intent` defaults to "layout" (back-compat with every pre-T7 call site)', () => {
+    const r = computeSnap(rect(503, 200), [rect(500, 500)], DEFAULTS);
+    expect(r.x).toBe(500);
+  });
+
+  test('"layout" intent (explicit) still snaps to siblings + guides', () => {
+    const r = computeSnap(rect(503, 200), [], {
+      ...DEFAULTS,
+      intent: 'layout',
+      guideLines: [{ axis: 'x', pos: 500, from: 0, to: 1000 }],
+    });
+    expect(r.x).toBe(500);
+  });
+});

package/apps/studio/use-chrome-visibility.tsx

@@ -26,6 +26,23 @@ export interface ChromeVisibilityState {
   zoom: boolean;
   /** Presentation Mode — hides ALL chrome regardless of the two above. */
   present: boolean;
+  /**
+   * Generic layout guides (feature-1-artboard-kinds-foundation T4–T6) — UNLIKE
+   * minimap/zoom/present, this is per-CANVAS persisted state (view.json
+   * `overlays.guides`), not a global shell preference. DesignCanvasInner
+   * self-seeds it from the canvas's own meta right after mount (see
+   * canvas-lib.tsx); the shell's View-menu toggle then live-updates it through
+   * the SAME `dgn:'view-chrome'` bridge as the other three flags.
+   */
+  guides: boolean;
+  /**
+   * feature-2-print-artboards T3 — "Show print guides" (bleed/trim/margin
+   * overlay for `kind="print"` artboards). Same shape as `guides` above:
+   * per-CANVAS persisted state (view.json `overlays.print`), self-seeded by
+   * DesignCanvasInner, live-updated through the same `dgn:'view-chrome'`
+   * bridge.
+   */
+  print: boolean;
 }
 
 export interface ChromeVisibilityValue extends ChromeVisibilityState {
@@ -52,6 +69,8 @@ export function ChromeVisibilityProvider({
     minimap: initial?.minimap ?? false,
     zoom: initial?.zoom ?? false,
     present: initial?.present ?? false,
+    guides: initial?.guides ?? false,
+    print: initial?.print ?? false,
   });
   const setChrome = useCallback((patch: Partial<ChromeVisibilityState>) => {
     setState((prev) => ({ ...prev, ...patch }));

package/apps/studio/use-element-resize.tsx

@@ -240,6 +240,26 @@ export function scaleFromMatrix(transform: string | null | undefined): number {
   return s > 0 ? s : 1;
 }
 
+/**
+ * The `.dc-world` camera's effective render zoom for an element. Dogfood fix
+ * (print-artboards round): the camera writes DIFFERENT properties per engine
+ * (writeTransform's IS_WEBKIT split in canvas-lib) — WebKit gets
+ * `transform: scale(z)`, Chromium gets the CSS `zoom` PROPERTY (whose
+ * computed `transform` is a bare translate). Reading only the matrix
+ * therefore returned 1 in every non-WebKit browser and the handle/spacing
+ * overlays drew at world size instead of screen size, visibly scaling with
+ * the camera (the desktop app is WKWebView, which is why dogfooding never
+ * caught it). Multiplying both reads is exact on each engine: the unused
+ * property computes to identity.
+ */
+export function worldZoomFor(el: Element): number {
+  const world = el.closest('.dc-world') as HTMLElement | null;
+  if (!world) return 1;
+  const cs = getComputedStyle(world);
+  const zoomProp = Number.parseFloat((cs as { zoom?: string }).zoom || '1') || 1;
+  return scaleFromMatrix(cs.transform) * zoomProp;
+}
+
 /** Rotate a local offset (dx,dy) by `deg` — screen y is down, positive = CW. */
 export function rotatePointDeg(dx: number, dy: number, deg: number): [number, number] {
   const r = (deg * Math.PI) / 180;
@@ -458,8 +478,7 @@ export function ElementResizeOverlay(): ReactNode {
       const cx = r.left + r.width / 2;
       const cy = r.top + r.height / 2;
       const deg = rotationDegFromMatrix(getComputedStyle(el).transform);
-      const world = el.closest('.dc-world') as HTMLElement | null;
-      const zoom = world ? scaleFromMatrix(getComputedStyle(world).transform) : 1;
+      const zoom = worldZoomFor(el);
       const hw = (el.offsetWidth * zoom) / 2;
       const hh = (el.offsetHeight * zoom) / 2;
       // Rotate zones sit ON each corner (same offset), 20×20, z-index below the

package/apps/studio/use-snap-guides.tsx

@@ -44,8 +44,10 @@ export type SnapAxis = 'x' | 'y';
  *  different visual treatments (grid = lighter gray fallback; sibling = full
  *  magenta confidence). `delta` is the signed correction the snap applied;
  *  the overlay renders a `Δ{Math.round(delta)}` pill mid-span when |delta| > 0
- *  and the guide span > 60 px. */
-export type SnapKind = 'grid' | 'sibling';
+ *  and the guide span > 60 px. `guide` (feature-1-artboard-kinds-foundation
+ *  T7) is a third source — an artboard's own generic layout guide lines
+ *  (T5), offered the same confidence treatment as `sibling`. */
+export type SnapKind = 'grid' | 'sibling' | 'guide';
 
 export interface SnapGuide {
   /** `"x"` → vertical line (snapping X coord). Line sits at `pos` on X,
@@ -72,6 +74,29 @@ export interface SnapResult {
   guides: SnapGuide[];
 }
 
+/**
+ * T7 — a single generic-layout-guide line (T5) in WORLD coordinates, ready to
+ * snap against. The caller (canvas-lib/canvas-shell) resolves an artboard's
+ * `guides` prop (columns/rows/grid, artboard-LOCAL coordinates) into these
+ * world-space lines — `computeSnap` itself stays artboard-agnostic, same as
+ * it already is for sibling rects.
+ */
+export interface GuideLineCandidate {
+  axis: SnapAxis;
+  pos: number;
+  from: number;
+  to: number;
+}
+
+/**
+ * T7 — the two snap-source presets: `layout` (default) offers sibling edges/
+ * centers AND guide lines, falling back to the grid; `pixel` offers ONLY the
+ * grid — for pixel-precise placement work where guide/sibling magnetism would
+ * get in the way. Affinity's "2 intent presets, not 15 toggles" call (see the
+ * plan's Design Decision 4).
+ */
+export type SnapIntent = 'layout' | 'pixel';
+
 export interface SnapOptions {
   /** World-units between grid lines. Default 40. */
   gridSize: number;
@@ -79,6 +104,11 @@ export interface SnapOptions {
   tolerance: number;
   /** Skip all snap math + return proposed unchanged (Alt-held bypass). */
   disabled: boolean;
+  /** Generic layout guide lines to snap against, in world coordinates. */
+  guideLines?: GuideLineCandidate[];
+  /** Which candidate sources are active. Default `'layout'` when omitted, so
+   *  every existing call site (pre-T7) keeps today's sibling+grid behavior. */
+  intent?: SnapIntent;
 }
 
 interface AxisCandidate {
@@ -141,6 +171,7 @@ export function computeSnap(proposed: Rect, others: Rect[], opts: SnapOptions):
     return { x: proposed.x, y: proposed.y, guides: [] };
   }
   const { gridSize, tolerance } = opts;
+  const intent = opts.intent ?? 'layout';
   const propLeft = proposed.x;
   const propRight = proposed.x + proposed.w;
   const propCenterX = proposed.x + proposed.w / 2;
@@ -152,7 +183,8 @@ export function computeSnap(proposed: Rect, others: Rect[], opts: SnapOptions):
   const yCands: AxisCandidate[] = [];
 
   // Grid candidates — left edge for X, top edge for Y. Perpendicular extent
-  // is just the proposed rect's own range (no sibling involved).
+  // is just the proposed rect's own range (no sibling involved). Grid is the
+  // one source active under BOTH intent presets (T7 Design Decision 4).
   const gridX = nearestGridDelta(propLeft, gridSize, tolerance);
   if (gridX !== null) {
     xCands.push({
@@ -174,8 +206,44 @@ export function computeSnap(proposed: Rect, others: Rect[], opts: SnapOptions):
     });
   }
 
-  // Sibling candidates.
-  for (const other of others) {
+  // T7 — generic-layout-guide-line candidates ("Layout" intent only). Each
+  // world-space line is tested the same three ways a sibling edge/center is
+  // (leading edge, trailing edge, center) — Figma's own layout-guide snap
+  // behavior — so a guide line snaps whichever part of the proposed rect
+  // lands closest, not just its leading edge (unlike the grid pass above).
+  if (intent === 'layout') {
+    for (const g of opts.guideLines ?? []) {
+      if (g.axis === 'x') {
+        for (const propCoord of [propLeft, propRight, propCenterX]) {
+          const delta = g.pos - propCoord;
+          if (Math.abs(delta) > tolerance) continue;
+          xCands.push({
+            delta,
+            pos: g.pos,
+            from: Math.min(propTop, g.from),
+            to: Math.max(propBottom, g.to),
+            kind: 'guide',
+          });
+        }
+      } else {
+        for (const propCoord of [propTop, propBottom, propCenterY]) {
+          const delta = g.pos - propCoord;
+          if (Math.abs(delta) > tolerance) continue;
+          yCands.push({
+            delta,
+            pos: g.pos,
+            from: Math.min(propLeft, g.from),
+            to: Math.max(propRight, g.to),
+            kind: 'guide',
+          });
+        }
+      }
+    }
+  }
+
+  // Sibling candidates ("Layout" intent only — "Pixel" is grid-only per T7
+  // Design Decision 4).
+  for (const other of intent === 'layout' ? others : []) {
     const oLeft = other.x;
     const oRight = other.x + other.w;
     const oCenterX = other.x + other.w / 2;

package/apps/studio/use-spacing-handles.tsx

@@ -28,7 +28,7 @@ import {
   type PaddingSide,
   paddingSideSet,
 } from './spacing-handles.ts';
-import { scaleFromMatrix } from './use-element-resize.tsx';
+import { worldZoomFor } from './use-element-resize.tsx';
 import { useSelectionSet } from './use-selection-set.tsx';
 import { useToolMode } from './use-tool-mode.tsx';
 
@@ -174,8 +174,10 @@ export function SpacingHandlesOverlay(): ReactNode {
         return;
       }
       const cs = getComputedStyle(el);
-      const world = el.closest('.dc-world') as HTMLElement | null;
-      const zoom = world ? scaleFromMatrix(getComputedStyle(world).transform) : 1;
+      // Dogfood fix — engine-split-aware zoom read (see worldZoomFor's own
+      // doc comment in use-element-resize: the Chromium camera writes the CSS
+      // `zoom` property, not a transform matrix).
+      const zoom = worldZoomFor(el);
       const padding = {
         top: computedPx(cs, 'padding-top'),
         right: computedPx(cs, 'padding-right'),
@@ -274,8 +276,10 @@ export function SpacingHandlesOverlay(): ReactNode {
       const prop = t.dataset.prop || '';
       const isGap = prop === 'gap';
       const cs = getComputedStyle(el);
-      const world = el.closest('.dc-world') as HTMLElement | null;
-      const zoom = world ? scaleFromMatrix(getComputedStyle(world).transform) : 1;
+      // Dogfood fix — engine-split-aware zoom read (see worldZoomFor's own
+      // doc comment in use-element-resize: the Chromium camera writes the CSS
+      // `zoom` property, not a transform matrix).
+      const zoom = worldZoomFor(el);
       const drag: SpacingDrag = {
         pointerId: e.pointerId,
         kind: isGap ? 'gap' : 'padding',

package/apps/studio/whats-new.json

@@ -1,6 +1,34 @@
 {
   "$schema": "./whats-new.schema.json",
   "entries": [
+    {
+      "id": "scene-aware-video-analyze",
+      "version": "0.46.0",
+      "date": "2026-07-18",
+      "kind": "feature",
+      "title": "Analyze a video — picture and sound — in one command",
+      "summary": "Run /design:video-analyze on a clip and Maude reads it end to end: it picks keyframes at real scene changes and action beats (not a blind frame rate), transcribes the audio, and writes a summary with shots, on-screen text, mood, and the best moment to use. A new Settings → Video section lets you choose the analysis engine and, on Apple Silicon, download an optional local Gemma model for smarter shot detection.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "print-artboards",
+      "version": "0.46.0",
+      "date": "2026-07-18",
+      "kind": "feature",
+      "title": "Design flyers, posters, and business cards — print-ready",
+      "summary": "Give a print artboard a real paper size (A4, Letter, business card, and more) and it resolves to the correct bleed-inclusive dimensions automatically. Toggle bleed/trim/margin guides from the View menu while you work, then export a 300–600 DPI PNG or a print-ready PDF with correct page boxes and crop/registration marks.",
+      "surface": "design-ui",
+      "learnMore": "https://maude.sh/docs/design/print"
+    },
+    {
+      "id": "artboard-kinds-foundation",
+      "version": "0.46.0",
+      "date": "2026-07-18",
+      "kind": "feature",
+      "title": "Artboards now know what they are",
+      "summary": "Give any artboard a kind — Digital, Print, Web, or Video — from the Inspector or the right-click menu, and it gets its own chrome. New generic layout guides (columns, rows, grid) can be toggled on from the View menu for any artboard. Print- and web-specific tools land in follow-up releases.",
+      "surface": "design-ui"
+    },
     {
       "id": "acp-ask-user-question",
       "version": "0.45.2",

package/cli/commands/design.mjs

@@ -87,6 +87,14 @@ const BIN_VERBS = new Set([
   // reads the clip as a file:// resource).
   'ingest-footage',
   'probe-footage',
+  // feature-scene-aware-keyframes. `smart-frames` is the scene-AWARE sibling of
+  // `probe-footage`: it selects keyframes at scene cuts + semantic action beats +
+  // endpoints (three tiers, auto-detected — gemma scout / ffmpeg scene-detect /
+  // blind Chromium floor) instead of a blind frame rate, and emits a SUPERSET of
+  // probe-footage's manifest (drop-in for the footage-analyst). No dev server.
+  // Owned by skill `footage-keyframes`; --engine auto self-detects deps so it
+  // works standalone as a terminal video analyzer.
+  'smart-frames',
   // feature-ai-media-generation (Phase 0, DDR-16x). `generate` is the thin
   // non-browser BYOK verb (curl → /_api/generate-jobs → poll → print the
   // produced /assets/<sha8>.<ext>). The provider call happens server-side (the
@@ -290,7 +298,7 @@ Dev-tooling (dispatch to the dev-server bash helpers — DDR-062):
   screenshot · server-up · prep · slug · bootstrap-check · runtime-health
   smoke · canvas-edit · handoff · asset-sweep · visual-sanity · fetch-asset
   draw-build · draw-proof · svg-optimize · to-lottie · read-annotations · annotate
-  canvas-rects · ingest-footage · probe-footage
+  canvas-rects · ingest-footage · probe-footage · smart-frames
   generate · transcribe · audio-search
         Invoke the bundled helper of the same name. maude resolves it from its
         own package root and sets CLAUDE_PLUGIN_ROOT for the child; stdout,