@hyperframes/producer 0.9.26 → 0.9.28-alpha.0

package/dist/index.js

@@ -67,7 +67,7 @@ import {
   referenceBackgroundResult,
   createReferenceBackgroundRecorder
 } from "@hyperframes/engine";
-import { join as join31, dirname as dirname13, resolve as resolve8 } from "path";
+import { join as join30, dirname as dirname13, resolve as resolve8 } from "path";
 import { totalmem as totalmem2 } from "node:os";
 import { randomUUID } from "crypto";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -1557,7 +1557,7 @@ var RenderExecutionContext = class {
 
 // src/services/render/artifactTransaction.ts
 import { closeSync as closeSync2, existsSync as existsSync6, fstatSync as fstatSync2, openSync as openSync2, readSync, readdirSync as readdirSync2, rmSync as rmSync3 } from "node:fs";
-import { basename as basename3, dirname as dirname4, extname as extname2, join as join5, resolve as resolve4 } from "node:path";
+import { basename as basename4, dirname as dirname4, extname as extname2, join as join5, resolve as resolve4 } from "node:path";
 import { HLS_MASTER_PLAYLIST, HLS_VIDEO_PLAYLIST, renameWithRetry } from "@hyperframes/engine";
 
 // src/utils/ffprobe.ts
@@ -1571,7 +1571,6 @@ import {
 import {
   existsSync as existsSync5,
   lstatSync,
-  mkdtempSync,
   readFileSync as readFileSync2,
   readdirSync,
   readlinkSync,
@@ -1579,8 +1578,9 @@ import {
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { hostname, uptime } from "node:os";
-import { dirname as dirname3, join as join4 } from "node:path";
+import { basename as basename3, dirname as dirname3, join as join4 } from "node:path";
 import { RENDER_TEMP_DIR } from "@hyperframes/core/project-folders";
+import { createStagingDir } from "@hyperframes/core/atomic-file";
 var OWNER_FILE = "owner.json";
 var TRANSACTION_BACKUP = "backup";
 var RENDER_JOB_DIR = /^[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}$/;
@@ -1600,7 +1600,7 @@ function pidScope() {
   };
 }
 function createOwnedRenderDir(prefix) {
-  const dir = mkdtempSync(prefix);
+  const dir = createStagingDir(dirname3(prefix), basename3(prefix));
   const owner = { pid: process.pid, ...pidScope() };
   writeFileSync2(join4(dir, OWNER_FILE), JSON.stringify(owner));
   return dir;
@@ -1710,7 +1710,7 @@ function buildArtifactExpectation(input) {
 function createSiblingTransactionDirectory(destination) {
   const parent = dirname4(destination);
   const extension = extname2(destination);
-  const stem = extension ? basename3(destination, extension) : basename3(destination);
+  const stem = extension ? basename4(destination, extension) : basename4(destination);
   return createOwnedRenderDir(join5(parent, `.${stem}.hf-transaction-`));
 }
 function assertReadableNonEmptyFile(path) {
@@ -1786,7 +1786,7 @@ var ArtifactTransaction = class {
     this.logger = logger;
     this.destinationPath = resolve4(destinationPath);
     this.transactionDirectory = createSiblingTransactionDirectory(this.destinationPath);
-    this.stagingPath = join5(this.transactionDirectory, basename3(this.destinationPath));
+    this.stagingPath = join5(this.transactionDirectory, basename4(this.destinationPath));
     this.backupPath = join5(this.transactionDirectory, TRANSACTION_BACKUP);
     this.durationProbe = durationProbe;
   }
@@ -1842,7 +1842,7 @@ var ArtifactTransaction = class {
     }
     if (expected.expectedFrames === void 0) return;
     const frameCount = files.filter(
-      (file) => dirname4(file) === this.stagingPath && /^frame_\d+\.png$/.test(basename3(file))
+      (file) => dirname4(file) === this.stagingPath && /^frame_\d+\.png$/.test(basename4(file))
     ).length;
     if (frameCount === 0) {
       throw new Error(
@@ -2081,7 +2081,7 @@ function replanAfterFailure(plan2, failure) {
 
 // src/services/render/stages/captureSegmentedStage.ts
 import { existsSync as existsSync7, mkdirSync as mkdirSync3, rmSync as rmSync6, statSync as statSync3 } from "node:fs";
-import { join as join10 } from "node:path";
+import { join as join9 } from "node:path";
 import {
   captureFrameToBuffer as captureFrameToBuffer2,
   closeCaptureSession as closeCaptureSession2,
@@ -2974,8 +2974,7 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
 }
 
 // src/services/render/stages/captureHdrResources.ts
-import { mkdirSync as mkdirSync2, mkdtempSync as mkdtempSync2, readFileSync as readFileSync3, rmSync as rmSync5, statSync as statSync2, statfsSync } from "node:fs";
-import { join as join8 } from "node:path";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync as rmSync5, statSync as statSync2, statfsSync } from "node:fs";
 import {
   decodePngToRgb48le,
   extractMediaMetadata as extractMediaMetadata2,
@@ -3075,6 +3074,7 @@ function createHdrFrameWindows(opts) {
 }
 
 // src/services/render/stages/captureHdrResources.ts
+import { createStagingDir as createStagingDir2 } from "@hyperframes/core/atomic-file";
 function tempDirSafePrefix(id) {
   const safe = id.replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 80);
   return safe || "video";
@@ -3332,7 +3332,7 @@ async function extractHdrVideoFrames(args) {
       if (!video || !planned) continue;
       const { window: window2, metadata } = planned;
       mkdirSync2(framesDir, { recursive: true });
-      const frameDir = mkdtempSync2(join8(framesDir, `hdr_${tempDirSafePrefix(videoId)}-`));
+      const frameDir = createStagingDir2(framesDir, `hdr_${tempDirSafePrefix(videoId)}-`);
       createdFrameDirs.add(frameDir);
       const dims = prep.hdrExtractionDims.get(videoId) ?? { width, height };
       const frameSize = dims.width * dims.height * 6;
@@ -3787,7 +3787,7 @@ function isTargetLossError(error) {
 // src/services/render/stages/captureStreamingStage.ts
 import { mkdtemp, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join8 } from "node:path";
 import {
   DrawElementVerificationError,
   captureFrameToBuffer,
@@ -4010,11 +4010,11 @@ async function verifyDrawElementSample(session, idx, buf, ctx) {
     return;
   }
   if (db < verifyMinDb) {
-    const dumpDir = await mkdtemp(join9(tmpdir(), "hf-de-verify-fail-")).catch(() => null);
+    const dumpDir = await mkdtemp(join8(tmpdir(), "hf-de-verify-fail-")).catch(() => null);
     if (dumpDir) {
       await Promise.all([
-        writeFile(join9(dumpDir, `frame-${idx}-de.jpg`), buf),
-        writeFile(join9(dumpDir, `frame-${idx}-truth.jpg`), truth)
+        writeFile(join8(dumpDir, `frame-${idx}-de.jpg`), buf),
+        writeFile(join8(dumpDir, `frame-${idx}-truth.jpg`), truth)
       ]).catch(() => {
       });
     }
@@ -4585,7 +4585,7 @@ async function runCaptureStreamingStage(input) {
 
 // src/services/render/stages/captureSegmentedStage.ts
 function segmentOutputPath(segmentDir, index) {
-  return join10(segmentDir, `segment_${String(index).padStart(5, "0")}.mp4`);
+  return join9(segmentDir, `segment_${String(index).padStart(5, "0")}.mp4`);
 }
 function segmentEncoderOptions(base, segment) {
   return {
@@ -4913,7 +4913,7 @@ async function runCaptureSegmentedStage(input) {
   const { log, dedupPerfs, assertNotAborted } = input;
   const deps = { ...DEFAULT_DEPS, ...input.deps };
   const segments = planSegments(input.totalFrames, input.segmentFrames);
-  const segmentDir = input.segmentDir ?? join10(input.workDir, "segments");
+  const segmentDir = input.segmentDir ?? join9(input.workDir, "segments");
   mkdirSync3(segmentDir, { recursive: true });
   const skip = input.completedSegments ?? /* @__PURE__ */ new Set();
   const pending = segments.filter((s) => !skip.has(s.index));
@@ -5060,7 +5060,7 @@ function startRenderEtaGuard(options) {
 }
 
 // src/services/render/captureCost.ts
-import { join as join11 } from "node:path";
+import { join as join10 } from "node:path";
 import { fpsToNumber as fpsToNumber4 } from "@hyperframes/core";
 import {
   calculateOptimalWorkers,
@@ -5306,7 +5306,7 @@ async function runCaptureCalibration(input) {
   });
   let calibration;
   try {
-    calibration = await runOneCalibration(join11(workDir, "capture-calibration"), calibrationCfg);
+    calibration = await runOneCalibration(join10(workDir, "capture-calibration"), calibrationCfg);
   } catch (error) {
     const shouldFallback = !forceScreenshot && shouldFallbackToScreenshotAfterCalibrationError(error);
     if (!shouldFallback) {
@@ -5340,7 +5340,7 @@ async function runCaptureCalibration(input) {
       const screenshotCfg = createCaptureCalibrationConfig({ ...cfg, forceScreenshot: true });
       try {
         calibration = await runOneCalibration(
-          join11(workDir, "capture-calibration-screenshot"),
+          join10(workDir, "capture-calibration-screenshot"),
           screenshotCfg
         );
       } catch (fallbackError) {
@@ -5405,7 +5405,7 @@ function checkPageNeverReady(input) {
 
 // src/services/render/deferredVideoFrames.ts
 import { mkdirSync as mkdirSync4, rmSync as rmSync7 } from "node:fs";
-import { dirname as dirname5, join as join12 } from "node:path";
+import { dirname as dirname5, join as join11 } from "node:path";
 import {
   createFrameLookupTable,
   extractVideoFramesRange,
@@ -5449,7 +5449,7 @@ async function extractDeferredFrames(input) {
   const shown = shownDeferredFrameIndexes(input, input.frames, input.fps);
   return Promise.all(
     deferred.map(async (video) => {
-      const outputDir = join12(input.outputRoot, video.videoId);
+      const outputDir = join11(input.outputRoot, video.videoId);
       const indexes = [...shown.get(video.videoId) ?? []].sort((a, b) => a - b);
       if (indexes.length === 0) {
         return { ...video, outputDir, framePaths: /* @__PURE__ */ new Map(), ownedByLookup: false };
@@ -5518,13 +5518,13 @@ async function extractAllDeferredFrames(extracted, input) {
 
 // src/services/render/segmentVideoFrames.ts
 import { mkdirSync as mkdirSync5, rmSync as rmSync8 } from "node:fs";
-import { join as join13 } from "node:path";
+import { join as join12 } from "node:path";
 import {
   createFrameLookupTable as createFrameLookupTable2,
   createVideoFrameInjector
 } from "@hyperframes/engine";
 function segmentFramesDir(rootDir, index) {
-  return join13(rootDir, "segment-frames", `segment_${String(index).padStart(5, "0")}`);
+  return join12(rootDir, "segment-frames", `segment_${String(index).padStart(5, "0")}`);
 }
 function createSegmentVideoFrames(input) {
   const extractFrames = input.extractFrames ?? extractDeferredFrames;
@@ -5554,7 +5554,7 @@ function createSegmentVideoFrames(input) {
   let onDemandCalls = 0;
   const onDemandHook = () => Object.assign(
     async (page, time, heldVideoTime) => {
-      const dir = join13(
+      const dir = join12(
         input.rootDir,
         "segment-frames",
         `on-demand_${String(onDemandCalls++).padStart(5, "0")}`
@@ -5571,7 +5571,7 @@ function createSegmentVideoFrames(input) {
   );
   return {
     async forFrames(frames, name) {
-      const dir = join13(input.rootDir, "segment-frames", name);
+      const dir = join12(input.rootDir, "segment-frames", name);
       const release = () => rmSync8(dir, { recursive: true, force: true });
       try {
         release();
@@ -5624,7 +5624,7 @@ function createSegmentVideoFrames(input) {
 
 // src/services/render/videoFrameWindow.ts
 import { readdirSync as readdirSync3, statSync as statSync4 } from "node:fs";
-import { join as join14 } from "node:path";
+import { join as join13 } from "node:path";
 function shouldWindowVideoFrames(args) {
   return args.segmented && args.env.HF_VIDEO_FRAME_WINDOW?.trim().toLowerCase() === "true";
 }
@@ -5637,7 +5637,7 @@ function directoryBytes(path) {
     return 0;
   }
   for (const entry of entries) {
-    const child3 = join14(path, entry.name);
+    const child3 = join13(path, entry.name);
     try {
       bytes += entry.isDirectory() ? directoryBytes(child3) : statSync4(child3).size;
     } catch {
@@ -5655,7 +5655,7 @@ function trackSegmentFramePeak(frames, rootDir, onPeak) {
         ...worker,
         async prepare(segment) {
           await worker.prepare(segment);
-          const held = directoryBytes(join14(rootDir, "segment-frames"));
+          const held = directoryBytes(join13(rootDir, "segment-frames"));
           if (held > peak) {
             peak = held;
             onPeak(peak);
@@ -5669,7 +5669,7 @@ function trackSegmentFramePeak(frames, rootDir, onPeak) {
 // src/services/render/segmentManifest.ts
 import { createHash as createHash2 } from "node:crypto";
 import { existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync4, statSync as statSync5, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join15 } from "node:path";
+import { join as join14 } from "node:path";
 import { renameWithRetry as renameWithRetry2 } from "@hyperframes/engine";
 var MANIFEST_FILENAME = "segments.json";
 function computeSegmentPlanHash(input) {
@@ -5697,7 +5697,7 @@ function computeSegmentPlanHash(input) {
   return createHash2("sha256").update(ordered.join(" ")).digest("hex").slice(0, 16);
 }
 function segmentDirFor(projectRendersDir, planHash) {
-  return join15(projectRendersDir, ".hf-segments", planHash);
+  return join14(projectRendersDir, ".hf-segments", planHash);
 }
 function hasNumber(value, key) {
   return key in value && typeof Reflect.get(value, key) === "number";
@@ -5715,7 +5715,7 @@ function isManifest(value) {
   return Reflect.get(value, "version") === 1 && hasString(value, "planHash") && hasNumber(value, "totalFrames") && hasNumber(value, "segmentFrames") && Array.isArray(completed) && completed.every(isEntry);
 }
 function readSegmentManifest(segmentDir) {
-  const path = join15(segmentDir, MANIFEST_FILENAME);
+  const path = join14(segmentDir, MANIFEST_FILENAME);
   if (!existsSync8(path)) return null;
   try {
     const parsed = JSON.parse(readFileSync4(path, "utf-8"));
@@ -5726,9 +5726,9 @@ function readSegmentManifest(segmentDir) {
 }
 function writeSegmentManifest(segmentDir, manifest) {
   mkdirSync6(segmentDir, { recursive: true });
-  const tmp = join15(segmentDir, `${MANIFEST_FILENAME}.${process.pid}.tmp`);
+  const tmp = join14(segmentDir, `${MANIFEST_FILENAME}.${process.pid}.tmp`);
   writeFileSync3(tmp, JSON.stringify(manifest, null, 2), "utf-8");
-  renameWithRetry2(tmp, join15(segmentDir, MANIFEST_FILENAME));
+  renameWithRetry2(tmp, join14(segmentDir, MANIFEST_FILENAME));
 }
 async function probeSegmentFrameCount(path, probe) {
   try {
@@ -6325,7 +6325,7 @@ function countAuthoredTimedClips(html) {
 
 // src/services/render/stages/compileStage.ts
 import { existsSync as existsSync12, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join19 } from "node:path";
+import { join as join18 } from "node:path";
 import { suggestMatchingPreset } from "@hyperframes/core";
 import { extractStandaloneEntryFromIndex, isTemplateEntry } from "@hyperframes/core/compiler";
 import { readTextFile as readTextFile2 } from "@hyperframes/parsers/asset-resolution";
@@ -6334,7 +6334,7 @@ import { readTextFile as readTextFile2 } from "@hyperframes/parsers/asset-resolu
 import { decodedUrlPath as decodedUrlPath2 } from "@hyperframes/parsers/asset-paths";
 import { createHash as createHash6 } from "node:crypto";
 import { createReadStream as createReadStream2, existsSync as existsSync11, mkdirSync as mkdirSync9, readFileSync as readFileSync7 } from "fs";
-import { join as join18, dirname as dirname8, resolve as resolve7, basename as basename4, relative as relative2, sep as sep2 } from "path";
+import { join as join17, dirname as dirname8, resolve as resolve7, basename as basename5, relative as relative2, sep as sep2 } from "path";
 import { parseHTML as parseHTML5 } from "linkedom";
 import {
   COMPOSITION_SOURCE_URL,
@@ -6581,7 +6581,7 @@ import {
 // src/services/animatedGifPrep.ts
 import { createHash as createHash4 } from "node:crypto";
 import { copyFileSync as copyFileSync2, existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync5, rmSync as rmSync9, statSync as statSync6 } from "node:fs";
-import { dirname as dirname6, isAbsolute as isAbsolute2, join as join16, resolve as resolve5 } from "node:path";
+import { dirname as dirname6, isAbsolute as isAbsolute2, join as join15, resolve as resolve5 } from "node:path";
 import { parseHTML as parseHTML3 } from "linkedom";
 import { parseAnimatedGifMetadata } from "@hyperframes/core";
 import { DEFAULT_VP9_CPU_USED, runFfmpeg as runFfmpeg2, renameWithRetry as renameWithRetry3 } from "@hyperframes/engine";
@@ -6824,7 +6824,7 @@ function replaceImageWithVideo(input) {
   return video;
 }
 async function prepareAnimatedGifInputs(html, options) {
-  const outputDir = options.outputDir ?? join16(options.downloadDir, PREPARED_GIF_SUBDIR);
+  const outputDir = options.outputDir ?? join15(options.downloadDir, PREPARED_GIF_SUBDIR);
   const outputSrcPrefix = normalizeRelPath(options.outputSrcPrefix ?? PREPARED_GIF_SUBDIR);
   const cacheDir = options.cacheDir ?? outputDir;
   const { document: document2 } = parseHTML3(html);
@@ -6851,8 +6851,8 @@ async function prepareAnimatedGifInputs(html, options) {
     );
     const hash = computePreparedGifHash(bytes, loopIterations, padSeconds);
     const filename = `${CACHE_SCHEMA}-${hash.slice(0, 24)}.webm`;
-    const cachePath = join16(cacheDir, filename);
-    const outputPath = join16(outputDir, filename);
+    const cachePath = join15(cacheDir, filename);
+    const outputPath = join15(outputDir, filename);
     const outputSrc = `${outputSrcPrefix}/${filename}`;
     await ensurePreparedWebm({
       sourcePath,
@@ -6897,7 +6897,7 @@ import {
   statSync as statSync7,
   writeFileSync as writeFileSync4
 } from "node:fs";
-import { dirname as dirname7, join as join17, resolve as resolve6 } from "node:path";
+import { dirname as dirname7, join as join16, resolve as resolve6 } from "node:path";
 import { parseHTML as parseHTML4 } from "linkedom";
 import { renameWithRetry as renameWithRetry4, runFfmpeg as runFfmpeg3, runFfprobe } from "@hyperframes/engine";
 
@@ -7171,7 +7171,7 @@ async function ensurePreparedJpeg(source, cachePath, outputPath, options) {
   }
 }
 async function prepareHeifImageInputs(html, options) {
-  const outputDir = options.outputDir ?? join17(options.downloadDir, PREPARED_HEIF_SUBDIR);
+  const outputDir = options.outputDir ?? join16(options.downloadDir, PREPARED_HEIF_SUBDIR);
   const outputSrcPrefix = normalizeRelPath(options.outputSrcPrefix ?? PREPARED_HEIF_SUBDIR);
   const cacheDir = options.cacheDir ?? outputDir;
   const preparedAssets = /* @__PURE__ */ new Map();
@@ -7192,7 +7192,7 @@ async function prepareHeifImageInputs(html, options) {
   await Promise.all(
     [...unique].map(
       ([filename, source]) => withMediaProbeSlot(
-        () => ensurePreparedJpeg(source, join17(cacheDir, filename), join17(outputDir, filename), options)
+        () => ensurePreparedJpeg(source, join16(cacheDir, filename), join16(outputDir, filename), options)
       ).catch((error) => {
         if (!options.onFailure) throw error;
         failed.add(filename);
@@ -7204,8 +7204,8 @@ async function prepareHeifImageInputs(html, options) {
     if (failed.has(filename)) continue;
     const outputSrc = `${outputSrcPrefix}/${filename}`;
     img.setAttribute("src", outputSrc);
-    preparedAssets.set(outputSrc, join17(outputDir, filename));
-    preparedImages.push({ sourceSrc: src, outputSrc, outputPath: join17(outputDir, filename) });
+    preparedAssets.set(outputSrc, join16(outputDir, filename));
+    preparedImages.push({ sourceSrc: src, outputSrc, outputPath: join16(outputDir, filename) });
   }
   return { html: document2.toString(), preparedAssets, preparedImages };
 }
@@ -7541,7 +7541,7 @@ function detectShaderTransitionUsage(html) {
 async function resolveMediaDuration(src, mediaStart, playbackRate, baseDir, downloadDir, tagName, elementIdentity, log, urlByAbsentLocalPath, probes) {
   let filePath = src;
   if (isHttpUrl(src)) {
-    const remoteDir = join18(downloadDir, REMOTE_MEDIA_SUBDIR);
+    const remoteDir = join17(downloadDir, REMOTE_MEDIA_SUBDIR);
     if (!existsSync11(remoteDir)) mkdirSync9(remoteDir, { recursive: true });
     try {
       filePath = await downloadToTemp(src, remoteDir, void 0, void 0, void 0, {
@@ -7552,7 +7552,7 @@ async function resolveMediaDuration(src, mediaStart, playbackRate, baseDir, down
     }
   } else {
     filePath = decodedUrlPath2(src);
-    if (!filePath.startsWith("/")) filePath = join18(baseDir, filePath);
+    if (!filePath.startsWith("/")) filePath = join17(baseDir, filePath);
     filePath = urlByAbsentLocalPath?.get(filePath) ?? filePath;
   }
   if (!isHttpUrl(filePath) && !existsSync11(filePath)) {
@@ -8168,7 +8168,7 @@ async function downloadAndRewriteUrls(urlSet, html, remoteDir, warnLabel, logLab
   const remoteMediaAssets = /* @__PURE__ */ new Map();
   const urlToRelPath = /* @__PURE__ */ new Map();
   for (const [url, absPath] of urlToLocal) {
-    const relPath = `${REMOTE_MEDIA_SUBDIR}/${basename4(absPath)}`;
+    const relPath = `${REMOTE_MEDIA_SUBDIR}/${basename5(absPath)}`;
     remoteMediaAssets.set(relPath, absPath);
     urlToRelPath.set(url, relPath);
   }
@@ -8192,7 +8192,7 @@ async function localizeRemoteMediaSources(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join18(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join17(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote media download failed",
     "Localized remote media source(s)"
   );
@@ -8207,7 +8207,7 @@ async function localizeRemoteImageSources(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join18(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join17(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote image download failed",
     "Localized remote image source(s)"
   );
@@ -8223,7 +8223,7 @@ async function localizeRemoteBackgroundImages(html, downloadDir) {
   return downloadAndRewriteUrls(
     urlSet,
     html,
-    join18(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join17(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote background-image download failed",
     "Localized remote background-image(s)",
     // Quoted url('..')/url("..") are rewritten by downloadAndRewriteUrls' default
@@ -8378,7 +8378,7 @@ function localizeFontFaceUrls(html, downloadDir) {
   return downloadAndRewriteUrls(
     collectFontFaceUrls(html),
     html,
-    join18(downloadDir, REMOTE_MEDIA_SUBDIR),
+    join17(downloadDir, REMOTE_MEDIA_SUBDIR),
     "Remote font download failed",
     "Localized remote font face(s)",
     (h, url, relPath) => h.replaceAll(`url(${url})`, `url("${relPath}")`)
@@ -9055,10 +9055,10 @@ function adaptAspectAgnosticResolution(requested, aspectAgnostic, width, height,
 }
 function resolveEntryHtmlPath(input) {
   const { projectDir, workDir, entryFile, log } = input;
-  const htmlPath = join19(projectDir, entryFile);
+  const htmlPath = join18(projectDir, entryFile);
   const rawEntry = readTextFile2(htmlPath);
   if (entryFile === "index.html" || !isTemplateEntry(rawEntry)) return htmlPath;
-  const projectIndexPath = join19(projectDir, "index.html");
+  const projectIndexPath = join18(projectDir, "index.html");
   if (!existsSync12(projectIndexPath)) {
     throw new Error(
       `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
@@ -9074,7 +9074,7 @@ function resolveEntryHtmlPath(input) {
       `Entry file "${entryFile}" is not mounted from index.html via data-composition-src, so it cannot be rendered independently.`
     );
   }
-  const wrapperPath = join19(workDir, "standalone-entry.html");
+  const wrapperPath = join18(workDir, "standalone-entry.html");
   writeFileSync5(wrapperPath, standaloneHtml, "utf-8");
   log.info("Extracted standalone entry from index.html host context", { entryFile });
   return wrapperPath;
@@ -9095,7 +9095,7 @@ async function runCompileStage(input) {
   } = input;
   const htmlPath = resolveEntryHtmlPath({ projectDir, workDir, entryFile, log });
   const compileStart = Date.now();
-  const compiled = await compileForRender(projectDir, htmlPath, join19(workDir, "downloads"), {
+  const compiled = await compileForRender(projectDir, htmlPath, join18(workDir, "downloads"), {
     log,
     failClosedFontFetch: failClosedFontFetch === true,
     allowSystemFontCapture,
@@ -9103,7 +9103,7 @@ async function runCompileStage(input) {
     variables: input.variables,
     urlByAbsentLocalPath: input.urlByAbsentLocalPath,
     pageMotionBlur: input.pageMotionBlur,
-    animatedGifCacheDir: cfg.extractCacheDir ? join19(cfg.extractCacheDir, "animated-gif") : void 0,
+    animatedGifCacheDir: cfg.extractCacheDir ? join18(cfg.extractCacheDir, "animated-gif") : void 0,
     ffmpegProcessTimeout: cfg.ffmpegProcessTimeout
   });
   assertNotAborted();
@@ -9160,7 +9160,7 @@ async function runCompileStage(input) {
   };
   await preflightCompositionAssetMediaTypes({
     projectDir,
-    compiledDir: join19(workDir, "compiled"),
+    compiledDir: join18(workDir, "compiled"),
     composition,
     signal: abortSignal
   });
@@ -9206,7 +9206,7 @@ async function runCompileStage(input) {
 
 // src/services/render/stages/probeStage.ts
 import { createHash as createHash7 } from "node:crypto";
-import { basename as basename5, join as join20 } from "node:path";
+import { basename as basename6, join as join19 } from "node:path";
 import { parseHTML as parseHTML6 } from "linkedom";
 import {
   closeCaptureSession as closeCaptureSession4,
@@ -9356,7 +9356,7 @@ function probeRequiresBrowser(args) {
 function reportedLengthSource(source) {
   if (!source) return null;
   if (source.from !== "media") return { from: source.from };
-  const name = basename5(source.src.split(/[?#]/, 1)[0] ?? "");
+  const name = basename6(source.src.split(/[?#]/, 1)[0] ?? "");
   const srcHash = createHash7("sha256").update(name).digest("hex").slice(0, 12);
   return { from: "media", tag: source.tag, trimmed: source.trimmed, srcHash };
 }
@@ -9415,7 +9415,7 @@ async function runProbeStage(input) {
       });
       fileServer = await createFileServer({
         projectDir,
-        compiledDir: join20(workDir, "compiled"),
+        compiledDir: join19(workDir, "compiled"),
         port: 0,
         preHeadScripts: [VIRTUAL_TIME_SHIM],
         fps: job.config.fps
@@ -9445,7 +9445,7 @@ async function runProbeStage(input) {
           log.info("Creating capture session...", { attempt, maxAttempts: PROBE_MAX_ATTEMPTS });
           probeSession = await createCaptureSession4(
             fileServer.url,
-            join20(workDir, "probe"),
+            join19(workDir, "probe"),
             captureOpts,
             null,
             probeCfg
@@ -9530,7 +9530,7 @@ async function runProbeStage(input) {
           });
           probeSession = await createCaptureSession4(
             fileServer.url,
-            join20(workDir, "probe-screenshot"),
+            join19(workDir, "probe-screenshot"),
             captureOpts,
             null,
             { ...probeCfg, forceScreenshot: true }
@@ -9568,7 +9568,7 @@ async function runProbeStage(input) {
             compiled,
             resolutions,
             projectDir,
-            join20(workDir, "downloads")
+            join19(workDir, "downloads")
           );
           assertNotAborted();
           composition.videos = compiled.videos;
@@ -9759,7 +9759,7 @@ async function runProbeStage(input) {
     }
     await preflightCompositionAssetMediaTypes({
       projectDir,
-      compiledDir: join20(workDir, "compiled"),
+      compiledDir: join19(workDir, "compiled"),
       composition,
       signal: abortSignal
     });
@@ -9926,7 +9926,7 @@ function validateDistributedDuration(input) {
 
 // src/services/render/stages/extractVideosStage.ts
 import { existsSync as existsSync13 } from "node:fs";
-import { join as join21 } from "node:path";
+import { join as join20 } from "node:path";
 import {
   classifyVideoExtractionError,
   createFrameLookupTable as createFrameLookupTable3,
@@ -10272,14 +10272,14 @@ async function runExtractVideosStage(input) {
       // because short boundary counts can differ by one frame.
       {
         fps: job.config.fps,
-        outputDir: join21(compiledDir, "__hyperframes_video_frames"),
+        outputDir: join20(compiledDir, "__hyperframes_video_frames"),
         format: job.config.videoFrameFormat ?? "auto",
         toneMapHdrToSdr: rendersSdrOnly(job.config, composition),
         timelineEnd: composition.duration,
         maxTransientRetries: extractionPolicy.maxTransientRetries,
         collectProbeFailures: extractionPolicy.failureMode === "enforce",
         deferRangeExtraction,
-        contentKeyedDirs: [join21(compiledDir, REMOTE_MEDIA_SUBDIR)],
+        contentKeyedDirs: [join20(compiledDir, REMOTE_MEDIA_SUBDIR)],
         urlByAbsentLocalPath,
         onProgress: ({ planned = 0, done = 0 }) => {
           framesPlanned += planned;
@@ -10462,7 +10462,7 @@ async function planVideoLayerPassthrough(input) {
 
 // src/services/render/stages/audioStage.ts
 import { existsSync as existsSync16 } from "node:fs";
-import { join as join24 } from "node:path";
+import { join as join23 } from "node:path";
 import {
   MIXED_AUDIO_FILENAME,
   audioFailureDiagnostics,
@@ -10473,7 +10473,7 @@ import {
 
 // src/services/render/audioDeliveryLimit.ts
 import { existsSync as existsSync15 } from "node:fs";
-import { dirname as dirname10, join as join23 } from "node:path";
+import { dirname as dirname10, join as join22 } from "node:path";
 import {
   applyAudioFxChain,
   describeFfmpegFailure as describeFfmpegFailure3,
@@ -10483,8 +10483,7 @@ import {
 
 // src/services/render/audioPadTrim.ts
 import { spawn } from "node:child_process";
-import { mkdtempSync as mkdtempSync3 } from "node:fs";
-import { dirname as dirname9, join as join22 } from "node:path";
+import { dirname as dirname9, join as join21 } from "node:path";
 import {
   DEFAULT_CONFIG,
   describeFfmpegFailure as describeFfmpegFailure2,
@@ -10591,6 +10590,7 @@ async function measureTruePeakDbfs(audioPath, options) {
 }
 
 // src/services/render/audioPadTrim.ts
+import { createStagingDir as createStagingDir3 } from "@hyperframes/core/atomic-file";
 var AUDIO_DURATION_TOLERANCE_SECONDS = 1e-3;
 var AAC_DELIVERY_TRUE_PEAK_DBFS = -1;
 var AAC_TRUE_PEAK_CORRECTION_HEADROOM_DB = 0.5;
@@ -10763,7 +10763,7 @@ async function constrainAacTruePeak(input) {
 }
 async function cutSource(input, scratchDir, attenuationDb) {
   if (!input.sourcePath || !input.rewriteSource) return true;
-  const cutPath = join22(scratchDir, "source.wav");
+  const cutPath = join21(scratchDir, "source.wav");
   try {
     const result = await input.rewriteSource(input.sourcePath, cutPath, gainFilter(attenuationDb));
     if (!result.success) throw new Error(result.error);
@@ -10777,8 +10777,8 @@ async function cutSource(input, scratchDir, attenuationDb) {
 async function enforceAacTruePeak(input) {
   let scratchDir;
   try {
-    scratchDir = mkdtempSync3(join22(dirname9(input.audioPath), ".true-peak-"));
-    const correctedPath = join22(scratchDir, "audio.m4a");
+    scratchDir = createStagingDir3(dirname9(input.audioPath), ".true-peak-");
+    const correctedPath = join21(scratchDir, "audio.m4a");
     const measurements = [];
     let attenuationDb = 0;
     let sourcePeakDbfs;
@@ -10988,7 +10988,7 @@ async function limitDeliveryPeaks(input, deps = {
   const peak = await deps.measure(audioPath, { timeoutMs, signal });
   if (peak <= AAC_DELIVERY_TRUE_PEAK_DBFS) return { success: true };
   const alternating = ["a", "b"].map(
-    (k) => join23(dirname10(sourcePath), `audio-source-limited-${k}.wav`)
+    (k) => join22(dirname10(sourcePath), `audio-source-limited-${k}.wav`)
   );
   let encodedFrom;
   let ceiling = AAC_DELIVERY_TRUE_PEAK_DBFS;
@@ -11060,7 +11060,7 @@ function runAudioStage(input) {
 }
 async function runAudioStageScoped(input) {
   const stageStart = Date.now();
-  const pcmSourcePath = join24(input.workDir, "audio-source.wav");
+  const pcmSourcePath = join23(input.workDir, "audio-source.wav");
   const duration = input.totalFrames * input.fps.den / input.fps.num;
   let deliverySourcePath;
   try {
@@ -11125,7 +11125,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
     assertNotAborted,
     log
   } = input;
-  const audioOutputPath = join24(workDir, MIXED_AUDIO_FILENAME);
+  const audioOutputPath = join23(workDir, MIXED_AUDIO_FILENAME);
   let hasAudio = false;
   let audioError;
   let audioFailures;
@@ -11136,7 +11136,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
       audioResult = await processCompositionAudio(
         audios,
         projectDir,
-        join24(workDir, "audio-work"),
+        join23(workDir, "audio-work"),
         audioOutputPath,
         duration,
         abortSignal,
@@ -11205,7 +11205,7 @@ async function mixAudioForDelivery(input, duration, pcmSourcePath) {
 
 // src/services/render/stages/captureStage.ts
 import { existsSync as existsSync17, readdirSync as readdirSync4, statfsSync as statfsSync2 } from "node:fs";
-import { join as join25 } from "node:path";
+import { join as join24 } from "node:path";
 import {
   classifyCaptureFailure as classifyCaptureFailure2,
   frameFileExtension,
@@ -11278,13 +11278,13 @@ function measureCaptureFrameBytes(workDir, framesDir) {
   if (!existsSync17(workDir)) return total;
   for (const attempt of readdirSync4(workDir)) {
     if (/^retry-\d+-batch-\d+-worker-\d+$/.test(attempt)) {
-      total += sampleDirectoryBytes(join25(workDir, attempt));
+      total += sampleDirectoryBytes(join24(workDir, attempt));
       continue;
     }
     if (!/^capture-attempt-\d+$/.test(attempt)) continue;
-    const attemptDir = join25(workDir, attempt);
+    const attemptDir = join24(workDir, attempt);
     for (const name of readdirSync4(attemptDir)) {
-      if (/^worker-\d+$/.test(name)) total += sampleDirectoryBytes(join25(attemptDir, name));
+      if (/^worker-\d+$/.test(name)) total += sampleDirectoryBytes(join24(attemptDir, name));
     }
   }
   return total;
@@ -11583,7 +11583,7 @@ async function captureSessionFrames(session, { input, rangeStart, rangeEnd, resu
 
 // src/services/render/stages/captureHdrStage.ts
 import { existsSync as existsSync19, mkdirSync as mkdirSync10 } from "node:fs";
-import { join as join29 } from "node:path";
+import { join as join28 } from "node:path";
 import {
   closeCaptureSession as closeCaptureSession7,
   cloneCaptureWarnings as cloneCaptureWarnings2,
@@ -11655,7 +11655,7 @@ function createHdrImageTransferCache(options = {}) {
 }
 
 // src/services/render/stages/captureHdrSequentialLoop.ts
-import { join as join26 } from "node:path";
+import { join as join25 } from "node:path";
 import {
   TRANSITIONS,
   crossfade
@@ -11780,7 +11780,7 @@ async function runSequentialLayeredFrameLoop(input) {
       );
       if (debugDumpEnabled && debugDumpDir && i % 30 === 0) {
         writeFileExclusiveSync(
-          join26(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
+          join25(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
           normalCanvas
         );
       }
@@ -11812,7 +11812,7 @@ async function runSequentialLayeredFrameLoop(input) {
 }
 
 // src/services/render/stages/captureHdrHybridLoop.ts
-import { join as join28 } from "node:path";
+import { join as join27 } from "node:path";
 import {
   TRANSITIONS as TRANSITIONS2,
   closeCaptureSession as closeCaptureSession6,
@@ -11826,7 +11826,7 @@ import {
 // src/services/shaderTransitionWorkerPool.ts
 import { Worker } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
-import { dirname as dirname11, join as join27 } from "node:path";
+import { dirname as dirname11, join as join26 } from "node:path";
 import { createRequire } from "node:module";
 import { existsSync as existsSync18 } from "node:fs";
 import { cpus as cpus2 } from "node:os";
@@ -11840,9 +11840,9 @@ function resolveWorkerEntry(explicit) {
     return { path: override, isTs };
   }
   const moduleDir = dirname11(fileURLToPath3(import.meta.url));
-  const jsPath = join27(moduleDir, "shaderTransitionWorker.js");
+  const jsPath = join26(moduleDir, "shaderTransitionWorker.js");
   if (existsSync18(jsPath)) return { path: jsPath, isTs: false };
-  const tsPath = join27(moduleDir, "shaderTransitionWorker.ts");
+  const tsPath = join26(moduleDir, "shaderTransitionWorker.ts");
   return { path: tsPath, isTs: true };
 }
 function buildExecArgv(entryIsTs) {
@@ -12210,7 +12210,7 @@ async function runHybridLayeredFrameLoop(input) {
           );
           if (debugDumpEnabled && debugDumpDir && i % 30 === 0) {
             writeFileExclusiveSync(
-              join28(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
+              join27(debugDumpDir, `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`),
               canvas
             );
           }
@@ -12401,7 +12401,7 @@ async function runCaptureHdrStage(input) {
         if (hdrVideoFrameSources.has(v.id)) hdrVideoEndTimes.set(v.id, v.end);
       }
       const debugDumpEnabled = process.env.KEEP_TEMP === "1";
-      const debugDumpDir = debugDumpEnabled ? join29(framesDir, "debug-composite") : null;
+      const debugDumpDir = debugDumpEnabled ? join28(framesDir, "debug-composite") : null;
       if (debugDumpDir && !existsSync19(debugDumpDir)) {
         mkdirSync10(debugDumpDir, { recursive: true });
       }
@@ -12568,7 +12568,7 @@ import {
   writeFileSync as writeFileSync6
 } from "node:fs";
 import { readFile as readFile2 } from "node:fs/promises";
-import { dirname as dirname12, join as join30 } from "node:path";
+import { dirname as dirname12, join as join29 } from "node:path";
 import {
   encodeFramesChunkedConcat,
   encodeFramesFromDir,
@@ -12779,7 +12779,7 @@ function encodeWhileCapturing(input, totalFrames) {
         await new Promise((resolve13) => wake = resolve13);
       }
       if (signal.aborted) return;
-      const mergedPath = join30(input.framesDir, formatCaptureFrameName(next, "jpg"));
+      const mergedPath = join29(input.framesDir, formatCaptureFrameName(next, "jpg"));
       const frame = await readLandedFrame(landed.get(next), mergedPath);
       landed.delete(next);
       if (!await stream.writeFrame(frame)) {
@@ -12862,11 +12862,11 @@ async function runEncodeStage(input) {
       );
     }
     captured.forEach((name, i) => {
-      const dst = join30(outputPath, formatExportFrameName(i, "png"));
-      copyFileSync4(join30(framesDir, name), dst);
+      const dst = join29(outputPath, formatExportFrameName(i, "png"));
+      copyFileSync4(join29(framesDir, name), dst);
     });
     if (hasAudio && audioOutputPath && existsSync20(audioOutputPath)) {
-      copyFileSync4(audioOutputPath, join30(outputPath, MIXED_AUDIO_FILENAME2));
+      copyFileSync4(audioOutputPath, join29(outputPath, MIXED_AUDIO_FILENAME2));
       log.info(
         `[Render] png-sequence: ${MIXED_AUDIO_FILENAME2} sidecar written to ${outputPath}/${MIXED_AUDIO_FILENAME2}`
       );
@@ -12886,7 +12886,7 @@ async function runEncodeStage(input) {
     const encodeResult2 = await encodeGifFromDir(framesDir, framePattern2, outputPath, {
       fps: job.config.fps,
       loop,
-      palettePath: join30(dirname12(videoOnlyPath), "gif-palette.png"),
+      palettePath: join29(dirname12(videoOnlyPath), "gif-palette.png"),
       preserveAlpha: needsAlpha,
       signal: abortSignal,
       timeout: engineCfg.ffmpegEncodeTimeout
@@ -13097,7 +13097,7 @@ function sampleDirectoryBytes(dir) {
       continue;
     }
     for (const name of entries) {
-      const full = join31(current, name);
+      const full = join30(current, name);
       try {
         const st = statSync9(full);
         if (st.isDirectory()) {
@@ -13253,7 +13253,7 @@ function findMissingFrameRanges(totalFrames, framesDir, frameExt) {
   const ranges = [];
   let rangeStart = null;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
-    const framePath = join31(framesDir, formatCaptureFrameName(frameIndex, frameExt));
+    const framePath = join30(framesDir, formatCaptureFrameName(frameIndex, frameExt));
     const missing = !existsSync21(framePath) || statSync9(framePath).size <= 8;
     if (missing && rangeStart === null) {
       rangeStart = frameIndex;
@@ -13270,7 +13270,7 @@ function findMissingFrameRanges(totalFrames, framesDir, frameExt) {
 function buildMissingFrameRetryBatches(ranges, maxWorkers, workDir, attempt, rangeStart = 0, stride = 1) {
   const workersPerBatch = Math.max(1, Math.floor(maxWorkers));
   const batches = [];
-  const outputDirFor = (batchIndex, workerId) => join31(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`);
+  const outputDirFor = (batchIndex, workerId) => join30(workDir, `retry-${attempt}-batch-${batchIndex}-worker-${workerId}`);
   if (stride > 1) {
     const spans = /* @__PURE__ */ new Map();
     for (const range of ranges) {
@@ -13330,8 +13330,8 @@ function getNextRetryWorkerCount(currentWorkers) {
   return Math.max(1, Math.floor(currentWorkers / 2));
 }
 function resolveRenderWorkDirPrefix(outputPath, jobId, platform2 = process.platform, systemTempDir = tmpdir2()) {
-  if (platform2 === "win32" || platform2 === "darwin") return join31(systemTempDir, "hf-render-");
-  return join31(dirname13(outputPath), `work-${jobId}-`);
+  if (platform2 === "win32" || platform2 === "darwin") return join30(systemTempDir, "hf-render-");
+  return join30(dirname13(outputPath), `work-${jobId}-`);
 }
 var MAX_TRANSIENT_CAPTURE_RETRIES = 1;
 function isTransientCaptureRetryEligible(failureKind, missing, retriesUsed) {
@@ -13378,7 +13378,7 @@ The composition is too large for the available memory. To reduce memory pressure
 function countCapturedFrames(totalFrames, framesDir, frameExt) {
   let captured = 0;
   for (let frameIndex = 0; frameIndex < totalFrames; frameIndex++) {
-    const framePath = join31(framesDir, formatCaptureFrameName(frameIndex, frameExt));
+    const framePath = join30(framesDir, formatCaptureFrameName(frameIndex, frameExt));
     if (existsSync21(framePath)) captured++;
   }
   return captured;
@@ -13404,7 +13404,7 @@ async function executeDiskCaptureWithAdaptiveRetry(options) {
       reason: attempt === 0 ? "initial" : pendingTransientRetry ? "transient-retry" : "retry"
     });
     pendingTransientRetry = false;
-    const attemptWorkDir = join31(options.workDir, `capture-attempt-${attempt}`);
+    const attemptWorkDir = join30(options.workDir, `capture-attempt-${attempt}`);
     const batches = missingRanges ? buildMissingFrameRetryBatches(
       missingRanges,
       currentWorkers,
@@ -14037,7 +14037,7 @@ function deVerifyFallbackTelemetry(err) {
 }
 function resolveRenderDebugDir() {
   const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve8(process.env.PRODUCER_RENDERS_DIR, "..") : resolve8(dirname13(fileURLToPath4(import.meta.url)), "../..");
-  return join31(producerRoot, ".debug");
+  return join30(producerRoot, ".debug");
 }
 async function executeRenderJob(job, projectDir, outputPath, progressSink, abortSignal, assertRenderActive) {
   validateHlsRenderConfig(job.config);
@@ -14045,10 +14045,10 @@ async function executeRenderJob(job, projectDir, outputPath, progressSink, abort
   const debugDir = resolveRenderDebugDir();
   const outputDir = dirname13(outputPath);
   if (!existsSync21(outputDir)) mkdirSync12(outputDir, { recursive: true });
-  const workDir = job.config.debug ? join31(debugDir, job.id) : createRenderWorkDir(resolveRenderWorkDirPrefix(outputPath, job.id), outputDir);
+  const workDir = job.config.debug ? join30(debugDir, job.id) : createRenderWorkDir(resolveRenderWorkDirPrefix(outputPath, job.id), outputDir);
   const pipelineStart = Date.now();
   const baseLog = job.config.logger ?? defaultLogger;
-  const logPath = job.config.debug ? join31(workDir, "render.log") : null;
+  const logPath = job.config.debug ? join30(workDir, "render.log") : null;
   const execution = new RenderExecutionContext({
     request: { renderJobId: job.id, projectDir, outputPath },
     logger: logPath ? createRenderFileLogger(logPath, baseLog) : baseLog,
@@ -14110,7 +14110,7 @@ async function executeRenderPipeline(input) {
     imageDecodeFailures: 0
   };
   let hdrPerf;
-  const perfOutputPath = join31(workDir, "perf-summary.json");
+  const perfOutputPath = join30(workDir, "perf-summary.json");
   const cfg = { ...job.config.producerConfig ?? resolveConfig2() };
   const observability = new RenderObservabilityRecorder({
     pipelineStartMs: pipelineStart,
@@ -14215,7 +14215,7 @@ async function executeRenderPipeline(input) {
       requestedWorkers: job.config.workers ?? "auto"
     });
     const entryFile = job.config.entryFile || "index.html";
-    const htmlPath = join31(projectDir, entryFile);
+    const htmlPath = join30(projectDir, entryFile);
     if (!existsSync21(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
@@ -14392,7 +14392,7 @@ async function executeRenderPipeline(input) {
           canvas: { width, height },
           page: probeSession.page,
           projectDir,
-          compiledDir: join31(workDir, "compiled")
+          compiledDir: join30(workDir, "compiled")
         });
         if (videoLayerPlan.videoId === void 0) {
           log.info(`[Render] Video layer passthrough off: ${videoLayerPlan.reason}`);
@@ -14410,7 +14410,7 @@ async function executeRenderPipeline(input) {
     updateJobStatus(job, "preprocessing", "Extracting video frames", 10, onProgress, {
       code: "extract_video"
     });
-    const compiledDir = join31(workDir, "compiled");
+    const compiledDir = join30(workDir, "compiled");
     const segmentsCapture = (layeredOrEffectRoute) => shouldSegmentCapture({
       env: process.env,
       durationSeconds: probeResult.duration,
@@ -14541,7 +14541,7 @@ async function executeRenderPipeline(input) {
       try {
         fileServer = await createFileServer({
           projectDir,
-          compiledDir: join31(workDir, "compiled"),
+          compiledDir: join30(workDir, "compiled"),
           port: 0,
           preHeadScripts: [VIRTUAL_TIME_SHIM],
           fps: job.config.fps
@@ -14559,7 +14559,7 @@ async function executeRenderPipeline(input) {
     if (!activeFileServer) {
       throw new Error("File server failed to initialize before frame capture");
     }
-    const framesDir = join31(workDir, "captured-frames");
+    const framesDir = join30(workDir, "captured-frames");
     if (!existsSync21(framesDir)) mkdirSync12(framesDir, { recursive: true });
     updateJobStatus(job, "rendering", "Checking browser GPU", 25, onProgress, {
       code: "start_browsers"
@@ -15123,7 +15123,7 @@ async function executeRenderPipeline(input) {
       hls: ".mp4"
     };
     const videoExt = FORMAT_EXT[outputFormat] ?? ".mp4";
-    const videoOnlyPath = join31(workDir, `video-only${videoExt}`);
+    const videoOnlyPath = join30(workDir, `video-only${videoExt}`);
     const usePageSideCompositingForTransitions = (cfg.enablePageSideCompositing || isGif) && compiled.hasShaderTransitions && !hasHdrContent && outputSupportsPageSideShaderCompositing(outputFormat);
     if (usePageSideCompositingForTransitions) {
       activeFileServer.addPreHeadScript(HF_PAGE_SIDE_COMPOSITING_STUB);
@@ -15409,7 +15409,7 @@ async function executeRenderPipeline(input) {
           pageMotionBlur: job.config.pageMotionBlur,
           captureQuality: captureOptions.quality
         });
-        const segmentDir = segmentDirFor(join31(projectDir, "renders"), segmentPlanHash);
+        const segmentDir = segmentDirFor(join30(projectDir, "renders"), segmentPlanHash);
         let completedSegments = /* @__PURE__ */ new Set();
         if (job.config.resumeSegments === true) {
           const existing = readSegmentManifest(segmentDir);
@@ -16032,7 +16032,7 @@ async function executeRenderPipeline(input) {
     }
     if (job.config.debug) {
       if (!isPngSequence && !isHls && existsSync21(stagedOutputPath)) {
-        const debugOutput = join31(workDir, `output${videoExt}`);
+        const debugOutput = join30(workDir, `output${videoExt}`);
         copyFileSync5(stagedOutputPath, debugOutput);
       }
     }
@@ -16146,16 +16146,17 @@ import {
   REFERENCE_BACKGROUND_FIELD as REFERENCE_BACKGROUND_FIELD4,
   referenceBackgroundResult as referenceBackgroundResult6
 } from "@hyperframes/engine";
-import { mkdirSync as mkdirSync20, mkdtempSync as mkdtempSync7, readFileSync as readFileSync14, rmSync as rmSync18 } from "node:fs";
-import { join as join45 } from "node:path";
+import { mkdirSync as mkdirSync20, mkdtempSync, readFileSync as readFileSync14, rmSync as rmSync18 } from "node:fs";
+import { join as join44 } from "node:path";
 import { tmpdir as tmpdir4 } from "node:os";
 
 // src/services/distributed/mp4Stitch.ts
-import { createReadStream as createReadStream3, createWriteStream, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync4, rmSync as rmSync13 } from "node:fs";
+import { createReadStream as createReadStream3, createWriteStream, mkdirSync as mkdirSync13, rmSync as rmSync13 } from "node:fs";
 import { open } from "node:fs/promises";
 import { renameWithRetry as renameWithRetry7 } from "@hyperframes/engine";
-import { dirname as dirname14, join as join32 } from "node:path";
+import { basename as basename7, dirname as dirname14, join as join31 } from "node:path";
 import { finished, pipeline } from "node:stream/promises";
+import { createStagingDir as createStagingDir4 } from "@hyperframes/core/atomic-file";
 function boxAt(src, off, at, limit) {
   let size = src.readUInt32BE(off);
   let bodyStart = at + 8;
@@ -16519,14 +16520,14 @@ async function writeStitchedMp4(chunkPaths, outputPath, audioPath) {
   const layouts = await Promise.all(sourcePaths.map((path) => readMp4Layout(fileRange(path))));
   const header = audioPath ? buildStitchedHeader(layouts.slice(1), layouts[0]) : buildStitchedHeader(layouts);
   mkdirSync13(dirname14(outputPath), { recursive: true });
-  const workDir = mkdtempSync4(`${outputPath}.stitch-`);
-  const out = createWriteStream(join32(workDir, "out.mp4"));
+  const workDir = createStagingDir4(dirname14(outputPath), `${basename7(outputPath)}.stitch-`);
+  const out = createWriteStream(join31(workDir, "out.mp4"));
   try {
     out.write(header);
     for (const [i, path] of sourcePaths.entries()) await copyPayload(path, layouts[i], i, out);
     out.end();
     await finished(out);
-    renameWithRetry7(join32(workDir, "out.mp4"), outputPath);
+    renameWithRetry7(join31(workDir, "out.mp4"), outputPath);
   } finally {
     out.destroy();
     rmSync13(workDir, { recursive: true, force: true });
@@ -16549,7 +16550,7 @@ import {
   rmSync as rmSync14,
   writeFileSync as writeFileSync10
 } from "node:fs";
-import { extname as extname6, isAbsolute as isAbsolute3, join as join40, relative as relative5, sep as sep3 } from "node:path";
+import { extname as extname6, isAbsolute as isAbsolute3, join as join39, relative as relative5, sep as sep3 } from "node:path";
 import {
   fpsToNumber as fpsToNumber9,
   HF_COLOR_GRADING_ATTR as HF_COLOR_GRADING_ATTR2
@@ -16565,7 +16566,7 @@ import {
 } from "@hyperframes/engine";
 
 // src/services/distributed/planFrameCost.ts
-import { join as join35 } from "node:path";
+import { join as join34 } from "node:path";
 import {
   closeCaptureSession as closeCaptureSession9,
   createCaptureSession as createCaptureSession9,
@@ -16575,7 +16576,7 @@ import {
 
 // src/services/distributed/chunkFrames.ts
 import { existsSync as existsSync23, readdirSync as readdirSync7 } from "node:fs";
-import { extname as extname4, join as join34 } from "node:path";
+import { extname as extname4, join as join33 } from "node:path";
 import {
   compositionRequiresWebGpu as compositionRequiresWebGpu3,
   createVideoFrameInjector as createVideoFrameInjector3
@@ -16583,7 +16584,7 @@ import {
 
 // src/services/distributed/shared.ts
 import { execFile as execFileCallback } from "node:child_process";
-import { dirname as dirname15, join as join33 } from "node:path";
+import { dirname as dirname15, join as join32 } from "node:path";
 import { existsSync as existsSync22, readFileSync as readFileSync9 } from "node:fs";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { promisify as promisify2 } from "node:util";
@@ -16599,7 +16600,7 @@ function isPlanAudioArtifactPath(path) {
 }
 function resolvePlanAudioPath(planDir) {
   for (const name of [PLAN_AUDIO_RELATIVE_PATH, PLAN_AUDIO_LEGACY_RELATIVE_PATH]) {
-    const candidate = join33(planDir, name);
+    const candidate = join32(planDir, name);
     if (existsSync22(candidate)) return candidate;
   }
   return null;
@@ -16850,7 +16851,7 @@ function buildSyntheticRenderJob(input) {
     strictness: input.strictness,
     producerConfig: input.producerConfig,
     variables: input.variables,
-    pageMotionBlur: "off"
+    pageMotionBlur: input.pageMotionBlur
   };
   return createRenderJob(renderConfig);
 }
@@ -16860,7 +16861,7 @@ function readProducerVersion() {
   const startDir = dirname15(fileURLToPath5(import.meta.url));
   let current = startDir;
   for (let i = 0; i < 10; i++) {
-    const candidate = join33(current, "package.json");
+    const candidate = join32(current, "package.json");
     if (existsSync22(candidate)) {
       try {
         const pkg = JSON.parse(readFileSync9(candidate, "utf-8"));
@@ -16915,7 +16916,7 @@ function frameNumberFromFileName(name) {
 function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v1") {
   const result = [];
   for (const v of videos) {
-    const outputDir = join34(planDir, "video-frames", v.videoId);
+    const outputDir = join33(planDir, "video-frames", v.videoId);
     if (!existsSync23(outputDir)) {
       throw new Error(
         `[renderChunk] planDir missing extracted video frames for ${JSON.stringify(v.videoId)}: ${outputDir} not present. plan() should have written frames here; the planDir is malformed.`
@@ -16934,7 +16935,7 @@ function rebuildExtractedFramesFromPlanDir(planDir, videos, indexMode = "dense-v
       if (!frameName) continue;
       const frameNumber = indexMode === "sparse-v2" ? frameNumberFromFileName(frameName) : null;
       const frameIndex = frameNumber === null ? i : frameNumber - 1;
-      framePaths.set(frameIndex, join34(outputDir, frameName));
+      framePaths.set(frameIndex, join33(outputDir, frameName));
     }
     result.push({
       videoId: v.videoId,
@@ -16967,7 +16968,7 @@ function buildChunkCaptureOptions(input) {
     skipReadinessVideoIds: input.skipReadinessVideoIds,
     videoMetadataHints: input.videoMetadataHints,
     ...videoCaptureBeyondViewport !== void 0 ? { captureBeyondViewport: videoCaptureBeyondViewport } : {},
-    pageMotionBlur: encoder.pageMotionBlur ?? "distributed-render",
+    pageMotionBlur: encoder.pageMotionBlur,
     // A fixed warmup count keeps `beginFrameTimeTicks` host-independent.
     lockWarmupTicks: true,
     requiresWebGpu: compositionRequiresWebGpu3(input.html)
@@ -17014,7 +17015,7 @@ async function extractDeferredVideoFramesForChunk(input) {
     sourceOf: (video) => {
       const range = planned.get(video.videoId).deferredRange;
       const remoteUrl = remoteSources[range.sourcePath];
-      const sourcePath = remoteUrl ?? join34(input.planDir, ...range.sourcePath.split("/"));
+      const sourcePath = remoteUrl ?? join33(input.planDir, ...range.sourcePath.split("/"));
       if (remoteUrl === void 0 && !existsSync23(sourcePath)) {
         throw new RenderChunkValidationError(
           MISSING_PLAN_ARTIFACT,
@@ -17045,12 +17046,12 @@ async function measurePlanSecondsPerFrame(input) {
       planVideos,
       frames: sampled,
       fps: fpsRatio,
-      outputRoot: join35(workDir, "frame-cost-video-frames"),
+      outputRoot: join34(workDir, "frame-cost-video-frames"),
       cfg: input.cfg
     })
   ];
   const lookup = extracted.length > 0 ? createFrameLookupTable4(planVideos.videos, extracted, resolveRenderFpsConfig(fpsRatio).value) : null;
-  const compiledDir = join35(planDir, "compiled");
+  const compiledDir = join34(planDir, "compiled");
   const fileServer = await createFileServer({
     projectDir: compiledDir,
     compiledDir,
@@ -17062,7 +17063,7 @@ async function measurePlanSecondsPerFrame(input) {
   try {
     session = await createCaptureSession9(
       fileServer.url,
-      join35(workDir, "frame-cost"),
+      join34(workDir, "frame-cost"),
       buildChunkCaptureOptions({
         dimensions: { ...input, fpsNum: fps, fpsDen: 1 },
         encoder: input,
@@ -17159,7 +17160,7 @@ function buildWeightedChunkSlices(weights, chunkCount, minFrames, maxFrames) {
 }
 
 // src/services/render/planReferenceBackground.ts
-import { join as join36 } from "node:path";
+import { join as join35 } from "node:path";
 import {
   closeCaptureSession as closeCaptureSession10,
   createCaptureSession as createCaptureSession10,
@@ -17172,14 +17173,14 @@ async function readPlanReferenceBackground(input) {
   try {
     server = await createFileServer({
       projectDir: input.projectDir,
-      compiledDir: join36(input.workDir, "compiled"),
+      compiledDir: join35(input.workDir, "compiled"),
       port: 0,
       preHeadScripts: [VIRTUAL_TIME_SHIM],
       fps: input.options.fps
     });
     session = await createCaptureSession10(
       server.url,
-      join36(input.workDir, "reference"),
+      join35(input.workDir, "reference"),
       {
         ...input.options,
         requiresWebGpu: false
@@ -17216,7 +17217,7 @@ async function readPlanReferenceBackground(input) {
 
 // src/services/render/stages/freezePlan.ts
 import { existsSync as existsSync24, mkdirSync as mkdirSync14, readFileSync as readFileSync10, readdirSync as readdirSync8, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join37, relative as relative3, resolve as resolve9 } from "node:path";
+import { join as join36, relative as relative3, resolve as resolve9 } from "node:path";
 import {
   REFERENCE_BACKGROUND_FIELD,
   referenceBackgroundResult as referenceBackgroundResult3
@@ -17434,7 +17435,7 @@ function listPlanFiles(planDir) {
   function walk(dir) {
     const entries = readdirSync8(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = join37(dir, entry.name);
+      const full = join36(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full);
       } else if (entry.isFile()) {
@@ -17475,15 +17476,15 @@ var PLAN_REMOTE_FILES_RELATIVE_PATH = "meta/remote-files.json";
 function writePlanRemoteFiles(planDir, files) {
   if (files.length === 0) return;
   const sorted = [...files].sort((a, b) => a.path < b.path ? -1 : 1);
-  writeFileSync8(join37(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH), JSON.stringify(sorted), "utf-8");
+  writeFileSync8(join36(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH), JSON.stringify(sorted), "utf-8");
 }
 function readPlanRemoteFiles(planDir) {
-  const path = join37(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH);
+  const path = join36(planDir, PLAN_REMOTE_FILES_RELATIVE_PATH);
   return existsSync24(path) ? JSON.parse(readFileSync10(path, "utf-8")) : [];
 }
 function recomputePlanHashFromPlanDir(planDir, digests) {
-  const planJsonPath = join37(planDir, "plan.json");
-  const encoderJsonPath = join37(planDir, "meta", "encoder.json");
+  const planJsonPath = join36(planDir, "plan.json");
+  const encoderJsonPath = join36(planDir, "meta", "encoder.json");
   if (!existsSync24(planJsonPath)) {
     throw new Error(`[freezePlan] plan.json missing: ${planJsonPath}`);
   }
@@ -17520,18 +17521,18 @@ async function freezePlan(input) {
   if (!existsSync24(planDir)) {
     throw new Error(`[freezePlan] planDir does not exist: ${planDir}`);
   }
-  const metaDir = join37(planDir, "meta");
+  const metaDir = join36(planDir, "meta");
   if (!existsSync24(metaDir)) mkdirSync14(metaDir, { recursive: true });
   writeFileSync8(
-    join37(metaDir, "composition.json"),
+    join36(metaDir, "composition.json"),
     `${JSON.stringify(composition, null, 2)}
 `,
     "utf-8"
   );
   const encoderForCanonical = stripUndefined(encoder);
   const encoderConfigCanonicalJson = canonicalJsonStringify(encoderForCanonical);
-  writeFileSync8(join37(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
-  writeFileSync8(join37(metaDir, "chunks.json"), `${JSON.stringify(chunks, null, 2)}
+  writeFileSync8(join36(metaDir, "encoder.json"), encoderConfigCanonicalJson, "utf-8");
+  writeFileSync8(join36(metaDir, "chunks.json"), `${JSON.stringify(chunks, null, 2)}
 `, "utf-8");
   const { compositionHtml, assets } = collectPlanAssetShas(planDir, digests);
   const planHash = computePlanHash({
@@ -17556,7 +17557,7 @@ async function freezePlan(input) {
     duration: durationSeconds,
     hasAudio
   };
-  const planJsonPath = join37(planDir, "plan.json");
+  const planJsonPath = join36(planDir, "plan.json");
   writeFileSync8(planJsonPath, `${JSON.stringify(planJson, null, 2)}
 `, "utf-8");
   return { planJsonPath, planHash };
@@ -17600,7 +17601,7 @@ function applyRuntimeEnvSnapshot(snapshot, env = process.env) {
 // src/services/distributed/chunkAudio.ts
 import { closeSync as closeSync6, existsSync as existsSync25, ftruncateSync, mkdirSync as mkdirSync15, openSync as openSync6, readFileSync as readFileSync11 } from "node:fs";
 import { writeFileSync as writeFileSync9, writeSync } from "node:fs";
-import { join as join38 } from "node:path";
+import { join as join37 } from "node:path";
 import { appendRenderProvenanceArgs, describeFfmpegFailure as describeFfmpegFailure4, runFfmpeg as runFfmpeg7 } from "@hyperframes/engine";
 function audioCutForChunk(grid, chunks, index, fps) {
   const firstPacketAt = (frame) => Math.min(
@@ -17688,7 +17689,7 @@ async function writeChunkAudioSlices(input) {
   });
   const bytes = readFileSync11(input.audioPath);
   const layout = { sizeBytes: bytes.length, payloadStart, payloadEnd, partStarts: {} };
-  mkdirSync15(join38(input.planDir, SLICE_DIR), { recursive: true });
+  mkdirSync15(join37(input.planDir, SLICE_DIR), { recursive: true });
   input.chunks.forEach((_, index) => {
     const cut = audioCutForChunk(grid, input.chunks, index, input.fps);
     if (!cut) return;
@@ -17696,17 +17697,17 @@ async function writeChunkAudioSlices(input) {
     const start = offsets[cut.firstPacket];
     layout.partStarts[index] = start;
     const end = offsets[last] + track.sizes[last];
-    writeFileSync9(join38(input.planDir, chunkAudioSlicePath(index)), bytes.subarray(start, end));
+    writeFileSync9(join37(input.planDir, chunkAudioSlicePath(index)), bytes.subarray(start, end));
   });
   const frame = [bytes.subarray(0, payloadStart), bytes.subarray(payloadEnd)];
-  writeFileSync9(join38(input.planDir, SLICE_FRAME), Buffer.concat(frame));
-  writeFileSync9(join38(input.planDir, SLICE_LAYOUT), JSON.stringify(layout));
+  writeFileSync9(join37(input.planDir, SLICE_FRAME), Buffer.concat(frame));
+  writeFileSync9(join37(input.planDir, SLICE_LAYOUT), JSON.stringify(layout));
 }
 function chunkAudioSource(planDir, chunkIndex, scratchPath) {
-  const layoutPath = join38(planDir, SLICE_LAYOUT);
+  const layoutPath = join37(planDir, SLICE_LAYOUT);
   if (!existsSync25(layoutPath)) return resolvePlanAudioPath(planDir);
   const layout = JSON.parse(readFileSync11(layoutPath, "utf-8"));
-  const frame = readFileSync11(join38(planDir, SLICE_FRAME));
+  const frame = readFileSync11(join37(planDir, SLICE_FRAME));
   const fd = openSync6(scratchPath, "w");
   try {
     writeSync(fd, frame, 0, layout.payloadStart, 0);
@@ -17719,7 +17720,7 @@ function chunkAudioSource(planDir, chunkIndex, scratchPath) {
     );
     const start = layout.partStarts[chunkIndex];
     if (start !== void 0) {
-      const part = readFileSync11(join38(planDir, chunkAudioSlicePath(chunkIndex)));
+      const part = readFileSync11(join37(planDir, chunkAudioSlicePath(chunkIndex)));
       writeSync(fd, part, 0, part.length, start);
     }
     ftruncateSync(fd, layout.sizeBytes);
@@ -17775,7 +17776,7 @@ async function muxChunkWithAudio(input) {
 // src/services/distributed/planSize.ts
 import { createHash as createHash9 } from "node:crypto";
 import { lstatSync as lstatSync2, readdirSync as readdirSync9 } from "node:fs";
-import { extname as extname5, join as join39, relative as relative4 } from "node:path";
+import { extname as extname5, join as join38, relative as relative4 } from "node:path";
 var MAX_TOP_COMPONENTS = 10;
 var SOURCE_MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
   ".aac",
@@ -17887,7 +17888,7 @@ function walkRegularFiles(dir, visit) {
     return;
   }
   for (const entry of entries) {
-    const full = join39(dir, entry.name);
+    const full = join38(dir, entry.name);
     if (entry.isDirectory()) {
       walkRegularFiles(full, visit);
     } else if (entry.isFile()) {
@@ -18103,13 +18104,13 @@ function assertPositiveInteger2(name, value) {
 }
 var FREEZE_OWNED_PLAN_FILES = [
   "plan.json",
-  join40("meta", "composition.json"),
-  join40("meta", "encoder.json"),
-  join40("meta", "chunks.json")
+  join39("meta", "composition.json"),
+  join39("meta", "encoder.json"),
+  join39("meta", "chunks.json")
 ];
 function removeFreezeOwnedPlanFiles(planDir) {
   for (const relativePath of FREEZE_OWNED_PLAN_FILES) {
-    rmSync14(join40(planDir, relativePath), { force: true });
+    rmSync14(join39(planDir, relativePath), { force: true });
   }
 }
 function buildChunkSlices(totalFrames, chunkCount, effectiveChunkSize) {
@@ -18264,19 +18265,19 @@ function createVideoSourceShipper(input) {
     const known = shipped.get(srcPath);
     if (known) return known;
     const stagedRel = pathInside(input.workVideoFramesDir, srcPath);
-    const current = stagedRel === null ? srcPath : join40(input.planDir, "video-frames", stagedRel);
+    const current = stagedRel === null ? srcPath : join39(input.planDir, "video-frames", stagedRel);
     let result = null;
     for (const root of stagedRel === null ? [input.workCompiledDir, input.projectDir] : []) {
       const rel = pathInside(root, srcPath);
-      if (rel !== null && (existsSync26(join40(input.planDir, "compiled", rel)) || input.isRemote(srcPath))) {
+      if (rel !== null && (existsSync26(join39(input.planDir, "compiled", rel)) || input.isRemote(srcPath))) {
         result = ["compiled", ...rel.split(sep3)].join("/");
         break;
       }
     }
     if (result === null) {
       result = `video-sources/${shipped.size}${extname6(current)}`;
-      const destination = join40(input.planDir, ...result.split("/"));
-      mkdirSync16(join40(input.planDir, "video-sources"), { recursive: true });
+      const destination = join39(input.planDir, ...result.split("/"));
+      mkdirSync16(join39(input.planDir, "video-sources"), { recursive: true });
       try {
         linkSync(current, destination);
       } catch {
@@ -18322,17 +18323,18 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     entryFile: config.entryFile ?? "index.html",
     logger: config.logger,
     producerConfig: cfg,
-    variables: config.variables
+    variables: config.variables,
+    pageMotionBlur: config.pageMotionBlur
   });
   const entryFile = config.entryFile ?? "index.html";
-  const htmlPath = join40(projectDir, entryFile);
+  const htmlPath = join39(projectDir, entryFile);
   if (!existsSync26(htmlPath)) {
     throw new Error(`[plan] entry file not found: ${htmlPath}`);
   }
-  const workDir = join40(planDir, ".plan-work");
+  const workDir = join39(planDir, ".plan-work");
   rmSync14(workDir, { recursive: true, force: true });
   mkdirSync16(workDir, { recursive: true });
-  const compiledDir = join40(workDir, "compiled");
+  const compiledDir = join39(workDir, "compiled");
   mkdirSync16(compiledDir, { recursive: true });
   let stageStarted = Date.now();
   cpSync2(projectDir, compiledDir, {
@@ -18346,10 +18348,10 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
     }
   });
   logPlanStage(log, "copy", stageStarted);
-  const finalCompiledDir = join40(planDir, "compiled");
+  const finalCompiledDir = join39(planDir, "compiled");
   const needsAlpha = outputNeedsAlpha(config.format);
   const remoteFiles = Object.entries(options.remoteFiles ?? {});
-  const remoteLocalPath = (rel) => join40(projectDir, ...rel.split("/"));
+  const remoteLocalPath = (rel) => join39(projectDir, ...rel.split("/"));
   for (const [, file] of remoteFiles) {
     declareContentAddressedUrl(file.url, file.sha256);
     if (file.probeFactsUrl) declareProbeFactsUrl(file.url, file.probeFactsUrl);
@@ -18552,10 +18554,10 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   let stageStarted = Date.now();
   const extractResult = await extractPlanVideos(c, options.deferVideoExtraction);
   logPlanStage(log, "extract", stageStarted);
-  const stagedVideoFrames = join40(compiledDir, "__hyperframes_video_frames");
-  const videoFramesDst = join40(planDir, "video-frames");
+  const stagedVideoFrames = join39(compiledDir, "__hyperframes_video_frames");
+  const videoFramesDst = join39(planDir, "video-frames");
   if (existsSync26(videoFramesDst)) rmSync14(videoFramesDst, { recursive: true, force: true });
-  const videoSourcesDir = join40(planDir, "video-sources");
+  const videoSourcesDir = join39(planDir, "video-sources");
   rmSync14(videoSourcesDir, { recursive: true, force: true });
   if (existsSync26(stagedVideoFrames)) {
     renameWithRetry8(stagedVideoFrames, videoFramesDst);
@@ -18592,7 +18594,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
       };
     })
   });
-  mkdirSync16(join40(planDir, "meta"), { recursive: true });
+  mkdirSync16(join39(planDir, "meta"), { recursive: true });
   writePlanRemoteFiles(
     planDir,
     remoteFiles.map(([rel, { sha256, sizeBytes }]) => ({
@@ -18602,7 +18604,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
     }))
   );
   writeFileSync10(
-    join40(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
+    join39(planDir, PLAN_VIDEOS_META_RELATIVE_PATH),
     JSON.stringify(planVideosJson, null, 2),
     "utf-8"
   );
@@ -18682,7 +18684,7 @@ async function buildLocalExecutionPlan(projectDir, config, executionPlanDir, opt
   if (audioResult?.audioError) {
     applyDistributedAudioWarningPolicy(job, audioResult.audioError, audioResult.audioFailures, log);
   }
-  const planAudioPath = join40(planDir, PLAN_AUDIO_RELATIVE_PATH);
+  const planAudioPath = join39(planDir, PLAN_AUDIO_RELATIVE_PATH);
   if (audioResult?.hasAudio && existsSync26(audioResult.audioOutputPath)) {
     renameWithRetry8(audioResult.audioOutputPath, planAudioPath);
   }
@@ -18806,7 +18808,7 @@ async function plan(projectDir, config, planDir, options = {}) {
 import { randomBytes } from "node:crypto";
 import { existsSync as existsSync29, mkdirSync as mkdirSync19, readFileSync as readFileSync13, readdirSync as readdirSync11, rmSync as rmSync17, writeFileSync as writeFileSync13 } from "node:fs";
 import { cpus as cpus3 } from "node:os";
-import { join as join44 } from "node:path";
+import { join as join43 } from "node:path";
 import {
   assertSwiftShader,
   BROWSER_GPU_NOT_SOFTWARE as BROWSER_GPU_NOT_SOFTWARE4,
@@ -18834,7 +18836,6 @@ import {
   existsSync as existsSync28,
   lstatSync as lstatSync3,
   mkdirSync as mkdirSync18,
-  mkdtempSync as mkdtempSync6,
   readFileSync as readFileSync12,
   readdirSync as readdirSync10,
   rmSync as rmSync16,
@@ -18842,7 +18843,7 @@ import {
   writeFileSync as writeFileSync12
 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname17, isAbsolute as isAbsolute4, join as join43, relative as relative6, resolve as resolve10, sep as sep4 } from "node:path";
+import { dirname as dirname17, isAbsolute as isAbsolute4, join as join42, relative as relative6, resolve as resolve10, sep as sep4 } from "node:path";
 import { DISTRIBUTED_FPS, isDistributedFps } from "@hyperframes/core";
 import { createFrameLookupTable as createFrameLookupTable5, renameWithRetry as renameWithRetry10 } from "@hyperframes/engine";
 
@@ -18852,13 +18853,12 @@ import {
   existsSync as existsSync27,
   linkSync as linkSync2,
   mkdirSync as mkdirSync17,
-  mkdtempSync as mkdtempSync5,
   rmSync as rmSync15,
   statSync as statSync10,
   writeFileSync as writeFileSync11
 } from "node:fs";
 import { renameWithRetry as renameWithRetry9 } from "@hyperframes/engine";
-import { dirname as dirname16, join as join42 } from "node:path";
+import { dirname as dirname16, join as join41 } from "node:path";
 
 // src/services/distributed/planV2Errors.ts
 var PLAN_V2_INTEGRITY_UNRECOVERABLE = "PLAN_V2_INTEGRITY_UNRECOVERABLE";
@@ -18873,7 +18873,7 @@ var PlanV2IntegrityError = class extends Error {
 };
 
 // src/services/distributed/planV2Layout.ts
-import { join as join41 } from "node:path";
+import { join as join40 } from "node:path";
 var SHA256_PATTERN = /^[0-9a-f]{64}$/;
 function assertPlanV2Sha256(value, field) {
   if (typeof value !== "string" || !SHA256_PATTERN.test(value)) {
@@ -18883,10 +18883,11 @@ function assertPlanV2Sha256(value, field) {
 }
 function planV2BlobPath(root, sha256) {
   const digest = assertPlanV2Sha256(sha256, "artifact sha256");
-  return join41(root, "artifacts", "sha256", digest.slice(0, 2), digest);
+  return join40(root, "artifacts", "sha256", digest.slice(0, 2), digest);
 }
 
 // src/services/distributed/planV2Publisher.ts
+import { createStagingDir as createStagingDir5 } from "@hyperframes/core/atomic-file";
 function canFallbackToCopy(error) {
   if (!(error instanceof Error) || !("code" in error)) return false;
   const code = error.code;
@@ -18924,7 +18925,7 @@ var LocalPlanV2ArtifactPublisher = class {
     this.destinationDir = destinationDir;
     this.#linkFile = options.linkFile ?? linkSync2;
     mkdirSync17(dirname16(destinationDir), { recursive: true });
-    this.temporaryDir = mkdtempSync5(join42(dirname16(destinationDir), ".plan-v2-publish-"));
+    this.temporaryDir = createStagingDir5(dirname16(destinationDir), ".plan-v2-publish-");
   }
   async putBlob(blob) {
     const digest = assertPlanV2Sha256(blob.sha256, "published blob sha256");
@@ -18937,8 +18938,8 @@ var LocalPlanV2ArtifactPublisher = class {
     const destinationPath = planV2BlobPath(this.temporaryDir, digest);
     if (existsSync27(destinationPath)) return;
     mkdirSync17(dirname16(destinationPath), { recursive: true });
-    const stagingDir = mkdtempSync5(join42(dirname16(destinationPath), ".plan-v2-blob-"));
-    const temporaryPath = join42(stagingDir, "blob");
+    const stagingDir = createStagingDir5(dirname16(destinationPath), ".plan-v2-blob-");
+    const temporaryPath = join41(stagingDir, "blob");
     try {
       try {
         this.#linkFile(blob.sourcePath, temporaryPath);
@@ -18959,7 +18960,7 @@ var LocalPlanV2ArtifactPublisher = class {
         );
       }
     }
-    writeFileSync11(join42(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
+    writeFileSync11(join41(this.temporaryDir, "plan.json"), manifestBytes, "utf-8");
     renameWithRetry9(this.temporaryDir, this.destinationDir);
     this.#committed = true;
   }
@@ -18971,6 +18972,7 @@ var LocalPlanV2ArtifactPublisher = class {
 };
 
 // src/services/distributed/planV2.ts
+import { createStagingDir as createStagingDir6 } from "@hyperframes/core/atomic-file";
 var PLAN_V2_HASH_PREFIX = "hyperframes-plan-manifest-hash-v2\0";
 var EXTRACTION_CACHE_COMPLETE_SENTINEL = ".hf-complete";
 var PLAN_V2_MATERIALIZATION_MARKER = ".hyperframes-plan-v2.json";
@@ -19004,7 +19006,7 @@ function listFiles(root) {
   const rootResolved = resolve10(root);
   function walk(dir) {
     for (const entry of readdirSync10(dir, { withFileTypes: true })) {
-      const absolutePath = join43(dir, entry.name);
+      const absolutePath = join42(dir, entry.name);
       if (entry.isDirectory()) {
         walk(absolutePath);
       } else if (entry.isFile()) {
@@ -19031,13 +19033,13 @@ function assertValidExtractionCacheCompleteSentinel(path) {
   }
 }
 function validateExtractionCacheCompleteSentinels(executionPlanDir) {
-  const videoRoot = join43(executionPlanDir, "video-frames");
+  const videoRoot = join42(executionPlanDir, "video-frames");
   if (!existsSync28(videoRoot)) return;
   for (const videoEntry of readdirSync10(videoRoot, { withFileTypes: true })) {
     if (!videoEntry.isDirectory()) continue;
-    const videoDir = join43(videoRoot, videoEntry.name);
+    const videoDir = join42(videoRoot, videoEntry.name);
     if (readdirSync10(videoDir).includes(EXTRACTION_CACHE_COMPLETE_SENTINEL)) {
-      const sentinelPath = join43(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
+      const sentinelPath = join42(videoDir, EXTRACTION_CACHE_COMPLETE_SENTINEL);
       assertValidExtractionCacheCompleteSentinel(sentinelPath);
     }
   }
@@ -19084,7 +19086,7 @@ function listVideoFramePaths(executionPlanDir, videos) {
     if (video.deferredRange) {
       const framePaths2 = /* @__PURE__ */ new Map();
       for (let index = 0; index < video.totalFrames; index++) {
-        framePaths2.set(index, join43(outputDir, String(index)));
+        framePaths2.set(index, join42(outputDir, String(index)));
       }
       return { ...video, outputDir, framePaths: framePaths2, ownedByLookup: false };
     }
@@ -19092,7 +19094,7 @@ function listVideoFramePaths(executionPlanDir, videos) {
     const framePaths = /* @__PURE__ */ new Map();
     for (const frameName of frameNames) {
       if (frameName === EXTRACTION_CACHE_COMPLETE_SENTINEL) {
-        assertValidExtractionCacheCompleteSentinel(join43(outputDir, frameName));
+        assertValidExtractionCacheCompleteSentinel(join42(outputDir, frameName));
         continue;
       }
       const match = /(\d+)(?=\.[^.]+$)/.exec(frameName);
@@ -19111,7 +19113,7 @@ function listVideoFramePaths(executionPlanDir, videos) {
           `duplicate extracted frame index ${frameIndex} in ${outputDir}`
         );
       }
-      framePaths.set(frameIndex, join43(outputDir, frameName));
+      framePaths.set(frameIndex, join42(outputDir, frameName));
     }
     return {
       ...video,
@@ -19132,7 +19134,7 @@ function parsePlanVideosJson2(value) {
   }
 }
 function materializeExtractedVideoDirectories(planDir) {
-  const videosPath = join43(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  const videosPath = join42(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   if (!existsSync28(videosPath)) return;
   const videos = parsePlanVideosJson2(readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH));
   for (const video of videos.extracted) {
@@ -19166,13 +19168,13 @@ function parseChunkSlices(value) {
   });
 }
 function buildVideoChunkDependencies(executionPlanDir, dimensions) {
-  const videoRoot = join43(executionPlanDir, "video-frames");
+  const videoRoot = join42(executionPlanDir, "video-frames");
   const hasExtractedFrames = existsSync28(videoRoot) && listFiles(videoRoot).length > 0;
-  const videosPath = join43(executionPlanDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  const videosPath = join42(executionPlanDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   if (!existsSync28(videosPath)) {
     return hasExtractedFrames ? { mode: "full-source-pack", dependencies: null } : { mode: "exact-rendered-frames", dependencies: /* @__PURE__ */ new Map() };
   }
-  const chunksPath = join43(executionPlanDir, "meta", "chunks.json");
+  const chunksPath = join42(executionPlanDir, "meta", "chunks.json");
   const videos = readJsonFile(videosPath, PLAN_VIDEOS_META_RELATIVE_PATH);
   const chunks = readJsonFile(chunksPath, "meta/chunks.json");
   const parsedVideos = parsePlanVideosJson2(videos);
@@ -19228,8 +19230,8 @@ function computeManifestHash(manifest) {
 function writeBlob(sourcePath, destinationPath) {
   if (existsSync28(destinationPath)) return;
   mkdirSync18(dirname17(destinationPath), { recursive: true });
-  const temporaryDir = mkdtempSync6(join43(dirname17(destinationPath), ".plan-v2-blob-"));
-  const temporaryPath = join43(temporaryDir, "blob");
+  const temporaryDir = createStagingDir6(dirname17(destinationPath), ".plan-v2-blob-");
+  const temporaryPath = join42(temporaryDir, "blob");
   try {
     copyFileSync8(sourcePath, temporaryPath);
     renameWithRetry10(temporaryPath, destinationPath);
@@ -19265,7 +19267,7 @@ async function putTasks(tasks) {
   if (failure) throw failure.reason;
 }
 function buildPlanV2Publication(executionPlanDir, digests) {
-  const executionPlanPath = join43(executionPlanDir, "plan.json");
+  const executionPlanPath = join42(executionPlanDir, "plan.json");
   if (!existsSync28(executionPlanPath)) {
     throw new PlanV2IntegrityError(`execution plan is missing plan.json: ${executionPlanPath}`);
   }
@@ -19293,7 +19295,7 @@ function buildPlanV2Publication(executionPlanDir, digests) {
   }
   validateExtractionCacheCompleteSentinels(executionPlanDir);
   const videoDependencyPlan = buildVideoChunkDependencies(executionPlanDir, dimensions);
-  const encoder = readJsonFile(join43(executionPlanDir, "meta", "encoder.json"), "meta/encoder.json");
+  const encoder = readJsonFile(join42(executionPlanDir, "meta", "encoder.json"), "meta/encoder.json");
   const files = listFiles(executionPlanDir);
   const chunkAudio = !isRecord3(encoder) || encoder.chunksCarryAudio !== true ? "none" : files.some((file) => chunkAudioSliceTarget(file.path) !== null) ? "sliced" : "whole";
   for (const file of files) {
@@ -19354,13 +19356,13 @@ function createPlanV2FromExecutionPlan(executionPlanDir, planV2Dir) {
     throw new PlanV2IntegrityError("a local plan v2 directory cannot reference remote files");
   }
   mkdirSync18(dirname17(planV2Dir), { recursive: true });
-  const tempDir = mkdtempSync6(join43(dirname17(planV2Dir), ".plan-v2-build-"));
+  const tempDir = createStagingDir6(dirname17(planV2Dir), ".plan-v2-build-");
   try {
     for (const blob of publication.blobs) {
       writeBlob(blob.sourcePath, planV2BlobPath(tempDir, blob.sha256));
     }
     writeFileSync12(
-      join43(tempDir, "plan.json"),
+      join42(tempDir, "plan.json"),
       canonicalJsonStringify(publication.manifest),
       "utf-8"
     );
@@ -19401,7 +19403,7 @@ async function publishExecutionPlan(executionPlanDir, publisher, { digests, log
   }
 }
 async function planV2WithPublisher(projectDir, config, publisher, options = {}) {
-  const stagingRoot = mkdtempSync6(join43(options.stagingParentDir ?? tmpdir3(), ".execution-plan-"));
+  const stagingRoot = createStagingDir6(options.stagingParentDir ?? tmpdir3(), ".execution-plan-");
   const digests = /* @__PURE__ */ new Map();
   try {
     await buildLocalExecutionPlan(projectDir, config, stagingRoot, {
@@ -19412,7 +19414,7 @@ async function planV2WithPublisher(projectDir, config, publisher, options = {})
       // artifactTargets ships every compiled/ file to all chunks, so each is in the manifest.
       whileAudioMixes: () => putBlobs(
         publisher,
-        listFiles(join43(stagingRoot, "compiled")).map(
+        listFiles(join42(stagingRoot, "compiled")).map(
           (file) => publishBlobFor(file.absolutePath, digests)
         )
       ),
@@ -19449,7 +19451,7 @@ function resultFromManifest(planV2Dir, manifest) {
       isRecord3(executionPlan) ? executionPlan[REFERENCE_BACKGROUND_FIELD3] : void 0
     ),
     planDir: planV2Dir,
-    manifestPath: join43(planV2Dir, "plan.json"),
+    manifestPath: join42(planV2Dir, "plan.json"),
     planProtocol: PLAN_PROTOCOL_V2,
     planHash: manifest.planHash,
     sourcePlanV1Hash: getPlanV2ExecutionPlanHash(manifest),
@@ -19585,7 +19587,7 @@ function parsePlanV2Manifest(value) {
   return parsed;
 }
 function readPlanV2Manifest(planV2Dir) {
-  const manifestPath = join43(planV2Dir, "plan.json");
+  const manifestPath = join42(planV2Dir, "plan.json");
   if (!existsSync28(manifestPath)) {
     throw new PlanV2IntegrityError(`missing v2 manifest: ${manifestPath}`);
   }
@@ -19631,16 +19633,16 @@ function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}
     sourcePath: verifyBlob(planV2Dir, artifact)
   }));
   mkdirSync18(dirname17(destinationDir), { recursive: true });
-  const tempDir = mkdtempSync6(join43(dirname17(destinationDir), ".plan-v2-materialize-"));
+  const tempDir = createStagingDir6(dirname17(destinationDir), ".plan-v2-materialize-");
   try {
     for (const { artifact, sourcePath } of verified) {
-      const destinationPath = join43(tempDir, ...artifact.path.split("/"));
+      const destinationPath = join42(tempDir, ...artifact.path.split("/"));
       mkdirSync18(dirname17(destinationPath), { recursive: true });
       copyFileSync8(sourcePath, destinationPath);
     }
     if (target.role === "chunk") materializeExtractedVideoDirectories(tempDir);
     writeFileSync12(
-      join43(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
+      join42(tempDir, PLAN_V2_MATERIALIZATION_MARKER),
       canonicalJsonStringify({
         manifest,
         target,
@@ -19663,7 +19665,7 @@ function materializePlanV2Target(planV2Dir, target, destinationDir, options = {}
     // Join the artifact's OWN name, not the current constant: a plan written
     // before the container change carries the legacy name, and materializing it
     // under the new one would point at a file that was never written.
-    audioPath: target.role === "assembler" ? audioArtifact ? join43(destinationDir, audioArtifact.path) : null : null
+    audioPath: target.role === "assembler" ? audioArtifact ? join42(destinationDir, audioArtifact.path) : null : null
   };
 }
 function assertRemoteSources(remoteSources, artifacts) {
@@ -19682,7 +19684,7 @@ function validatePlanV2MaterializedTarget(planDir, expectedTarget) {
   return readValidatedPlanV2Materialization(planDir, expectedTarget)?.manifest ?? null;
 }
 function readValidatedPlanV2Materialization(planDir, expectedTarget) {
-  const markerPath = join43(planDir, PLAN_V2_MATERIALIZATION_MARKER);
+  const markerPath = join42(planDir, PLAN_V2_MATERIALIZATION_MARKER);
   if (!existsSync28(markerPath)) return null;
   const marker = readJsonFile(markerPath, "materialization marker");
   if (!isRecord3(marker) || !isRecord3(marker.manifest) || !isRecord3(marker.target)) {
@@ -19700,7 +19702,7 @@ function readValidatedPlanV2Materialization(planDir, expectedTarget) {
   assertRemoteSources(remoteSources, required);
   for (const artifact of required) {
     if (Object.hasOwn(remoteSources, artifact.path)) continue;
-    const path = join43(planDir, ...artifact.path.split("/"));
+    const path = join42(planDir, ...artifact.path.split("/"));
     if (!existsSync28(path) || statSync11(path).size !== artifact.sizeBytes) {
       throw new PlanV2IntegrityError(
         `materialized artifact missing or truncated: ${artifact.path}`
@@ -19832,7 +19834,7 @@ function hashChunkOutput(outputPath, kind) {
   if (kind === "file") return sha256Hex(readFileSync13(outputPath));
   const entries = readdirSync11(outputPath).filter((name) => /\.(png|jpg|jpeg)$/i.test(name)).sort();
   const lines = entries.map(
-    (name) => `${name}\0${sha256Hex(readFileSync13(join44(outputPath, name)))}`
+    (name) => `${name}\0${sha256Hex(readFileSync13(join43(outputPath, name)))}`
   );
   return sha256Hex(lines.join("\0"));
 }
@@ -19849,9 +19851,9 @@ function resolveLockedVp9CpuUsed(lockedEncoder) {
 async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   const start = Date.now();
   const log = defaultLogger;
-  const planJsonPath = join44(planDir, "plan.json");
-  const encoderJsonPath = join44(planDir, "meta", "encoder.json");
-  const chunksJsonPath = join44(planDir, "meta", "chunks.json");
+  const planJsonPath = join43(planDir, "plan.json");
+  const encoderJsonPath = join43(planDir, "meta", "encoder.json");
+  const chunksJsonPath = join43(planDir, "meta", "chunks.json");
   if (!existsSync29(planJsonPath)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
@@ -19877,7 +19879,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   }
   const encoder = JSON.parse(readFileSync13(encoderJsonPath, "utf-8"));
   const chunks = JSON.parse(readFileSync13(chunksJsonPath, "utf-8"));
-  const videosJsonPath = join44(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
+  const videosJsonPath = join43(planDir, PLAN_VIDEOS_META_RELATIVE_PATH);
   let planVideos = null;
   if (existsSync29(videosJsonPath)) {
     try {
@@ -19909,7 +19911,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
   }
   const range = resolveChunkFrameRange(slice, chunkIndex, options?.frameRange);
   const framesInChunk = range.endFrame - range.startFrame;
-  const compiledDir = join44(planDir, "compiled");
+  const compiledDir = join43(planDir, "compiled");
   if (!existsSync29(compiledDir)) {
     throw new RenderChunkValidationError(
       MISSING_PLAN_ARTIFACT,
@@ -19952,7 +19954,8 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       crf: encoder.crf,
       bitrate: encoder.bitrate,
       hdrMode: "force-sdr",
-      entryFile: "index.html"
+      entryFile: "index.html",
+      pageMotionBlur: encoder.pageMotionBlur
     });
     job.totalFrames = framesInChunk;
     job.duration = framesInChunk * plan2.dimensions.fpsDen / plan2.dimensions.fpsNum;
@@ -19967,7 +19970,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
     };
     const workDir = `${outputChunkPath}.work.${process.pid}.${randomBytes(4).toString("hex")}`;
     mkdirSync19(workDir, { recursive: true });
-    const framesDir = join44(workDir, "captured-frames");
+    const framesDir = join43(workDir, "captured-frames");
     mkdirSync19(framesDir, { recursive: true });
     const videoFramesDir = `${workDir}.video-frames`;
     const chunkFrameNumbers = Array.from({ length: framesInChunk }, (_, i) => range.startFrame + i);
@@ -19992,7 +19995,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       dimensions: plan2.dimensions,
       encoder,
       videoCount: planVideos?.videos.length ?? 0,
-      html: readFileSync13(join44(compiledDir, "index.html"), "utf-8"),
+      html: readFileSync13(join43(compiledDir, "index.html"), "utf-8"),
       // The plan ships a deferred source only to chunks that show it; don't wait on the rest.
       skipReadinessVideoIds: deferredVideos.filter(
         (video) => !shownFrames.get(video.videoId)?.size || remoteVideoIds.has(video.videoId)
@@ -20162,7 +20165,7 @@ async function renderChunk(planDir, chunkIndex, outputChunkPath, options) {
       if (isPngSequence) {
         if (!existsSync29(outputChunkPath)) mkdirSync19(outputChunkPath, { recursive: true });
       } else {
-        const outDir = join44(outputChunkPath, "..");
+        const outDir = join43(outputChunkPath, "..");
         if (!existsSync29(outDir)) mkdirSync19(outDir, { recursive: true });
       }
       const encodeInput = {
@@ -20436,10 +20439,10 @@ async function renderSpan(projectDir, config, span, outputPath) {
   if (config.cfr === true) {
     throw new RenderSpanUnsupportedError("--start/--end cannot be combined with a cfr re-encode.");
   }
-  const workDir = mkdtempSync7(join45(tmpdir4(), "hf-render-span-"));
+  const workDir = mkdtempSync(join44(tmpdir4(), "hf-render-span-"));
   try {
-    const planDir = join45(workDir, "plan");
-    const partsDir = join45(workDir, "parts");
+    const planDir = join44(workDir, "plan");
+    const partsDir = join44(workDir, "parts");
     mkdirSync20(partsDir, { recursive: true });
     const planned = await plan(
       projectDir,
@@ -20454,7 +20457,7 @@ async function renderSpan(projectDir, config, span, outputPath) {
       planned.totalFrames
     );
     const slices = JSON.parse(
-      readFileSync14(join45(planDir, "meta", "chunks.json"), "utf-8")
+      readFileSync14(join44(planDir, "meta", "chunks.json"), "utf-8")
     );
     const parts = [];
     for (const slice of slices) {
@@ -20464,7 +20467,7 @@ async function renderSpan(projectDir, config, span, outputPath) {
       };
       if (range.endFrame <= range.startFrame) continue;
       throwIfAborted(config.abortSignal);
-      const part = join45(partsDir, `part-${String(parts.length).padStart(4, "0")}.mp4`);
+      const part = join44(partsDir, `part-${String(parts.length).padStart(4, "0")}.mp4`);
       await renderChunk(planDir, slice.index, part, { frameRange: range });
       parts.push(part);
     }
@@ -21083,12 +21086,12 @@ import {
   existsSync as existsSync32,
   mkdirSync as mkdirSync21,
   statSync as statSync13,
-  mkdtempSync as mkdtempSync8,
+  mkdtempSync as mkdtempSync2,
   writeFileSync as writeFileSync14,
   rmSync as rmSync19,
   createReadStream as createReadStream5
 } from "node:fs";
-import { resolve as resolve12, dirname as dirname19, join as join48 } from "node:path";
+import { resolve as resolve12, dirname as dirname19, join as join47 } from "node:path";
 import { tmpdir as tmpdir5 } from "node:os";
 import { parseArgs } from "node:util";
 import crypto from "node:crypto";
@@ -21111,7 +21114,7 @@ import {
   closeSync as closeSync7,
   constants as constants3
 } from "node:fs";
-import { resolve as resolve11, join as join46, relative as relative7, isAbsolute as isAbsolute5, sep as sep5 } from "node:path";
+import { resolve as resolve11, join as join45, relative as relative7, isAbsolute as isAbsolute5, sep as sep5 } from "node:path";
 import { lintHyperframeHtml } from "@hyperframes/lint";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -21179,7 +21182,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join46(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join45(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -21225,7 +21228,7 @@ async function runHyperframeLint(prepared) {
 // src/services/healthWorker.ts
 import { Worker as Worker2 } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
-import { dirname as dirname18, join as join47 } from "node:path";
+import { dirname as dirname18, join as join46 } from "node:path";
 import { existsSync as existsSync31 } from "node:fs";
 var DEFAULT_HEALTH_PORT = 9848;
 async function startHealthWorker(options = {}) {
@@ -21301,7 +21304,7 @@ function defaultLogger2() {
 }
 function resolveWorkerEntry2() {
   const here = dirname18(fileURLToPath6(import.meta.url));
-  const candidates = [join47(here, "healthWorkerThread.js"), join47(here, "healthWorkerThread.ts")];
+  const candidates = [join46(here, "healthWorkerThread.js"), join46(here, "healthWorkerThread.ts")];
   for (const candidate of candidates) {
     if (existsSync31(candidate)) return candidate;
   }
@@ -21515,8 +21518,8 @@ async function resolveInlineRenderHtml(body) {
 }
 function materializeInlineProject(html, options) {
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir5();
-  const tempProjectDir = mkdtempSync8(join48(tempRoot, "producer-project-"));
-  writeFileSync14(join48(tempProjectDir, "index.html"), html, "utf-8");
+  const tempProjectDir = mkdtempSync2(join47(tempRoot, "producer-project-"));
+  writeFileSync14(join47(tempProjectDir, "index.html"), html, "utf-8");
   return {
     prepared: {
       input: { projectDir: tempProjectDir, ...options },
@@ -21985,9 +21988,9 @@ import {
 import { quantizeTimeToFrame, MEDIA_VISUAL_STYLE_PROPERTIES } from "@hyperframes/engine";
 
 // src/services/distributed/planV2Execution.ts
-import { mkdtempSync as mkdtempSync10, rmSync as rmSync21 } from "node:fs";
+import { mkdtempSync as mkdtempSync3, rmSync as rmSync21 } from "node:fs";
 import { tmpdir as tmpdir6 } from "node:os";
-import { join as join50 } from "node:path";
+import { join as join49 } from "node:path";
 
 // src/services/distributed/assemble.ts
 import {
@@ -21998,14 +22001,13 @@ import {
   cpSync as cpSync3,
   existsSync as existsSync33,
   mkdirSync as mkdirSync22,
-  mkdtempSync as mkdtempSync9,
   readFileSync as readFileSync16,
   readdirSync as readdirSync12,
   rmSync as rmSync20,
   statSync as statSync14,
   writeFileSync as writeFileSync15
 } from "node:fs";
-import { dirname as dirname20, join as join49 } from "node:path";
+import { basename as basename8, dirname as dirname20, join as join48 } from "node:path";
 import {
   appendRateCapArgs as appendRateCapArgs2,
   appendRenderProvenanceArgs as appendRenderProvenanceArgs2,
@@ -22019,6 +22021,7 @@ import {
   renameWithRetry as renameWithRetry11
 } from "@hyperframes/engine";
 import { fpsToFfmpegArg as fpsToFfmpegArg3 } from "@hyperframes/core";
+import { createStagingDir as createStagingDir7 } from "@hyperframes/core/atomic-file";
 function cfrRateControlArgs(locked) {
   const preset = getEncoderPreset6(locked.quality ?? "standard", "mp4");
   if (locked.crf == null && locked.bitrate) {
@@ -22054,7 +22057,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
   if (!existsSync33(dirname20(outputPath))) {
     mkdirSync22(dirname20(outputPath), { recursive: true });
   }
-  const workDir = mkdtempSync9(`${outputPath}.assemble-work-`);
+  const workDir = createStagingDir7(dirname20(outputPath), `${basename8(outputPath)}.assemble-work-`);
   const fps = { num: plan2.dimensions.fpsNum, den: plan2.dimensions.fpsDen };
   const stageMs = {};
   const ctx = {
@@ -22074,7 +22077,7 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
   };
   try {
     const videoSources = cfrEncoder ? [await reencodeCfr(ctx, chunkPaths, cfrEncoder)] : chunkPaths;
-    const finalPath = join49(workDir, `output.${format}`);
+    const finalPath = join48(workDir, `output.${format}`);
     const audio = audioPath !== null && existsSync33(audioPath) ? audioPath : null;
     await writeJoined(ctx, videoSources, audio, finalPath);
     renameWithRetry11(finalPath, outputPath);
@@ -22103,8 +22106,8 @@ async function assemble(planDir, chunkOutputs, audioPath, outputPath, options) {
   };
 }
 function readAssemblePlan(planDir, chunkPaths) {
-  const planJsonPath = join49(planDir, "plan.json");
-  const chunksJsonPath = join49(planDir, "meta", "chunks.json");
+  const planJsonPath = join48(planDir, "plan.json");
+  const chunksJsonPath = join48(planDir, "meta", "chunks.json");
   if (!existsSync33(planJsonPath)) {
     throw new Error(`[assemble] planDir missing plan.json: ${planJsonPath}`);
   }
@@ -22155,7 +22158,7 @@ function cfrEncodeArgs(inputArgs, encoder, fpsArg) {
   return args;
 }
 async function reencodeCfr(ctx, chunkPaths, encoder) {
-  const cfrOutputPath = join49(ctx.workDir, `cfr.${ctx.format}`);
+  const cfrOutputPath = join48(ctx.workDir, `cfr.${ctx.format}`);
   const cfrArgs = cfrEncodeArgs(videoInputArgs(ctx, chunkPaths), encoder, ctx.fpsArg);
   appendRenderProvenanceArgs2(cfrArgs, cfrOutputPath);
   cfrArgs.push("-y", cfrOutputPath);
@@ -22182,7 +22185,7 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
     );
     return;
   }
-  const paddedAudioPath = join49(ctx.workDir, "audio-padded.m4a");
+  const paddedAudioPath = join48(ctx.workDir, "audio-padded.m4a");
   const padTrimResult = await ctx.timed(
     "audioMs",
     () => padOrTrimAudioToVideoFrameCount({
@@ -22222,7 +22225,7 @@ async function writeJoined(ctx, videoSources, audioPath, finalPath) {
   }
 }
 function concatDemuxerInput(chunkPaths, workDir, fpsArg) {
-  const listPath = join49(workDir, "concat-list.txt");
+  const listPath = join48(workDir, "concat-list.txt");
   const body = chunkPaths.map((path) => `file '${path.replace(/'/g, "'\\''")}'`).join("\n");
   writeFileSync15(listPath, `${body}
 `, "utf-8");
@@ -22260,11 +22263,11 @@ function stitchesSeparateAudio(planDir) {
   return lockedAudio(planDir).separateAudio === true;
 }
 function planFormat(planDir) {
-  const plan2 = JSON.parse(readFileSync16(join49(planDir, "plan.json"), "utf-8"));
+  const plan2 = JSON.parse(readFileSync16(join48(planDir, "plan.json"), "utf-8"));
   return plan2.dimensions.format;
 }
 function lockedAudio(planDir) {
-  const encoderJsonPath = join49(planDir, "meta", "encoder.json");
+  const encoderJsonPath = join48(planDir, "meta", "encoder.json");
   if (!existsSync33(encoderJsonPath)) return {};
   return JSON.parse(readFileSync16(encoderJsonPath, "utf-8"));
 }
@@ -22274,7 +22277,7 @@ function readCfrEncoder(planDir, format) {
       `[assemble] cfr=true is only supported for format="mp4" (got "${format}"). Stream-copy paths for webm and mov already produce exact avg_frame_rate; cfr re-encode is not needed.`
     );
   }
-  const encoderJsonPath = join49(planDir, "meta", "encoder.json");
+  const encoderJsonPath = join48(planDir, "meta", "encoder.json");
   if (!existsSync33(encoderJsonPath)) {
     throw new Error(`[assemble] planDir missing meta/encoder.json: ${encoderJsonPath}`);
   }
@@ -22301,8 +22304,8 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
       throw new Error(`[assemble] png-sequence chunk has no frames: ${chunkDir}`);
     }
     for (const frame of frames) {
-      const dst = join49(outputPath, formatExportFrameName(globalIdx, "png"));
-      cpSync3(join49(chunkDir, frame), dst);
+      const dst = join48(outputPath, formatExportFrameName(globalIdx, "png"));
+      cpSync3(join48(chunkDir, frame), dst);
       globalIdx += 1;
     }
   }
@@ -22312,13 +22315,13 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
     );
   }
   if (audioPath !== null && existsSync33(audioPath)) {
-    const sidecar = join49(outputPath, MIXED_AUDIO_FILENAME4);
+    const sidecar = join48(outputPath, MIXED_AUDIO_FILENAME4);
     cpSync3(audioPath, sidecar);
   }
   let fileSize = 0;
   for (const name of readdirSync12(outputPath)) {
     try {
-      fileSize += statSync14(join49(outputPath, name)).size;
+      fileSize += statSync14(join48(outputPath, name)).size;
     } catch {
     }
   }
@@ -22332,8 +22335,8 @@ function mergePngFrameDirs(chunkPaths, outputPath, totalFrames, audioPath, start
 
 // src/services/distributed/planV2Execution.ts
 async function renderChunkV2(planV2Dir, chunkIndex, outputChunkPath, options) {
-  const workRoot = mkdtempSync10(join50(tmpdir6(), "hf-plan-v2-chunk-"));
-  const materializedPlanDir = join50(workRoot, "plan");
+  const workRoot = mkdtempSync3(join49(tmpdir6(), "hf-plan-v2-chunk-"));
+  const materializedPlanDir = join49(workRoot, "plan");
   try {
     materializePlanV2Target(planV2Dir, { role: "chunk", chunkIndex }, materializedPlanDir);
     return await renderChunk(materializedPlanDir, chunkIndex, outputChunkPath, options);
@@ -22342,8 +22345,8 @@ async function renderChunkV2(planV2Dir, chunkIndex, outputChunkPath, options) {
   }
 }
 async function assembleV2(planV2Dir, chunkPaths, outputPath, options) {
-  const workRoot = mkdtempSync10(join50(tmpdir6(), "hf-plan-v2-assembler-"));
-  const materializedPlanDir = join50(workRoot, "plan");
+  const workRoot = mkdtempSync3(join49(tmpdir6(), "hf-plan-v2-assembler-"));
+  const materializedPlanDir = join49(workRoot, "plan");
   try {
     const materialized = materializePlanV2Target(
       planV2Dir,