@1agh/maude 0.45.1 → 0.46.0

package/apps/studio/print/units.ts

@@ -0,0 +1,269 @@
+// feature-2-print-artboards T1 — the single source for print unit conversion
+// + paper presets.
+//
+// Authoring stays at CSS px @96dpi (DDR-027 — mm never enters JSX geometry).
+// This module is the ONLY place mm/in ↔ px conversion happens: the on-canvas
+// overlay (T3), the Inspector print knobs (T2), and both exporters (T4/T5)
+// all import from here. Two mm→px sites would let the on-canvas bleed
+// silently desync from the exported PDF — see the plan's T1 gotcha.
+
+export const CSS_DPI = 96;
+export const MM_PER_INCH = 25.4;
+export const PT_PER_INCH = 72;
+
+export function mmToPx(mm: number, dpi: number = CSS_DPI): number {
+  return (mm * dpi) / MM_PER_INCH;
+}
+
+export function inToPx(inches: number, dpi: number = CSS_DPI): number {
+  return inches * dpi;
+}
+
+export function pxToMm(px: number, dpi: number = CSS_DPI): number {
+  return (px * MM_PER_INCH) / dpi;
+}
+
+export function pxToIn(px: number, dpi: number = CSS_DPI): number {
+  return px / dpi;
+}
+
+/** px → pt (1pt = 1/72in) — the unit pdf-lib's PDFPage boxes expect. */
+export function pxToPt(px: number, dpi: number = CSS_DPI): number {
+  return (px / dpi) * PT_PER_INCH;
+}
+
+export function mmToPt(mm: number): number {
+  return (mm / MM_PER_INCH) * PT_PER_INCH;
+}
+
+export type PaperUnit = 'mm' | 'in';
+export type PaperCategory = 'iso' | 'us' | 'envelope' | 'card' | 'poster';
+
+export interface PaperPreset {
+  id: string;
+  label: string;
+  category: PaperCategory;
+  unit: PaperUnit;
+  /** Portrait width × height, in `unit`. */
+  width: number;
+  height: number;
+}
+
+export const PAPER_PRESETS: readonly PaperPreset[] = [
+  // ISO A series (mm)
+  { id: 'a6', label: 'A6', category: 'iso', unit: 'mm', width: 105, height: 148 },
+  { id: 'a5', label: 'A5', category: 'iso', unit: 'mm', width: 148, height: 210 },
+  { id: 'a4', label: 'A4', category: 'iso', unit: 'mm', width: 210, height: 297 },
+  { id: 'a3', label: 'A3', category: 'iso', unit: 'mm', width: 297, height: 420 },
+  { id: 'a2', label: 'A2', category: 'iso', unit: 'mm', width: 420, height: 594 },
+  { id: 'a1', label: 'A1', category: 'iso', unit: 'mm', width: 594, height: 841 },
+  { id: 'a0', label: 'A0', category: 'iso', unit: 'mm', width: 841, height: 1189 },
+  // US (in)
+  { id: 'letter', label: 'Letter', category: 'us', unit: 'in', width: 8.5, height: 11 },
+  { id: 'legal', label: 'Legal', category: 'us', unit: 'in', width: 8.5, height: 14 },
+  { id: 'tabloid', label: 'Tabloid', category: 'us', unit: 'in', width: 11, height: 17 },
+  // Envelopes
+  { id: 'dl', label: 'DL envelope', category: 'envelope', unit: 'mm', width: 110, height: 220 },
+  { id: 'c5', label: 'C5 envelope', category: 'envelope', unit: 'mm', width: 162, height: 229 },
+  // Business cards
+  {
+    id: 'card-eu',
+    label: 'Business card (EU)',
+    category: 'card',
+    unit: 'mm',
+    width: 85,
+    height: 55,
+  },
+  {
+    id: 'card-us',
+    label: 'Business card (US)',
+    category: 'card',
+    unit: 'in',
+    width: 3.5,
+    height: 2,
+  },
+  // Posters
+  {
+    id: 'poster-18x24',
+    label: 'Poster 18×24"',
+    category: 'poster',
+    unit: 'in',
+    width: 18,
+    height: 24,
+  },
+  {
+    id: 'poster-24x36',
+    label: 'Poster 24×36"',
+    category: 'poster',
+    unit: 'in',
+    width: 24,
+    height: 36,
+  },
+];
+
+export function getPaperPreset(id: string): PaperPreset | undefined {
+  return PAPER_PRESETS.find((p) => p.id === id);
+}
+
+export type Orientation = 'portrait' | 'landscape';
+
+/** Trim size in mm, orientation-applied (swap width/height for landscape). */
+export function trimSizeMm(
+  preset: PaperPreset,
+  orientation: Orientation
+): { widthMm: number; heightMm: number } {
+  const wMm = preset.unit === 'mm' ? preset.width : preset.width * MM_PER_INCH;
+  const hMm = preset.unit === 'mm' ? preset.height : preset.height * MM_PER_INCH;
+  return orientation === 'landscape'
+    ? { widthMm: hMm, heightMm: wMm }
+    : { widthMm: wMm, heightMm: hMm };
+}
+
+/** Default bleed (mm) by preset's unit family — 3mm EU (mm-unit presets), 0.125in (in-unit presets). */
+export function defaultBleedMm(preset: PaperPreset): number {
+  return preset.unit === 'mm' ? 3 : 0.125 * MM_PER_INCH;
+}
+
+export const DEFAULT_SAFE_MARGIN_MM = 5;
+
+/** Generous but finite bound on bleed/margin mm values — guards a
+ *  malicious/broken value (a hand-edited or hub-synced `print` prop is
+ *  DDR-054 untrusted canvas content) from producing a negative trim box
+ *  (rect.w - 2×bleedPx) or a degenerate PDF geometry. Enforced at WRITE
+ *  time by `setArtboardPrintOp` (api.ts) AND at READ time by
+ *  `resolveBleedMm`/`resolveMarginsMm` below — a `print` prop can also
+ *  reach the exporter via disk/hub-sync without ever passing through the
+ *  write-time validator, so the read side needs its own clamp. */
+export const MAX_PRINT_MM = 200;
+
+function clampMm(v: number): number {
+  if (!Number.isFinite(v)) return 0;
+  return Math.min(Math.max(v, 0), MAX_PRINT_MM);
+}
+
+/** Crop/registration mark geometry — length ~3.5mm, stroke offset from trim = bleed. */
+export const MARK_LENGTH_MM = 3.5;
+export const MARK_STROKE_MM = 0.25;
+
+export interface PrintMargins {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+}
+
+/**
+ * The `print` JSX prop on `DCArtboard` (T2) — authoring-time intent, kept
+ * alongside the resolved px `width`/`height` DDR-027 already requires (this
+ * prop does NOT re-derive geometry at render time; the paper picker writes
+ * both this prop and the resolved px size together, see resolvePrintArtboard).
+ * Consumed by the Inspector's print picker (T2), the on-canvas overlay (T3),
+ * and both exporters (T4/T5) — all via THIS module, never a local copy.
+ */
+export interface ArtboardPrintProp {
+  /** Paper preset id — one of PAPER_PRESETS. */
+  paper: string;
+  orientation?: Orientation;
+  /** Bleed extension, mm. Omitted ⇒ defaultBleedMm(preset). */
+  bleedMm?: number;
+  marginsMm?: Partial<PrintMargins>;
+}
+
+export interface ResolvedPrintArtboard {
+  paper: string;
+  orientation: Orientation;
+  /** Trim (final cut) size, in mm. */
+  trimWidthMm: number;
+  trimHeightMm: number;
+  /** Bleed extension, in mm (uniform on all 4 sides). */
+  bleedMm: number;
+  /** Artboard px size = trim + 2×bleed — the artboard IS the bleed box (Design Decision 1). */
+  widthPx: number;
+  heightPx: number;
+  /** Trim box, in px, inset from the artboard edges by bleedPx on every side. */
+  trimWidthPx: number;
+  trimHeightPx: number;
+  bleedPx: number;
+  marginsMm: PrintMargins;
+}
+
+/**
+ * Resolve a possibly-partial `marginsMm` override against the 5mm default —
+ * the SAME resolution `resolvePrintArtboard` applies, factored out so the
+ * on-canvas overlay (T3) and the PDF post-pass (T5) apply identical defaults
+ * without re-deriving them from a full `resolvePrintArtboard` call (which
+ * needs a paper size neither of those call sites actually has to hand — both
+ * work from the artboard's own already-resolved px rect instead, per
+ * DDR-027).
+ */
+export function resolveMarginsMm(marginsMm?: Partial<PrintMargins>): PrintMargins {
+  const m = marginsMm ?? {};
+  return {
+    top: typeof m.top === 'number' ? clampMm(m.top) : DEFAULT_SAFE_MARGIN_MM,
+    right: typeof m.right === 'number' ? clampMm(m.right) : DEFAULT_SAFE_MARGIN_MM,
+    bottom: typeof m.bottom === 'number' ? clampMm(m.bottom) : DEFAULT_SAFE_MARGIN_MM,
+    left: typeof m.left === 'number' ? clampMm(m.left) : DEFAULT_SAFE_MARGIN_MM,
+  };
+}
+
+/**
+ * Resolve an `ArtboardPrintProp`'s bleed to a concrete mm value — explicit
+ * `bleedMm` wins, else the paper preset's unit-family default (3mm EU /
+ * 0.125in US). Unknown paper id with no explicit bleedMm falls back to 3mm
+ * rather than throwing — the overlay/exporter must never hard-fail a render
+ * over a bad paper id (resolvePrintArtboard is the strict, throwing entry
+ * point used at WRITE time; this one is the lenient, read-time counterpart).
+ */
+export function resolveBleedMm(print: { paper: string; bleedMm?: number }): number {
+  if (typeof print.bleedMm === 'number') return clampMm(print.bleedMm);
+  const preset = getPaperPreset(print.paper);
+  return preset ? defaultBleedMm(preset) : 3;
+}
+
+/** mm → whole px, rounded — the ONE rounding rule bleed/trim/margin geometry
+ *  uses everywhere (overlay, exporter, resolvePrintArtboard). */
+export function resolveMmPx(mm: number, dpi: number = CSS_DPI): number {
+  return Math.round(mmToPx(mm, dpi));
+}
+
+/**
+ * Resolve a `print` prop's paper/orientation/bleed into concrete px geometry.
+ * The artboard IS the bleed box: bleed lives INSIDE the artboard bounds so
+ * background content can reach the cut edge under today's clip-at-artboard
+ * -bounds rendering model (the alternative — artboard=trim, bleed outside —
+ * can't render bleeding content at all).
+ *
+ * px values are rounded to the nearest integer (CSS `width`/`height` must be
+ * whole px); overlay + exporter both re-derive px from the same mm fields
+ * on this result rather than re-rounding independently, so trim/bleed/margin
+ * geometry stays pixel-identical between what's drawn and what's exported.
+ */
+export function resolvePrintArtboard(args: {
+  paper: string;
+  orientation?: Orientation;
+  bleedMm?: number;
+  marginsMm?: Partial<PrintMargins>;
+}): ResolvedPrintArtboard {
+  const preset = getPaperPreset(args.paper);
+  if (!preset) throw new Error(`unknown paper preset: ${args.paper}`);
+  const orientation = args.orientation ?? 'portrait';
+  const { widthMm: trimWidthMm, heightMm: trimHeightMm } = trimSizeMm(preset, orientation);
+  const bleedMm = args.bleedMm ?? defaultBleedMm(preset);
+  const marginsMm = resolveMarginsMm(args.marginsMm);
+  const bleedPx = resolveMmPx(bleedMm);
+  const trimWidthPx = resolveMmPx(trimWidthMm);
+  const trimHeightPx = resolveMmPx(trimHeightMm);
+  return {
+    paper: preset.id,
+    orientation,
+    trimWidthMm,
+    trimHeightMm,
+    bleedMm,
+    widthPx: trimWidthPx + 2 * bleedPx,
+    heightPx: trimHeightPx + 2 * bleedPx,
+    trimWidthPx,
+    trimHeightPx,
+    bleedPx,
+    marginsMm,
+  };
+}

package/apps/studio/print-overlay-content.tsx

@@ -0,0 +1,132 @@
+/**
+ * @file       print-overlay-content.tsx — feature-2-print-artboards T3.
+ * @scope      apps/studio/print-overlay-content.tsx
+ * @purpose    Registers the 'print' kind's on-canvas guide chrome into the
+ *             foundation's kindOverlayRegistry (artboard-guides-overlay.tsx):
+ *             bleed zone (red tint), trim line (solid), safe-margin line
+ *             (magenta dashed) — the Adobe-convention colors Design
+ *             Decision 3 specifies. Decorative — aria-hidden, pointer-events
+ *             none, flat divs/borders only (no filters/blends — WKWebView
+ *             doesn't GPU-accelerate those; same constraint the foundation
+ *             overlay itself documents).
+ *
+ *             Geometry reads print/units.ts ONLY (never a local mm→px copy —
+ *             the T1 single-source invariant: bleedPx here must match the
+ *             PDF post-pass's bleedPx (T5) exactly, or the on-canvas guide
+ *             and the exported TrimBox visibly disagree).
+ */
+
+import { type KindOverlayRenderFn, registerKindOverlay } from './artboard-guides-overlay.tsx';
+import { resolveBleedMm, resolveMarginsMm, resolveMmPx } from './print/units.ts';
+
+// Adobe print-tool convention (Design Decision 3): bleed = red, trim = solid
+// dark line, margins/safe-area = magenta dashed. Chrome-engine constants, not
+// DS tokens — guides are never part of exported artboard content, same
+// reasoning as the foundation's own COLUMN_FILL/GRID_LINE constants.
+const BLEED_TINT = 'color-mix(in oklab, oklch(55% 0.22 25) 14%, transparent)';
+const TRIM_LINE = 'oklch(25% 0 0)';
+const MARGIN_LINE = 'oklch(58% 0.24 340)';
+
+const PrintOverlayContent: KindOverlayRenderFn = ({ rect, print, visibility }) => {
+  if (visibility.print !== true || !print) return null;
+
+  const bleedMm = resolveBleedMm(print);
+  const bleedPx = resolveMmPx(bleedMm);
+  const margins = resolveMarginsMm(print.marginsMm);
+  const marginPx = {
+    top: resolveMmPx(margins.top),
+    right: resolveMmPx(margins.right),
+    bottom: resolveMmPx(margins.bottom),
+    left: resolveMmPx(margins.left),
+  };
+
+  // Trim box — inset from the artboard (= bleed box, Design Decision 1) by
+  // bleedPx on every side.
+  const trimW = Math.max(0, rect.w - 2 * bleedPx);
+  const trimH = Math.max(0, rect.h - 2 * bleedPx);
+  // Safe/margin box — inset further from the trim box by marginPx per side.
+  const marginW = Math.max(0, trimW - marginPx.left - marginPx.right);
+  const marginH = Math.max(0, trimH - marginPx.top - marginPx.bottom);
+
+  return (
+    <>
+      {bleedPx > 0 ? (
+        <>
+          {/* Bleed zone — the annulus between the artboard edge and the trim
+              line, drawn as 4 tinted strips (never a single translucent box
+              over the whole artboard, which would also tint the live content
+              inside the trim box). */}
+          <div
+            style={{
+              position: 'absolute',
+              left: 0,
+              top: 0,
+              width: rect.w,
+              height: bleedPx,
+              background: BLEED_TINT,
+            }}
+          />
+          <div
+            style={{
+              position: 'absolute',
+              left: 0,
+              bottom: 0,
+              width: rect.w,
+              height: bleedPx,
+              background: BLEED_TINT,
+            }}
+          />
+          <div
+            style={{
+              position: 'absolute',
+              left: 0,
+              top: bleedPx,
+              width: bleedPx,
+              height: trimH,
+              background: BLEED_TINT,
+            }}
+          />
+          <div
+            style={{
+              position: 'absolute',
+              right: 0,
+              top: bleedPx,
+              width: bleedPx,
+              height: trimH,
+              background: BLEED_TINT,
+            }}
+          />
+        </>
+      ) : null}
+      {/* Trim line — the final cut edge, solid. */}
+      <div
+        style={{
+          position: 'absolute',
+          left: bleedPx,
+          top: bleedPx,
+          width: trimW,
+          height: trimH,
+          border: `1px solid ${TRIM_LINE}`,
+          boxSizing: 'border-box',
+        }}
+      />
+      {/* Safe-area / margin line — inset from trim, dashed. */}
+      {marginW > 0 && marginH > 0 ? (
+        <div
+          style={{
+            position: 'absolute',
+            left: bleedPx + marginPx.left,
+            top: bleedPx + marginPx.top,
+            width: marginW,
+            height: marginH,
+            border: `1px dashed ${MARGIN_LINE}`,
+            boxSizing: 'border-box',
+          }}
+        />
+      ) : null}
+    </>
+  );
+};
+PrintOverlayContent.displayName = 'PrintOverlayContent';
+
+registerKindOverlay('print', PrintOverlayContent);

package/apps/studio/test/acp-bridge.test.ts

@@ -52,7 +52,7 @@ describe('AcpBridge — round-trip + subscription guardrail', () => {
     }
   }, 15000);
 
-  test('setConfig passes model + effort to the child env (ANTHROPIC_MODEL / MAX_THINKING_TOKENS)', async () => {
+  test('model/effort are no longer env-at-spawn — a config change never respawns the running adapter', async () => {
     process.env.MAUDE_ACP_ADAPTER_ENTRY = FIXTURE;
     process.env.MAUDE_ACP_RUNTIME = process.execPath;
     process.env.MAUDE_CLAUDE_BIN = process.execPath;
@@ -60,19 +60,24 @@ describe('AcpBridge — round-trip + subscription guardrail', () => {
     const updates: unknown[] = [];
     const bridge = new AcpBridge({ repoRoot: process.cwd(), onUpdate: (u) => updates.push(u) });
     try {
+      // A persisted pick this mock doesn't advertise (it has no configOptions at
+      // all) is skipped best-effort, never forwarded to ANTHROPIC_MODEL/env.
       bridge.setConfig('opus', 'thorough');
       await bridge.prompt('hi', 'c1');
+      const sid = bridge.sessionId;
       const first = JSON.stringify(updates);
-      expect(first).toContain('model=opus');
-      expect(first).toContain('thinking=31999');
+      expect(first).toContain('model=<unset>');
+      expect(first).toContain('thinking=<unset>');
 
-      // Changing the config re-spawns with the new env on the next prompt.
+      // Changing the config again must NOT tear down / respawn the live process
+      // (Task A3 — the old configChanged()-triggered stop() is gone).
       updates.length = 0;
       bridge.setConfig(null, 'fast');
       await bridge.prompt('again', 'c1');
+      expect(bridge.sessionId).toBe(sid); // same session — no respawn happened
       const second = JSON.stringify(updates);
-      expect(second).toContain('model=<unset>'); // null model → ANTHROPIC_MODEL not set
-      expect(second).toContain('thinking=0'); // fast → thinking disabled
+      expect(second).toContain('model=<unset>');
+      expect(second).toContain('thinking=<unset>');
     } finally {
       await bridge.stop();
     }

package/apps/studio/test/acp-capabilities.test.ts

@@ -0,0 +1,123 @@
+// Pure unit tests for client/panels/acp-capabilities.js — the parsing +
+// persisted-pick-resolution helpers the dynamic CapabilityBar renders from.
+// No hardcoded model/effort/mode list is under test here BY DESIGN: these
+// functions must work for whatever the session actually advertises.
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  flattenSelectOptions,
+  parseConfigOptions,
+  parseModes,
+  resolvePersistedPick,
+} from '../client/panels/acp-capabilities.js';
+
+describe('parseConfigOptions', () => {
+  test('identifies model/effort/fast by id, excludes the mode-mirror entry, and buckets everything else into others', () => {
+    const configOptions = [
+      { id: 'model', category: 'model', currentValue: 'sonnet', options: [] },
+      { id: 'effort', category: 'thought_level', currentValue: 'default', options: [] },
+      { id: 'mode', category: 'mode', currentValue: 'default', options: [] },
+      { id: 'fast', category: 'model_config', currentValue: 'off', options: [] },
+      { id: 'agent', currentValue: 'default', options: [] }, // no category — the documented gap
+      { id: 'some-future-option', category: '_custom', currentValue: 'x', options: [] },
+    ];
+    const { model, effort, fast, others } = parseConfigOptions(configOptions);
+    expect(model?.id).toBe('model');
+    expect(effort?.id).toBe('effort');
+    expect(fast?.id).toBe('fast');
+    expect(others.map((o) => o.id)).toEqual(['agent', 'some-future-option']);
+  });
+
+  test('tolerates missing/empty/malformed input', () => {
+    expect(parseConfigOptions(undefined)).toEqual({
+      model: null,
+      effort: null,
+      fast: null,
+      others: [],
+    });
+    expect(parseConfigOptions(null)).toEqual({ model: null, effort: null, fast: null, others: [] });
+    expect(parseConfigOptions([])).toEqual({ model: null, effort: null, fast: null, others: [] });
+    // A non-object entry must not throw.
+    expect(parseConfigOptions([null, 'x', 42]).others).toEqual([]);
+  });
+
+  test('a session with only a subset of options omits the rest as null, not a stale default', () => {
+    const { model, effort, fast } = parseConfigOptions([{ id: 'model', options: [] }]);
+    expect(model).not.toBeNull();
+    expect(effort).toBeNull();
+    expect(fast).toBeNull();
+  });
+});
+
+describe('parseModes', () => {
+  test('returns current + available from a real SessionModeState', () => {
+    const modes = {
+      currentModeId: 'plan',
+      availableModes: [
+        { id: 'default', name: 'Manual' },
+        { id: 'plan', name: 'Plan Mode' },
+      ],
+    };
+    expect(parseModes(modes)).toEqual({
+      current: 'plan',
+      available: modes.availableModes,
+    });
+  });
+
+  test('an agent that never advertises modes yields an empty, non-throwing shape', () => {
+    expect(parseModes(null)).toEqual({ current: null, available: [] });
+    expect(parseModes(undefined)).toEqual({ current: null, available: [] });
+    expect(parseModes({})).toEqual({ current: null, available: [] });
+  });
+});
+
+describe('flattenSelectOptions', () => {
+  test('passes through a flat option list unchanged', () => {
+    const options = [
+      { value: 'a', name: 'A' },
+      { value: 'b', name: 'B' },
+    ];
+    expect(flattenSelectOptions(options)).toEqual(options);
+  });
+
+  test('flattens grouped SessionConfigSelectGroup[] into one leaf list', () => {
+    const options = [
+      { group: 'g1', name: 'Group 1', options: [{ value: 'a', name: 'A' }] },
+      {
+        group: 'g2',
+        name: 'Group 2',
+        options: [
+          { value: 'b', name: 'B' },
+          { value: 'c', name: 'C' },
+        ],
+      },
+    ];
+    expect(flattenSelectOptions(options).map((o) => o.value)).toEqual(['a', 'b', 'c']);
+  });
+
+  test('tolerates missing input', () => {
+    expect(flattenSelectOptions(undefined)).toEqual([]);
+    expect(flattenSelectOptions(null)).toEqual([]);
+  });
+});
+
+describe('resolvePersistedPick', () => {
+  test('prefers the saved pick when the session still offers it', () => {
+    expect(resolvePersistedPick(['opus', 'sonnet'], 'opus', 'sonnet')).toBe('opus');
+  });
+
+  test('falls back to the session default when the saved pick is no longer offered', () => {
+    expect(resolvePersistedPick(['sonnet', 'haiku'], 'opus', 'sonnet')).toBe('sonnet');
+  });
+
+  test('falls back to null when there is neither a valid saved pick nor a default', () => {
+    expect(resolvePersistedPick([], 'opus', undefined)).toBeNull();
+    expect(resolvePersistedPick([], null, null)).toBeNull();
+  });
+
+  test('a null/undefined saved value always defers to the default', () => {
+    expect(resolvePersistedPick(['a', 'b'], null, 'b')).toBe('b');
+    expect(resolvePersistedPick(['a', 'b'], undefined, 'a')).toBe('a');
+  });
+});