@jokerized/decksmith 0.1.0

package/dist/server/errors.js

@@ -0,0 +1,73 @@
+import { UploadError } from "./upload.js";
+const HINTS = [
+  {
+    when: /"codex" CLI is not on PATH/i,
+    hint: "Install it on the server with `npm i -g @openai/codex`, then run `codex login` as the user this process runs as. Planning is the only stage that needs it."
+  },
+  {
+    when: /Codex did not finish within/i,
+    hint: "The document is probably long. Split it, or ask for fewer slides, and try again."
+  },
+  {
+    when: /codex exec exited|final message was not JSON|produced no final message/i,
+    hint: "Codex answered but not with a storyboard. Retry once \u2014 if it repeats, the document is likely too long or too unstructured to plan from."
+  },
+  {
+    when: /edge-tts is not installed/i,
+    hint: "Install it on the server with `python3 -m pip install --user edge-tts`, or submit with narration off \u2014 the deck itself needs no network."
+  },
+  {
+    when: /\bffprobe\b|\bffmpeg\b/i,
+    hint: "Install ffmpeg on the server (`brew install ffmpeg` / `apt install ffmpeg`). Narration measures its own audio with ffprobe and the video is muxed with ffmpeg."
+  },
+  {
+    when: /Cannot burn in captions/i,
+    hint: "Ask for sidecar subtitles instead of burned-in ones, or install a Chrome for the caption pass."
+  },
+  {
+    when: /browsers install chrome|DECKSMITH_CHROME|No (installed )?(Chrome|browser)/i,
+    hint: "Install a browser on the server with `npx puppeteer browsers install chrome`, or point DECKSMITH_CHROME at one. Only the video render needs it; the deck does not."
+  },
+  {
+    when: /timing\.json is missing/i,
+    hint: "The video needs narration to time itself against. Re-submit with narration on."
+  },
+  {
+    when: /Deck runtime missing/i,
+    hint: "The server was started without a build. Run `npm run build` and restart it."
+  },
+  {
+    // Seen on a real run: "Codex returned a storyboard that does not validate:
+    // beats.3.params.bars: Too small". The planner is schema-constrained but not
+    // schema-guaranteed, and a retry usually lands — so the hint has to match the
+    // sentence the library actually writes, not the one this table first guessed.
+    when: /storyboard that does not validate|is not a valid storyboard|does not resolve|dangling/i,
+    hint: "The planner answered with a storyboard that does not fit the schema \u2014 a beat came back half-filled. This is usually one bad roll of the dice; submit the same document again."
+  },
+  {
+    // A planner problem that surfaces wherever the emitter is first called —
+    // which is `narrate`, because narration asks the emitter how many stops a
+    // beat has. The stage in the UI is therefore honest about WHERE it stopped
+    // and misleading about WHAT went wrong, so the hint has to say so.
+    when: /equation-walk .*term|none of its \d+ term/i,
+    hint: "The planner labelled a symbol the equation does not contain. Nothing is wrong with your document; it is a planning miss and a fresh run usually writes the term correctly. Reported at the narration stage because that is the first stage that builds a slide."
+  },
+  {
+    when: /unrecognised image header/i,
+    hint: "One of the figures is not a PNG, JPEG or GIF. SVG and PDF figures are not read; export them to PNG first."
+  },
+  {
+    when: /ENOSPC|no space left/i,
+    hint: "The server is out of disk. Nothing you can do from here \u2014 tell whoever runs it."
+  }
+];
+const FALLBACK = "This one is not a document problem we recognise. The stage list above shows how far it got; re-running an identical upload is worth one try.";
+function explain(err) {
+  if (err instanceof UploadError) return { message: err.message, hint: err.hint };
+  const message = err instanceof Error ? err.message : String(err);
+  const clean = message.split("\n    at ")[0]?.trim() || "The job failed.";
+  return { message: clean, hint: HINTS.find((h) => h.when.test(message))?.hint ?? FALLBACK };
+}
+export {
+  explain
+};

package/dist/server/http.js

@@ -0,0 +1,504 @@
+import { randomBytes } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { createServer } from "node:http";
+import { extname, join, resolve, sep } from "node:path";
+import { catalog, parseOptions } from "./options.js";
+import { runPipeline, stagesFor } from "./pipeline.js";
+import { Queue, QueueFullError } from "./queue.js";
+import { parseMultipart, readBody, UploadError } from "./upload.js";
+const ID = /^[A-Za-z0-9_-]{22}$/;
+const KEEP = "job.json";
+const RAW = "upload.bin";
+async function keepUpload(dir, upload) {
+  try {
+    await mkdir(dir, { recursive: true });
+    const kept = { filename: upload.filename, fields: upload.fields, createdAt: Date.now() };
+    await writeFile(join(dir, KEEP), JSON.stringify(kept));
+    await writeFile(join(dir, RAW), upload.bytes);
+  } catch {
+  }
+}
+async function readKept(dir) {
+  try {
+    const kept = JSON.parse(await readFile(join(dir, KEEP), "utf8"));
+    if (typeof kept?.filename !== "string" || typeof kept?.fields !== "object") return null;
+    return { kept, bytes: await readFile(join(dir, RAW)) };
+  } catch {
+    return null;
+  }
+}
+function createDeckServer(opts) {
+  const queue = new Queue({
+    maxQueued: opts.maxQueued,
+    ttlMs: opts.ttlMs,
+    onExpire: (id, dir) => {
+      opts.log(`sweep: ${id} expired`);
+      opts.removeDir(dir);
+    }
+  });
+  const requests = new RateLimiter(opts.requestsPerMinute, 6e4);
+  const jobs = new RateLimiter(opts.jobsPerHour, 60 * 6e4);
+  const server = createServer((req, res) => {
+    handle(req, res).catch((err) => fail(res, err));
+  });
+  server.requestTimeout = 12e4;
+  server.headersTimeout = 3e4;
+  async function handle(req, res) {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const path = url.pathname;
+    res.setHeader("X-Content-Type-Options", "nosniff");
+    res.setHeader("Referrer-Policy", "no-referrer");
+    if (!requests.take(ipOf(req))) {
+      return send(res, 429, {
+        error: { message: "Too many requests.", hint: "Slow down and retry in a minute." }
+      });
+    }
+    if (req.method === "GET" && (path === "/" || path === "/index.html")) {
+      const page = await uiPage(opts.log);
+      res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+      res.end(page);
+      return;
+    }
+    if (req.method === "GET" && path === "/api/formats") {
+      return send(res, 200, catalog());
+    }
+    if (req.method === "POST" && path === "/api/jobs") {
+      return submit(req, res);
+    }
+    const events = path.match(/^\/api\/jobs\/([^/]+)\/events$/);
+    if (req.method === "GET" && events) return stream(req, res, events[1]);
+    const retry = path.match(/^\/api\/jobs\/([^/]+)\/retry$/);
+    if (req.method === "POST" && retry) return again(req, res, retry[1]);
+    const one = path.match(/^\/api\/jobs\/([^/]+)$/);
+    if (req.method === "GET" && one) {
+      const id = one[1];
+      const view = ID.test(id) ? queue.view(id) : void 0;
+      if (view) return send(res, 200, view);
+      const kept = ID.test(id) ? await readKept(join(resolve(opts.work), id)) : null;
+      if (kept) {
+        return send(res, 200, {
+          id,
+          state: "interrupted",
+          filename: kept.kept.filename,
+          createdAt: kept.kept.createdAt
+        });
+      }
+      return send(res, 404, {
+        error: {
+          message: "No such job.",
+          hint: "It may have expired; jobs are kept for a couple of hours."
+        }
+      });
+    }
+    const deck = path.match(/^\/d\/([^/]+)(\/.*)?$/);
+    if ((req.method === "GET" || req.method === "HEAD") && deck) {
+      return serveDeck(req, res, deck[1], deck[2] ?? "/");
+    }
+    send(res, 404, {
+      error: {
+        message: `No route for ${req.method} ${path}.`,
+        hint: "The API is POST /api/jobs, GET /api/jobs/:id and GET /api/formats."
+      }
+    });
+  }
+  async function submit(req, res) {
+    const body = await readBody(req, opts.maxUploadBytes);
+    const upload = await parseMultipart(body, req.headers["content-type"] ?? "");
+    const options = parseOptions(upload.fields);
+    if (!jobs.take(ipOf(req))) {
+      return send(res, 429, {
+        error: {
+          message: `That address has already submitted ${opts.jobsPerHour} decks this hour.`,
+          hint: "Each deck is minutes of CPU. Wait for the hour to roll over."
+        }
+      });
+    }
+    const id = randomBytes(16).toString("base64url");
+    const dir = join(resolve(opts.work), id);
+    await keepUpload(dir, upload);
+    const view = queue.submit({
+      id,
+      dir,
+      stages: stagesFor(options),
+      run: (job) => (opts.run ?? runPipeline)(job, {
+        upload,
+        options,
+        fetchRemoteFigures: opts.fetchRemoteFigures
+      })
+    });
+    opts.log(
+      `job ${id}: ${upload.filename} (${Math.round(upload.bytes.length / 1024)} KB) \u2192 ${options.formatId}${options.narrate ? " +narration" : ""}${options.video ? " +video" : ""}, position ${view.queuePosition ?? 0}`
+    );
+    send(res, 202, { id, queuePosition: view.queuePosition ?? 0 });
+  }
+  async function again(req, res, old) {
+    if (!ID.test(old)) return send(res, 404, { error: { message: "No such job." } });
+    const kept = await readKept(join(resolve(opts.work), old));
+    if (!kept) {
+      return send(res, 404, {
+        error: {
+          message: "That upload is no longer on the server.",
+          hint: "Choose the file again."
+        }
+      });
+    }
+    if (!jobs.take(ipOf(req))) {
+      return send(res, 429, {
+        error: {
+          message: `That address has already submitted ${opts.jobsPerHour} decks this hour.`,
+          hint: "Each deck is minutes of CPU. Wait for the hour to roll over."
+        }
+      });
+    }
+    const upload = {
+      filename: kept.kept.filename,
+      bytes: kept.bytes,
+      fields: kept.kept.fields
+    };
+    const options = parseOptions(upload.fields);
+    const id = randomBytes(16).toString("base64url");
+    const dir = join(resolve(opts.work), id);
+    await keepUpload(dir, upload);
+    const view = queue.submit({
+      id,
+      dir,
+      stages: stagesFor(options),
+      run: (job) => (opts.run ?? runPipeline)(job, {
+        upload,
+        options,
+        fetchRemoteFigures: opts.fetchRemoteFigures
+      })
+    });
+    opts.log(`job ${id}: retry of ${old} \u2014 ${upload.filename} \u2192 ${options.formatId}`);
+    send(res, 202, { id, queuePosition: view.queuePosition ?? 0 });
+  }
+  function stream(req, res, id) {
+    if (!ID.test(id) || !queue.view(id)) {
+      send(res, 404, { error: { message: "No such job.", hint: "It may have expired." } });
+      return;
+    }
+    res.writeHead(200, {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache, no-transform",
+      connection: "keep-alive"
+    });
+    let last = "";
+    const push = (view) => {
+      const { ms: _ms, ...stable } = view;
+      const body = JSON.stringify(view);
+      if (JSON.stringify(stable) === last) return;
+      last = JSON.stringify(stable);
+      res.write(`data: ${body}
+
+`);
+      if (view.state === "done" || view.state === "error") {
+        clearInterval(beat);
+        stop();
+        res.end();
+      }
+    };
+    const stop = queue.watch(id, push);
+    const beat = setInterval(() => res.write(": keep-alive\n\n"), 2e4);
+    req.on("close", () => {
+      clearInterval(beat);
+      stop();
+    });
+    const now = queue.view(id);
+    if (now) push(now);
+  }
+  async function serveDeck(req, res, id, rest) {
+    if (!ID.test(id))
+      return send(res, 404, { error: { message: "No such deck.", hint: "Check the link." } });
+    const base = resolve(join(opts.work, id, "deck"));
+    const rel = safeUrlPath(rest);
+    if (rel === null) {
+      return send(res, 400, {
+        error: {
+          message: "That path is not one we will serve.",
+          hint: "Follow the link the job returned rather than editing it."
+        }
+      });
+    }
+    const file = resolve(join(base, rel || "deck.html"));
+    if (file !== base && !file.startsWith(base + sep)) {
+      return send(res, 403, {
+        error: {
+          message: "That path is outside the deck.",
+          hint: "Follow the link the job returned rather than editing it."
+        }
+      });
+    }
+    const info = await stat(file).catch(() => null);
+    if (!info?.isFile()) {
+      return send(res, 404, {
+        error: {
+          message: "Not in this deck.",
+          hint: "The job may still be running, or its files may have expired."
+        }
+      });
+    }
+    const ext = extname(file).toLowerCase();
+    const type = MIME[ext] ?? "application/octet-stream";
+    const headers = {
+      "content-type": type,
+      "accept-ranges": "bytes",
+      // Each job id is fresh, so its files never change under the same URL.
+      "cache-control": "private, max-age=600"
+    };
+    if (opts.sandboxDecks) {
+      headers["content-security-policy"] = "sandbox allow-scripts allow-same-origin allow-downloads; connect-src 'none'";
+      headers["cross-origin-resource-policy"] = "same-site";
+    }
+    const range = parseRange(req.headers.range, info.size);
+    if (range === "unsatisfiable") {
+      res.writeHead(416, { "content-range": `bytes */${info.size}` });
+      res.end();
+      return;
+    }
+    if (range) {
+      headers["content-range"] = `bytes ${range.start}-${range.end}/${info.size}`;
+      headers["content-length"] = String(range.end - range.start + 1);
+      res.writeHead(206, headers);
+      if (req.method === "HEAD") return void res.end();
+      createReadStream(file, range).pipe(res);
+      return;
+    }
+    headers["content-length"] = String(info.size);
+    res.writeHead(200, headers);
+    if (req.method === "HEAD") return void res.end();
+    createReadStream(file).pipe(res);
+  }
+  function fail(res, err) {
+    if (res.headersSent) return void res.end();
+    if (err instanceof UploadError || err instanceof QueueFullError) {
+      send(res, err.status, { error: { message: err.message, hint: err.hint } });
+      return;
+    }
+    opts.log(`error: ${err instanceof Error ? err.stack : String(err)}`);
+    send(res, 500, {
+      error: {
+        message: "The server could not handle that request.",
+        hint: "If it repeats, the server log has the detail; nothing about your document is wrong that we can name."
+      }
+    });
+  }
+  return { server, queue };
+}
+function send(res, status, body) {
+  const text = JSON.stringify(body);
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": Buffer.byteLength(text)
+  });
+  res.end(text);
+}
+function safeUrlPath(rest) {
+  const out = [];
+  for (const raw of rest.split("/")) {
+    if (raw === "") continue;
+    let seg;
+    try {
+      seg = decodeURIComponent(raw);
+    } catch {
+      return null;
+    }
+    if (seg === ".") continue;
+    if (seg === ".." || seg.includes("/") || seg.includes("\\") || seg.includes("\0")) return null;
+    out.push(seg);
+  }
+  return out.join("/");
+}
+function parseRange(header, size) {
+  const m = header?.match(/^bytes=(\d*)-(\d*)$/);
+  if (!m) return null;
+  const [, rawStart = "", rawEnd = ""] = m;
+  if (rawStart === "" && rawEnd === "") return null;
+  let start;
+  let end;
+  if (rawStart === "") {
+    start = Math.max(0, size - Number(rawEnd));
+    end = size - 1;
+  } else {
+    start = Number(rawStart);
+    end = rawEnd === "" ? size - 1 : Math.min(Number(rawEnd), size - 1);
+  }
+  if (!Number.isFinite(start) || !Number.isFinite(end) || start > end || start >= size) {
+    return "unsatisfiable";
+  }
+  return { start, end };
+}
+class RateLimiter {
+  constructor(limit, windowMs, now = Date.now) {
+    this.limit = limit;
+    this.windowMs = windowMs;
+    this.now = now;
+  }
+  #hits = /* @__PURE__ */ new Map();
+  take(key) {
+    const at = this.now();
+    const row = this.#hits.get(key);
+    if (!row || row.resetAt <= at) {
+      if (this.#hits.size > 1e4) {
+        for (const [k, v] of this.#hits) if (v.resetAt <= at) this.#hits.delete(k);
+      }
+      this.#hits.set(key, { count: 1, resetAt: at + this.windowMs });
+      return true;
+    }
+    if (row.count >= this.limit) return false;
+    row.count++;
+    return true;
+  }
+}
+function ipOf(req) {
+  return req.socket.remoteAddress ?? "unknown";
+}
+const MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".mp3": "audio/mpeg",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".srt": "text/plain; charset=utf-8",
+  ".vtt": "text/vtt; charset=utf-8",
+  ".deck": "application/zip",
+  ".txt": "text/plain; charset=utf-8",
+  ".md": "text/markdown; charset=utf-8"
+};
+let cachedPage;
+async function uiPage(log) {
+  if (cachedPage) return cachedPage;
+  const specifier = "./ui.js";
+  try {
+    const mod = await import(specifier);
+    const page = mod.uiPage ?? mod.PAGE ?? mod.page ?? mod.default;
+    const html = typeof page === "function" ? page() : page;
+    if (typeof html === "string" && html.trim() !== "") {
+      cachedPage = html;
+      return html;
+    }
+    log(`decksmith: ${specifier} exports no page; serving the stand-in uploader`);
+  } catch (err) {
+    log(
+      `decksmith: cannot load ${specifier} (${err instanceof Error ? err.message : String(err)}); serving the stand-in uploader`
+    );
+  }
+  cachedPage = FALLBACK_PAGE;
+  return cachedPage;
+}
+const FALLBACK_PAGE = `<!doctype html>
+<html lang="en"><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>DeckSmith</title>
+<style>
+ body{font:15px/1.5 system-ui,sans-serif;max-width:44rem;margin:3rem auto;padding:0 1rem;color:#111}
+ fieldset{border:1px solid #ddd;border-radius:6px;margin:0 0 1rem}
+ label{display:inline-block;margin:.25rem 1rem .25rem 0}
+ #steps li{font-variant-numeric:tabular-nums}
+ #log{background:#111;color:#ddd;padding:.75rem;border-radius:6px;max-height:16rem;overflow:auto;white-space:pre-wrap;font:12px/1.4 ui-monospace,monospace}
+ .err{background:#fee;border:1px solid #c00;padding:.75rem;border-radius:6px}
+</style></head><body>
+<h1>DeckSmith</h1>
+<p>A document in, an animated deck out. Markdown, or a zip holding one.</p>
+<form id="f">
+  <fieldset><legend>Document</legend>
+    <input type="file" name="file" accept=".md,.markdown,.txt,.zip" required>
+  </fieldset>
+  <fieldset><legend>Options</legend>
+    <label>Format <select name="format" id="format"></select></label>
+    <label>Theme <select name="theme" id="theme"></select></label>
+    <label>Slides <input type="number" name="slides" min="3" max="40" value="12" style="width:5rem"></label>
+    <label><input type="checkbox" name="narrate" value="true"> Narrate</label>
+    <label><input type="checkbox" name="video" value="true"> Video</label>
+  </fieldset>
+  <button>Make the deck</button>
+</form>
+<div id="out"></div>
+<script>
+const $ = (s) => document.querySelector(s);
+// EVERY string below originates in an upload \u2014 a filename, a zip entry name, a
+// figure id the planner echoed back \u2014 so nothing reaches the DOM as markup.
+// This page is served from the same origin as the API; an unescaped error
+// message would be reflected XSS with the attacker choosing the filename.
+const el = (tag, text, attrs) => {
+  const n = document.createElement(tag);
+  if (text != null) n.textContent = text;
+  for (const [k, v] of Object.entries(attrs || {})) n.setAttribute(k, v);
+  return n;
+};
+const clear = (n) => { while (n.firstChild) n.removeChild(n.firstChild); return n; };
+const errorBox = (e) => {
+  const box = el("div", null, { class: "err" });
+  box.append(el("b", e.message), el("br"), document.createTextNode(e.hint || ""));
+  return box;
+};
+fetch("/api/formats").then(r => r.json()).then(c => {
+  for (const f of c.formats) $("#format").append(el("option", f.id + " \u2014 " + f.width + "\xD7" + f.height, { value: f.id }));
+  for (const t of c.themes) $("#theme").append(el("option", t));
+});
+$("#f").addEventListener("submit", async (e) => {
+  e.preventDefault();
+  clear($("#out")).append(el("p", "Uploading\u2026"));
+  const res = await fetch("/api/jobs", { method: "POST", body: new FormData(e.target) });
+  const body = await res.json();
+  if (!res.ok) { clear($("#out")).append(errorBox(body.error)); return; }
+  watch(body.id);
+});
+function watch(id) {
+  clear($("#out")).append(el("ul", null, { id: "steps" }), el("p", null, { id: "where" }), el("pre", null, { id: "log" }));
+  const es = new EventSource("/api/jobs/" + encodeURIComponent(id) + "/events");
+  es.onmessage = (m) => draw(JSON.parse(m.data), es);
+  es.onerror = () => { es.close(); poll(id); };
+}
+async function poll(id) {
+  const v = await (await fetch("/api/jobs/" + encodeURIComponent(id))).json();
+  draw(v, null);
+  if (v.state === "queued" || v.state === "running") setTimeout(() => poll(id), 2000);
+}
+const ICON = { pending: "\u2026", running: "\u25B6", done: "\u2713", skipped: "\u2013", error: "\u2717" };
+function draw(v, es) {
+  const secs = (n) => (n / 1000).toFixed(0) + "s";
+  const steps = clear($("#steps"));
+  for (const s of v.steps) {
+    steps.append(el("li", ICON[s.state] + " " + s.name + (s.ms ? " " + secs(s.ms) : "") + (s.detail ? " \u2014 " + s.detail : "")));
+  }
+  const where = clear($("#where"));
+  where.textContent = v.state === "queued"
+    ? "queued, position " + v.queuePosition
+    : v.state + (v.stage ? " \xB7 " + v.stage : "") + " \xB7 " + secs(v.ms) + " elapsed";
+  $("#log").textContent = v.log.join("\\n");
+  $("#log").scrollTop = 1e9;
+  if (v.error) clear(where).append(errorBox(v.error));
+  if (v.result) {
+    clear(where).append(el("span", v.result.slides + " slides, " + v.result.duration.toFixed(0) + "s \u2014 "));
+    for (const [label, href] of [["Open the deck", v.result.deckUrl], ["Video", v.result.videoUrl], ["Subtitles", v.result.srtUrl], ["Pack", v.result.packUrl]]) {
+      // Server-minted, same-origin paths only; anything else is not a link.
+      if (href && href.startsWith("/d/")) where.append(el("a", label, { href, target: "_blank" }), document.createTextNode(" "));
+    }
+    if (v.result.warnings.length) {
+      const ul = el("ul");
+      for (const w of v.result.warnings) ul.append(el("li", w));
+      where.append(ul);
+    }
+  }
+  if (es && (v.state === "done" || v.state === "error")) es.close();
+}
+</script></body></html>
+`;
+export {
+  RateLimiter,
+  createDeckServer,
+  parseRange,
+  safeUrlPath
+};

package/dist/server/main.js

@@ -0,0 +1,91 @@
+import { existsSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createDeckServer } from "./http.js";
+import { MAX_UPLOAD_BYTES } from "./upload.js";
+const env = process.env;
+const options = {
+  port: int(env.PORT, 8475),
+  host: env.DECKSMITH_HOST ?? "127.0.0.1",
+  work: env.DECKSMITH_WORK ?? join(tmpdir(), "decksmith-server"),
+  maxUploadBytes: int(env.DECKSMITH_MAX_UPLOAD, MAX_UPLOAD_BYTES),
+  maxQueued: int(env.DECKSMITH_MAX_QUEUE, 8),
+  ttlMs: int(env.DECKSMITH_JOB_TTL_MIN, 120) * 6e4,
+  jobsPerHour: int(env.DECKSMITH_JOBS_PER_HOUR, 5),
+  requestsPerMinute: int(env.DECKSMITH_REQS_PER_MIN, 240),
+  fetchRemoteFigures: flag(env.DECKSMITH_FETCH_FIGURES, true),
+  sandboxDecks: flag(env.DECKSMITH_DECK_SANDBOX, true),
+  removeDir: (dir) => void rm(dir, { recursive: true, force: true }).catch(() => {
+  }),
+  log: (line) => process.stderr.write(`${line}
+`)
+};
+mkdirSync(options.work, { recursive: true });
+const { server, queue } = createDeckServer(options);
+const sweeper = setInterval(() => queue.sweep(), 6e4);
+sweeper.unref();
+function sweepOrphans() {
+  const cutoff = Date.now() - options.ttlMs;
+  for (const entry of readdirSync(options.work, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const dir = join(options.work, entry.name);
+    if (!existsSync(join(dir, "deck"))) {
+      if (existsSync(join(dir, "job.json"))) {
+        for (const derived of ["src", "audio", "deck", "upload", "storyboard.json"]) {
+          options.removeDir(join(dir, derived));
+        }
+        options.log(`decksmith: ${entry.name} interrupted \u2014 upload kept, it can be run again`);
+        continue;
+      }
+      options.removeDir(dir);
+      options.log(`decksmith: dropped ${entry.name} \u2014 interrupted, nothing to keep`);
+      continue;
+    }
+    if (statSync(dir).mtimeMs > cutoff) continue;
+    options.removeDir(dir);
+    options.log(`decksmith: swept ${entry.name} from a previous run`);
+  }
+}
+sweepOrphans();
+server.listen(options.port, options.host, () => {
+  options.log(`decksmith: http://${options.host}:${options.port}`);
+  options.log(`decksmith: work ${options.work}, one job at a time, ${options.maxQueued} may wait`);
+  options.log(
+    `decksmith: no auth, no TLS. Bound to ${options.host}${options.host === "127.0.0.1" ? " \u2014 set DECKSMITH_HOST to open it, knowing that" : " \u2014 anyone who can reach this port can spend your Codex quota"}.`
+  );
+  preflight();
+});
+for (const signal of ["SIGINT", "SIGTERM"]) {
+  process.on(signal, () => {
+    options.log("decksmith: stopping");
+    server.close(() => process.exit(0));
+    setTimeout(() => process.exit(0), 5e3).unref();
+  });
+}
+function preflight() {
+  const runtime = fileURLToPath(new URL("../deck-runtime.js", import.meta.url));
+  const missing = [];
+  if (!existsSync(runtime)) missing.push(`the deck runtime (${runtime}) \u2014 run \`npm run build\``);
+  for (const [bin, why] of [
+    ["codex", "planning; every job needs it"],
+    ["edge-tts", "narration"],
+    ["ffmpeg", "video"]
+  ]) {
+    if (!onPath(bin)) missing.push(`${bin} \u2014 needed for ${why}`);
+  }
+  for (const line of missing) options.log(`decksmith: MISSING ${line}`);
+  if (missing.length === 0) options.log("decksmith: codex, edge-tts and ffmpeg all found");
+}
+function onPath(bin) {
+  return (env.PATH ?? "").split(":").some((dir) => dir !== "" && existsSync(join(dir, bin)));
+}
+function int(raw, fallback) {
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
+}
+function flag(raw, fallback) {
+  if (raw === void 0) return fallback;
+  return ["1", "true", "on", "yes"].includes(raw.toLowerCase());
+}