@hyperframes/gcp-cloud-run 0.8.231 → 0.9.1

package/README.md

@@ -30,8 +30,8 @@ GCS bucket  ←→  Cloud Run service (plan / renderChunk / assemble)
                 Cloud Workflows  (Plan → parallel RenderChunk → Assemble)
 ```
 
-- **Plan** downloads the project tarball and publishes either a legacy v1
-  planDir tarball or a v2 manifest plus content-addressed artifacts.
+- **Plan** downloads the project tarball and publishes a Plan v2 manifest plus
+  content-addressed artifacts.
 - **RenderChunk** runs in a parallel `for` loop in the workflow, fanned out
   up to the plan's chunk count. Each invocation renders one chunk and uploads
   it.
@@ -43,11 +43,11 @@ The workflow accumulates each step's small result body and returns
 `{ Plan, Chunks, Assemble }` so `getRenderProgress` can read frame totals and
 per-step durations on success.
 
-### Plan transport selection
+### Plan transport
 
-Plan v2 is the default for new renders. When `planProtocol` is omitted,
-`renderToCloudRun` sends an explicit `PlanProtocol: "v2"` so the SDK and
-the deployed workflow agree:
+Plan v2 is the only supported distributed plan transport.
+`renderToCloudRun` sends `PlanProtocol: "v2"` without requiring a protocol
+option:
 
 ```ts
 await renderToCloudRun({
@@ -56,22 +56,17 @@ await renderToCloudRun({
 ```
 
 V2 uses separate manifest and content-addressed artifact locators throughout
-the workflow. Unknown protocols and integrity failures fail closed; a render
-never mixes v1 and v2 artifacts.
-
-The monolithic v1 transport remains available as deprecated compatibility by
-passing `planProtocol: "v1"` explicitly.
+the workflow. Unknown protocols and integrity failures fail closed.
 
 #### Upgrade order
 
 Redeploy the Cloud Run image and Cloud Workflows definition from the same new
 package version before upgrading an application that calls
 `renderToCloudRun`. Pause new renders and drain active workflow executions
-during the infrastructure update. Older workflows can default omission to v1
-or lack the v2 branch, while the new SDK sends explicit v2. If infrastructure
-cannot be redeployed first, keep the previous SDK version or pass
-`planProtocol: "v1"` explicitly until the Terraform/workflow redeploy is
-complete.
+during the infrastructure update. Older workflows may lack the Plan v2-only
+request and locator contract. If infrastructure cannot be redeployed first,
+keep the application on its previous package version until the workflow
+redeploy is complete.
 
 ## Chrome runtime
 

package/dist/events.d.ts

@@ -6,7 +6,7 @@
  * dispatches on the `Action` field of the JSON request body. Each action
  * maps 1:1 onto one of the three OSS distributed primitives:
  *
- *   "plan"        → `plan(projectDir, config, planDir)`        (Activity A)
+ *   "plan"        → `planV2WithPublisher(...)`                (Activity A)
  *   "renderChunk" → `renderChunk(planDir, chunkIndex, output)` (Activity B)
  *   "assemble"    → `assemble(planDir, chunkPaths, audio, out)` (Activity C)
  *
@@ -25,8 +25,6 @@ import type { DistributedFormat, SerializableDistributedRenderConfig } from "@hy
 export type { SerializableDistributedRenderConfig } from "@hyperframes/producer/distributed";
 /** Discriminator for the three roles the one Cloud Run image fulfills. */
 export type CloudRunAction = "plan" | "renderChunk" | "assemble";
-/** Transport protocol selected for one complete distributed render. */
-export type CloudRunPlanProtocol = "v1" | "v2";
 /**
  * Top-level shape of any request body the handler may receive.
  *
@@ -41,7 +39,7 @@ export type CloudRunEvent = PlanEvent | RenderChunkEvent | AssembleEvent | {
     Input: CloudRunEvent;
 };
 /** Activity A: produce a planDir, upload to GCS. */
-interface PlanEventBase {
+export interface PlanEvent {
     Action: "plan";
     /** GCS URI pointing at a `tar -czf`-archived project directory (`gs://bucket/key.tar.gz`). */
     ProjectGcsUri: string;
@@ -49,22 +47,13 @@ interface PlanEventBase {
     PlanOutputGcsPrefix: string;
     /** `DistributedRenderConfig` minus runtime-only fields (logger, abortSignal). */
     Config: SerializableDistributedRenderConfig;
-}
-/**
- * Legacy plan transport. Callers must select it explicitly.
- *
- * @deprecated Use {@link PlanV2Event} for new integrations.
- */
-export interface PlanV1Event extends PlanEventBase {
-    PlanProtocol: "v1";
-}
-/** Default content-addressed v2 plan transport. */
-export interface PlanV2Event extends PlanEventBase {
+    /** Optional for direct handler callers; the SDK and orchestrator send it explicitly. */
     PlanProtocol?: "v2";
 }
-export type PlanEvent = PlanV1Event | PlanV2Event;
+/** Compatibility alias for the only supported plan event. */
+export type PlanV2Event = PlanEvent;
 /** Activity B: fetch planDir, render one chunk, upload result. */
-interface RenderChunkEventBase {
+export interface RenderChunkEvent {
     Action: "renderChunk";
     /**
      * `PlanResult.planHash` from the Plan invocation. The handler verifies
@@ -80,32 +69,14 @@ interface RenderChunkEventBase {
     ChunkOutputGcsPrefix: string;
     /** Output container format from the plan's encoder.json; drives file vs frame-dir handling. */
     Format: DistributedFormat;
-}
-/**
- * Legacy chunk event. Callers must select it explicitly.
- *
- * @deprecated Use {@link RenderChunkV2Event} for new integrations.
- */
-export interface RenderChunkV1Event extends RenderChunkEventBase {
-    PlanProtocol: "v1";
-    /** GCS URI of the v1 plan tar produced by a PlanEvent invocation. */
-    PlanGcsUri: string;
-    PlanV2ManifestGcsUri?: never;
-    PlanV2ArtifactGcsPrefix?: never;
-}
-/**
- * V2 chunk event. It intentionally cannot carry `PlanGcsUri`: the manifest
- * describes the exact content-addressed artifacts needed by this chunk.
- */
-export interface RenderChunkV2Event extends RenderChunkEventBase {
     PlanProtocol?: "v2";
     PlanV2ManifestGcsUri: string;
     PlanV2ArtifactGcsPrefix: string;
-    PlanGcsUri?: never;
 }
-export type RenderChunkEvent = RenderChunkV1Event | RenderChunkV2Event;
+/** Compatibility alias for the only supported chunk event. */
+export type RenderChunkV2Event = RenderChunkEvent;
 /** Activity C: fetch planDir + all chunks + audio, assemble, upload final. */
-interface AssembleEventBase {
+export interface AssembleEvent {
     Action: "assemble";
     /** GCS URIs of every chunk, ordered by chunk index. Length must equal `chunkCount`. */
     ChunkGcsUris: string[];
@@ -123,34 +94,17 @@ interface AssembleEventBase {
      * unset preserves current `-c copy` behavior.
      */
     Cfr?: boolean;
-}
-/**
- * Legacy assemble event. Callers must select it explicitly.
- *
- * @deprecated Use {@link AssembleV2Event} for new integrations.
- */
-export interface AssembleV1Event extends AssembleEventBase {
-    PlanProtocol: "v1";
-    /** GCS URI of the v1 plan tar produced by a PlanEvent invocation. */
-    PlanGcsUri: string;
-    /** Legacy standalone audio locator; `null` when audio is embedded in the v1 plan tar. */
-    AudioGcsUri: string | null;
-    PlanV2ManifestGcsUri?: never;
-    PlanV2ArtifactGcsPrefix?: never;
-}
-/** V2 assemble event, scoped to manifest-declared assembler artifacts. */
-export interface AssembleV2Event extends AssembleEventBase {
     PlanProtocol?: "v2";
     PlanV2ManifestGcsUri: string;
     PlanV2ArtifactGcsPrefix: string;
     PlanHash: string;
-    PlanGcsUri?: never;
     /** V2 audio is a manifest artifact materialized only for the assembler. */
     AudioGcsUri: null;
 }
-export type AssembleEvent = AssembleV1Event | AssembleV2Event;
+/** Compatibility alias for the only supported assemble event. */
+export type AssembleV2Event = AssembleEvent;
 /** Result of a `plan` invocation. Carries enough to size the Map(N) state. */
-interface PlanResultBodyBase {
+export interface PlanResultBody {
     Action: "plan";
     PlanHash: string;
     ChunkCount: number;
@@ -160,31 +114,16 @@ interface PlanResultBodyBase {
     Height: number;
     Format: DistributedFormat;
     HasAudio: boolean;
-    AudioGcsUri: string | null;
     FfmpegVersion: string;
     ProducerVersion: string;
     DurationMs: number;
-}
-/**
- * Existing v1 result. Kept unchanged for wire compatibility.
- *
- * @deprecated New integrations should consume {@link PlanV2ResultBody}.
- */
-export interface PlanV1ResultBody extends PlanResultBodyBase {
-    PlanGcsUri: string;
-    PlanProtocol?: never;
-    PlanV2ManifestGcsUri?: never;
-    PlanV2ArtifactGcsPrefix?: never;
-}
-/** V2 result. The two v2 locators are never aliases for `PlanGcsUri`. */
-export interface PlanV2ResultBody extends PlanResultBodyBase {
     PlanProtocol: "v2";
     PlanV2ManifestGcsUri: string;
     PlanV2ArtifactGcsPrefix: string;
-    PlanGcsUri?: never;
     AudioGcsUri: null;
 }
-export type PlanResultBody = PlanV1ResultBody | PlanV2ResultBody;
+/** Compatibility alias for the only supported plan result. */
+export type PlanV2ResultBody = PlanResultBody;
 /** Result of a `renderChunk` invocation. Sized ≤200 bytes. */
 export interface RenderChunkResultBody {
     Action: "renderChunk";

package/dist/index.d.ts

@@ -18,7 +18,7 @@
  * separately.
  */
 export { createApp, dispatch, type HandlerDeps, startServer, unwrapEvent } from "./server.js";
-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 { type AssembleEvent, type AssembleV2Event, type AssembleResultBody, type CloudRunAction, type CloudRunEvent, type CloudRunResult, type PlanEvent, type PlanResultBody, type PlanV2Event, type PlanV2ResultBody, type RenderChunkEvent, type RenderChunkResultBody, 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";

package/dist/index.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,
@@ -383,27 +381,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;
@@ -412,7 +409,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;
   }
 }
@@ -459,14 +456,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,
@@ -480,51 +477,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;
@@ -566,45 +518,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;
@@ -656,50 +569,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;
@@ -818,10 +687,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
@@ -866,26 +740,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",
@@ -903,13 +757,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"
@@ -948,13 +800,13 @@ if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
 }
 
 // src/sdk/deploySite.ts
-import { mkdtempSync as mkdtempSync3, rmSync as rmSync4, statSync as statSync4 } from "node:fs";
+import { mkdtempSync as mkdtempSync3, rmSync as rmSync4, statSync as statSync3 } 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, listSiteFiles } from "@hyperframes/producer/distributed";
 async function deploySite(opts) {
-  if (!statSync4(opts.projectDir).isDirectory()) {
+  if (!statSync3(opts.projectDir).isDirectory()) {
     throw new Error(`[deploySite] projectDir is not a directory: ${opts.projectDir}`);
   }
   const files = listSiteFiles(opts.projectDir);
@@ -978,7 +830,7 @@ async function deploySite(opts) {
   try {
     const tarball = join3(workdir, "project.tar.gz");
     await tarDirectory(opts.projectDir, tarball, files);
-    const size = statSync4(tarball).size;
+    const size = statSync3(tarball).size;
     await uploadFileToGcs(storage, tarball, projectGcsUri, "application/gzip");
     return {
       siteId,
@@ -1042,7 +894,17 @@ function validateWorkflowsInputSize(input) {
 }
 
 // src/sdk/renderToCloudRun.ts
+function rejectUnsupportedLegacyPlanProtocol(opts) {
+  const planProtocol = Reflect.get(opts, "planProtocol");
+  if (planProtocol === void 0 || planProtocol === "v2") return;
+  const error = new Error(
+    `[renderToCloudRun] planProtocol is no longer configurable; expected "v2" or absent, got ${JSON.stringify(planProtocol)}`
+  );
+  error.name = "PLAN_PROTOCOL_UNSUPPORTED";
+  throw error;
+}
 async function renderToCloudRun(opts) {
+  rejectUnsupportedLegacyPlanProtocol(opts);
   validateDistributedRenderConfig(opts.config);
   if (!opts.bucketName) throw new Error("[renderToCloudRun] bucketName is required");
   if (!opts.projectId) throw new Error("[renderToCloudRun] projectId is required");
@@ -1077,7 +939,7 @@ async function renderToCloudRun(opts) {
     OutputGcsUri: outputGcsUri,
     ServiceUrl: opts.serviceUrl,
     Config: opts.config,
-    PlanProtocol: opts.planProtocol ?? "v2"
+    PlanProtocol: "v2"
   };
   validateWorkflowsInputSize(argument);
   const executions = opts.executions ?? await defaultExecutionsClient();

package/dist/sdk/index.js

@@ -161,7 +161,17 @@ function validateWorkflowsInputSize(input) {
 }
 
 // src/sdk/renderToCloudRun.ts
+function rejectUnsupportedLegacyPlanProtocol(opts) {
+  const planProtocol = Reflect.get(opts, "planProtocol");
+  if (planProtocol === void 0 || planProtocol === "v2") return;
+  const error = new Error(
+    `[renderToCloudRun] planProtocol is no longer configurable; expected "v2" or absent, got ${JSON.stringify(planProtocol)}`
+  );
+  error.name = "PLAN_PROTOCOL_UNSUPPORTED";
+  throw error;
+}
 async function renderToCloudRun(opts) {
+  rejectUnsupportedLegacyPlanProtocol(opts);
   validateDistributedRenderConfig(opts.config);
   if (!opts.bucketName) throw new Error("[renderToCloudRun] bucketName is required");
   if (!opts.projectId) throw new Error("[renderToCloudRun] projectId is required");
@@ -196,7 +206,7 @@ async function renderToCloudRun(opts) {
     OutputGcsUri: outputGcsUri,
     ServiceUrl: opts.serviceUrl,
     Config: opts.config,
-    PlanProtocol: opts.planProtocol ?? "v2"
+    PlanProtocol: "v2"
   };
   validateWorkflowsInputSize(argument);
   const executions = opts.executions ?? await defaultExecutionsClient();

package/dist/sdk/renderToCloudRun.d.ts

@@ -24,7 +24,7 @@
  * separately for polling.
  */
 import type { Storage } from "@google-cloud/storage";
-import type { CloudRunPlanProtocol, SerializableDistributedRenderConfig } from "../events.js";
+import type { SerializableDistributedRenderConfig } from "../events.js";
 import { type SiteHandle } from "./deploySite.js";
 /**
  * Minimal surface of `@google-cloud/workflows`' `ExecutionsClient` that
@@ -50,11 +50,6 @@ export interface RenderToCloudRunOptions {
     siteHandle?: SiteHandle;
     /** Validated `SerializableDistributedRenderConfig` (no logger / abortSignal). */
     config: SerializableDistributedRenderConfig;
-    /**
-     * Distributed plan transport. Defaults to `"v2"`. Select `"v1"`
-     * explicitly only for deprecated compatibility with the monolithic plan.
-     */
-    planProtocol?: CloudRunPlanProtocol;
     /** GCS bucket from the Terraform output (`render_bucket_name`). */
     bucketName: string;
     /** GCP project id hosting the workflow. */

package/dist/server.d.ts

@@ -17,7 +17,7 @@
  */
 import { Storage } from "@google-cloud/storage";
 import { Hono } from "hono";
-import { assemble, type ChunkRenderer, plan, planV2WithPublisher } from "@hyperframes/producer/distributed";
+import { assemble, type ChunkRenderer, planV2WithPublisher } from "@hyperframes/producer/distributed";
 import type { AssembleEvent, CloudRunEvent, CloudRunResult, PlanEvent, RenderChunkEvent } from "./events.js";
 /**
  * Optional injection points used by the handler's unit tests. Production
@@ -27,7 +27,6 @@ import type { AssembleEvent, CloudRunEvent, CloudRunResult, PlanEvent, RenderChu
 export interface HandlerDeps {
     storage?: Storage;
     primitives?: {
-        plan: typeof plan;
         planV2WithPublisher?: typeof planV2WithPublisher;
         renderChunk: ChunkRenderer;
         assemble: typeof assemble;