@mekuru/core 0.1.2 → 0.1.4

package/README.jp.md

@@ -2,17 +2,68 @@
 
 [English](README.md)
 
-Mekuru Movie Maker の台本を TSX で書き、XML に書き出すパッケージです。組み込み要素の型と、Hono の JSX ランタイムの再エクスポートを提供します。
+Mekuru Movie Maker の Rust 製動画コンパイラ兼プレビューサーバーです。XML の監視、コンパイル、HTTP/WebSocket・素材の配信、ブラウザ用ビューアを1つの実行ファイルにまとめています。ffmpeg による動画書き出しも行います。
 
-Bun 1.4 以上が必要です。
+旧 `@mekuru/core` の TSX の型・JSX ランタイム・XML 出力は [@mekuru/types](../types/README.jp.md) へ移動しました。台本の import と `jsxImportSource` は `@mekuru/types` へ変更してください。
 
 ```sh
 bun add -d @mekuru/core
+bunx mekuru-compiler .mekuru/main.xml --serve --run 'bun --hot src/main.tsx'
+bunx mekuru-compiler .mekuru/main.xml -o video.mp4
 ```
 
-- `tsconfig.json` の `jsx` を `react-jsx`、`jsxImportSource` を `@mekuru/core` に設定します。
-- `writeXml(path, video)` で部品を展開して XML を書き出し、`toXml(video)` で XML 文字列を取得できます。
-- 非同期の読み上げ部品は、先に下書きを書き出し、音声合成が終わると更新できます。
-- XML のプレビューと動画への書き出しには [@mekuru/cli](../cli/README.jp.md) を使います。
+`@mekuru/cli` を `@mekuru/core` に統合しました。依存名と `@mekuru/cli/timeline` などの import を `@mekuru/core/timeline` へ変更してください。OS 別バイナリは自動導入されます。npm コマンドにはバイナリ選択用の小さな Node/Bun ランチャーだけを残し、サーバーの処理はすべて Rust です。`mekuru-server <xml>` は `mekuru-compiler <xml> --serve` の別名として使えます。JavaScript の旧 `startServer` API は廃止し、ネイティブコマンドの起動または Rust の `mekuru_compiler::server::start` を利用します。
 
-[TSX の書き方](../../docs/reference/Component.jp.md) と [組み込みの要素](../../docs/reference/Syntax.jp.md)
+実行ファイルをコピーすれば、Node・Bun・別のビューアフォルダなしで直接起動できます。
+
+```sh
+mekuru-compiler project/main.xml --serve --no-open
+```
+
+`--run` で TSX から XML を作る場合は、そのコマンドに Bun が必要です。動画書き出し・メディア解析には ffmpeg/ffprobe、文字表示には適切なフォントを用意してください。
+
+## プレビューのオプション
+
+- `--serve`: XML を監視し、ループバックでプレビューとタイムラインを配信します。
+- `-p, --port <port>`: ポート。既定は3333、0なら空きポートを選びます。
+- `--root <dir>`: 素材とスクリプトの基準フォルダ。既定は XML のフォルダ、`.mekuru` の場合はその親です。
+- `--run <command>`: プロジェクトフォルダでシェルコマンドを実行します。標準エラーを次の XML 保存までビューアへ表示し、サーバー終了時は子プロセスも終了させます。
+- `--title <name>`: ブラウザのタイトル。既定は XML の引数です。
+- `--no-open` / `--open`: ブラウザの自動起動。`MEKURU_OPEN=0`・`false`・`no`・`off` でも抑止できます。
+
+`--run` があれば XML がまだ存在しなくても起動できます。コンパイル失敗時は最後の成功シーンを維持します。保存後は10 ms間隔で2回読み、内容の一致を確認します。`/mnt/` では500 ms間隔のポーリングを使います。受信が遅れた WebSocket 接続には snapshot を送り直します。素材は HEAD・バイト範囲取得に対応し、プロジェクト外へ解決されるパスは配信しません。
+
+## 書き出し・機械向け出力
+
+- `--scale`・`--fps`・`--from`・`--to`・`--preset`・`--crf`・`--no-audio`・`--preview` で動画書き出しを設定します。
+- `--emit-preview`: 展開済みのプレビュー JSON を出力します。
+- `--emit-timeline`: 描画パスを含めず、台本 ID・整数フレーム区間・繰り返し・診断を出力します。
+- `--preview-worker`: ツールと計測用に JSON Lines 接続を維持します。ネイティブサーバーはコンパイラを同一プロセス内で呼び出し、IPC を使いません。
+
+## 公開APIと軽量タイムライン
+
+Bun の台本用アダプターと型は `@mekuru/core/timeline` から利用できます。
+
+```ts
+import { compileTimeline, timelineIntervals } from "@mekuru/core/timeline";
+const result = await compileTimeline(".mekuru/main.xml");
+for (const entry of result.timeline?.entries ?? []) {
+  console.log(entry.sourceId, timelineIntervals(entry));
+}
+```
+
+`compileTimeline(xmlPath, { root? })` は `{ timeline, diagnostics }` を返し、解析失敗時は timeline が null です。`timelineIntervals` は入れ子の繰り返しを展開し、最終周回を切り詰めた論理区間を返します。スロットによる表示区間とは別です。`@mekuru/core/compiler` の `findCompiler` は、`MEKURU_COMPILER`、OS 別 npm パッケージ、ローカルの新しい debug/release バイナリの順に探します。
+
+## ビルド
+
+Rust 1.89 以上、C リンカー、UI ビルド用の Bun を使います。
+
+```sh
+bun install
+bun run build:release
+./target/release/mekuru-compiler path/to/main.xml --serve
+```
+
+ビューアを `pkgs/core/viewer/` にビルドし、`build.rs` で実行ファイルへ埋め込みます。UI 変更後は実行ファイルも再ビルドしてください。release ビルドは UI 未生成なら失敗し、Rust だけの debug ビルドでは作成手順を表示します。CI はすべての OS 別バイナリへ UI を埋め込んでから梱包します。
+
+[XML構文](../../docs/reference/Syntax.jp.md)・[開発手順](../../docs/dev/Developer.jp.md)も参照してください。

package/README.md

@@ -2,17 +2,68 @@
 
 [日本語](README.jp.md)
 
-TSX authoring and XML output for Mekuru Movie Maker. Provides types for built-in elements and re-exports Hono's JSX runtime.
+The Rust video compiler and preview server for Mekuru Movie Maker. One native executable watches XML, compiles scenes, serves HTTP/WebSocket and media, and contains the browser viewer. It also exports video through ffmpeg.
 
-Requires Bun 1.4 or later.
+TSX types, the JSX runtime and XML output are provided by [@mekuru/types](../types/README.md), formerly `@mekuru/core`. Update authoring imports and `jsxImportSource` to `@mekuru/types`.
 
 ```sh
 bun add -d @mekuru/core
+bunx mekuru-compiler .mekuru/main.xml --serve --run 'bun --hot src/main.tsx'
+bunx mekuru-compiler .mekuru/main.xml -o video.mp4
 ```
 
-- Set `jsx` to `react-jsx` and `jsxImportSource` to `@mekuru/core` in `tsconfig.json`.
-- Use `writeXml(path, video)` to expand components and write XML, or `toXml(video)` to get an XML string.
-- Async speech components can write an initial draft and update it after synthesis finishes.
-- Use [@mekuru/cli](../cli/README.md) to preview the XML or render a video.
+`@mekuru/core` replaces `@mekuru/cli`. Change that dependency and imports such as `@mekuru/cli/timeline` to `@mekuru/core/timeline`. Platform binaries are installed automatically. The npm commands are small Node/Bun launchers that select the binary; all server behavior is Rust. `mekuru-server <xml>` remains an alias for `mekuru-compiler <xml> --serve`. The old JavaScript `startServer` API is removed; spawn the native command or use Rust's `mekuru_compiler::server::start`.
 
-See [TSX authoring](../../docs/reference/Component.md) and [built-in elements](../../docs/reference/Syntax.md).
+The native executable can be copied and run directly without Node, Bun or a separate viewer folder:
+
+```sh
+mekuru-compiler project/main.xml --serve --no-open
+```
+
+Bun is still needed when your `--run` command authors XML using TSX. Video export and media analysis require ffmpeg/ffprobe; install fonts suitable for your script.
+
+## Preview options
+
+- `--serve`: watch XML and serve the embedded preview and timeline on loopback.
+- `-p, --port <port>`: port, default 3333; use 0 to choose an available port.
+- `--root <dir>`: asset and script working directory. Defaults to the XML folder, or its parent when that folder is `.mekuru`.
+- `--run <command>`: run a shell command in the project directory. Stderr appears in the viewer until the next XML save. The server terminates the command and its child processes on shutdown.
+- `--title <name>`: browser title, default the XML argument.
+- `--no-open` / `--open`: control automatic browser opening. `MEKURU_OPEN=0`, `false`, `no` or `off` also disables it.
+
+A missing XML file is allowed with `--run`. Compilation errors preserve the last successful scene. Saving uses two matching reads 10 ms apart; `/mnt/` uses a 500 ms polling fallback. Slow WebSocket readers receive a fresh snapshot when they fall behind. Asset URLs support HEAD and byte ranges; paths must resolve inside the project root.
+
+## Export and machine output
+
+- `--scale`, `--fps`, `--from`, `--to`, `--preset`, `--crf`, `--no-audio`, and `--preview` configure video export.
+- `--emit-preview` emits standalone expanded preview JSON.
+- `--emit-timeline` emits source IDs, integer frame intervals, repeat chains and diagnostics without drawing paths.
+- `--preview-worker` retains the JSON Lines interface for tools and benchmarks. The native server calls the compiler in process and does not use IPC.
+
+## Programmatic APIs
+
+The Bun authoring adapter and its types are available from `@mekuru/core/timeline`:
+
+```ts
+import { compileTimeline, timelineIntervals } from "@mekuru/core/timeline";
+const result = await compileTimeline(".mekuru/main.xml");
+for (const entry of result.timeline?.entries ?? []) {
+  console.log(entry.sourceId, timelineIntervals(entry));
+}
+```
+
+`compileTimeline(xmlPath, { root? })` returns `{ timeline, diagnostics }`. Failed analysis has a null timeline. `timelineIntervals` expands nested repeats and clips the final round; it describes logical intervals, not slot visibility. `findCompiler` from `@mekuru/core/compiler` resolves `MEKURU_COMPILER`, then the platform npm package, then the newest local debug/release binary.
+
+## Building
+
+Use Rust 1.89 or later, a C linker and Bun for the UI build:
+
+```sh
+bun install
+bun run build:release
+./target/release/mekuru-compiler path/to/main.xml --serve
+```
+
+The viewer builds to `pkgs/core/viewer/` and `build.rs` embeds it. Rebuild the executable after UI changes. A release build fails if the UI is missing; a Rust-only debug build displays build instructions instead. CI embeds the UI in every platform binary before packaging.
+
+See [XML syntax](../../docs/reference/Syntax.md) and [development](../../docs/dev/Developer.md).

package/bin/launch.js

@@ -0,0 +1,19 @@
+import { spawn } from "node:child_process";
+import { findCompiler } from "../npm/compiler.js";
+
+export function launch(prefix = []) {
+  try {
+    const child = spawn(findCompiler(), [...prefix, ...process.argv.slice(2)], { stdio: "inherit" });
+    const stop = (signal) => child.kill(signal);
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+    child.on("error", (error) => {
+      console.error(`error: ${error.message}`);
+      process.exit(1);
+    });
+    child.on("exit", (code, signal) => process.exit(code ?? (signal === "SIGINT" ? 130 : 1)));
+  } catch (error) {
+    console.error(`error: ${error.message}`);
+    process.exit(1);
+  }
+}

package/bin/mekuru-compiler.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { launch } from "./launch.js";
+launch();

package/bin/mekuru-server.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { launch } from "./launch.js";
+launch(["--serve"]);

package/npm/compiler.d.ts

@@ -0,0 +1 @@
+export declare const findCompiler: () => string;

package/npm/compiler.js

@@ -0,0 +1,43 @@
+import { existsSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+const here = dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+const EXE = process.platform === "win32" ? "mekuru-compiler.exe" : "mekuru-compiler";
+const PKG = `@mekuru/core-${process.platform}-${process.arch}`;
+const ENV = "MEKURU_COMPILER";
+
+const fromPlatformPackage = () => {
+  try {
+    const path = join(dirname(require.resolve(`${PKG}/package.json`)), "bin", EXE);
+    return existsSync(path) ? path : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+const fromRepository = () => {
+  const target = join(here, "..", "..", "..", "target");
+  return ["debug", "release"]
+    .map((p) => join(target, p, EXE))
+    .filter((p) => existsSync(p))
+    .sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs)[0];
+};
+
+export const findCompiler = () => {
+  const env = process.env[ENV];
+  if (env) {
+    if (!existsSync(env)) throw new Error(`${ENV} points to ${env}, which does not exist`);
+    return env;
+  }
+  const found = fromPlatformPackage() ?? fromRepository();
+  if (found) return found;
+  throw new Error(
+    `mekuru-compiler for ${process.platform}-${process.arch} is not installed.\n` +
+      `  - reinstall the packages (\`bun install\`) so that ${PKG} is installed, or\n` +
+      `  - build it from the Mekuru Movie Maker repository (\`cargo build --locked\`)\n` +
+      `    and set ${ENV} to the binary`,
+  );
+};

package/npm/timeline.ts

@@ -0,0 +1,38 @@
+import type { FrameInterval, TimelineCompilation, TimelineEntry } from "@mekuru/protocol";
+import { findCompiler } from "./compiler.js";
+export type { FrameRate, FrameInterval, TimelineEntry, ResolvedTimeline, TimelineCompilation } from "@mekuru/protocol";
+
+export async function compileTimeline(xmlPath: string, options: { root?: string } = {}): Promise<TimelineCompilation> {
+  const args = [findCompiler(), xmlPath, "--emit-timeline"];
+  if (options.root) args.push("--root", options.root);
+  const proc = Bun.spawn(args, { stdout: "pipe", stderr: "pipe" });
+  const [stdout, stderr, code] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text(), proc.exited]);
+  if (code !== 0) throw new Error(stderr.slice(-16000).trim() || `mekuru-compiler exited (${code})`);
+  const result = JSON.parse(stdout) as TimelineCompilation;
+  if (
+    !result ||
+    !Array.isArray(result.diagnostics) ||
+    !("timeline" in result) ||
+    (result.timeline !== null && (!Array.isArray(result.timeline?.entries) || !result.timeline?.fps))
+  )
+    throw new Error("unexpected compiler response; rebuild or update mekuru-compiler");
+  return result;
+}
+
+/** Expand only this entry's logical intervals, not slot visibility. */
+export function timelineIntervals(entry: TimelineEntry): FrameInterval[] {
+  let intervals: FrameInterval[] = [{ startFrame: entry.startFrame, endFrame: entry.endFrame }];
+  for (const r of [...entry.repeat].reverse()) {
+    if (!Number.isSafeInteger(r.periodFrames) || r.periodFrames <= 0) throw new Error("invalid repeat period");
+    const next: FrameInterval[] = [];
+    for (const span of intervals) {
+      for (let shift = 0; r.fromFrame + shift < r.untilFrame; shift += r.periodFrames) {
+        const startFrame = span.startFrame + shift;
+        const endFrame = Math.min(span.endFrame + shift, r.untilFrame);
+        if (endFrame > startFrame) next.push({ startFrame, endFrame });
+      }
+    }
+    intervals = next;
+  }
+  return intervals.filter((s) => s.endFrame > s.startFrame).sort((a, b) => a.startFrame - b.startFrame);
+}

package/package.json

@@ -1,21 +1,37 @@
 {
   "name": "@mekuru/core",
-  "version": "0.1.2",
-  "description": "The types of the XML of Mekuru Movie Maker, for writing videos in TSX with jsxImportSource @mekuru/core (the JSX runtime is Hono's); the viewer and the compiler are in @mekuru/cli",
+  "version": "0.1.4",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kanade-k-1228/mekuru.git",
+    "directory": "pkgs/core"
+  },
+  "homepage": "https://github.com/kanade-k-1228/mekuru/blob/main/pkgs/core/README.md",
+  "description": "Native video compiler and preview server with an embedded browser viewer",
   "type": "module",
-  "exports": {
-    ".": "./src/index.ts",
-    "./jsx-runtime": "./src/index.ts",
-    "./jsx-dev-runtime": "./src/index.ts"
+  "bin": {
+    "mekuru-compiler": "./bin/mekuru-compiler.js",
+    "mekuru-server": "./bin/mekuru-server.js"
   },
   "files": [
-    "src"
+    "bin",
+    "npm"
   ],
-  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
   "dependencies": {
-    "hono": "^4.13.0"
+    "@mekuru/protocol": "^0.1.4"
   },
-  "engines": {
-    "bun": ">=1.4"
+  "exports": {
+    "./compiler": "./npm/compiler.js",
+    "./timeline": "./npm/timeline.ts"
+  },
+  "optionalDependencies": {
+    "@mekuru/core-darwin-arm64": "0.1.4",
+    "@mekuru/core-darwin-x64": "0.1.4",
+    "@mekuru/core-linux-arm64": "0.1.4",
+    "@mekuru/core-linux-x64": "0.1.4",
+    "@mekuru/core-win32-x64": "0.1.4"
   }
 }

package/src/index.ts

@@ -1,5 +0,0 @@
-export { Fragment, jsx, jsx as jsxs, jsx as jsxDEV } from "hono/jsx/jsx-runtime";
-
-export type { Anchor, At, Color, IntrinsicElements, JSX, Length, Node, Time } from "./jsx.ts";
-export { isDraft, waitFor, writeXml } from "./write.ts";
-export { fps, toXml } from "./xml.ts";

package/src/jsx.ts

@@ -1,138 +0,0 @@
-import type { Child } from "hono/jsx";
-import type { JSX as HonoJSX } from "hono/jsx/jsx-runtime";
-
-export type Node = Child;
-
-export type Length = number | `${number}%` | "auto";
-type Ratio = number | `${number}%`;
-export type Time = number;
-export type At = number | string;
-export type Color = string;
-export type Anchor = "tl" | "t" | "tr" | "l" | "c" | "r" | "bl" | "b" | "br" | "center" | "top" | "bottom" | "left" | "right";
-
-interface Base {
-  key?: string | number;
-}
-
-interface WithChildren {
-  children?: Node;
-}
-
-interface Timed {
-  id?: string;
-  at?: At;
-  fadein?: Time;
-  fadeout?: Time;
-  slot?: string;
-}
-
-interface Look {
-  z?: number;
-  opacity?: Ratio;
-}
-
-interface Box {
-  x?: Length;
-  y?: Length;
-  anchor?: Anchor;
-  w?: Length;
-  h?: Length;
-  "min-w"?: Length;
-  "max-w"?: Length;
-  "min-h"?: Length;
-  "max-h"?: Length;
-  grow?: boolean | number;
-  shrink?: number;
-  rotate?: number;
-}
-
-interface Deco {
-  fill?: Color;
-  stroke?: Color;
-  "stroke-width"?: number;
-  radius?: number;
-}
-
-type Align = "start" | "center" | "end" | "stretch";
-
-interface Overlay extends Base, Timed, Look, Box, Deco, WithChildren {
-  padding?: Length | readonly Length[];
-  align?: Align;
-}
-
-interface Flow extends Overlay {
-  gap?: Length;
-  justify?: "start" | "center" | "end" | "between" | "around" | "evenly";
-  wrap?: boolean;
-}
-
-interface TextStyle {
-  size?: number;
-  color?: Color;
-  font?: string;
-  stroke?: Color;
-  "stroke-width"?: number;
-  "line-height"?: number;
-  background?: Color;
-  radius?: number;
-  padding?: Length | readonly Length[];
-}
-
-interface Media {
-  src: string;
-  from?: Time;
-  to?: Time;
-  volume?: Ratio;
-  children?: Node;
-}
-
-export interface IntrinsicElements {
-  mekuru: Base &
-    WithChildren & {
-      size?: `${number}x${number}`;
-      fps?: number;
-      font?: string;
-      preset?: string;
-      crf?: number;
-      "audio-bitrate"?: string;
-    };
-  seq: Overlay;
-  stack: Overlay;
-  row: Flow;
-  column: Flow;
-  repeat: Base & Timed & Look & WithChildren;
-  dur: Base & Timed & Look & WithChildren & { len: Time };
-
-  text: Base & Timed & Look & Box & TextStyle & WithChildren & { weight?: "normal" | "bold"; align?: "left" | "center" | "right"; pre?: boolean };
-  image: Base & Timed & Look & Box & { src: string };
-  video: Base & Timed & Look & Omit<Box, "rotate"> & Media;
-  audio: Base & Omit<Timed, "slot"> & Omit<Media, "src"> & { src?: string; label?: string; draft?: boolean };
-  hold: Base & WithChildren & Look & { at: Time; id?: string; fadein?: Time; fadeout?: Time; slot?: string };
-  speed: Base & { from?: Time; to?: Time; rate: number };
-  cut: Base & { from?: Time; to?: Time };
-  rect: Base & Timed & Look & Box & Deco;
-  circle: Base & Timed & Look & Box & Deco;
-  line: Base &
-    Timed &
-    Look & {
-      p: string;
-      closed?: boolean;
-      fill?: Color;
-      stroke?: Color;
-      "stroke-width"?: number;
-      head?: "none" | "start" | "end" | "both";
-      dashed?: boolean;
-      dotted?: boolean;
-    };
-  br: Base;
-}
-
-export namespace JSX {
-  export type Element = HonoJSX.Element;
-  export type ElementType = HonoJSX.ElementType;
-  export interface ElementChildrenAttribute extends HonoJSX.ElementChildrenAttribute {}
-  export interface IntrinsicAttributes extends HonoJSX.IntrinsicAttributes {}
-  export interface IntrinsicElements extends IntrinsicElementsBase {}
-}
-
-type IntrinsicElementsBase = IntrinsicElements;

package/src/write.ts

@@ -1,35 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import { rename, rm } from "node:fs/promises";
-import { toXml } from "./xml.ts";
-
-const output = new AsyncLocalStorage<{ draft: boolean; waits: Set<Promise<unknown>> }>();
-
-export const isDraft = (): boolean => output.getStore()?.draft ?? false;
-
-export const waitFor = (work: Promise<unknown>): void => {
-  work.catch(() => {});
-  output.getStore()?.waits.add(work);
-};
-
-export const writeXml = async (path: string, video: unknown): Promise<void> => {
-  const context = { draft: true, waits: new Set<Promise<unknown>>() };
-  await output.run(context, async () => {
-    const tmp = `${path}.${process.pid}.${crypto.randomUUID()}.tmp`;
-    const save = async () => {
-      const xml = await toXml(video);
-      await Bun.write(tmp, xml);
-      await rename(tmp, path);
-    };
-    try {
-      await save();
-      context.draft = false;
-      if (context.waits.size === 0) return;
-      await Promise.all(context.waits);
-      await save();
-    } finally {
-      context.draft = false;
-      context.waits.clear();
-      await rm(tmp, { force: true });
-    }
-  });
-};

package/src/xml.ts

@@ -1,194 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-
-type Props = Record<string, unknown>;
-
-interface Element {
-  tag: string;
-  props: Props;
-  children: Item[];
-}
-type Item = Element | string;
-
-interface JsxNode {
-  tag: unknown;
-  props: Props;
-  children: unknown[];
-}
-
-const isJsxNode = (v: unknown): v is JsxNode => typeof v === "object" && v !== null && "tag" in v && "props" in v && Array.isArray((v as JsxNode).children);
-
-const describe = (v: unknown): string => (typeof v === "object" && v !== null ? (v.constructor?.name ?? "an object") : typeof v);
-
-const rate = new AsyncLocalStorage<number>();
-
-export const fps = (): number => {
-  const f = rate.getStore();
-  if (f === undefined) throw new Error("fps() is known only inside `<mekuru>` while writeXml writes it: call it in a component");
-  return f;
-};
-
-const frameRate = (v: unknown): number => {
-  const f = v === undefined ? 30 : Number(v);
-  if (!(f > 0 && f <= 240)) throw new Error(`\`<mekuru fps>\` is frames per second, a number above 0 (not ${String(v)})`);
-  return f;
-};
-
-const expand = async (node: unknown, out: Item[]): Promise<void> => {
-  node = await node;
-  if (node === null || node === undefined || typeof node === "boolean") return;
-  if (typeof node === "string" || typeof node === "number" || typeof node === "bigint" || node instanceof String) {
-    out.push(String(node));
-    return;
-  }
-  if (Array.isArray(node)) {
-    for (const n of node) await expand(n, out);
-    return;
-  }
-  if (isJsxNode(node)) {
-    const { tag, props, children } = node;
-    if (typeof tag === "function") {
-      const p = { ...props };
-      if (children.length) p.children = children.length === 1 ? children[0] : children;
-      return expand(await tag(p), out);
-    }
-    if (tag === "") {
-      for (const c of children) await expand(c, out);
-      return;
-    }
-    if (typeof tag === "string") {
-      const el: Element = { tag, props, children: [] };
-      const inside = async () => {
-        for (const c of children) await expand(c, el.children);
-      };
-      await (tag === "mekuru" ? rate.run(frameRate(props.fps), inside) : inside());
-      out.push(el);
-      return;
-    }
-  }
-  throw new Error(`a video is made of elements and text, not ${describe(node)}`);
-};
-
-interface X {
-  tag: string;
-  attrs: [string, string][];
-  children: (X | string)[];
-}
-
-const TIMES = new Set(["len", "fadein", "fadeout", "from", "to", "delay"]);
-const LENGTHS = new Set(["x", "y", "w", "h", "min-w", "max-w", "min-h", "max-h", "gap"]);
-const RATIOS = new Set(["opacity", "volume"]);
-const COLORS = new Set(["fill", "stroke", "color", "background"]);
-
-const NAMED: Record<string, string> = {
-  black: "#000000",
-  white: "#FFFFFF",
-  red: "#FF0000",
-  lime: "#00FF00",
-  green: "#008000",
-  blue: "#0000FF",
-  yellow: "#FFFF00",
-  cyan: "#00FFFF",
-  aqua: "#00FFFF",
-  magenta: "#FF00FF",
-  fuchsia: "#FF00FF",
-  gray: "#808080",
-  grey: "#808080",
-  silver: "#C0C0C0",
-  maroon: "#800000",
-  olive: "#808000",
-  purple: "#800080",
-  teal: "#008080",
-  navy: "#000080",
-  orange: "#FFA500",
-  transparent: "#00000000",
-  none: "#00000000",
-};
-
-const ANCHORS: Record<string, string> = { center: "c", top: "t", bottom: "b", left: "l", right: "r" };
-
-const num = (n: number): string => {
-  const s = String(n);
-  return /e/i.test(s) && Math.abs(n) < 1 ? n.toFixed(20).replace(/\.?0+$/, "") : s;
-};
-
-const frames = (v: unknown): string => (typeof v === "number" ? num(v) : String(v).trim());
-
-const length = (v: unknown): string => (typeof v === "number" ? num(v) : String(v));
-
-const ratio = (v: unknown): string => {
-  if (typeof v === "number") return num(v);
-  const s = String(v).trim();
-  const pct = /^(-?[\d.]+)%$/.exec(s);
-  return pct ? num(Number(pct[1]) / 100) : s;
-};
-
-const color = (v: unknown): string => NAMED[String(v).trim().toLowerCase()] ?? String(v).trim();
-
-const at = (v: unknown): [string, string] => {
-  const s = typeof v === "string" ? v.trim() : v;
-  if (typeof s !== "string" || !/^[\p{L}_]/u.test(s)) return ["delay", frames(s)];
-  const [id, q] = s.includes(":") ? [s.slice(0, s.indexOf(":")), s.slice(s.indexOf(":") + 1)] : [s, "0"];
-  return ["at", `${id.trim()}:${frames(q)}`];
-};
-
-const attr = (tag: string, key: string, v: unknown): [string, string] | undefined => {
-  if (key === "at") return tag === "hold" ? ["at", frames(v)] : at(v);
-  if (typeof v === "boolean") return key === "grow" ? [key, v ? "1" : "0"] : v ? [key, "true"] : undefined;
-  if (TIMES.has(key)) return [key, frames(v)];
-  if (LENGTHS.has(key)) return [key, length(v)];
-  if (RATIOS.has(key)) return [key, ratio(v)];
-  if (COLORS.has(key)) return [key, color(v)];
-  if (key === "padding") return [key, (Array.isArray(v) ? v : [v]).map(length).join(" ")];
-  if (key === "anchor") return [key, ANCHORS[String(v)] ?? String(v)];
-  return [key, typeof v === "number" ? num(v) : String(v)];
-};
-
-const normalize = (el: Element): X => {
-  const x: X = { tag: el.tag, attrs: [], children: [] };
-  for (const c of el.children) {
-    if (typeof c !== "string") x.children.push(normalize(c));
-    else if (el.tag === "text" || c.trim()) x.children.push(c);
-  }
-  for (const [k, v] of Object.entries(el.props)) {
-    if (k === "children" || k === "key" || v === undefined || v === null) continue;
-    const a = attr(el.tag, k, v);
-    if (a) x.attrs.push(a);
-  }
-  return x;
-};
-
-const escapeXml = (s: string, quote: boolean) =>
-  s.replace(
-    quote ? /[&<>"\n\r\t]/g : /[&<>]/g,
-    (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "\n": "&#10;", "\r": "&#13;", "\t": "&#9;" })[c] ?? c,
-  );
-
-const head = (x: X) => `<${x.tag}${x.attrs.map(([k, v]) => ` ${k}="${escapeXml(v, true)}"`).join("")}`;
-
-const inline = (c: X | string): string =>
-  typeof c === "string" ? escapeXml(c, false) : c.children.length ? `${head(c)}>${c.children.map(inline).join("")}</${c.tag}>` : `${head(c)}/>`;
-
-const write = (x: X, indent: string, out: string[]) => {
-  if (x.children.length === 0 || x.children.some((c) => typeof c === "string")) {
-    out.push(`${indent}${inline(x)}`);
-  } else {
-    out.push(`${indent}${head(x)}>`);
-    for (const c of x.children) write(c as X, `${indent}  `, out);
-    out.push(`${indent}</${x.tag}>`);
-  }
-};
-
-export const toXml = async (video: unknown): Promise<string> => {
-  const top: Item[] = [];
-  await expand(video, top);
-  const root = top.find((i): i is Element => typeof i !== "string");
-  if (top.length !== 1 || !root || root.tag !== "mekuru") throw new Error("writeXml takes a video: one `<mekuru>` element");
-  const x: X = { tag: "mekuru", attrs: [], children: [] };
-  for (const [k, v] of Object.entries(root.props)) {
-    if (k !== "children" && k !== "key" && v !== undefined && v !== null) x.attrs.push([k, typeof v === "number" ? num(v) : String(v)]);
-  }
-  x.children.push(normalize({ tag: "seq", props: {}, children: root.children }));
-  const out: string[] = [];
-  write(x, "", out);
-  return `${out.join("\n")}\n`;
-};