@1agh/maude 0.41.0 → 0.43.0

package/apps/studio/exporters/svg.ts

@@ -13,10 +13,11 @@ import path from 'node:path';
 import JSZip from 'jszip';
 
 import { getBrowserBundle } from './_browser-bundles.ts';
-import { exportShimPath, resolveExportRuntime } from './_runtime.ts';
+import { exportShimPath, runShim } from './_runtime.ts';
 import {
   canvasShellUrl,
   type ExportContext,
+  type ExportHooks,
   type ExportOptions,
   type ExportResult,
 } from './index.ts';
@@ -30,7 +31,8 @@ async function captureSvg(
   ctx: ExportContext,
   outDir: string,
   timeoutSec: number,
-  bundlePath: string
+  bundlePath: string,
+  hooks?: ExportHooks
 ): Promise<string[]> {
   const args = [
     SVG_PLAYWRIGHT,
@@ -55,31 +57,20 @@ async function captureSvg(
   // Run via a resolved node/bun runtime so the shim's `import 'playwright'`
   // resolves against dev-server/node_modules (playwright is a devDep). `npm exec`
   // doesn't bridge the module path for ESM imports — confirmed against npm 10.x.
-  // resolveExportRuntime() replaces a hardcoded `'node'` so a compiled binary
-  // without `node` on PATH surfaces an actionable error, not `posix_spawn 'node'`.
-  const proc = Bun.spawn([resolveExportRuntime(), ...args], {
+  // runShim resolves the runtime internally so a compiled binary without
+  // `node` on PATH surfaces an actionable error, not `posix_spawn 'node'`.
+  return runShim(args, {
     cwd: path.dirname(SVG_PLAYWRIGHT),
-    stdout: 'pipe',
-    stderr: 'pipe',
+    signal: hooks?.signal,
+    onProgress: hooks?.onProgress,
   });
-  const [stdout, stderr] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-  ]);
-  const code = await proc.exited;
-  if (code !== 0) {
-    throw new Error(`_svg-playwright exited ${code}: ${stderr.trim() || stdout.trim()}`);
-  }
-  return stdout
-    .split('\n')
-    .map((s) => s.trim())
-    .filter(Boolean);
 }
 
 export async function run(
   targets: Target[],
   options: ExportOptions,
-  ctx: ExportContext
+  ctx: ExportContext,
+  hooks?: ExportHooks
 ): Promise<ExportResult> {
   if (!targets.length) {
     return { filename: 'export.svg', contentType: 'image/svg+xml', body: new Uint8Array(0) };
@@ -96,9 +87,10 @@ export async function run(
 
   try {
     const written: string[] = [];
-    for (const t of elementTargets) {
-      const paths = await captureSvg(t, ctx, tmp, timeoutSec, bundlePath);
+    for (let i = 0; i < elementTargets.length; i += 1) {
+      const paths = await captureSvg(elementTargets[i], ctx, tmp, timeoutSec, bundlePath, hooks);
       written.push(...paths);
+      hooks?.onProgress?.({ current: i + 1, total: elementTargets.length });
     }
     if (!written.length) {
       return { filename: 'export.svg', contentType: 'image/svg+xml', body: new Uint8Array(0) };

package/apps/studio/exporters/video.ts

@@ -20,10 +20,11 @@ import { tmpdir } from 'node:os';
 import path from 'node:path';
 
 import { getEncodeLibBundle, getWebRendererBundle } from './_browser-bundles.ts';
-import { exportShimPath, resolveExportRuntime } from './_runtime.ts';
+import { exportShimPath, runShim } from './_runtime.ts';
 import {
   canvasShellUrl,
   type ExportContext,
+  type ExportHooks,
   type ExportOptions,
   type ExportResult,
 } from './index.ts';
@@ -47,7 +48,8 @@ async function runVideo(
   format: VideoFormat,
   targets: Target[],
   options: ExportOptions,
-  ctx: ExportContext
+  ctx: ExportContext,
+  hooks?: ExportHooks
 ): Promise<ExportResult> {
   const el = targets.find((t): t is Extract<Target, { kind: 'element' }> => t.kind === 'element');
   if (!el) {
@@ -119,27 +121,40 @@ async function runVideo(
   }
 
   try {
-    const proc = Bun.spawn([resolveExportRuntime(), ...args], {
+    const stdoutLines = await runShim(args, {
       cwd: path.dirname(VIDEO_PLAYWRIGHT),
-      stdout: 'pipe',
-      stderr: 'pipe',
+      signal: hooks?.signal,
+      // Frame-step capture emits `MAUDE_PROGRESS {current,total}` per frame → a
+      // live "N of M" progress bar in the Exports panel. This is exactly the
+      // slow path (the renderMediaOnWeb-overflow fallback can run many minutes);
+      // the fast one-pass renderer finishes before progress matters and reports
+      // none until done (it exposes no per-frame hook) — acceptable.
+      onProgress: hooks?.onProgress,
     });
-    const [stdout, stderr] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-    ]);
-    const code = await proc.exited;
-    if (code !== 0) {
-      throw new Error(`_video-playwright exited ${code}: ${stderr.trim() || stdout.trim()}`);
-    }
     const body = new Uint8Array(readFileSync(outPath));
     // The container can differ from the request (mp4 → webm fallback when the
-    // browser has no H.264 encoder). Read the summary line for the real ext.
+    // browser has no H.264 encoder). Read the summary line for the real ext, and
+    // for the degradation marker the shim sets when it had to fall back from the
+    // renderMediaOnWeb audio path to frame-step screenshots (RCA
+    // issue-video-mp4-rendermediaonweb-stack-overflow) — surfaced here so the
+    // dropped audio isn't silent (job stderr / logs; a UI toast is a follow-up).
     let ext: string = format;
     try {
-      const lastLine = stdout.trim().split('\n').filter(Boolean).pop() ?? '{}';
-      const summary = JSON.parse(lastLine) as { container?: string };
+      const lastLine = stdoutLines.at(-1) ?? '{}';
+      const summary = JSON.parse(lastLine) as {
+        container?: string;
+        degraded?: boolean;
+        audioDropped?: boolean;
+        fallbackReason?: string;
+      };
       if (summary.container) ext = summary.container;
+      if (summary.degraded) {
+        console.error(
+          `⚠ ${format} export degraded: the audio renderer failed ` +
+            `(${summary.fallbackReason ?? 'unknown'}), so this file was captured ` +
+            'frame-by-frame and has no audio.'
+        );
+      }
     } catch {
       /* keep the requested ext */
     }
@@ -174,11 +189,14 @@ function resolveFrames(options: ExportOptions, fps: number | undefined): number
 }
 
 export const mp4 = {
-  run: (t: Target[], o: ExportOptions, c: ExportContext) => runVideo('mp4', t, o, c),
+  run: (t: Target[], o: ExportOptions, c: ExportContext, h?: ExportHooks) =>
+    runVideo('mp4', t, o, c, h),
 };
 export const webm = {
-  run: (t: Target[], o: ExportOptions, c: ExportContext) => runVideo('webm', t, o, c),
+  run: (t: Target[], o: ExportOptions, c: ExportContext, h?: ExportHooks) =>
+    runVideo('webm', t, o, c, h),
 };
 export const gif = {
-  run: (t: Target[], o: ExportOptions, c: ExportContext) => runVideo('gif', t, o, c),
+  run: (t: Target[], o: ExportOptions, c: ExportContext, h?: ExportHooks) =>
+    runVideo('gif', t, o, c, h),
 };

package/apps/studio/footage/schema.test.ts

@@ -0,0 +1,195 @@
+// footage/schema — validator + helper coverage (feature-footage-analysis-director).
+// Mirrors the photo/schema house style: a valid fixture round-trips, and every
+// rejection lane (unknown key / bad type / out-of-range / non-relative asset /
+// end≤start / end>duration / bad transition presentation) is asserted so a
+// crafted field can never reach disk via the `/_api/footage` route.
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  EDL_VERSION,
+  type Edl,
+  emptyFootageAnalysis,
+  FOOTAGE_ANALYSIS_VERSION,
+  type FootageAnalysis,
+  isEmptyAnalysis,
+  validateEdl,
+  validateFootageAnalysis,
+} from './schema.ts';
+
+const GOOD_ANALYSIS: FootageAnalysis = {
+  version: FOOTAGE_ANALYSIS_VERSION,
+  asset: 'assets/a1b2c3d4.mp4',
+  durationSec: 12.5,
+  width: 1920,
+  height: 1080,
+  keyframes: 12,
+  shots: [
+    {
+      start: 0,
+      end: 3.2,
+      kind: 'establishing',
+      motion: 'push-in',
+      subject: 'drone push over the river',
+      lighting: 'golden hour',
+      mood: 'calm',
+      quality: 0.9,
+      usable: true,
+      note: 'hero shot',
+    },
+    { start: 4, end: 6, kind: 'detail', usable: false },
+  ],
+  summary: 'Calm aspirational exterior b-roll.',
+  tags: ['rebrand', 'exterior'],
+};
+
+const GOOD_EDL: Edl = {
+  version: EDL_VERSION,
+  title: 'Alligators rebrand reel',
+  fps: 30,
+  width: 1920,
+  height: 1080,
+  beats: [
+    {
+      clip: 'assets/a1b2c3d4.mp4',
+      startSec: 0,
+      durationFrames: 60,
+      name: 'intro',
+      transition: null,
+    },
+    {
+      clip: 'assets/a1b2c3d4.mp4',
+      startSec: 8,
+      durationFrames: 45,
+      why: 'second shot from the same clip',
+      transition: { presentation: 'fade', frames: 15 },
+      overlay: { kind: 'title', text: 'Alligators' },
+      name: 'hero',
+    },
+  ],
+  music: { asset: 'assets/deadbeef.mp3', fadeOutFrames: 20 },
+};
+
+describe('validateFootageAnalysis', () => {
+  test('accepts a well-formed analysis', () => {
+    expect(validateFootageAnalysis(GOOD_ANALYSIS)).toEqual({ ok: true, errors: [] });
+  });
+
+  test('accepts an empty analysis from the helper', () => {
+    expect(validateFootageAnalysis(emptyFootageAnalysis('assets/a1b2c3d4.mp4')).ok).toBe(true);
+  });
+
+  test('rejects a non-object root', () => {
+    expect(validateFootageAnalysis(null).ok).toBe(false);
+    expect(validateFootageAnalysis(42).ok).toBe(false);
+  });
+
+  test('rejects an unknown top-level key', () => {
+    const r = validateFootageAnalysis({ ...GOOD_ANALYSIS, evil: 1 });
+    expect(r.ok).toBe(false);
+    expect(r.errors.join()).toContain('unknown key "evil"');
+  });
+
+  test('rejects a non-relative / traversing asset path', () => {
+    for (const asset of ['/etc/passwd', '../secret.mp4', 'assets/../x.mp4', 'http://x/y.mp4']) {
+      expect(validateFootageAnalysis({ ...GOOD_ANALYSIS, asset }).ok).toBe(false);
+    }
+  });
+
+  test('rejects a shot whose end ≤ start', () => {
+    const r = validateFootageAnalysis({
+      ...GOOD_ANALYSIS,
+      shots: [{ start: 5, end: 5 }],
+    });
+    expect(r.ok).toBe(false);
+    expect(r.errors.join()).toContain('end must be > start');
+  });
+
+  test('rejects a shot that runs past the clip duration', () => {
+    const r = validateFootageAnalysis({
+      ...GOOD_ANALYSIS,
+      durationSec: 5,
+      shots: [{ start: 1, end: 9 }],
+    });
+    expect(r.ok).toBe(false);
+    expect(r.errors.join()).toContain('exceeds clip duration');
+  });
+
+  test('rejects an out-of-range quality + bad shot kind', () => {
+    expect(
+      validateFootageAnalysis({ ...GOOD_ANALYSIS, shots: [{ start: 0, end: 1, quality: 2 }] }).ok
+    ).toBe(false);
+    expect(
+      validateFootageAnalysis({ ...GOOD_ANALYSIS, shots: [{ start: 0, end: 1, kind: 'nope' }] }).ok
+    ).toBe(false);
+  });
+});
+
+describe('isEmptyAnalysis', () => {
+  test('true for null / no shots / no usable shots', () => {
+    expect(isEmptyAnalysis(null)).toBe(true);
+    expect(isEmptyAnalysis({ shots: [] })).toBe(true);
+    expect(isEmptyAnalysis({ shots: [{ start: 0, end: 1, usable: false }] })).toBe(true);
+  });
+  test('false when at least one shot is usable', () => {
+    expect(isEmptyAnalysis(GOOD_ANALYSIS)).toBe(false);
+  });
+});
+
+describe('validateEdl', () => {
+  test('accepts a well-formed EDL', () => {
+    expect(validateEdl(GOOD_EDL)).toEqual({ ok: true, errors: [] });
+  });
+
+  test('rejects a beat with no clip', () => {
+    const r = validateEdl({ ...GOOD_EDL, beats: [{ startSec: 0, durationFrames: 30 }] });
+    expect(r.ok).toBe(false);
+    expect(r.errors.join()).toContain('clip');
+  });
+
+  test('rejects a non-relative beat clip', () => {
+    expect(
+      validateEdl({ ...GOOD_EDL, beats: [{ clip: '/x.mp4', startSec: 0, durationFrames: 30 }] }).ok
+    ).toBe(false);
+  });
+
+  test('rejects durationFrames < 1 / non-integer', () => {
+    expect(
+      validateEdl({
+        ...GOOD_EDL,
+        beats: [{ clip: 'assets/a1b2c3d4.mp4', startSec: 0, durationFrames: 0 }],
+      }).ok
+    ).toBe(false);
+    expect(
+      validateEdl({
+        ...GOOD_EDL,
+        beats: [{ clip: 'assets/a1b2c3d4.mp4', startSec: 0, durationFrames: 12.5 }],
+      }).ok
+    ).toBe(false);
+  });
+
+  test('rejects an unbundled transition presentation', () => {
+    const r = validateEdl({
+      ...GOOD_EDL,
+      beats: [
+        {
+          clip: 'assets/a1b2c3d4.mp4',
+          startSec: 0,
+          durationFrames: 30,
+          transition: { presentation: 'dreamy-zoom', frames: 10 },
+        },
+      ],
+    });
+    expect(r.ok).toBe(false);
+    expect(r.errors.join()).toContain('presentation');
+  });
+
+  test('rejects an fps above 120 / below 1', () => {
+    expect(validateEdl({ ...GOOD_EDL, fps: 999 }).ok).toBe(false);
+    expect(validateEdl({ ...GOOD_EDL, fps: 0 }).ok).toBe(false);
+  });
+
+  test('rejects a music bed with a non-relative asset', () => {
+    expect(validateEdl({ ...GOOD_EDL, music: { asset: 'http://x/y.mp3' } }).ok).toBe(false);
+  });
+});