@muhkoo/theater-transcoder 0.3.0 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@muhkoo/theater-transcoder",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Drain a Muhkoo Theater transcode queue with NATIVE ffmpeg. Run it on any machine signed in as you to add transcoding power to your library.",
   "type": "module",
   "bin": {
@@ -25,7 +25,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@muhkoo/connect": "0.10.1-alpha.0",
+    "@muhkoo/connect": "0.10.2-alpha.0",
     "ffmpeg-static": "^5.2.0",
     "node-datachannel": "^0.12.0",
     "snarkjs": "^0.7.5",

package/src/client.js

@@ -55,10 +55,16 @@ export async function connect({ baseUrl, appKey, username, password }) {
     apiKey: appKey,
     circuits,
     offline: { enabled: false },
-    // P2P on: fetch raw shards from a browser peer over WebRTC. Empty iceServers
-    // → direct LAN (host) candidates, no STUN — ideal same-network transcoding;
-    // origin remains the fallback. The block engine runs main-thread in Node.
-    p2p: { enabled: true, iceServers: [], debug: process.env.MUHKOO_P2P_DEBUG === "1" },
+    // P2P on: fetch raw shards from a browser peer over WebRTC instead of
+    // round-tripping R2. We must let the default STUN server apply (do NOT pass
+    // an empty iceServers — that disables STUN entirely, so WebRTC can't gather
+    // server-reflexive candidates and the browser↔Node connection never forms).
+    // Origin stays the fallback; the block engine runs main-thread in Node.
+    p2p: {
+      enabled: true,
+      ...(process.env.MUHKOO_STUN ? { iceServers: [{ urls: process.env.MUHKOO_STUN }] } : {}),
+      debug: process.env.MUHKOO_P2P_DEBUG === "1",
+    },
   });
   const user = await client.auth.zk.login(username, password);
   return { client, user };

package/src/worker.js

@@ -45,11 +45,11 @@ export function startWorker({ client, space, appKey, baseUrl }) {
       limit: 100,
     });
     const now = Date.now();
-    const cand = rows.find((j) =>
-      j.input_manifest && (
-        j.status === "queued" ||
-        (j.status === "processing" && (!j.heartbeat_at || now - j.heartbeat_at > STALE_MS))
-      ));
+    const isStale = (j) => j.status === "processing" && (!j.heartbeat_at || now - j.heartbeat_at > STALE_MS);
+    // Prefer an unclaimed queued job over reclaiming a stale one, so multiple
+    // workers spread across DIFFERENT jobs instead of piling onto the same movie.
+    const cand = rows.find((j) => j.input_manifest && j.status === "queued")
+      || rows.find((j) => j.input_manifest && isStale(j));
     if (!cand) return null;
     await patch(cand._id, { status: "processing", worker_id: WORKER_ID, worker_label: WORKER_LABEL, claimed_at: now, heartbeat_at: now });
     const fresh = await jobs().get(cand._id);
@@ -61,6 +61,10 @@ export function startWorker({ client, space, appKey, baseUrl }) {
   async function process(job) {
     activeJobId = job._id;
     abort = new AbortController();
+    // Keep the lease alive for the WHOLE job — including the raw download, which
+    // for a big file can exceed STALE_MS with no progress events. Without this a
+    // peer treats us as dead mid-download and steals the job (double-transcode).
+    const beat = setInterval(() => void patch(job._id, { heartbeat_at: Date.now() }).catch(() => {}), 12_000);
     let lastBeat = 0;
     const onProgress = ({ fraction, label }) => {
       const now = Date.now();
@@ -71,11 +75,18 @@ export function startWorker({ client, space, appKey, baseUrl }) {
       }
     };
     try {
-      log(`claim job ${job._id} "${job.title}" — downloading raw…`);
+      log(`claim job ${job._id} "${job.title}" — fetching raw (P2P → origin)…`);
+      // Surface the fetch stage so the uploader's UI shows "Fetching raw… on the
+      // transcoder" instead of a silent stall while the bytes transfer.
+      await patch(job._id, { phase: "Fetching raw…", progress: 0 }).catch(() => {});
+      await postSignal({ kind: "progress", jobId: job._id, progress: 0, phase: "Fetching raw…", worker: WORKER_LABEL });
       // The DB json column can hand back the manifest as a STRING — parse it, or
-      // readByManifest chokes ("manifest.chunks is not iterable").
+      // getFile chokes ("manifest.chunks is not iterable").
       const manifest = typeof job.input_manifest === "string" ? JSON.parse(job.input_manifest) : job.input_manifest;
-      const { data } = await client.storage.readByManifest(manifest);
+      // Read through the Space's getFile (NOT client.storage.readByManifest):
+      // only the Space file surface has the P2P peer source wired, so this pulls
+      // shards from the uploader's browser over WebRTC first, origin as fallback.
+      const { data } = await space.getFile(manifest);
       log(`transcoding ${(data.length / 1e6).toFixed(1)}MB…`);
       const { hls_index, duration, size } = await transcodeToHls({
         rawBytes: data, filename: job.filename || "input.mp4", space, onProgress, signal: abort.signal,
@@ -92,6 +103,7 @@ export function startWorker({ client, space, appKey, baseUrl }) {
       if (abort.signal.aborted) { log(`job ${job._id} stopped remotely`); }
       else { await patch(job._id, { status: "error", error: String(e?.message || e) }).catch(() => {}); log(`✗ job ${job._id} failed:`, e?.message || e); }
     } finally {
+      clearInterval(beat);
       activeJobId = null; abort = null;
     }
   }