kasaframe 0.0.0-stage → 0.1.3

package/packages/gen/src/video/fal.ts

@@ -0,0 +1,140 @@
+import { readKey } from "../keys.ts";
+import { dataUri } from "../media.ts";
+import type { RawResult, VideoProvider, VideoRequest } from "../types.ts";
+import { ceilTo, download, json, poll } from "./http.ts";
+
+interface FalModel {
+  id: string;
+  i2v: string;
+  t2v: string;
+  durations: number[];
+  usd(o: VideoRequest, sec: number): number;
+  input(o: VideoRequest, sec: number): Record<string, unknown>;
+  license: string;
+}
+
+const res = (o: VideoRequest) => o.resolution ?? "720p";
+const WAN_PER_SEC: Record<string, number> = { "720p": 0.08, "580p": 0.06, "480p": 0.04 };
+const WAN_TURBO: Record<string, number> = { "720p": 0.1, "580p": 0.075, "480p": 0.05 };
+const WAN_LICENSE = "Wan 2.2 가중치 Apache-2.0 — 출력물 상업 사용 가능, 지역 제한 없음";
+const KLING_LICENSE = "Kling API 약관 — 유료 생성물 상업 사용 가능";
+
+// fal 의 Wan 2.2 는 16fps 로 프레임 수를 센다(81 프레임 = 약 5초).
+const wanFrames = (sec: number) => Math.min(161, Math.max(17, Math.round(sec * 16) + 1));
+
+export const FAL_MODELS: FalModel[] = [
+  {
+    id: "wan-2.2-turbo",
+    i2v: "fal-ai/wan/v2.2-a14b/image-to-video/turbo",
+    t2v: "fal-ai/wan/v2.2-a14b/text-to-video/turbo",
+    durations: [5],
+    usd: (o) => WAN_TURBO[res(o)] ?? 0.1,
+    input: (o) => ({ resolution: res(o), aspect_ratio: "auto", enable_safety_checker: true, ...(o.seed !== undefined ? { seed: o.seed } : {}) }),
+    license: WAN_LICENSE,
+  },
+  {
+    id: "wan-2.2",
+    i2v: "fal-ai/wan/v2.2-a14b/image-to-video",
+    t2v: "fal-ai/wan/v2.2-a14b/text-to-video",
+    durations: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+    usd: (o, sec) => (WAN_PER_SEC[res(o)] ?? 0.08) * (wanFrames(sec) / 16),
+    input: (o, sec) => ({
+      num_frames: wanFrames(sec),
+      frames_per_second: 16,
+      resolution: res(o),
+      aspect_ratio: "auto",
+      enable_prompt_expansion: false,
+      ...(o.seed !== undefined ? { seed: o.seed } : {}),
+    }),
+    license: WAN_LICENSE,
+  },
+  {
+    id: "kling-3-std",
+    i2v: "fal-ai/kling-video/v3/standard/image-to-video",
+    t2v: "fal-ai/kling-video/v3/standard/text-to-video",
+    durations: [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    usd: (_o, sec) => 0.084 * sec,
+    input: (_o, sec) => ({ duration: String(sec), generate_audio: false }),
+    license: KLING_LICENSE,
+  },
+  {
+    id: "kling-3-pro",
+    i2v: "fal-ai/kling-video/v3/pro/image-to-video",
+    t2v: "fal-ai/kling-video/v3/pro/text-to-video",
+    durations: [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    usd: (_o, sec) => 0.112 * sec,
+    input: (_o, sec) => ({ duration: String(sec), generate_audio: false }),
+    license: KLING_LICENSE,
+  },
+];
+
+const isKling = (m: FalModel) => m.id.startsWith("kling");
+
+export function falBody(m: FalModel, o: VideoRequest, first?: string, last?: string): { endpoint: string; body: Record<string, unknown> } {
+  const sec = ceilTo(m.durations, o.duration);
+  const body: Record<string, unknown> = { prompt: o.prompt, ...m.input(o, sec) };
+  if (!first) {
+    if (last) throw new Error("끝 프레임만 주고 첫 프레임을 안 주면 못 만든다");
+    body.aspect_ratio = o.aspect;
+    return { endpoint: m.t2v, body };
+  }
+  if (isKling(m)) {
+    body.start_image_url = first;
+    if (last) body.end_image_url = last;
+  } else {
+    body.image_url = first;
+    if (last) body.end_image_url = last;
+  }
+  return { endpoint: m.i2v, body };
+}
+
+export function falVideo(modelId = "wan-2.2-turbo"): VideoProvider {
+  const m = FAL_MODELS.find((x) => x.id === modelId);
+  if (!m) throw new Error(`fal 모델 없음: ${modelId} (있는 것: ${FAL_MODELS.map((x) => x.id).join(" ")})`);
+  return {
+    id: `fal-${m.id}`,
+    kind: "vid",
+    model: m.i2v,
+    license: m.license,
+    region: "fal.ai(미국) API — 한국에서 호출·결제 가능",
+    keyName: "fal",
+    durations: m.durations,
+    firstLast: true,
+    estimateUsd: (o) => m.usd(o, ceilTo(m.durations, o.duration)),
+
+    async generate(o): Promise<RawResult> {
+      const key = readKey("fal");
+      const headers = { Authorization: `Key ${key}`, "Content-Type": "application/json" };
+      const first = o.firstFrame ? await dataUri(o.firstFrame) : undefined;
+      const last = o.lastFrame ? await dataUri(o.lastFrame) : undefined;
+      const { endpoint, body } = falBody(m, o, first, last);
+      const sub = await json(`https://queue.fal.run/${endpoint}`, { method: "POST", headers, body: JSON.stringify(body) }, `fal ${endpoint}`);
+      const auth = { Authorization: `Key ${key}` };
+      await poll(
+        async () => {
+          const s = await json(sub.status_url, { headers: auth }, "fal 상태");
+          if (s.status === "COMPLETED") return true;
+          if (s.status === "FAILED" || s.error) throw new Error(`fal 실패: ${JSON.stringify(s).slice(0, 300)}`);
+          return undefined;
+        },
+        { everyMs: 4000, timeoutMs: 15 * 60_000, who: `fal ${endpoint}` },
+      );
+      const out = await json(sub.response_url, { headers: auth }, "fal 결과");
+      const url = out.video?.url;
+      if (!url) throw new Error(`fal 결과에 영상이 없다: ${JSON.stringify(out).slice(0, 300)}`);
+      const sec = ceilTo(m.durations, o.duration);
+      const params: Record<string, unknown> = { ...body, endpoint, request_id: sub.request_id };
+      delete params.prompt;
+      for (const k of ["image_url", "start_image_url", "end_image_url"]) if (k in params) params[k] = "<frame>";
+      return {
+        bytes: await download(url),
+        ext: "mp4",
+        model: endpoint,
+        seed: typeof out.seed === "number" ? out.seed : (o.seed ?? null),
+        costUsd: m.usd(o, sec),
+        costEstimated: true,
+        params,
+      };
+    },
+  };
+}

package/packages/gen/src/video/h3.ts

@@ -0,0 +1,112 @@
+import { readFileSync } from "node:fs";
+import { findKey, whereToPut } from "../keys.ts";
+import type { VideoProvider } from "../types.ts";
+import { ceilTo, download, json, poll } from "./http.ts";
+
+// 자체 호스팅한 H3 영상 모델의 SGLang 서버를 직접 부른다(KF_H3_URL — 닫힌 망이면 터널로 닿는다).
+// 주소는 비밀이 아니지만 키와 같은 자리에서 읽어 "설정돼 있으면 쓴다"를 한 규칙으로 둔다.
+// 서버 검증기가 4–15 초만 받는다(그 밖은 400).
+const DURATIONS = [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+
+function settings() {
+  const env = process.env;
+  return {
+    // 걸음 수는 서버에 걸린 LoRA 에 묶인다 — 터보면 9, LoRA 없으면 50. 터보가 걸린 채 50 을 주면 그림이 틀어지는데
+    // 그 상태는 서버 전체 것이라 여기서 알 수 없으니 기본값을 두지 않는다.
+    steps: env.KF_H3_STEPS ? Number(env.KF_H3_STEPS) : undefined,
+    shortEdge: Number(env.KF_H3_SHORT_EDGE ?? 768),
+    flowShift: Number(env.KF_H3_FLOW_SHIFT ?? 12),
+    // 터보 LoRA 처럼 서버마다 다른 필드는 JSON 으로 그대로 얹는다.
+    extra: env.KF_H3_EXTRA ? (JSON.parse(env.KF_H3_EXTRA) as Record<string, unknown>) : {},
+  };
+}
+
+// 키프레임은 첫 프레임이 픽셀 단위로 이어져야 해서 줄이지 않은 PNG 를 data URI 로 보낸다 — 서버가 직접 디코드한다.
+const inline = (path: string) => `data:image/png;base64,${readFileSync(path).toString("base64")}`;
+
+export function h3Body(o: { prompt: string; firstFrame?: string; lastFrame?: string; duration: number; aspect: string; seed?: number }, frames: { first?: string; last?: string }) {
+  const s = settings();
+  const conditions: Record<string, unknown>[] = [];
+  if (frames.first) conditions.push({ type: "image", uri: frames.first, role: "keyframe", frame_index: 0 });
+  if (frames.last) conditions.push({ type: "image", uri: frames.last, role: "keyframe", frame_index: -1 });
+  return {
+    model: "MiniMaxAI/MiniMax-H3",
+    prompt: o.prompt,
+    task: conditions.length ? "fl2va" : "t2va",
+    conditions,
+    target: { short_edge: s.shortEdge, aspect_ratio: o.aspect, duration_seconds: ceilTo(DURATIONS, o.duration) },
+    num_outputs_per_prompt: 1,
+    num_inference_steps: s.steps,
+    flow_shift: s.flowShift,
+    audio_flow_shift: 3,
+    // 시드를 비우면 서버가 몰래 골라 같은 판을 다시 못 뽑는다.
+    seed: o.seed ?? Math.floor(Math.random() * 2 ** 31),
+    ...s.extra,
+  };
+}
+
+// 공개 가중치 라이선스가 한국·미국·EU·영국을 제외 지역으로 두고 산출물에도 건다 — 사내 파드로 돌려도 같다(API 판은 전 세계 가능)
+export const H3_RESTRICT =
+  "MiniMax H3 공개 가중치는 한국 제외 지역 — 회사·바깥 결과물엔 쓰지 않는다(시험·사내 보기만). 밖에 낼 영상은 minimax-h3 API(전 세계 가능)나 다른 공급자로";
+
+export function h3Video(): VideoProvider {
+  const { steps, shortEdge, flowShift, extra } = settings();
+  return {
+    id: "h3-pod",
+    variant: { steps, shortEdge, flowShift, extra },
+    kind: "vid",
+    model: "MiniMaxAI/MiniMax-H3",
+    license: "공개 가중치 — 지역 제한 확인 필요(MiniMax H3 커뮤니티 라이선스는 한국·미국·EU·영국을 제외 지역으로 둔다)",
+    region: "사내 GPU 파드 자체 호스팅 — 한국 사용은 MiniMax 라이선스 신청 여부 확인 필요",
+    restrict: H3_RESTRICT,
+    keyName: "h3",
+    durations: DURATIONS,
+    firstLast: true,
+    estimateUsd: () => 0,
+
+    async generate(o) {
+      const base = findKey("h3");
+      if (!base) throw new Error(`h3 주소 없음 — ${whereToPut("h3")} 에 SGLang 주소(터널이면 http://127.0.0.1:30110)`);
+      if (steps === undefined) throw new Error("KF_H3_STEPS 를 정한다 — 서버에 터보 LoRA 가 걸려 있으면 9, 없으면 50(파드 운영자에게 확인)");
+      const url = base.replace(/\/+$/, "");
+      const body = h3Body(o, { first: o.firstFrame && inline(o.firstFrame), last: o.lastFrame && inline(o.lastFrame) });
+      const headers = { "Content-Type": "application/json" };
+      // 받기 전에 끊겨도 GPU 가 한 일은 서버에 남는다 — 그 작업 id 를 주면 다시 보내지 않고 받아 온다.
+      const resume = process.env.KF_H3_RESUME;
+      const id: string = resume || (await json(`${url}/v1/videos`, { method: "POST", headers, body: JSON.stringify(body) }, "H3")).id;
+      let job: any;
+      try {
+        job = await poll(
+          async () => {
+            const s = await json(`${url}/v1/videos/${id}`, {}, "H3 상태");
+            if (s.status === "completed" || s.status === "succeeded") return s;
+            if (s.status === "failed" || s.status === "error" || s.status === "cancelled") throw new Error(`H3 ${s.status}: ${String(s.error ?? "").slice(0, 300)}`);
+            return undefined;
+          },
+          { everyMs: 5000, timeoutMs: 30 * 60_000, who: "H3" },
+        );
+      } catch (e) {
+        const why = e instanceof Error ? e.message : String(e);
+        throw new Error(`${why} — 작업 ${id}. 서버에서 끝났으면 KF_H3_RESUME=${id} 로 같은 명령을 다시 부르면 받아 온다`);
+      }
+      // 걸린 시간은 줄 선 시간·내려받기와 섞이지 않게 서버가 잰 추론 시간을 따로 둔다.
+      const params: Record<string, unknown> = { ...body, id, inferenceSec: job.inference_time_s, size: job.size, ...(resume ? { resumed: true } : {}) };
+      delete params.prompt;
+      params.conditions = (body.conditions as Record<string, unknown>[]).map((c) => ({ ...c, uri: "<frame>" }));
+      const bytes = await download(`${url}/v1/videos/${id}/content`);
+      // SGLang 은 받은 뒤에도 작업 기록을 쥐고 있다 — 기록만 지운다(파일은 파드 쪽 정리 몫).
+      await fetch(`${url}/v1/videos/${id}`, { method: "DELETE" }).catch(() => undefined);
+      return {
+        bytes,
+        ext: "mp4",
+        model: "MiniMaxAI/MiniMax-H3",
+        // 이어 받은 작업의 시드는 처음 보낸 요청에만 있다.
+        seed: resume ? null : body.seed,
+        costUsd: 0,
+        costEstimated: false,
+        params,
+        notes: ["self-hosted"],
+      };
+    },
+  };
+}

package/packages/gen/src/video/http.ts

@@ -0,0 +1,44 @@
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+export async function json(url: string, init: RequestInit, who: string): Promise<any> {
+  const r = await fetch(url, init);
+  const text = await r.text();
+  if (!r.ok) {
+    const hint = r.status === 402 || r.status === 403 ? " (잔액·권한을 확인)" : "";
+    throw Object.assign(new Error(`${who} ${r.status}${hint}: ${text.slice(0, 300)}`), { status: r.status });
+  }
+  return text ? JSON.parse(text) : {};
+}
+
+// 생성 큐는 몇십 초~몇 분 걸린다. 상태 하나만 보고 끝/계속을 가르는 함수를 받아 돈다.
+export async function poll<T>(
+  step: () => Promise<T | undefined>,
+  o: { everyMs: number; timeoutMs: number; who: string },
+): Promise<T> {
+  const until = Date.now() + o.timeoutMs;
+  let dropped = 0;
+  while (Date.now() < until) {
+    let v: T | undefined;
+    try {
+      v = await step();
+      dropped = 0;
+    } catch (e) {
+      // 터널·와이파이가 잠깐 끊기면 fetch 가 TypeError 로 죽는다. 몇 분짜리 생성을 그 한 번에 버리지 않는다.
+      if (!(e instanceof TypeError) || ++dropped > 24) throw e;
+    }
+    if (v !== undefined) return v;
+    await sleep(o.everyMs);
+  }
+  throw new Error(`${o.who}: ${Math.round(o.timeoutMs / 1000)}초 안에 안 끝났다`);
+}
+
+export async function download(url: string, headers: Record<string, string> = {}): Promise<Uint8Array> {
+  const r = await fetch(url, { headers, redirect: "follow" });
+  if (!r.ok) throw new Error(`내려받기 ${r.status}: ${url.slice(0, 120)}`);
+  return new Uint8Array(await r.arrayBuffer());
+}
+
+export function ceilTo(options: number[], v: number): number {
+  const sorted = [...options].sort((a, b) => a - b);
+  return sorted.find((d) => d >= v - 1e-6) ?? sorted[sorted.length - 1];
+}

package/packages/gen/src/video/ltx.ts

@@ -0,0 +1,60 @@
+import { readKey } from "../keys.ts";
+import { dataUri } from "../media.ts";
+import type { VideoProvider } from "../types.ts";
+import { ceilTo, download, json, poll } from "./http.ts";
+
+const BASE = "https://api.ltx.io/v2";
+const DURATIONS = [6, 8, 10, 12, 14, 16, 18, 20];
+const PER_SEC: Record<string, number> = { "1920x1080": 0.06, "1080x1920": 0.06, "2560x1440": 0.12, "1440x2560": 0.12 };
+
+// 키가 없어 실호출로 검증하지 못했다 — 요청 모양은 LTX API 문서(2026-10) 그대로.
+export function ltxVideo(model = "ltx-2-3-fast"): VideoProvider {
+  const resOf = (aspect: string) => (aspect === "9:16" ? "1080x1920" : "1920x1080");
+  return {
+    id: model,
+    kind: "vid",
+    model,
+    license: "LTX 커뮤니티 라이선스 — 연 매출 1천만 달러 미만 무료, 넘으면 유료 계약",
+    region: "API·가중치 전 세계(한국 포함)",
+    keyName: "ltx",
+    durations: DURATIONS,
+    firstLast: true,
+    estimateUsd: (o) => (PER_SEC[resOf(o.aspect)] ?? 0.06) * ceilTo(DURATIONS, o.duration),
+
+    async generate(o) {
+      if (!o.firstFrame) throw new Error("ltx 는 v0 에서 첫 프레임이 있는 경우만 감쌌다");
+      const key = readKey("ltx");
+      const headers = { Authorization: `Bearer ${key}`, "Content-Type": "application/json" };
+      const sec = ceilTo(DURATIONS, o.duration);
+      const resolution = resOf(o.aspect);
+      const body: Record<string, unknown> = {
+        image_uri: await dataUri(o.firstFrame),
+        prompt: o.prompt,
+        model,
+        duration: sec,
+        resolution,
+        generate_audio: false,
+      };
+      if (o.lastFrame) body.last_frame_uri = await dataUri(o.lastFrame);
+      const sub = await json(`${BASE}/image-to-video`, { method: "POST", headers, body: JSON.stringify(body) }, "LTX");
+      const url = await poll(
+        async () => {
+          const s = await json(`${BASE}/image-to-video/${sub.id}`, { headers }, "LTX 상태");
+          if (s.status === "completed") return s.result?.video_url as string;
+          if (s.status === "failed") throw new Error(`LTX 실패: ${JSON.stringify(s).slice(0, 300)}`);
+          return undefined;
+        },
+        { everyMs: 5000, timeoutMs: 15 * 60_000, who: "LTX" },
+      );
+      return {
+        bytes: await download(url),
+        ext: "mp4",
+        model,
+        seed: null,
+        costUsd: (PER_SEC[resolution] ?? 0.06) * sec,
+        costEstimated: true,
+        params: { duration: sec, resolution, id: sub.id },
+      };
+    },
+  };
+}

package/packages/gen/src/video/minimax.ts

@@ -0,0 +1,55 @@
+import { readKey } from "../keys.ts";
+import { dataUri } from "../media.ts";
+import type { VideoProvider } from "../types.ts";
+import { ceilTo, download, json, poll } from "./http.ts";
+
+const BASE = "https://api.minimax.io";
+const DURATIONS = [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+const PER_SEC: Record<string, number> = { "768P": 0.08, "2K": 0.13 };
+
+// 키가 없어 실호출로 검증하지 못했다 — 요청 모양은 MiniMax 문서(2026-10) 그대로.
+export function minimaxVideo(model = "MiniMax-H3"): VideoProvider {
+  const resolution = (r?: string) => (r === "2K" || r === "1080p" ? "2K" : "768P");
+  return {
+    id: "minimax-h3",
+    kind: "vid",
+    model,
+    license: "MiniMax API 약관 — 출력물 상업 사용 가능(공개 가중치는 한국·미국·EU·영국 제외라 API 로만)",
+    region: "API 전 세계(한국 포함). 공개 가중치는 한국 제외",
+    keyName: "minimax",
+    durations: DURATIONS,
+    firstLast: true,
+    estimateUsd: (o) => PER_SEC[resolution(o.resolution)] * ceilTo(DURATIONS, o.duration),
+
+    async generate(o) {
+      const key = readKey("minimax");
+      const headers = { Authorization: `Bearer ${key}`, "Content-Type": "application/json" };
+      const sec = ceilTo(DURATIONS, o.duration);
+      const r = resolution(o.resolution);
+      const content: unknown[] = [{ type: "text", text: o.prompt }];
+      if (o.firstFrame) content.push({ type: "image_url", image_url: { url: await dataUri(o.firstFrame) }, role: "first_frame" });
+      if (o.lastFrame) content.push({ type: "image_url", image_url: { url: await dataUri(o.lastFrame) }, role: "last_frame" });
+      const body = { model, content, duration: sec, resolution: r, ...(o.firstFrame ? {} : { ratio: o.aspect }) };
+      const sub = await json(`${BASE}/v2/video_generation`, { method: "POST", headers, body: JSON.stringify(body) }, "MiniMax");
+      const url = await poll(
+        async () => {
+          const q = await json(`${BASE}/v2/query/video_generation/${sub.task_id}`, { headers }, "MiniMax 상태");
+          const t = q.task ?? {};
+          if (t.status === "succeeded") return t.content?.url as string;
+          if (t.status === "failed" || t.status === "cancelled") throw new Error(`MiniMax ${t.status}: ${JSON.stringify(t.error ?? {})}`);
+          return undefined;
+        },
+        { everyMs: 10_000, timeoutMs: 20 * 60_000, who: "MiniMax" },
+      );
+      return {
+        bytes: await download(url),
+        ext: "mp4",
+        model,
+        seed: null,
+        costUsd: PER_SEC[r] * sec,
+        costEstimated: true,
+        params: { duration: sec, resolution: r, task_id: sub.task_id },
+      };
+    },
+  };
+}

package/packages/gen/src/video/veo.ts

@@ -0,0 +1,71 @@
+import { readFileSync } from "node:fs";
+import { readKey } from "../keys.ts";
+import type { VideoProvider } from "../types.ts";
+import { ceilTo, download, json, poll } from "./http.ts";
+
+const BASE = "https://generativelanguage.googleapis.com/v1beta";
+const DURATIONS = [4, 6, 8];
+const PER_SEC: Record<string, Record<string, number>> = {
+  "veo-3.1-lite-generate-preview": { "720p": 0.05, "1080p": 0.08 },
+  "veo-3.1-fast-generate-preview": { "720p": 0.1, "1080p": 0.12 },
+  "veo-3.1-generate-preview": { "720p": 0.4, "1080p": 0.4 },
+};
+
+const inline = (path: string) => ({
+  inlineData: { mimeType: path.endsWith(".png") ? "image/png" : "image/jpeg", data: readFileSync(path).toString("base64") },
+});
+
+// 키가 없어 실호출로 검증하지 못했다 — 요청 모양은 Gemini API Veo 문서(2026-10) 그대로.
+export function veoVideo(model = "veo-3.1-fast-generate-preview"): VideoProvider {
+  const resOf = (r?: string) => (r === "1080p" ? "1080p" : "720p");
+  // 1080p 는 8초만 받는다.
+  const secOf = (d: number, r: string) => (r === "1080p" ? 8 : ceilTo(DURATIONS, d));
+  return {
+    id: model.replace(/-generate-preview$/, ""),
+    kind: "vid",
+    model,
+    license: "Google 생성형 AI 약관 — 출력물 사용 가능, SynthID 워터마크가 박힌다",
+    region: "Gemini API 한국 제공. 사람 생성은 allow_adult 만",
+    keyName: "gemini",
+    durations: DURATIONS,
+    firstLast: true,
+    estimateUsd: (o) => {
+      const r = resOf(o.resolution);
+      return (PER_SEC[model]?.[r] ?? 0.4) * secOf(o.duration, r);
+    },
+
+    async generate(o) {
+      const key = readKey("gemini");
+      const headers = { "x-goog-api-key": key, "Content-Type": "application/json" };
+      const r = resOf(o.resolution);
+      const sec = secOf(o.duration, r);
+      const instance: Record<string, unknown> = { prompt: o.prompt };
+      if (o.firstFrame) instance.image = inline(o.firstFrame);
+      if (o.lastFrame) instance.lastFrame = inline(o.lastFrame);
+      const aspectRatio = o.aspect === "9:16" ? "9:16" : "16:9";
+      const body = { instances: [instance], parameters: { aspectRatio, durationSeconds: String(sec), resolution: r } };
+      const op = await json(`${BASE}/models/${model}:predictLongRunning`, { method: "POST", headers, body: JSON.stringify(body) }, "Veo");
+      const uri = await poll(
+        async () => {
+          const s = await json(`${BASE}/${op.name}`, { headers }, "Veo 상태");
+          if (s.error) throw new Error(`Veo 실패: ${JSON.stringify(s.error)}`);
+          if (!s.done) return undefined;
+          const u = s.response?.generateVideoResponse?.generatedSamples?.[0]?.video?.uri;
+          if (!u) throw new Error(`Veo 결과에 영상이 없다: ${JSON.stringify(s).slice(0, 300)}`);
+          return u as string;
+        },
+        { everyMs: 10_000, timeoutMs: 15 * 60_000, who: "Veo" },
+      );
+      return {
+        bytes: await download(uri, { "x-goog-api-key": key }),
+        ext: "mp4",
+        model,
+        seed: null,
+        costUsd: (PER_SEC[model]?.[r] ?? 0.4) * sec,
+        costEstimated: true,
+        params: { aspectRatio, durationSeconds: sec, resolution: r },
+        notes: ["synthid"],
+      };
+    },
+  };
+}

package/packages/jizura/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@kasaframe/jizura",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./install": "./src/install.ts",
+    "./lyrics": "./src/lyrics.ts",
+    "./vite": "./src/vite.ts"
+  },
+  "dependencies": {
+    "@kasaframe/adapters": "^0.0.0",
+    "@kasaframe/core": "^0.0.0"
+  }
+}

package/packages/jizura/src/deny.ts

@@ -0,0 +1,73 @@
+// JIZURA 부품 거부 목록 — 가사 층을 장면 위에 투명하게 얹을 때 화면을 통째로 덮거나 톤이 튀는 부품.
+// 출처: vocaloid-style-mv-pipeline(MIT, NikusonP) references/06-jizura.md §5 와 그 틀로 만든 뮤비의 timeline.js.
+// 거기에 front·transparent 에서 화면을 덮은 것으로 확인한 layout filmstrip·justified·circle(글 뒤 불투명 원판), trans whipPan·cover, hold colorRun, decor moonPhases 를 더했다.
+// 이 목록을 바꾸면 그 플랜의 컷이 다시 굴려진다 — 스틸을 다시 본다.
+
+export type PartGroup = "layout" | "enter" | "hold" | "exit" | "decor" | "treat" | "bg" | "cam" | "fx" | "trans";
+
+const words = (s: string): string[] => s.split(/\s+/).filter(Boolean);
+
+export const DENY: Record<PartGroup, string[]> = {
+  layout: words(`scatter ring wave labels pill knSeesaw knGearWords knTumble knPadGrid knPathRide zigzag arcTop gridCells bubble ticker
+    searchBar chat notification ticket hanging wordCloud bounceLine elastic stickerBomb keycaps bubbles slotMachine flipBoard dotMatrix
+    equalizer tape contents numbered poster ema ransom newspaper vinyl cassette bookSpine stampSheet calendar chochin routeMap stationSign
+    noren tanzaku omikuji kakejiku shoji clapper warningLabel priceTag nameTag stickyNotes karuta cube flipCards accordion pile blocks
+    balloons magnets tiles bulbs ledScroll billboard crowdBubbles crossword wordSearch puzzle dominoes burst fisheye origami zipper
+    mosaicTiles stencil tyIndexTable tyStatCount typeSpecimen dictionary proofread magazine headlineDeck footnote ribbon flag pendulum
+    knCollide knSlamStack halftoneBig tySquare tyRotBlock subtitleBar tile kaleido polaroid postcard letterPaper genkou panels splitScreen
+    splitHalves wall cylinder shadowPlay glitchGrid filmstrip justified circle`),
+  // 화면 전체 효과는 섬광 예산과 함께 kasaframe 쪽(dropBurst·전환)이 쥔다
+  fx: words(`panelWipe irisTrans doors blindsTrans splitSlide gridRepeat whiteFrame blackFrame strobe colorBars mirrorFlash starGlint
+    focusLines speedLines halftone duotone kaleido bulge squash snapshot loopScroll crtOff tvStatic zoomStutter negativeRing edgeDetect
+    hueShift posterize ditherBit rotateSnap invert bandInvert flash bloomFlash`),
+  decor: words(`dots arrows shapes qrBlock triangleSpin checkerStrip confetti petals heartsStars kamon seigaiha asanoha hanabi chochin
+    shimenawa sensu momiji namiGashira memphis zigzagRibbon polkaPatch stripeCircle starburst cursorClick windowChrome progressBar
+    toggleSwitch notifBell likeCounter mediaControls volumeBars musicNotes bubbles dandelion vines cloudPuffs tapePieces highlightMark
+    staple paperClip indexTabs punchHoles swatches spinner tally bracketsJP loopArrows halfCircles decoCorners tyColophon dateStamp
+    tyTypeScale tyTextRule dataColumns timecodeBar rainStreaks moonPhases`),
+  // 키네틱 카메라는 컷 전체를 불투명 카드로 감싼다 — 장면 위에 노랑·검정 판이 통째로 뜬다
+  cam: words("knCardFlip jelly bounce knJumpCut knTiltKick knReadPan knShearKick knRushIn"),
+  treat: words("boxed marker knWordPlate circled sticker splitColor rainbow chrome"),
+  enter: words("bubbles stickerPeel crumple loadingBar tokoroten"),
+  hold: words("colorRun"),
+  exit: words("balloonOff crumpleOut peelOff"),
+  bg: words(`argyle tartan chevron houndstooth herringbone polka checker retroGrid eqBars kaleidoscope fireworks sunburst bigStripes
+    isoCubes seigaiha asanoha tvBars splitDiag spiralArms squareTunnel moire`),
+  trans: words("knCornerSwing knStripSlam checker cubeTurn spinOut doorsOpen pixelate knStutterCut whipPan cover"),
+};
+
+/** JIZURA 엔진(window.J)의 부품 등록부 — 필요한 것만 */
+export interface JizuraRegistry {
+  GROUP_KEYS: string[];
+  order(group: string): string[];
+  registry(group: string): Record<string, { tags?: string[]; set?: string } | undefined> | undefined;
+}
+
+export interface PoolOptions {
+  /** 기본 목록에 더 막을 부품 */
+  deny?: Partial<Record<PartGroup, string[]>>;
+  /** 기본 목록 대신 이것만 막는다 */
+  denyOnly?: Partial<Record<PartGroup, string[]>>;
+  /** 이 태그(pop·emotional·graphic·calm·editorial·glitch) 중 하나를 단 부품만. 태그 없는 부품은 남는다 */
+  moods?: string[] | null;
+}
+
+/** JIZURA project.enabled — 거부 목록·공포 세트·분위기 거르기를 한 번에 */
+export function partPool(J: JizuraRegistry, o: PoolOptions = {}): Record<string, Record<string, boolean>> {
+  const base = o.denyOnly ?? DENY;
+  const out: Record<string, Record<string, boolean>> = {};
+  for (const g of J.GROUP_KEYS) {
+    const deny = new Set([...(base[g as PartGroup] ?? []), ...(o.deny?.[g as PartGroup] ?? [])]);
+    const reg = J.registry(g) ?? {};
+    out[g] = {};
+    for (const k of J.order(g)) {
+      const d = reg[k] ?? {};
+      const tags = Array.isArray(d.tags) ? d.tags : null;
+      let ok = !deny.has(k) && !/^hr[A-Z]/.test(k) && d.set !== "horror";
+      if (ok && o.moods && tags && !tags.some((m) => o.moods!.includes(m))) ok = false;
+      if (k === "none") ok = true;
+      out[g][k] = ok;
+    }
+  }
+  return out;
+}

package/packages/jizura/src/index.ts

@@ -0,0 +1,7 @@
+export { jizuraLayer, jizuraPlans, jizuraReady, jizuraCuts, loadJizura, lyricsMode } from "./layer.ts";
+export type { DrawMode, JizuraPaint, LayerOptions, LyricsMode, PlanSettings } from "./layer.ts";
+export { DENY, partPool } from "./deny.ts";
+export type { PartGroup, PoolOptions } from "./deny.ts";
+export { toLrc, parseLyrics, wordsOf } from "./lyrics.ts";
+export type { LyricsJson, LyricLine, LyricWord, LrcOptions } from "./lyrics.ts";
+export { JIZURA_COMMIT, JIZURA_VERSION, JIZURA_CREDIT } from "./pin.ts";