@mekuru/cli 0.0.0-stage → 0.1.2

package/README.jp.md

@@ -0,0 +1,29 @@
+# @mekuru/cli
+
+[English](README.md)
+
+プレビューと動画書き出しのコマンドです。Bun 1.4 以上・ffmpeg・ffprobe・台本の文字に対応したフォントが必要です。
+
+```sh
+bun add -d @mekuru/cli
+bunx mekuru-server .mekuru/main.xml --run 'bun --hot src/main.tsx'
+bunx mekuru-compiler .mekuru/main.xml -o video.mp4
+```
+
+- `mekuru-server <xml>`: XML を監視してブラウザのビューアを起動。
+- `--run <cmd>`: XML を生成するコマンドを起動。
+- `--port`, `--title`: ポート（既定: 3333）とブラウザのタイトル。
+- `--no-open`, `--open`: ブラウザの自動起動。既定は開く。`MEKURU_OPEN=0` で抑止。
+- `mekuru-compiler <xml>`: ネイティブコンパイラで動画を書き出す。
+- `-o <file>`: 出力ファイル。
+- `--preview`: 半分の解像度・15 fps。
+- `--scale`, `--fps`: 解像度の倍率とフレームレート。
+- `--from`, `--to`: 書き出す範囲（秒）。
+- `--preset`, `--crf`: x264 のエンコード設定。
+- `--no-audio`: 音声なしで書き出す。
+
+両コマンドの `--root <dir>` で素材の基準フォルダを指定できます。既定は XML のあるフォルダ（`.mekuru/` ならその親）です。
+
+コンパイラは `MEKURU_COMPILER` → OS 別 npm パッケージ → 更新日時が新しい `target/debug`・`target/release` の順で探します（同時刻なら debug）。`@mekuru/cli/protocol` はサーバーとビューアの共有型です。
+
+[TSX の作業手順](../../docs/reference/Component.jp.md)・[開発](../../docs/dev/Developer.jp.md)

package/README.md

@@ -1,3 +1,29 @@
-# Temporary Holding Version
+# @mekuru/cli
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[日本語](README.jp.md)
+
+Preview and video export commands. Requires Bun 1.4+, ffmpeg, ffprobe, and fonts for the script.
+
+```sh
+bun add -d @mekuru/cli
+bunx mekuru-server .mekuru/main.xml --run 'bun --hot src/main.tsx'
+bunx mekuru-compiler .mekuru/main.xml -o video.mp4
+```
+
+- `mekuru-server <xml>`: Watch XML and open the browser viewer.
+- `--run <cmd>`: Run the command that generates XML.
+- `--port`, `--title`: Port (default: 3333) and browser title.
+- `--no-open`, `--open`: Control browser launch. Default: open, unless `MEKURU_OPEN=0`.
+- `mekuru-compiler <xml>`: Export video with the native compiler.
+- `-o <file>`: Output file.
+- `--preview`: Half resolution, 15 fps.
+- `--scale`, `--fps`: Resolution multiplier and frame rate.
+- `--from`, `--to`: Export range in seconds.
+- `--preset`, `--crf`: x264 encoding settings.
+- `--no-audio`: Export without audio.
+
+Both commands accept `--root <dir>` for the media base directory. Default: the XML directory, or its parent when named `.mekuru/`.
+
+Compiler lookup: `MEKURU_COMPILER` → platform npm package → newest local `target/debug` or `target/release` binary (debug wins ties). `@mekuru/cli/protocol` exports the server/viewer types.
+
+[TSX workflow](../../docs/reference/Component.md) · [Development](../../docs/dev/Developer.md).

package/package.json

@@ -1,6 +1,31 @@
 {
   "name": "@mekuru/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.2",
+  "description": "The commands of Mekuru Movie Maker: mekuru-server (the viewer in the browser, which can run the script with --run) and mekuru-compiler (XML → video, a prebuilt binary for each platform)",
+  "type": "module",
+  "bin": {
+    "mekuru-server": "./src/mekuru-server.ts",
+    "mekuru-compiler": "./src/mekuru-compiler.ts"
+  },
+  "files": [
+    "src",
+    "viewer"
+  ],
+  "engines": {
+    "bun": ">=1.4"
+  },
+  "dependencies": {
+    "commander": "^14.0.3"
+  },
+  "exports": {
+    "./protocol": "./src/protocol.ts",
+    "./*": "./*"
+  },
+  "optionalDependencies": {
+    "@mekuru/compiler-darwin-arm64": "0.1.2",
+    "@mekuru/compiler-darwin-x64": "0.1.2",
+    "@mekuru/compiler-linux-arm64": "0.1.2",
+    "@mekuru/compiler-linux-x64": "0.1.2",
+    "@mekuru/compiler-win32-x64": "0.1.2"
+  }
+}

package/src/compiler.ts

@@ -0,0 +1,39 @@
+import { existsSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+const EXE = process.platform === "win32" ? "mekuru-compiler.exe" : "mekuru-compiler";
+const PKG = `@mekuru/compiler-${process.platform}-${process.arch}`;
+const ENV = "MEKURU_COMPILER";
+
+const fromPlatformPackage = (): string | undefined => {
+  try {
+    const path = join(dirname(Bun.resolveSync(`${PKG}/package.json`, import.meta.dir)), "bin", EXE);
+    return existsSync(path) ? path : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+const fromRepository = (): string | undefined => {
+  const target = join(import.meta.dir, "..", "..", "..", "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 = (): string => {
+  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/src/mekuru-compiler.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env bun
+
+import { findCompiler } from "./compiler.ts";
+
+try {
+  const child = Bun.spawn([findCompiler(), ...Bun.argv.slice(2)], { stdin: "inherit", stdout: "inherit", stderr: "inherit" });
+  const stop = () => child.kill("SIGINT");
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+  process.exit(await child.exited);
+} catch (e) {
+  console.error(`error: ${(e as Error).message}`);
+  process.exit(1);
+}

package/src/mekuru-server.ts

@@ -0,0 +1,61 @@
+#!/usr/bin/env bun
+
+import { Command, InvalidArgumentError } from "commander";
+import { openBrowser, startServer } from "./server.ts";
+
+const VERSION: string = (await Bun.file(new URL("../package.json", import.meta.url)).json()).version;
+
+interface Options {
+  run?: string;
+  port: number;
+  root?: string;
+  title?: string;
+  open?: boolean;
+}
+
+const parsePort = (value: string): number => {
+  const port = Number(value);
+  if (!Number.isInteger(port) || port < 0 || port > 65535) throw new InvalidArgumentError("a port is an integer from 0 to 65535");
+  return port;
+};
+
+const openByDefault = (): boolean => !/^(0|false|no|off)$/i.test(process.env.MEKURU_OPEN ?? "");
+
+const serve = async (xml: string, { open = openByDefault(), ...opts }: Options): Promise<void> => {
+  const server = await startServer({ xml, ...opts }).catch((e: unknown) => {
+    console.error(`error: ${(e as Error).message}`);
+    process.exit(1);
+  });
+  process.stderr.write(`mekuru viewer: ${server.url}  (${opts.title ?? xml})\n`);
+  if (open) openBrowser(server.url);
+  const stop = () => {
+    server.close();
+    setTimeout(() => process.exit(0), 300).unref();
+  };
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+};
+
+new Command("mekuru-server")
+  .description(
+    "The viewer of Mekuru Movie Maker: shows the video of the XML that a script writes in the browser, as a preview and a timeline, " +
+      "and shows it again whenever the XML changes.",
+  )
+  .version(VERSION)
+  .argument("<xml>", "the XML that the script writes (such as .mekuru/main.xml)")
+  .option(
+    "--run <cmd>",
+    "a command that writes the XML (`bun --hot src/main.tsx`), run in the project folder while the viewer is open: " +
+      "what it prints on stderr is shown as the error of the script until it writes the XML again",
+  )
+  .option("-p, --port <port>", "the port to listen on", parsePort, 3333)
+  .option(
+    "--root <dir>",
+    "the project folder: the paths of the files are relative to it (default: the folder of the XML, or the one above it when that is .mekuru/)",
+  )
+  .option("--title <name>", "the name shown in the browser tab (default: the file name of the XML)")
+  .option("--open", "open a browser (the default, unless the environment variable MEKURU_OPEN is 0)")
+  .option("--no-open", "do not open a browser (in the terminal of VS Code, select the URL that it prints to open it in the integrated browser)")
+  .showHelpAfterError("(add --help for more information)")
+  .action(serve)
+  .parseAsync();

package/src/preview.ts

@@ -0,0 +1,46 @@
+import { findCompiler } from "./compiler.ts";
+import type { Compilation } from "./protocol.ts";
+
+export const previewCompiler = (root: string, publish: (version: number, result: Compilation | Error) => void) => {
+  let child: Bun.Subprocess | undefined;
+  let closed = false;
+  let pending: { xml: string; version: number } | undefined;
+  const next = async () => {
+    if (closed || child || !pending) return;
+    const { xml, version } = pending;
+    pending = undefined;
+    let result: Compilation | Error;
+    try {
+      const proc = Bun.spawn([findCompiler(), "-", "--emit-preview", "--root", root], {
+        stdin: new Blob([xml]),
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      child = proc;
+      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})`);
+      result = JSON.parse(stdout) as Compilation;
+      if (!Array.isArray(result.diagnostics) || !("preview" in result)) throw new Error("unexpected compiler response; rebuild or update mekuru-compiler");
+    } catch (e) {
+      result = e instanceof Error ? e : new Error(String(e));
+    } finally {
+      child = undefined;
+    }
+    if (closed) return;
+    if (!pending) publish(version, result);
+    void next();
+  };
+  return {
+    update(xml: string, version: number) {
+      if (!closed) {
+        pending = { xml, version };
+        void next();
+      }
+    },
+    close() {
+      closed = true;
+      pending = undefined;
+      child?.kill();
+    },
+  };
+};

package/src/protocol.ts

@@ -0,0 +1,87 @@
+export interface Diagnostic {
+  code: string;
+  severity: "error" | "warning";
+  line: number;
+  message: string;
+}
+export interface Compilation {
+  preview: PreviewDto | null;
+  diagnostics: Diagnostic[];
+}
+export interface StateDto {
+  path: string;
+  version: number;
+  previewVersion: number;
+  status: "building" | "ready" | "error";
+  error: string | null;
+  diagnostics: Diagnostic[];
+  preview: PreviewDto | null;
+}
+
+export interface PreviewDto {
+  width: number;
+  height: number;
+  fps: number;
+  duration: number;
+  elements: SceneElement[];
+  timeline: TimelineDto;
+}
+export type Bounds = [number, number, number, number];
+export type Fade = [start: number, end: number, fadeIn: number, fadeOut: number, level: number];
+export type DrawOp =
+  | {
+      kind: "path";
+      d: string;
+      color: string;
+      stroke: { width: number; lineCap: "butt" | "round" | "square"; lineJoin: "miter" | "round" | "bevel"; dash: number[] } | null;
+    }
+  | { kind: "image"; src: string; bounds: Bounds; transform: [number, number, number, number, number, number] | null };
+export interface MediaMap {
+  from: number;
+  end: number;
+  segments: [outStart: number, outEnd: number, srcStart: number, rate: number][];
+}
+export interface SceneElement {
+  id: number;
+  kind: "view" | "video" | "audio";
+  start: number;
+  end: number;
+  opacity: number;
+  fades: Fade[];
+  ops: DrawOp[];
+  bounds: Bounds | null;
+  media: { src: string; gain: number; map: MediaMap } | null;
+  repeat: [from: number, period: number, until: number][];
+  hidden: [start: number, end: number][];
+}
+
+export interface TimelineNode {
+  id: number;
+  parent: number | null;
+  depth: number;
+  kind: "seq" | "par" | "repeat";
+  tag: string;
+  label: string;
+  line: number;
+  start: number;
+  end: number;
+  pin: number | null;
+}
+
+export type ClipLane = "speech" | "visual" | "video" | "audio";
+
+export interface TimelineClip {
+  tag: string;
+  lane: ClipLane;
+  line: number;
+  start: number;
+  end: number;
+  label: string;
+  estimated: boolean;
+  freezes: [start: number, end: number][];
+}
+
+export interface TimelineDto {
+  nodes: TimelineNode[];
+  clips: TimelineClip[];
+}

package/src/server.ts

@@ -0,0 +1,281 @@
+import { existsSync, mkdirSync, unwatchFile, watch, watchFile } from "node:fs";
+import { basename, dirname, join, resolve, sep } from "node:path";
+import { previewCompiler } from "./preview.ts";
+import type { Diagnostic, StateDto } from "./protocol.ts";
+
+export interface ServerOptions {
+  xml: string;
+  root?: string;
+  run?: string;
+  port: number;
+  title?: string;
+}
+
+const projectRoot = (xml: string): string => {
+  const dir = dirname(resolve(xml));
+  return basename(dir) === ".mekuru" ? dirname(dir) : dir;
+};
+
+const VIEWER = join(import.meta.dir, "..", "viewer");
+
+const NOT_BUILT = `<!doctype html><meta charset=utf-8><title>Mekuru Movie Maker</title><body style="font-family:sans-serif;padding:2em"><h1>Mekuru Movie Maker</h1><p>The viewer is not built.</p><pre>bun install\nbun run --cwd pkgs/viewer build</pre>`;
+
+const log = (line: string) => process.stderr.write(`${new Date().toTimeString().slice(0, 8)} ${line}\n`);
+const seconds = (since: number) => `${((Date.now() - since) / 1000).toFixed(1)}s`;
+const formatDiagnostic = (d: Diagnostic) => `L${d.line} ${d.code}: ${d.message}`;
+
+const sendFile = async (req: Request, path: string): Promise<Response> => {
+  const file = Bun.file(path);
+  if (!(await file.exists())) return new Response(null, { status: 404 });
+  const size = file.size;
+  const headers = { "content-type": file.type, "accept-ranges": "bytes", "cache-control": "no-cache" };
+  const range = /^bytes=(\d*)-(\d*)$/.exec(req.headers.get("range") ?? "");
+  if (range && (range[1] || range[2])) {
+    const start = Math.max(0, range[1] ? Number(range[1]) : size - Number(range[2]));
+    const end = Math.min(size - 1, range[1] && range[2] ? Number(range[2]) : size - 1);
+    if (start > end) return new Response(null, { status: 416, headers: { "content-range": `bytes */${size}` } });
+    return new Response(req.method === "HEAD" ? null : file.slice(start, end + 1), {
+      status: 206,
+      headers: { ...headers, "content-range": `bytes ${start}-${end}/${size}`, "content-length": String(end - start + 1) },
+    });
+  }
+  return new Response(req.method === "HEAD" ? null : file, { headers: { ...headers, "content-length": String(size) } });
+};
+
+const inside = (dir: string, rel: string): string | undefined => {
+  let decoded: string;
+  try {
+    decoded = decodeURIComponent(rel);
+  } catch {
+    return undefined;
+  }
+  const path = resolve(dir, `.${sep}${decoded}`);
+  return path === dir || path.startsWith(dir + sep) ? path : undefined;
+};
+
+export const openBrowser = (url: string): void => {
+  const wsl = process.platform === "linux" && (!!process.env.WSL_INTEROP || existsSync("/proc/sys/fs/binfmt_misc/WSLInterop"));
+  const tries: string[][] = wsl
+    ? [["wslview"], ["cmd.exe", "/c", "start", ""]]
+    : process.platform === "darwin"
+      ? [["open"]]
+      : process.platform === "win32"
+        ? [["cmd", "/c", "start", ""]]
+        : [["xdg-open"]];
+  for (const [cmd, ...args] of tries) {
+    try {
+      Bun.spawn([cmd, ...args, url], { stdin: "ignore", stdout: "ignore", stderr: "ignore", cwd: wsl ? "/mnt/c" : undefined }).unref();
+      break;
+    } catch {}
+  }
+};
+
+export interface Server {
+  url: string;
+  close(): void;
+}
+
+export const startServer = async (opts: ServerOptions): Promise<Server> => {
+  const xmlPath = resolve(opts.xml);
+  const root = resolve(opts.root ?? projectRoot(xmlPath));
+  const title = opts.title ?? opts.xml;
+
+  let xml: string;
+  if (await Bun.file(xmlPath).exists()) xml = await Bun.file(xmlPath).text();
+  else if (opts.run) {
+    mkdirSync(dirname(xmlPath), { recursive: true });
+    xml = "<mekuru><seq/></mekuru>";
+  } else throw new Error(`cannot read ${opts.xml}`);
+  let closed = false;
+  const cleanup: (() => void)[] = [];
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    for (const dispose of cleanup.reverse()) dispose();
+  };
+  let writes = 0;
+  let scriptError: string | null = null;
+  let compileError: string | null = null;
+  let current: StateDto = { path: title, version: 1, previewVersion: 0, status: "building", error: null, diagnostics: [], preview: null };
+  const clients = new Set<ReadableStreamDefaultController<Uint8Array>>();
+  const encoder = new TextEncoder();
+  const send = (client: ReadableStreamDefaultController<Uint8Array>) => client.enqueue(encoder.encode(`event: state\ndata: ${JSON.stringify(current)}\n\n`));
+  const emit = () => {
+    if (closed) return;
+    current = { ...current, error: scriptError ?? compileError };
+    clients.forEach(send);
+  };
+  let started = Date.now();
+  const compiler = previewCompiler(root, (version, result) => {
+    if (closed || version !== current.version) return;
+    if (result instanceof Error) {
+      compileError = result.message;
+      current = { ...current, status: "error", diagnostics: [] };
+      log(`error: the preview failed\n${result.message}`);
+    } else {
+      compileError = result.preview ? null : result.diagnostics.map(formatDiagnostic).join("\n");
+      current = {
+        ...current,
+        status: result.preview ? "ready" : "error",
+        diagnostics: result.diagnostics,
+        preview: result.preview ?? current.preview,
+        previewVersion: result.preview ? version : current.previewVersion,
+      };
+      const warnings = result.diagnostics.filter((d) => d.severity === "warning").length;
+      const head = result.preview
+        ? `preview updated in ${seconds(started)}${warnings ? ` (${warnings} warning${warnings > 1 ? "s" : ""})` : ""}`
+        : "error: the preview failed";
+      log([head, ...result.diagnostics.map((d) => `  ${formatDiagnostic(d)}`)].join("\n"));
+    }
+    emit();
+  });
+
+  cleanup.push(() => compiler.close());
+
+  let server: ReturnType<typeof Bun.serve>;
+  try {
+    server = Bun.serve({
+      hostname: "127.0.0.1",
+      port: opts.port,
+      idleTimeout: 0,
+      async fetch(req) {
+        const path = new URL(req.url).pathname;
+        if (path === "/api/state") return Response.json(current, { headers: { "cache-control": "no-store" } });
+        if (path === "/api/events") {
+          let client: ReadableStreamDefaultController<Uint8Array>;
+          const stream = new ReadableStream<Uint8Array>({
+            start(controller) {
+              client = controller;
+              clients.add(client);
+              send(client);
+            },
+            cancel() {
+              clients.delete(client);
+            },
+          });
+          return new Response(stream, { headers: { "content-type": "text/event-stream", "cache-control": "no-store", connection: "keep-alive" } });
+        }
+        if (path.startsWith("/files/")) {
+          const file = inside(root, path.slice("/files/".length));
+          return file ? sendFile(req, file) : new Response(null, { status: 404 });
+        }
+        if (path.startsWith("/api/")) return new Response(null, { status: 404 });
+        const index = join(VIEWER, "index.html");
+        if (!(await Bun.file(index).exists())) return new Response(NOT_BUILT, { headers: { "content-type": "text/html; charset=utf-8" } });
+        const file = inside(VIEWER, path === "/" ? "index.html" : path.slice(1));
+        return sendFile(req, file && (await Bun.file(file).exists()) ? file : index);
+      },
+    });
+  } catch (e) {
+    close();
+    if ((e as { code?: string }).code === "EADDRINUSE") throw new Error(`cannot listen on 127.0.0.1:${opts.port} (is the port in use? try --port)`);
+    throw e;
+  }
+  cleanup.push(() => {
+    for (const client of clients) client.close();
+    clients.clear();
+    void server.stop(true);
+  });
+  const url = `http://localhost:${server.port}`;
+  const keepAlive = setInterval(() => {
+    for (const c of clients) c.enqueue(encoder.encode(": keep-alive\n\n"));
+  }, 15_000);
+  cleanup.push(() => clearInterval(keepAlive));
+
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  cleanup.push(() => clearTimeout(timer));
+  let readVersion = 0;
+  const changed = () => {
+    const version = ++readVersion;
+    clearTimeout(timer);
+    timer = setTimeout(async () => {
+      let text: string;
+      try {
+        text = await Bun.file(xmlPath).text();
+        if (closed || version !== readVersion) return;
+      } catch {
+        return;
+      }
+      writes++;
+      scriptError = null;
+      if (text === xml) {
+        log("the XML has not changed");
+        emit();
+        return;
+      }
+      xml = text;
+      compileError = null;
+      started = Date.now();
+      current = { ...current, version: current.version + 1, status: "building", diagnostics: [] };
+      emit();
+      compiler.update(xml, current.version);
+    }, 100);
+  };
+  try {
+    if (xmlPath.startsWith("/mnt/")) {
+      watchFile(xmlPath, { interval: 500 }, changed);
+      cleanup.push(() => unwatchFile(xmlPath, changed));
+    } else {
+      const watcher = watch(dirname(xmlPath), (_event, name) => {
+        if (name === null || name.toString() === basename(xmlPath)) changed();
+      });
+      cleanup.push(() => watcher.close());
+    }
+  } catch (e) {
+    close();
+    throw e;
+  }
+
+  let child: Bun.Subprocess | undefined;
+  let pause: ReturnType<typeof setTimeout> | undefined;
+  cleanup.push(() => {
+    clearTimeout(pause);
+    child?.kill("SIGTERM");
+  });
+  if (opts.run) {
+    const [shell, args] = process.platform === "win32" ? ["cmd", ["/C", opts.run]] : ["sh", ["-c", opts.run]];
+    const env = { ...process.env, BUN_CONFIG_NO_CLEAR_TERMINAL_ON_RELOAD: process.env.BUN_CONFIG_NO_CLEAR_TERMINAL_ON_RELOAD ?? "1" };
+    try {
+      const proc = Bun.spawn([shell, ...args], {
+        cwd: root,
+        env,
+        stdin: "ignore",
+        stdout: "inherit",
+        stderr: "pipe",
+        onExit(_proc, code, signal) {
+          if (!closed) console.error(`\`${opts.run}\` exited (${signal ?? code})`);
+        },
+      });
+      child = proc;
+      void (async () => {
+        let text = "";
+        let since = writes;
+        const decoder = new TextDecoder();
+        for await (const chunk of proc.stderr) {
+          process.stderr.write(chunk);
+          if (writes !== since) {
+            text = "";
+            since = writes;
+          }
+          text += Bun.stripANSI(decoder.decode(chunk, { stream: true }));
+          clearTimeout(pause);
+          pause = setTimeout(() => {
+            if (!closed && writes === since && text.trim()) {
+              scriptError = text;
+              emit();
+            }
+          }, 150);
+        }
+      })().catch((e: unknown) => {
+        scriptError = String(e);
+        emit();
+      });
+    } catch (e) {
+      scriptError = (e as Error).message;
+      emit();
+    }
+  }
+
+  compiler.update(xml, current.version);
+  return { url, close };
+};