@1agh/maude 0.45.1 → 0.46.0

package/apps/studio/http.ts

@@ -17,7 +17,7 @@ import {
   startSignin,
 } from './acp/login-state.ts';
 import { probeAcpAvailabilityAuthed } from './acp/probe.ts';
-import { deleteChat, listChats, readChatMessages } from './acp/transcript.ts';
+import { deleteChat, listChats, readChatMessages, writeChatMeta } from './acp/transcript.ts';
 import { type Api, ASSET_MAX_BYTES, ASSET_MAX_VIDEO_BYTES } from './api.ts';
 import { ImportAssetError, importSvg, SVG_MAX_BYTES } from './bin/_import-asset.mjs';
 import { ImportBrandError, importBrand } from './bin/_import-brand.mjs';
@@ -40,6 +40,12 @@ import {
   sanitizeReuseText,
 } from './generation/audio-library.ts';
 import { localizeGenAsset } from './generation/download.ts';
+import {
+  downloadGemmaModel,
+  ffmpegAvailable,
+  listGemmaModels,
+  mlxVlmAvailable,
+} from './generation/gemma-models.ts';
 import { type GenerationJobQueue, GenerationQueueFullError } from './generation/jobs.ts';
 import {
   configuredProviders,
@@ -49,8 +55,11 @@ import {
   setProviderKey,
 } from './generation/keys.ts';
 import {
+  isKeyframeEngine,
   isTranscriptionProvider,
+  readKeyframeEngine,
   readTranscriptionProvider,
+  writeKeyframeEngine,
   writeTranscriptionProvider,
 } from './generation/prefs.ts';
 import {
@@ -691,6 +700,12 @@ export function createHttp(
     error?: string;
   } | null = null;
 
+  // feature-scene-aware-keyframes — in-flight Gemma-model download state, polled by
+  // the Settings "Scene-aware keyframes" card via GET /_api/generate/keyframe-model.
+  // Closure-scoped: one server, one download.
+  let keyframeDownload: { id: string; received: number; total: number; error?: string } | null =
+    null;
+
   // Cache invalidation — when canvas-lib changes, every cached canvas bundle
   // is stale because canvas-lib is inlined into each one via the resolver
   // plugin. Drop the whole cache so the next request rebuilds with the fresh
@@ -1017,7 +1032,7 @@ export function createHttp(
       Response.json(listChats(ctx.paths.designRoot), {
         headers: { 'Cache-Control': 'no-store' },
       }),
-    '/_api/acp/chat': (req: Request) => {
+    '/_api/acp/chat': async (req: Request) => {
       const id = (new URL(req.url).searchParams.get('id') ?? '')
         .replace(/[^a-z0-9_-]/gi, '')
         .slice(0, 64);
@@ -1025,6 +1040,37 @@ export function createHttp(
         const removed = id ? deleteChat(ctx.paths.designRoot, id) : false;
         return Response.json({ ok: removed }, { headers: { 'Cache-Control': 'no-store' } });
       }
+      // Task C5 — Rename / Archive from the chat switcher's overflow menu.
+      // Same CSRF + loopback gate as every other privileged write route
+      // (DDR-088); id is already sanitized/contained above.
+      if (req.method === 'PATCH') {
+        if (!sameOriginWrite(req))
+          return new Response('cross-origin write rejected', { status: 403 });
+        if (!isLoopbackHost(req.headers.get('host')))
+          return new Response('local request required (DNS-rebinding guard)', { status: 403 });
+        if (!id) return new Response('missing id', { status: 400 });
+        let body: unknown;
+        try {
+          body = await req.json();
+        } catch {
+          return new Response('invalid JSON body', { status: 400 });
+        }
+        if (!body || typeof body !== 'object') return new Response('invalid body', { status: 400 });
+        const b = body as { title?: unknown; archived?: unknown };
+        const patch: { title?: string | null; archived?: boolean } = {};
+        if ('title' in b) {
+          if (b.title === null) patch.title = null;
+          else if (typeof b.title === 'string') patch.title = b.title;
+          else return new Response('title must be a string or null', { status: 400 });
+        }
+        if ('archived' in b) {
+          if (typeof b.archived !== 'boolean')
+            return new Response('archived must be a boolean', { status: 400 });
+          patch.archived = b.archived;
+        }
+        const meta = writeChatMeta(ctx.paths.designRoot, id, patch);
+        return Response.json(meta, { headers: { 'Cache-Control': 'no-store' } });
+      }
       if (!id) return Response.json([], { headers: { 'Cache-Control': 'no-store' } });
       return Response.json(readChatMessages(ctx.paths.designRoot, id), {
         headers: { 'Cache-Control': 'no-store' },
@@ -2390,6 +2436,98 @@ export function createHttp(
       );
     },
 
+    '/_api/set-artboard-kind': async (req: Request) => {
+      // feature-1-artboard-kinds-foundation, T8. POST { canvas, artboardId,
+      // kind: 'digital'|'print'|'web'|'video'|null } → api.setArtboardKindOp.
+      // `null` clears the explicit prop back to the implicit default. Whole-
+      // file undo seq. MAIN-ORIGIN ONLY; same gate pair as set-artboard-style
+      // (the kind-switch surfaces — context menu, Inspector — are shell UI,
+      // never reachable from the untrusted canvas origin).
+      if (req.method !== 'POST') return new Response('Method not allowed', { status: 405 });
+      if (!sameOriginWrite(req))
+        return new Response('cross-origin write rejected', { status: 403 });
+      if (!isLoopbackHost(req.headers.get('host')))
+        return new Response('local request required (DNS-rebinding guard)', { status: 403 });
+      const body = await readJson<{
+        canvas?: unknown;
+        artboardId?: unknown;
+        kind?: unknown;
+      }>(req, 2 * 1024);
+      if (!body) return new Response('body required', { status: 400 });
+      const result = await api.setArtboardKindOp(body);
+      if (!result.ok) {
+        return Response.json(
+          { ok: false, error: result.error },
+          { status: result.status, headers: { 'Cache-Control': 'no-store' } }
+        );
+      }
+      return Response.json(
+        { ok: true, seq: result.seq },
+        { status: 200, headers: { 'Cache-Control': 'no-store' } }
+      );
+    },
+
+    '/_api/set-artboard-guides': async (req: Request) => {
+      // feature-1-artboard-kinds-foundation, T5. POST { canvas, artboardId,
+      // guides: {...}|null } → api.setArtboardGuidesOp. REPLACE-whole-prop
+      // (see applySetArtboardGuides doc comment) — the caller sends the full
+      // merged object, not a delta. MAIN-ORIGIN ONLY; same gate pair as
+      // set-artboard-style.
+      if (req.method !== 'POST') return new Response('Method not allowed', { status: 405 });
+      if (!sameOriginWrite(req))
+        return new Response('cross-origin write rejected', { status: 403 });
+      if (!isLoopbackHost(req.headers.get('host')))
+        return new Response('local request required (DNS-rebinding guard)', { status: 403 });
+      const body = await readJson<{
+        canvas?: unknown;
+        artboardId?: unknown;
+        guides?: unknown;
+      }>(req, 8 * 1024);
+      if (!body) return new Response('body required', { status: 400 });
+      const result = await api.setArtboardGuidesOp(body);
+      if (!result.ok) {
+        return Response.json(
+          { ok: false, error: result.error },
+          { status: result.status, headers: { 'Cache-Control': 'no-store' } }
+        );
+      }
+      return Response.json(
+        { ok: true, seq: result.seq },
+        { status: 200, headers: { 'Cache-Control': 'no-store' } }
+      );
+    },
+
+    '/_api/set-artboard-print': async (req: Request) => {
+      // feature-2-print-artboards T2. POST { canvas, artboardId, print:
+      // {paper, orientation?, bleedMm?, marginsMm?}|null } → api.setArtboardPrintOp.
+      // REPLACE-whole-prop (see applySetArtboardPrint's own doc comment) — the
+      // caller sends the full merged object, not a delta. MAIN-ORIGIN ONLY;
+      // same gate pair as set-artboard-guides (Inspector picker is shell UI,
+      // never reachable from the untrusted canvas origin).
+      if (req.method !== 'POST') return new Response('Method not allowed', { status: 405 });
+      if (!sameOriginWrite(req))
+        return new Response('cross-origin write rejected', { status: 403 });
+      if (!isLoopbackHost(req.headers.get('host')))
+        return new Response('local request required (DNS-rebinding guard)', { status: 403 });
+      const body = await readJson<{
+        canvas?: unknown;
+        artboardId?: unknown;
+        print?: unknown;
+      }>(req, 2 * 1024);
+      if (!body) return new Response('body required', { status: 400 });
+      const result = await api.setArtboardPrintOp(body);
+      if (!result.ok) {
+        return Response.json(
+          { ok: false, error: result.error },
+          { status: result.status, headers: { 'Cache-Control': 'no-store' } }
+        );
+      }
+      return Response.json(
+        { ok: true, seq: result.seq },
+        { status: 200, headers: { 'Cache-Control': 'no-store' } }
+      );
+    },
+
     '/_api/delete-artboard': async (req: Request) => {
       // Delete an artboard by its `id` prop (Backspace / context-menu on a frame).
       // POST { canvas, artboardId } → api.deleteArtboardOp (removes the
@@ -2911,20 +3049,38 @@ export function createHttp(
         return new Response('local request required (DNS-rebinding guard)', { status: 403 });
       if (req.method === 'GET') {
         return Response.json(
-          { transcriptionProvider: readTranscriptionProvider(ctx.paths.repoRoot) },
+          {
+            transcriptionProvider: readTranscriptionProvider(ctx.paths.repoRoot),
+            keyframeEngine: readKeyframeEngine(ctx.paths.repoRoot),
+          },
           { headers: { 'Cache-Control': 'no-store' } }
         );
       }
       if (req.method !== 'POST') return new Response('Method not allowed', { status: 405 });
       if (!sameOriginWrite(req))
         return new Response('cross-origin write rejected', { status: 403 });
-      const body = await readJson<{ transcriptionProvider?: unknown }>(req, 4 * 1024);
-      const provider = body?.transcriptionProvider;
-      if (!isTranscriptionProvider(provider))
-        return new Response('transcriptionProvider must be whisper|elevenlabs|groq', {
-          status: 400,
-        });
+      const body = await readJson<{ transcriptionProvider?: unknown; keyframeEngine?: unknown }>(
+        req,
+        4 * 1024
+      );
+      // The panel POSTs ONE pref at a time (transcription engine OR keyframe engine).
       try {
+        if ('keyframeEngine' in (body ?? {})) {
+          const engine = body?.keyframeEngine;
+          if (!isKeyframeEngine(engine))
+            return new Response('keyframeEngine must be auto|gemma|ffmpeg|blind', { status: 400 });
+          await writeKeyframeEngine(ctx.paths.repoRoot, engine);
+          reloadConfig(ctx);
+          return Response.json(
+            { keyframeEngine: engine },
+            { headers: { 'Cache-Control': 'no-store' } }
+          );
+        }
+        const provider = body?.transcriptionProvider;
+        if (!isTranscriptionProvider(provider))
+          return new Response('transcriptionProvider must be whisper|elevenlabs|groq', {
+            status: 400,
+          });
         await writeTranscriptionProvider(ctx.paths.repoRoot, provider);
         reloadConfig(ctx);
         return Response.json(
@@ -3146,6 +3302,87 @@ export function createHttp(
       );
     },
 
+    // feature-scene-aware-keyframes — managed local Gemma-4 MLX scout models: GET
+    // lists the registry + which are downloaded + any in-flight download + the two
+    // availability signals (mlx-vlm runtime, ffmpeg) the Settings card needs to say
+    // which tier will run; POST {id} downloads one via huggingface_hub (gated on
+    // mlx-vlm being installed — the model is useless without it). MAIN-ORIGIN ONLY.
+    '/_api/generate/keyframe-model': async (req: Request) => {
+      if (!isLoopbackHost(req.headers.get('host')))
+        return new Response('local request required (DNS-rebinding guard)', { status: 403 });
+      if (req.method === 'GET') {
+        // The GET builds availability by spawning subprocesses (import mlx_vlm is
+        // heavy). Gate it same-origin so a cross-origin no-cors flood can't drive a
+        // spawn-storm against the loopback server (DDR-183 security finding — the
+        // sibling audio-search GET added this guard for the same reason). The probes
+        // are also TTL-cached in gemma-models.ts as defence-in-depth.
+        if (!sameOriginRead(req))
+          return new Response('cross-origin read rejected', { status: 403 });
+        return Response.json(
+          {
+            models: listGemmaModels(),
+            downloading: keyframeDownload,
+            mlxVlmAvailable: mlxVlmAvailable(),
+            ffmpegAvailable: ffmpegAvailable(),
+          },
+          { headers: { 'Cache-Control': 'no-store' } }
+        );
+      }
+      if (req.method === 'DELETE') {
+        // Free a wedged download slot (a stalled HF connection) without waiting out
+        // the 60-min abort timeout (DDR-183 F4). Same-origin write-gated.
+        if (!sameOriginWrite(req))
+          return new Response('cross-origin write rejected', { status: 403 });
+        keyframeDownload = null;
+        return Response.json({ cancelled: true }, { headers: { 'Cache-Control': 'no-store' } });
+      }
+      if (req.method !== 'POST') return new Response('Method not allowed', { status: 405 });
+      if (!sameOriginWrite(req))
+        return new Response('cross-origin write rejected', { status: 403 });
+      if (!mlxVlmAvailable())
+        return new Response(
+          'mlx-vlm not installed — the Gemma scout needs an Apple-Silicon Mac + `pip install mlx-vlm`.',
+          {
+            status: 400,
+          }
+        );
+      const body = await readJson<{ id?: unknown }>(req, 4 * 1024);
+      const id = typeof body?.id === 'string' ? body.id : '';
+      if (!listGemmaModels().some((m) => m.id === id))
+        return new Response('unknown model id', { status: 400 });
+      if (keyframeDownload && !keyframeDownload.error)
+        return new Response(`a download is already in progress (${keyframeDownload.id})`, {
+          status: 409,
+        });
+      keyframeDownload = { id, received: 0, total: 0 };
+      void downloadGemmaModel(
+        id,
+        (received, total) => {
+          if (keyframeDownload && keyframeDownload.id === id) {
+            keyframeDownload.received = received;
+            keyframeDownload.total = total;
+          }
+        },
+        AbortSignal.timeout(60 * 60_000) // multi-GB snapshots on a slow link
+      )
+        .then(() => {
+          if (keyframeDownload?.id === id) keyframeDownload = null;
+        })
+        .catch((err) => {
+          if (keyframeDownload?.id === id)
+            keyframeDownload = {
+              id,
+              received: keyframeDownload.received,
+              total: keyframeDownload.total,
+              error: err instanceof Error ? err.message : 'download failed',
+            };
+        });
+      return Response.json(
+        { started: id },
+        { status: 202, headers: { 'Cache-Control': 'no-store' } }
+      );
+    },
+
     '/_canvas-state': async (req: Request) => {
       const url = new URL(req.url);
       if (req.method === 'GET') {

package/apps/studio/print/marks.ts

@@ -0,0 +1,113 @@
+// feature-2-print-artboards T1/T5 — pure crop/registration-mark geometry.
+//
+// Consumed by the pdf-lib post-pass (T5) to draw vector marks, and reusable
+// by a future on-canvas marks preview (T3 left that optional — see the plan).
+// Coordinates are PDF POINTS in the BLEED-BOX-origin space: x ∈ [0, pageWidthPt],
+// y ∈ [0, pageHeightPt] is the rendered page itself (Chromium's page.pdf()
+// output, unchanged); marks live OUTSIDE that box, at negative coordinates or
+// beyond pageWidthPt/pageHeightPt. The pdf-lib post-pass enlarges MediaBox
+// with a negative origin to make room for them without moving page content.
+
+import { MARK_LENGTH_MM, MARK_STROKE_MM, mmToPt } from './units.ts';
+
+export interface LineSegment {
+  x1: number;
+  y1: number;
+  x2: number;
+  y2: number;
+}
+
+export interface Circle {
+  cx: number;
+  cy: number;
+  r: number;
+}
+
+export interface RegistrationMark {
+  circle: Circle;
+  crosshair: LineSegment[];
+}
+
+export interface MarksGeometry {
+  cropMarks: LineSegment[];
+  registrationMarks: RegistrationMark[];
+}
+
+const REG_RADIUS_MM = 1.5;
+const REG_GAP_MM = 1;
+
+/**
+ * The extra margin MediaBox must extend beyond the bleed box on every side to
+ * fit the requested marks without clipping. Callers ask for this BEFORE
+ * calling computeMarksGeometry, to size the enlarged MediaBox first.
+ */
+export function requiredSlugPt(args: { crop?: boolean; registration?: boolean }): number {
+  const markLen = mmToPt(MARK_LENGTH_MM);
+  let slug = 0;
+  if (args.crop) slug = Math.max(slug, markLen);
+  if (args.registration) {
+    slug = Math.max(slug, markLen + mmToPt(REG_GAP_MM) + 2 * mmToPt(REG_RADIUS_MM));
+  }
+  return slug;
+}
+
+/**
+ * Compute crop-mark (8 segments, 2 per corner) and registration-mark (4,
+ * side-midpoints) geometry for a page of the given size + bleed. Crop marks
+ * are aligned to the TRIM line but drawn starting exactly at the bleed-box
+ * edge (T1's "offset = bleed"), extending outward by `MARK_LENGTH_MM`.
+ * Registration marks sit just beyond the crop marks' reach.
+ */
+export function computeMarksGeometry(args: {
+  pageWidthPt: number;
+  pageHeightPt: number;
+  bleedPt: number;
+  crop?: boolean;
+  registration?: boolean;
+}): MarksGeometry {
+  const { pageWidthPt, pageHeightPt, bleedPt } = args;
+  const markLen = mmToPt(MARK_LENGTH_MM);
+  const trimX0 = bleedPt;
+  const trimY0 = bleedPt;
+  const trimX1 = pageWidthPt - bleedPt;
+  const trimY1 = pageHeightPt - bleedPt;
+
+  const cropMarks: LineSegment[] = [];
+  if (args.crop) {
+    // Bottom-left
+    cropMarks.push({ x1: trimX0, y1: 0, x2: trimX0, y2: -markLen });
+    cropMarks.push({ x1: 0, y1: trimY0, x2: -markLen, y2: trimY0 });
+    // Bottom-right
+    cropMarks.push({ x1: trimX1, y1: 0, x2: trimX1, y2: -markLen });
+    cropMarks.push({ x1: pageWidthPt, y1: trimY0, x2: pageWidthPt + markLen, y2: trimY0 });
+    // Top-left
+    cropMarks.push({ x1: trimX0, y1: pageHeightPt, x2: trimX0, y2: pageHeightPt + markLen });
+    cropMarks.push({ x1: 0, y1: trimY1, x2: -markLen, y2: trimY1 });
+    // Top-right
+    cropMarks.push({ x1: trimX1, y1: pageHeightPt, x2: trimX1, y2: pageHeightPt + markLen });
+    cropMarks.push({ x1: pageWidthPt, y1: trimY1, x2: pageWidthPt + markLen, y2: trimY1 });
+  }
+
+  const registrationMarks: RegistrationMark[] = [];
+  if (args.registration) {
+    const regR = mmToPt(REG_RADIUS_MM);
+    const offset = markLen + mmToPt(REG_GAP_MM) + regR;
+    const mk = (cx: number, cy: number): RegistrationMark => ({
+      circle: { cx, cy, r: regR },
+      crosshair: [
+        { x1: cx - regR, y1: cy, x2: cx + regR, y2: cy },
+        { x1: cx, y1: cy - regR, x2: cx, y2: cy + regR },
+      ],
+    });
+    registrationMarks.push(
+      mk(pageWidthPt / 2, pageHeightPt + offset), // top-center
+      mk(pageWidthPt / 2, -offset), // bottom-center
+      mk(-offset, pageHeightPt / 2), // left-center
+      mk(pageWidthPt + offset, pageHeightPt / 2) // right-center
+    );
+  }
+
+  return { cropMarks, registrationMarks };
+}
+
+export const MARK_STROKE_PT = mmToPt(MARK_STROKE_MM);