@hyperframes/aws-lambda 0.6.20

package/dist/chromium.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chromium.d.ts","sourceRoot":"","sources":["../src/chromium.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAIH,0DAA0D;AAC1D,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,uBAAuB,CAAC;AAEjE;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,YAAY,CAIlD;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,2BAA2B,IAAI,OAAO,CAAC,MAAM,CAAC,CAmBnE;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAI3D;AAED;;;;;;GAMG;AACH,UAAU,uBAAuB;IAC/B,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CACnC;AAcD,uEAAuE;AACvE,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,uBAAuB,GAAG,IAAI,GAAG,IAAI,CAEvF"}

package/dist/events.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Lambda event + result types for the HyperFrames distributed render handler.
+ *
+ * The Step Functions state machine in `examples/aws-lambda/template.yaml`
+ * 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)
+ *   "renderChunk" → `renderChunk(planDir, chunkIndex, output)` (Activity B)
+ *   "assemble"    → `assemble(planDir, chunkPaths, audio, out)` (Activity C)
+ *
+ * All file I/O is mediated by S3 — the handler downloads inputs into
+ * `/tmp` (Lambda's only writable filesystem path), invokes the primitive,
+ * uploads outputs back to S3, and returns a small JSON payload that fits
+ * inside Step Functions' history budget (under 200 bytes for chunk
+ * results per §2.4).
+ */
+import type { DistributedRenderConfig } from "@hyperframes/producer/distributed";
+/** Discriminator for the three roles the one Lambda image fulfills. */
+export type LambdaAction = "plan" | "renderChunk" | "assemble";
+/**
+ * Top-level shape of any event the handler may receive.
+ *
+ * Step Functions can also invoke with a wrapped payload (e.g. when a Map
+ * state's `ItemSelector` passes through `$$.Map.Item.Value`), so the
+ * handler unwraps both `event.Payload` and `event.Input` before
+ * dispatching.
+ */
+export type LambdaEvent = PlanEvent | RenderChunkEvent | AssembleEvent | {
+    Payload: LambdaEvent;
+} | {
+    Input: LambdaEvent;
+};
+/** Activity A: produce a planDir, upload to S3. */
+export interface PlanEvent {
+    Action: "plan";
+    /** S3 URI pointing at a `tar -czf`-archived project directory (`s3://bucket/key.tar.gz`). */
+    ProjectS3Uri: string;
+    /** S3 URI prefix where the planDir tar should be uploaded (`s3://bucket/{prefix}/`). */
+    PlanOutputS3Prefix: string;
+    /** `DistributedRenderConfig` minus runtime-only fields (logger, abortSignal). */
+    Config: SerializableDistributedRenderConfig;
+}
+/** Activity B: fetch planDir, render one chunk, upload result. */
+export interface RenderChunkEvent {
+    Action: "renderChunk";
+    /** S3 URI of the plan tar produced by a PlanEvent invocation. */
+    PlanS3Uri: string;
+    /**
+     * `PlanResult.planHash` from the Plan invocation. The handler verifies
+     * this against the untarred planDir's `plan.json` before invoking the
+     * producer, throwing a typed `PLAN_HASH_MISMATCH` on divergence so the
+     * state machine routes it as non-retryable. Defense-in-depth — the
+     * producer also re-checks internally.
+     */
+    PlanHash: string;
+    /** 0-based chunk index this invocation should render. */
+    ChunkIndex: number;
+    /** S3 URI prefix where the chunk output should be uploaded (`s3://bucket/{prefix}/`). */
+    ChunkOutputS3Prefix: string;
+    /** Output container format from the plan's encoder.json; drives file vs frame-dir handling. */
+    Format: "mp4" | "mov" | "png-sequence";
+}
+/** Activity C: fetch planDir + all chunks + audio, assemble, upload final. */
+export interface AssembleEvent {
+    Action: "assemble";
+    /** S3 URI of the plan tar produced by a PlanEvent invocation. */
+    PlanS3Uri: string;
+    /** S3 URIs of every chunk, ordered by chunk index. Length must equal `chunkCount`. */
+    ChunkS3Uris: string[];
+    /** S3 URI of the planDir's `audio.aac` if the composition has audio; `null` otherwise. */
+    AudioS3Uri: string | null;
+    /** Final output S3 URI (`s3://bucket/key.mp4`). */
+    OutputS3Uri: string;
+    /** Output container format; drives file vs frame-dir handling. */
+    Format: "mp4" | "mov" | "png-sequence";
+}
+/**
+ * `DistributedRenderConfig` minus the runtime-only fields (`logger`,
+ * `abortSignal`, `producerConfig`). The Step Functions event JSON cannot
+ * carry function references; the handler reconstitutes the runtime fields
+ * from Lambda environment + the AbortController it owns.
+ */
+export type SerializableDistributedRenderConfig = Omit<DistributedRenderConfig, "logger" | "abortSignal" | "producerConfig">;
+/** Result of a `plan` invocation. Carries enough to size the Map(N) state. */
+export interface PlanLambdaResult {
+    Action: "plan";
+    PlanS3Uri: string;
+    PlanHash: string;
+    ChunkCount: number;
+    TotalFrames: number;
+    Fps: 24 | 30 | 60;
+    Width: number;
+    Height: number;
+    Format: "mp4" | "mov" | "png-sequence";
+    HasAudio: boolean;
+    AudioS3Uri: string | null;
+    FfmpegVersion: string;
+    ProducerVersion: string;
+    DurationMs: number;
+}
+/** Result of a `renderChunk` invocation. Sized ≤200 bytes per §2.4. */
+export interface RenderChunkLambdaResult {
+    Action: "renderChunk";
+    ChunkS3Uri: string;
+    ChunkIndex: number;
+    Sha256: string;
+    FramesEncoded: number;
+    DurationMs: number;
+}
+/** Result of an `assemble` invocation. */
+export interface AssembleLambdaResult {
+    Action: "assemble";
+    OutputS3Uri: string;
+    FramesEncoded: number;
+    FileSize: number;
+    DurationMs: number;
+}
+export type LambdaResult = PlanLambdaResult | RenderChunkLambdaResult | AssembleLambdaResult;
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"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"}

package/dist/formatExtension.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Map a distributed `format` to the file extension the assembled output
+ * should carry on disk + in S3. Shared by `src/handler.ts` (chunk +
+ * assemble output paths) and `src/sdk/renderToLambda.ts` (final
+ * output key construction) so the two sides agree on what an mp4
+ * looks like vs a png-sequence.
+ */
+export type DistributedFormat = "mp4" | "mov" | "png-sequence";
+export declare function formatExtension(format: DistributedFormat): string;
+//# sourceMappingURL=formatExtension.d.ts.map

package/dist/formatExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatExtension.d.ts","sourceRoot":"","sources":["../src/formatExtension.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,MAAM,iBAAiB,GAAG,KAAK,GAAG,KAAK,GAAG,cAAc,CAAC;AAE/D,wBAAgB,eAAe,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAajE"}

package/dist/handler.d.ts

@@ -0,0 +1,42 @@
+/**
+ * AWS Lambda handler for HyperFrames distributed rendering.
+ *
+ * One Lambda function, three roles. Step Functions dispatches by setting
+ * `event.Action`; the handler unwraps Map-state envelopes, primes the
+ * Lambda environment (Chrome path, ffmpeg path, tmpdir), and forwards to
+ * the matching OSS primitive from `@hyperframes/producer/distributed`.
+ *
+ * Everything heavy — capture, encode, audio mix — happens inside the OSS
+ * primitives. The handler is thin glue: parse event → S3 download → call
+ * primitive → S3 upload → return small JSON result.
+ */
+import { S3Client } from "@aws-sdk/client-s3";
+import { assemble, plan, renderChunk } from "@hyperframes/producer/distributed";
+import type { AssembleEvent, 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
+ * inject `s3` and `primitives` directly rather than mutating module
+ * state — the dependency-injection seam is sufficient and avoids a
+ * second leak point for cross-test contamination.
+ */
+export interface HandlerDeps {
+    s3?: S3Client;
+    primitives?: {
+        plan: typeof plan;
+        renderChunk: typeof renderChunk;
+        assemble: typeof assemble;
+    };
+    /** Override the per-invocation `/tmp` workdir root (defaults to Lambda's `/tmp`). */
+    tmpRoot?: string;
+    /** Skip Chrome resolution (used by handler dispatch tests that mock renderChunk). */
+    skipChromeResolution?: boolean;
+}
+/**
+ * Lambda entry. Step Functions sometimes wraps the event in
+ * `{ Payload: ... }` or `{ Input: ... }` depending on the state machine
+ * 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;
+//# sourceMappingURL=handler.d.ts.map

package/dist/handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../src/handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EACL,QAAQ,EAIR,IAAI,EAEJ,WAAW,EACZ,MAAM,mCAAmC,CAAC;AAG3C,OAAO,KAAK,EACV,aAAa,EAGb,WAAW,EACX,YAAY,EACZ,SAAS,EAET,gBAAgB,EAEjB,MAAM,aAAa,CAAC;AAoBrB;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,EAAE,CAAC,EAAE,QAAQ,CAAC;IACd,UAAU,CAAC,EAAE;QACX,IAAI,EAAE,OAAO,IAAI,CAAC;QAClB,WAAW,EAAE,OAAO,WAAW,CAAC;QAChC,QAAQ,EAAE,OAAO,QAAQ,CAAC;KAC3B,CAAC;IACF,qFAAqF;IACrF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qFAAqF;IACrF,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;;GAIG;AACH,wBAAsB,OAAO,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAuC3F;AAWD,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,GAAG,gBAAgB,GAAG,aAAa,CAsB5F"}

package/dist/handler.js

@@ -0,0 +1,432 @@
+// src/handler.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, mkdtempSync, readFileSync, rmSync as rmSync2, statSync as statSync2 } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join as join2 } from "node:path";
+import { S3Client } from "@aws-sdk/client-s3";
+import {
+  assemble,
+  plan,
+  renderChunk
+} from "@hyperframes/producer/distributed";
+
+// src/chromium.ts
+import { existsSync } from "node:fs";
+function resolveChromeSource() {
+  const raw = process.env.HYPERFRAMES_LAMBDA_CHROME_SOURCE?.toLowerCase();
+  if (raw === "chrome-headless-shell" || raw === "shell") return "chrome-headless-shell";
+  return "sparticuz";
+}
+async function resolveChromeExecutablePath() {
+  const source = resolveChromeSource();
+  if (source === "sparticuz") {
+    const mod = await loadSparticuzChromium();
+    return mod.executablePath();
+  }
+  const explicit = process.env.HYPERFRAMES_LAMBDA_CHROME_PATH;
+  if (!explicit) {
+    throw new Error(
+      "[chromium] HYPERFRAMES_LAMBDA_CHROME_SOURCE=chrome-headless-shell requires HYPERFRAMES_LAMBDA_CHROME_PATH to be set to the absolute path of the bundled binary."
+    );
+  }
+  if (!existsSync(explicit)) {
+    throw new Error(
+      `[chromium] HYPERFRAMES_LAMBDA_CHROME_PATH=${JSON.stringify(explicit)} does not exist`
+    );
+  }
+  return explicit;
+}
+var cachedSparticuz = null;
+async function loadSparticuzChromium() {
+  if (cachedSparticuz) return cachedSparticuz;
+  const mod = await import("@sparticuz/chromium");
+  const resolved = "default" in mod ? mod.default : mod;
+  cachedSparticuz = resolved;
+  return resolved;
+}
+
+// src/formatExtension.ts
+function formatExtension(format) {
+  switch (format) {
+    case "mp4":
+      return ".mp4";
+    case "mov":
+      return ".mov";
+    case "png-sequence":
+      return "";
+    default: {
+      const _exhaustive = format;
+      throw new Error(`[formatExtension] unsupported format: ${_exhaustive}`);
+    }
+  }
+}
+
+// src/s3Transport.ts
+import {
+  createReadStream,
+  createWriteStream,
+  existsSync as existsSync2,
+  mkdirSync,
+  readdirSync,
+  rmSync,
+  statSync
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3";
+import * as tar from "tar";
+function parseS3Uri(uri) {
+  if (!uri.startsWith("s3://")) {
+    throw new Error(`[s3Transport] expected s3:// URI, got: ${JSON.stringify(uri)}`);
+  }
+  const rest = uri.slice("s3://".length);
+  const slash = rest.indexOf("/");
+  if (slash === -1) {
+    throw new Error(`[s3Transport] missing key in s3 URI: ${JSON.stringify(uri)}`);
+  }
+  const bucket = rest.slice(0, slash);
+  const key = rest.slice(slash + 1);
+  if (!bucket || !key) {
+    throw new Error(`[s3Transport] empty bucket or key in s3 URI: ${JSON.stringify(uri)}`);
+  }
+  return { bucket, key };
+}
+async function downloadS3ObjectToFile(client, uri, destPath) {
+  const { bucket, key } = parseS3Uri(uri);
+  const response = await client.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+  const body = response.Body;
+  if (!body) {
+    throw new Error(`[s3Transport] s3 GetObject returned empty body for ${uri}`);
+  }
+  mkdirSync(dirname(destPath), { recursive: true });
+  await pipeline(body, createWriteStream(destPath));
+}
+async function uploadFileToS3(client, localPath, uri, contentType) {
+  if (!existsSync2(localPath)) {
+    throw new Error(`[s3Transport] upload source missing: ${localPath}`);
+  }
+  const { bucket, key } = parseS3Uri(uri);
+  const size = statSync(localPath).size;
+  await client.send(
+    new PutObjectCommand({
+      Bucket: bucket,
+      Key: key,
+      Body: createReadStream(localPath),
+      ContentType: contentType,
+      ContentLength: size
+    })
+  );
+}
+async function tarDirectory(sourceDir, destTarball) {
+  if (!existsSync2(sourceDir) || !statSync(sourceDir).isDirectory()) {
+    throw new Error(`[s3Transport] tar source must be an existing directory: ${sourceDir}`);
+  }
+  mkdirSync(dirname(destTarball), { recursive: true });
+  await tar.create({ gzip: true, file: destTarball, cwd: sourceDir }, ["."]);
+}
+async function untarDirectory(tarballPath, destDir) {
+  if (!existsSync2(tarballPath)) {
+    throw new Error(`[s3Transport] tarball missing: ${tarballPath}`);
+  }
+  if (existsSync2(destDir)) {
+    rmSync(destDir, { recursive: true, force: true });
+  }
+  mkdirSync(destDir, { recursive: true });
+  await tar.extract({ file: tarballPath, cwd: destDir });
+}
+
+// src/handler.ts
+var cachedS3Client = null;
+function getS3Client() {
+  if (cachedS3Client) return cachedS3Client;
+  cachedS3Client = new S3Client({});
+  return cachedS3Client;
+}
+async function handler(event, deps) {
+  const unwrapped = unwrapEvent(event);
+  primeRuntimeEnv();
+  logEvent({ event: "handler_start", action: unwrapped.Action, input: summarizeEvent(unwrapped) });
+  try {
+    switch (unwrapped.Action) {
+      case "plan":
+        return await handlePlan(unwrapped, deps);
+      case "renderChunk":
+        return await handleRenderChunk(unwrapped, deps);
+      case "assemble":
+        return await handleAssemble(unwrapped, deps);
+      default: {
+        const _exhaustive = unwrapped;
+        throw new Error(
+          `[handler] unknown Action: ${JSON.stringify(
+            _exhaustive.Action
+          )}. Expected one of "plan", "renderChunk", "assemble".`
+        );
+      }
+    }
+  } catch (err) {
+    logEvent({
+      event: "handler_error",
+      action: unwrapped.Action,
+      message: err instanceof Error ? err.message : String(err),
+      name: err instanceof Error ? err.name : void 0
+    });
+    throw err;
+  }
+}
+var MAX_ENVELOPE_DEPTH = 4;
+function unwrapEvent(event) {
+  let cursor = event;
+  for (let i = 0; i < MAX_ENVELOPE_DEPTH; i++) {
+    if (cursor && typeof cursor === "object") {
+      const obj = cursor;
+      if (typeof obj.Action === "string" && isLambdaAction(obj.Action)) {
+        return cursor;
+      }
+      if ("Payload" in obj) {
+        cursor = obj.Payload;
+        continue;
+      }
+      if ("Input" in obj) {
+        cursor = obj.Input;
+        continue;
+      }
+    }
+    break;
+  }
+  throw new Error(
+    `[handler] event has no recognised Action; unwrapped ${MAX_ENVELOPE_DEPTH} levels of Payload/Input without finding one.`
+  );
+}
+function isLambdaAction(value) {
+  return value === "plan" || value === "renderChunk" || value === "assemble";
+}
+function logEvent(payload) {
+  console.log(JSON.stringify(payload));
+}
+function summarizeEvent(event) {
+  switch (event.Action) {
+    case "plan":
+      return {
+        projectS3Uri: event.ProjectS3Uri,
+        planOutputS3Prefix: event.PlanOutputS3Prefix,
+        format: event.Config.format,
+        fps: event.Config.fps
+      };
+    case "renderChunk":
+      return {
+        planS3Uri: event.PlanS3Uri,
+        chunkIndex: event.ChunkIndex,
+        format: event.Format
+      };
+    case "assemble":
+      return {
+        planS3Uri: event.PlanS3Uri,
+        chunkCount: event.ChunkS3Uris.length,
+        hasAudio: event.AudioS3Uri !== null,
+        outputS3Uri: event.OutputS3Uri,
+        format: event.Format
+      };
+  }
+}
+var runtimeEnvPrimed = false;
+function primeRuntimeEnv() {
+  if (runtimeEnvPrimed) return;
+  runtimeEnvPrimed = true;
+  const taskRoot = process.env.LAMBDA_TASK_ROOT ?? "/var/task";
+  const bin = join2(taskRoot, "bin");
+  if (existsSync3(bin)) {
+    process.env.PATH = `${bin}:${process.env.PATH ?? ""}`;
+  }
+}
+async function handlePlan(event, deps) {
+  const started = Date.now();
+  const s3 = deps?.s3 ?? getS3Client();
+  const primitive = deps?.primitives?.plan ?? plan;
+  const work = mkdtempSync(join2(deps?.tmpRoot ?? tmpdir(), "hf-lambda-plan-"));
+  const projectArchive = join2(work, "project.tar.gz");
+  const projectDir = join2(work, "project");
+  const planDir = join2(work, "plan");
+  try {
+    await downloadS3ObjectToFile(s3, event.ProjectS3Uri, projectArchive);
+    await untarDirectory(projectArchive, projectDir);
+    const config = {
+      ...event.Config
+    };
+    const result = await primitive(projectDir, config, planDir);
+    const planTar = join2(work, "plan.tar.gz");
+    await tarDirectory(planDir, planTar);
+    const planTarUri = `${trimTrailingSlash(event.PlanOutputS3Prefix)}/plan.tar.gz`;
+    const audioPath = join2(planDir, "audio.aac");
+    const hasAudio = existsSync3(audioPath) && statSync2(audioPath).size > 0;
+    const audioUri = hasAudio ? `${trimTrailingSlash(event.PlanOutputS3Prefix)}/audio.aac` : 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,
+      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 handleRenderChunk(event, deps) {
+  const started = Date.now();
+  const s3 = deps?.s3 ?? getS3Client();
+  const primitive = deps?.primitives?.renderChunk ?? renderChunk;
+  if (!deps?.skipChromeResolution && !process.env.PRODUCER_HEADLESS_SHELL_PATH) {
+    const chromePath = await resolveChromeExecutablePath();
+    process.env.PRODUCER_HEADLESS_SHELL_PATH = chromePath;
+  }
+  const work = mkdtempSync(join2(deps?.tmpRoot ?? tmpdir(), "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 result = await primitive(planDir, event.ChunkIndex, chunkOutputBase);
+    const chunkUri = await uploadChunkOutput(
+      s3,
+      result,
+      event.ChunkOutputS3Prefix,
+      event.ChunkIndex
+    );
+    return {
+      Action: "renderChunk",
+      ChunkS3Uri: chunkUri,
+      ChunkIndex: event.ChunkIndex,
+      Sha256: result.sha256,
+      FramesEncoded: result.framesEncoded,
+      DurationMs: Date.now() - started
+    };
+  } finally {
+    cleanupDir(work);
+  }
+}
+async function uploadChunkOutput(s3, result, prefix, chunkIndex) {
+  const trimmed = trimTrailingSlash(prefix);
+  if (result.outputKind === "file") {
+    const ext = result.outputPath.slice(result.outputPath.lastIndexOf("."));
+    const uri2 = `${trimmed}/chunks/${pad(chunkIndex)}${ext}`;
+    await uploadFileToS3(s3, result.outputPath, uri2);
+    return uri2;
+  }
+  const tarball = `${result.outputPath}.tar.gz`;
+  await tarDirectory(result.outputPath, tarball);
+  const uri = `${trimmed}/chunks/${pad(chunkIndex)}.tar.gz`;
+  await uploadFileToS3(s3, tarball, uri, "application/gzip");
+  return uri;
+}
+async function handleAssemble(event, deps) {
+  const started = Date.now();
+  const s3 = deps?.s3 ?? getS3Client();
+  const primitive = deps?.primitives?.assemble ?? assemble;
+  const work = mkdtempSync(join2(deps?.tmpRoot ?? tmpdir(), "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 = join2(planDir, "audio.aac");
+      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);
+    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 downloadChunkObjects(s3, uris, workDir, format) {
+  const chunksDir = join2(workDir, "chunks");
+  mkdirSync2(chunksDir, { recursive: true });
+  const local = new Array(uris.length);
+  await Promise.all(
+    uris.map(async (uri, i) => {
+      if (!uri) {
+        throw new Error(`[handler] chunk URI at index ${i} is empty`);
+      }
+      const { key } = parseS3Uri(uri);
+      const localPath = join2(chunksDir, basename(key));
+      await downloadS3ObjectToFile(s3, uri, localPath);
+      if (format === "png-sequence") {
+        const dirPath = join2(chunksDir, `frames-${pad(i)}`);
+        await untarDirectory(localPath, dirPath);
+        local[i] = dirPath;
+      } else {
+        local[i] = localPath;
+      }
+    })
+  );
+  return local;
+}
+function pad(n) {
+  return n.toString().padStart(4, "0");
+}
+function trimTrailingSlash(prefix) {
+  return prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+}
+function cleanupDir(dir) {
+  try {
+    rmSync2(dir, { recursive: true, force: true });
+  } 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 {
+  handler,
+  unwrapEvent
+};
+//# sourceMappingURL=handler.js.map