@lalalic/markcut 1.0.0

package/src/player/pipeline.ts

@@ -0,0 +1,117 @@
+/**
+ * Standalone pipeline bundle entry point.
+ *
+ * Bundled with esbuild into `src/player/pipeline.mjs` so plain-JS contexts
+ * (like the player server) can run the full descriptive resolve + compile
+ * pipeline without a TypeScript loader.
+ *
+ * Exports:
+ *   - isDescriptiveRoot(data): boolean — heuristic format detection
+ *   - resolveAndCompile(data, options): Promise<Root> — full pipeline
+ *   - compileDescriptiveRoot(root): Root — pure compile (no I/O)
+ *   - resolveAll(root, options): Promise<DescriptiveRoot>
+ *
+ * Build:
+ *   bash scripts/build-pipeline.sh
+ */
+import { compileDescriptiveRoot, resolveVariantOverrides, parseImportsBlock, extractDependencySpecs } from "../descriptive/compiler";
+import { resolveAll, resolveIncludes } from "../descriptive/resolve";
+import { parseMarkdownDescriptive, parseMarkdownVariants } from "../descriptive/markdown";
+import type { DescriptiveRoot } from "../descriptive/compiler";
+import type { Root } from "../schema/index";
+
+export interface ResolveAndCompileOptions {
+  /** Base directory for resolving relative media src paths */
+  baseDir?: string;
+  /** Output directory for generated TTS audio / STT VTT files */
+  scriptOutputDir?: string;
+  /** Output directory for generated TTI/TTV media files */
+  mediaOutputDir?: string;
+  /** Output directory for pre-compiled include JSON files */
+  includeOutputDir?: string;
+  /** TTS CLI template override (default: edge-tts). Overrides root.tts. */
+  ttsCli?: string;
+  /** STT CLI template override (default: whisper). Overrides root.stt. */
+  sttCli?: string;
+  /** Separate output dir for the merged subtitles.vtt (e.g., per-variant).
+   *  Per-clip VTTs stay in scriptOutputDir; defaults to scriptOutputDir. */
+  subtitleOutputDir?: string;
+  /** Variant chain to apply to include nodes (e.g. ["zh", "tiktok"]).
+   *  When set, included .md files are parsed with variant awareness. */
+  variants?: string[];
+}
+
+/**
+ * Heuristic: detect whether a parsed JSON object is a descriptive root
+ * (vs. a pre-compiled stream tree Root).
+ *
+ * Signals:
+ *   - has `layout` field (descriptive-only, stripped by compiler)
+ *   - has `tts` or `stt` config (descriptive-only)
+ *   - any direct child has `type: "scene"` with `layout`
+ *   - any direct child has `type` of `series`/`parallel`/`transitionSeries`
+ */
+export function isDescriptiveRoot(data: any): boolean {
+  if (!data || typeof data !== "object") return false;
+  if (data.layout || data.tts || data.stt) return true;
+
+  const children = data.children ?? [];
+  if (!Array.isArray(children)) return false;
+
+  // Descriptive containers as direct children
+  if (children.some((c: any) =>
+    c?.type === "series" || c?.type === "parallel" || c?.type === "transitionSeries"
+  )) return true;
+
+  // Scenes with descriptive layout
+  if (children.some((c: any) =>
+    c?.type === "scene" && (c.layout || c.tts)
+  )) return true;
+
+  return false;
+}
+
+/**
+ * Run the full pipeline: resolve (TTS/STT/durations) + compile → Root.
+ *
+ * Pure data in, compiled Root out. Side effects: writes TTS audio files
+ * and VTT files to `options.scriptOutputDir` when scripts/scripts exist.
+ */
+export async function resolveAndCompile(
+  data: DescriptiveRoot,
+  options: ResolveAndCompileOptions = {},
+): Promise<Root> {
+  // 1. Async resolve: durations, TTS, STT, includes
+  const resolved = await resolveAll(data, {
+    baseDir: options.baseDir,
+    scriptOutputDir: options.scriptOutputDir,
+    mediaOutputDir: options.mediaOutputDir,
+    includeOutputDir: options.includeOutputDir,
+    ttsCli: options.ttsCli,
+    sttCli: options.sttCli,
+    subtitleOutputDir: options.subtitleOutputDir,
+    variants: options.variants,
+  });
+
+  // 2. Sync compile: descriptive → stream tree
+  const compiled = compileDescriptiveRoot(resolved);
+
+  return compiled;
+}
+
+/**
+ * Parse a descriptive markdown document into a DescriptiveRoot,
+ * then run the full resolve + compile pipeline.
+ *
+ * Convenience wrapper for markdown inputs.
+ */
+export async function resolveAndCompileMarkdown(
+  markdown: string,
+  options: ResolveAndCompileOptions = {},
+): Promise<Root> {
+  const descriptive = parseMarkdownDescriptive(markdown);
+  return resolveAndCompile(descriptive, options);
+}
+
+export { compileDescriptiveRoot, resolveVariantOverrides, resolveAll, resolveIncludes, parseMarkdownDescriptive, parseMarkdownVariants, parseImportsBlock, extractDependencySpecs };
+export type { DescriptiveRoot, Root, VariantParseResult } from "../descriptive/markdown";

package/src/player/server-shared.mjs

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+/**
+ * Shared utilities for markcut player servers.
+ *
+ * Extracts common code between server.mjs (edit/preview) and
+ * label-server.mjs (label annotation) into one place.
+ */
+
+import { statSync, createReadStream, readFileSync, existsSync } from "node:fs";
+import { extname } from "node:path";
+
+// ─── MIME types ──────────────────────────────────────────────────────────
+export const MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".vtt": "text/vtt",
+  ".wasm": "application/wasm",
+};
+
+// ─── Extract scene info from compiled root ───────────────────────────────
+export function extractScenes(root) {
+  const scenes = [];
+  let totalDuration = 0;
+
+  // Format 1: scenes as direct children of root
+  if (root.children?.length && !root.children.find(c => c.name === "scenes" || c.id === "scenes")) {
+    let offset = 0;
+    for (const s of root.children) {
+      if (!(s.type === "folder" || s.type === "scene" || s.children?.length)) continue;
+      if (s.isBackground) continue;
+      const leaf = (s.children || []).find(c => c.src && (c.type === "image" || c.type === "video"));
+      const action = leaf?.actions?.[0] || s.actions?.[0] || {};
+      const dur = (action.end || 5) - (action.start || 0);
+      scenes.push({
+        name: s.name || s.id || "scene",
+        start: offset,
+        end: offset + dur,
+        duration: dur,
+        src: leaf?.src || "",
+        mediaType: leaf?.type || "unknown",
+      });
+      offset += dur;
+    }
+    totalDuration = offset;
+  }
+
+  // Format 2: scenes wrapped in a "scenes" folder
+  const scenesFolder = root.children?.find(c => c.name === "scenes" || c.id === "scenes");
+  if (scenesFolder?.children && scenes.length === 0) {
+    let offset = 0;
+    for (const s of scenesFolder.children) {
+      const child = s.children?.[0] || {};
+      const action = child?.actions?.[0];
+      const dur = action ? (action.end - action.start) : 5;
+      scenes.push({
+        name: s.name,
+        start: offset,
+        end: offset + dur,
+        duration: dur,
+        src: child.src || "",
+        mediaType: child.type || "unknown",
+      });
+      offset += dur;
+    }
+    totalDuration = offset;
+  }
+
+  // Format 3: flat scenes array (labels.json format)
+  if (scenes.length === 0 && Array.isArray(root.scenes)) {
+    let offset = 0;
+    for (const s of root.scenes) {
+      const dur = (s.end ?? (s.start ?? 0) + 5) - (s.start ?? 0);
+      scenes.push({
+        name: s.name || "scene",
+        start: offset,
+        end: offset + dur,
+        duration: dur,
+        src: s.src || "",
+        mediaType: s.mediaType || "unknown",
+      });
+      offset += dur;
+    }
+    totalDuration = offset;
+  }
+
+  return { scenes, totalDuration };
+}
+
+// ─── Static file serving with range request support ──────────────────────
+export function serveFile(req, res, filePath) {
+  if (!existsSync(filePath) || !statSync(filePath).isFile()) return false;
+
+  const ext = extname(filePath).toLowerCase();
+  const mime = MIME[ext] || "application/octet-stream";
+  const fileSize = statSync(filePath).size;
+  const cacheControl = (ext === ".js" || ext === ".html") ? "no-cache" : "public, max-age=3600";
+  const range = req.headers.range;
+
+  if (range) {
+    const parts = range.replace(/bytes=/, "").split("-");
+    const start = parseInt(parts[0], 10);
+    const end = parts[1] ? parseInt(parts[1], 10) : fileSize - 1;
+    const chunkSize = end - start + 1;
+    const stream = createReadStream(filePath, { start, end });
+    res.writeHead(206, {
+      "Content-Range": `bytes ${start}-${end}/${fileSize}`,
+      "Accept-Ranges": "bytes",
+      "Content-Length": chunkSize,
+      "Content-Type": mime,
+      "Cache-Control": cacheControl,
+    });
+    stream.pipe(res);
+  } else {
+    const data = readFileSync(filePath);
+    res.writeHead(200, {
+      "Content-Type": mime,
+      "Accept-Ranges": "bytes",
+      "Content-Length": fileSize,
+      "Cache-Control": cacheControl,
+    });
+    res.end(data);
+  }
+  return true;
+}
+
+// ─── Shutdown handler ────────────────────────────────────────────────────
+export function handleShutdown(req, res, message = "Shutdown requested") {
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ shutting_down: true }));
+  console.log(`\n  🚪 ${message}\n`);
+  process.exit(0);
+}