@hyperframes/gcp-cloud-run 0.6.79

package/dist/server.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Cloud Run request handler for HyperFrames distributed rendering.
+ *
+ * One container image, three roles. Cloud Workflows POSTs a JSON body with
+ * an `Action` field; the handler unwraps any `Payload`/`Input` envelope,
+ * primes the runtime (Chrome path), 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 body → GCS download → call
+ * primitive → GCS upload → return small JSON result.
+ *
+ * `dispatch()` is the testable core (inject `storage` + `primitives`); the
+ * Hono app at the bottom is the HTTP shell the Dockerfile runs. The shape
+ * deliberately tracks `@hyperframes/aws-lambda`'s `handler.ts` so the two
+ * adapters stay easy to diff.
+ */
+import { Storage } from "@google-cloud/storage";
+import { Hono } from "hono";
+import { assemble, plan, renderChunk } from "@hyperframes/producer/distributed";
+import type { AssembleEvent, CloudRunEvent, CloudRunResult, 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
+ * `storage` and `primitives` directly rather than mutating module state.
+ */
+export interface HandlerDeps {
+    storage?: Storage;
+    primitives?: {
+        plan: typeof plan;
+        renderChunk: typeof renderChunk;
+        assemble: typeof assemble;
+    };
+    /** Override the per-request workdir root (defaults to the OS tmpdir). */
+    tmpRoot?: string;
+    /** Skip Chrome resolution (used by dispatch tests that mock renderChunk). */
+    skipChromeResolution?: boolean;
+}
+/**
+ * Dispatch a single render request. Cloud Workflows (or a direct caller)
+ * sometimes wraps the body in `{ Payload: ... }` or `{ Input: ... }`; unwrap
+ * until we hit a discriminated event.
+ */
+export declare function dispatch(event: CloudRunEvent, deps?: HandlerDeps): Promise<CloudRunResult>;
+export declare function unwrapEvent(event: CloudRunEvent): PlanEvent | RenderChunkEvent | AssembleEvent;
+/**
+ * Build the Hono app. A single `POST /` endpoint dispatches on the body's
+ * `Action` field — the workflow points every step (plan, each renderChunk,
+ * assemble) at the same URL and varies only the body. `GET /healthz` backs
+ * the Cloud Run startup/liveness probe.
+ *
+ * `deps` is threaded through so tests can drive the real HTTP surface with
+ * an injected Storage double + mocked primitives.
+ */
+export declare function createApp(deps?: HandlerDeps): Hono;
+/** Start the HTTP server. Cloud Run injects `PORT` (default 8080). */
+export declare function startServer(): void;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAOH,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,EACL,QAAQ,EAIR,IAAI,EAEJ,WAAW,EACZ,MAAM,mCAAmC,CAAC;AAE3C,OAAO,KAAK,EACV,aAAa,EAGb,aAAa,EACb,cAAc,EACd,SAAS,EAET,gBAAgB,EAEjB,MAAM,aAAa,CAAC;AAsBrB;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE;QACX,IAAI,EAAE,OAAO,IAAI,CAAC;QAClB,WAAW,EAAE,OAAO,WAAW,CAAC;QAChC,QAAQ,EAAE,OAAO,QAAQ,CAAC;KAC3B,CAAC;IACF,yEAAyE;IACzE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6EAA6E;IAC7E,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;;GAIG;AAEH,wBAAsB,QAAQ,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,cAAc,CAAC,CAgChG;AAOD,wBAAgB,WAAW,CAAC,KAAK,EAAE,aAAa,GAAG,SAAS,GAAG,gBAAgB,GAAG,aAAa,CAsB9F;AA2bD;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI,CA2BlD;AAED,sEAAsE;AACtE,wBAAgB,WAAW,IAAI,IAAI,CAMlC"}

package/dist/server.js

@@ -0,0 +1,517 @@
+// src/server.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, extname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { serve } from "@hono/node-server";
+import { Storage } from "@google-cloud/storage";
+import { Hono } from "hono";
+import {
+  assemble,
+  plan,
+  renderChunk
+} from "@hyperframes/producer/distributed";
+
+// src/chromium.ts
+import { existsSync } from "node:fs";
+var ChromeBinaryUnavailableError = class extends Error {
+  // Read indirectly via the error envelope / Error.prototype.toString.
+  // fallow-ignore-next-line unused-class-member
+  name = "ChromeBinaryUnavailableError";
+  resolvedPath;
+  constructor(resolvedPath, hint) {
+    super(`[chromium] Chrome binary unavailable: ${hint}`);
+    this.resolvedPath = resolvedPath;
+  }
+};
+var FALLBACK_CHROME_PATHS = [
+  "/opt/chrome/chrome-headless-shell",
+  "/usr/bin/chrome-headless-shell",
+  "/usr/bin/google-chrome",
+  "/usr/bin/google-chrome-stable",
+  "/usr/bin/chromium",
+  "/usr/bin/chromium-browser"
+];
+function resolveChromeExecutablePath() {
+  const fromEngineOverride = process.env.PRODUCER_HEADLESS_SHELL_PATH?.trim();
+  if (fromEngineOverride) {
+    if (!existsSync(fromEngineOverride)) {
+      throw new ChromeBinaryUnavailableError(
+        fromEngineOverride,
+        `PRODUCER_HEADLESS_SHELL_PATH=${JSON.stringify(fromEngineOverride)} does not exist on disk.`
+      );
+    }
+    return fromEngineOverride;
+  }
+  const fromImage = process.env.HYPERFRAMES_CHROME_PATH?.trim();
+  if (fromImage) {
+    if (!existsSync(fromImage)) {
+      throw new ChromeBinaryUnavailableError(
+        fromImage,
+        `HYPERFRAMES_CHROME_PATH=${JSON.stringify(fromImage)} does not exist on disk.`
+      );
+    }
+    return fromImage;
+  }
+  for (const candidate of FALLBACK_CHROME_PATHS) {
+    if (existsSync(candidate)) return candidate;
+  }
+  throw new ChromeBinaryUnavailableError(
+    null,
+    `no Chrome binary found. Set HYPERFRAMES_CHROME_PATH (the Dockerfile does this) or PRODUCER_HEADLESS_SHELL_PATH to the absolute path of a chrome-headless-shell binary. Searched: ${FALLBACK_CHROME_PATHS.join(", ")}.`
+  );
+}
+
+// src/formatExtension.ts
+var FORMAT_EXTENSIONS = {
+  mp4: ".mp4",
+  mov: ".mov",
+  webm: ".webm",
+  "png-sequence": ""
+};
+function formatExtension(format) {
+  return FORMAT_EXTENSIONS[format];
+}
+
+// src/gcsTransport.ts
+import { createWriteStream, existsSync as existsSync2, mkdirSync, rmSync, statSync } from "node:fs";
+import { dirname } from "node:path";
+import { pipeline } from "node:stream/promises";
+import * as tar from "tar";
+function parseGcsUri(uri) {
+  if (!uri.startsWith("gs://")) {
+    throw new Error(`[gcsTransport] expected gs:// URI, got: ${JSON.stringify(uri)}`);
+  }
+  const rest = uri.slice("gs://".length);
+  const slash = rest.indexOf("/");
+  if (slash === -1) {
+    throw new Error(`[gcsTransport] missing key in gs URI: ${JSON.stringify(uri)}`);
+  }
+  const bucket = rest.slice(0, slash);
+  const key = rest.slice(slash + 1);
+  if (!bucket || !key) {
+    throw new Error(`[gcsTransport] empty bucket or key in gs URI: ${JSON.stringify(uri)}`);
+  }
+  return { bucket, key };
+}
+async function downloadGcsObjectToFile(storage, uri, destPath) {
+  const { bucket, key } = parseGcsUri(uri);
+  mkdirSync(dirname(destPath), { recursive: true });
+  const file = storage.bucket(bucket).file(key);
+  await pipeline(file.createReadStream(), createWriteStream(destPath));
+}
+async function uploadFileToGcs(storage, localPath, uri, contentType) {
+  if (!existsSync2(localPath)) {
+    throw new Error(`[gcsTransport] upload source missing: ${localPath}`);
+  }
+  const { bucket, key } = parseGcsUri(uri);
+  await storage.bucket(bucket).upload(localPath, {
+    destination: key,
+    // `resumable: false` (simple upload) is faster for the small-to-medium
+    // objects this adapter moves and avoids the extra round-trip a resumable
+    // session start costs; GCS recommends resumable only past ~8 MB but our
+    // chunks are reliably above that, so let the client pick by default.
+    contentType
+  });
+}
+async function tarDirectory(sourceDir, destTarball) {
+  if (!existsSync2(sourceDir) || !statSync(sourceDir).isDirectory()) {
+    throw new Error(`[gcsTransport] 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(`[gcsTransport] tarball missing: ${tarballPath}`);
+  }
+  if (existsSync2(destDir)) {
+    rmSync(destDir, { recursive: true, force: true });
+  }
+  mkdirSync(destDir, { recursive: true });
+  await tar.extract({ file: tarballPath, cwd: destDir });
+}
+
+// src/server.ts
+var cachedStorage = null;
+function getStorage() {
+  if (cachedStorage) return cachedStorage;
+  cachedStorage = new Storage();
+  return cachedStorage;
+}
+async function dispatch(event, deps) {
+  const unwrapped = unwrapEvent(event);
+  validateEventGcsUris(unwrapped);
+  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" && isCloudRunAction(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] body has no recognised Action; unwrapped ${MAX_ENVELOPE_DEPTH} levels of Payload/Input without finding one.`
+  );
+}
+function isCloudRunAction(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 {
+        projectGcsUri: event.ProjectGcsUri,
+        planOutputGcsPrefix: event.PlanOutputGcsPrefix,
+        format: event.Config.format,
+        fps: event.Config.fps
+      };
+    case "renderChunk":
+      return {
+        planGcsUri: event.PlanGcsUri,
+        chunkIndex: event.ChunkIndex,
+        format: event.Format
+      };
+    case "assemble":
+      return {
+        planGcsUri: event.PlanGcsUri,
+        chunkCount: event.ChunkGcsUris.length,
+        hasAudio: event.AudioGcsUri !== null,
+        outputGcsUri: event.OutputGcsUri,
+        format: event.Format
+      };
+  }
+}
+function primeChrome(deps) {
+  if (deps?.skipChromeResolution) return;
+  if (process.env.PRODUCER_HEADLESS_SHELL_PATH) return;
+  process.env.PRODUCER_HEADLESS_SHELL_PATH = resolveChromeExecutablePath();
+}
+async function handlePlan(event, deps) {
+  const started = Date.now();
+  const storage = deps?.storage ?? getStorage();
+  const primitive = deps?.primitives?.plan ?? plan;
+  primeChrome(deps);
+  const work = mkdtempSync(join(deps?.tmpRoot ?? tmpdir(), "hf-cr-plan-"));
+  const projectArchive = join(work, "project.tar.gz");
+  const projectDir = join(work, "project");
+  const planDir = join(work, "plan");
+  try {
+    await downloadGcsObjectToFile(storage, event.ProjectGcsUri, projectArchive);
+    await untarDirectory(projectArchive, projectDir);
+    const config = {
+      ...event.Config
+    };
+    const result = await primitive(projectDir, config, planDir);
+    const planTar = join(work, "plan.tar.gz");
+    await tarDirectory(planDir, planTar);
+    const planTarUri = `${trimTrailingSlash(event.PlanOutputGcsPrefix)}/plan.tar.gz`;
+    const audioPath = join(planDir, "audio.aac");
+    const hasAudio = existsSync3(audioPath) && statSync2(audioPath).size > 0;
+    await uploadFileToGcs(storage, planTar, planTarUri, "application/gzip");
+    return {
+      Action: "plan",
+      PlanGcsUri: planTarUri,
+      PlanHash: result.planHash,
+      ChunkCount: result.chunkCount,
+      TotalFrames: result.totalFrames,
+      Fps: result.fps,
+      Width: result.width,
+      Height: result.height,
+      Format: result.format,
+      HasAudio: hasAudio,
+      AudioGcsUri: null,
+      FfmpegVersion: result.ffmpegVersion,
+      ProducerVersion: result.producerVersion,
+      DurationMs: Date.now() - started
+    };
+  } finally {
+    cleanupDir(work);
+  }
+}
+async function handleRenderChunk(event, deps) {
+  const started = Date.now();
+  const storage = deps?.storage ?? getStorage();
+  const primitive = deps?.primitives?.renderChunk ?? renderChunk;
+  primeChrome(deps);
+  const work = mkdtempSync(join(deps?.tmpRoot ?? tmpdir(), "hf-cr-chunk-"));
+  const planTar = join(work, "plan.tar.gz");
+  const planDir = join(work, "plan");
+  try {
+    await downloadGcsObjectToFile(storage, event.PlanGcsUri, planTar);
+    await untarDirectory(planTar, planDir);
+    verifyPlanHash(planDir, event.PlanHash);
+    const chunkOutputBase = join(
+      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(
+      storage,
+      result,
+      event.ChunkOutputGcsPrefix,
+      event.ChunkIndex
+    );
+    return {
+      Action: "renderChunk",
+      ChunkGcsUri: chunkUri,
+      ChunkIndex: event.ChunkIndex,
+      Sha256: result.sha256,
+      FramesEncoded: result.framesEncoded,
+      DurationMs: Date.now() - started
+    };
+  } finally {
+    cleanupDir(work);
+  }
+}
+async function uploadChunkOutput(storage, result, prefix, chunkIndex) {
+  const trimmed = trimTrailingSlash(prefix);
+  if (result.outputKind === "file") {
+    const ext = extname(result.outputPath);
+    const uri2 = `${trimmed}/chunks/${pad(chunkIndex)}${ext}`;
+    await uploadFileToGcs(storage, 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 uploadFileToGcs(storage, tarball, uri, "application/gzip");
+  return uri;
+}
+async function handleAssemble(event, deps) {
+  const started = Date.now();
+  const storage = deps?.storage ?? getStorage();
+  const primitive = deps?.primitives?.assemble ?? assemble;
+  const work = mkdtempSync(join(deps?.tmpRoot ?? tmpdir(), "hf-cr-assemble-"));
+  const planTar = join(work, "plan.tar.gz");
+  const planDir = join(work, "plan");
+  try {
+    await downloadGcsObjectToFile(storage, event.PlanGcsUri, planTar);
+    await untarDirectory(planTar, planDir);
+    const chunkPaths = await downloadChunkObjects(storage, event.ChunkGcsUris, work, event.Format);
+    let audioPath = null;
+    const planAudio = join(planDir, "audio.aac");
+    if (existsSync3(planAudio) && statSync2(planAudio).size > 0) {
+      audioPath = planAudio;
+    } else if (event.AudioGcsUri) {
+      audioPath = planAudio;
+      await downloadGcsObjectToFile(storage, event.AudioGcsUri, audioPath);
+    }
+    const finalOutput = event.Format === "png-sequence" ? join(work, "output-frames") : join(work, `output${formatExtension(event.Format)}`);
+    const result = await primitive(planDir, chunkPaths, audioPath, finalOutput, {
+      cfr: event.Cfr === true
+    });
+    if (event.Format === "png-sequence") {
+      const tarball = `${finalOutput}.tar.gz`;
+      await tarDirectory(finalOutput, tarball);
+      await uploadFileToGcs(storage, tarball, event.OutputGcsUri, "application/gzip");
+    } else {
+      await uploadFileToGcs(storage, finalOutput, event.OutputGcsUri);
+    }
+    return {
+      Action: "assemble",
+      OutputGcsUri: event.OutputGcsUri,
+      FramesEncoded: result.framesEncoded,
+      FileSize: result.fileSize,
+      DurationMs: Date.now() - started
+    };
+  } finally {
+    cleanupDir(work);
+  }
+}
+async function downloadChunkObjects(storage, uris, workDir, format) {
+  const chunksDir = join(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 } = parseGcsUri(uri);
+      const localPath = join(chunksDir, basename(key));
+      await downloadGcsObjectToFile(storage, uri, localPath);
+      if (format === "png-sequence") {
+        const dirPath = join(chunksDir, `frames-${pad(i)}`);
+        await untarDirectory(localPath, dirPath);
+        local[i] = dirPath;
+      } else {
+        local[i] = localPath;
+      }
+    })
+  );
+  return local;
+}
+function getEventGcsUris(event) {
+  switch (event.Action) {
+    case "plan":
+      return [event.ProjectGcsUri, event.PlanOutputGcsPrefix];
+    case "renderChunk":
+      return [event.PlanGcsUri, event.ChunkOutputGcsPrefix];
+    case "assemble":
+      return [
+        event.PlanGcsUri,
+        ...event.ChunkGcsUris,
+        event.OutputGcsUri,
+        event.AudioGcsUri
+      ].filter((u) => u != null);
+  }
+}
+var warnedAllowlistDisabled = false;
+function validateEventGcsUris(event) {
+  const allowedBucket = process.env.HYPERFRAMES_RENDER_BUCKET?.trim();
+  if (allowedBucket === "*") return;
+  if (!allowedBucket) {
+    if (!warnedAllowlistDisabled) {
+      warnedAllowlistDisabled = true;
+      logEvent({
+        event: "bucket_allowlist_disabled",
+        level: "WARNING",
+        message: 'HYPERFRAMES_RENDER_BUCKET is unset \u2014 the GCS bucket-allowlist guard is DISABLED. Set it to the render bucket name to enforce, or to "*" to opt out intentionally.'
+      });
+    }
+    return;
+  }
+  for (const uri of getEventGcsUris(event)) {
+    const { bucket } = parseGcsUri(uri);
+    if (bucket !== allowedBucket) {
+      const err = new Error(
+        `[handler] GCS_URI_NOT_ALLOWED: URI ${JSON.stringify(uri)} targets bucket "${bucket}" but only "${allowedBucket}" is permitted`
+      );
+      err.name = "GCS_URI_NOT_ALLOWED";
+      throw err;
+    }
+  }
+}
+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 = join(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;
+  }
+}
+var NON_RETRYABLE_ERROR_NAMES = /* @__PURE__ */ new Set([
+  // Handler-boundary guards.
+  "GCS_URI_NOT_ALLOWED",
+  "PLAN_HASH_MISMATCH",
+  // Producer error class names (`.name`) + their string code aliases — the
+  // class sets `.name` to the class name but wraps a `code`; cover both so a
+  // raw-code throw is caught too. Mirrors the AWS state machine's
+  // non-retryable list.
+  "FormatNotSupportedInDistributedError",
+  "PlanTooLargeError",
+  "RenderChunkValidationError",
+  "FFMPEG_VERSION_MISMATCH",
+  "FORMAT_NOT_SUPPORTED_IN_DISTRIBUTED",
+  "PLAN_TOO_LARGE",
+  "BROWSER_GPU_NOT_SOFTWARE",
+  "FONT_FETCH_FAILED",
+  "ChromeBinaryUnavailableError"
+]);
+function createApp(deps) {
+  const app = new Hono();
+  app.get("/healthz", (c) => c.json({ status: "ok" }));
+  app.post("/", async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "BAD_REQUEST", message: "request body must be JSON" }, 400);
+    }
+    try {
+      const result = await dispatch(body, deps);
+      return c.json(result, 200);
+    } catch (err) {
+      const name = err instanceof Error ? err.name : void 0;
+      const message = err instanceof Error ? err.message : String(err);
+      const status = name && NON_RETRYABLE_ERROR_NAMES.has(name) ? 400 : 500;
+      return c.json({ error: name ?? "RenderError", message }, status);
+    }
+  });
+  return app;
+}
+function startServer() {
+  const port = Number(process.env.PORT ?? 8080);
+  const app = createApp();
+  serve({ fetch: app.fetch, port }, (info) => {
+    logEvent({ event: "server_listening", port: info.port });
+  });
+}
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  startServer();
+}
+export {
+  createApp,
+  dispatch,
+  startServer,
+  unwrapEvent
+};
+//# sourceMappingURL=server.js.map