@hyperframes/aws-lambda 0.8.186 → 0.8.189

package/dist/_chunks/{chunk-SGNVVPIS.js → chunk-CKQ6SAJX.js}

@@ -32,7 +32,7 @@ var MAX_SINGLE_PUT_BYTES = 5 * 1024 ** 3;
 var MAX_PARTS = 1e4;
 var MIN_FILE_PART_BYTES = 64 * 1024 * 1024;
 var FILE_PARTS_IN_FLIGHT = 8;
-var PART_ATTEMPTS = 3;
+var UPLOAD_ATTEMPTS = 3;
 function parseS3Uri(uri) {
   if (!uri.startsWith("s3://")) {
     throw new Error(`[s3Transport] expected s3:// URI, got: ${JSON.stringify(uri)}`);
@@ -111,14 +111,18 @@ async function uploadFileToS3(client, localPath, uri, contentType) {
     });
     return;
   }
-  await client.send(
-    new PutObjectCommand({
-      Bucket: bucket,
-      Key: key,
-      Body: createReadStream(localPath),
-      ContentType: contentType,
-      ContentLength: size
-    })
+  await sendFileBody(
+    localPath,
+    void 0,
+    (body) => client.send(
+      new PutObjectCommand({
+        Bucket: bucket,
+        Key: key,
+        Body: body,
+        ContentType: contentType,
+        ContentLength: size
+      })
+    )
   );
 }
 async function uploadContentAddressedFileToS3(client, localPath, uri, expectedSha256, contentType) {
@@ -152,9 +156,10 @@ async function putImmutableFile(client, localPath, uri, expectedSha256, contentT
   }
 }
 async function putImmutableBody(client, localPath, bucket, key, size, expectedSha256, contentType) {
-  const body = createReadStream(localPath);
-  try {
-    await client.send(
+  await sendFileBody(
+    localPath,
+    void 0,
+    (body) => client.send(
       new PutObjectCommand({
         Bucket: bucket,
         Key: key,
@@ -165,10 +170,8 @@ async function putImmutableBody(client, localPath, bucket, key, size, expectedSh
         ChecksumSHA256: Buffer.from(expectedSha256, "hex").toString("base64"),
         IfNoneMatch: "*"
       })
-    );
-  } finally {
-    body.destroy();
-  }
+    )
+  );
 }
 async function multipartUpload(client, create2, sendParts, complete = {}) {
   const created = await client.send(new CreateMultipartUploadCommand(create2));
@@ -255,22 +258,29 @@ async function hashRange(path, { start, end }, whole) {
   return part.digest("base64");
 }
 async function sendFilePart(client, target, partNumber, path, { start, end }, checksum) {
+  const result = await sendFileBody(
+    path,
+    { start, end },
+    (body) => client.send(
+      new UploadPartCommand({
+        ...target,
+        PartNumber: partNumber,
+        Body: body,
+        ContentLength: end - start,
+        ChecksumSHA256: checksum
+      })
+    )
+  );
+  if (!result.ETag) throw new Error(`[s3Transport] part ${partNumber} returned no ETag`);
+  return { ETag: result.ETag, PartNumber: partNumber, ChecksumSHA256: checksum };
+}
+async function sendFileBody(path, range, send) {
   for (let attempt = 1; ; attempt++) {
-    const body = createReadStream(path, { start, end: end - 1 });
+    const body = createReadStream(path, range && { start: range.start, end: range.end - 1 });
     try {
-      const result = await client.send(
-        new UploadPartCommand({
-          ...target,
-          PartNumber: partNumber,
-          Body: body,
-          ContentLength: end - start,
-          ChecksumSHA256: checksum
-        })
-      );
-      if (!result.ETag) throw new Error(`[s3Transport] part ${partNumber} returned no ETag`);
-      return { ETag: result.ETag, PartNumber: partNumber, ChecksumSHA256: checksum };
+      return await send(body);
     } catch (error) {
-      if (attempt >= PART_ATTEMPTS) throw error;
+      if (attempt >= UPLOAD_ATTEMPTS || !isTransientS3Error(error)) throw error;
     } finally {
       body.destroy();
     }
@@ -420,6 +430,13 @@ function isS3PreconditionFailed(error) {
   const metadata = isRecord(error.$metadata) ? error.$metadata : void 0;
   return error.name === "PreconditionFailed" || metadata?.httpStatusCode === 412;
 }
+var TRANSIENT_S3_ERRORS = /* @__PURE__ */ new Set(["TimeoutError", "RequestTimeout", "RequestTimeoutException"]);
+function isTransientS3Error(error) {
+  if (!isRecord(error)) return false;
+  if (typeof error.name === "string" && TRANSIENT_S3_ERRORS.has(error.name)) return true;
+  const status = isRecord(error.$metadata) ? error.$metadata.httpStatusCode : void 0;
+  return typeof status !== "number" || status === 429 || status >= 500;
+}
 function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }

package/dist/_chunks/{chunk-5FLGGUWE.js → chunk-EG2WRNUL.js}

@@ -16,7 +16,7 @@ import {
   siteManifestUri,
   siteTarballUri,
   uploadContentAddressedFileToS3
-} from "./chunk-SGNVVPIS.js";
+} from "./chunk-CKQ6SAJX.js";
 import {
   CONTENT_STORE_RETENTION_DAYS
 } from "./chunk-YS3KY3C5.js";
@@ -234,14 +234,14 @@ async function assertStackReadsSites(opts) {
 }
 
 // src/sdk/costAccounting.ts
-var LAMBDA_USD_PER_GB_SECOND = 166667e-10;
+var LAMBDA_USD_PER_GB_SECOND = { x86_64: 166667e-10, arm64: 133334e-10 };
 var SFN_USD_PER_TRANSITION = 25e-6;
 function computeRenderCost(lambdaInvocations, stateTransitions) {
   let lambdaUsd = 0;
   let anyEstimated = false;
   for (const inv of lambdaInvocations) {
     const gbSeconds = inv.memorySizeMb / 1024 * (inv.billedDurationMs / 1e3);
-    lambdaUsd += gbSeconds * LAMBDA_USD_PER_GB_SECOND;
+    lambdaUsd += gbSeconds * LAMBDA_USD_PER_GB_SECOND[inv.architecture ?? "x86_64"];
     if (inv.estimated) anyEstimated = true;
   }
   const stepFunctionsUsd = stateTransitions * SFN_USD_PER_TRANSITION;
@@ -289,10 +289,10 @@ async function getRenderProgress(opts) {
   const startedAt = describe.startDate?.toISOString() ?? (/* @__PURE__ */ new Date(0)).toISOString();
   const endedAt = describe.stopDate?.toISOString() ?? null;
   const history = await loadFullHistory(sfn, opts.executionArn);
-  const summary = summarizeHistory(history, memoryMb);
+  const summary = summarizeHistory(history, memoryMb, opts.videoArchitecture);
   const mapRun = findChunkMapRun(history);
   const warnings = [];
-  if (mapRun?.exited) addChunkResults(summary, mapRun.output, memoryMb);
+  if (mapRun?.exited) addChunkResults(summary, mapRun.output, memoryMb, opts.videoArchitecture);
   else if (mapRun) {
     await addRunningMapRun(sfn, mapRun.arn, summary, memoryMb).catch((err) => {
       if (err?.name !== "AccessDeniedException") throw err;
@@ -353,17 +353,12 @@ function findChunkMapRun(events) {
   }
   return run;
 }
-function addChunkResults(summary, mapOutput, memoryMb) {
+function addChunkResults(summary, mapOutput, memoryMb, architecture) {
   const chunks = parseJson(mapOutput)?.Chunks;
   for (const chunk of Array.isArray(chunks) ? chunks : []) {
     summary.lambdasInvoked++;
     summary.stateTransitions++;
-    const billedDurationMs = inferBilledMs(chunk);
-    summary.lambdaInvocations.push({
-      billedDurationMs,
-      memorySizeMb: memoryMb,
-      estimated: billedDurationMs === 0
-    });
+    summary.lambdaInvocations.push(billedInvocation(chunk, memoryMb, architecture));
     applyPayloadFrameCounts(chunk, "RenderChunk", (delta) => {
       summary.framesRendered += delta;
     });
@@ -395,7 +390,7 @@ async function failedChunkErrors(sfn, mapRunArn, memoryMb) {
   }
   return errors;
 }
-function summarizeHistory(events, memoryMb) {
+function summarizeHistory(events, memoryMb, videoArchitecture) {
   let framesRendered = 0;
   let totalFrames = null;
   let lambdasInvoked = 0;
@@ -432,12 +427,13 @@ function summarizeHistory(events, memoryMb) {
         if (ev.taskSucceededEventDetails?.resourceType !== "lambda") break;
         const wrapped = parseJson(ev.taskSucceededEventDetails?.output);
         const payload = unwrapLambdaPayload(wrapped);
-        const billedDurationMs = inferBilledMs(payload);
-        lambdaInvocations.push({
-          billedDurationMs,
-          memorySizeMb: memoryMb,
-          estimated: billedDurationMs === 0
-        });
+        lambdaInvocations.push(
+          billedInvocation(
+            payload,
+            memoryMb,
+            stateArchitecture(currentLambdaState, videoArchitecture)
+          )
+        );
         applyPayloadFrameCounts(payload, currentLambdaState, (delta) => {
           framesRendered += delta;
         });
@@ -449,12 +445,13 @@ function summarizeHistory(events, memoryMb) {
       }
       case "LambdaFunctionSucceeded": {
         const payload = parseJson(ev.lambdaFunctionSucceededEventDetails?.output);
-        const billedDurationMs = inferBilledMs(payload);
-        lambdaInvocations.push({
-          billedDurationMs,
-          memorySizeMb: memoryMb,
-          estimated: billedDurationMs === 0
-        });
+        lambdaInvocations.push(
+          billedInvocation(
+            payload,
+            memoryMb,
+            stateArchitecture(currentLambdaState, videoArchitecture)
+          )
+        );
         applyPayloadFrameCounts(payload, currentLambdaState, (delta) => {
           framesRendered += delta;
         });
@@ -559,6 +556,18 @@ function isRenderChunksMapState(name) {
 function isAssembleState(name) {
   return name === "Assemble" || name === "AssembleV2";
 }
+function billedInvocation(payload, memoryMb, architecture) {
+  const billedDurationMs = inferBilledMs(payload);
+  return {
+    billedDurationMs,
+    memorySizeMb: memoryMb,
+    estimated: billedDurationMs === 0,
+    architecture
+  };
+}
+function stateArchitecture(state, videoArchitecture) {
+  return state === "Plan" || state === "PlanV2" || isRenderChunkState(state) ? videoArchitecture : void 0;
+}
 function inferBilledMs(payload) {
   if (!payload || typeof payload !== "object") return 0;
   const obj = payload;

package/dist/_chunks/{chunk-QCYPNODV.js → chunk-ROTCAPRH.js}

@@ -15,7 +15,7 @@ import {
   untarDirectory,
   uploadContentAddressedFileToS3,
   uploadFileToS3
-} from "./chunk-SGNVVPIS.js";
+} from "./chunk-CKQ6SAJX.js";
 import {
   CONTENT_STORE_PREFIX
 } from "./chunk-YS3KY3C5.js";
@@ -844,7 +844,11 @@ async function handleAssembleV2(event, deps) {
     if (chunksAreStitchedMp4(planDir, event.Cfr === true)) {
       return await stitchChunksInS3(s3, event, manifest, started);
     }
-    const audioPath = resolvePlanAudioPath(planDir);
+    let audioPath = resolvePlanAudioPath(planDir);
+    if (event.AudioS3Uri !== null) {
+      audioPath = join2(planDir, PLAN_AUDIO_RELATIVE_PATH);
+      await downloadS3ObjectToFile(s3, event.AudioS3Uri, audioPath);
+    }
     const chunksStarted = Date.now();
     const chunkPaths = await downloadChunkObjects(s3, event.ChunkS3Uris, work, event.Format);
     const chunksMs = Date.now() - chunksStarted;

package/dist/handler.js

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

package/dist/index.js

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

package/dist/sdk/costAccounting.d.ts

@@ -16,6 +16,12 @@
  * see the dollar value but downstream automation can also read the
  * raw number.
  */
+/** On-demand Lambda price, us-east-1: USD per GB-second, by function architecture. */
+declare const LAMBDA_USD_PER_GB_SECOND: {
+    readonly x86_64: 0.0000166667;
+    readonly arm64: 0.0000133334;
+};
+export type LambdaArchitecture = keyof typeof LAMBDA_USD_PER_GB_SECOND;
 /** Raw history event subset the cost calc cares about. Caller filters from `getExecutionHistory`. */
 export interface BilledLambdaInvocation {
     /** Millis of Lambda billed duration. Carried on `TaskSucceeded`/`TaskFailed` events. */
@@ -24,6 +30,8 @@ export interface BilledLambdaInvocation {
     memorySizeMb: number;
     /** `true` if the event payload did NOT carry a billed duration and we fell back to `Duration` or a constant. */
     estimated: boolean;
+    /** Architecture of the invoked function; x86_64 when omitted. */
+    architecture?: LambdaArchitecture;
 }
 /** Result of {@link computeRenderCost}. */
 export interface RenderCost {
@@ -48,3 +56,4 @@ export interface RenderCost {
  * workflows. Express workflows price differently and are out of scope.
  */
 export declare function computeRenderCost(lambdaInvocations: BilledLambdaInvocation[], stateTransitions: number): RenderCost;
+export {};

package/dist/sdk/getRenderProgress.d.ts

@@ -20,7 +20,7 @@
  * "JSON.parse this string and grab two fields."
  */
 import { SFNClient, type SFNClientConfig } from "@aws-sdk/client-sfn";
-import { type RenderCost } from "./costAccounting.js";
+import { type LambdaArchitecture, type RenderCost } from "./costAccounting.js";
 /** Options for {@link getRenderProgress}. */
 export interface GetRenderProgressOptions {
     /** Execution ARN from a {@link renderToLambda} call. */
@@ -31,6 +31,8 @@ export interface GetRenderProgressOptions {
      * `LambdaMemoryMb` parameter the stack was deployed with.
      */
     defaultMemorySizeMb?: number;
+    /** Architecture of the stack's video function, which runs the plan and the chunks: `arm64` when it has one. */
+    videoArchitecture?: LambdaArchitecture;
     region?: string;
     /** Test injection seam. */
     sfn?: SFNClient;

package/dist/sdk/index.d.ts

@@ -12,6 +12,7 @@ export { assertStackReadsSites, renderToLambda, type RenderHandle, type RenderTo
 export { getRenderProgress, type GetRenderProgressOptions, type RenderError, type RenderProgress, type RenderStatus, } from "./getRenderProgress.js";
 export { type BilledLambdaInvocation, computeRenderCost, type RenderCost, } from "./costAccounting.js";
 export { InvalidConfigError, MAX_STEP_FUNCTIONS_INPUT_BYTES, validateDistributedRenderConfig, validateStepFunctionsInputSize, validateVariablesPayload, } from "./validateConfig.js";
-export { type PrebuiltHandler, prebuiltHandler } from "./prebuiltHandler.js";
+export { type PrebuiltHandler, prebuiltHandler, prebuiltVideoImage, type ReleaseAssetManifest, } from "./prebuiltHandler.js";
+export { ensureEcrRepository, type EnsureEcrRepositoryOptions, type PushedImage, pushImageToEcr, type PushImageToEcrOptions, } from "./pushImageToEcr.js";
 export type { SerializableDistributedRenderConfig } from "../events.js";
 export type { DistributedFormat } from "../formatExtension.js";

package/dist/sdk/index.js

@@ -10,8 +10,10 @@ import {
   validateDistributedRenderConfig,
   validateStepFunctionsInputSize,
   validateVariablesPayload
-} from "../_chunks/chunk-5FLGGUWE.js";
-import "../_chunks/chunk-SGNVVPIS.js";
+} from "../_chunks/chunk-EG2WRNUL.js";
+import {
+  sha256File
+} from "../_chunks/chunk-CKQ6SAJX.js";
 import "../_chunks/chunk-YS3KY3C5.js";
 
 // src/sdk/prebuiltHandler.ts
@@ -20,6 +22,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 var PREBUILT_DIR = "prebuilt";
 var HANDLER_MANIFEST_FILE = "handler-zip.json";
+var VIDEO_IMAGE_MANIFEST_FILE = "video-image.json";
 function adapterPackageRoot() {
   const from = fileURLToPath(import.meta.url);
   for (let dir = dirname(from); dir !== dirname(dir); dir = dirname(dir)) {
@@ -29,12 +32,196 @@ function adapterPackageRoot() {
   }
   throw new Error(`[aws-lambda] no @hyperframes/aws-lambda package.json above ${from}`);
 }
+function readManifest(root, file) {
+  const path = join(root, PREBUILT_DIR, file);
+  if (!existsSync(path)) return void 0;
+  return JSON.parse(readFileSync(path, "utf-8"));
+}
 function prebuiltHandler(root = adapterPackageRoot()) {
-  const dir = join(root, PREBUILT_DIR);
-  const manifestPath = join(dir, HANDLER_MANIFEST_FILE);
-  if (!existsSync(manifestPath)) return void 0;
-  const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
-  return { ...manifest, templatePath: join(dir, "template.yaml") };
+  const manifest = readManifest(root, HANDLER_MANIFEST_FILE);
+  return manifest && { ...manifest, templatePath: join(root, PREBUILT_DIR, "template.yaml") };
+}
+function prebuiltVideoImage(root = adapterPackageRoot()) {
+  return readManifest(root, VIDEO_IMAGE_MANIFEST_FILE);
+}
+
+// src/sdk/pushImageToEcr.ts
+import { open, readFile, stat } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import {
+  BatchCheckLayerAvailabilityCommand,
+  CompleteLayerUploadCommand,
+  CreateRepositoryCommand,
+  DescribeRepositoriesCommand,
+  ECRClient,
+  InitiateLayerUploadCommand,
+  ListTagsForResourceCommand,
+  PutImageCommand,
+  UploadLayerPartCommand
+} from "@aws-sdk/client-ecr";
+var MANIFEST_MEDIA_TYPES = /* @__PURE__ */ new Set([
+  "application/vnd.oci.image.manifest.v1+json",
+  "application/vnd.docker.distribution.manifest.v2+json"
+]);
+var CHECK_BATCH_SIZE = 100;
+async function ensureEcrRepository(opts) {
+  const { repositoryName, tags } = opts;
+  const ecr = opts.ecr ?? new ECRClient({ region: opts.region });
+  try {
+    const created = await ecr.send(new CreateRepositoryCommand({ repositoryName, tags }));
+    return { repositoryUri: repositoryUriOf(created.repository, repositoryName) };
+  } catch (error) {
+    if (error.name !== "RepositoryAlreadyExistsException") throw error;
+  }
+  const found = await ecr.send(
+    new DescribeRepositoriesCommand({ repositoryNames: [repositoryName] })
+  );
+  const repository = found.repositories?.[0];
+  if (tags?.length) {
+    const listed = await ecr.send(
+      new ListTagsForResourceCommand({ resourceArn: repository?.repositoryArn })
+    );
+    const has = new Map((listed.tags ?? []).map((tag) => [tag.Key, tag.Value]));
+    const missing = tags.filter((tag) => has.get(tag.Key) !== tag.Value);
+    if (missing.length > 0) {
+      const wanted = missing.map((tag) => `${tag.Key}=${tag.Value}`).join(", ");
+      throw new Error(
+        `[ensureEcrRepository] ${repositoryName} already exists without ${wanted}; refusing to adopt a repository this caller did not create`
+      );
+    }
+  }
+  return { repositoryUri: repositoryUriOf(repository, repositoryName) };
+}
+function repositoryUriOf(repository, repositoryName) {
+  if (!repository?.repositoryUri) {
+    throw new Error(`[ensureEcrRepository] ECR returned no repositoryUri for ${repositoryName}`);
+  }
+  return repository.repositoryUri;
+}
+async function pushImageToEcr(opts) {
+  const { layoutDir, repositoryName, log = () => {
+  } } = opts;
+  const ecr = opts.ecr ?? new ECRClient({ region: opts.region });
+  const manifestDescriptor = await readManifestDescriptor(layoutDir);
+  await verifyBlob(layoutDir, manifestDescriptor);
+  const manifestText = await readFile(blobPath(layoutDir, manifestDescriptor.digest), "utf-8");
+  const manifest = JSON.parse(manifestText);
+  if (!manifest.config || !Array.isArray(manifest.layers)) {
+    throw new Error(
+      `[pushImageToEcr] manifest ${manifestDescriptor.digest} has no config or layers`
+    );
+  }
+  const blobs = [manifest.config, ...manifest.layers];
+  for (const blob of blobs) await verifyBlob(layoutDir, blob);
+  const config = JSON.parse(
+    await readFile(blobPath(layoutDir, manifest.config.digest), "utf-8")
+  );
+  if (!config.architecture || !config.os) {
+    throw new Error(
+      `[pushImageToEcr] image config ${manifest.config.digest} names no architecture/os; build the image for one platform`
+    );
+  }
+  const missing = await unavailableDigests(ecr, repositoryName, blobs);
+  for (const blob of blobs) {
+    if (!missing.delete(blob.digest)) continue;
+    log(`uploading ${blob.digest} (${blob.size} bytes)`);
+    await uploadBlob(ecr, repositoryName, blobPath(layoutDir, blob.digest), blob);
+  }
+  try {
+    await ecr.send(
+      new PutImageCommand({
+        repositoryName,
+        imageManifest: manifestText,
+        imageManifestMediaType: manifestDescriptor.mediaType,
+        imageTag: opts.tag,
+        imageDigest: manifestDescriptor.digest
+      })
+    );
+  } catch (error) {
+    if (error.name !== "ImageAlreadyExistsException") throw error;
+  }
+  return {
+    imageUri: `${opts.repositoryUri}@${manifestDescriptor.digest}`,
+    digest: manifestDescriptor.digest,
+    architecture: config.architecture,
+    os: config.os
+  };
+}
+async function readManifestDescriptor(layoutDir) {
+  const index = JSON.parse(await readFile(join2(layoutDir, "index.json"), "utf-8"));
+  const manifests = index.manifests ?? [];
+  const [only] = manifests;
+  if (manifests.length !== 1 || !only || !MANIFEST_MEDIA_TYPES.has(only.mediaType)) {
+    const found = manifests.map((m) => m.mediaType).join(", ") || "none";
+    throw new Error(
+      `[pushImageToEcr] ${layoutDir}/index.json must list exactly one single-platform image manifest; found ${manifests.length} (${found}). Build one platform with --provenance=false --sbom=false.`
+    );
+  }
+  return only;
+}
+function blobPath(layoutDir, digest) {
+  const hex = /^sha256:([a-f0-9]{64})$/.exec(digest)?.[1];
+  if (!hex) throw new Error(`[pushImageToEcr] unsupported blob digest ${JSON.stringify(digest)}`);
+  return join2(layoutDir, "blobs", "sha256", hex);
+}
+async function verifyBlob(layoutDir, blob) {
+  const path = blobPath(layoutDir, blob.digest);
+  const size = (await stat(path)).size;
+  if (size !== blob.size || `sha256:${await sha256File(path)}` !== blob.digest) {
+    throw new Error(
+      `[pushImageToEcr] blob ${blob.digest} (${size} bytes, expected ${blob.size}) does not match its descriptor; the image layout is corrupt`
+    );
+  }
+}
+async function unavailableDigests(ecr, repositoryName, blobs) {
+  const missing = new Set(blobs.map((blob) => blob.digest));
+  const digests = [...missing];
+  for (let i = 0; i < digests.length; i += CHECK_BATCH_SIZE) {
+    const { layers = [] } = await ecr.send(
+      new BatchCheckLayerAvailabilityCommand({
+        repositoryName,
+        layerDigests: digests.slice(i, i + CHECK_BATCH_SIZE)
+      })
+    );
+    for (const layer of layers) {
+      if (layer.layerAvailability === "AVAILABLE" && layer.layerDigest) {
+        missing.delete(layer.layerDigest);
+      }
+    }
+  }
+  return missing;
+}
+async function uploadBlob(ecr, repositoryName, path, blob) {
+  const { uploadId, partSize } = await ecr.send(new InitiateLayerUploadCommand({ repositoryName }));
+  if (!uploadId || !partSize) {
+    throw new Error(`[pushImageToEcr] InitiateLayerUpload returned no uploadId/partSize`);
+  }
+  const file = await open(path);
+  try {
+    for (let first = 0; first < blob.size; first += partSize) {
+      const part = Buffer.alloc(Math.min(partSize, blob.size - first));
+      const { bytesRead } = await file.read(part, 0, part.length, first);
+      if (bytesRead !== part.length) throw new Error(`[pushImageToEcr] ${path} changed on disk`);
+      await ecr.send(
+        new UploadLayerPartCommand({
+          repositoryName,
+          uploadId,
+          partFirstByte: first,
+          partLastByte: first + part.length - 1,
+          layerPartBlob: part
+        })
+      );
+    }
+  } finally {
+    await file.close();
+  }
+  try {
+    await ecr.send(
+      new CompleteLayerUploadCommand({ repositoryName, uploadId, layerDigests: [blob.digest] })
+    );
+  } catch (error) {
+    if (error.name !== "LayerAlreadyExistsException") throw error;
+  }
 }
 export {
   InvalidConfigError,
@@ -42,8 +229,11 @@ export {
   assertStackReadsSites,
   computeRenderCost,
   deploySite,
+  ensureEcrRepository,
   getRenderProgress,
   prebuiltHandler,
+  prebuiltVideoImage,
+  pushImageToEcr,
   renderToLambda,
   siteHandleFromId,
   validateDistributedRenderConfig,

package/dist/sdk/prebuiltHandler.d.ts

@@ -1,13 +1,15 @@
 export declare const HANDLER_ZIP_ASSET = "hyperframes-lambda-handler.zip";
 export declare const PREBUILT_DIR = "prebuilt";
 export declare const HANDLER_MANIFEST_FILE = "handler-zip.json";
-export interface HandlerZipManifest {
+export declare const VIDEO_IMAGE_ASSET = "hyperframes-lambda-video-arm64.oci.tar";
+export declare const VIDEO_IMAGE_MANIFEST_FILE = "video-image.json";
+export interface ReleaseAssetManifest {
     version: string;
     url: string;
     sha256: string;
     bytes: number;
 }
-export interface PrebuiltHandler extends HandlerZipManifest {
+export interface PrebuiltHandler extends ReleaseAssetManifest {
     /** SAM template whose `CodeUri` is `handler.zip` in the same directory. */
     templatePath: string;
 }
@@ -15,3 +17,5 @@ export interface PrebuiltHandler extends HandlerZipManifest {
 export declare function adapterPackageRoot(): string;
 /** The pinned handler for this install, or undefined when this build carries none. */
 export declare function prebuiltHandler(root?: string): PrebuiltHandler | undefined;
+/** The pinned arm64 video function image (an OCI layout tarball), or undefined when none is pinned. */
+export declare function prebuiltVideoImage(root?: string): ReleaseAssetManifest | undefined;

package/dist/sdk/pushImageToEcr.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Push a prebuilt single-platform OCI image layout into ECR through the ECR API alone,
+ * so deploying the container-image function needs neither Docker nor registry HTTP calls.
+ */
+import { ECRClient, type Tag } from "@aws-sdk/client-ecr";
+/** Options for {@link ensureEcrRepository}. */
+export interface EnsureEcrRepositoryOptions {
+    ecr?: ECRClient;
+    region?: string;
+    repositoryName: string;
+    /** Set on create. An existing repository is adopted only if it already carries every one. */
+    tags?: Tag[];
+}
+/** Create the repository, or adopt an existing one that carries `tags`. */
+export declare function ensureEcrRepository(opts: EnsureEcrRepositoryOptions): Promise<{
+    repositoryUri: string;
+}>;
+/** Options for {@link pushImageToEcr}. */
+export interface PushImageToEcrOptions {
+    ecr?: ECRClient;
+    region?: string;
+    /** OCI image layout directory: `index.json` plus `blobs/sha256/<hex>`. */
+    layoutDir: string;
+    repositoryName: string;
+    /** From {@link ensureEcrRepository}. */
+    repositoryUri: string;
+    tag: string;
+    log?: (message: string) => void;
+}
+/** Result of {@link pushImageToEcr}. */
+export interface PushedImage {
+    /** `<repositoryUri>@sha256:<manifest digest>`, pinned to exactly the pushed bytes. */
+    imageUri: string;
+    digest: string;
+    /** From the image config, so callers can assert the platform they expect. */
+    architecture: string;
+    os: string;
+}
+/** Upload the layout's missing blobs, then put its manifest under `tag`. Safe to re-run. */
+export declare function pushImageToEcr(opts: PushImageToEcrOptions): Promise<PushedImage>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/aws-lambda",
-  "version": "0.8.186",
+  "version": "0.8.189",
   "description": "AWS Lambda adapter for HyperFrames distributed rendering — handler, client-side SDK, and CDK construct.",
   "repository": {
     "type": "git",
@@ -12,6 +12,8 @@
     "prebuilt/",
     "scripts/",
     "!scripts/*.test.ts",
+    "!scripts/pin-handler-zip.ts",
+    "!scripts/stage-arm64-image.ts",
     "README.md"
   ],
   "type": "module",
@@ -40,6 +42,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
+    "@aws-sdk/client-ecr": "^3.1146.0",
     "@aws-sdk/client-lambda": "^3.1146.0",
     "@aws-sdk/client-s3": "^3.1146.0",
     "@aws-sdk/client-sfn": "^3.1146.0",
@@ -49,7 +52,7 @@
     "ffprobe-static": "^3.1.0",
     "puppeteer-core": "^25.8.0",
     "tar": "^7.4.3",
-    "@hyperframes/producer": "^0.8.186"
+    "@hyperframes/producer": "^0.8.189"
   },
   "devDependencies": {
     "@types/aws-lambda": "^8.10.146",

package/prebuilt/handler-zip.json

@@ -1,6 +1,6 @@
 {
-  "version": "0.8.186",
-  "url": "https://github.com/heygen-com/hyperframes/releases/download/v0.8.186/hyperframes-lambda-handler.zip",
-  "sha256": "fa8555652527ad7daeefe1bc843eca96e7be7a8b2be310d1d0686a2347dd7ef1",
-  "bytes": 129247659
+  "version": "0.8.189",
+  "url": "https://github.com/heygen-com/hyperframes/releases/download/v0.8.189/hyperframes-lambda-handler.zip",
+  "sha256": "95078b7e47160ad95141a051ae8bf772909229c3d626eea59061ddcd5cfb764f",
+  "bytes": 129250008
 }

package/prebuilt/template.yaml

@@ -3,7 +3,7 @@ Transform: AWS::Serverless-2016-10-31
 Description: >-
   HyperFrames distributed rendering — Step Functions standard workflow with
   one Lambda function handling Plan, RenderChunk (fan-out via Map state),
-  and Assemble. One S3 bucket, alarms for runaway concurrency, Lambda
+  and Assemble, or Plan and RenderChunk on an optional arm64 image. One S3 bucket, alarms for runaway concurrency, Lambda
   errors, and Step Functions execution failures.
 
   Built from the handler ZIP at packages/aws-lambda/dist/handler.zip.
@@ -64,29 +64,29 @@ Parameters:
       chunks than expected; an alarm at 10× the typical workload
       protects against billing surprises.
 
+  VideoImageUri:
+    Type: String
+    Default: ""
+    Description: >-
+      Optional arm64 image (`<ECR repository URI>@sha256:<digest>`) that runs the
+      plan and renders the chunks. Audio and assemble stay on the x86 render
+      function. Empty: one x86 function does it all.
+
 Conditions:
   HasReservedConcurrency: !Not [!Equals [!Ref ReservedConcurrency, -1]]
+  HasVideoFunction: !Not [!Equals [!Ref VideoImageUri, ""]]
 
 Globals:
   Function:
-    Runtime: nodejs22.x
     MemorySize: !Ref LambdaMemoryMb
     Timeout: !Ref LambdaTimeoutSec
-    # x86_64 is required for @sparticuz/chromium — its prebuilt
-    # Chromium ships x86_64-only. Adopters who switch to a custom
-    # ARM-built chrome-headless-shell can change this to `arm64`, but
-    # the default ZIP build will fail to launch on Graviton.
-    Architectures: [x86_64]
     # Lambda function-level X-Ray tracing. The state machine already
     # has Tracing.Enabled: true; without this, X-Ray traces would
     # terminate at the Step Functions → Lambda boundary instead of
     # following into per-function spans.
     Tracing: Active
-    # Cost-allocation tags. Setting these at the Globals level applies
-    # to every AWS::Serverless::Function in the template — there's
-    # only one today, but the contract is portable to multi-function
-    # variants. Bucket + state-machine carry the same tags resource-
-    # locally because Globals only covers functions.
+    # Cost-allocation tags for the render function. Bucket, state machine and
+    # video-function.yaml carry the same tags themselves; Globals covers only SAM functions.
     Tags:
       Project: !Ref ProjectName
       HyperFramesComponent: lambda-renderer
@@ -149,14 +149,18 @@ Resources:
       Description: >-
         HyperFrames distributed render handler. Dispatches on event.Action.
       Handler: handler.handler
+      Runtime: nodejs22.x
+      # The ZIP's @sparticuz/chromium ships x86_64 Chrome only; video-function.yaml runs chunks on arm64.
+      Architectures: [x86_64]
       # Local path is resolved by `sam build` + `sam deploy --resolve-s3`
       # (or `--s3-bucket`); the resulting CodeUri rewrites to s3://.
       CodeUri: handler.zip
       PackageType: Zip
+      # With a video function the chunks run there, so the reservation moves with them.
       ReservedConcurrentExecutions: !If
-        - HasReservedConcurrency
-        - !Ref ReservedConcurrency
+        - HasVideoFunction
         - !Ref AWS::NoValue
+        - !If [HasReservedConcurrency, !Ref ReservedConcurrency, !Ref AWS::NoValue]
       EphemeralStorage:
         Size: 10240
       Environment:
@@ -184,6 +188,27 @@ Resources:
       # CreateExportTask). Reference templates shouldn't leak overbroad
       # IAM into adopters' accounts.
 
+  # ── Optional arm64 chunk renderer: the same handler as a container image ──
+  # Nested: `sam deploy` demands an image repository for any image function in this template.
+  VideoFunctionStack:
+    Type: AWS::CloudFormation::Stack
+    Condition: HasVideoFunction
+    Properties:
+      TemplateURL: video-function.yaml
+      Parameters:
+        ProjectName: !Ref ProjectName
+        ImageUri: !Ref VideoImageUri
+        RenderBucket: !Ref RenderBucket
+        MemorySize: !Ref LambdaMemoryMb
+        Timeout: !Ref LambdaTimeoutSec
+        ReservedConcurrency: !Ref ReservedConcurrency
+        ChromeSource: !Ref ChromeSource
+      Tags:
+        - Key: Project
+          Value: !Ref ProjectName
+        - Key: HyperFramesComponent
+          Value: lambda-renderer
+
   # ── CloudWatch log group for the state machine ──────────────────────────
   # SAM doesn't auto-create one when `LoggingConfiguration` is set, so we
   # define it explicitly — that way the IAM grant on the state-machine
@@ -249,7 +274,13 @@ Resources:
             Type: Task
             Resource: arn:aws:states:::lambda:invoke
             Parameters:
-              FunctionName: !GetAtt RenderFunction.Arn
+              # 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
@@ -308,7 +339,12 @@ Resources:
             Type: Task
             Resource: arn:aws:states:::lambda:invoke
             Parameters:
-              FunctionName: !GetAtt RenderFunction.Arn
+              FunctionName:
+                !If [
+                  HasVideoFunction,
+                  !GetAtt VideoFunctionStack.Outputs.FunctionArn,
+                  !GetAtt RenderFunction.Arn,
+                ]
               Payload:
                 Action: plan
                 PlanProtocol: v2
@@ -424,7 +460,12 @@ Resources:
                   Type: Task
                   Resource: arn:aws:states:::lambda:invoke
                   Parameters:
-                    FunctionName: !GetAtt RenderFunction.Arn
+                    FunctionName:
+                      !If [
+                        HasVideoFunction,
+                        !GetAtt VideoFunctionStack.Outputs.FunctionArn,
+                        !GetAtt RenderFunction.Arn,
+                      ]
                     Payload:
                       Action: renderChunk
                       PlanProtocol: v1
@@ -542,7 +583,12 @@ Resources:
                           Type: Task
                           Resource: arn:aws:states:::lambda:invoke
                           Parameters:
-                            FunctionName: !GetAtt RenderFunction.Arn
+                            FunctionName:
+                              !If [
+                                HasVideoFunction,
+                                !GetAtt VideoFunctionStack.Outputs.FunctionArn,
+                                !GetAtt RenderFunction.Arn,
+                              ]
                             Payload:
                               Action: renderChunk
                               PlanProtocol: v2
@@ -725,7 +771,13 @@ Resources:
             Statement:
               - Effect: Allow
                 Action: lambda:InvokeFunction
-                Resource: !GetAtt RenderFunction.Arn
+                Resource:
+                  - !GetAtt RenderFunction.Arn
+                  - !If [
+                      HasVideoFunction,
+                      !GetAtt VideoFunctionStack.Outputs.FunctionArn,
+                      !Ref AWS::NoValue,
+                    ]
         # A Distributed Map runs each chunk as a child execution of this state machine.
         # ARNs built by name: !Ref RenderStateMachine here would be a dependency cycle.
         - PolicyName: RunDistributedMapChildren
@@ -780,7 +832,12 @@ Resources:
       MetricName: Invocations
       Dimensions:
         - Name: FunctionName
-          Value: !Ref RenderFunction
+          Value:
+            !If [
+              HasVideoFunction,
+              !GetAtt VideoFunctionStack.Outputs.FunctionName,
+              !Ref RenderFunction,
+            ]
       Statistic: Sum
       Period: 3600
       EvaluationPeriods: 1
@@ -813,6 +870,25 @@ Resources:
       ComparisonOperator: GreaterThanOrEqualToThreshold
       TreatMissingData: notBreaching
 
+  VideoFunctionErrorsAlarm:
+    Type: AWS::CloudWatch::Alarm
+    Condition: HasVideoFunction
+    Properties:
+      AlarmName: !Sub "${ProjectName}-video-function-errors"
+      AlarmDescription: >-
+        Fires if the arm64 chunk Lambda reports any errors in a 5-minute window.
+      Namespace: AWS/Lambda
+      MetricName: Errors
+      Dimensions:
+        - Name: FunctionName
+          Value: !GetAtt VideoFunctionStack.Outputs.FunctionName
+      Statistic: Sum
+      Period: 300
+      EvaluationPeriods: 1
+      Threshold: 1
+      ComparisonOperator: GreaterThanOrEqualToThreshold
+      TreatMissingData: notBreaching
+
   # ── CloudWatch alarm: Step Functions execution failures ─────────────────
   # Fires when a state-machine execution reaches a terminal failure
   # state (typed non-retryable, retry-exhausted, or top-level timeout).
@@ -853,6 +929,11 @@ Outputs:
     Export:
       Name: !Sub "${AWS::StackName}-RenderFunctionArn"
 
+  VideoFunctionArn:
+    Condition: HasVideoFunction
+    Description: ARN of the arm64 chunk-rendering function.
+    Value: !GetAtt VideoFunctionStack.Outputs.FunctionArn
+
   RenderStateMachineArn:
     Description: ARN of the Step Functions state machine. Pass to `aws stepfunctions start-execution`.
     Value: !Ref RenderStateMachine

package/prebuilt/video-function.yaml

@@ -0,0 +1,108 @@
+AWSTemplateFormatVersion: "2010-09-09"
+Description: >-
+  HyperFrames arm64 video renderer: the render handler as a container image, invoked for plan and
+  renderChunk. Nested in template.yaml when VideoImageUri is set; plain CloudFormation, because `sam deploy`
+  demands an image repository for any top-level image function, even one whose Condition is false.
+
+Parameters:
+  ProjectName:
+    Type: String
+  ImageUri:
+    Type: String
+  RenderBucket:
+    Type: String
+  MemorySize:
+    Type: Number
+  Timeout:
+    Type: Number
+  ReservedConcurrency:
+    Type: Number
+  ChromeSource:
+    Type: String
+
+Conditions:
+  HasReservedConcurrency: !Not [!Equals [!Ref ReservedConcurrency, -1]]
+
+Resources:
+  Role:
+    Type: AWS::IAM::Role
+    Properties:
+      AssumeRolePolicyDocument:
+        Version: "2012-10-17"
+        Statement:
+          - Effect: Allow
+            Principal:
+              Service: lambda.amazonaws.com
+            Action: sts:AssumeRole
+      ManagedPolicyArns:
+        - !Sub "arn:${AWS::Partition}:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
+        - !Sub "arn:${AWS::Partition}:iam::aws:policy/AWSXRayDaemonWriteAccess"
+      # The render function's S3CrudPolicy plus AbortMultipartUpload, spelled out.
+      Policies:
+        - PolicyName: render-bucket
+          PolicyDocument:
+            Version: "2012-10-17"
+            Statement:
+              - Effect: Allow
+                Action:
+                  - s3:GetObject
+                  - s3:ListBucket
+                  - s3:GetBucketLocation
+                  - s3:GetObjectVersion
+                  - s3:PutObject
+                  - s3:PutObjectAcl
+                  - s3:GetLifecycleConfiguration
+                  - s3:PutLifecycleConfiguration
+                  - s3:DeleteObject
+                  - s3:AbortMultipartUpload
+                Resource:
+                  - !Sub "arn:${AWS::Partition}:s3:::${RenderBucket}"
+                  - !Sub "arn:${AWS::Partition}:s3:::${RenderBucket}/*"
+              # The plan sizes an unreserved render to the account's concurrency.
+              - Effect: Allow
+                Action: lambda:GetAccountSettings
+                Resource: "*"
+      Tags:
+        - Key: Project
+          Value: !Ref ProjectName
+        - Key: HyperFramesComponent
+          Value: lambda-renderer
+
+  Function:
+    Type: AWS::Lambda::Function
+    Properties:
+      FunctionName: !Sub "${ProjectName}-video"
+      Description: HyperFrames distributed render handler on arm64, invoked for plan and renderChunk.
+      PackageType: Image
+      Code:
+        ImageUri: !Ref ImageUri
+      Architectures: [arm64]
+      Role: !GetAtt Role.Arn
+      MemorySize: !Ref MemorySize
+      Timeout: !Ref Timeout
+      ReservedConcurrentExecutions: !If
+        - HasReservedConcurrency
+        - !Ref ReservedConcurrency
+        - !Ref AWS::NoValue
+      EphemeralStorage:
+        Size: 10240
+      TracingConfig:
+        Mode: Active
+      Environment:
+        Variables:
+          NODE_OPTIONS: "--enable-source-maps"
+          HYPERFRAMES_LAMBDA_CHROME_SOURCE: !Ref ChromeSource
+          TMPDIR: /tmp
+          HYPERFRAMES_RENDER_BUCKET: !Ref RenderBucket
+          HYPERFRAMES_LAMBDA_RESERVED_CONCURRENCY: !Ref ReservedConcurrency
+      Tags:
+        - Key: Project
+          Value: !Ref ProjectName
+        - Key: HyperFramesComponent
+          Value: lambda-renderer
+
+Outputs:
+  FunctionArn:
+    Value: !GetAtt Function.Arn
+  FunctionName:
+    Value: !Ref Function

package/prebuilt/video-image.json

@@ -0,0 +1,6 @@
+{
+  "version": "0.8.189",
+  "url": "https://github.com/heygen-com/hyperframes/releases/download/v0.8.189/hyperframes-lambda-video-arm64.oci.tar",
+  "sha256": "f47d18971cccbdef020abc1e43fb1d5296ece69af7f02e0bde1f951db61aea73",
+  "bytes": 244629504
+}

package/scripts/prebuilt-template.mjs

@@ -1,11 +1,15 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { copyFileSync, 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. */
+/**
+ * Writes `<outDir>/template.yaml`, the example SAM template pointed at a `handler.zip` beside it, and
+ * the `video-function.yaml` it nests.
+ */
 export function writePrebuiltTemplate(repoRoot, outDir) {
-  const template = readFileSync(join(repoRoot, "examples", "aws-lambda", "template.yaml"), "utf-8");
+  const examples = join(repoRoot, "examples", "aws-lambda");
+  const template = readFileSync(join(examples, "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`,
@@ -16,4 +20,5 @@ export function writePrebuiltTemplate(repoRoot, outDir) {
     join(outDir, "template.yaml"),
     template.replace(CHECKOUT_CODE_URI, "CodeUri: handler.zip"),
   );
+  copyFileSync(join(examples, "video-function.yaml"), join(outDir, "video-function.yaml"));
 }

package/scripts/pin-handler-zip.ts

@@ -1,48 +0,0 @@
-#!/usr/bin/env bun
-// Release step: writes the handler ZIP's pin (asset URL + sha256) and the SAM template into the
-// package. A retried release run reuses the ZIP already on the release.
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import {
-  HANDLER_MANIFEST_FILE,
-  HANDLER_ZIP_ASSET,
-  type HandlerZipManifest,
-  PREBUILT_DIR,
-} from "../src/sdk/prebuiltHandler.js";
-import { writePrebuiltTemplate } from "./prebuilt-template.mjs";
-
-export function pinHandlerZip(repoRoot: string): HandlerZipManifest {
-  const pkgDir = join(repoRoot, "packages", "aws-lambda");
-  const pkg = JSON.parse(readFileSync(join(pkgDir, "package.json"), "utf-8")) as {
-    version: string;
-    repository: { url: string };
-  };
-  const asset = join(repoRoot, "dist", HANDLER_ZIP_ASSET);
-  const built = join(pkgDir, "dist", "handler.zip");
-  if (existsSync(built)) {
-    mkdirSync(dirname(asset), { recursive: true });
-    renameSync(built, asset);
-    rmSync(`${built}.manifest.json`, { force: true });
-  }
-  const bytes = readFileSync(asset);
-  const sha256 = createHash("sha256").update(bytes).digest("hex");
-  writeFileSync(asset.replace(/\.zip$/, ".sha256"), `${sha256}  ${HANDLER_ZIP_ASSET}\n`);
-
-  const outDir = join(pkgDir, PREBUILT_DIR);
-  writePrebuiltTemplate(repoRoot, outDir);
-  const manifest: HandlerZipManifest = {
-    version: pkg.version,
-    url: `${pkg.repository.url}/releases/download/v${pkg.version}/${HANDLER_ZIP_ASSET}`,
-    sha256,
-    bytes: bytes.length,
-  };
-  writeFileSync(join(outDir, HANDLER_MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}\n`);
-  return manifest;
-}
-
-if (import.meta.main) {
-  const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../../..");
-  console.log(JSON.stringify(pinHandlerZip(repoRoot), null, 2));
-}