@1agh/maude 1.0.11 → 1.2.0

package/apps/studio/test/use-undo-stack.test.tsx

@@ -1,223 +0,0 @@
-// use-undo-stack — Provider runner contract. SSR-capture pattern + ref-as-
-// store means most of the interesting state lives outside React renders,
-// so we exercise the action closures directly. Pure reducer is covered in
-// undo-stack.test.ts.
-
-import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test';
-
-import { renderToStaticMarkup } from 'react-dom/server';
-
-import {
-  _clearBuilderRegistry,
-  _clearStackStore,
-  type CommandRecord,
-  type CommandSinks,
-  registerCommand,
-} from '../undo-stack.ts';
-import {
-  UndoStackProvider,
-  useUndoSinks,
-  useUndoStack,
-  useUndoStackOptional,
-} from '../use-undo-stack.tsx';
-
-// Shared spy plumbing for record-builder tests below.
-let doSpy: ReturnType<typeof mock>;
-let undoSpy: ReturnType<typeof mock>;
-
-beforeEach(() => {
-  _clearStackStore();
-  _clearBuilderRegistry();
-  doSpy = mock(() => {});
-  undoSpy = mock(() => {});
-  // A single "test" command kind shared across this file. The builder reads
-  // `sinks.layoutPatchFn` as a generic "trigger" — when present, do() and
-  // undo() fire the spies; when absent, rebuild returns null.
-  registerCommand('test', (record, sinks) => {
-    if (!sinks.layoutPatchFn) return null;
-    return {
-      kind: record.kind,
-      label: record.label,
-      do() {
-        doSpy(record.payload);
-      },
-      undo() {
-        undoSpy(record.payload);
-      },
-    };
-  });
-});
-
-afterEach(() => {
-  _clearStackStore();
-});
-
-function rec(label: string, payload: unknown = null): CommandRecord {
-  return { kind: 'test', label, payload };
-}
-
-function capture<T>(useHook: () => T, tree: (consumer: React.ReactElement) => React.ReactElement) {
-  let captured: T | null = null;
-  function Consumer() {
-    captured = useHook();
-    return null;
-  }
-  renderToStaticMarkup(tree(<Consumer />));
-  if (!captured) throw new Error('hook did not capture a value');
-  return captured;
-}
-
-/**
- * Render a provider tree and capture both the stack value and the sinks API.
- * Sinks are bound during the same SSR render via a sibling capture, so the
- * runner's first push() sees the registered sink.
- */
-function captureProvider(canvasFile?: string, sinks?: Partial<CommandSinks>) {
-  let stack: ReturnType<typeof useUndoStack> | null = null;
-  function Inner() {
-    stack = useUndoStack();
-    const undoSinks = useUndoSinks();
-    if (sinks) {
-      for (const [k, v] of Object.entries(sinks)) {
-        // biome-ignore lint/suspicious/noExplicitAny: setSink generic indexing
-        undoSinks.setSink(k as never, v as any);
-      }
-    }
-    return null;
-  }
-  renderToStaticMarkup(
-    <UndoStackProvider canvasFile={canvasFile}>
-      <Inner />
-    </UndoStackProvider>
-  );
-  if (!stack) throw new Error('no provider value captured');
-  return stack;
-}
-
-describe('use-undo-stack / contract outside provider', () => {
-  test('useUndoStack() throws outside provider', () => {
-    function Bare() {
-      useUndoStack();
-      return null;
-    }
-    expect(() => renderToStaticMarkup(<Bare />)).toThrow(
-      /useUndoStack must be used inside <UndoStackProvider>/
-    );
-  });
-
-  test('useUndoStackOptional() returns no-op value outside provider', () => {
-    const value = capture(useUndoStackOptional, (child) => <>{child}</>);
-    expect(value.canUndo).toBe(false);
-    expect(value.canRedo).toBe(false);
-    expect(value.lastLabel).toBeNull();
-    expect(() => value.clear()).not.toThrow();
-  });
-
-  test('useUndoSinks() outside provider is a silent no-op', () => {
-    const value = capture(useUndoSinks, (child) => <>{child}</>);
-    expect(() => value.setSink('layoutPatchFn', () => {})).not.toThrow();
-  });
-});
-
-describe('use-undo-stack / runner side-effects', () => {
-  test('push() invokes rebuilt cmd.do() exactly once', async () => {
-    const v = captureProvider(undefined, { layoutPatchFn: () => {} });
-    await v.push(rec('move 1'));
-    expect(doSpy).toHaveBeenCalledTimes(1);
-    expect(undoSpy).toHaveBeenCalledTimes(0);
-  });
-
-  test('undo() invokes cmd.undo() on the most recently pushed record', async () => {
-    const v = captureProvider(undefined, { layoutPatchFn: () => {} });
-    await v.push(rec('a', 'A'));
-    await v.push(rec('b', 'B'));
-    await v.undo();
-    expect(undoSpy).toHaveBeenCalledTimes(1);
-    expect(undoSpy.mock.calls[0]?.[0]).toBe('B');
-  });
-
-  test('redo() re-invokes cmd.do() on the most recently undone record', async () => {
-    const v = captureProvider(undefined, { layoutPatchFn: () => {} });
-    await v.push(rec('a', 'A'));
-    await v.undo();
-    await v.redo();
-    expect(doSpy).toHaveBeenCalledTimes(2);
-    expect(doSpy.mock.calls[1]?.[0]).toBe('A');
-  });
-
-  test('push without a registered sink skips the do() call (rebuild returned null)', async () => {
-    const v = captureProvider(undefined, {}); // no sinks → builder returns null
-    await v.push(rec('lonely'));
-    // doSpy is the only observable signal here — `lastLabel` is React
-    // state that doesn't refresh under SSR-capture.
-    expect(doSpy).toHaveBeenCalledTimes(0);
-    expect(undoSpy).toHaveBeenCalledTimes(0);
-  });
-});
-
-describe('use-undo-stack / record (already-applied edits)', () => {
-  test('record() appends WITHOUT running do()', async () => {
-    const v = captureProvider(undefined, { layoutPatchFn: () => {} });
-    v.record(rec('inline-edit', 'X'));
-    // undo() is enqueued after record(), so awaiting it flushes record first.
-    await v.undo();
-    expect(doSpy).toHaveBeenCalledTimes(0); // record never runs do()
-    expect(undoSpy).toHaveBeenCalledTimes(1);
-    expect(undoSpy.mock.calls[0]?.[0]).toBe('X');
-  });
-
-  test('record() then redo() (after undo) re-runs do()', async () => {
-    const v = captureProvider(undefined, { layoutPatchFn: () => {} });
-    v.record(rec('e', 'Y'));
-    await v.undo();
-    await v.redo();
-    expect(doSpy).toHaveBeenCalledTimes(1); // only redo's do(), not the record
-    expect(doSpy.mock.calls[0]?.[0]).toBe('Y');
-  });
-
-  test('record() clears the redo future', async () => {
-    const v = captureProvider(undefined, { layoutPatchFn: () => {} });
-    await v.push(rec('a', 'A')); // doSpy: 1
-    await v.undo(); // future = [a]
-    v.record(rec('b', 'B')); // clears future
-    await v.redo(); // future empty → no-op, no extra do()
-    expect(doSpy).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe('use-undo-stack / cross-canvas persistence', () => {
-  test('history under a canvasFile survives a fresh provider mount with the same canvasFile', async () => {
-    // First mount: push 2 records.
-    {
-      const v = captureProvider('ui/Foo.tsx', { layoutPatchFn: () => {} });
-      await v.push(rec('e1'));
-      await v.push(rec('e2'));
-    }
-    // Second mount (simulates iframe destroy + remount for same canvas).
-    const v2 = captureProvider('ui/Foo.tsx', { layoutPatchFn: () => {} });
-    expect(v2.canUndo).toBe(true);
-    expect(v2.lastLabel).toBeNull(); // labels are per-mount session
-    // Undo the top — should fire spy with rec('e2') payload.
-    await v2.undo();
-    expect(undoSpy).toHaveBeenCalledTimes(1);
-  });
-
-  test('switching canvases keeps each history independent', async () => {
-    {
-      const v = captureProvider('ui/Foo.tsx', { layoutPatchFn: () => {} });
-      await v.push(rec('foo-1'));
-      await v.push(rec('foo-2'));
-    }
-    {
-      const v = captureProvider('ui/Bar.tsx', { layoutPatchFn: () => {} });
-      await v.push(rec('bar-1'));
-    }
-    // Come back to Foo.
-    const v2 = captureProvider('ui/Foo.tsx', { layoutPatchFn: () => {} });
-    expect(v2.canUndo).toBe(true);
-    await v2.undo();
-    // The spy was called for foo-2 last (LIFO).
-    const lastCall = undoSpy.mock.calls[undoSpy.mock.calls.length - 1]?.[0];
-    expect(lastCall).toBeNull(); // payload is null in `rec(label)` default
-  });
-});

package/apps/studio/test/video-asset.test.ts

@@ -1,163 +0,0 @@
-// POST /_api/asset — DDR-148 video/audio widening of the Phase 23 asset route.
-//
-// Two layers (mirroring asset-api.test.ts):
-//   (1) the pure magic-byte sniff (`sniffAssetType`) — the ONE gate that decides
-//       the stored type AND category (→ which cap applies); a header lie / SVG /
-//       script is caught here;
-//   (2) the streaming POST endpoint (boots a real server) — video/audio happy
-//       path, per-category cap (image stays tighter than video; video honors
-//       the MAUDE_ASSET_MAX_VIDEO_BYTES override), content-addressed dedupe.
-
-import { describe, expect, test } from 'bun:test';
-import { existsSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-
-import { ASSET_MAX_BYTES, assetCapForCategory, sniffAssetType } from '../api.ts';
-import { bootServer, killProc, makeSandbox, nextPort } from './_helpers.ts';
-
-// ── Minimal valid magic-byte headers (padded so the ≥12-byte sniff has data). ──
-const pad = (header: number[], len = 64): Uint8Array => {
-  const out = new Uint8Array(len);
-  out.set(header, 0);
-  return out;
-};
-const ascii = (s: string): number[] => [...s].map((c) => c.charCodeAt(0));
-
-const MP4 = pad([0, 0, 0, 0x18, ...ascii('ftyp'), ...ascii('isom')]);
-const MOV = pad([0, 0, 0, 0x14, ...ascii('ftyp'), ...ascii('qt  ')]);
-const M4A = pad([0, 0, 0, 0x18, ...ascii('ftyp'), ...ascii('M4A ')]);
-const WEBM = pad([0x1a, 0x45, 0xdf, 0xa3]);
-const MP3_ID3 = pad([...ascii('ID3'), 0x03, 0x00]);
-const MP3_SYNC = pad([0xff, 0xfb, 0x90, 0x00]);
-const WAV = pad([...ascii('RIFF'), 0, 0, 0, 0, ...ascii('WAVE')]);
-const PNG = pad([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
-const SVG = new TextEncoder().encode('<svg xmlns="http://www.w3.org/2000/svg"><script/></svg>');
-
-describe('video-asset / sniffAssetType (the widened type gate)', () => {
-  test('recognizes video containers by magic bytes', () => {
-    expect(sniffAssetType(MP4)).toEqual({ ext: 'mp4', category: 'video' });
-    expect(sniffAssetType(MOV)).toEqual({ ext: 'mov', category: 'video' });
-    expect(sniffAssetType(WEBM)).toEqual({ ext: 'webm', category: 'video' });
-  });
-
-  test('recognizes audio containers by magic bytes', () => {
-    expect(sniffAssetType(M4A)).toEqual({ ext: 'm4a', category: 'audio' });
-    expect(sniffAssetType(MP3_ID3)).toEqual({ ext: 'mp3', category: 'audio' });
-    expect(sniffAssetType(MP3_SYNC)).toEqual({ ext: 'mp3', category: 'audio' });
-    expect(sniffAssetType(WAV)).toEqual({ ext: 'wav', category: 'audio' });
-  });
-
-  test('images still resolve through the same superset sniff', () => {
-    expect(sniffAssetType(PNG)).toEqual({ ext: 'png', category: 'image' });
-  });
-
-  test('rejects SVG / script / text / empty (no script-bearing vector rides in)', () => {
-    expect(sniffAssetType(SVG)).toBeNull();
-    expect(sniffAssetType(new TextEncoder().encode('not media at all'))).toBeNull();
-    expect(sniffAssetType(new Uint8Array(0))).toBeNull();
-    // "RIFF" without "WAVE" (or "WEBP") must NOT match a media/image type.
-    expect(sniffAssetType(pad([...ascii('RIFF'), 0, 0, 0, 0, ...ascii('AVI ')]))).toBeNull();
-  });
-
-  test('caps: image stays tight, video/audio share the larger cap', () => {
-    expect(assetCapForCategory('image')).toBe(ASSET_MAX_BYTES);
-    expect(assetCapForCategory('video')).toBeGreaterThan(assetCapForCategory('image'));
-    expect(assetCapForCategory('audio')).toBe(assetCapForCategory('video'));
-  });
-});
-
-describe('video-asset / POST /_api/asset (streaming endpoint)', () => {
-  async function withServer(
-    fn: (port: number, designRoot: string) => Promise<void>,
-    extraEnv?: Record<string, string>
-  ) {
-    const sandbox = makeSandbox();
-    const port = nextPort();
-    const proc = await bootServer(sandbox.root, port, extraEnv);
-    try {
-      await fn(port, sandbox.designRoot);
-    } finally {
-      await killProc(proc);
-    }
-  }
-
-  const postAsset = (port: number, body: Uint8Array) =>
-    fetch(`http://localhost:${port}/_api/asset`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/octet-stream' },
-      body,
-    });
-
-  test('writes valid mp4/mov/webm/mp3/wav/m4a with the sniffed ext', async () => {
-    await withServer(async (port, designRoot) => {
-      for (const [bytes, ext] of [
-        [MP4, 'mp4'],
-        [MOV, 'mov'],
-        [WEBM, 'webm'],
-        [MP3_ID3, 'mp3'],
-        [WAV, 'wav'],
-        [M4A, 'm4a'],
-      ] as const) {
-        const res = await postAsset(port, bytes);
-        expect(res.status).toBe(201);
-        const json = (await res.json()) as { path: string };
-        expect(json.path).toMatch(new RegExp(`^assets/[0-9a-f]{8}\\.${ext}$`));
-        expect(existsSync(join(designRoot, json.path))).toBe(true);
-      }
-    });
-  });
-
-  test('bytes decide the ext, never the (octet-stream) upload header', async () => {
-    await withServer(async (port) => {
-      const res = await postAsset(port, MP4);
-      expect(res.status).toBe(201);
-      const json = (await res.json()) as { path: string };
-      expect(json.path.endsWith('.mp4')).toBe(true);
-    });
-  });
-
-  test('rejects an SVG upload (script-bearing) with 415 even on the media route', async () => {
-    await withServer(async (port) => {
-      expect((await postAsset(port, SVG)).status).toBe(415);
-    });
-  });
-
-  test('honors the MAUDE_ASSET_MAX_VIDEO_BYTES per-file cap (streamed → 413)', async () => {
-    await withServer(
-      async (port) => {
-        const big = new Uint8Array(2048);
-        big.set([0, 0, 0, 0x18, ...ascii('ftyp'), ...ascii('isom')], 0); // valid mp4 head
-        expect((await postAsset(port, big)).status).toBe(413);
-        // A small mp4 under the cap still writes.
-        expect((await postAsset(port, MP4)).status).toBe(201);
-      },
-      { MAUDE_ASSET_MAX_VIDEO_BYTES: '1024' }
-    );
-  });
-
-  test('identical media bytes dedupe to ONE content-addressed file', async () => {
-    await withServer(async (port, designRoot) => {
-      const a = await (await postAsset(port, MP4)).json();
-      const b = await (await postAsset(port, MP4)).json();
-      expect(a.path).toBe(b.path);
-      const files = readdirSync(join(designRoot, 'assets')).filter((f) => !f.startsWith('.tmp-'));
-      expect(files.length).toBe(1);
-    });
-  });
-
-  test('a rejected oversize upload leaves NO temp file behind (clean disk)', async () => {
-    await withServer(
-      async (port, designRoot) => {
-        const big = new Uint8Array(2048);
-        big.set([0, 0, 0, 0x18, ...ascii('ftyp'), ...ascii('isom')], 0);
-        expect((await postAsset(port, big)).status).toBe(413);
-        const assetsDir = join(designRoot, 'assets');
-        const leftover = existsSync(assetsDir)
-          ? readdirSync(assetsDir).filter((f) => f.startsWith('.tmp-'))
-          : [];
-        expect(leftover).toEqual([]);
-      },
-      { MAUDE_ASSET_MAX_VIDEO_BYTES: '1024' }
-    );
-  });
-});

package/apps/studio/test/video-comp-fixture.test.ts

@@ -1,50 +0,0 @@
-// video-comp-fixture — DDR-148 end-to-end build guard (CI-safe, no browser).
-//
-// The heavy render/scrub/export path is verified live via agent-browser + the
-// determinism smoke; here we lock the CI-cheap invariant the whole feature
-// rests on: a real video-comp canvas (the canonical fixture) BUILDS through the
-// production canvas pipeline (buildCanvasModule) with `remotion`,
-// `@remotion/transitions`, and the `fade` presentation externalised to the
-// importmap (RUNTIME_PACKAGES) — never inlined (which would resolve against a
-// non-existent user node_modules on an npm/marketplace install) — and with the
-// <VideoComp> wrapper inlined from @maude/canvas-lib.
-
-import { describe, expect, test } from 'bun:test';
-import { readFileSync } from 'node:fs';
-
-import { buildCanvasModule } from '../canvas-build.ts';
-
-const FIXTURE = new URL('./fixtures/video-comp-fixture.tsx', import.meta.url).pathname;
-
-describe('video-comp fixture — production build guard', () => {
-  test('builds through buildCanvasModule with the Remotion runtime externalised', async () => {
-    const src = readFileSync(FIXTURE, 'utf8');
-    const r = await buildCanvasModule(FIXTURE, src);
-    expect(r.js.length).toBeGreaterThan(1000);
-
-    const externals = new Set(
-      [...r.js.matchAll(/from\s*["']([^"'.][^"']*)["']/g)].map((m) => m[1])
-    );
-    // The comp's Remotion imports MUST stay external (importmap → pre-built
-    // /_canvas-runtime bundles), or an end-user install can't resolve them.
-    expect(externals.has('remotion')).toBe(true);
-    expect(externals.has('@remotion/transitions')).toBe(true);
-    expect(externals.has('@remotion/transitions/fade')).toBe(true);
-    expect(externals.has('react')).toBe(true);
-
-    // <VideoComp> (+ the seek-bridge) is inlined from @maude/canvas-lib.
-    expect(r.js).toContain('VideoComp');
-    expect(r.js).toContain('__maude_seek__');
-  });
-
-  test('every Remotion specifier the fixture imports is a known RUNTIME_PACKAGE', async () => {
-    const { RUNTIME_PACKAGES } = await import('../runtime-bundle.ts');
-    const known = new Set<string>(RUNTIME_PACKAGES);
-    const src = readFileSync(FIXTURE, 'utf8');
-    const imported = [...src.matchAll(/from\s*["'](@?remotion[^"']*)["']/g)].map((m) => m[1]);
-    expect(imported.length).toBeGreaterThan(0);
-    for (const spec of imported) {
-      expect(known.has(spec)).toBe(true);
-    }
-  });
-});