@hyperframes/aws-lambda 0.8.231 → 0.9.1

package/README.md

@@ -37,7 +37,7 @@ smoke flow; the SDK + CDK are the supported public surface for adopters.
                               │ pure functions over local paths
                               ▼
 ┌──────────────────────────────────────────────────────────────────┐
-│ S3 bucket — v1 plan tar or v2 manifest/blobs + chunks + output  │
+│ S3 bucket — Plan v2 manifest/blobs + chunks + output            │
 └──────────────────────────────────────────────────────────────────┘
 ```
 
@@ -45,11 +45,11 @@ The handler downloads inputs from S3 into `/tmp`, calls the OSS primitive,
 uploads outputs back to S3, and returns a small JSON result that fits
 inside Step Functions' history budget (under 200 bytes per chunk).
 
-### Plan transport selection
+### Plan transport
 
-Plan v2 is the default for new renders. When `planProtocol` is omitted,
-`renderToLambda` sends an explicit `PlanProtocol: "v2"` so the SDK and the
-deployed state machine agree:
+Plan v2 is the only supported distributed plan transport.
+`renderToLambda` sends `PlanProtocol: "v2"` without requiring a protocol
+option:
 
 ```ts
 await renderToLambda({
@@ -63,8 +63,7 @@ only manifest-selected chunk artifacts, while the assembler fetches its
 own metadata and audio subset. Blobs are immutable SHA-256-addressed
 objects, verified on upload and download, and the manifest is published
 last. Unknown protocols and digest mismatches are terminal Step Functions
-errors. The monolithic v1 transport remains available as deprecated
-compatibility by passing `planProtocol: "v1"` explicitly.
+errors.
 
 #### Upgrade order
 
@@ -78,7 +77,7 @@ infrastructure upgrade. Before upgrading an application that calls
 3. Resume renders, then upgrade the application/SDK dependency.
 
 A site is a `sites/<id>/files.json` file list that an older stack cannot
-read, under either plan protocol. Before it uploads anything,
+read. Before it uploads anything,
 `renderToLambda` reads the state machine definition
 (`states:DescribeStateMachine`) and fails with `STACK_TOO_OLD` when the
 stack predates that format. If infrastructure cannot be redeployed first,

package/dist/_chunks/{chunk-QU5TSGIK.js → chunk-2XZPJGCQ.js}

@@ -21,7 +21,7 @@ import {
 } from "./chunk-4CK3RKM2.js";
 
 // src/handler.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, mkdtempSync as mkdtempSync2, readFileSync, rmSync as rmSync2, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, mkdtempSync as mkdtempSync2, rmSync as rmSync2 } from "node:fs";
 import { availableParallelism, tmpdir as tmpdir2 } from "node:os";
 import { basename, join as join2 } from "node:path";
 import { GetAccountSettingsCommand, InvokeCommand, LambdaClient } from "@aws-sdk/client-lambda";
@@ -35,7 +35,6 @@ import {
   DEFAULT_MAX_PARALLEL_CHUNKS,
   listPlanV2ArtifactsForTarget,
   materializePlanV2Target,
-  plan,
   isPlanAudioArtifactPath,
   PLAN_AUDIO_RELATIVE_PATH,
   resolvePlanAudioPath,
@@ -452,7 +451,7 @@ async function handler(event, deps) {
 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 === "NOT_MEDIA_PAYLOAD" || candidate.code === "VIDEO_SOURCE_UNRENDERABLE" || candidate.code === "VIDEO_EXTRACTION_FAILED" || candidate.code === "INVALID_VIDEO_METADATA" || candidate.code === "FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED" || 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 === "NOT_MEDIA_PAYLOAD" || candidate.code === "VIDEO_SOURCE_UNRENDERABLE" || candidate.code === "VIDEO_EXTRACTION_FAILED" || candidate.code === "INVALID_VIDEO_METADATA" || candidate.code === "FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED" || candidate.code === "CHUNK_EXCEEDS_WORKER_TIMEOUT") {
     candidate.name = candidate.code;
   }
 }
@@ -486,22 +485,20 @@ function isLambdaAction(value) {
 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" || event.Action === "audio") return;
-  const effectiveProtocol = protocol ?? "v2";
   const hasV1Locator = typeof raw.PlanS3Uri === "string";
   const hasV2Manifest = typeof raw.PlanV2ManifestS3Uri === "string";
   const hasV2Prefix = typeof raw.PlanV2ArtifactS3Prefix === "string";
-  const valid = effectiveProtocol === "v2" ? !hasV1Locator && hasV2Manifest && hasV2Prefix : hasV1Locator && !hasV2Manifest && !hasV2Prefix;
-  if (!valid) {
+  if (hasV1Locator || !hasV2Manifest || !hasV2Prefix) {
     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;
@@ -516,7 +513,7 @@ function summarizeEvent(event) {
       return {
         projectS3Uri: event.ProjectS3Uri,
         planOutputS3Prefix: event.PlanOutputS3Prefix,
-        planProtocol: event.PlanProtocol ?? "v2",
+        planProtocol: "v2",
         format: event.Config.format,
         fps: event.Config.fps
       };
@@ -529,15 +526,15 @@ function summarizeEvent(event) {
       };
     case "renderChunk":
       return {
-        planProtocol: event.PlanProtocol ?? "v2",
-        ...event.PlanProtocol !== "v1" ? { planV2ManifestS3Uri: event.PlanV2ManifestS3Uri } : { planS3Uri: event.PlanS3Uri },
+        planProtocol: "v2",
+        planV2ManifestS3Uri: event.PlanV2ManifestS3Uri,
         chunkIndex: event.ChunkIndex,
         format: event.Format
       };
     case "assemble":
       return {
-        planProtocol: event.PlanProtocol ?? "v2",
-        ...event.PlanProtocol !== "v1" ? { planV2ManifestS3Uri: event.PlanV2ManifestS3Uri } : { planS3Uri: event.PlanS3Uri },
+        planProtocol: "v2",
+        planV2ManifestS3Uri: event.PlanV2ManifestS3Uri,
         chunkCount: event.ChunkS3Uris.length,
         hasAudio: event.AudioS3Uri !== null,
         outputS3Uri: event.OutputS3Uri,
@@ -596,53 +593,6 @@ async function planConfig(event, deps) {
   }
   return config;
 }
-async function handlePlan(event, deps) {
-  if (event.PlanProtocol !== "v1") {
-    return handlePlanV2(event, deps);
-  }
-  const started = Date.now();
-  const config = await planConfig(event, deps);
-  const s3 = deps?.s3 ?? getS3Client();
-  const primitive = deps?.primitives?.plan ?? plan;
-  await ensureChromePath(deps);
-  const work = mkdtempSync2(join2(deps?.tmpRoot ?? tmpdir2(), "hf-lambda-plan-"));
-  const planDir = join2(work, "plan");
-  try {
-    const { projectDir } = await fetchProject(s3, event.ProjectS3Uri, work);
-    const result = await primitive(projectDir, config, planDir, {
-      chunksCarryAudio: true
-    });
-    const planTar = join2(work, "plan.tar.gz");
-    await tarDirectory(planDir, planTar);
-    const planTarUri = `${trimTrailingSlash2(event.PlanOutputS3Prefix)}/plan.tar.gz`;
-    const audioPath = join2(planDir, PLAN_AUDIO_RELATIVE_PATH);
-    const hasAudio = existsSync2(audioPath) && statSync2(audioPath).size > 0;
-    const audioUri = hasAudio ? `${trimTrailingSlash2(event.PlanOutputS3Prefix)}/${PLAN_AUDIO_RELATIVE_PATH}` : null;
-    await Promise.all([
-      uploadFileToS3(s3, planTar, planTarUri, "application/gzip"),
-      hasAudio && audioUri ? uploadFileToS3(s3, audioPath, audioUri, "audio/aac") : null
-    ]);
-    return {
-      Action: "plan",
-      PlanS3Uri: planTarUri,
-      PlanHash: result.planHash,
-      ChunkCount: result.chunkCount,
-      MaxChunkConcurrency: Math.min(config.workerConcurrency, result.chunkCount),
-      TotalFrames: result.totalFrames,
-      Fps: result.fps,
-      Width: result.width,
-      Height: result.height,
-      Format: result.format,
-      HasAudio: audioUri !== null,
-      AudioS3Uri: audioUri,
-      FfmpegVersion: result.ffmpegVersion,
-      ProducerVersion: result.producerVersion,
-      DurationMs: Date.now() - started
-    };
-  } finally {
-    cleanupDir(work);
-  }
-}
 async function fetchProject(s3, projectS3Uri, work, leaveVideosRemote = false) {
   const projectDir = join2(work, "project");
   if (isSiteManifestUri(projectS3Uri)) {
@@ -658,7 +608,7 @@ async function fetchProject(s3, projectS3Uri, work, leaveVideosRemote = false) {
   logEvent({ event: "plan_stage", stage: "untar", ms: Date.now() - stageStarted });
   return { projectDir, remoteFiles: {} };
 }
-async function handlePlanV2(event, deps) {
+async function handlePlan(event, deps) {
   const started = Date.now();
   const config = await planConfig(event, deps);
   const s3 = deps?.s3 ?? getS3Client();
@@ -750,58 +700,6 @@ function lambdaMaxCaptureWorkers() {
   return Math.max(1, Math.min(byMemory, availableParallelism() - 1));
 }
 async function handleRenderChunk(event, deps) {
-  if (event.PlanProtocol !== "v1") {
-    return handleRenderChunkV2(event, deps);
-  }
-  const started = Date.now();
-  const s3 = deps?.s3 ?? getS3Client();
-  const primitive = deps?.primitives?.renderChunk ?? renderChunk;
-  const chromeStarted = Date.now();
-  await ensureChromePath(deps);
-  const chromeMs = Date.now() - chromeStarted;
-  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 = join2(
-      work,
-      event.Format === "png-sequence" ? `chunk-${pad(event.ChunkIndex)}` : `chunk-${pad(event.ChunkIndex)}${formatExtension(event.Format)}`
-    );
-    const primitiveStarted = Date.now();
-    const result = await primitive(planDir, event.ChunkIndex, chunkOutputBase, {
-      maxCaptureWorkers: lambdaMaxCaptureWorkers(),
-      interleaveCapture: true
-    });
-    logEvent({
-      event: "chunk_capture",
-      chunkIndex: event.ChunkIndex,
-      workers: result.workers,
-      captureMode: result.captureMode,
-      ...chunkStageTimings(result, primitiveStarted - started, chromeMs)
-    });
-    const chunkUri = await uploadChunkOutput(
-      s3,
-      result,
-      event.ChunkOutputS3Prefix,
-      event.ChunkIndex
-    );
-    return {
-      Action: "renderChunk",
-      ChunkS3Uri: 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 s3 = deps?.s3 ?? getS3Client();
   const primitive = deps?.primitives?.renderChunk ?? renderChunk;
@@ -878,47 +776,6 @@ async function uploadChunkOutput(s3, result, prefix, chunkIndex) {
   return uri;
 }
 async function handleAssemble(event, deps) {
-  if (event.PlanProtocol !== "v1") {
-    return handleAssembleV2(event, deps);
-  }
-  const started = Date.now();
-  const s3 = deps?.s3 ?? getS3Client();
-  const primitive = deps?.primitives?.assemble ?? assemble;
-  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 = resolvePlanAudioPath(planDir) ?? join2(planDir, PLAN_AUDIO_RELATIVE_PATH);
-      await downloadS3ObjectToFile(s3, event.AudioS3Uri, 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 uploadFileToS3(s3, tarball, event.OutputS3Uri, "application/gzip");
-    } else {
-      await uploadFileToS3(s3, finalOutput, event.OutputS3Uri);
-    }
-    return {
-      Action: "assemble",
-      OutputS3Uri: event.OutputS3Uri,
-      FramesEncoded: result.framesEncoded,
-      FileSize: result.fileSize,
-      DurationMs: Date.now() - started
-    };
-  } finally {
-    cleanupDir(work);
-  }
-}
-async function handleAssembleV2(event, deps) {
   const started = Date.now();
   const s3 = deps?.s3 ?? getS3Client();
   const primitive = deps?.primitives?.assemble ?? assemble;
@@ -976,10 +833,10 @@ async function handleAssembleV2(event, deps) {
     cleanupDir(work);
   }
 }
-async function stitchChunksInS3(s3, event, plan2, started, lambda) {
-  if (event.ChunkS3Uris.length !== plan2.chunkCount) {
+async function stitchChunksInS3(s3, event, plan, started, lambda) {
+  if (event.ChunkS3Uris.length !== plan.chunkCount) {
     throw new Error(
-      `[handler] ${event.ChunkS3Uris.length} chunk URIs for a plan of ${plan2.chunkCount} chunks`
+      `[handler] ${event.ChunkS3Uris.length} chunk URIs for a plan of ${plan.chunkCount} chunks`
     );
   }
   const stitchStarted = Date.now();
@@ -1000,7 +857,7 @@ async function stitchChunksInS3(s3, event, plan2, started, lambda) {
   return {
     Action: "assemble",
     OutputS3Uri: event.OutputS3Uri,
-    FramesEncoded: plan2.totalFrames,
+    FramesEncoded: plan.totalFrames,
     FileSize: stitched.fileSize,
     DurationMs: Date.now() - started
   };
@@ -1095,10 +952,11 @@ function getEventS3Uris(event) {
     case "audio":
       return [event.ProjectS3Uri, event.PlanOutputS3Prefix];
     case "renderChunk":
-      return event.PlanProtocol !== "v1" ? [event.PlanV2ManifestS3Uri, event.PlanV2ArtifactS3Prefix, event.ChunkOutputS3Prefix] : [event.PlanS3Uri, event.ChunkOutputS3Prefix];
+      return [event.PlanV2ManifestS3Uri, event.PlanV2ArtifactS3Prefix, event.ChunkOutputS3Prefix];
     case "assemble":
       return [
-        ...event.PlanProtocol !== "v1" ? [event.PlanV2ManifestS3Uri, event.PlanV2ArtifactS3Prefix] : [event.PlanS3Uri],
+        event.PlanV2ManifestS3Uri,
+        event.PlanV2ArtifactS3Prefix,
         ...event.ChunkS3Uris,
         event.OutputS3Uri,
         event.AudioS3Uri
@@ -1168,26 +1026,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;
-  }
-}
 
 export {
   ChromeBinaryUnavailableError,

package/dist/_chunks/{chunk-Q6NRBJWH.js → chunk-JZCUNVDN.js}

@@ -221,7 +221,17 @@ function validateStepFunctionsInputSize(input) {
 import { randomUUID } from "node:crypto";
 import { DescribeStateMachineCommand, SFNClient, StartExecutionCommand } from "@aws-sdk/client-sfn";
 import { S3Client as S3Client2 } from "@aws-sdk/client-s3";
+function rejectUnsupportedLegacyPlanProtocol(opts) {
+  const planProtocol = Reflect.get(opts, "planProtocol");
+  if (planProtocol === void 0 || planProtocol === "v2") return;
+  const error = new Error(
+    `[renderToLambda] planProtocol is no longer configurable; expected "v2" or absent, got ${JSON.stringify(planProtocol)}`
+  );
+  error.name = "PLAN_PROTOCOL_UNSUPPORTED";
+  throw error;
+}
 async function renderToLambda(opts) {
+  rejectUnsupportedLegacyPlanProtocol(opts);
   validateDistributedRenderConfig(opts.config);
   if (!opts.bucketName) {
     throw new Error("[renderToLambda] bucketName is required");
@@ -258,7 +268,7 @@ async function renderToLambda(opts) {
     PlanOutputS3Prefix: planOutputS3Prefix,
     OutputS3Uri: outputS3Uri,
     Config: opts.config,
-    PlanProtocol: opts.planProtocol ?? "v2"
+    PlanProtocol: "v2"
   };
   validateStepFunctionsInputSize(input);
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();

package/dist/cdk/index.js

@@ -160,8 +160,6 @@ var HyperframesRenderStack = class extends Construct {
       "S3_URI_NOT_ALLOWED",
       "BROWSER_GPU_NOT_SOFTWARE",
       "FONT_FETCH_FAILED",
-      "PLAN_TOO_LARGE",
-      "PlanTooLargeError",
       "PLAN_PROTOCOL_UNSUPPORTED",
       "PlanProtocolUnsupportedError",
       "PLAN_V2_INTEGRITY_UNRECOVERABLE",
@@ -181,8 +179,6 @@ var HyperframesRenderStack = class extends Construct {
       "PLAN_HASH_MISMATCH",
       "S3_URI_NOT_ALLOWED",
       "BROWSER_GPU_NOT_SOFTWARE",
-      "PLAN_TOO_LARGE",
-      "PlanTooLargeError",
       "PLAN_PROTOCOL_UNSUPPORTED",
       "PlanProtocolUnsupportedError",
       "PLAN_V2_INTEGRITY_UNRECOVERABLE",
@@ -200,8 +196,6 @@ var HyperframesRenderStack = class extends Construct {
       "PLAN_V2_INTEGRITY_UNRECOVERABLE",
       "PlanV2IntegrityError",
       "FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED",
-      "PLAN_TOO_LARGE",
-      "PlanTooLargeError",
       "PLAN_ARTIFACT_DIGEST_MISMATCH",
       "ChromeBinaryUnavailableError"
     ];
@@ -213,39 +207,6 @@ var HyperframesRenderStack = class extends Construct {
       maxDelay: Duration.seconds(60),
       jitterStrategy: sfn.JitterType.FULL
     };
-    const plan = new tasks.LambdaInvoke(this, "Plan", {
-      lambdaFunction: this.renderFunction,
-      payload: sfn.TaskInput.fromObject({
-        Action: "plan",
-        PlanProtocol: "v1",
-        "ProjectS3Uri.$": "$.ProjectS3Uri",
-        "PlanOutputS3Prefix.$": "$.PlanOutputS3Prefix",
-        "Config.$": "$.Config"
-      }),
-      resultSelector: {
-        PlanProtocol: "v1",
-        "PlanS3Uri.$": "$.Payload.PlanS3Uri",
-        "PlanHash.$": "$.Payload.PlanHash",
-        "ChunkCount.$": "$.Payload.ChunkCount",
-        "MaxChunkConcurrency.$": "$.Payload.MaxChunkConcurrency",
-        "Format.$": "$.Payload.Format",
-        "HasAudio.$": "$.Payload.HasAudio",
-        "AudioS3Uri.$": "$.Payload.AudioS3Uri"
-      },
-      resultPath: "$.Plan"
-    });
-    plan.addRetry({
-      errors: NON_RETRYABLE_PLAN,
-      maxAttempts: 0
-    });
-    plan.addRetry(THROTTLED_RETRY);
-    plan.addRetry({
-      errors: ["States.ALL"],
-      interval: Duration.seconds(2),
-      maxAttempts: 4,
-      backoffRate: 2,
-      maxDelay: Duration.seconds(60)
-    });
     const planV2 = new tasks.LambdaInvoke(this, "PlanV2", {
       lambdaFunction: this.renderFunction,
       payload: sfn.TaskInput.fromObject({
@@ -284,87 +245,9 @@ var HyperframesRenderStack = class extends Construct {
       resultPath: "$.Iterator"
     });
     const planProducedZero = new sfn.Fail(this, "PlanProducedZeroChunks", {
-      error: "PLAN_TOO_LARGE",
+      error: "PLAN_EMPTY",
       cause: "Plan returned ChunkCount=0 \u2014 non-retryable producer-side invariant violation."
     });
-    const renderChunkTask = new tasks.LambdaInvoke(this, "RenderChunk", {
-      lambdaFunction: this.renderFunction,
-      payload: sfn.TaskInput.fromObject({
-        Action: "renderChunk",
-        PlanProtocol: "v1",
-        "ChunkIndex.$": "$.ChunkIndex",
-        "PlanS3Uri.$": "$.PlanS3Uri",
-        "PlanHash.$": "$.PlanHash",
-        "ChunkOutputS3Prefix.$": "$.ChunkOutputS3Prefix",
-        "Format.$": "$.Format"
-      }),
-      resultSelector: {
-        "ChunkS3Uri.$": "$.Payload.ChunkS3Uri",
-        "ChunkIndex.$": "$.Payload.ChunkIndex",
-        "Sha256.$": "$.Payload.Sha256",
-        "FramesEncoded.$": "$.Payload.FramesEncoded",
-        "DurationMs.$": "$.Payload.DurationMs"
-      }
-    });
-    renderChunkTask.addRetry({
-      errors: NON_RETRYABLE_CHUNK,
-      maxAttempts: 0
-    });
-    renderChunkTask.addRetry(THROTTLED_RETRY);
-    renderChunkTask.addRetry({
-      errors: ["States.ALL"],
-      interval: Duration.seconds(2),
-      maxAttempts: 4,
-      backoffRate: 2,
-      maxDelay: Duration.seconds(60)
-    });
-    const renderChunks = new sfn.DistributedMap(this, "RenderChunks", {
-      label: "RenderChunks",
-      // Standard-type children: express ones stop at 5 minutes and a chunk may run the Lambda's full 15.
-      mapExecutionType: sfn.StateMachineType.STANDARD,
-      itemsPath: "$.Iterator.ChunkIndexes",
-      itemSelector: {
-        "ChunkIndex.$": "$$.Map.Item.Value",
-        "PlanS3Uri.$": "$.Plan.PlanS3Uri",
-        "PlanHash.$": "$.Plan.PlanHash",
-        "ChunkOutputS3Prefix.$": "$.PlanOutputS3Prefix",
-        "Format.$": "$.Plan.Format"
-      },
-      // Chunks past the plan's concurrency queue here instead of being throttled by Lambda.
-      maxConcurrencyPath: "$.Plan.MaxChunkConcurrency",
-      resultPath: "$.Chunks"
-    });
-    renderChunks.itemProcessor(renderChunkTask);
-    const assemble = new tasks.LambdaInvoke(this, "Assemble", {
-      lambdaFunction: this.renderFunction,
-      payload: sfn.TaskInput.fromObject({
-        Action: "assemble",
-        PlanProtocol: "v1",
-        "PlanS3Uri.$": "$.Plan.PlanS3Uri",
-        "ChunkS3Uris.$": "$.Chunks[*].ChunkS3Uri",
-        "AudioS3Uri.$": "$.Plan.AudioS3Uri",
-        "OutputS3Uri.$": "$.OutputS3Uri",
-        "Format.$": "$.Plan.Format"
-      }),
-      resultSelector: {
-        "OutputS3Uri.$": "$.Payload.OutputS3Uri",
-        "FramesEncoded.$": "$.Payload.FramesEncoded",
-        "FileSize.$": "$.Payload.FileSize"
-      },
-      resultPath: "$.Output"
-    });
-    assemble.addRetry({
-      errors: NON_RETRYABLE_ASSEMBLE,
-      maxAttempts: 0
-    });
-    assemble.addRetry(THROTTLED_RETRY);
-    assemble.addRetry({
-      errors: ["States.ALL"],
-      interval: Duration.seconds(2),
-      maxAttempts: 4,
-      backoffRate: 2,
-      maxDelay: Duration.seconds(60)
-    });
     const renderChunkV2Task = new tasks.LambdaInvoke(this, "RenderChunkV2", {
       lambdaFunction: this.renderFunction,
       payload: sfn.TaskInput.fromObject({
@@ -472,16 +355,14 @@ var HyperframesRenderStack = class extends Construct {
       resultSelector: { "Chunks.$": "$[0].Chunks", "Audio.$": "$[1].Audio" },
       resultPath: "$.Render"
     }).branch(renderChunksV2).branch(audioNeeded);
-    const selectWorkerProtocol = new sfn.Choice(this, "SelectWorkerProtocol").when(sfn.Condition.stringEquals("$.Plan.PlanProtocol", "v2"), renderV2.next(assembleV2)).otherwise(renderChunks.next(assemble));
-    const assertChunkCount = new sfn.Choice(this, "AssertChunkCount").when(sfn.Condition.numberGreaterThan("$.Plan.ChunkCount", 0), selectWorkerProtocol).otherwise(planProducedZero);
-    plan.next(buildChunkList);
+    const assertChunkCount = new sfn.Choice(this, "AssertChunkCount").when(sfn.Condition.numberGreaterThan("$.Plan.ChunkCount", 0), renderV2.next(assembleV2)).otherwise(planProducedZero);
     planV2.next(buildChunkList);
     buildChunkList.next(assertChunkCount);
     const unsupportedPlanProtocol = new sfn.Fail(this, "UnsupportedPlanProtocol", {
       error: "PLAN_PROTOCOL_UNSUPPORTED",
-      cause: 'PlanProtocol must be "v1", "v2", or absent (defaults to v2).'
+      cause: 'PlanProtocol must be "v2" or absent (defaults to v2).'
     });
-    return new sfn.Choice(this, "SelectPlanProtocol").when(sfn.Condition.stringEquals("$.PlanProtocol", "v2"), planV2).when(sfn.Condition.stringEquals("$.PlanProtocol", "v1"), plan).when(sfn.Condition.isPresent("$.PlanProtocol"), unsupportedPlanProtocol).otherwise(planV2);
+    return new sfn.Choice(this, "SelectPlanProtocol").when(sfn.Condition.isNotPresent("$.PlanProtocol"), planV2).when(sfn.Condition.stringEquals("$.PlanProtocol", "v2"), planV2).when(sfn.Condition.isPresent("$.PlanProtocol"), unsupportedPlanProtocol).otherwise(planV2);
   }
 };
 function defaultHandlerZipPath() {

package/dist/events.d.ts

@@ -5,7 +5,7 @@
  * dispatches on the `Action` field. 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)
  *
@@ -37,8 +37,6 @@ export interface StitchPartsEvent {
         }[];
     }[];
 }
-/** Transport protocol selected for one complete distributed render. */
-export type LambdaPlanProtocol = "v1" | "v2";
 /**
  * Top-level shape of any event the handler may receive.
  *
@@ -53,7 +51,7 @@ export type LambdaEvent = PlanEvent | AudioEvent | RenderChunkEvent | AssembleEv
     Input: LambdaEvent;
 };
 /** Activity A: produce a planDir, upload to S3. */
-interface PlanEventBase {
+export interface PlanEvent {
     Action: "plan";
     /** S3 URI pointing at a `tar -czf`-archived project directory (`s3://bucket/key.tar.gz`). */
     ProjectS3Uri: string;
@@ -61,33 +59,23 @@ interface PlanEventBase {
     PlanOutputS3Prefix: 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;
 /** Makes a v2 plan's audio beside its chunks, from the same project and config as the plan. */
-export interface AudioEvent extends Omit<PlanEventBase, "Action"> {
+export interface AudioEvent extends Omit<PlanEvent, "Action" | "PlanProtocol"> {
     Action: "audio";
 }
 /** Activity B: fetch planDir, render one chunk, upload result. */
-interface RenderChunkEventBase {
+export interface RenderChunkEvent {
     Action: "renderChunk";
     /**
-     * `PlanResult.planHash` from the Plan invocation. For v1, the handler
-     * verifies it against the untarred planDir's `plan.json`; for v2, it
-     * verifies it against the content-addressed manifest before invoking the
-     * producer. Divergence throws a typed `PLAN_HASH_MISMATCH` so the state
-     * machine routes it as non-retryable.
+     * `PlanResult.planHash` from the Plan invocation. The handler verifies it
+     * against the content-addressed manifest before invoking the producer.
+     * Divergence throws a typed `PLAN_HASH_MISMATCH` so the state machine routes
+     * it as non-retryable.
      */
     PlanHash: string;
     /** 0-based chunk index this invocation should render. */
@@ -96,29 +84,14 @@ interface RenderChunkEventBase {
     ChunkOutputS3Prefix: 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";
-    /** S3 URI of the v1 plan tar produced by a PlanEvent invocation. */
-    PlanS3Uri: string;
-}
-/**
- * V2 chunk event. It intentionally cannot carry `PlanS3Uri`: the manifest
- * describes the exact content-addressed artifacts needed by this chunk.
- */
-export interface RenderChunkV2Event extends RenderChunkEventBase {
     PlanProtocol?: "v2";
     PlanV2ManifestS3Uri: string;
     PlanV2ArtifactS3Prefix: string;
 }
-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";
     /** S3 URIs of every chunk, ordered by chunk index. Length must equal `chunkCount`. */
     ChunkS3Uris: string[];
@@ -138,27 +111,15 @@ 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";
-    /** S3 URI of the v1 plan tar produced by a PlanEvent invocation. */
-    PlanS3Uri: string;
-}
-/** V2 assemble event, scoped to manifest-declared assembler artifacts. */
-export interface AssembleV2Event extends AssembleEventBase {
     PlanProtocol?: "v2";
     PlanV2ManifestS3Uri: string;
     PlanV2ArtifactS3Prefix: string;
     PlanHash: string;
 }
-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 PlanLambdaResultBase {
+export interface PlanLambdaResult {
     Action: "plan";
     PlanHash: string;
     ChunkCount: number;
@@ -173,24 +134,14 @@ interface PlanLambdaResultBase {
     FfmpegVersion: string;
     ProducerVersion: string;
     DurationMs: number;
-}
-/**
- * Existing v1 result. Kept unchanged for wire compatibility.
- *
- * @deprecated New integrations should consume {@link PlanV2LambdaResult}.
- */
-export interface PlanV1LambdaResult extends PlanLambdaResultBase {
-    PlanS3Uri: string;
-}
-/** V2 result. The two v2 locators are never aliases for `PlanS3Uri`. */
-export interface PlanV2LambdaResult extends PlanLambdaResultBase {
     PlanProtocol: "v2";
     PlanV2ManifestS3Uri: string;
     PlanV2ArtifactS3Prefix: string;
     /** The plan left its audio to the audio task, which has a worker kept free for it. */
     SeparateAudio: boolean;
 }
-export type PlanLambdaResult = PlanV1LambdaResult | PlanV2LambdaResult;
+/** Compatibility alias for the only supported plan result. */
+export type PlanV2LambdaResult = PlanLambdaResult;
 export interface AudioLambdaResult {
     Action: "audio";
     HasAudio: boolean;

package/dist/handler.d.ts

@@ -12,7 +12,7 @@
  */
 import { LambdaClient } from "@aws-sdk/client-lambda";
 import { S3Client } from "@aws-sdk/client-s3";
-import { assemble, buildPlanAudio, type ChunkRenderer, plan, planV2WithPublisher } from "@hyperframes/producer/distributed";
+import { assemble, buildPlanAudio, type ChunkRenderer, planV2WithPublisher } from "@hyperframes/producer/distributed";
 import { type StitchHelper } from "./s3Stitch.js";
 import type { AssembleEvent, AudioEvent, LambdaEvent, LambdaResult, PlanEvent, RenderChunkEvent } from "./events.js";
 /**
@@ -27,7 +27,6 @@ export interface HandlerDeps {
     /** Reads the account's concurrency when the render does not set one. */
     lambda?: LambdaClient;
     primitives?: {
-        plan: typeof plan;
         planV2WithPublisher?: typeof planV2WithPublisher;
         buildPlanAudio?: typeof buildPlanAudio;
         renderChunk: ChunkRenderer;

package/dist/handler.js

@@ -2,7 +2,7 @@ import {
   handler,
   stitchHelper,
   unwrapEvent
-} from "./_chunks/chunk-QU5TSGIK.js";
+} from "./_chunks/chunk-2XZPJGCQ.js";
 import "./_chunks/chunk-6TIVMKTV.js";
 import "./_chunks/chunk-4CK3RKM2.js";
 export {

package/dist/index.d.ts

@@ -22,7 +22,7 @@
  * install it separately.
  */
 export { handler, type HandlerDeps, unwrapEvent } from "./handler.js";
-export { type AssembleEvent, type AssembleLambdaResult, type LambdaAction, type LambdaEvent, type LambdaPlanProtocol, type LambdaResult, type PlanEvent, type PlanLambdaResult, type PlanV1Event, type PlanV1LambdaResult, type PlanV2Event, type PlanV2LambdaResult, type RenderChunkEvent, type RenderChunkLambdaResult, type RenderChunkV1Event, type RenderChunkV2Event, type AssembleV1Event, type AssembleV2Event, type SerializableDistributedRenderConfig, } from "./events.js";
+export { type AssembleEvent, type AssembleLambdaResult, type LambdaAction, type LambdaEvent, type LambdaResult, type PlanEvent, type PlanLambdaResult, type PlanV2Event, type PlanV2LambdaResult, type RenderChunkEvent, type RenderChunkLambdaResult, type RenderChunkV2Event, type AssembleV2Event, type SerializableDistributedRenderConfig, } from "./events.js";
 export { ChromeBinaryUnavailableError, type ChromeSource, resolveChromeArgs, resolveChromeExecutablePath, resolveChromeSource, } from "./chromium.js";
 export { downloadS3ObjectToFile, downloadS3ObjectToFileVerified, formatS3Uri, parseS3Uri, type S3Location, tarDirectory, untarDirectory, uploadContentAddressedFileToS3, uploadFileToS3, } from "./s3Transport.js";
 export { S3PlanV2ArtifactPublisher, type S3PlanV2ArtifactPublisherOptions, } from "./s3PlanV2Publisher.js";

package/dist/index.js

@@ -6,7 +6,7 @@ import {
   resolveChromeExecutablePath,
   resolveChromeSource,
   unwrapEvent
-} from "./_chunks/chunk-QU5TSGIK.js";
+} from "./_chunks/chunk-2XZPJGCQ.js";
 import {
   InvalidConfigError,
   computeRenderCost,
@@ -14,7 +14,7 @@ import {
   getRenderProgress,
   renderToLambda,
   validateDistributedRenderConfig
-} from "./_chunks/chunk-Q6NRBJWH.js";
+} from "./_chunks/chunk-JZCUNVDN.js";
 import {
   downloadS3ObjectToFile,
   downloadS3ObjectToFileVerified,

package/dist/sdk/index.js

@@ -10,7 +10,7 @@ import {
   validateDistributedRenderConfig,
   validateStepFunctionsInputSize,
   validateVariablesPayload
-} from "../_chunks/chunk-Q6NRBJWH.js";
+} from "../_chunks/chunk-JZCUNVDN.js";
 import {
   sha256File
 } from "../_chunks/chunk-6TIVMKTV.js";

package/dist/sdk/renderToLambda.d.ts

@@ -18,7 +18,7 @@
  */
 import { SFNClient } from "@aws-sdk/client-sfn";
 import { S3Client } from "@aws-sdk/client-s3";
-import type { LambdaPlanProtocol, SerializableDistributedRenderConfig } from "../events.js";
+import type { SerializableDistributedRenderConfig } from "../events.js";
 import { type SiteHandle } from "./deploySite.js";
 /** Options for {@link renderToLambda}. */
 export interface RenderToLambdaOptions {
@@ -29,11 +29,6 @@ export interface RenderToLambdaOptions {
     onNotice?: (message: string) => void;
     /** 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?: LambdaPlanProtocol;
     /** S3 bucket from the SAM stack output (`RenderBucketName`). */
     bucketName: string;
     /** State machine ARN from the SAM stack output (`RenderStateMachineArn`). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/aws-lambda",
-  "version": "0.8.231",
+  "version": "0.9.1",
   "description": "AWS Lambda adapter for HyperFrames distributed rendering — handler, client-side SDK, and CDK construct.",
   "repository": {
     "type": "git",
@@ -52,7 +52,7 @@
     "ffprobe-static": "^3.1.0",
     "puppeteer-core": "^25.8.0",
     "tar": "^7.4.3",
-    "@hyperframes/producer": "^0.8.231"
+    "@hyperframes/producer": "^0.9.1"
   },
   "devDependencies": {
     "@types/aws-lambda": "^8.10.146",

package/prebuilt/handler-zip.json

@@ -1,6 +1,6 @@
 {
-  "version": "0.8.231",
-  "url": "https://github.com/heygen-com/hyperframes/releases/download/v0.8.231/hyperframes-lambda-handler.zip",
-  "sha256": "62ee613d34de27b26bb6fce9b5870892f52596310bba12f71477f33af1dd6a2d",
-  "bytes": 129521302
+  "version": "0.9.1",
+  "url": "https://github.com/heygen-com/hyperframes/releases/download/v0.9.1/hyperframes-lambda-handler.zip",
+  "sha256": "53dacd375455a5d8d558b3f00c6185af36be9a61b341fa54a89bcad3e8634876",
+  "bytes": 129520617
 }

package/prebuilt/template.yaml

@@ -266,6 +266,11 @@ Resources:
           SelectPlanProtocol:
             Type: Choice
             Choices:
+              # A comparison on a missing path is a States.Runtime error, not a non-match, so an
+              # omitted PlanProtocol has to be caught before any StringEquals rule.
+              - Variable: $.PlanProtocol
+                IsPresent: false
+                Next: !If [HasVideoFunction, WarmRender, PlanV2]
               # Only a stack with the arm64 video function has a cold x86 function to warm.
               # Without one the compared value can never match.
               - Variable: $.PlanProtocol
@@ -274,9 +279,6 @@ Resources:
               - Variable: $.PlanProtocol
                 StringEquals: v2
                 Next: PlanV2
-              - Variable: $.PlanProtocol
-                StringEquals: v1
-                Next: Plan
               - Variable: $.PlanProtocol
                 IsPresent: true
                 Next: UnsupportedPlanProtocol
@@ -302,72 +304,7 @@ Resources:
           UnsupportedPlanProtocol:
             Type: Fail
             Error: PLAN_PROTOCOL_UNSUPPORTED
-            Cause: PlanProtocol must be "v1", "v2", or absent (defaults to v2).
-
-          Plan:
-            Type: Task
-            Resource: arn:aws:states:::lambda:invoke
-            Parameters:
-              # Chunks must run the ffmpeg build the plan records, so the plan runs where they do.
-              FunctionName:
-                !If [
-                  HasVideoFunction,
-                  !GetAtt VideoFunctionStack.Outputs.FunctionArn,
-                  !GetAtt RenderFunction.Arn,
-                ]
-              Payload:
-                Action: plan
-                PlanProtocol: v1
-                ProjectS3Uri.$: "$.ProjectS3Uri"
-                PlanOutputS3Prefix.$: "$.PlanOutputS3Prefix"
-                Config.$: "$.Config"
-            ResultSelector:
-              PlanProtocol: v1
-              PlanS3Uri.$: "$.Payload.PlanS3Uri"
-              PlanHash.$: "$.Payload.PlanHash"
-              ChunkCount.$: "$.Payload.ChunkCount"
-              MaxChunkConcurrency.$: "$.Payload.MaxChunkConcurrency"
-              Format.$: "$.Payload.Format"
-              HasAudio.$: "$.Payload.HasAudio"
-              AudioS3Uri.$: "$.Payload.AudioS3Uri"
-            ResultPath: $.Plan
-            Retry:
-              - ErrorEquals:
-                  # These error names are thrown by the producer's plan
-                  # stage when retrying can never help — version skew,
-                  # determinism violations, GPU misconfiguration, font
-                  # fetch failures, plan-size cap, unsupported format.
-                  # Fail fast rather than burning ~120s of retry budget.
-                  - FFMPEG_VERSION_MISMATCH
-                  - PLAN_HASH_MISMATCH
-                  - BROWSER_GPU_NOT_SOFTWARE
-                  - FONT_FETCH_FAILED
-                  - PLAN_TOO_LARGE
-                  - PlanTooLargeError
-                  - PLAN_PROTOCOL_UNSUPPORTED
-                  - PlanProtocolUnsupportedError
-                  - VIDEO_SOURCE_UNRENDERABLE
-                  - INVALID_VIDEO_METADATA
-                  - NOT_MEDIA_PAYLOAD
-                  - NotMediaPayloadError
-                  - PLAN_ARTIFACT_DIGEST_MISMATCH
-                  - FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED
-                  - CHUNK_EXCEEDS_WORKER_TIMEOUT
-                  - SITE_MANIFEST_INVALID
-                MaxAttempts: 0
-              # Another render on the same function can still take the reserved slots; wait minutes.
-              - ErrorEquals: [Lambda.TooManyRequestsException]
-                IntervalSeconds: 5
-                MaxAttempts: 10
-                BackoffRate: 2
-                MaxDelaySeconds: 60
-                JitterStrategy: FULL
-              - ErrorEquals: [States.ALL]
-                IntervalSeconds: 2
-                MaxAttempts: 4
-                BackoffRate: 2
-                MaxDelaySeconds: 60
-            Next: BuildChunkList
+            Cause: PlanProtocol must be "v2" or absent (defaults to v2).
 
           PlanV2:
             Type: Task
@@ -403,8 +340,6 @@ Resources:
                   - S3_URI_NOT_ALLOWED
                   - BROWSER_GPU_NOT_SOFTWARE
                   - FONT_FETCH_FAILED
-                  - PLAN_TOO_LARGE
-                  - PlanTooLargeError
                   - PLAN_PROTOCOL_UNSUPPORTED
                   - PlanProtocolUnsupportedError
                   - PLAN_V2_INTEGRITY_UNRECOVERABLE
@@ -453,140 +388,14 @@ Resources:
             Choices:
               - Variable: $.Plan.ChunkCount
                 NumericGreaterThan: 0
-                Next: SelectWorkerProtocol
+                Next: RenderV2
             Default: PlanProducedZeroChunks
 
           PlanProducedZeroChunks:
             Type: Fail
-            Error: PLAN_TOO_LARGE
+            Error: PLAN_EMPTY
             Cause: Plan returned ChunkCount=0 — non-retryable producer-side invariant violation.
 
-          SelectWorkerProtocol:
-            Type: Choice
-            Choices:
-              - Variable: $.Plan.PlanProtocol
-                StringEquals: v2
-                Next: RenderV2
-            Default: RenderChunks
-
-          RenderChunks:
-            Type: Map
-            Label: RenderChunks
-            ItemsPath: $.Iterator.ChunkIndexes
-            ItemSelector:
-              ChunkIndex.$: "$$.Map.Item.Value"
-              PlanS3Uri.$: "$.Plan.PlanS3Uri"
-              PlanHash.$: "$.Plan.PlanHash"
-              ChunkOutputS3Prefix.$: "$.PlanOutputS3Prefix"
-              Format.$: "$.Plan.Format"
-            # Chunks past the plan's concurrency queue here instead of being throttled by Lambda.
-            MaxConcurrencyPath: $.Plan.MaxChunkConcurrency
-            ResultPath: $.Chunks
-            ItemProcessor:
-              ProcessorConfig:
-                # Inline Map runs at most 40 iterations at once. STANDARD children
-                # because EXPRESS ones stop at 5 minutes and a chunk may run 15.
-                Mode: DISTRIBUTED
-                ExecutionType: STANDARD
-              StartAt: RenderChunk
-              States:
-                RenderChunk:
-                  Type: Task
-                  Resource: arn:aws:states:::lambda:invoke
-                  Parameters:
-                    FunctionName:
-                      !If [
-                        HasVideoFunction,
-                        !GetAtt VideoFunctionStack.Outputs.FunctionArn,
-                        !GetAtt RenderFunction.Arn,
-                      ]
-                    Payload:
-                      Action: renderChunk
-                      PlanProtocol: v1
-                      ChunkIndex.$: "$.ChunkIndex"
-                      PlanS3Uri.$: "$.PlanS3Uri"
-                      PlanHash.$: "$.PlanHash"
-                      ChunkOutputS3Prefix.$: "$.ChunkOutputS3Prefix"
-                      Format.$: "$.Format"
-                  ResultSelector:
-                    ChunkS3Uri.$: "$.Payload.ChunkS3Uri"
-                    ChunkIndex.$: "$.Payload.ChunkIndex"
-                    Sha256.$: "$.Payload.Sha256"
-                    FramesEncoded.$: "$.Payload.FramesEncoded"
-                    DurationMs.$: "$.Payload.DurationMs"
-                  Retry:
-                    - ErrorEquals:
-                        - FFMPEG_VERSION_MISMATCH
-                        - PLAN_HASH_MISMATCH
-                        - BROWSER_GPU_NOT_SOFTWARE
-                        - PLAN_TOO_LARGE
-                        - PlanTooLargeError
-                        - PLAN_PROTOCOL_UNSUPPORTED
-                        - PlanProtocolUnsupportedError
-                        - INVALID_VIDEO_METADATA
-                        - PLAN_ARTIFACT_DIGEST_MISMATCH
-                      MaxAttempts: 0
-                    - ErrorEquals: [Lambda.TooManyRequestsException]
-                      IntervalSeconds: 5
-                      MaxAttempts: 10
-                      BackoffRate: 2
-                      MaxDelaySeconds: 60
-                      JitterStrategy: FULL
-                    - ErrorEquals: [States.ALL]
-                      IntervalSeconds: 2
-                      MaxAttempts: 4
-                      BackoffRate: 2
-                      MaxDelaySeconds: 60
-                  End: true
-            Next: Assemble
-
-          Assemble:
-            Type: Task
-            Resource: arn:aws:states:::lambda:invoke
-            Parameters:
-              FunctionName: !GetAtt RenderFunction.Arn
-              Payload:
-                Action: assemble
-                PlanProtocol: v1
-                PlanS3Uri.$: "$.Plan.PlanS3Uri"
-                ChunkS3Uris.$: "$.Chunks[*].ChunkS3Uri"
-                AudioS3Uri.$: "$.Plan.AudioS3Uri"
-                OutputS3Uri.$: "$.OutputS3Uri"
-                Format.$: "$.Plan.Format"
-            ResultSelector:
-              OutputS3Uri.$: "$.Payload.OutputS3Uri"
-              FramesEncoded.$: "$.Payload.FramesEncoded"
-              FileSize.$: "$.Payload.FileSize"
-            ResultPath: $.Output
-            Retry:
-              - ErrorEquals:
-                  # Same non-retryable error names as the Plan state's
-                  # gate — these surface at assemble time too because
-                  # ffmpeg-driven concat picks up version drift and we
-                  # re-verify plan hash + format at assemble. Skip the
-                  # retry storm; fail fast.
-                  - FFMPEG_VERSION_MISMATCH
-                  - PLAN_HASH_MISMATCH
-                  - FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED
-                  - PLAN_TOO_LARGE
-                  - PlanTooLargeError
-                  - PLAN_PROTOCOL_UNSUPPORTED
-                  - PlanProtocolUnsupportedError
-                  - PLAN_ARTIFACT_DIGEST_MISMATCH
-                MaxAttempts: 0
-              - ErrorEquals: [Lambda.TooManyRequestsException]
-                IntervalSeconds: 5
-                MaxAttempts: 10
-                BackoffRate: 2
-                MaxDelaySeconds: 60
-                JitterStrategy: FULL
-              - ErrorEquals: [States.ALL]
-                IntervalSeconds: 2
-                MaxAttempts: 4
-                BackoffRate: 2
-                MaxDelaySeconds: 60
-            End: true
-
           RenderV2:
             # Chunks render video only while the audio task mixes the track AssembleV2 stitches in.
             Type: Parallel
@@ -644,8 +453,6 @@ Resources:
                                 - PLAN_HASH_MISMATCH
                                 - S3_URI_NOT_ALLOWED
                                 - BROWSER_GPU_NOT_SOFTWARE
-                                - PLAN_TOO_LARGE
-                                - PlanTooLargeError
                                 - PLAN_PROTOCOL_UNSUPPORTED
                                 - PlanProtocolUnsupportedError
                                 - PLAN_V2_INTEGRITY_UNRECOVERABLE
@@ -705,8 +512,6 @@ Resources:
                           - S3_URI_NOT_ALLOWED
                           - BROWSER_GPU_NOT_SOFTWARE
                           - FONT_FETCH_FAILED
-                          - PLAN_TOO_LARGE
-                          - PlanTooLargeError
                           - PLAN_PROTOCOL_UNSUPPORTED
                           - PlanProtocolUnsupportedError
                           - PLAN_V2_INTEGRITY_UNRECOVERABLE
@@ -765,8 +570,6 @@ Resources:
                   - PLAN_HASH_MISMATCH
                   - S3_URI_NOT_ALLOWED
                   - FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED
-                  - PLAN_TOO_LARGE
-                  - PlanTooLargeError
                   - PLAN_PROTOCOL_UNSUPPORTED
                   - PlanProtocolUnsupportedError
                   - PLAN_V2_INTEGRITY_UNRECOVERABLE

package/prebuilt/video-image.json

@@ -1,6 +1,6 @@
 {
-  "version": "0.8.231",
-  "url": "https://github.com/heygen-com/hyperframes/releases/download/v0.8.231/hyperframes-lambda-video-arm64.oci.tar",
-  "sha256": "c80295ca876bf376f7aa80aa3e8dccbcf9764b044dc6f262a07d9faf6c4d25eb",
+  "version": "0.9.1",
+  "url": "https://github.com/heygen-com/hyperframes/releases/download/v0.9.1/hyperframes-lambda-video-arm64.oci.tar",
+  "sha256": "ebcdf52194aac5d690539f4cd1747355809e3c21762e759b97346e2133424e5e",
   "bytes": 244900864
 }