@hyperframes/aws-lambda 0.8.181 → 0.8.184

package/dist/cdk/index.js

@@ -250,7 +250,8 @@ var HyperframesRenderStack = class extends Construct {
         "ChunkCount.$": "$.Payload.ChunkCount",
         "MaxChunkConcurrency.$": "$.Payload.MaxChunkConcurrency",
         "Format.$": "$.Payload.Format",
-        "HasAudio.$": "$.Payload.HasAudio"
+        "HasAudio.$": "$.Payload.HasAudio",
+        "SeparateAudio.$": "$.Payload.SeparateAudio"
       },
       resultPath: "$.Plan"
     });
@@ -404,8 +405,8 @@ var HyperframesRenderStack = class extends Construct {
         "PlanV2ManifestS3Uri.$": "$.Plan.PlanV2ManifestS3Uri",
         "PlanV2ArtifactS3Prefix.$": "$.Plan.PlanV2ArtifactS3Prefix",
         "PlanHash.$": "$.Plan.PlanHash",
-        "ChunkS3Uris.$": "$.Chunks[*].ChunkS3Uri",
-        AudioS3Uri: sfn.JsonPath.stringToJson("null"),
+        "ChunkS3Uris.$": "$.Render.Chunks[*].ChunkS3Uri",
+        "AudioS3Uri.$": "$.Render.Audio.AudioS3Uri",
         "OutputS3Uri.$": "$.OutputS3Uri",
         "Format.$": "$.Plan.Format"
       }),
@@ -425,10 +426,40 @@ var HyperframesRenderStack = class extends Construct {
       backoffRate: 2,
       maxDelay: Duration.seconds(60)
     });
-    const selectWorkerProtocol = new sfn.Choice(this, "SelectWorkerProtocol").when(
-      sfn.Condition.stringEquals("$.Plan.PlanProtocol", "v2"),
-      renderChunksV2.next(assembleV2)
-    ).otherwise(renderChunks.next(assemble));
+    const audio = new tasks.LambdaInvoke(this, "Audio", {
+      lambdaFunction: this.renderFunction,
+      payload: sfn.TaskInput.fromObject({
+        Action: "audio",
+        "ProjectS3Uri.$": "$.ProjectS3Uri",
+        "PlanOutputS3Prefix.$": "$.PlanOutputS3Prefix",
+        "Config.$": "$.Config"
+      }),
+      resultSelector: {
+        "HasAudio.$": "$.Payload.HasAudio",
+        "AudioS3Uri.$": "$.Payload.AudioS3Uri"
+      },
+      resultPath: "$.Audio"
+    });
+    audio.addRetry({ errors: NON_RETRYABLE_PLAN, maxAttempts: 0 });
+    audio.addRetry(THROTTLED_RETRY);
+    audio.addRetry({
+      errors: ["States.ALL"],
+      interval: Duration.seconds(2),
+      maxAttempts: 4,
+      backoffRate: 2,
+      maxDelay: Duration.seconds(60)
+    });
+    const audioNeeded = new sfn.Choice(this, "AudioNeeded").when(sfn.Condition.booleanEquals("$.Plan.SeparateAudio", true), audio).otherwise(
+      new sfn.Pass(this, "NoAudio", {
+        result: sfn.Result.fromObject({ HasAudio: false, AudioS3Uri: null }),
+        resultPath: "$.Audio"
+      })
+    );
+    const renderV2 = new sfn.Parallel(this, "RenderV2", {
+      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);
     planV2.next(buildChunkList);

package/dist/events.d.ts

@@ -18,7 +18,7 @@
 import type { DistributedFormat, SerializableDistributedRenderConfig } from "@hyperframes/producer/distributed";
 export type { SerializableDistributedRenderConfig } from "@hyperframes/producer/distributed";
 /** Discriminator for the three roles the one Lambda image fulfills. */
-export type LambdaAction = "plan" | "renderChunk" | "assemble";
+export type LambdaAction = "plan" | "audio" | "renderChunk" | "assemble";
 /** Transport protocol selected for one complete distributed render. */
 export type LambdaPlanProtocol = "v1" | "v2";
 /**
@@ -29,7 +29,7 @@ export type LambdaPlanProtocol = "v1" | "v2";
  * handler unwraps both `event.Payload` and `event.Input` before
  * dispatching.
  */
-export type LambdaEvent = PlanEvent | RenderChunkEvent | AssembleEvent | {
+export type LambdaEvent = PlanEvent | AudioEvent | RenderChunkEvent | AssembleEvent | {
     Payload: LambdaEvent;
 } | {
     Input: LambdaEvent;
@@ -57,6 +57,10 @@ export interface PlanV2Event extends PlanEventBase {
     PlanProtocol?: "v2";
 }
 export type PlanEvent = PlanV1Event | PlanV2Event;
+/** 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"> {
+    Action: "audio";
+}
 /** Activity B: fetch planDir, render one chunk, upload result. */
 interface RenderChunkEventBase {
     Action: "renderChunk";
@@ -165,8 +169,17 @@ 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;
+export interface AudioLambdaResult {
+    Action: "audio";
+    HasAudio: boolean;
+    /** The track for the assembler to stitch in; `null` without audio or when the plan mixed it. */
+    AudioS3Uri: string | null;
+    DurationMs: number;
+}
 /** Result of a `renderChunk` invocation. Sized ≤200 bytes per §2.4. */
 export interface RenderChunkLambdaResult {
     Action: "renderChunk";
@@ -186,4 +199,4 @@ export interface AssembleLambdaResult {
     FileSize: number;
     DurationMs: number;
 }
-export type LambdaResult = PlanLambdaResult | RenderChunkLambdaResult | AssembleLambdaResult;
+export type LambdaResult = PlanLambdaResult | AudioLambdaResult | RenderChunkLambdaResult | AssembleLambdaResult;

package/dist/handler.d.ts

@@ -12,8 +12,8 @@
  */
 import { LambdaClient } from "@aws-sdk/client-lambda";
 import { S3Client } from "@aws-sdk/client-s3";
-import { assemble, type ChunkRenderer, plan, planV2WithPublisher } from "@hyperframes/producer/distributed";
-import type { AssembleEvent, LambdaEvent, LambdaResult, PlanEvent, RenderChunkEvent } from "./events.js";
+import { assemble, buildPlanAudio, type ChunkRenderer, plan, planV2WithPublisher } from "@hyperframes/producer/distributed";
+import type { AssembleEvent, AudioEvent, LambdaEvent, LambdaResult, PlanEvent, RenderChunkEvent } from "./events.js";
 /**
  * Optional injection points used by the handler's unit tests. Production
  * callers leave these unset; the real OSS primitives are used. Tests
@@ -28,6 +28,7 @@ export interface HandlerDeps {
     primitives?: {
         plan: typeof plan;
         planV2WithPublisher?: typeof planV2WithPublisher;
+        buildPlanAudio?: typeof buildPlanAudio;
         renderChunk: ChunkRenderer;
         assemble: typeof assemble;
     };
@@ -47,4 +48,4 @@ export interface HandlerDeps {
  * shape; unwrap until we hit a discriminated event.
  */
 export declare function handler(event: LambdaEvent, deps?: HandlerDeps): Promise<LambdaResult>;
-export declare function unwrapEvent(event: LambdaEvent): PlanEvent | RenderChunkEvent | AssembleEvent;
+export declare function unwrapEvent(event: LambdaEvent): PlanEvent | AudioEvent | RenderChunkEvent | AssembleEvent;

package/dist/handler.js

@@ -1,8 +1,8 @@
 import {
   handler,
   unwrapEvent
-} from "./_chunks/chunk-AK7J3QQN.js";
-import "./_chunks/chunk-ZY5YIH5W.js";
+} from "./_chunks/chunk-QCYPNODV.js";
+import "./_chunks/chunk-SGNVVPIS.js";
 import "./_chunks/chunk-YS3KY3C5.js";
 export {
   handler,

package/dist/index.js

@@ -6,7 +6,7 @@ import {
   resolveChromeExecutablePath,
   resolveChromeSource,
   unwrapEvent
-} from "./_chunks/chunk-AK7J3QQN.js";
+} from "./_chunks/chunk-QCYPNODV.js";
 import {
   InvalidConfigError,
   computeRenderCost,
@@ -14,7 +14,7 @@ import {
   getRenderProgress,
   renderToLambda,
   validateDistributedRenderConfig
-} from "./_chunks/chunk-PK7PO3MH.js";
+} from "./_chunks/chunk-5FLGGUWE.js";
 import {
   downloadS3ObjectToFile,
   downloadS3ObjectToFileVerified,
@@ -24,7 +24,7 @@ import {
   untarDirectory,
   uploadContentAddressedFileToS3,
   uploadFileToS3
-} from "./_chunks/chunk-ZY5YIH5W.js";
+} from "./_chunks/chunk-SGNVVPIS.js";
 import "./_chunks/chunk-YS3KY3C5.js";
 export {
   ChromeBinaryUnavailableError,

package/dist/s3Stitch.d.ts

@@ -21,6 +21,9 @@ export interface StitchResult {
     parts: number;
     downloadedBytes: number;
 }
-/** One faststart mp4 at `destUri` from the stitched mp4 chunks at `chunkUris`, in order. */
-export declare function stitchMp4InS3(s3: S3Client, chunkUris: readonly string[], destUri: string, minPartBytes?: number): Promise<StitchResult>;
+/** One faststart mp4 at `destUri` from the stitched mp4 chunks at `chunkUris`, plus `audioUri`'s track when given. */
+export declare function stitchMp4InS3(s3: S3Client, chunkUris: readonly string[], destUri: string, { audioUri, minPartBytes }?: {
+    audioUri?: string;
+    minPartBytes?: number;
+}): Promise<StitchResult>;
 export {};

package/dist/s3Transport.d.ts

@@ -16,7 +16,9 @@
  *     `/usr/bin`, so a system-binary tar would ENOENT in the actual
  *     deployment.
  */
-import { type S3Client } from "@aws-sdk/client-s3";
+import { type CompletedPart, type CreateMultipartUploadCommandInput, type S3Client } from "@aws-sdk/client-s3";
+/** S3's largest PutObject or CopyObject; bigger objects go multipart. */
+export declare const MAX_SINGLE_PUT_BYTES: number;
 /** Parsed `s3://bucket/key` URI. */
 export interface S3Location {
     bucket: string;
@@ -35,13 +37,7 @@ export declare function downloadS3ObjectToFileVerified(client: S3Client, uri: st
  * SHA-256 and size are the ones the manifest pins.
  */
 export declare function presignVerifiedS3GetUrl(client: S3Client, uri: string, expectedSha256: string, expectedSize: number, expiresInSeconds: number): Promise<string>;
-/**
- * Upload a local file's contents to an S3 URI using a streaming
- * `PutObjectCommand`. PutObject's 5 GB cap comfortably exceeds the
- * distributed pipeline's 2 GB planDir limit and the typical
- * chunk size (≤ 200 MB), so a single PUT works for every artifact this
- * adapter handles.
- */
+/** Upload a local file to an S3 URI, streamed: one PutObject up to S3's 5 GB cap, multipart above. */
 export declare function uploadFileToS3(client: S3Client, localPath: string, uri: string, contentType?: string): Promise<void>;
 /**
  * Upload one content-addressed plan-v2 artifact exactly once; S3 verifies the bytes against
@@ -49,6 +45,22 @@ export declare function uploadFileToS3(client: S3Client, localPath: string, uri:
  * and a conflicting one is never overwritten, since a chunk may already be reading that plan.
  */
 export declare function uploadContentAddressedFileToS3(client: S3Client, localPath: string, uri: string, expectedSha256: string, contentType?: string): Promise<"uploaded" | "reused">;
+export type MultipartTarget = {
+    Bucket: string;
+    Key: string;
+    UploadId: string;
+};
+/**
+ * Creates a multipart upload, lets `sendParts` fill it, then completes it. A failure aborts the
+ * upload so no parts linger; `sendParts` must settle every part before it rejects.
+ */
+export declare function multipartUpload(client: S3Client, create: CreateMultipartUploadCommandInput & {
+    Bucket: string;
+    Key: string;
+}, sendParts: (target: MultipartTarget) => Promise<CompletedPart[]>, complete?: {
+    ifNoneMatch?: "*";
+    objectSize?: number;
+}): Promise<void>;
 export declare function mapConcurrent<T>(values: readonly T[], concurrency: number, fn: (value: T) => Promise<void>): Promise<void>;
 export declare function sha256File(path: string): Promise<string>;
 /** Put a file into the shared content store once; reusing an aging object restarts its expiry. */

package/dist/sdk/index.js

@@ -10,8 +10,8 @@ import {
   validateDistributedRenderConfig,
   validateStepFunctionsInputSize,
   validateVariablesPayload
-} from "../_chunks/chunk-PK7PO3MH.js";
-import "../_chunks/chunk-ZY5YIH5W.js";
+} from "../_chunks/chunk-5FLGGUWE.js";
+import "../_chunks/chunk-SGNVVPIS.js";
 import "../_chunks/chunk-YS3KY3C5.js";
 
 // src/sdk/prebuiltHandler.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/aws-lambda",
-  "version": "0.8.181",
+  "version": "0.8.184",
   "description": "AWS Lambda adapter for HyperFrames distributed rendering — handler, client-side SDK, and CDK construct.",
   "repository": {
     "type": "git",
@@ -11,6 +11,7 @@
     "dist/",
     "prebuilt/",
     "scripts/",
+    "!scripts/*.test.ts",
     "README.md"
   ],
   "type": "module",
@@ -48,7 +49,7 @@
     "ffprobe-static": "^3.1.0",
     "puppeteer-core": "^25.8.0",
     "tar": "^7.4.3",
-    "@hyperframes/producer": "^0.8.181"
+    "@hyperframes/producer": "^0.8.184"
   },
   "devDependencies": {
     "@types/aws-lambda": "^8.10.146",

package/prebuilt/handler-zip.json

@@ -1,6 +1,6 @@
 {
-  "version": "0.8.181",
-  "url": "https://github.com/heygen-com/hyperframes/releases/download/v0.8.181/hyperframes-lambda-handler.zip",
-  "sha256": "547401886f6fd729e0e12ad07bdebfdaf990972c22efadcd6129ea1af6b8b525",
-  "bytes": 129250221
+  "version": "0.8.184",
+  "url": "https://github.com/heygen-com/hyperframes/releases/download/v0.8.184/hyperframes-lambda-handler.zip",
+  "sha256": "3bfb70ba6961f63748d6eccfde8236d2a5d566ae8794f5d21e4a1d0e160de3c5",
+  "bytes": 129237052
 }

package/prebuilt/template.yaml

@@ -324,6 +324,7 @@ Resources:
               MaxChunkConcurrency.$: "$.Payload.MaxChunkConcurrency"
               Format.$: "$.Payload.Format"
               HasAudio.$: "$.Payload.HasAudio"
+              SeparateAudio.$: "$.Payload.SeparateAudio"
             ResultPath: $.Plan
             Retry:
               - ErrorEquals:
@@ -395,7 +396,7 @@ Resources:
             Choices:
               - Variable: $.Plan.PlanProtocol
                 StringEquals: v2
-                Next: RenderChunksV2
+                Next: RenderV2
             Default: RenderChunks
 
           RenderChunks:
@@ -511,74 +512,151 @@ Resources:
                 MaxDelaySeconds: 60
             End: true
 
-          RenderChunksV2:
-            Type: Map
-            Label: RenderChunksV2
-            ItemsPath: $.Iterator.ChunkIndexes
-            ItemSelector:
-              ChunkIndex.$: "$$.Map.Item.Value"
-              PlanV2ManifestS3Uri.$: "$.Plan.PlanV2ManifestS3Uri"
-              PlanV2ArtifactS3Prefix.$: "$.Plan.PlanV2ArtifactS3Prefix"
-              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:
-                Mode: DISTRIBUTED
-                ExecutionType: STANDARD
-              StartAt: RenderChunkV2
-              States:
-                RenderChunkV2:
-                  Type: Task
-                  Resource: arn:aws:states:::lambda:invoke
-                  Parameters:
-                    FunctionName: !GetAtt RenderFunction.Arn
-                    Payload:
-                      Action: renderChunk
-                      PlanProtocol: v2
-                      ChunkIndex.$: "$.ChunkIndex"
-                      PlanV2ManifestS3Uri.$: "$.PlanV2ManifestS3Uri"
-                      PlanV2ArtifactS3Prefix.$: "$.PlanV2ArtifactS3Prefix"
-                      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
-                        - S3_URI_NOT_ALLOWED
-                        - BROWSER_GPU_NOT_SOFTWARE
-                        - PLAN_TOO_LARGE
-                        - PlanTooLargeError
-                        - PLAN_PROTOCOL_UNSUPPORTED
-                        - PlanProtocolUnsupportedError
-                        - PLAN_V2_INTEGRITY_UNRECOVERABLE
-                        - INVALID_VIDEO_METADATA
-                        - PlanV2IntegrityError
-                        - PLAN_ARTIFACT_DIGEST_MISMATCH
-                        - ChromeBinaryUnavailableError
-                      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
+            Branches:
+              - StartAt: RenderChunksV2
+                States:
+                  RenderChunksV2:
+                    Type: Map
+                    Label: RenderChunksV2
+                    ItemsPath: $.Iterator.ChunkIndexes
+                    ItemSelector:
+                      ChunkIndex.$: "$$.Map.Item.Value"
+                      PlanV2ManifestS3Uri.$: "$.Plan.PlanV2ManifestS3Uri"
+                      PlanV2ArtifactS3Prefix.$: "$.Plan.PlanV2ArtifactS3Prefix"
+                      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:
+                        Mode: DISTRIBUTED
+                        ExecutionType: STANDARD
+                      StartAt: RenderChunkV2
+                      States:
+                        RenderChunkV2:
+                          Type: Task
+                          Resource: arn:aws:states:::lambda:invoke
+                          Parameters:
+                            FunctionName: !GetAtt RenderFunction.Arn
+                            Payload:
+                              Action: renderChunk
+                              PlanProtocol: v2
+                              ChunkIndex.$: "$.ChunkIndex"
+                              PlanV2ManifestS3Uri.$: "$.PlanV2ManifestS3Uri"
+                              PlanV2ArtifactS3Prefix.$: "$.PlanV2ArtifactS3Prefix"
+                              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
+                                - S3_URI_NOT_ALLOWED
+                                - BROWSER_GPU_NOT_SOFTWARE
+                                - PLAN_TOO_LARGE
+                                - PlanTooLargeError
+                                - PLAN_PROTOCOL_UNSUPPORTED
+                                - PlanProtocolUnsupportedError
+                                - PLAN_V2_INTEGRITY_UNRECOVERABLE
+                                - INVALID_VIDEO_METADATA
+                                - PlanV2IntegrityError
+                                - PLAN_ARTIFACT_DIGEST_MISMATCH
+                                - ChromeBinaryUnavailableError
+                              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
+                    End: true
+              - StartAt: AudioNeeded
+                States:
+                  AudioNeeded:
+                    Type: Choice
+                    Choices:
+                      - Variable: $.Plan.SeparateAudio
+                        BooleanEquals: true
+                        Next: Audio
+                    Default: NoAudio
+                  NoAudio:
+                    Type: Pass
+                    Result:
+                      HasAudio: false
+                      AudioS3Uri: null
+                    ResultPath: $.Audio
+                    End: true
+                  Audio:
+                    # The plan left its audio out: mix it here while the chunks render.
+                    Type: Task
+                    Resource: arn:aws:states:::lambda:invoke
+                    Parameters:
+                      FunctionName: !GetAtt RenderFunction.Arn
+                      Payload:
+                        Action: audio
+                        ProjectS3Uri.$: "$.ProjectS3Uri"
+                        PlanOutputS3Prefix.$: "$.PlanOutputS3Prefix"
+                        Config.$: "$.Config"
+                    ResultSelector:
+                      HasAudio.$: "$.Payload.HasAudio"
+                      AudioS3Uri.$: "$.Payload.AudioS3Uri"
+                    ResultPath: $.Audio
+                    Retry:
+                      - ErrorEquals:
+                          - FFMPEG_VERSION_MISMATCH
+                          - PLAN_HASH_MISMATCH
+                          - S3_URI_NOT_ALLOWED
+                          - BROWSER_GPU_NOT_SOFTWARE
+                          - FONT_FETCH_FAILED
+                          - PLAN_TOO_LARGE
+                          - PlanTooLargeError
+                          - PLAN_PROTOCOL_UNSUPPORTED
+                          - PlanProtocolUnsupportedError
+                          - PLAN_V2_INTEGRITY_UNRECOVERABLE
+                          - VIDEO_SOURCE_UNRENDERABLE
+                          - INVALID_VIDEO_METADATA
+                          - NOT_MEDIA_PAYLOAD
+                          - NotMediaPayloadError
+                          - PlanV2IntegrityError
+                          - PLAN_ARTIFACT_DIGEST_MISMATCH
+                          - FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED
+                          - CHUNK_EXCEEDS_WORKER_TIMEOUT
+                          - ChromeBinaryUnavailableError
+                          - SITE_MANIFEST_INVALID
+                        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
+            ResultSelector:
+              Chunks.$: "$[0].Chunks"
+              Audio.$: "$[1].Audio"
+            ResultPath: $.Render
             Next: AssembleV2
 
           AssembleV2:
@@ -592,8 +670,8 @@ Resources:
                 PlanV2ManifestS3Uri.$: "$.Plan.PlanV2ManifestS3Uri"
                 PlanV2ArtifactS3Prefix.$: "$.Plan.PlanV2ArtifactS3Prefix"
                 PlanHash.$: "$.Plan.PlanHash"
-                ChunkS3Uris.$: "$.Chunks[*].ChunkS3Uri"
-                AudioS3Uri: null
+                ChunkS3Uris.$: "$.Render.Chunks[*].ChunkS3Uri"
+                AudioS3Uri.$: "$.Render.Audio.AudioS3Uri"
                 OutputS3Uri.$: "$.OutputS3Uri"
                 Format.$: "$.Plan.Format"
             ResultSelector:

package/scripts/pin-handler-zip.ts

@@ -11,8 +11,7 @@ import {
   type HandlerZipManifest,
   PREBUILT_DIR,
 } from "../src/sdk/prebuiltHandler.js";
-
-const CHECKOUT_CODE_URI = "CodeUri: ../../packages/aws-lambda/dist/handler.zip";
+import { writePrebuiltTemplate } from "./prebuilt-template.mjs";
 
 export function pinHandlerZip(repoRoot: string): HandlerZipManifest {
   const pkgDir = join(repoRoot, "packages", "aws-lambda");
@@ -31,18 +30,8 @@ export function pinHandlerZip(repoRoot: string): HandlerZipManifest {
   const sha256 = createHash("sha256").update(bytes).digest("hex");
   writeFileSync(asset.replace(/\.zip$/, ".sha256"), `${sha256}  ${HANDLER_ZIP_ASSET}\n`);
 
-  const template = readFileSync(join(repoRoot, "examples", "aws-lambda", "template.yaml"), "utf-8");
-  if (template.split(CHECKOUT_CODE_URI).length !== 2) {
-    throw new Error(
-      `[pin-handler-zip] expected exactly one "${CHECKOUT_CODE_URI}" in the template`,
-    );
-  }
   const outDir = join(pkgDir, PREBUILT_DIR);
-  mkdirSync(outDir, { recursive: true });
-  writeFileSync(
-    join(outDir, "template.yaml"),
-    template.replace(CHECKOUT_CODE_URI, "CodeUri: handler.zip"),
-  );
+  writePrebuiltTemplate(repoRoot, outDir);
   const manifest: HandlerZipManifest = {
     version: pkg.version,
     url: `${pkg.repository.url}/releases/download/v${pkg.version}/${HANDLER_ZIP_ASSET}`,

package/scripts/prebuilt-template.mjs

@@ -0,0 +1,19 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+const CHECKOUT_CODE_URI = "CodeUri: ../../packages/aws-lambda/dist/handler.zip";
+
+/** Writes `<outDir>/template.yaml`: the example SAM template, pointed at a `handler.zip` beside it. */
+export function writePrebuiltTemplate(repoRoot, outDir) {
+  const template = readFileSync(join(repoRoot, "examples", "aws-lambda", "template.yaml"), "utf-8");
+  if (template.split(CHECKOUT_CODE_URI).length !== 2) {
+    throw new Error(
+      `[prebuilt-template] expected exactly one "${CHECKOUT_CODE_URI}" in the template`,
+    );
+  }
+  mkdirSync(outDir, { recursive: true });
+  writeFileSync(
+    join(outDir, "template.yaml"),
+    template.replace(CHECKOUT_CODE_URI, "CodeUri: handler.zip"),
+  );
+}