@hyperframes/gcp-cloud-run 0.7.72 → 0.7.73

package/dist/gcsPlanV2Publisher.d.ts

@@ -0,0 +1,25 @@
+import type { Storage } from "@google-cloud/storage";
+import { type PlanV2ArtifactPublisher, type PlanV2PublishBlob } from "@hyperframes/producer/distributed";
+export interface GcsPlanV2ArtifactPublisherOptions {
+    readonly storage: Storage;
+    /** Validated render output prefix from which all v2 object keys are derived. */
+    readonly planOutputGcsPrefix: string;
+    /** Planner-local scratch parent for the small manifest upload file. */
+    readonly temporaryRoot?: string;
+}
+/**
+ * Manifest-last GCS implementation of the producer's plan-v2 publication seam.
+ *
+ * Every path remains private to the planner container. Remote workers receive
+ * only the manifest URI and artifact prefix and materialize their own target.
+ */
+export declare class GcsPlanV2ArtifactPublisher implements PlanV2ArtifactPublisher {
+    #private;
+    readonly artifactPrefix: string;
+    readonly manifestUri: string;
+    constructor(options: Readonly<GcsPlanV2ArtifactPublisherOptions>);
+    putBlob(blob: Readonly<PlanV2PublishBlob>): Promise<void>;
+    commitManifest(manifestBytes: string): Promise<void>;
+    abort(): Promise<void>;
+}
+//# sourceMappingURL=gcsPlanV2Publisher.d.ts.map

package/dist/gcsPlanV2Publisher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gcsPlanV2Publisher.d.ts","sourceRoot":"","sources":["../src/gcsPlanV2Publisher.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAEL,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACvB,MAAM,mCAAmC,CAAC;AAG3C,MAAM,WAAW,iCAAiC;IAChD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,gFAAgF;IAChF,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,uEAAuE;IACvE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC;AAuCD;;;;;GAKG;AACH,qBAAa,0BAA2B,YAAW,uBAAuB;;IACxE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;gBAMjB,OAAO,EAAE,QAAQ,CAAC,iCAAiC,CAAC;IAU1D,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,iBAAiB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAczD,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA4BpD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAW7B"}

package/dist/index.d.ts

@@ -21,6 +21,7 @@ export { createApp, dispatch, type HandlerDeps, startServer, unwrapEvent } from
 export { type AssembleEvent, type AssembleV1Event, type AssembleV2Event, type AssembleResultBody, type CloudRunAction, type CloudRunEvent, type CloudRunPlanProtocol, type CloudRunResult, type PlanEvent, type PlanResultBody, type PlanV1Event, type PlanV1ResultBody, type PlanV2Event, type PlanV2ResultBody, type RenderChunkEvent, type RenderChunkResultBody, type RenderChunkV1Event, type RenderChunkV2Event, type SerializableDistributedRenderConfig, } from "./events.js";
 export { ChromeBinaryUnavailableError, resolveChromeExecutablePath } from "./chromium.js";
 export { downloadGcsObjectToFile, downloadGcsObjectToFileVerified, formatGcsUri, type GcsLocation, parseGcsUri, sha256File, tarDirectory, untarDirectory, uploadContentAddressedFileToGcs, uploadFileToGcs, } from "./gcsTransport.js";
+export { GcsPlanV2ArtifactPublisher, type GcsPlanV2ArtifactPublisherOptions, } from "./gcsPlanV2Publisher.js";
 export { deploySite, type DeploySiteOptions, type SiteHandle } from "./sdk/deploySite.js";
 export { renderToCloudRun, type RenderHandle, type RenderToCloudRunOptions, } from "./sdk/renderToCloudRun.js";
 export { getRenderProgress, type GetRenderProgressOptions, type RenderError, type RenderProgress, type RenderStatus, } from "./sdk/getRenderProgress.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC9F,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACnB,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,mCAAmC,GACzC,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,4BAA4B,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAC1F,OAAO,EACL,uBAAuB,EACvB,+BAA+B,EAC/B,YAAY,EACZ,KAAK,WAAW,EAChB,WAAW,EACX,UAAU,EACV,YAAY,EACZ,cAAc,EACd,+BAA+B,EAC/B,eAAe,GAChB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC1F,OAAO,EACL,gBAAgB,EAChB,KAAK,YAAY,EACjB,KAAK,uBAAuB,GAC7B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,iBAAiB,EACjB,KAAK,wBAAwB,EAC7B,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,YAAY,GAClB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,KAAK,wBAAwB,EAC7B,iBAAiB,EACjB,KAAK,UAAU,GAChB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,kBAAkB,EAAE,+BAA+B,EAAE,MAAM,yBAAyB,CAAC;AAC9F,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC9F,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACnB,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,mCAAmC,GACzC,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,4BAA4B,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAC1F,OAAO,EACL,uBAAuB,EACvB,+BAA+B,EAC/B,YAAY,EACZ,KAAK,WAAW,EAChB,WAAW,EACX,UAAU,EACV,YAAY,EACZ,cAAc,EACd,+BAA+B,EAC/B,eAAe,GAChB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,0BAA0B,EAC1B,KAAK,iCAAiC,GACvC,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC1F,OAAO,EACL,gBAAgB,EAChB,KAAK,YAAY,EACjB,KAAK,uBAAuB,GAC7B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,iBAAiB,EACjB,KAAK,wBAAwB,EAC7B,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,YAAY,GAClB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,KAAK,wBAAwB,EAC7B,iBAAiB,EACjB,KAAK,UAAU,GAChB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,kBAAkB,EAAE,+BAA+B,EAAE,MAAM,yBAAyB,CAAC;AAC9F,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/server.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, extname, 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, extname, join as join2 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { serve } from "@hono/node-server";
 import { Storage } from "@google-cloud/storage";
@@ -11,7 +11,7 @@ import {
   listPlanV2ArtifactsForTarget,
   materializePlanV2Target,
   plan,
-  planV2,
+  planV2WithPublisher,
   readPlanV2Manifest,
   renderChunk
 } from "@hyperframes/producer/distributed";
@@ -227,6 +227,112 @@ async function untarDirectory(tarballPath, destDir) {
   await tar.extract({ file: tarballPath, cwd: destDir });
 }
 
+// src/gcsPlanV2Publisher.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 isRecord(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("GCS publisher received invalid manifest JSON");
+  }
+  if (!isRecord(value) || !Array.isArray(value.artifacts)) {
+    throw new PlanV2IntegrityError("GCS publisher manifest requires an artifacts array");
+  }
+  return new Set(
+    value.artifacts.map((artifact, index) => {
+      if (!isRecord(artifact)) {
+        throw new PlanV2IntegrityError(`GCS publisher artifacts[${index}] must be an object`);
+      }
+      return assertSha2562(artifact.sha256, `GCS 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 GcsPlanV2ArtifactPublisher = class {
+  artifactPrefix;
+  manifestUri;
+  #storage;
+  #temporaryRoot;
+  #publishedDigests = /* @__PURE__ */ new Set();
+  #state = "open";
+  constructor(options) {
+    const outputPrefix = `${trimTrailingSlash(options.planOutputGcsPrefix)}/v2`;
+    parseGcsUri(outputPrefix);
+    this.#storage = options.storage;
+    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, "GCS published blob sha256");
+    const sourceSize = statSync2(blob.sourcePath).size;
+    if (sourceSize !== blob.sizeBytes) {
+      throw new PlanV2IntegrityError(
+        `GCS published blob size changed for ${digest}: expected ${blob.sizeBytes}, got ${sourceSize}`
+      );
+    }
+    const uri = `${this.artifactPrefix}/${digest.slice(0, 2)}/${digest}`;
+    await uploadContentAddressedFileToGcs(this.#storage, 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 GCS 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 uploadContentAddressedFileToGcs(
+        this.#storage,
+        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/server.ts
 var cachedStorage = null;
 function getStorage() {
@@ -374,10 +480,10 @@ async function handlePlan(event, deps) {
   const storage = deps?.storage ?? getStorage();
   const primitive = deps?.primitives?.plan ?? plan;
   primeChrome(deps);
-  const work = mkdtempSync(join(deps?.tmpRoot ?? tmpdir(), "hf-cr-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-cr-plan-"));
+  const projectArchive = join2(work, "project.tar.gz");
+  const projectDir = join2(work, "project");
+  const planDir = join2(work, "plan");
   try {
     await downloadGcsObjectToFile(storage, event.ProjectGcsUri, projectArchive);
     await untarDirectory(projectArchive, projectDir);
@@ -385,11 +491,11 @@ 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.PlanOutputGcsPrefix)}/plan.tar.gz`;
-    const audioPath = join(planDir, "audio.aac");
-    const hasAudio = existsSync3(audioPath) && statSync2(audioPath).size > 0;
+    const planTarUri = `${trimTrailingSlash2(event.PlanOutputGcsPrefix)}/plan.tar.gz`;
+    const audioPath = join2(planDir, "audio.aac");
+    const hasAudio = existsSync3(audioPath) && statSync3(audioPath).size > 0;
     await uploadFileToGcs(storage, planTar, planTarUri, "application/gzip");
     return {
       Action: "plan",
@@ -414,57 +520,38 @@ async function handlePlan(event, deps) {
 async function handlePlanV2(event, deps) {
   const started = Date.now();
   const storage = deps?.storage ?? getStorage();
-  const primitive = deps?.primitives?.planV2 ?? planV2;
+  const primitive = deps?.primitives?.planV2WithPublisher ?? planV2WithPublisher;
   primeChrome(deps);
-  const work = mkdtempSync(join(deps?.tmpRoot ?? tmpdir(), "hf-cr-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-cr-plan-v2-"));
+  const projectArchive = join2(work, "project.tar.gz");
+  const projectDir = join2(work, "project");
   try {
     await downloadGcsObjectToFile(storage, event.ProjectGcsUri, 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.PlanOutputGcsPrefix)}/v2`;
-    const artifactPrefix = `${outputPrefix}/artifacts/sha256`;
-    const uniqueArtifacts = [
-      ...new Map(manifest.artifacts.map((artifact) => [artifact.sha256, artifact])).values()
-    ];
-    await mapConcurrent(uniqueArtifacts, 16, async (artifact) => {
-      await uploadContentAddressedFileToGcs(
-        storage,
-        planV2BlobPath(planV2Dir, artifact.sha256),
-        planV2BlobUri(artifactPrefix, artifact.sha256),
-        artifact.sha256
-      );
-    });
-    const manifestUri = `${outputPrefix}/manifest.json`;
-    await uploadContentAddressedFileToGcs(
+    const publisher = new GcsPlanV2ArtifactPublisher({
       storage,
-      result.manifestPath,
-      manifestUri,
-      await sha256File(result.manifestPath),
-      "application/json"
-    );
+      planOutputGcsPrefix: event.PlanOutputGcsPrefix,
+      temporaryRoot: work
+    });
+    const manifest = await primitive(projectDir, { ...event.Config }, publisher, {
+      stagingParentDir: work
+    });
     return {
       Action: "plan",
       PlanProtocol: "v2",
-      PlanV2ManifestGcsUri: manifestUri,
-      PlanV2ArtifactGcsPrefix: artifactPrefix,
-      PlanHash: result.planHash,
-      ChunkCount: result.chunkCount,
-      TotalFrames: result.totalFrames,
-      Fps: result.fps,
-      Width: result.width,
-      Height: result.height,
-      Format: result.format,
+      PlanV2ManifestGcsUri: publisher.manifestUri,
+      PlanV2ArtifactGcsPrefix: 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"),
       AudioGcsUri: null,
-      FfmpegVersion: result.ffmpegVersion,
-      ProducerVersion: result.producerVersion,
+      FfmpegVersion: manifest.ffmpegVersion,
+      ProducerVersion: manifest.producerVersion,
       DurationMs: Date.now() - started
     };
   } finally {
@@ -479,14 +566,14 @@ async function handleRenderChunk(event, deps) {
   const storage = deps?.storage ?? getStorage();
   const primitive = deps?.primitives?.renderChunk ?? renderChunk;
   primeChrome(deps);
-  const work = mkdtempSync(join(deps?.tmpRoot ?? tmpdir(), "hf-cr-chunk-"));
-  const planTar = join(work, "plan.tar.gz");
-  const planDir = join(work, "plan");
+  const work = mkdtempSync2(join2(deps?.tmpRoot ?? tmpdir2(), "hf-cr-chunk-"));
+  const planTar = join2(work, "plan.tar.gz");
+  const planDir = join2(work, "plan");
   try {
     await downloadGcsObjectToFile(storage, event.PlanGcsUri, 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)}`
     );
@@ -514,7 +601,7 @@ async function handleRenderChunkV2(event, deps) {
   const storage = deps?.storage ?? getStorage();
   const primitive = deps?.primitives?.renderChunk ?? renderChunk;
   primeChrome(deps);
-  const work = mkdtempSync(join(deps?.tmpRoot ?? tmpdir(), "hf-cr-chunk-v2-"));
+  const work = mkdtempSync2(join2(deps?.tmpRoot ?? tmpdir2(), "hf-cr-chunk-v2-"));
   try {
     const planDir = await downloadAndMaterializePlanV2(
       storage,
@@ -522,7 +609,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)}`
     );
@@ -546,7 +633,7 @@ async function handleRenderChunkV2(event, deps) {
   }
 }
 async function uploadChunkOutput(storage, result, prefix, chunkIndex) {
-  const trimmed = trimTrailingSlash(prefix);
+  const trimmed = trimTrailingSlash2(prefix);
   if (result.outputKind === "file") {
     const ext = extname(result.outputPath);
     const uri2 = `${trimmed}/chunks/${pad(chunkIndex)}${ext}`;
@@ -566,22 +653,22 @@ async function handleAssemble(event, deps) {
   const started = Date.now();
   const storage = deps?.storage ?? getStorage();
   const primitive = deps?.primitives?.assemble ?? assemble;
-  const work = mkdtempSync(join(deps?.tmpRoot ?? tmpdir(), "hf-cr-assemble-"));
-  const planTar = join(work, "plan.tar.gz");
-  const planDir = join(work, "plan");
+  const work = mkdtempSync2(join2(deps?.tmpRoot ?? tmpdir2(), "hf-cr-assemble-"));
+  const planTar = join2(work, "plan.tar.gz");
+  const planDir = join2(work, "plan");
   try {
     await downloadGcsObjectToFile(storage, event.PlanGcsUri, planTar);
     await untarDirectory(planTar, planDir);
     const chunkPaths = await downloadChunkObjects(storage, event.ChunkGcsUris, work, event.Format);
     let audioPath = null;
-    const planAudio = join(planDir, "audio.aac");
-    if (existsSync3(planAudio) && statSync2(planAudio).size > 0) {
+    const planAudio = join2(planDir, "audio.aac");
+    if (existsSync3(planAudio) && statSync3(planAudio).size > 0) {
       audioPath = planAudio;
     } else if (event.AudioGcsUri) {
       audioPath = planAudio;
       await downloadGcsObjectToFile(storage, event.AudioGcsUri, 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
     });
@@ -607,12 +694,12 @@ async function handleAssembleV2(event, deps) {
   const started = Date.now();
   const storage = deps?.storage ?? getStorage();
   const primitive = deps?.primitives?.assemble ?? assemble;
-  const work = mkdtempSync(join(deps?.tmpRoot ?? tmpdir(), "hf-cr-assemble-v2-"));
+  const work = mkdtempSync2(join2(deps?.tmpRoot ?? tmpdir2(), "hf-cr-assemble-v2-"));
   try {
     const planDir = await downloadAndMaterializePlanV2(storage, 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(storage, event.ChunkGcsUris, 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
     });
@@ -635,12 +722,12 @@ async function handleAssembleV2(event, deps) {
   }
 }
 async function downloadAndMaterializePlanV2(storage, event, target, work) {
-  const transportDir = join(work, "plan-v2");
-  mkdirSync2(transportDir, { recursive: true });
+  const transportDir = join2(work, "plan-v2");
+  mkdirSync3(transportDir, { recursive: true });
   await downloadGcsObjectToFile(
     storage,
     event.PlanV2ManifestGcsUri,
-    join(transportDir, "plan.json")
+    join2(transportDir, "plan.json")
   );
   const manifest = readPlanV2Manifest(transportDir);
   if (manifest.planHash !== event.PlanHash) {
@@ -653,7 +740,7 @@ async function downloadAndMaterializePlanV2(storage, event, target, work) {
   await mapConcurrent(uniqueArtifacts, 16, async (artifact) => {
     await downloadPlanV2Artifact(storage, event.PlanV2ArtifactGcsPrefix, transportDir, artifact);
   });
-  const planDir = join(work, "plan");
+  const planDir = join2(work, "plan");
   materializePlanV2Target(transportDir, target, planDir);
   return planDir;
 }
@@ -666,10 +753,10 @@ async function downloadPlanV2Artifact(storage, artifactPrefix, planV2Dir, artifa
   );
 }
 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(
@@ -686,11 +773,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(storage, 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) => {
@@ -698,10 +791,10 @@ async function downloadChunkObjects(storage, uris, workDir, format) {
         throw new Error(`[handler] chunk URI at index ${i} is empty`);
       }
       const { key } = parseGcsUri(uri);
-      const localPath = join(chunksDir, basename(key));
+      const localPath = join2(chunksDir, basename(key));
       await downloadGcsObjectToFile(storage, 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 {
@@ -755,17 +848,17 @@ function validateEventGcsUris(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"));
@@ -841,13 +934,13 @@ if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
 }
 
 // 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 { Storage as Storage2 } from "@google-cloud/storage";
 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);
@@ -866,11 +959,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 uploadFileToGcs(storage, tarball, projectGcsUri, "application/gzip");
     return {
       siteId,
@@ -881,7 +974,7 @@ async function deploySite(opts) {
       uploaded: true
     };
   } finally {
-    rmSync3(workdir, { recursive: true, force: true });
+    rmSync4(workdir, { recursive: true, force: true });
   }
 }
 async function headObject(file) {
@@ -1170,6 +1263,7 @@ function getTerraformModuleDir() {
 }
 export {
   ChromeBinaryUnavailableError,
+  GcsPlanV2ArtifactPublisher,
   InvalidConfigError2 as InvalidConfigError,
   computeRenderCost,
   createApp,