@sequio/cli 0.1.0 → 0.1.2

package/dist/args.d.ts

@@ -27,6 +27,21 @@ export interface PreviewCommand {
     /** Bind to `0.0.0.0` (expose on the network) instead of localhost. */
     host: boolean;
 }
+/** Audio-only container formats `sequio audio` can write. */
+export declare const AUDIO_FORMATS: readonly ["m4a", "mp3", "wav", "ogg", "webm"];
+export type AudioFormat = (typeof AUDIO_FORMATS)[number];
+/** `sequio audio <file> [-o out.m4a] [--format m4a] [--bitrate N]`. */
+export interface AudioCommand {
+    kind: 'audio';
+    /** Path to the entry composition file. */
+    file: string;
+    /** Output audio path. `undefined` → `out.<format>`. */
+    out?: string;
+    /** Audio container format. `undefined` → inferred from `out`'s extension, else `mp3`. */
+    format?: AudioFormat;
+    /** Target audio bitrate, bits/sec. `undefined` → the engine default (128 kbps). */
+    bitrate?: number;
+}
 /** `sequio frame <file> [-t sec] [-o out.png] [--scale N]`. */
 export interface FrameCommand {
     kind: 'frame';
@@ -39,15 +54,23 @@ export interface FrameCommand {
     /** Output resolution multiplier (N× the composition size). @default 1 */
     scale: number;
 }
+/** `sequio check <file> [--json]`. */
+export interface CheckCommand {
+    kind: 'check';
+    /** Path to the entry composition file. */
+    file: string;
+    /** Emit machine-readable `Diagnostic[]` JSON instead of human-readable lines. */
+    json: boolean;
+}
 /** Show usage / version / a parse error and exit. */
 export interface MetaCommand {
     kind: 'help' | 'version' | 'error';
     /** For `error`: the message to print (before usage) and exit non-zero. */
     message?: string;
 }
-export type CliCommand = RenderCommand | PreviewCommand | FrameCommand | MetaCommand;
+export type CliCommand = RenderCommand | PreviewCommand | FrameCommand | AudioCommand | CheckCommand | MetaCommand;
 export declare const DEFAULT_PREVIEW_PORT = 6180;
-export declare const USAGE = "sequio \u2014 programmable-timeline CLI\n\nUsage:\n  sequio render <file> [options]     Encode a composition to a video file\n  sequio frame <file> [options]      Export a single frame at a time as a PNG\n  sequio preview <file> [options]    Serve a live in-browser preview\n\nRender options (pure Node, PixiJS WebGPU \u2014 needs a GPU or Mesa lavapipe):\n  -o, --out <path>     Output path (default: out.mp4)\n  -s, --scale <n>      Render at n\u00D7 the composition resolution (default: 1)\n      --verify         Assert a valid video container came out\n\nFrame options (pure Node, PixiJS WebGPU \u2014 needs a GPU or Mesa lavapipe):\n  -t, --time <sec>     Timeline time to sample, in seconds (default: 0)\n  -o, --out <path>     Output PNG path (default: frame.png)\n  -s, --scale <n>      Render at n\u00D7 the composition resolution (default: 1)\n\nPreview options:\n  -w, --watch          Re-run on any project-file change (live reload)\n  -p, --port <n>       Dev-server port (default: 6180)\n      --host           Expose the server on the local network (0.0.0.0)\n\nGlobal:\n  -h, --help           Show this help\n  -v, --version        Print the version\n\n<file> is a TS/JS module whose default export is a\ndefineComposition(builder) (or a bare builder). Its sibling files are\nbundled with it, so relative imports (./scene, ./title) resolve.";
+export declare const USAGE: string;
 /** Parse `process.argv.slice(2)` into a {@link CliCommand}. Never throws. */
 export declare function parseArgs(argv: string[]): CliCommand;
 //# sourceMappingURL=args.d.ts.map

package/dist/audio.d.ts

@@ -0,0 +1,15 @@
+import { AudioFormat } from './args';
+export interface AudioOptions {
+    /** Output audio path. `undefined` → `out.<format>`. */
+    out?: string;
+    /** Audio container format. `undefined` → inferred from `out`'s extension, else `mp3`. */
+    format?: AudioFormat;
+    /** Target audio bitrate, bits/sec. `undefined` → the engine default (128 kbps). */
+    bitrate?: number;
+}
+/**
+ * Export the audio of `entryFile` to a file, returning the process exit code
+ * (0 = success).
+ */
+export declare function runAudio(entryFile: string, options?: AudioOptions): Promise<number>;
+//# sourceMappingURL=audio.d.ts.map

package/dist/check.d.ts

@@ -0,0 +1,46 @@
+import { Renderer } from '@sequio/engine';
+import { Externals, RuntimeBundle } from '@sequio/runtime';
+/** A single validation finding. */
+export interface Diagnostic {
+    /** `error` fails the check (non-zero exit); `warn` is advisory. */
+    severity: 'error' | 'warn';
+    /** Stable code (`A1`…`C9`) identifying the check that fired. */
+    code: string;
+    /** Human-readable explanation. */
+    message: string;
+    /** Where in the object graph it was found (e.g. `track 0 · clip 2 (TextClip)`). */
+    at?: string;
+}
+export interface CheckBundleOptions {
+    /** Extra bare modules the composition may import (e.g. `{ gsap }`). */
+    externals?: Externals;
+    /**
+     * Existence predicate for `loadAsset('./x.mp4')` paths (normalized,
+     * root-relative). Returns `false` → a C7 "asset not found" diagnostic. Omit to
+     * skip asset-existence checking (in-memory tests have no disk).
+     */
+    assetExists?: (path: string) => boolean;
+}
+/**
+ * A headless no-op {@link Renderer}: `init()` resolves without a GPU and nothing
+ * ever draws (check reconciles no frames). Injected via
+ * `CompositorOptions.createRenderer`, so `await compositor.init()` in a builder
+ * completes on a machine with no Vulkan at all.
+ */
+export declare function nullRenderer(): Promise<Renderer>;
+/**
+ * Validate a {@link RuntimeBundle} and return every {@link Diagnostic} found.
+ * Pure and GPU-free — the unit-testable core behind `runCheck`.
+ */
+export declare function checkBundle(bundle: RuntimeBundle, options?: CheckBundleOptions): Promise<Diagnostic[]>;
+export interface CheckOptions {
+    /** Emit machine-readable `Diagnostic[]` JSON instead of human lines. */
+    json?: boolean;
+}
+/**
+ * Statically check `entryFile` and return the process exit code (0 = no errors,
+ * 1 = at least one `error`). `warn`-only results still exit 0. Prints a
+ * human-readable summary, or a `Diagnostic[]` JSON array with `--json`.
+ */
+export declare function runCheck(entryFile: string, options?: CheckOptions): Promise<number>;
+//# sourceMappingURL=check.d.ts.map

package/dist/cli.js

@@ -1,34 +1,38 @@
-import { p as n, s as t, a as i, b as l, U as c, v as p } from "./version-B2TKvZen.js";
-async function u(s) {
-  const e = n(s);
+import { p as c, s as n, a as i, d as l, e as u, b as f, U as t, v as p } from "./version-C7OkFI_V.js";
+async function m(r) {
+  const e = c(r);
   switch (e.kind) {
     case "help":
-      return console.log(c), 0;
+      return console.log(t), 0;
     case "version":
       return console.log(p), 0;
     case "error":
       return console.error(`✖ ${e.message}
-`), console.error(c), 2;
+`), console.error(t), 2;
+    case "check":
+      return f(e.file, { json: e.json });
     case "render":
-      return l(e.file, { out: e.out, scale: e.scale, verify: e.verify });
+      return u(e.file, { out: e.out, scale: e.scale, verify: e.verify });
     case "frame":
-      return i(e.file, { out: e.out, time: e.time, scale: e.scale });
+      return l(e.file, { out: e.out, time: e.time, scale: e.scale });
+    case "audio":
+      return i(e.file, { out: e.out, format: e.format, bitrate: e.bitrate });
     case "preview": {
-      const r = await t(e.file, {
+      const s = await n(e.file, {
         port: e.port,
         host: e.host,
         watch: e.watch
       });
-      return console.log(`▸ sequio preview → ${r.url}`), console.log(`  serving ${e.file}${e.watch ? " (watching for changes)" : ""}`), console.log("  press Ctrl-C to stop."), await new Promise((a) => {
+      return console.log(`▸ sequio preview → ${s.url}`), console.log(`  serving ${e.file}${e.watch ? " (watching for changes)" : ""}`), console.log("  press Ctrl-C to stop."), await new Promise((a) => {
         const o = () => {
-          r.close().finally(() => a());
+          s.close().finally(() => a());
         };
         process.once("SIGINT", o), process.once("SIGTERM", o);
       }), 0;
     }
   }
 }
-u(process.argv.slice(2)).then((s) => process.exit(s)).catch((s) => {
-  console.error("✖", s instanceof Error ? s.message : s), process.exit(1);
+m(process.argv.slice(2)).then((r) => process.exit(r)).catch((r) => {
+  console.error("✖", r instanceof Error ? r.message : r), process.exit(1);
 });
 //# sourceMappingURL=cli.js.map

package/dist/index.d.ts

@@ -1,22 +1,29 @@
 /**
  * `@sequio/cli` — the `sequio` command line.
  *
- * Three commands, all thin front-ends over infrastructure the other packages
+ * Five commands, all thin front-ends over infrastructure the other packages
  * already own:
+ *  - `check <file>` → compile + link + build the object graph with a null
+ *    renderer and statically validate it — no GPU, no network (the fast
+ *    pre-flight in the `check → frame → render` loop).
  *  - `render <file>` → snapshot the composition into a {@link RuntimeBundle} and
  *    hand it to the server's Route B (pure Node, WebGPU) to encode a video.
  *  - `frame <file>` → the same Route B path, but seek to one time and write a
  *    single PNG — a fast visual check without a full render.
+ *  - `audio <file>` → the same Route B path, but export only the audio mix to an
+ *    audio-only file (m4a / mp3 / wav / ogg / webm).
  *  - `preview <file>` → boot a Vite dev server whose page runs the same
  *    `Runtime` → `Composer` → `preview()` path in-browser; `--watch` live-reloads.
  *
  * This barrel is the programmatic surface (used by tests and embedders); the
  * `sequio` binary is `bin/sequio.js`, which runs `src/cli.ts`.
  */
-export { parseArgs, USAGE, DEFAULT_PREVIEW_PORT, type CliCommand, type RenderCommand, type FrameCommand, type PreviewCommand, type MetaCommand, } from './args';
+export { parseArgs, USAGE, DEFAULT_PREVIEW_PORT, AUDIO_FORMATS, type AudioFormat, type CliCommand, type RenderCommand, type FrameCommand, type AudioCommand, type CheckCommand, type PreviewCommand, type MetaCommand, } from './args';
 export { readBundle } from './bundle';
+export { runCheck, checkBundle, nullRenderer, type Diagnostic, type CheckOptions, type CheckBundleOptions, } from './check';
 export { runRender, type RenderOptions } from './render';
 export { runFrame, type FrameOptions } from './frame';
+export { runAudio, type AudioOptions } from './audio';
 export { startPreviewServer, type PreviewServer, type PreviewServerOptions, } from './preview';
 export { version } from './version';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,12 +1,17 @@
-import { D as s, U as e, p as n, r as v, a as E, b as d, s as o, v as p } from "./version-B2TKvZen.js";
+import { A as a, D as s, U as n, c as u, n as d, p as A, r as R, a as c, b as l, d as o, e as v, s as E, v as U } from "./version-C7OkFI_V.js";
 export {
+  a as AUDIO_FORMATS,
   s as DEFAULT_PREVIEW_PORT,
-  e as USAGE,
-  n as parseArgs,
-  v as readBundle,
-  E as runFrame,
-  d as runRender,
-  o as startPreviewServer,
-  p as version
+  n as USAGE,
+  u as checkBundle,
+  d as nullRenderer,
+  A as parseArgs,
+  R as readBundle,
+  c as runAudio,
+  l as runCheck,
+  o as runFrame,
+  v as runRender,
+  E as startPreviewServer,
+  U as version
 };
 //# sourceMappingURL=index.js.map

package/dist/version-C7OkFI_V.js

@@ -0,0 +1,760 @@
+import { existsSync as $, readFileSync as A, statSync as R, createReadStream as U } from "node:fs";
+import { resolve as m, dirname as h, basename as P } from "node:path";
+import { Compositor as N, FontManager as B, fonts as I, VisualTrack as L, VisualClip as j, GroupClip as O, TextClip as b } from "@sequio/engine";
+import { Runtime as F, ModuleResolutionError as G, resolveAssetPath as _ } from "@sequio/runtime";
+import { cliExternals as w } from "./externals.js";
+import { fileURLToPath as D } from "node:url";
+import { NodeFileSystem as W } from "@sequio/runtime/node-fs";
+import { createRequire as q } from "node:module";
+const v = ["m4a", "mp3", "wav", "ogg", "webm"], x = 6180, be = `sequio — programmable-timeline CLI
+
+Usage:
+  sequio check <file> [options]      Statically validate a composition (no GPU, offline)
+  sequio render <file> [options]     Encode a composition to a video file
+  sequio frame <file> [options]      Export a single frame at a time as a PNG
+  sequio audio <file> [options]      Export just the audio track to an audio file
+  sequio preview <file> [options]    Serve a live in-browser preview
+
+Check options (no GPU, no network — the fast pre-flight before frame/render):
+      --json           Emit machine-readable Diagnostic[] JSON
+
+Render options (pure Node, PixiJS WebGPU — needs a GPU or Mesa lavapipe):
+  -o, --out <path>     Output path (default: out.mp4)
+  -s, --scale <n>      Render at n× the composition resolution (default: 1)
+      --verify         Assert a valid video container came out
+
+Frame options (pure Node, PixiJS WebGPU — needs a GPU or Mesa lavapipe):
+  -t, --time <sec>     Timeline time to sample, in seconds (default: 0)
+  -o, --out <path>     Output PNG path (default: frame.png)
+  -s, --scale <n>      Render at n× the composition resolution (default: 1)
+
+Audio options:
+  -o, --out <path>     Output path (default: out.<format>)
+  -f, --format <fmt>   Container: ${v.join(" | ")} (default: mp3, or inferred from --out)
+  -b, --bitrate <bps>  Target audio bitrate in bits/sec (default: 128000; ignored for wav)
+
+Preview options:
+  -w, --watch          Re-run on any project-file change (live reload)
+  -p, --port <n>       Dev-server port (default: ${x})
+      --host           Expose the server on the local network (0.0.0.0)
+
+Global:
+  -h, --help           Show this help
+  -v, --version        Print the version
+
+<file> is a TS/JS module whose default export is a
+defineComposition(builder) (or a bare builder). Its sibling files are
+bundled with it, so relative imports (./scene, ./title) resolve.`;
+function ke(e) {
+  if (e[0] === "--" && (e = e.slice(1)), e.length === 0) return { kind: "help" };
+  const t = e[0];
+  return t === "-h" || t === "--help" ? { kind: "help" } : t === "-v" || t === "--version" ? { kind: "version" } : t === "check" ? M(e.slice(1)) : t === "render" ? H(e.slice(1)) : t === "frame" ? z(e.slice(1)) : t === "audio" ? J(e.slice(1)) : t === "preview" ? V(e.slice(1)) : { kind: "error", message: `Unknown command: ${t}` };
+}
+function M(e) {
+  let t, n = !1;
+  for (let c = 0; c < e.length; c++) {
+    const i = e[c];
+    if (i === "-h" || i === "--help") return { kind: "help" };
+    if (i === "--json") n = !0;
+    else {
+      if (i.startsWith("-")) return { kind: "error", message: `Unknown option: ${i}` };
+      if (t === void 0) t = i;
+      else return { kind: "error", message: `Unexpected argument: ${i}` };
+    }
+  }
+  return t === void 0 ? { kind: "error", message: "check needs a <file>" } : { kind: "check", file: t, json: n };
+}
+function H(e) {
+  let t, n, c = 1, i = !1;
+  for (let o = 0; o < e.length; o++) {
+    const r = e[o];
+    if (r === "-h" || r === "--help") return { kind: "help" };
+    if (r === "-o" || r === "--out") {
+      if (n = e[++o], n === void 0) return { kind: "error", message: `${r} needs a path` };
+    } else if (r === "-s" || r === "--scale") {
+      const s = e[++o], a = Number(s);
+      if (!(a >= 1) || !Number.isFinite(a)) return { kind: "error", message: `${r} needs a number ≥ 1, got: ${s}` };
+      c = a;
+    } else if (r === "--verify") i = !0;
+    else {
+      if (r.startsWith("-")) return { kind: "error", message: `Unknown option: ${r}` };
+      if (t === void 0) t = r;
+      else return { kind: "error", message: `Unexpected argument: ${r}` };
+    }
+  }
+  return t === void 0 ? { kind: "error", message: "render needs a <file>" } : { kind: "render", file: t, out: n, scale: c, verify: i };
+}
+function z(e) {
+  let t, n, c = 0, i = 1;
+  for (let o = 0; o < e.length; o++) {
+    const r = e[o];
+    if (r === "-h" || r === "--help") return { kind: "help" };
+    if (r === "-o" || r === "--out") {
+      if (n = e[++o], n === void 0) return { kind: "error", message: `${r} needs a path` };
+    } else if (r === "-t" || r === "--time") {
+      const s = e[++o], a = Number(s);
+      if (!Number.isFinite(a) || a < 0) return { kind: "error", message: `${r} needs a number ≥ 0, got: ${s}` };
+      c = a;
+    } else if (r === "-s" || r === "--scale") {
+      const s = e[++o], a = Number(s);
+      if (!(a >= 1) || !Number.isFinite(a)) return { kind: "error", message: `${r} needs a number ≥ 1, got: ${s}` };
+      i = a;
+    } else {
+      if (r.startsWith("-")) return { kind: "error", message: `Unknown option: ${r}` };
+      if (t === void 0) t = r;
+      else return { kind: "error", message: `Unexpected argument: ${r}` };
+    }
+  }
+  return t === void 0 ? { kind: "error", message: "frame needs a <file>" } : { kind: "frame", file: t, time: c, out: n, scale: i };
+}
+function J(e) {
+  let t, n, c, i;
+  for (let o = 0; o < e.length; o++) {
+    const r = e[o];
+    if (r === "-h" || r === "--help") return { kind: "help" };
+    if (r === "-o" || r === "--out") {
+      if (n = e[++o], n === void 0) return { kind: "error", message: `${r} needs a path` };
+    } else if (r === "-f" || r === "--format") {
+      const s = e[++o];
+      if (!v.includes(s))
+        return { kind: "error", message: `${r} needs one of ${v.join(", ")}, got: ${s}` };
+      c = s;
+    } else if (r === "-b" || r === "--bitrate") {
+      const s = e[++o], a = Number(s);
+      if (!Number.isFinite(a) || a <= 0) return { kind: "error", message: `${r} needs a number > 0, got: ${s}` };
+      i = a;
+    } else {
+      if (r.startsWith("-")) return { kind: "error", message: `Unknown option: ${r}` };
+      if (t === void 0) t = r;
+      else return { kind: "error", message: `Unexpected argument: ${r}` };
+    }
+  }
+  return t === void 0 ? { kind: "error", message: "audio needs a <file>" } : { kind: "audio", file: t, out: n, format: c, bitrate: i };
+}
+function V(e) {
+  let t, n = !1, c = !1, i = x;
+  for (let o = 0; o < e.length; o++) {
+    const r = e[o];
+    if (r === "-h" || r === "--help") return { kind: "help" };
+    if (r === "-w" || r === "--watch") n = !0;
+    else if (r === "--host") c = !0;
+    else if (r === "-p" || r === "--port") {
+      const s = e[++o], a = Number(s);
+      if (!Number.isInteger(a) || a <= 0 || a > 65535)
+        return { kind: "error", message: `${r} needs a valid port, got: ${s}` };
+      i = a;
+    } else {
+      if (r.startsWith("-")) return { kind: "error", message: `Unknown option: ${r}` };
+      if (t === void 0) t = r;
+      else return { kind: "error", message: `Unexpected argument: ${r}` };
+    }
+  }
+  return t === void 0 ? { kind: "error", message: "preview needs a <file>" } : { kind: "preview", file: t, watch: n, port: i, host: c };
+}
+const K = /* @__PURE__ */ new Set([
+  // images
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "avif",
+  "bmp",
+  "ico",
+  // video
+  "mp4",
+  "webm",
+  "mov",
+  "mkv",
+  "avi",
+  "m4v",
+  // audio
+  "mp3",
+  "wav",
+  "m4a",
+  "aac",
+  "ogg",
+  "oga",
+  "flac",
+  "opus",
+  // fonts
+  "ttf",
+  "otf",
+  "woff",
+  "woff2"
+]);
+function C(e) {
+  const t = e.lastIndexOf(".");
+  return t < 0 ? "" : e.slice(t + 1).toLowerCase();
+}
+function X(e) {
+  return K.has(C(e));
+}
+function Y(e) {
+  return {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    avif: "image/avif",
+    bmp: "image/bmp",
+    ico: "image/x-icon",
+    mp4: "video/mp4",
+    webm: "video/webm",
+    mov: "video/quicktime",
+    mkv: "video/x-matroska",
+    avi: "video/x-msvideo",
+    m4v: "video/x-m4v",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    m4a: "audio/mp4",
+    aac: "audio/aac",
+    ogg: "audio/ogg",
+    oga: "audio/ogg",
+    flac: "audio/flac",
+    opus: "audio/opus",
+    ttf: "font/ttf",
+    otf: "font/otf",
+    woff: "font/woff",
+    woff2: "font/woff2"
+  }[C(e)] ?? "application/octet-stream";
+}
+function g(e) {
+  const t = m(e), n = h(t), c = "/" + P(t), i = new W(n), o = {};
+  for (const r of i.listFiles()) {
+    if (X(r)) continue;
+    const s = i.readFile(r);
+    s !== null && (o[r] = s);
+  }
+  if (o[c] === void 0)
+    throw new Error(`Entry file not found: ${e}`);
+  return { files: o, entry: c };
+}
+const Q = /* @__PURE__ */ new Set([
+  "sans-serif",
+  "serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "system-ui",
+  "ui-sans-serif",
+  "ui-serif",
+  "ui-monospace",
+  "ui-rounded",
+  "math",
+  "emoji",
+  "inherit",
+  "initial",
+  "unset"
+]);
+function Z() {
+  const e = () => {
+  };
+  return Promise.resolve({ render: e, resize: e, destroy: e });
+}
+function ee() {
+  const e = globalThis;
+  e.createImageBitmap ??= async () => ({ width: 1, height: 1, close() {
+  } });
+  class t {
+  }
+  class n {
+  }
+  class c {
+  }
+  e.CanvasRenderingContext2D ??= t, e.HTMLCanvasElement ??= n, e.HTMLImageElement ??= c;
+  const i = e.CanvasRenderingContext2D, o = e.HTMLCanvasElement, r = (a) => Object.assign(new i(), {
+    canvas: a,
+    font: "10px sans-serif",
+    textBaseline: "alphabetic",
+    fillStyle: "#000",
+    strokeStyle: "#000",
+    lineWidth: 1,
+    globalAlpha: 1,
+    // A monospace-ish advance is enough for split/layout math; check never paints.
+    measureText: (l) => {
+      const d = (l?.length ?? 0) * 8;
+      return {
+        width: d,
+        actualBoundingBoxAscent: 8,
+        actualBoundingBoxDescent: 2,
+        actualBoundingBoxLeft: 0,
+        actualBoundingBoxRight: d,
+        fontBoundingBoxAscent: 8,
+        fontBoundingBoxDescent: 2
+      };
+    },
+    getImageData: (l, d, f, u) => ({
+      data: new Uint8ClampedArray(Math.max(1, f) * Math.max(1, u) * 4),
+      width: f,
+      height: u
+    }),
+    createLinearGradient: () => ({ addColorStop() {
+    } }),
+    createPattern: () => null,
+    fillText() {
+    },
+    strokeText() {
+    },
+    clearRect() {
+    },
+    fillRect() {
+    },
+    save() {
+    },
+    restore() {
+    },
+    scale() {
+    },
+    translate() {
+    },
+    rotate() {
+    },
+    beginPath() {
+    },
+    closePath() {
+    },
+    moveTo() {
+    },
+    lineTo() {
+    },
+    arc() {
+    },
+    fill() {
+    },
+    stroke() {
+    },
+    putImageData() {
+    },
+    drawImage() {
+    },
+    setTransform() {
+    },
+    transform() {
+    },
+    rect() {
+    },
+    clip() {
+    }
+  }), s = () => {
+    const a = new o();
+    let l;
+    return Object.assign(a, {
+      width: 1,
+      height: 1,
+      style: {},
+      getContext: (d) => d === "2d" ? l ??= r(a) : null,
+      addEventListener() {
+      },
+      removeEventListener() {
+      },
+      toDataURL: () => "data:,"
+    });
+  };
+  e.document === void 0 && (e.document = {
+    createElement: (a) => a === "canvas" ? s() : { style: {}, appendChild() {
+    }, addEventListener() {
+    }, removeEventListener() {
+    } },
+    createElementNS: () => s(),
+    documentElement: { style: {} },
+    body: { appendChild() {
+    }, style: {} },
+    head: { appendChild() {
+    } },
+    addEventListener() {
+    },
+    removeEventListener() {
+    },
+    fonts: { add() {
+    }, load: async () => [], ready: Promise.resolve() }
+  }), e.OffscreenCanvas ??= class {
+    width;
+    height;
+    constructor(a, l) {
+      this.width = a ?? 1, this.height = l ?? 1;
+    }
+    getContext(a) {
+      return a === "2d" ? r(this) : null;
+    }
+  };
+}
+function te() {
+  const e = B.prototype;
+  e.loadFace = () => Promise.resolve(), e.loadGoogle = () => Promise.resolve();
+}
+function p(e) {
+  return typeof e == "number" && Number.isFinite(e);
+}
+const re = /createImageBitmap|source type for resource|ImageBitmap|VideoFrame|GPU|WebGL|texture|decode|fetch|ENOTFOUND|ECONNREFUSED|EAI_AGAIN|Forbidden|\b4\d\d\b|\b5\d\d\b|network/i;
+function k(e, t) {
+  const n = e instanceof Error ? e.message : String(e);
+  return e instanceof G ? !/^[./]/.test(e.specifier) ? {
+    severity: "error",
+    code: "A3",
+    message: `external module '${e.specifier}' is not injected — provide it via externals (the CLI ships gsap): ${n}`
+  } : { severity: "error", code: "A2", message: `relative import does not resolve: ${n}` } : /must export|defineComposition|builder function/i.test(n) ? { severity: "error", code: "A4", message: n } : /not implemented/i.test(n) ? {
+    severity: "error",
+    code: "B2",
+    message: `hit an unimplemented path (throws instead of rendering a black frame): ${n}`
+  } : t === "build" && re.test(n) ? {
+    severity: "warn",
+    code: "B4",
+    message: `builder needs a capability check runs without (media decode / network / GPU texture) — the code compiled and linked; verify the picture with \`sequio frame\`: ${n}`
+  } : t === "build" ? { severity: "error", code: "B1", message: `builder threw: ${n}` } : { severity: "error", code: "A1", message: n };
+}
+async function oe(e, t = {}) {
+  const n = [];
+  ee(), te();
+  const c = [], i = async (d) => (t.assetExists && !t.assetExists(d) && c.push(d), new Blob([new Uint8Array([0])])), o = new F({
+    files: e.files,
+    entry: e.entry,
+    externals: t.externals,
+    loadAsset: i
+  }), r = {
+    compositorOptions: { createRenderer: Z },
+    target: "server"
+  };
+  let s;
+  try {
+    s = o.link(r);
+  } catch (d) {
+    return n.push(k(d, "link")), n;
+  }
+  let a;
+  try {
+    a = await s.build(r);
+  } catch (d) {
+    return n.push(k(d, "build")), n;
+  }
+  if (!a || !(a.compositor instanceof N))
+    return n.push({
+      severity: "error",
+      code: "B1",
+      message: "builder did not return { compositor } (an initialized Compositor)"
+    }), n;
+  const l = a.compositor;
+  l.isInitialized || n.push({
+    severity: "error",
+    code: "B3",
+    message: "compositor was never initialized — add `await compositor.init()` in the builder"
+  });
+  for (const d of c)
+    n.push({ severity: "error", code: "C7", message: `local asset not found: ${d}` });
+  ne(l, a.duration, n);
+  try {
+    l.dispose();
+  } catch {
+  }
+  return n;
+}
+function ne(e, t, n) {
+  const c = new Set(I.families());
+  e.getTracks().forEach((o, r) => {
+    o.clips.forEach((s, a) => {
+      E(s, `track ${r} · clip ${a}`, t, c, n);
+    }), o instanceof L && o.transitions.forEach((s, a) => {
+      ie(s, o.clips, `track ${r} · transition ${a}`, n);
+    });
+  });
+}
+function E(e, t, n, c, i) {
+  const o = `${t} (${e.constructor.name})`;
+  !p(e.start) || !p(e.end) ? i.push({ severity: "error", code: "C1", message: "clip start/end is not a finite number", at: o }) : (e.start < 0 && i.push({ severity: "error", code: "C1", message: `clip start < 0 (${e.start})`, at: o }), e.end <= e.start && i.push({
+    severity: "error",
+    code: "C1",
+    message: `clip end ≤ start (start=${e.start}, end=${e.end})`,
+    at: o
+  }), n !== void 0 && p(n) && e.end > n && i.push({
+    severity: "error",
+    code: "C3",
+    message: `clip end (${e.end}) exceeds the declared duration (${n})`,
+    at: o
+  }), p(e.sourceIn) && p(e.sourceOut) && e.sourceOut > 0 && e.sourceOut < e.sourceIn && i.push({
+    severity: "warn",
+    code: "C9",
+    message: `sourceOut (${e.sourceOut}) is before sourceIn (${e.sourceIn})`,
+    at: o
+  })), e instanceof j && se(e, o, c, i), e instanceof O && e.children.forEach((r, s) => {
+    E(r, `${t} · child ${s}`, void 0, c, i);
+  });
+}
+function se(e, t, n, c) {
+  const i = e.start, o = e.end, r = p(i) && p(o) && o > i, s = [
+    { name: "position", times: e.transform.position.keyframeTimes },
+    { name: "scale", times: e.transform.scale.keyframeTimes },
+    { name: "rotation", times: e.transform.rotation.keyframeTimes },
+    { name: "anchor", times: e.transform.anchor.keyframeTimes },
+    { name: "opacity", times: e.opacity.keyframeTimes }
+  ];
+  if (e instanceof b && s.push({ name: "fontSize", times: e.fontSize.keyframeTimes }), r)
+    for (const { name: d, times: f } of s)
+      for (const u of f)
+        (u < i || u > o) && c.push({
+          severity: "error",
+          code: "C2",
+          message: `${d} keyframe at t=${u} falls outside the clip's [${i}, ${o}] — dead keyframe`,
+          at: t
+        });
+  const a = e.transform.anchor, l = a.keyframeTimes.length ? a.keyframeTimes : [r ? i : 0];
+  for (const d of l) {
+    const [f, u] = a.valueAt(d);
+    if (f < -1e-6 || f > 1 + 1e-6 || u < -1e-6 || u > 1 + 1e-6) {
+      c.push({
+        severity: "error",
+        code: "C8",
+        message: `anchor [${f}, ${u}] is outside 0..1 (anchor is normalized, not pixels)`,
+        at: t
+      });
+      break;
+    }
+  }
+  if (e instanceof b) {
+    const d = e.fontFamily.split(",").map((u) => u.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+    !d.some((u) => Q.has(u.toLowerCase()) || n.has(u)) && d.length > 0 && c.push({
+      severity: "warn",
+      code: "C4",
+      message: `font-family "${e.fontFamily}" is not registered via fonts.load(...) — will fall back to a system font (preview may differ from render)`,
+      at: t
+    });
+  }
+}
+function ie(e, t, n, c) {
+  const { from: i, to: o } = e;
+  if (!i || !o) {
+    c.push({ severity: "error", code: "C5", message: "transition is not bound to two clips (call .between(a, b))", at: n });
+    return;
+  }
+  if (!t.includes(i) || !t.includes(o)) {
+    c.push({
+      severity: "error",
+      code: "C5",
+      message: "transition binds clips that are not both on this track",
+      at: n
+    });
+    return;
+  }
+  e.windowAt() == null && c.push({
+    severity: "error",
+    code: "C5",
+    message: `transition clips do not overlap — the transition window is empty (overlap [${i.start}, ${i.end}] with [${o.start}, ${o.end}])`,
+    at: n
+  });
+}
+function ae(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+async function xe(e, t = {}) {
+  let n;
+  try {
+    const o = g(e), r = h(m(e));
+    n = await oe(o, {
+      externals: w(),
+      assetExists: (s) => $(m(r, s))
+    });
+  } catch (o) {
+    n = [{ severity: "error", code: "A0", message: ae(o) }];
+  }
+  const c = n.filter((o) => o.severity === "error"), i = n.filter((o) => o.severity === "warn");
+  if (t.json)
+    return console.log(JSON.stringify(n, null, 2)), c.length > 0 ? 1 : 0;
+  for (const o of n) {
+    const r = o.severity === "error" ? "✖" : "⚠", s = o.at ? ` [${o.at}]` : "";
+    console.error(`${r} ${o.code}${s}: ${o.message}`);
+  }
+  if (c.length === 0) {
+    const o = i.length ? ` (${i.length} warning${i.length === 1 ? "" : "s"})` : "";
+    return console.log(`✅ check passed: ${e}${o}`), 0;
+  }
+  return console.error(
+    `
+✖ check failed: ${c.length} error${c.length === 1 ? "" : "s"}${i.length ? `, ${i.length} warning${i.length === 1 ? "" : "s"}` : ""}.`
+  ), 1;
+}
+function y(e) {
+  const t = m(e);
+  return async (n) => {
+    const c = m(t, n);
+    if (c !== t && !c.startsWith(t + "/"))
+      throw new Error(`asset path escapes the project root: ${n}`);
+    let i;
+    try {
+      i = A(c);
+    } catch {
+      throw new Error(
+        `local asset not found: ${n} (looked in ${t}). Drop the file there, or reference a network URL instead.`
+      );
+    }
+    return new Blob([new Uint8Array(i)]);
+  };
+}
+function ce(e) {
+  return e.length >= 12 && Buffer.from(e.subarray(4, 8)).toString("latin1") === "ftyp" ? "mp4" : e.length >= 4 && e[0] === 26 && e[1] === 69 && e[2] === 223 && e[3] === 163 ? "webm" : null;
+}
+async function Ce(e, t = {}) {
+  const n = g(e), c = h(m(e)), { renderBundleToFile: i } = await import("@sequio/server/route-b");
+  try {
+    const o = t.out ?? "out.mp4";
+    console.log(`Rendering ${e} (pure Node, WebGPU)${t.scale && t.scale !== 1 ? ` @ ${t.scale}×` : ""} …`);
+    let r = -1;
+    const s = await i(n, {
+      out: o,
+      scale: t.scale,
+      // Make gsap (and any other CLI-provided lib) resolvable to the composition
+      // in the Node render, same as the browser preview does.
+      externals: w(),
+      // Resolve `loadAsset('./clip.mp4')` against the project directory on disk,
+      // so a local image/video renders the same as it previews (contract #3).
+      loadAsset: y(c),
+      onProgress: (a) => {
+        const l = Math.round(a * 100);
+        l !== r && l % 10 === 0 && (r = l, process.stdout.write(`\r  ${l}%`));
+      }
+    });
+    if (process.stdout.write("\r     \r"), console.log(
+      `✅ wrote ${s.out} (${s.frames} frames, ${s.container}/${s.videoCodec}, ${s.bytes} bytes${s.audio ? ", +audio" : ""})`
+    ), t.verify) {
+      const l = (await import("node:fs")).readFileSync(s.out), d = ce(l);
+      if (!d || l.length < 500)
+        throw new Error(`--verify failed: not a valid container (detected=${d}, size=${l.length})`);
+      console.log(`✅ verified: valid ${d} container.`);
+    }
+    return 0;
+  } catch (o) {
+    return console.error("✖", o instanceof Error ? o.message : String(o)), 1;
+  }
+}
+async function Ee(e, t = {}) {
+  const n = g(e), c = h(m(e)), { renderBundleFrameToFile: i } = await import("@sequio/server/route-b");
+  try {
+    const o = t.out ?? "frame.png", r = t.time ?? 0;
+    console.log(
+      `Rendering ${e} frame @ t=${r}s (pure Node, WebGPU)${t.scale && t.scale !== 1 ? ` @ ${t.scale}×` : ""} …`
+    );
+    const s = await i(n, {
+      out: o,
+      time: r,
+      scale: t.scale,
+      // Make gsap (and any other CLI-provided lib) resolvable to the composition
+      // in the Node render, same as the browser preview does.
+      externals: w(),
+      // Resolve `loadAsset('./clip.mp4')` against the project directory on disk,
+      // so a local image/video renders the same as it previews (contract #3).
+      loadAsset: y(c)
+    }), a = s.time !== r ? ` (clamped from ${r}s)` : "";
+    return console.log(
+      `✅ wrote ${s.out} (${s.width}×${s.height}, t=${s.time}s${a}, ${s.bytes} bytes)`
+    ), 0;
+  } catch (o) {
+    return console.error("✖", o instanceof Error ? o.message : String(o)), 1;
+  }
+}
+function le(e) {
+  const t = e?.toLowerCase().match(/\.([^./\\]+)$/), n = t?.[1] === "oga" ? "ogg" : t?.[1];
+  return v.includes(n) ? n : void 0;
+}
+async function Se(e, t = {}) {
+  const n = g(e), c = h(m(e)), i = t.format ?? le(t.out) ?? "mp3", { exportBundleAudioToFile: o } = await import("@sequio/server/route-b");
+  try {
+    const r = t.out ?? `out.${i}`;
+    console.log(`Exporting audio from ${e} (pure Node) → ${i} …`);
+    const s = await o(n, {
+      out: r,
+      format: i,
+      bitrate: t.bitrate,
+      // Make gsap (and any other CLI-provided lib) resolvable to the composition
+      // in the Node run, same as the browser preview does.
+      externals: w(),
+      // Resolve `loadAsset('./song.mp3')` against the project directory on disk,
+      // so a local audio source mixes the same as it previews (contract #3).
+      loadAsset: y(c)
+    });
+    return console.log(
+      `✅ wrote ${s.out} (${s.format}/${s.codec}, ${s.duration.toFixed(2)}s, ${s.bytes} bytes)`
+    ), 0;
+  } catch (r) {
+    return console.error("✖", r instanceof Error ? r.message : String(r)), 1;
+  }
+}
+const S = h(D(import.meta.url)), de = m(S, "../preview"), T = {};
+for (const [e, t] of [
+  ["@sequio/engine", "../../engine/src/index.ts"],
+  ["@sequio/runtime", "../../runtime/src/index.ts"],
+  ["@sequio/cli/externals", "./externals.ts"]
+]) {
+  const n = m(S, t);
+  $(n) && (T[e] = n);
+}
+async function Te(e, t = {}) {
+  const n = m(e), c = h(n);
+  g(n);
+  const { createServer: i } = await import("vite"), o = await i({
+    configFile: !1,
+    root: de,
+    logLevel: "warn",
+    server: {
+      port: t.port ?? 6180,
+      host: t.host ? !0 : "localhost",
+      strictPort: !0
+    },
+    resolve: {
+      alias: T
+    },
+    plugins: [
+      {
+        name: "sequio-preview-bundle",
+        configureServer(s) {
+          if (s.middlewares.use("/__bundle", (a, l) => {
+            try {
+              const d = g(n);
+              l.setHeader("Content-Type", "application/json"), l.setHeader("Cache-Control", "no-store"), l.end(JSON.stringify(d));
+            } catch (d) {
+              l.statusCode = 500, l.setHeader("Content-Type", "application/json"), l.end(JSON.stringify({ error: d instanceof Error ? d.message : String(d) }));
+            }
+          }), s.middlewares.use("/__asset", (a, l) => {
+            try {
+              const d = (a.url ?? "").split("?")[0], f = _(decodeURIComponent(d)), u = m(c, f);
+              if (u !== c && !u.startsWith(c + "/"))
+                return l.statusCode = 403, l.end("forbidden");
+              if (!$(u) || !R(u).isFile())
+                return l.statusCode = 404, l.end(`asset not found: ${f}`);
+              l.setHeader("Content-Type", Y(f)), l.setHeader("Cache-Control", "no-store"), U(u).pipe(l);
+            } catch (d) {
+              l.statusCode = 400, l.end(d instanceof Error ? d.message : String(d));
+            }
+          }), t.watch) {
+            s.watcher.add(c);
+            const a = (l) => {
+              m(l).startsWith(c) && s.ws.send({ type: "full-reload", path: "*" });
+            };
+            s.watcher.on("change", a), s.watcher.on("add", a), s.watcher.on("unlink", a);
+          }
+        }
+      }
+    ]
+  });
+  return await o.listen(), {
+    url: o.resolvedUrls?.local[0] ?? `http://localhost:${t.port ?? 6180}/`,
+    async close() {
+      await o.close();
+    }
+  };
+}
+const ue = q(import.meta.url), fe = ue("../package.json"), Ae = fe.version;
+export {
+  v as A,
+  x as D,
+  be as U,
+  Se as a,
+  xe as b,
+  oe as c,
+  Ee as d,
+  Ce as e,
+  Z as n,
+  ke as p,
+  g as r,
+  Te as s,
+  Ae as v
+};
+//# sourceMappingURL=version-C7OkFI_V.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sequio/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "The sequio command-line: `sequio render <file>` encodes a composition to video (pure Node, PixiJS WebGPU), `sequio frame <file>` writes a single-frame PNG, and `sequio preview <file>` serves a live in-browser preview (with --watch).",
   "type": "module",
   "license": "MIT",
@@ -52,9 +52,9 @@
   "dependencies": {
     "gsap": "^3.12.0",
     "vite": "^6.0.0",
-    "@sequio/engine": "^0.1.1",
-    "@sequio/server": "^0.1.0",
-    "@sequio/runtime": "^0.1.0"
+    "@sequio/engine": "^0.1.2",
+    "@sequio/server": "^0.1.2",
+    "@sequio/runtime": "^0.1.2"
   },
   "scripts": {
     "dev": "tsx src/cli.ts",

package/dist/version-B2TKvZen.js

@@ -1,338 +0,0 @@
-import { resolve as f, dirname as m, basename as S } from "node:path";
-import { cliExternals as h } from "./externals.js";
-import { readFileSync as E, existsSync as w, statSync as P, createReadStream as x } from "node:fs";
-import { fileURLToPath as U } from "node:url";
-import { resolveAssetPath as R } from "@sequio/runtime";
-import { NodeFileSystem as N } from "@sequio/runtime/node-fs";
-import { createRequire as C } from "node:module";
-const v = 6180, z = `sequio — programmable-timeline CLI
-
-Usage:
-  sequio render <file> [options]     Encode a composition to a video file
-  sequio frame <file> [options]      Export a single frame at a time as a PNG
-  sequio preview <file> [options]    Serve a live in-browser preview
-
-Render options (pure Node, PixiJS WebGPU — needs a GPU or Mesa lavapipe):
-  -o, --out <path>     Output path (default: out.mp4)
-  -s, --scale <n>      Render at n× the composition resolution (default: 1)
-      --verify         Assert a valid video container came out
-
-Frame options (pure Node, PixiJS WebGPU — needs a GPU or Mesa lavapipe):
-  -t, --time <sec>     Timeline time to sample, in seconds (default: 0)
-  -o, --out <path>     Output PNG path (default: frame.png)
-  -s, --scale <n>      Render at n× the composition resolution (default: 1)
-
-Preview options:
-  -w, --watch          Re-run on any project-file change (live reload)
-  -p, --port <n>       Dev-server port (default: ${v})
-      --host           Expose the server on the local network (0.0.0.0)
-
-Global:
-  -h, --help           Show this help
-  -v, --version        Print the version
-
-<file> is a TS/JS module whose default export is a
-defineComposition(builder) (or a bare builder). Its sibling files are
-bundled with it, so relative imports (./scene, ./title) resolve.`;
-function X(t) {
-  if (t[0] === "--" && (t = t.slice(1)), t.length === 0) return { kind: "help" };
-  const e = t[0];
-  return e === "-h" || e === "--help" ? { kind: "help" } : e === "-v" || e === "--version" ? { kind: "version" } : e === "render" ? j(t.slice(1)) : e === "frame" ? A(t.slice(1)) : e === "preview" ? F(t.slice(1)) : { kind: "error", message: `Unknown command: ${e}` };
-}
-function j(t) {
-  let e, i, l = 1, c = !1;
-  for (let o = 0; o < t.length; o++) {
-    const r = t[o];
-    if (r === "-h" || r === "--help") return { kind: "help" };
-    if (r === "-o" || r === "--out") {
-      if (i = t[++o], i === void 0) return { kind: "error", message: `${r} needs a path` };
-    } else if (r === "-s" || r === "--scale") {
-      const n = t[++o], s = Number(n);
-      if (!(s >= 1) || !Number.isFinite(s)) return { kind: "error", message: `${r} needs a number ≥ 1, got: ${n}` };
-      l = s;
-    } else if (r === "--verify") c = !0;
-    else {
-      if (r.startsWith("-")) return { kind: "error", message: `Unknown option: ${r}` };
-      if (e === void 0) e = r;
-      else return { kind: "error", message: `Unexpected argument: ${r}` };
-    }
-  }
-  return e === void 0 ? { kind: "error", message: "render needs a <file>" } : { kind: "render", file: e, out: i, scale: l, verify: c };
-}
-function A(t) {
-  let e, i, l = 0, c = 1;
-  for (let o = 0; o < t.length; o++) {
-    const r = t[o];
-    if (r === "-h" || r === "--help") return { kind: "help" };
-    if (r === "-o" || r === "--out") {
-      if (i = t[++o], i === void 0) return { kind: "error", message: `${r} needs a path` };
-    } else if (r === "-t" || r === "--time") {
-      const n = t[++o], s = Number(n);
-      if (!Number.isFinite(s) || s < 0) return { kind: "error", message: `${r} needs a number ≥ 0, got: ${n}` };
-      l = s;
-    } else if (r === "-s" || r === "--scale") {
-      const n = t[++o], s = Number(n);
-      if (!(s >= 1) || !Number.isFinite(s)) return { kind: "error", message: `${r} needs a number ≥ 1, got: ${n}` };
-      c = s;
-    } else {
-      if (r.startsWith("-")) return { kind: "error", message: `Unknown option: ${r}` };
-      if (e === void 0) e = r;
-      else return { kind: "error", message: `Unexpected argument: ${r}` };
-    }
-  }
-  return e === void 0 ? { kind: "error", message: "frame needs a <file>" } : { kind: "frame", file: e, time: l, out: i, scale: c };
-}
-function F(t) {
-  let e, i = !1, l = !1, c = v;
-  for (let o = 0; o < t.length; o++) {
-    const r = t[o];
-    if (r === "-h" || r === "--help") return { kind: "help" };
-    if (r === "-w" || r === "--watch") i = !0;
-    else if (r === "--host") l = !0;
-    else if (r === "-p" || r === "--port") {
-      const n = t[++o], s = Number(n);
-      if (!Number.isInteger(s) || s <= 0 || s > 65535)
-        return { kind: "error", message: `${r} needs a valid port, got: ${n}` };
-      c = s;
-    } else {
-      if (r.startsWith("-")) return { kind: "error", message: `Unknown option: ${r}` };
-      if (e === void 0) e = r;
-      else return { kind: "error", message: `Unexpected argument: ${r}` };
-    }
-  }
-  return e === void 0 ? { kind: "error", message: "preview needs a <file>" } : { kind: "preview", file: e, watch: i, port: c, host: l };
-}
-const T = /* @__PURE__ */ new Set([
-  // images
-  "png",
-  "jpg",
-  "jpeg",
-  "gif",
-  "webp",
-  "avif",
-  "bmp",
-  "ico",
-  // video
-  "mp4",
-  "webm",
-  "mov",
-  "mkv",
-  "avi",
-  "m4v",
-  // audio
-  "mp3",
-  "wav",
-  "m4a",
-  "aac",
-  "ogg",
-  "oga",
-  "flac",
-  "opus",
-  // fonts
-  "ttf",
-  "otf",
-  "woff",
-  "woff2"
-]);
-function $(t) {
-  const e = t.lastIndexOf(".");
-  return e < 0 ? "" : t.slice(e + 1).toLowerCase();
-}
-function q(t) {
-  return T.has($(t));
-}
-function W(t) {
-  return {
-    png: "image/png",
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    gif: "image/gif",
-    webp: "image/webp",
-    avif: "image/avif",
-    bmp: "image/bmp",
-    ico: "image/x-icon",
-    mp4: "video/mp4",
-    webm: "video/webm",
-    mov: "video/quicktime",
-    mkv: "video/x-matroska",
-    avi: "video/x-msvideo",
-    m4v: "video/x-m4v",
-    mp3: "audio/mpeg",
-    wav: "audio/wav",
-    m4a: "audio/mp4",
-    aac: "audio/aac",
-    ogg: "audio/ogg",
-    oga: "audio/ogg",
-    flac: "audio/flac",
-    opus: "audio/opus",
-    ttf: "font/ttf",
-    otf: "font/otf",
-    woff: "font/woff",
-    woff2: "font/woff2"
-  }[$(t)] ?? "application/octet-stream";
-}
-function p(t) {
-  const e = f(t), i = m(e), l = "/" + S(e), c = new N(i), o = {};
-  for (const r of c.listFiles()) {
-    if (q(r)) continue;
-    const n = c.readFile(r);
-    n !== null && (o[r] = n);
-  }
-  if (o[l] === void 0)
-    throw new Error(`Entry file not found: ${t}`);
-  return { files: o, entry: l };
-}
-function b(t) {
-  const e = f(t);
-  return async (i) => {
-    const l = f(e, i);
-    if (l !== e && !l.startsWith(e + "/"))
-      throw new Error(`asset path escapes the project root: ${i}`);
-    let c;
-    try {
-      c = E(l);
-    } catch {
-      throw new Error(
-        `local asset not found: ${i} (looked in ${e}). Drop the file there, or reference a network URL instead.`
-      );
-    }
-    return new Blob([new Uint8Array(c)]);
-  };
-}
-function O(t) {
-  return t.length >= 12 && Buffer.from(t.subarray(4, 8)).toString("latin1") === "ftyp" ? "mp4" : t.length >= 4 && t[0] === 26 && t[1] === 69 && t[2] === 223 && t[3] === 163 ? "webm" : null;
-}
-async function Y(t, e = {}) {
-  const i = p(t), l = m(f(t)), { renderBundleToFile: c } = await import("@sequio/server/route-b");
-  try {
-    const o = e.out ?? "out.mp4";
-    console.log(`Rendering ${t} (pure Node, WebGPU)${e.scale && e.scale !== 1 ? ` @ ${e.scale}×` : ""} …`);
-    let r = -1;
-    const n = await c(i, {
-      out: o,
-      scale: e.scale,
-      // Make gsap (and any other CLI-provided lib) resolvable to the composition
-      // in the Node render, same as the browser preview does.
-      externals: h(),
-      // Resolve `loadAsset('./clip.mp4')` against the project directory on disk,
-      // so a local image/video renders the same as it previews (contract #3).
-      loadAsset: b(l),
-      onProgress: (s) => {
-        const a = Math.round(s * 100);
-        a !== r && a % 10 === 0 && (r = a, process.stdout.write(`\r  ${a}%`));
-      }
-    });
-    if (process.stdout.write("\r     \r"), console.log(
-      `✅ wrote ${n.out} (${n.frames} frames, ${n.container}/${n.videoCodec}, ${n.bytes} bytes${n.audio ? ", +audio" : ""})`
-    ), e.verify) {
-      const a = (await import("node:fs")).readFileSync(n.out), d = O(a);
-      if (!d || a.length < 500)
-        throw new Error(`--verify failed: not a valid container (detected=${d}, size=${a.length})`);
-      console.log(`✅ verified: valid ${d} container.`);
-    }
-    return 0;
-  } catch (o) {
-    return console.error("✖", o instanceof Error ? o.message : String(o)), 1;
-  }
-}
-async function K(t, e = {}) {
-  const i = p(t), l = m(f(t)), { renderBundleFrameToFile: c } = await import("@sequio/server/route-b");
-  try {
-    const o = e.out ?? "frame.png", r = e.time ?? 0;
-    console.log(
-      `Rendering ${t} frame @ t=${r}s (pure Node, WebGPU)${e.scale && e.scale !== 1 ? ` @ ${e.scale}×` : ""} …`
-    );
-    const n = await c(i, {
-      out: o,
-      time: r,
-      scale: e.scale,
-      // Make gsap (and any other CLI-provided lib) resolvable to the composition
-      // in the Node render, same as the browser preview does.
-      externals: h(),
-      // Resolve `loadAsset('./clip.mp4')` against the project directory on disk,
-      // so a local image/video renders the same as it previews (contract #3).
-      loadAsset: b(l)
-    }), s = n.time !== r ? ` (clamped from ${r}s)` : "";
-    return console.log(
-      `✅ wrote ${n.out} (${n.width}×${n.height}, t=${n.time}s${s}, ${n.bytes} bytes)`
-    ), 0;
-  } catch (o) {
-    return console.error("✖", o instanceof Error ? o.message : String(o)), 1;
-  }
-}
-const k = m(U(import.meta.url)), _ = f(k, "../preview"), y = {};
-for (const [t, e] of [
-  ["@sequio/engine", "../../engine/src/index.ts"],
-  ["@sequio/runtime", "../../runtime/src/index.ts"],
-  ["@sequio/cli/externals", "./externals.ts"]
-]) {
-  const i = f(k, e);
-  w(i) && (y[t] = i);
-}
-async function Q(t, e = {}) {
-  const i = f(t), l = m(i);
-  p(i);
-  const { createServer: c } = await import("vite"), o = await c({
-    configFile: !1,
-    root: _,
-    logLevel: "warn",
-    server: {
-      port: e.port ?? 6180,
-      host: e.host ? !0 : "localhost",
-      strictPort: !0
-    },
-    resolve: {
-      alias: y
-    },
-    plugins: [
-      {
-        name: "sequio-preview-bundle",
-        configureServer(n) {
-          if (n.middlewares.use("/__bundle", (s, a) => {
-            try {
-              const d = p(i);
-              a.setHeader("Content-Type", "application/json"), a.setHeader("Cache-Control", "no-store"), a.end(JSON.stringify(d));
-            } catch (d) {
-              a.statusCode = 500, a.setHeader("Content-Type", "application/json"), a.end(JSON.stringify({ error: d instanceof Error ? d.message : String(d) }));
-            }
-          }), n.middlewares.use("/__asset", (s, a) => {
-            try {
-              const d = (s.url ?? "").split("?")[0], g = R(decodeURIComponent(d)), u = f(l, g);
-              if (u !== l && !u.startsWith(l + "/"))
-                return a.statusCode = 403, a.end("forbidden");
-              if (!w(u) || !P(u).isFile())
-                return a.statusCode = 404, a.end(`asset not found: ${g}`);
-              a.setHeader("Content-Type", W(g)), a.setHeader("Cache-Control", "no-store"), x(u).pipe(a);
-            } catch (d) {
-              a.statusCode = 400, a.end(d instanceof Error ? d.message : String(d));
-            }
-          }), e.watch) {
-            n.watcher.add(l);
-            const s = (a) => {
-              f(a).startsWith(l) && n.ws.send({ type: "full-reload", path: "*" });
-            };
-            n.watcher.on("change", s), n.watcher.on("add", s), n.watcher.on("unlink", s);
-          }
-        }
-      }
-    ]
-  });
-  return await o.listen(), {
-    url: o.resolvedUrls?.local[0] ?? `http://localhost:${e.port ?? 6180}/`,
-    async close() {
-      await o.close();
-    }
-  };
-}
-const G = C(import.meta.url), I = G("../package.json"), Z = I.version;
-export {
-  v as D,
-  z as U,
-  K as a,
-  Y as b,
-  X as p,
-  p as r,
-  Q as s,
-  Z as v
-};
-//# sourceMappingURL=version-B2TKvZen.js.map