@hyperframes/aws-lambda 0.7.72 → 0.7.74

package/dist/index.js

@@ -1,14 +1,14 @@
 // src/handler.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, mkdtempSync, readFileSync, rmSync as rmSync2, statSync as statSync2 } from "node:fs";
-import { tmpdir } from "node:os";
-import { basename, join } from "node:path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, mkdtempSync as mkdtempSync2, readFileSync, rmSync as rmSync3, statSync as statSync3 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { basename, join as join2 } from "node:path";
 import { S3Client } from "@aws-sdk/client-s3";
 import {
   assemble,
   listPlanV2ArtifactsForTarget,
   materializePlanV2Target,
   plan,
-  planV2,
+  planV2WithPublisher,
   readPlanV2Manifest,
   renderChunk
 } from "@hyperframes/producer/distributed";
@@ -181,33 +181,36 @@ async function uploadContentAddressedFileToS3(client, localPath, uri, expectedSh
   }
   const { bucket, key } = parseS3Uri(uri);
   const size = statSync(localPath).size;
+  const existing = await inspectContentAddressedObject(client, bucket, key, size, expectedSha256);
+  if (existing === "matching") return "reused";
+  if (existing === "conflict") throwImmutableObjectConflict(uri);
+  const body = createReadStream(localPath);
   try {
-    const existing = await client.send(
-      new HeadObjectCommand({ Bucket: bucket, Key: key, ChecksumMode: "ENABLED" })
-    );
-    if (existing.ContentLength === size && existing.Metadata?.sha256 === expectedSha256) {
-      return "reused";
-    }
-    const error = new Error(
-      `[s3Transport] PLAN_ARTIFACT_DIGEST_MISMATCH: immutable object ${uri} already exists with different digest metadata or size`
+    await client.send(
+      new PutObjectCommand({
+        Bucket: bucket,
+        Key: key,
+        Body: body,
+        ContentType: contentType,
+        ContentLength: size,
+        Metadata: { sha256: expectedSha256 },
+        ChecksumSHA256: Buffer.from(expectedSha256, "hex").toString("base64"),
+        // HEAD followed by an unconditional PUT can overwrite a conflicting
+        // object published by a concurrent planner. Conditional create makes
+        // immutable CAS and fixed-key manifest publication race-safe.
+        IfNoneMatch: "*"
+      })
     );
-    error.name = "PLAN_ARTIFACT_DIGEST_MISMATCH";
-    throw error;
+    return "uploaded";
   } catch (error) {
-    if (!isS3NotFound(error)) throw error;
+    if (!isS3PreconditionFailed(error)) throw error;
+    const raced = await inspectContentAddressedObject(client, bucket, key, size, expectedSha256);
+    if (raced === "matching") return "reused";
+    if (raced === "conflict") throwImmutableObjectConflict(uri);
+    throw error;
+  } finally {
+    body.destroy();
   }
-  await client.send(
-    new PutObjectCommand({
-      Bucket: bucket,
-      Key: key,
-      Body: createReadStream(localPath),
-      ContentType: contentType,
-      ContentLength: size,
-      Metadata: { sha256: expectedSha256 },
-      ChecksumSHA256: Buffer.from(expectedSha256, "hex").toString("base64")
-    })
-  );
-  return "uploaded";
 }
 async function sha256File(path) {
   const hash = createHash("sha256");
@@ -223,10 +226,36 @@ function assertSha256(value) {
     );
   }
 }
+async function inspectContentAddressedObject(client, bucket, key, expectedSize, expectedSha256) {
+  try {
+    const existing = await client.send(
+      new HeadObjectCommand({ Bucket: bucket, Key: key, ChecksumMode: "ENABLED" })
+    );
+    return existing.ContentLength === expectedSize && existing.Metadata?.sha256 === expectedSha256 ? "matching" : "conflict";
+  } catch (error) {
+    if (isS3NotFound(error)) return "missing";
+    throw error;
+  }
+}
+function throwImmutableObjectConflict(uri) {
+  const error = new Error(
+    `[s3Transport] PLAN_ARTIFACT_DIGEST_MISMATCH: immutable object ${uri} already exists with different digest metadata or size`
+  );
+  error.name = "PLAN_ARTIFACT_DIGEST_MISMATCH";
+  throw error;
+}
 function isS3NotFound(error) {
-  if (!error || typeof error !== "object") return false;
-  const candidate = error;
-  return candidate.name === "NotFound" || candidate.name === "NoSuchKey" || candidate.$metadata?.httpStatusCode === 404;
+  if (!isRecord(error)) return false;
+  const metadata = isRecord(error.$metadata) ? error.$metadata : void 0;
+  return error.name === "NotFound" || error.name === "NoSuchKey" || metadata?.httpStatusCode === 404;
+}
+function isS3PreconditionFailed(error) {
+  if (!isRecord(error)) return false;
+  const metadata = isRecord(error.$metadata) ? error.$metadata : void 0;
+  return error.name === "PreconditionFailed" || metadata?.httpStatusCode === 412;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 async function tarDirectory(sourceDir, destTarball) {
   if (!existsSync2(sourceDir) || !statSync(sourceDir).isDirectory()) {
@@ -246,6 +275,112 @@ async function untarDirectory(tarballPath, destDir) {
   await tar.extract({ file: tarballPath, cwd: destDir });
 }
 
+// src/s3PlanV2Publisher.ts
+import { createHash as createHash2 } from "node:crypto";
+import { mkdirSync as mkdirSync2, mkdtempSync, rmSync as rmSync2, statSync as statSync2, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  PlanV2IntegrityError
+} from "@hyperframes/producer/distributed";
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function assertSha2562(value, label) {
+  if (typeof value !== "string" || !/^[a-f0-9]{64}$/.test(value)) {
+    throw new PlanV2IntegrityError(`${label} must be a lowercase SHA-256 digest`);
+  }
+  return value;
+}
+function manifestDigests(manifestBytes) {
+  let value;
+  try {
+    value = JSON.parse(manifestBytes);
+  } catch {
+    throw new PlanV2IntegrityError("S3 publisher received invalid manifest JSON");
+  }
+  if (!isRecord2(value) || !Array.isArray(value.artifacts)) {
+    throw new PlanV2IntegrityError("S3 publisher manifest requires an artifacts array");
+  }
+  return new Set(
+    value.artifacts.map((artifact, index) => {
+      if (!isRecord2(artifact)) {
+        throw new PlanV2IntegrityError(`S3 publisher artifacts[${index}] must be an object`);
+      }
+      return assertSha2562(artifact.sha256, `S3 publisher artifacts[${index}].sha256`);
+    })
+  );
+}
+function trimTrailingSlash(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) end -= 1;
+  return value.slice(0, end);
+}
+var S3PlanV2ArtifactPublisher = class {
+  artifactPrefix;
+  manifestUri;
+  #s3;
+  #temporaryRoot;
+  #publishedDigests = /* @__PURE__ */ new Set();
+  #state = "open";
+  constructor(options) {
+    const outputPrefix = `${trimTrailingSlash(options.planOutputS3Prefix)}/v2`;
+    parseS3Uri(outputPrefix);
+    this.#s3 = options.s3;
+    this.artifactPrefix = `${outputPrefix}/artifacts/sha256`;
+    this.manifestUri = `${outputPrefix}/manifest.json`;
+    this.#temporaryRoot = options.temporaryRoot ?? tmpdir();
+    mkdirSync2(this.#temporaryRoot, { recursive: true });
+  }
+  async putBlob(blob) {
+    this.#assertOpen("publish a blob");
+    const digest = assertSha2562(blob.sha256, "S3 published blob sha256");
+    const sourceSize = statSync2(blob.sourcePath).size;
+    if (sourceSize !== blob.sizeBytes) {
+      throw new PlanV2IntegrityError(
+        `S3 published blob size changed for ${digest}: expected ${blob.sizeBytes}, got ${sourceSize}`
+      );
+    }
+    const uri = `${this.artifactPrefix}/${digest.slice(0, 2)}/${digest}`;
+    await uploadContentAddressedFileToS3(this.#s3, blob.sourcePath, uri, digest);
+    this.#publishedDigests.add(digest);
+  }
+  async commitManifest(manifestBytes) {
+    this.#assertOpen("commit a manifest");
+    for (const digest of manifestDigests(manifestBytes)) {
+      if (!this.#publishedDigests.has(digest)) {
+        throw new PlanV2IntegrityError(
+          `cannot commit S3 manifest before referenced blob is durable: ${digest}`
+        );
+      }
+    }
+    const manifestDigest = createHash2("sha256").update(manifestBytes, "utf8").digest("hex");
+    const stagingDir = mkdtempSync(join(this.#temporaryRoot, "hf-plan-v2-manifest-"));
+    const manifestPath = join(stagingDir, "manifest.json");
+    try {
+      writeFileSync(manifestPath, manifestBytes, "utf8");
+      await uploadContentAddressedFileToS3(
+        this.#s3,
+        manifestPath,
+        this.manifestUri,
+        manifestDigest,
+        "application/json"
+      );
+      this.#state = "committed";
+    } finally {
+      rmSync2(stagingDir, { recursive: true, force: true });
+    }
+  }
+  async abort() {
+    if (this.#state === "open") this.#state = "aborted";
+  }
+  #assertOpen(operation) {
+    if (this.#state !== "open") {
+      throw new PlanV2IntegrityError(`cannot ${operation} after publisher is ${this.#state}`);
+    }
+  }
+};
+
 // src/handler.ts
 var cachedS3Client = null;
 function getS3Client() {
@@ -357,7 +492,7 @@ function primeRuntimeEnv() {
   if (runtimeEnvPrimed) return;
   runtimeEnvPrimed = true;
   const taskRoot = process.env.LAMBDA_TASK_ROOT ?? "/var/task";
-  const bin = join(taskRoot, "bin");
+  const bin = join2(taskRoot, "bin");
   if (existsSync3(bin)) {
     process.env.PATH = `${bin}:${process.env.PATH ?? ""}`;
   }
@@ -373,10 +508,10 @@ async function handlePlan(event, deps) {
     const chromePath = await resolveChromeExecutablePath();
     process.env.PRODUCER_HEADLESS_SHELL_PATH = chromePath;
   }
-  const work = mkdtempSync(join(deps?.tmpRoot ?? tmpdir(), "hf-lambda-plan-"));
-  const projectArchive = join(work, "project.tar.gz");
-  const projectDir = join(work, "project");
-  const planDir = join(work, "plan");
+  const work = mkdtempSync2(join2(deps?.tmpRoot ?? tmpdir2(), "hf-lambda-plan-"));
+  const projectArchive = join2(work, "project.tar.gz");
+  const projectDir = join2(work, "project");
+  const planDir = join2(work, "plan");
   try {
     await downloadS3ObjectToFile(s3, event.ProjectS3Uri, projectArchive);
     await untarDirectory(projectArchive, projectDir);
@@ -384,12 +519,12 @@ async function handlePlan(event, deps) {
       ...event.Config
     };
     const result = await primitive(projectDir, config, planDir);
-    const planTar = join(work, "plan.tar.gz");
+    const planTar = join2(work, "plan.tar.gz");
     await tarDirectory(planDir, planTar);
-    const planTarUri = `${trimTrailingSlash(event.PlanOutputS3Prefix)}/plan.tar.gz`;
-    const audioPath = join(planDir, "audio.aac");
-    const hasAudio = existsSync3(audioPath) && statSync2(audioPath).size > 0;
-    const audioUri = hasAudio ? `${trimTrailingSlash(event.PlanOutputS3Prefix)}/audio.aac` : null;
+    const planTarUri = `${trimTrailingSlash2(event.PlanOutputS3Prefix)}/plan.tar.gz`;
+    const audioPath = join2(planDir, "audio.aac");
+    const hasAudio = existsSync3(audioPath) && statSync3(audioPath).size > 0;
+    const audioUri = hasAudio ? `${trimTrailingSlash2(event.PlanOutputS3Prefix)}/audio.aac` : null;
     await Promise.all([
       uploadFileToS3(s3, planTar, planTarUri, "application/gzip"),
       hasAudio && audioUri ? uploadFileToS3(s3, audioPath, audioUri, "audio/aac") : null
@@ -417,60 +552,40 @@ async function handlePlan(event, deps) {
 async function handlePlanV2(event, deps) {
   const started = Date.now();
   const s3 = deps?.s3 ?? getS3Client();
-  const primitive = deps?.primitives?.planV2 ?? planV2;
+  const primitive = deps?.primitives?.planV2WithPublisher ?? planV2WithPublisher;
   if (!deps?.skipChromeResolution && !process.env.PRODUCER_HEADLESS_SHELL_PATH) {
     process.env.PRODUCER_HEADLESS_SHELL_PATH = await resolveChromeExecutablePath();
   }
-  const work = mkdtempSync(join(deps?.tmpRoot ?? tmpdir(), "hf-lambda-plan-v2-"));
-  const projectArchive = join(work, "project.tar.gz");
-  const projectDir = join(work, "project");
-  const planV2Dir = join(work, "plan-v2");
+  const work = mkdtempSync2(join2(deps?.tmpRoot ?? tmpdir2(), "hf-lambda-plan-v2-"));
+  const projectArchive = join2(work, "project.tar.gz");
+  const projectDir = join2(work, "project");
   try {
     await downloadS3ObjectToFile(s3, event.ProjectS3Uri, projectArchive);
     await untarDirectory(projectArchive, projectDir);
-    const result = await primitive(projectDir, { ...event.Config }, planV2Dir);
-    const manifest = readPlanV2Manifest(planV2Dir);
-    if (manifest.planHash !== result.planHash) {
-      throwPlanHashMismatch(result.planHash, manifest.planHash);
-    }
-    const outputPrefix = `${trimTrailingSlash(event.PlanOutputS3Prefix)}/v2`;
-    const artifactPrefix = `${outputPrefix}/artifacts/sha256`;
-    const uniqueArtifacts = [
-      ...new Map(manifest.artifacts.map((artifact) => [artifact.sha256, artifact])).values()
-    ];
-    await mapConcurrent(uniqueArtifacts, 16, async (artifact) => {
-      const localPath = planV2BlobPath(planV2Dir, artifact.sha256);
-      await uploadContentAddressedFileToS3(
-        s3,
-        localPath,
-        planV2BlobUri(artifactPrefix, artifact.sha256),
-        artifact.sha256
-      );
-    });
-    const manifestUri = `${outputPrefix}/manifest.json`;
-    await uploadContentAddressedFileToS3(
+    const publisher = new S3PlanV2ArtifactPublisher({
       s3,
-      result.manifestPath,
-      manifestUri,
-      await sha256File(result.manifestPath),
-      "application/json"
-    );
+      planOutputS3Prefix: event.PlanOutputS3Prefix,
+      temporaryRoot: work
+    });
+    const manifest = await primitive(projectDir, { ...event.Config }, publisher, {
+      stagingParentDir: work
+    });
     return {
       Action: "plan",
       PlanProtocol: "v2",
-      PlanV2ManifestS3Uri: manifestUri,
-      PlanV2ArtifactS3Prefix: artifactPrefix,
-      PlanHash: result.planHash,
-      ChunkCount: result.chunkCount,
-      TotalFrames: result.totalFrames,
-      Fps: result.fps,
-      Width: result.width,
-      Height: result.height,
-      Format: result.format,
+      PlanV2ManifestS3Uri: publisher.manifestUri,
+      PlanV2ArtifactS3Prefix: publisher.artifactPrefix,
+      PlanHash: manifest.planHash,
+      ChunkCount: manifest.chunkCount,
+      TotalFrames: manifest.totalFrames,
+      Fps: manifest.fps,
+      Width: manifest.width,
+      Height: manifest.height,
+      Format: manifest.format,
       HasAudio: manifest.artifacts.some((artifact) => artifact.path === "audio.aac"),
       AudioS3Uri: null,
-      FfmpegVersion: result.ffmpegVersion,
-      ProducerVersion: result.producerVersion,
+      FfmpegVersion: manifest.ffmpegVersion,
+      ProducerVersion: manifest.producerVersion,
       DurationMs: Date.now() - started
     };
   } finally {
@@ -488,14 +603,14 @@ async function handleRenderChunk(event, deps) {
     const chromePath = await resolveChromeExecutablePath();
     process.env.PRODUCER_HEADLESS_SHELL_PATH = chromePath;
   }
-  const work = mkdtempSync(join(deps?.tmpRoot ?? tmpdir(), "hf-lambda-chunk-"));
-  const planTar = join(work, "plan.tar.gz");
-  const planDir = join(work, "plan");
+  const work = mkdtempSync2(join2(deps?.tmpRoot ?? tmpdir2(), "hf-lambda-chunk-"));
+  const planTar = join2(work, "plan.tar.gz");
+  const planDir = join2(work, "plan");
   try {
     await downloadS3ObjectToFile(s3, event.PlanS3Uri, planTar);
     await untarDirectory(planTar, planDir);
     verifyPlanHash(planDir, event.PlanHash);
-    const chunkOutputBase = join(
+    const chunkOutputBase = join2(
       work,
       event.Format === "png-sequence" ? `chunk-${pad(event.ChunkIndex)}` : `chunk-${pad(event.ChunkIndex)}${formatExtension(event.Format)}`
     );
@@ -512,6 +627,7 @@ async function handleRenderChunk(event, deps) {
       ChunkIndex: event.ChunkIndex,
       Sha256: result.sha256,
       FramesEncoded: result.framesEncoded,
+      CaptureMode: result.captureMode,
       DurationMs: Date.now() - started
     };
   } finally {
@@ -525,7 +641,7 @@ async function handleRenderChunkV2(event, deps) {
   if (!deps?.skipChromeResolution && !process.env.PRODUCER_HEADLESS_SHELL_PATH) {
     process.env.PRODUCER_HEADLESS_SHELL_PATH = await resolveChromeExecutablePath();
   }
-  const work = mkdtempSync(join(deps?.tmpRoot ?? tmpdir(), "hf-lambda-chunk-v2-"));
+  const work = mkdtempSync2(join2(deps?.tmpRoot ?? tmpdir2(), "hf-lambda-chunk-v2-"));
   try {
     const planDir = await downloadAndMaterializePlanV2(
       s3,
@@ -533,7 +649,7 @@ async function handleRenderChunkV2(event, deps) {
       { role: "chunk", chunkIndex: event.ChunkIndex },
       work
     );
-    const chunkOutputBase = join(
+    const chunkOutputBase = join2(
       work,
       event.Format === "png-sequence" ? `chunk-${pad(event.ChunkIndex)}` : `chunk-${pad(event.ChunkIndex)}${formatExtension(event.Format)}`
     );
@@ -550,6 +666,7 @@ async function handleRenderChunkV2(event, deps) {
       ChunkIndex: event.ChunkIndex,
       Sha256: result.sha256,
       FramesEncoded: result.framesEncoded,
+      CaptureMode: result.captureMode,
       DurationMs: Date.now() - started
     };
   } finally {
@@ -557,7 +674,7 @@ async function handleRenderChunkV2(event, deps) {
   }
 }
 async function uploadChunkOutput(s3, result, prefix, chunkIndex) {
-  const trimmed = trimTrailingSlash(prefix);
+  const trimmed = trimTrailingSlash2(prefix);
   if (result.outputKind === "file") {
     const ext = result.outputPath.slice(result.outputPath.lastIndexOf("."));
     const uri2 = `${trimmed}/chunks/${pad(chunkIndex)}${ext}`;
@@ -577,19 +694,19 @@ async function handleAssemble(event, deps) {
   const started = Date.now();
   const s3 = deps?.s3 ?? getS3Client();
   const primitive = deps?.primitives?.assemble ?? assemble;
-  const work = mkdtempSync(join(deps?.tmpRoot ?? tmpdir(), "hf-lambda-assemble-"));
-  const planTar = join(work, "plan.tar.gz");
-  const planDir = join(work, "plan");
+  const work = mkdtempSync2(join2(deps?.tmpRoot ?? tmpdir2(), "hf-lambda-assemble-"));
+  const planTar = join2(work, "plan.tar.gz");
+  const planDir = join2(work, "plan");
   try {
     await downloadS3ObjectToFile(s3, event.PlanS3Uri, planTar);
     await untarDirectory(planTar, planDir);
     const chunkPaths = await downloadChunkObjects(s3, event.ChunkS3Uris, work, event.Format);
     let audioPath = null;
     if (event.AudioS3Uri) {
-      audioPath = join(planDir, "audio.aac");
+      audioPath = join2(planDir, "audio.aac");
       await downloadS3ObjectToFile(s3, event.AudioS3Uri, audioPath);
     }
-    const finalOutput = event.Format === "png-sequence" ? join(work, "output-frames") : join(work, `output${formatExtension(event.Format)}`);
+    const finalOutput = event.Format === "png-sequence" ? join2(work, "output-frames") : join2(work, `output${formatExtension(event.Format)}`);
     const result = await primitive(planDir, chunkPaths, audioPath, finalOutput, {
       cfr: event.Cfr === true
     });
@@ -615,12 +732,12 @@ async function handleAssembleV2(event, deps) {
   const started = Date.now();
   const s3 = deps?.s3 ?? getS3Client();
   const primitive = deps?.primitives?.assemble ?? assemble;
-  const work = mkdtempSync(join(deps?.tmpRoot ?? tmpdir(), "hf-lambda-assemble-v2-"));
+  const work = mkdtempSync2(join2(deps?.tmpRoot ?? tmpdir2(), "hf-lambda-assemble-v2-"));
   try {
     const planDir = await downloadAndMaterializePlanV2(s3, event, { role: "assembler" }, work);
-    const audioPath = existsSync3(join(planDir, "audio.aac")) ? join(planDir, "audio.aac") : null;
+    const audioPath = existsSync3(join2(planDir, "audio.aac")) ? join2(planDir, "audio.aac") : null;
     const chunkPaths = await downloadChunkObjects(s3, event.ChunkS3Uris, work, event.Format);
-    const finalOutput = event.Format === "png-sequence" ? join(work, "output-frames") : join(work, `output${formatExtension(event.Format)}`);
+    const finalOutput = event.Format === "png-sequence" ? join2(work, "output-frames") : join2(work, `output${formatExtension(event.Format)}`);
     const result = await primitive(planDir, chunkPaths, audioPath, finalOutput, {
       cfr: event.Cfr === true
     });
@@ -643,9 +760,9 @@ async function handleAssembleV2(event, deps) {
   }
 }
 async function downloadAndMaterializePlanV2(s3, event, target, work) {
-  const transportDir = join(work, "plan-v2");
-  mkdirSync2(transportDir, { recursive: true });
-  await downloadS3ObjectToFile(s3, event.PlanV2ManifestS3Uri, join(transportDir, "plan.json"));
+  const transportDir = join2(work, "plan-v2");
+  mkdirSync3(transportDir, { recursive: true });
+  await downloadS3ObjectToFile(s3, event.PlanV2ManifestS3Uri, join2(transportDir, "plan.json"));
   const manifest = readPlanV2Manifest(transportDir);
   if (manifest.planHash !== event.PlanHash) {
     throwPlanHashMismatch(event.PlanHash, manifest.planHash);
@@ -657,7 +774,7 @@ async function downloadAndMaterializePlanV2(s3, event, target, work) {
   await mapConcurrent(uniqueArtifacts, 16, async (artifact) => {
     await downloadPlanV2Artifact(s3, event.PlanV2ArtifactS3Prefix, transportDir, artifact);
   });
-  const planDir = join(work, "plan");
+  const planDir = join2(work, "plan");
   materializePlanV2Target(transportDir, target, planDir);
   return planDir;
 }
@@ -670,10 +787,10 @@ async function downloadPlanV2Artifact(s3, artifactPrefix, planV2Dir, artifact) {
   );
 }
 function planV2BlobPath(planV2Dir, digest) {
-  return join(planV2Dir, "artifacts", "sha256", digest.slice(0, 2), digest);
+  return join2(planV2Dir, "artifacts", "sha256", digest.slice(0, 2), digest);
 }
 function planV2BlobUri(prefix, digest) {
-  return `${trimTrailingSlash(prefix)}/${digest.slice(0, 2)}/${digest}`;
+  return `${trimTrailingSlash2(prefix)}/${digest.slice(0, 2)}/${digest}`;
 }
 function throwPlanHashMismatch(expected, actual) {
   const error = new Error(
@@ -690,11 +807,17 @@ async function mapConcurrent(values, concurrency, fn) {
       await fn(values[index]);
     }
   }
-  await Promise.all(Array.from({ length: Math.min(concurrency, values.length) }, () => worker()));
+  const results = await Promise.allSettled(
+    Array.from({ length: Math.min(concurrency, values.length) }, () => worker())
+  );
+  const failure = results.find(
+    (result) => result.status === "rejected"
+  );
+  if (failure) throw failure.reason;
 }
 async function downloadChunkObjects(s3, uris, workDir, format) {
-  const chunksDir = join(workDir, "chunks");
-  mkdirSync2(chunksDir, { recursive: true });
+  const chunksDir = join2(workDir, "chunks");
+  mkdirSync3(chunksDir, { recursive: true });
   const local = new Array(uris.length);
   await Promise.all(
     uris.map(async (uri, i) => {
@@ -702,10 +825,10 @@ async function downloadChunkObjects(s3, uris, workDir, format) {
         throw new Error(`[handler] chunk URI at index ${i} is empty`);
       }
       const { key } = parseS3Uri(uri);
-      const localPath = join(chunksDir, basename(key));
+      const localPath = join2(chunksDir, basename(key));
       await downloadS3ObjectToFile(s3, uri, localPath);
       if (format === "png-sequence") {
-        const dirPath = join(chunksDir, `frames-${pad(i)}`);
+        const dirPath = join2(chunksDir, `frames-${pad(i)}`);
         await untarDirectory(localPath, dirPath);
         local[i] = dirPath;
       } else {
@@ -747,17 +870,17 @@ function validateEventS3Uris(event) {
 function pad(n) {
   return n.toString().padStart(4, "0");
 }
-function trimTrailingSlash(prefix) {
+function trimTrailingSlash2(prefix) {
   return prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
 }
 function cleanupDir(dir) {
   try {
-    rmSync2(dir, { recursive: true, force: true });
+    rmSync3(dir, { recursive: true, force: true });
   } catch {
   }
 }
 function verifyPlanHash(planDir, expected) {
-  const planJsonPath = join(planDir, "plan.json");
+  const planJsonPath = join2(planDir, "plan.json");
   let parsed;
   try {
     parsed = JSON.parse(readFileSync(planJsonPath, "utf-8"));
@@ -778,13 +901,13 @@ function verifyPlanHash(planDir, expected) {
 }
 
 // src/sdk/deploySite.ts
-import { mkdtempSync as mkdtempSync2, rmSync as rmSync3, statSync as statSync3 } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
-import { join as join2 } from "node:path";
+import { mkdtempSync as mkdtempSync3, rmSync as rmSync4, statSync as statSync4 } from "node:fs";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join3 } from "node:path";
 import { HeadObjectCommand as HeadObjectCommand2, S3Client as S3Client2 } from "@aws-sdk/client-s3";
 import { hashProjectDir } from "@hyperframes/producer/distributed";
 async function deploySite(opts) {
-  if (!statSync3(opts.projectDir).isDirectory()) {
+  if (!statSync4(opts.projectDir).isDirectory()) {
     throw new Error(`[deploySite] projectDir is not a directory: ${opts.projectDir}`);
   }
   const siteId = opts.siteId ?? hashProjectDir(opts.projectDir);
@@ -802,11 +925,11 @@ async function deploySite(opts) {
       uploaded: false
     };
   }
-  const workdir = mkdtempSync2(join2(tmpdir2(), "hf-deploy-site-"));
+  const workdir = mkdtempSync3(join3(tmpdir3(), "hf-deploy-site-"));
   try {
-    const tarball = join2(workdir, "project.tar.gz");
+    const tarball = join3(workdir, "project.tar.gz");
     await tarDirectory(opts.projectDir, tarball);
-    const size = statSync3(tarball).size;
+    const size = statSync4(tarball).size;
     await uploadFileToS3(s3, tarball, projectS3Uri, "application/gzip");
     return {
       siteId,
@@ -817,7 +940,7 @@ async function deploySite(opts) {
       uploaded: true
     };
   } finally {
-    rmSync3(workdir, { recursive: true, force: true });
+    rmSync4(workdir, { recursive: true, force: true });
   }
 }
 async function headObject(s3, bucket, key) {
@@ -1209,6 +1332,7 @@ function isTerminalFailure(status) {
 export {
   ChromeBinaryUnavailableError,
   InvalidConfigError2 as InvalidConfigError,
+  S3PlanV2ArtifactPublisher,
   computeRenderCost,
   deploySite,
   downloadS3ObjectToFile,