@hyperframes/aws-lambda 0.8.177 → 0.8.179

package/dist/sdk/index.js

@@ -1,585 +1,51 @@
-// src/sdk/deploySite.ts
-import { mkdtempSync, rmSync as rmSync2, statSync as statSync2 } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { HeadObjectCommand as HeadObjectCommand2, S3Client } from "@aws-sdk/client-s3";
-import { hashProjectDir } from "@hyperframes/producer/distributed";
-
-// src/s3Transport.ts
-import {
-  createReadStream,
-  createWriteStream,
-  existsSync,
-  mkdirSync,
-  rmSync,
-  statSync
-} from "node:fs";
-import { dirname } from "node:path";
 import {
-  GetObjectCommand,
-  HeadObjectCommand,
-  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 };
-}
-function formatS3Uri(loc) {
-  return `s3://${loc.bucket}/${loc.key}`;
-}
-async function uploadFileToS3(client, localPath, uri, contentType) {
-  if (!existsSync(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 (!existsSync(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 }, ["."]);
-}
-
-// src/sdk/deploySite.ts
-async function deploySite(opts) {
-  if (!statSync2(opts.projectDir).isDirectory()) {
-    throw new Error(`[deploySite] projectDir is not a directory: ${opts.projectDir}`);
-  }
-  const siteId = opts.siteId ?? hashProjectDir(opts.projectDir);
-  const key = `sites/${siteId}/project.tar.gz`;
-  const projectS3Uri = formatS3Uri({ bucket: opts.bucketName, key });
-  const s3 = opts.s3 ?? new S3Client({ region: opts.region });
-  const existing = await headObject(s3, opts.bucketName, key);
-  if (existing) {
-    return {
-      siteId,
-      bucketName: opts.bucketName,
-      projectS3Uri,
-      bytes: existing.bytes,
-      uploadedAt: existing.lastModified,
-      uploaded: false
-    };
-  }
-  const workdir = mkdtempSync(join(tmpdir(), "hf-deploy-site-"));
-  try {
-    const tarball = join(workdir, "project.tar.gz");
-    await tarDirectory(opts.projectDir, tarball);
-    const size = statSync2(tarball).size;
-    await uploadFileToS3(s3, tarball, projectS3Uri, "application/gzip");
-    return {
-      siteId,
-      bucketName: opts.bucketName,
-      projectS3Uri,
-      bytes: size,
-      uploadedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      uploaded: true
-    };
-  } finally {
-    rmSync2(workdir, { recursive: true, force: true });
-  }
-}
-async function headObject(s3, bucket, key) {
-  try {
-    const res = await s3.send(new HeadObjectCommand2({ Bucket: bucket, Key: key }));
-    return {
-      bytes: typeof res.ContentLength === "number" ? res.ContentLength : 0,
-      lastModified: res.LastModified instanceof Date ? res.LastModified.toISOString() : (/* @__PURE__ */ new Date()).toISOString()
-    };
-  } catch (err) {
-    const status = err.$metadata?.httpStatusCode;
-    if (status === 404) return null;
-    const name = err.name;
-    if (name === "NotFound" || name === "NoSuchKey") return null;
-    throw err;
-  }
-}
-
-// src/sdk/renderToLambda.ts
-import { randomUUID } from "node:crypto";
-import { SFNClient, StartExecutionCommand } from "@aws-sdk/client-sfn";
-
-// src/formatExtension.ts
-var FORMAT_EXTENSIONS = {
-  mp4: ".mp4",
-  mov: ".mov",
-  webm: ".webm",
-  "png-sequence": ""
-};
-function formatExtension(format) {
-  return FORMAT_EXTENSIONS[format];
-}
-
-// src/sdk/validateConfig.ts
-import { InvalidConfigError } from "@hyperframes/producer/distributed";
-import {
-  InvalidConfigError as InvalidConfigError2,
+  InvalidConfigError,
+  MAX_STEP_FUNCTIONS_INPUT_BYTES,
+  assertStackReadsSites,
+  computeRenderCost,
+  deploySite,
+  getRenderProgress,
+  renderToLambda,
+  siteHandleFromId,
   validateDistributedRenderConfig,
+  validateStepFunctionsInputSize,
   validateVariablesPayload
-} from "@hyperframes/producer/distributed";
-var MAX_STEP_FUNCTIONS_INPUT_BYTES = 256 * 1024;
-var LARGE_VARIABLES_DOCS_URL = "https://hyperframes.heygen.com/deploy/templates-on-lambda#working-with-large-variables";
-function validateStepFunctionsInputSize(input) {
-  let serialized;
-  try {
-    serialized = JSON.stringify(input);
-  } catch (err) {
-    throw new InvalidConfigError(
-      "config",
-      `Step Functions execution input is not JSON-serializable: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  if (serialized === void 0) {
-    throw new InvalidConfigError(
-      "config",
-      "Step Functions execution input is not JSON-serializable (JSON.stringify returned undefined). Check that all fields, including config.variables, are plain JSON values."
-    );
-  }
-  const byteLength = Buffer.byteLength(serialized, "utf8");
-  if (byteLength > MAX_STEP_FUNCTIONS_INPUT_BYTES) {
-    throw new InvalidConfigError(
-      "config",
-      `Step Functions execution input is ${byteLength} bytes, which exceeds the ${MAX_STEP_FUNCTIONS_INPUT_BYTES}-byte (256 KiB) limit for Standard workflows. Variables are for typed data (strings, numbers, structured records); media assets (images, audio, video) should be passed as URL references the composition resolves at render time, not inlined as base64. See ${LARGE_VARIABLES_DOCS_URL} for the URL-your-assets convention.`
-    );
-  }
-}
-
-// src/sdk/renderToLambda.ts
-async function renderToLambda(opts) {
-  validateDistributedRenderConfig(opts.config);
-  if (!opts.bucketName) {
-    throw new Error("[renderToLambda] bucketName is required");
-  }
-  if (!opts.stateMachineArn) {
-    throw new Error("[renderToLambda] stateMachineArn is required");
-  }
-  if (!opts.siteHandle && !opts.projectDir) {
-    throw new Error("[renderToLambda] either siteHandle or projectDir must be supplied");
-  }
-  const executionName = opts.executionName ?? `hf-render-${randomUUID()}`;
-  const ext = formatExtension(opts.config.format);
-  const outputKey = opts.outputKey ?? `renders/${executionName}/output${ext}`;
-  const planOutputS3Prefix = formatS3Uri({
-    bucket: opts.bucketName,
-    key: `renders/${executionName}/`
-  });
-  const outputS3Uri = formatS3Uri({ bucket: opts.bucketName, key: outputKey });
-  const site = opts.siteHandle ?? await deploySite({
-    projectDir: opts.projectDir,
-    bucketName: opts.bucketName,
-    region: opts.region,
-    s3: opts.s3
-  });
-  const input = {
-    ProjectS3Uri: site.projectS3Uri,
-    PlanOutputS3Prefix: planOutputS3Prefix,
-    OutputS3Uri: outputS3Uri,
-    Config: opts.config,
-    PlanProtocol: opts.planProtocol ?? "v2"
-  };
-  validateStepFunctionsInputSize(input);
-  const sfn = opts.sfn ?? new SFNClient({ region: opts.region });
-  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const response = await sfn.send(
-    new StartExecutionCommand({
-      stateMachineArn: opts.stateMachineArn,
-      name: executionName,
-      input: JSON.stringify(input)
-    })
-  );
-  if (!response.executionArn) {
-    throw new Error("[renderToLambda] StartExecution returned no executionArn");
-  }
-  return {
-    renderId: executionName,
-    executionArn: response.executionArn,
-    bucketName: opts.bucketName,
-    stateMachineArn: opts.stateMachineArn,
-    outputS3Uri,
-    projectS3Uri: site.projectS3Uri,
-    startedAt
-  };
-}
-
-// src/sdk/getRenderProgress.ts
-import {
-  DescribeExecutionCommand,
-  DescribeMapRunCommand,
-  GetExecutionHistoryCommand,
-  ListExecutionsCommand,
-  SFNClient as SFNClient2
-} from "@aws-sdk/client-sfn";
-
-// src/sdk/costAccounting.ts
-var LAMBDA_USD_PER_GB_SECOND = 166667e-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;
-    if (inv.estimated) anyEstimated = true;
-  }
-  const stepFunctionsUsd = stateTransitions * SFN_USD_PER_TRANSITION;
-  const accruedSoFarUsd = roundUsd(lambdaUsd + stepFunctionsUsd);
-  return {
-    accruedSoFarUsd,
-    displayCost: formatUsd(accruedSoFarUsd),
-    breakdown: {
-      lambdaUsd: roundUsd(lambdaUsd),
-      stepFunctionsUsd: roundUsd(stepFunctionsUsd),
-      s3Estimate: "not-included",
-      estimated: anyEstimated
-    }
-  };
-}
-function roundUsd(usd) {
-  return Math.round(usd * 1e4) / 1e4;
-}
-function formatUsd(usd) {
-  return `$${usd.toFixed(4)}`;
-}
-
-// src/sdk/getRenderProgress.ts
-var DEFAULT_MEMORY_MB = 10240;
-function createProgressSfnClient(config = {}) {
-  return new SFNClient2({ maxAttempts: 8, ...config });
-}
-async function getRenderProgress(opts) {
-  if (!opts.executionArn) {
-    throw new Error("[getRenderProgress] executionArn is required");
-  }
-  const sfn = opts.sfn ?? createProgressSfnClient({ region: opts.region });
-  const memoryMb = opts.defaultMemorySizeMb ?? DEFAULT_MEMORY_MB;
-  const describe = await sfn.send(
-    new DescribeExecutionCommand({ executionArn: opts.executionArn })
-  );
-  const status = describe.status ?? "RUNNING";
-  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 mapRun = findChunkMapRun(history);
-  const warnings = [];
-  if (mapRun?.exited) addChunkResults(summary, mapRun.output, memoryMb);
-  else if (mapRun) {
-    await addRunningMapRun(sfn, mapRun.arn, summary, memoryMb).catch((err) => {
-      if (err?.name !== "AccessDeniedException") throw err;
-      warnings.push(MAP_RUN_ACCESS_DENIED);
-    });
-  }
-  const costs = computeRenderCost(summary.lambdaInvocations, summary.stateTransitions);
-  const overallProgress = computeOverallProgress({
-    status,
-    totalFrames: summary.totalFrames,
-    framesRendered: summary.framesRendered,
-    assembleComplete: summary.assembleComplete
-  });
-  return {
-    status,
-    overallProgress,
-    framesRendered: summary.framesRendered,
-    totalFrames: summary.totalFrames,
-    lambdasInvoked: summary.lambdasInvoked,
-    costs,
-    outputFile: summary.outputFile,
-    errors: summary.errors,
-    fatalErrorEncountered: isTerminalFailure(status),
-    warnings,
-    startedAt,
-    endedAt
-  };
-}
-async function loadFullHistory(sfn, executionArn) {
-  const events = [];
-  let nextToken;
-  for (let page = 0; page < 50; page++) {
-    const res = await sfn.send(
-      new GetExecutionHistoryCommand({
-        executionArn,
-        maxResults: 1e3,
-        nextToken,
-        reverseOrder: false
-      })
-    );
-    if (res.events) events.push(...res.events);
-    nextToken = res.nextToken;
-    if (!nextToken) break;
-  }
-  return events;
-}
-var FAILED_CHUNK_HISTORIES_READ = 5;
-var MAP_RUN_ACCESS_DENIED = "Chunk progress is hidden until the chunks finish: this caller lacks states:DescribeMapRun. Re-apply the policy from `hyperframes lambda policies user`.";
-function findChunkMapRun(events) {
-  let run = null;
-  for (const ev of events) {
-    const arn = ev.mapRunStartedEventDetails?.mapRunArn;
-    if (arn) run = { arn, exited: false, output: void 0 };
-    const exit = ev.stateExitedEventDetails;
-    if (run && ev.type === "MapStateExited" && isRenderChunksMapState(exit?.name)) {
-      run = { ...run, exited: true, output: exit?.output };
-    }
-  }
-  return run;
-}
-function addChunkResults(summary, mapOutput, memoryMb) {
-  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
-    });
-    applyPayloadFrameCounts(chunk, "RenderChunk", (delta) => {
-      summary.framesRendered += delta;
-    });
-  }
-}
-async function addRunningMapRun(sfn, mapRunArn, summary, memoryMb) {
-  const res = await sfn.send(new DescribeMapRunCommand({ mapRunArn }));
-  const { total = 0, pending = 0, succeeded = 0, failed = 0 } = res.itemCounts ?? {};
-  summary.lambdasInvoked += total - pending;
-  summary.stateTransitions += total - pending;
-  if (summary.totalFrames !== null && total > 0) {
-    summary.framesRendered += Math.floor(summary.totalFrames * succeeded / total);
-  }
-  if (failed > 0) summary.errors.push(...await failedChunkErrors(sfn, mapRunArn, memoryMb));
-}
-async function failedChunkErrors(sfn, mapRunArn, memoryMb) {
-  const failed = await sfn.send(
-    new ListExecutionsCommand({
-      mapRunArn,
-      statusFilter: "FAILED",
-      maxResults: FAILED_CHUNK_HISTORIES_READ
-    })
-  );
-  const errors = [];
-  for (const child of failed.executions ?? []) {
-    if (!child.executionArn) continue;
-    const childHistory = await loadFullHistory(sfn, child.executionArn);
-    errors.push(...summarizeHistory(childHistory, memoryMb).errors);
-  }
-  return errors;
-}
-function summarizeHistory(events, memoryMb) {
-  let framesRendered = 0;
-  let totalFrames = null;
-  let lambdasInvoked = 0;
-  let assembleComplete = false;
-  let outputFile = null;
-  let stateTransitions = 0;
-  const errors = [];
-  const lambdaInvocations = [];
-  let currentLambdaState = null;
-  for (const ev of events) {
-    switch (ev.type) {
-      case "TaskStateEntered":
-      case "MapStateEntered":
-      case "PassStateEntered":
-      case "ChoiceStateEntered":
-      case "SucceedStateEntered":
-      case "FailStateEntered":
-      case "WaitStateEntered":
-      case "ParallelStateEntered":
-        stateTransitions++;
-        currentLambdaState = ev.stateEnteredEventDetails?.name ?? currentLambdaState;
-        break;
-      // Optimized `lambda:invoke` task emits Task* events; raw
-      // `lambda:invokeFunction.sync` emits LambdaFunction*. Handle both.
-      case "TaskScheduled":
-        if (ev.taskScheduledEventDetails?.resourceType === "lambda") {
-          lambdasInvoked++;
-        }
-        break;
-      case "LambdaFunctionScheduled":
-        lambdasInvoked++;
-        break;
-      case "TaskSucceeded": {
-        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
-        });
-        applyPayloadFrameCounts(payload, currentLambdaState, (delta) => {
-          framesRendered += delta;
-        });
-        if (payload && typeof payload === "object") {
-          const obj = payload;
-          if (typeof obj.TotalFrames === "number") totalFrames = obj.TotalFrames;
-        }
-        break;
-      }
-      case "LambdaFunctionSucceeded": {
-        const payload = parseJson(ev.lambdaFunctionSucceededEventDetails?.output);
-        const billedDurationMs = inferBilledMs(payload);
-        lambdaInvocations.push({
-          billedDurationMs,
-          memorySizeMb: memoryMb,
-          estimated: billedDurationMs === 0
-        });
-        applyPayloadFrameCounts(payload, currentLambdaState, (delta) => {
-          framesRendered += delta;
-        });
-        if (payload && typeof payload === "object") {
-          const obj = payload;
-          if (typeof obj.TotalFrames === "number") totalFrames = obj.TotalFrames;
-        }
-        break;
-      }
-      case "TaskStateExited":
-      case "MapStateExited":
-        if (isAssembleState(ev.stateExitedEventDetails?.name)) {
-          assembleComplete = true;
-          const exitPayload = parseJson(ev.stateExitedEventDetails?.output);
-          if (exitPayload && typeof exitPayload === "object") {
-            const obj = exitPayload;
-            const out = obj.Output;
-            const outputS3Uri = typeof out?.OutputS3Uri === "string" ? out.OutputS3Uri : null;
-            const bytes = typeof out?.FileSize === "number" ? out.FileSize : null;
-            outputFile = outputS3Uri ? { s3Uri: outputS3Uri, bytes } : outputFile;
-          }
-        }
-        break;
-      case "TaskFailed":
-        if (ev.taskFailedEventDetails?.resourceType !== "lambda") break;
-        errors.push({
-          state: currentLambdaState ?? "<unknown>",
-          error: ev.taskFailedEventDetails?.error ?? "UNKNOWN",
-          cause: ev.taskFailedEventDetails?.cause ?? ""
-        });
-        break;
-      case "LambdaFunctionFailed":
-        errors.push({
-          state: currentLambdaState ?? "<unknown>",
-          error: ev.lambdaFunctionFailedEventDetails?.error ?? "UNKNOWN",
-          cause: ev.lambdaFunctionFailedEventDetails?.cause ?? ""
-        });
-        break;
-      case "ExecutionFailed":
-        errors.push({
-          state: "<execution>",
-          error: ev.executionFailedEventDetails?.error ?? "UNKNOWN",
-          cause: ev.executionFailedEventDetails?.cause ?? ""
-        });
-        break;
-      case "ExecutionAborted":
-        errors.push({
-          state: "<execution>",
-          error: ev.executionAbortedEventDetails?.error ?? "ABORTED",
-          cause: ev.executionAbortedEventDetails?.cause ?? ""
-        });
-        break;
-      case "ExecutionTimedOut":
-        errors.push({
-          state: "<execution>",
-          error: "TIMEOUT",
-          cause: ev.executionTimedOutEventDetails?.cause ?? ""
-        });
-        break;
-      default:
-        break;
-    }
-  }
-  return {
-    lambdaInvocations,
-    stateTransitions,
-    framesRendered,
-    totalFrames,
-    lambdasInvoked,
-    assembleComplete,
-    outputFile,
-    errors
-  };
-}
-function parseJson(s) {
-  if (!s) return null;
-  try {
-    return JSON.parse(s);
-  } catch {
-    return null;
-  }
-}
-function unwrapLambdaPayload(payload) {
-  if (payload && typeof payload === "object" && "Payload" in payload) {
-    const inner = payload.Payload;
-    if (inner && typeof inner === "object") return inner;
-  }
-  return payload;
-}
-function applyPayloadFrameCounts(payload, currentLambdaState, bump) {
-  if (!isRenderChunkState(currentLambdaState)) return;
-  if (!payload || typeof payload !== "object") return;
-  const obj = payload;
-  if (typeof obj.FramesEncoded === "number") bump(obj.FramesEncoded);
-}
-function isRenderChunkState(name) {
-  return name === "RenderChunk" || name === "RenderChunkV2";
-}
-function isRenderChunksMapState(name) {
-  return name === "RenderChunks" || name === "RenderChunksV2";
-}
-function isAssembleState(name) {
-  return name === "Assemble" || name === "AssembleV2";
-}
-function inferBilledMs(payload) {
-  if (!payload || typeof payload !== "object") return 0;
-  const obj = payload;
-  if (typeof obj.DurationMs === "number") return obj.DurationMs;
-  return 0;
-}
-function computeOverallProgress({
-  status,
-  totalFrames,
-  framesRendered,
-  assembleComplete
-}) {
-  if (status === "SUCCEEDED") return 1;
-  if (assembleComplete) return 1;
-  if (totalFrames === null) return 0;
-  const chunkProgress = Math.min(1, framesRendered / totalFrames);
-  return 0.1 + 0.8 * chunkProgress;
-}
-function isTerminalFailure(status) {
-  return status === "FAILED" || status === "TIMED_OUT" || status === "ABORTED";
+} from "../_chunks/chunk-PK7PO3MH.js";
+import "../_chunks/chunk-ZY5YIH5W.js";
+import "../_chunks/chunk-YS3KY3C5.js";
+
+// src/sdk/prebuiltHandler.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var PREBUILT_DIR = "prebuilt";
+var HANDLER_MANIFEST_FILE = "handler-zip.json";
+function adapterPackageRoot() {
+  const from = fileURLToPath(import.meta.url);
+  for (let dir = dirname(from); dir !== dirname(dir); dir = dirname(dir)) {
+    const pkg = join(dir, "package.json");
+    if (existsSync(pkg) && JSON.parse(readFileSync(pkg, "utf-8")).name === "@hyperframes/aws-lambda")
+      return dir;
+  }
+  throw new Error(`[aws-lambda] no @hyperframes/aws-lambda package.json above ${from}`);
+}
+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") };
 }
 export {
-  InvalidConfigError2 as InvalidConfigError,
+  InvalidConfigError,
   MAX_STEP_FUNCTIONS_INPUT_BYTES,
+  assertStackReadsSites,
   computeRenderCost,
   deploySite,
   getRenderProgress,
+  prebuiltHandler,
   renderToLambda,
+  siteHandleFromId,
   validateDistributedRenderConfig,
   validateStepFunctionsInputSize,
   validateVariablesPayload

package/dist/sdk/prebuiltHandler.d.ts

@@ -0,0 +1,17 @@
+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 {
+    version: string;
+    url: string;
+    sha256: string;
+    bytes: number;
+}
+export interface PrebuiltHandler extends HandlerZipManifest {
+    /** SAM template whose `CodeUri` is `handler.zip` in the same directory. */
+    templatePath: string;
+}
+/** This package's root, found by walking up from the running module (source or bundle). */
+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;

package/dist/sdk/renderToLambda.d.ts

@@ -17,12 +17,12 @@
  *      execution name so the caller can predict the final object URL.
  */
 import { SFNClient } from "@aws-sdk/client-sfn";
-import type { S3Client } from "@aws-sdk/client-s3";
+import { S3Client } from "@aws-sdk/client-s3";
 import type { LambdaPlanProtocol, SerializableDistributedRenderConfig } from "../events.js";
 import { type SiteHandle } from "./deploySite.js";
 /** Options for {@link renderToLambda}. */
 export interface RenderToLambdaOptions {
-    /** Local project directory. Required when `siteHandle` is not supplied. */
+    /** Local project directory. Required without `siteHandle`; with one, re-uploads expired files. */
     projectDir?: string;
     /** Re-use an existing `deploySite` upload (skips tar+S3 PUT). */
     siteHandle?: SiteHandle;
@@ -68,3 +68,9 @@ export interface RenderHandle {
     startedAt: string;
 }
 export declare function renderToLambda(opts: RenderToLambdaOptions): Promise<RenderHandle>;
+/** An older stack's plan step would try to untar a site manifest and fail after retries. */
+export declare function assertStackReadsSites(opts: {
+    stateMachineArn: string;
+    region?: string;
+    sfn?: SFNClient;
+}): Promise<void>;

package/dist/siteManifest.d.ts

@@ -0,0 +1,18 @@
+import type { S3Client } from "@aws-sdk/client-s3";
+import type { RemoteProjectFile } from "@hyperframes/producer/distributed";
+/** Stacks that read site manifests list this as a terminal plan error; the SDK checks for it. */
+export declare const SITE_MANIFEST_INVALID = "SITE_MANIFEST_INVALID";
+export interface SiteFile {
+    /** `/`-separated, relative to the project root. */
+    readonly path: string;
+    readonly sha256: string;
+    readonly sizeBytes: number;
+}
+export declare function siteManifestUri(bucket: string, siteId: string): string;
+/** Sites uploaded before site manifests are one tarball; the plan step still reads them. */
+export declare function siteTarballUri(bucket: string, siteId: string): string;
+export declare function isSiteManifestUri(uri: string): boolean;
+export declare function serializeSiteManifest(files: readonly SiteFile[]): string;
+export declare function parseSiteManifest(text: string): SiteFile[];
+/** Rebuild the project under `projectDir`, SHA-256 verified; videos can stay remote, as URLs. */
+export declare function downloadSiteFiles(s3: S3Client, manifestUri: string, projectDir: string, leaveVideosRemote: boolean): Promise<Record<string, RemoteProjectFile>>;