kasaframe 0.1.1 → 0.1.4

package/NOTICE

@@ -112,15 +112,17 @@ GPL 파일에 들이는 것은 허용되고, 아래 MIT 고지를 지킨다.
   SOFTWARE.
 
 ----------------------------------------------------------------------
-JIZURA 字面 — packages/jizura (엔진은 싣지 않고 설치 때 받는다)
-https://github.com/852wa/JIZURA (고정 커밋 fc16bfe, v0.10.1)
+JIZURA 字面 — packages/jizura/vendor/jizura_engine.js (실려 있다)
+https://github.com/852wa/JIZURA (고정 커밋 fc16bfe43ea4a6c25a21f1caf04d17326de14f00, v0.10.1)
 MIT — Copyright (c) 2026 hakoniwa
-kf setup jizura 가 고정 커밋을 ~/.cache/kasaframe/jizura 로 받아 src/*.js(편집기 UI 12_ui.js 빼고)를 업스트림
-build.py 와 같은 순서로 한 파일로 잇는다. 업스트림 파일은 고치지 않는다. 묶은 엔진 옆에 원본 LICENSE 를
-JIZURA_LICENSE.txt 로 둔다. 가사 층으로 낸 영상에는 "JIZURA 字面 (c) 2026 hakoniwa (github.com/852wa), MIT" 를 적는다.
-같이 받는 글꼴(google/fonts 의 Noto Sans·Serif KR 등)은 SIL Open Font License 1.1 — 원문은 글꼴 옆 OFL-<폴더>.txt.
-
-vocaloid-style-mv-pipeline — packages/jizura/src/layer.ts·deny.ts·install.ts, tools/lyrics/align.py
+고정 커밋의 src/*.js(편집기 UI 12_ui.js 빼고)를 업스트림 build.py 와 같은 순서로 한 파일로 이었다. 업스트림 파일은
+고치지 않았다. 원본 LICENSE 는 옆 JIZURA_LICENSE.txt, 출처·고정 커밋·MIT 원문은 packages/jizura/vendor/NOTICE.
+다시 만들기: node packages/jizura/src/vendor.ts. 가사 층으로 낸 영상에는 "JIZURA 字面 (c) 2026 hakoniwa (github.com/852wa), MIT" 를 적는다.
+글꼴 — google/fonts 고정 커밋 51303ca 의 SIL Open Font License 1.1 글꼴. 자주 쓰는 Noto Sans KR·Noto Serif KR·Black Han Sans·
+Gowun Batang·DotGothic16 은 한글·영숫자·문장부호만 남긴 서브셋으로, IBM Plex Mono 는 원본 그대로 packages/jizura/vendor/fonts 에
+OFL-<폴더>.txt 원문과 함께 실려 있다. 그 밖의 얼굴은 처음 쓸 때 같은 커밋의 원본을 ~/.cache/kasaframe/jizura/fonts 로 받는다.
+
+vocaloid-style-mv-pipeline — packages/jizura/src/layer.ts·deny.ts·vendor.ts, tools/lyrics/align.py
 https://github.com/EGSECDA/vocaloid-style-mv-pipeline (로컬 클론 커밋 13b380d)
 MIT — Copyright (c) 2026 NikusonP
 엔진 묶기 순서(template/tools/build_jizura_bundle.mjs), 플랜 만들기와 색 구성 고르기 schemes 'dark'·'light'

package/README.md

@@ -53,6 +53,19 @@ kf skill install                   # ~/.claude/skills/kasaframe 에 스킬 링
 
 키는 환경 변수 `OPENGATEWAY_API_KEY` 또는 파일 `~/.config/opengateway.key`(한 줄). 없으면 이 셋만 빠지고 — 생성 대신 키를 둘 자리를 알려 준다 — 장면·렌더·검사는 그대로 돈다.
 
+## 목소리·곡
+
+쇼츠·설명은 차분한 TTS 내레이션과 깊은 앰비언트 곡(`deep`)이 기본이다. 목소리가 장면 길이를 정하고, 렌더가 곡을 말 아래로 덕킹해 -14 LUFS 로 섞는다. 곡은 틀이 박은 분위기(`deep`)대로 매번 같고, 목소리는 만들기 전에 묻는다(로컬 Qwen3·ElevenLabs·자막만·그 밖 차례). 엔진·곡이 없으면 다른 것으로 넘어가지 않고 키 넣기·다른 엔진·빼기를 묻는다.
+
+| 쓰는 것 | 키 | 상태 |
+|---|---|---|
+| Gemini TTS(`gemini-3.8-flash-tts`) · Lyria 3.5 음악 | `GEMINI_API_KEY` 또는 `~/.config/gemini.key` | 실호출로 확인 |
+| ElevenLabs TTS(with-timestamps — 낱말 시각까지) · Eleven Music | `ELEVENLABS_API_KEY` | 문서대로 짰고 **실호출 안 함** |
+| Qwen TTS(DashScope `qwen3-tts-flash`) | `DASHSCOPE_API_KEY` | 문서대로 짰고 **실호출 안 함** |
+| 로컬 Qwen3-TTS(`tools/tts/qwen3_tts_server.py`) | `KF_QWEN3_TTS_URL` | 서버 주소가 있을 때만 — **실호출 안 함** |
+
+키가 하나도 없으면 목소리 없이 자막 트랙만 간다. 단가·라이선스: `packages/gen/PROVIDERS.md`.
+
 ## 명령
 
 | 명령 | 하는 일 |
@@ -65,8 +78,10 @@ kf skill install                   # ~/.claude/skills/kasaframe 에 스킬 링
 | `kf still` · `kf sheet` · `kf look` | 한 장 · 장면 모음 · 장면별 확인표 |
 | `kf beats` | 곡을 재서 `beats.json` — 박·마디·프레이즈·구간·드롭·대역 에너지 |
 | `kf gen` | 그림·영상 생성(OG · fal · MiniMax · Veo · LTX) |
+| `kf narrate` | 내레이션 먼저 — 장면별 문장을 TTS 로 읽혀 장면 길이를 목소리에 맞추고(곡이 있으면 박에), 자막을 목소리 시각으로 |
+| `kf music` | 곡 모음(분위기 태그) 보기·넣기, 음악 생성(Lyria · Eleven Music) |
 | `kf transitions` | 전환 목록 — 이름·출처·라이선스 |
-| `kf theme list` | 테마 — `riso-zine` · `debug-hud` · `og-measure` |
+| `kf theme list [--variants]` · `kf theme sheet [--variants <세계\|all>]` · `kf theme vary <세계\|all>` · `kf theme suggest [--json]` | 테마 — 세계(`riso-zine` · `debug-hud` · `og-measure` …)와 겉모습만 바꾼 변주(`og-measure/night-amber`), 같은 문장 한 장면을 테마마다 찍은 견본 격자, 변주 뽑기, 요청에 맞는 후보(kf make 의 테마 질문과 같은 고르기) |
 | `kf app` | 작업실 — 요청 칸·실시간 미리보기·렌더·검사 보고를 브라우저로(:5150) |
 | `kf doctor` · `kf setup` | 바깥 도구 점검 · 깔기 |
 | `kf skill` | Claude Code 스킬 링크 |

package/app/server/engine.ts

@@ -1,9 +1,11 @@
 import { type ChildProcess, spawn } from "node:child_process";
 import { EventEmitter } from "node:events";
-import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, join, resolve } from "node:path";
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { basename, extname, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { listTemplates, makePlan, type Plan, type Purpose, suggestThemes } from "@kasaframe/plan";
+import { checkContent } from "@kasaframe/director";
+import { capabilities } from "@kasaframe/gen";
+import { listTemplates, makePlan, type Plan, type Purpose, planQuestions, suggestThemes } from "@kasaframe/plan";
 import { loadTheme, themeCards, type ThemeStatus } from "@kasaframe/themes";
 import { captionMode } from "@kasaframe/motion/captions";
 
@@ -18,6 +20,11 @@ const PREVIEW_PORTS = [5151, 5152, 5153, 5154, 5155, 5156, 5157, 5158];
 
 export type Phase = "plan" | "scaffold" | "gen" | "scenes" | "render" | "check" | "done" | "waiting" | "failed";
 
+// 장면마다 따로 흐르는 상태 — kf make·direct·render 가 찍는 「장면 <id>: <상태>」 줄에서 읽는다
+export type SceneState = "writing" | "written" | "assets" | "render" | "rendered" | "reused" | "check" | "done" | "failed";
+const SCENE_WORDS: Record<string, SceneState> = { "쓰는 중": "writing", 씀: "written", 재료: "assets", 렌더: "render", 구움: "rendered", 그대로: "reused", 검사: "check", 끝: "done", 실패: "failed" };
+const SCENE_LINE = /^장면 (\S+): (쓰는 중|씀|재료|렌더|구움|그대로|검사|끝|실패)(?:\s*(?:—\s*)?(.*))?$/;
+
 export interface JobInput {
   request: string;
   purpose?: Purpose | "auto";
@@ -28,6 +35,7 @@ export interface JobInput {
   approve?: boolean;
   title?: string;
   captions?: "on" | "off"; // 화면 자막 — 안 주면 틀 기본
+  answers?: Record<string, string>; // 계획의 asks 에 고른 답 { 질문 id: 값 } — kf make --<id> <값> 로 넘겨 묻지 않고 간다
 }
 
 export interface Job {
@@ -43,20 +51,37 @@ export interface Job {
   log: string[];
   error?: string;
   checkPassed?: boolean;
+  scenes?: Record<string, { state: SceneState; note?: string; at: number }>;
+  // 사람이 고쳐 다시 굽는 장면 — 다 되면 화면이 그 장면 시각부터 튼다
+  focus?: string;
 }
 
 export interface JobView extends Omit<Job, "log"> {
   plan?: Plan;
   kf?: unknown;
   // alt — 자막을 반대로 다시 구운 판(video-자막.mp4 · video-자막없음.mp4). captions — 들릴 말(captions.json)이 있다
-  files: { video?: string; cover?: string; check?: string; alt?: string; captions?: string };
+  files: { video?: string; cover?: string; check?: string; alt?: string; captions?: string; videoAt?: number };
+}
+
+export interface SceneDetail {
+  scene: Record<string, unknown> & { id: string; from: number; dur: number; role?: string; idea?: string };
+  direct: boolean;
+  model: string | null;
+  content: Record<string, unknown> | null;
+  pattern: string | null;
+  candidates: { id: string; score: number; why: string[] }[];
+  pinned: { pattern?: string; seed?: string } | null;
+  assets: { path: string; url: string; kind: "image" | "video" }[];
 }
 
 const PHASES: [RegExp, Phase][] = [
   [/^용도 /, "scaffold"],
   [/^생성 자산/, "gen"],
   [/^계획 다듬/, "scaffold"],
-  [/^장면 \S+ 쓰는 중/, "scenes"],
+  [/^장면 \S+: 쓰는 중/, "scenes"],
+  [/^장면 \S+: 재료/, "gen"],
+  [/^장면 \S+: 렌더/, "render"],
+  [/^장면 \S+: 검사/, "check"],
   [/^\s+\S+ \d+번째/, "scenes"],
   [/^\s+\d+\/\d+ \(\d+%\)/, "render"],
   [/^고치기 /, "scenes"],
@@ -99,9 +124,12 @@ export class Engine extends EventEmitter {
     }));
   }
 
-  // 만들기 전에 보여 줄 계획 — 곡 분석 없이 길이·장면 비율만. 사람이 용도를 고르면 판별을 건너뛰고, "auto" 거나 비우면 판별한다
-  plan(request: string, purpose?: Purpose | "auto", theme?: string): Plan {
-    return makePlan({ request, purpose: purpose && purpose !== "auto" ? purpose : undefined, theme });
+  // 만들기 전에 보여 줄 계획 — 곡 분석 없이 길이·장면 비율만. 사람이 용도를 고르면 판별을 건너뛰고, "auto" 거나 비우면 판별한다.
+  // asks 는 돈이 들거나 없는 생성 능력만(kf make 와 같은 질문) — 페이지가 고른 답을 일에 실어 보낸다
+  async plan(request: string, purpose?: Purpose | "auto", theme?: string): Promise<Plan> {
+    const plan = makePlan({ request, purpose: purpose && purpose !== "auto" ? purpose : undefined, theme });
+    const { questions, auto } = planQuestions(plan, await capabilities({ probe: true }));
+    return { ...plan, asks: questions, answers: auto };
   }
 
   // 목록은 approved 만(SPEC 9). all 이면 review·draft 도 — 테마 만드는 사람이 견본을 보는 자리
@@ -185,7 +213,8 @@ export class Engine extends EventEmitter {
     const job: Job = { id, input, dir: join(dataDir, "jobs", id, "project"), phase: "plan", progress: 0, running: false, createdAt: Date.now(), log: [] };
     this.jobs.set(id, job);
     mkdirSync(join(dataDir, "jobs", id), { recursive: true });
-    const args = ["make", input.request, "--out", job.dir, "--model", input.model ?? "deepseek/deepseek-v4-pro"];
+    // 모델을 안 고르면 kf make 의 기본 — 고른 모델은 plan.json 에 남아 장면 다시 쓰기가 같은 모델을 부른다
+    const args = ["make", input.request, "--out", job.dir, ...(input.model ? ["--model", input.model] : [])];
     if (input.purpose && input.purpose !== "auto") args.push("--purpose", input.purpose);
     if (input.music) args.push("--music", input.music);
     const given = (input.assets ?? []).filter((a) => existsSync(a));
@@ -199,14 +228,33 @@ export class Engine extends EventEmitter {
     if (input.theme) args.push("--theme", input.theme);
     if (input.approve) args.push("--yes");
     if (input.captions) args.push("--captions", input.captions);
+    // 질문 id 가 곧 kf make 플래그 이름이다(image·video·blender·voice·music)
+    for (const [id, v] of Object.entries(input.answers ?? {})) if (/^[a-z]+$/.test(id) && v) args.push(`--${id}`, v);
     this.run(job, args);
     return job;
   }
 
-  // 장면 카드에서 고친 뒤: 고른 장면만 다시 쓰고 렌더·검사
-  rewrite(id: string, scenes: string[]): Job {
+  // 장면 카드에서 고친 뒤: 고른 장면만 다시 쓰고(감독 프로젝트는 다시 짓고) 그 조각만 다시 굽고 그 구간만 검사.
+  // 모델은 그 일의 모델 그대로 — 안 정했으면 kf make 가 plan.json 에 남은 모델을 쓴다. pattern·seed 는 감독 후보 고르기
+  rewrite(id: string, scenes: string[], o: { pattern?: Record<string, string>; seed?: Record<string, string> } = {}): Job {
     const job = this.must(id);
-    this.run(job, ["make", "--rewrite", job.dir, "--scenes", scenes.join(","), "--model", job.input.model ?? "deepseek/deepseek-v4-pro"]);
+    if (!scenes.length) throw Object.assign(new Error("다시 쓸 장면이 없다"), { status: 400 });
+    const pairs = (m?: Record<string, string>) => Object.entries(m ?? {}).filter(([k, v]) => scenes.includes(k) && v).map(([k, v]) => `${k}=${v}`).join(",");
+    const args = ["make", "--rewrite", job.dir, "--scenes", scenes.join(",")];
+    if (job.input.model) args.push("--model", job.input.model);
+    if (pairs(o.pattern)) args.push("--pattern", pairs(o.pattern));
+    if (pairs(o.seed)) args.push("--scene-seed", pairs(o.seed));
+    this.focusOn(job, scenes);
+    this.run(job, args);
+    return job;
+  }
+
+  // 장면 파일은 그대로, 바뀐 조각만 다시 굽고 그 구간만 검사 — 손으로 고친 장면·바꾼 자산
+  redo(id: string, scenes: string[]): Job {
+    const job = this.must(id);
+    if (!scenes.length) throw Object.assign(new Error("다시 구울 장면이 없다"), { status: 400 });
+    this.focusOn(job, scenes);
+    this.run(job, ["make", "--finish", job.dir, "--scenes", scenes.join(","), "--fix", "0"]);
     return job;
   }
 
@@ -214,10 +262,63 @@ export class Engine extends EventEmitter {
   rerender(id: string, o: { captions?: "on" | "off" } = {}): Job {
     const job = this.must(id);
     const caps = o.captions === "on" || o.captions === "off" ? ["--captions", o.captions, "--suffix"] : [];
-    this.run(job, ["make", "--finish", job.dir, "--model", job.input.model ?? "deepseek/deepseek-v4-pro", "--fix", "0", ...caps]);
+    this.run(job, ["make", "--finish", job.dir, "--fix", "0", ...caps]);
     return job;
   }
 
+  private focusOn(job: Job, scenes: string[]): void {
+    job.focus = scenes[0];
+    job.scenes = Object.fromEntries(Object.entries(job.scenes ?? {}).filter(([k]) => !scenes.includes(k)));
+  }
+
+  private sceneLine(job: Job, line: string): void {
+    const m = line.match(SCENE_LINE);
+    if (!m) return;
+    (job.scenes ??= {})[m[1]] = { state: SCENE_WORDS[m[2]], ...(m[3] ? { note: m[3].trim() } : {}), at: Date.now() };
+  }
+
+  // 장면 하나 고치는 자리 — 감독 프로젝트는 content.json 의 그 장면 칸·패턴 후보·씨앗, 아니면 할 일·장면 모델. 자산은 그 장면이 쓰는 그림·영상
+  sceneDetail(id: string, sid: string): SceneDetail {
+    const job = this.must(id);
+    const read = (f: string) => (existsSync(join(job.dir, f)) ? JSON.parse(readFileSync(join(job.dir, f), "utf8")) : null);
+    const kf = read("kf.json");
+    const scene = kf?.scenes?.find((s: { id: string }) => s.id === sid);
+    if (!scene) throw Object.assign(new Error(`장면 ${sid} 가 없다`), { status: 404 });
+    const plan = read("plan.json") ?? {};
+    const director = read("director.json");
+    const ds = director?.scenes?.find((s: { id: string }) => s.id === sid);
+    const file = join(job.dir, scene.file ?? `scenes/${sid}.ts`);
+    const src = existsSync(file) ? readFileSync(file, "utf8") : "";
+    const assetsDir = join(job.dir, "assets");
+    const walk = (d: string): string[] => (existsSync(d) ? readdirSync(d, { withFileTypes: true }).flatMap((e) => (e.isDirectory() ? walk(join(d, e.name)) : [join(d, e.name)])) : []);
+    const assets = walk(assetsDir)
+      .filter((f) => /\.(png|jpe?g|webp|gif|mp4|webm|mov)$/i.test(f))
+      .map((f) => relative(assetsDir, f).split(sep).join("/"))
+      .filter((rel) => src.includes(rel) || basename(rel).startsWith(`${sid}.`) || basename(rel).startsWith(`${sid}-`))
+      .map((rel) => ({ path: rel, url: `/api/jobs/${id}/files/assets/${rel}`, kind: (/\.(mp4|webm|mov)$/i.test(rel) ? "video" : "image") as "image" | "video" }));
+    return {
+      scene,
+      direct: plan.direct === true,
+      model: job.input.model ?? plan.model ?? null,
+      content: read("content.json")?.scenes?.find((s: { id: string }) => s.id === sid) ?? null,
+      pattern: ds?.pattern ?? null,
+      candidates: ds?.order ?? [],
+      pinned: director?.pinned?.[sid] ?? null,
+      assets,
+    };
+  }
+
+  // 사람이 올린 파일로 그 장면 자산 하나를 바꾼다 — 다음 굽기에서 그 자산을 쓰는 조각만 다시 찍힌다
+  replaceAsset(id: string, sid: string, o: { path: string; upload: string }): SceneDetail {
+    const job = this.must(id);
+    const detail = this.sceneDetail(id, sid);
+    if (!detail.assets.some((a) => a.path === o.path)) throw Object.assign(new Error(`장면 ${sid} 가 쓰는 자산이 아니다: ${o.path}`), { status: 400 });
+    if (!existsSync(o.upload)) throw Object.assign(new Error("올린 파일이 없다"), { status: 400 });
+    if (extname(o.upload).toLowerCase() !== extname(o.path).toLowerCase()) throw Object.assign(new Error(`같은 꼴(${extname(o.path)})로 올린다`), { status: 400 });
+    copyFileSync(o.upload, join(job.dir, "assets", o.path));
+    return this.sceneDetail(id, sid);
+  }
+
   // 말로 시작한 kf make(Claude Code 등)가 스스로 등록한다 — 같은 폴더면 같은 일(--finish 가 다시 붙는다)
   attach(o: { dir: string; request: string; model?: string; purpose?: Purpose }): Job {
     const dir = resolve(o.dir);
@@ -237,6 +338,7 @@ export class Engine extends EventEmitter {
     const job = this.must(id);
     for (const line of p.lines ?? []) {
       job.log.push(line);
+      this.sceneLine(job, line);
       for (const [re, phase] of PHASES) if (re.test(line)) job.phase = phase;
       const pct = line.match(/\((\d+)%\)/);
       if (pct && job.phase === "render") job.progress = Number(pct[1]) / 100;
@@ -254,8 +356,20 @@ export class Engine extends EventEmitter {
     this.emit("state", this.view(id));
   }
 
-  editScene(id: string, sceneId: string, patch: { idea?: string; dur?: number }): unknown {
+  editScene(id: string, sceneId: string, patch: { idea?: string; dur?: number; content?: Record<string, unknown> }): unknown {
     const job = this.must(id);
+    // 감독 프로젝트 — 화면에 보일 것은 content.json 이 정본이다. 칸이 틀리면 저장하지 않고 어느 칸인지 돌려준다
+    if (patch.content) {
+      const cPath = join(job.dir, "content.json");
+      if (!existsSync(cPath)) throw Object.assign(new Error("content.json 이 없다 — 감독 모드로 만든 일이 아니다"), { status: 400 });
+      const content = JSON.parse(readFileSync(cPath, "utf8"));
+      const at = content.scenes?.findIndex((s: { id: string }) => s.id === sceneId) ?? -1;
+      if (at < 0) throw Object.assign(new Error(`content.json 에 장면 ${sceneId} 가 없다`), { status: 404 });
+      content.scenes[at] = { ...patch.content, id: sceneId };
+      const c = checkContent(content);
+      if (c.errors.length) throw Object.assign(new Error(c.errors.map((e) => `${e.at}: ${e.msg}`).join("\n")), { status: 400 });
+      writeFileSync(cPath, `${JSON.stringify(content, null, 2)}\n`);
+    }
     const kfPath = join(job.dir, "kf.json");
     const kf = JSON.parse(readFileSync(kfPath, "utf8"));
     const i = kf.scenes.findIndex((s: { id: string }) => s.id === sceneId);
@@ -289,7 +403,10 @@ export class Engine extends EventEmitter {
     const { log: _log, ...rest } = job;
     const kf = read("kf.json");
     const alt = has(captionMode(kf?.captions) === "on" ? "out/video-자막없음.mp4" : "out/video-자막.mp4");
-    return { ...rest, plan: read("plan.json"), kf, files: { video: has("out/video.mp4"), cover: has("out/cover.png"), check: has("out/check.json"), alt, captions: has("captions.json") } };
+    const video = has("out/video.mp4");
+    // 같은 이름으로 다시 구워도 화면이 새 영상을 받게 — 고친 시각을 붙인다
+    const videoAt = video ? Math.round(statSync(join(job.dir, video)).mtimeMs) : undefined;
+    return { ...rest, plan: read("plan.json"), kf, files: { video, cover: has("out/cover.png"), check: has("out/check.json"), alt, captions: has("captions.json"), videoAt } };
   }
 
   list(): JobView[] {
@@ -326,6 +443,7 @@ export class Engine extends EventEmitter {
       if (!line.trim()) return;
       job.log.push(line);
       if (job.log.length > 800) job.log.splice(0, job.log.length - 800);
+      this.sceneLine(job, line);
       for (const [re, phase] of PHASES) if (re.test(line)) job.phase = phase;
       const pct = line.match(/\((\d+)%\)/);
       if (pct && job.phase === "render") job.progress = Number(pct[1]) / 100;

package/app/server/main.ts

@@ -84,7 +84,7 @@ async function api(req: IncomingMessage, res: ServerResponse, path: string): Pro
   if (path === "/api/plan" && method === "POST") {
     const b = await body<{ request: string; purpose?: never; theme?: string }>(req);
     // purpose: 틀 id 면 그 틀로, "auto" 거나 없으면 요청 글로 판별. theme: id 나 "auto"
-    return send(res, 200, engine.plan(b.request ?? "", b.purpose, b.theme));
+    return send(res, 200, await engine.plan(b.request ?? "", b.purpose, b.theme));
   }
   if (path === "/api/themes" && method === "GET") {
     const q = new URL(req.url ?? "", "http://x").searchParams;
@@ -167,11 +167,15 @@ async function api(req: IncomingMessage, res: ServerResponse, path: string): Pro
   }
   if (rest === "render" && method === "POST") return send(res, 200, engine.view(engine.rerender(id, await body<{ captions?: "on" | "off" }>(req)).id));
   if (rest === "rewrite" && method === "POST") {
-    const b = await body<{ scenes: string[] }>(req);
-    return send(res, 200, engine.view(engine.rewrite(id, b.scenes ?? []).id));
+    const b = await body<{ scenes: string[]; pattern?: Record<string, string>; seed?: Record<string, string> }>(req);
+    return send(res, 200, engine.view(engine.rewrite(id, b.scenes ?? [], { pattern: b.pattern, seed: b.seed }).id));
   }
+  if (rest === "redo" && method === "POST") return send(res, 200, engine.view(engine.redo(id, (await body<{ scenes: string[] }>(req)).scenes ?? []).id));
   const scene = rest.match(/^scenes\/([\w-]+)$/);
+  if (scene && method === "GET") return send(res, 200, engine.sceneDetail(id, scene[1]));
   if (scene && method === "PATCH") return send(res, 200, engine.editScene(id, scene[1], await body(req)));
+  const sceneAsset = rest.match(/^scenes\/([\w-]+)\/asset$/);
+  if (sceneAsset && method === "PUT") return send(res, 200, engine.replaceAsset(id, sceneAsset[1], await body(req)));
   const file = rest.match(/^files\/(.+)$/);
   if (file && method === "GET") {
     const dir = engine.view(id).dir;