@hyperframes/gcp-cloud-run 0.8.230 → 0.9.0

package/dist/server.js

@@ -1,5 +1,5 @@
 // src/server.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, mkdtempSync as mkdtempSync2, readFileSync, rmSync as rmSync3, statSync as statSync3 } from "node:fs";
+import { mkdirSync as mkdirSync3, mkdtempSync as mkdtempSync2, rmSync as rmSync3 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { basename, extname, join as join2 } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -10,9 +10,7 @@ import {
   assemble,
   listPlanV2ArtifactsForTarget,
   materializePlanV2Target,
-  plan,
   isPlanAudioArtifactPath,
-  PLAN_AUDIO_RELATIVE_PATH,
   resolvePlanAudioPath,
   planV2WithPublisher,
   readPlanV2Manifest,
@@ -380,27 +378,26 @@ async function dispatch(event, deps) {
 function validatePlanProtocolShape(event) {
   const raw = event;
   const protocol = raw.PlanProtocol;
-  if (protocol !== void 0 && protocol !== "v1" && protocol !== "v2") {
+  if (protocol !== void 0 && protocol !== "v2") {
     const error = new Error(
-      `[handler] unsupported PlanProtocol ${JSON.stringify(protocol)}; expected "v1", "v2", or absent`
+      `[handler] unsupported PlanProtocol ${JSON.stringify(protocol)}; expected "v2" or absent`
     );
     error.name = "PLAN_PROTOCOL_UNSUPPORTED";
     throw error;
   }
   if (event.Action === "plan") return;
-  const effectiveProtocol = protocol ?? "v2";
   const hasV1Locator = typeof raw.PlanGcsUri === "string";
   const hasV2Manifest = typeof raw.PlanV2ManifestGcsUri === "string";
   const hasV2Prefix = typeof raw.PlanV2ArtifactGcsPrefix === "string";
-  const valid = effectiveProtocol === "v2" ? !hasV1Locator && hasV2Manifest && hasV2Prefix : hasV1Locator && !hasV2Manifest && !hasV2Prefix;
+  const valid = !hasV1Locator && hasV2Manifest && hasV2Prefix;
   if (!valid) {
     const error = new Error(
-      `[handler] ${effectiveProtocol} ${event.Action} event has mixed or missing plan locators`
+      `[handler] v2 ${event.Action} event has mixed or missing plan locators`
     );
     error.name = "PLAN_PROTOCOL_UNSUPPORTED";
     throw error;
   }
-  if (effectiveProtocol === "v2" && event.Action === "assemble" && event.AudioGcsUri !== null) {
+  if (event.Action === "assemble" && event.AudioGcsUri !== null) {
     const error = new Error("[handler] v2 assemble audio must be materialized from the manifest");
     error.name = "PLAN_PROTOCOL_UNSUPPORTED";
     throw error;
@@ -409,7 +406,7 @@ function validatePlanProtocolShape(event) {
 function normalizeTerminalErrorName(error) {
   if (!error || typeof error !== "object") return;
   const candidate = error;
-  if (candidate.code === "PLAN_PROTOCOL_UNSUPPORTED" || candidate.code === "PLAN_TOO_LARGE" || candidate.code === "PLAN_V2_INTEGRITY_UNRECOVERABLE" || candidate.code === "FONT_FETCH_FAILED" || candidate.code === "FONT_FETCH_UNAVAILABLE" || candidate.code === "VIDEO_SOURCE_UNRENDERABLE" || candidate.code === "VIDEO_EXTRACTION_FAILED" || candidate.code === "INVALID_VIDEO_METADATA" || candidate.code === "CHUNK_EXCEEDS_WORKER_TIMEOUT") {
+  if (candidate.code === "PLAN_PROTOCOL_UNSUPPORTED" || candidate.code === "PLAN_V2_INTEGRITY_UNRECOVERABLE" || candidate.code === "FONT_FETCH_FAILED" || candidate.code === "FONT_FETCH_UNAVAILABLE" || candidate.code === "VIDEO_SOURCE_UNRENDERABLE" || candidate.code === "VIDEO_EXTRACTION_FAILED" || candidate.code === "INVALID_VIDEO_METADATA" || candidate.code === "CHUNK_EXCEEDS_WORKER_TIMEOUT") {
     candidate.name = candidate.code;
   }
 }
@@ -456,14 +453,14 @@ function summarizeEvent(event) {
     case "renderChunk":
       return {
         planProtocol: event.PlanProtocol ?? "v2",
-        ...event.PlanProtocol !== "v1" ? { planV2ManifestGcsUri: event.PlanV2ManifestGcsUri } : { planGcsUri: event.PlanGcsUri },
+        planV2ManifestGcsUri: event.PlanV2ManifestGcsUri,
         chunkIndex: event.ChunkIndex,
         format: event.Format
       };
     case "assemble":
       return {
         planProtocol: event.PlanProtocol ?? "v2",
-        ...event.PlanProtocol !== "v1" ? { planV2ManifestGcsUri: event.PlanV2ManifestGcsUri } : { planGcsUri: event.PlanGcsUri },
+        planV2ManifestGcsUri: event.PlanV2ManifestGcsUri,
         chunkCount: event.ChunkGcsUris.length,
         hasAudio: event.AudioGcsUri !== null,
         outputGcsUri: event.OutputGcsUri,
@@ -477,51 +474,6 @@ function primeChrome(deps) {
   process.env.PRODUCER_HEADLESS_SHELL_PATH = resolveChromeExecutablePath();
 }
 async function handlePlan(event, deps) {
-  if (event.PlanProtocol !== "v1") {
-    return handlePlanV2(event, deps);
-  }
-  const started = Date.now();
-  const storage = deps?.storage ?? getStorage();
-  const primitive = deps?.primitives?.plan ?? plan;
-  primeChrome(deps);
-  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);
-    const config = {
-      ...event.Config
-    };
-    const result = await primitive(projectDir, config, planDir);
-    const planTar = join2(work, "plan.tar.gz");
-    await tarDirectory(planDir, planTar);
-    const planTarUri = `${trimTrailingSlash2(event.PlanOutputGcsPrefix)}/plan.tar.gz`;
-    const audioPath = join2(planDir, PLAN_AUDIO_RELATIVE_PATH);
-    const hasAudio = existsSync3(audioPath) && statSync3(audioPath).size > 0;
-    await uploadFileToGcs(storage, planTar, planTarUri, "application/gzip");
-    return {
-      Action: "plan",
-      PlanGcsUri: planTarUri,
-      PlanHash: result.planHash,
-      ChunkCount: result.chunkCount,
-      TotalFrames: result.totalFrames,
-      Fps: result.fps,
-      Width: result.width,
-      Height: result.height,
-      Format: result.format,
-      HasAudio: hasAudio,
-      AudioGcsUri: null,
-      FfmpegVersion: result.ffmpegVersion,
-      ProducerVersion: result.producerVersion,
-      DurationMs: Date.now() - started
-    };
-  } finally {
-    cleanupDir(work);
-  }
-}
-async function handlePlanV2(event, deps) {
   const started = Date.now();
   const storage = deps?.storage ?? getStorage();
   const primitive = deps?.primitives?.planV2WithPublisher ?? planV2WithPublisher;
@@ -563,45 +515,6 @@ async function handlePlanV2(event, deps) {
   }
 }
 async function handleRenderChunk(event, deps) {
-  if (event.PlanProtocol !== "v1") {
-    return handleRenderChunkV2(event, deps);
-  }
-  const started = Date.now();
-  const storage = deps?.storage ?? getStorage();
-  const primitive = deps?.primitives?.renderChunk ?? renderChunk;
-  primeChrome(deps);
-  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 = join2(
-      work,
-      event.Format === "png-sequence" ? `chunk-${pad(event.ChunkIndex)}` : `chunk-${pad(event.ChunkIndex)}${formatExtension(event.Format)}`
-    );
-    const result = await primitive(planDir, event.ChunkIndex, chunkOutputBase);
-    const chunkUri = await uploadChunkOutput(
-      storage,
-      result,
-      event.ChunkOutputGcsPrefix,
-      event.ChunkIndex
-    );
-    return {
-      Action: "renderChunk",
-      ChunkGcsUri: chunkUri,
-      ChunkIndex: event.ChunkIndex,
-      Sha256: result.sha256,
-      FramesEncoded: result.framesEncoded,
-      CaptureMode: result.captureMode,
-      DurationMs: Date.now() - started
-    };
-  } finally {
-    cleanupDir(work);
-  }
-}
-async function handleRenderChunkV2(event, deps) {
   const started = Date.now();
   const storage = deps?.storage ?? getStorage();
   const primitive = deps?.primitives?.renderChunk ?? renderChunk;
@@ -653,50 +566,6 @@ async function uploadChunkOutput(storage, result, prefix, chunkIndex) {
   return uri;
 }
 async function handleAssemble(event, deps) {
-  if (event.PlanProtocol !== "v1") {
-    return handleAssembleV2(event, deps);
-  }
-  const started = Date.now();
-  const storage = deps?.storage ?? getStorage();
-  const primitive = deps?.primitives?.assemble ?? assemble;
-  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 = resolvePlanAudioPath(planDir) ?? join2(planDir, PLAN_AUDIO_RELATIVE_PATH);
-    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" ? join2(work, "output-frames") : join2(work, `output${formatExtension(event.Format)}`);
-    const result = await primitive(planDir, chunkPaths, audioPath, finalOutput, {
-      cfr: event.Cfr === true
-    });
-    if (event.Format === "png-sequence") {
-      const tarball = `${finalOutput}.tar.gz`;
-      await tarDirectory(finalOutput, tarball);
-      await uploadFileToGcs(storage, tarball, event.OutputGcsUri, "application/gzip");
-    } else {
-      await uploadFileToGcs(storage, finalOutput, event.OutputGcsUri);
-    }
-    return {
-      Action: "assemble",
-      OutputGcsUri: event.OutputGcsUri,
-      FramesEncoded: result.framesEncoded,
-      FileSize: result.fileSize,
-      DurationMs: Date.now() - started
-    };
-  } finally {
-    cleanupDir(work);
-  }
-}
-async function handleAssembleV2(event, deps) {
   const started = Date.now();
   const storage = deps?.storage ?? getStorage();
   const primitive = deps?.primitives?.assemble ?? assemble;
@@ -815,10 +684,15 @@ function getEventGcsUris(event) {
     case "plan":
       return [event.ProjectGcsUri, event.PlanOutputGcsPrefix];
     case "renderChunk":
-      return event.PlanProtocol !== "v1" ? [event.PlanV2ManifestGcsUri, event.PlanV2ArtifactGcsPrefix, event.ChunkOutputGcsPrefix] : [event.PlanGcsUri, event.ChunkOutputGcsPrefix];
+      return [
+        event.PlanV2ManifestGcsUri,
+        event.PlanV2ArtifactGcsPrefix,
+        event.ChunkOutputGcsPrefix
+      ];
     case "assemble":
       return [
-        ...event.PlanProtocol !== "v1" ? [event.PlanV2ManifestGcsUri, event.PlanV2ArtifactGcsPrefix] : [event.PlanGcsUri],
+        event.PlanV2ManifestGcsUri,
+        event.PlanV2ArtifactGcsPrefix,
         ...event.ChunkGcsUris,
         event.OutputGcsUri,
         event.AudioGcsUri
@@ -863,26 +737,6 @@ function cleanupDir(dir) {
   } catch {
   }
 }
-function verifyPlanHash(planDir, expected) {
-  const planJsonPath = join2(planDir, "plan.json");
-  let parsed;
-  try {
-    parsed = JSON.parse(readFileSync(planJsonPath, "utf-8"));
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    const error = new Error(`PLAN_HASH_MISMATCH: failed to read ${planJsonPath}: ${msg}`);
-    error.name = "PLAN_HASH_MISMATCH";
-    throw error;
-  }
-  const actual = parsed.planHash;
-  if (typeof actual !== "string" || actual !== expected) {
-    const error = new Error(
-      `PLAN_HASH_MISMATCH: event PlanHash=${expected} did not match plan.json planHash=${String(actual)}`
-    );
-    error.name = "PLAN_HASH_MISMATCH";
-    throw error;
-  }
-}
 var NON_RETRYABLE_ERROR_NAMES = /* @__PURE__ */ new Set([
   // Handler-boundary guards.
   "GCS_URI_NOT_ALLOWED",
@@ -900,13 +754,11 @@ var NON_RETRYABLE_ERROR_NAMES = /* @__PURE__ */ new Set([
   // non-retryable list.
   "FormatNotSupportedInDistributedError",
   "NotMediaPayloadError",
-  "PlanTooLargeError",
   "PlanProtocolUnsupportedError",
   "PlanV2IntegrityError",
   "RenderChunkValidationError",
   "FFMPEG_VERSION_MISMATCH",
   "FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED",
-  "PLAN_TOO_LARGE",
   "BROWSER_GPU_NOT_SOFTWARE",
   "FONT_FETCH_FAILED",
   "ChromeBinaryUnavailableError"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/gcp-cloud-run",
-  "version": "0.8.230",
+  "version": "0.9.0",
   "description": "Google Cloud Run + Workflows adapter for HyperFrames distributed rendering — request handler, client-side SDK, and Terraform module.",
   "repository": {
     "type": "git",
@@ -45,7 +45,7 @@
     "hono": "^4.6.0",
     "puppeteer-core": "^25.8.0",
     "tar": "^7.4.3",
-    "@hyperframes/producer": "^0.8.230"
+    "@hyperframes/producer": "^0.9.0"
   },
   "devDependencies": {
     "@types/node": "^25.0.10",

package/terraform/smoke-safety.test.ts

@@ -7,13 +7,11 @@ const smoke = readFileSync(smokePath, "utf-8");
 const dockerfile = readFileSync(join(import.meta.dir, "../Dockerfile"), "utf-8");
 
 describe("GCP smoke ownership and protocol safety", () => {
-  it("defaults to v2 and retains explicit v1/v2 protocol arguments", () => {
-    expect(smoke).toContain('PROTOCOLS="${PROTOCOLS:-v2}"');
-    expect(smoke).toContain("--protocols)");
+  it("runs only the Plan v2 protocol", () => {
+    expect(smoke).toContain('PROTOCOL="v2"');
+    expect(smoke).not.toContain("--protocols)");
     expect(smoke).toContain("PlanProtocol: $protocol");
-    expect(smoke).toContain("decodedFramesEqual");
-    expect(smoke).toContain("decodedAudioEqual");
-    expect(smoke).toContain("normalizedMetadataEqual");
+    expect(smoke).not.toContain("PlanProtocol: v1");
     expect(smoke).toContain('.CaptureMode == "beginframe"');
     expect(smoke).toContain("expected every chunk to use beginframe");
   });

package/terraform/workflow.test.ts

@@ -6,19 +6,12 @@ import { parse } from "yaml";
 type Step = Record<string, unknown>;
 
 const source = readFileSync(join(import.meta.dir, "workflow.yaml"), "utf-8");
-// Cloud Workflows expressions are valid to Google's parser but `${...}`
-// inside YAML flow collections is not valid generic YAML. Quote expressions
-// for structural parsing while preserving their text for contract assertions.
 const parseableSource = source.replace(/\$\{([^}]*)\}/g, (_match, expression: string) =>
   JSON.stringify(`\${${expression}}`),
 );
 const workflow = parse(parseableSource) as {
-  main: {
-    steps: Step[];
-  };
-  retryable: {
-    steps: Step[];
-  };
+  main: { steps: Step[] };
+  retryable: { steps: Step[] };
 };
 
 function namedStep(name: string, steps = workflow.main.steps): Record<string, unknown> {
@@ -28,121 +21,54 @@ function namedStep(name: string, steps = workflow.main.steps): Record<string, un
   throw new Error(`missing workflow step ${name}`);
 }
 
-function requestBody(stepName: string): Record<string, unknown> {
-  const step = namedStep(stepName);
-  const attempt = step.try as {
-    args: {
-      body: Record<string, unknown>;
-    };
-  };
-  return attempt.args.body;
+function requestBody(stepName: "plan" | "assemble"): Record<string, unknown> {
+  return (namedStep(stepName).try as { args: { body: Record<string, unknown> } }).args.body;
 }
 
-function requestAuth(stepName: string): Record<string, unknown> {
-  const step = namedStep(stepName);
-  const attempt = step.try as {
-    args: {
-      auth: Record<string, unknown>;
-    };
-  };
-  return attempt.args.auth;
+function chunkRequestBody(): Record<string, unknown> {
+  const renderChunks = namedStep("renderChunks").parallel as { for: { steps: Step[] } };
+  const render = namedStep("renderOneChunk", renderChunks.for.steps);
+  return (render.try as { args: { body: Record<string, unknown> } }).args.body;
 }
 
-function chunkRequestBody(stepName: string): Record<string, unknown> {
-  const renderChunks = namedStep("renderChunks");
-  const parallel = renderChunks.parallel as {
-    for: {
-      steps: Step[];
-    };
-  };
-  const step = namedStep(stepName, parallel.for.steps);
-  const attempt = step.try as {
-    args: {
-      body: Record<string, unknown>;
-    };
-  };
-  return attempt.args.body;
-}
-
-describe("Cloud Workflows plan protocol routing", () => {
-  it("pins OIDC tokens to the Cloud Run root and retries IAM propagation", () => {
-    for (const stepName of ["planV1", "planV2", "assembleV1", "assembleV2"]) {
-      expect(requestAuth(stepName)).toEqual({
-        type: "OIDC",
-        audience: "${serviceUrl}",
-      });
-    }
-    expect(JSON.stringify(workflow.retryable)).toContain("e.code == 403");
-    expect(source.match(/max_retries: 6/g)).toHaveLength(2);
-    expect(source.match(/max_retries: 4/g)).toHaveLength(4);
-  });
-
-  it("defaults omitted protocol to v2 and rejects unknown protocols before plan", () => {
+describe("Cloud Workflows Plan v2 orchestration", () => {
+  it("defaults an omitted protocol to v2 and rejects every explicit non-v2 value", () => {
     expect(source).toContain('default(map.get(args, "PlanProtocol"), "v2")');
-    expect(namedStep("selectPlanProtocol")).toMatchObject({
+    expect(namedStep("checkPlanProtocol")).toMatchObject({
+      switch: [{ condition: '${planProtocol == "v2"}', next: "plan" }],
       next: "unsupportedPlanProtocol",
     });
     expect(namedStep("unsupportedPlanProtocol")).toMatchObject({
-      raise: {
-        code: "PLAN_PROTOCOL_UNSUPPORTED",
-      },
+      raise: { code: "PLAN_PROTOCOL_UNSUPPORTED" },
     });
   });
 
-  it("uses disjoint v1 and v2 plan request/response contracts", () => {
-    expect(requestBody("planV1")).toMatchObject({
-      Action: "plan",
-      PlanProtocol: "v1",
-    });
-    expect(requestBody("planV2")).toMatchObject({
-      Action: "plan",
-      PlanProtocol: "v2",
-    });
+  it("uses Plan v2 for every distributed action", () => {
+    for (const body of [requestBody("plan"), chunkRequestBody(), requestBody("assemble")]) {
+      expect(body.PlanProtocol).toBe("v2");
+      expect(body).not.toHaveProperty("PlanGcsUri");
+    }
+    expect(chunkRequestBody()).toHaveProperty("PlanV2ManifestGcsUri");
+    expect(chunkRequestBody()).toHaveProperty("PlanV2ArtifactGcsPrefix");
+    expect(requestBody("assemble")).toMatchObject({ AudioGcsUri: null });
+    expect(source).not.toContain("PlanProtocol: v1");
+  });
+
+  it("validates the v2 plan response before fan-out", () => {
     const validation = JSON.stringify(namedStep("validatePlanResult"));
-    expect(validation).toContain("PlanGcsUri");
     expect(validation).toContain("PlanV2ManifestGcsUri");
     expect(validation).toContain("PlanV2ArtifactGcsPrefix");
-    expect(source).toContain('not("PlanGcsUri" in planResult)');
-    expect(source).toContain(
-      '(not("PlanProtocol" in planResult) or planResult.PlanProtocol == "v1")',
-    );
-  });
-
-  it("never mixes v1 and v2 chunk locators", () => {
-    const v1 = chunkRequestBody("renderOneChunkV1");
-    expect(v1).toMatchObject({
-      Action: "renderChunk",
-      PlanProtocol: "v1",
-    });
-    expect(v1).toHaveProperty("PlanGcsUri");
-    expect(v1).not.toHaveProperty("PlanV2ManifestGcsUri");
-    expect(v1).not.toHaveProperty("PlanV2ArtifactGcsPrefix");
-
-    const v2 = chunkRequestBody("renderOneChunkV2");
-    expect(v2).toMatchObject({
-      Action: "renderChunk",
-      PlanProtocol: "v2",
+    expect(validation).toContain("PlanGcsUri");
+    expect(validation).toContain("chunkCount > 0");
+    expect(namedStep("invalidPlanResult")).toMatchObject({
+      raise: { code: "PLAN_RESULT_INVALID" },
     });
-    expect(v2).not.toHaveProperty("PlanGcsUri");
-    expect(v2).toHaveProperty("PlanV2ManifestGcsUri");
-    expect(v2).toHaveProperty("PlanV2ArtifactGcsPrefix");
-    expect(v2).toHaveProperty("PlanHash");
   });
 
-  it("never mixes v1 and v2 assembler locators", () => {
-    const v1 = requestBody("assembleV1");
-    expect(v1).toHaveProperty("PlanGcsUri");
-    expect(v1).not.toHaveProperty("PlanV2ManifestGcsUri");
-    expect(v1).not.toHaveProperty("PlanV2ArtifactGcsPrefix");
-
-    const v2 = requestBody("assembleV2");
-    expect(v2).not.toHaveProperty("PlanGcsUri");
-    expect(v2).toHaveProperty("PlanV2ManifestGcsUri");
-    expect(v2).toHaveProperty("PlanV2ArtifactGcsPrefix");
-    expect(v2).toHaveProperty("PlanHash");
-    expect(v2).toMatchObject({
-      PlanProtocol: "v2",
-      AudioGcsUri: null,
-    });
+  it("pins OIDC tokens to the service and retries transient failures", () => {
+    expect(source.match(/audience: \$\{serviceUrl\}/g)).toHaveLength(3);
+    expect(JSON.stringify(workflow.retryable)).toContain("e.code == 403");
+    expect(source.match(/max_retries: 6/g)).toHaveLength(1);
+    expect(source.match(/max_retries: 4/g)).toHaveLength(2);
   });
 });