@hyperframes/gcp-cloud-run 0.6.79

package/Dockerfile

@@ -0,0 +1,118 @@
+# HyperFrames distributed render — Cloud Run image.
+#
+# One container image, three roles (plan / renderChunk / assemble). Cloud
+# Workflows POSTs a JSON body with an `Action` field; `dist/server.js`
+# dispatches to the matching `@hyperframes/producer/distributed` primitive.
+#
+# Build context is the REPOSITORY ROOT (not this package dir) because the
+# package depends on the `@hyperframes/producer` workspace and renders with
+# the same chrome-headless-shell + fonts + ffmpeg the production renderer
+# uses. The example smoke script and `hyperframes cloudrun deploy` both
+# build with the repo root as context:
+#
+#   docker build -f packages/gcp-cloud-run/Dockerfile -t <image> .
+#
+# NOTE: this Dockerfile only builds from a full hyperframes monorepo checkout
+# — it COPYs sibling workspace packages (core/engine/producer). It is NOT
+# buildable from the published npm tarball alone; install the repo (or use
+# `hyperframes cloudrun deploy`, which builds from your checkout via Cloud
+# Build) to produce the image.
+#
+# Unlike the AWS Lambda adapter there is no ZIP-size ceiling and no runtime
+# Chrome decompression step — the binary lives in the image at a fixed path.
+
+FROM node:22-bookworm-slim
+
+# ── System dependencies (identical set to the producer's render image) ───────
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ca-certificates \
+    curl \
+    unzip \
+    ffmpeg \
+    libgbm1 \
+    libnss3 \
+    libatk-bridge2.0-0 \
+    libdrm2 \
+    libxcomposite1 \
+    libxdamage1 \
+    libxrandr2 \
+    libcups2 \
+    libasound2 \
+    libpangocairo-1.0-0 \
+    libxshmfence1 \
+    libgtk-3-0 \
+    fonts-liberation \
+    fonts-noto-color-emoji \
+    fonts-noto-cjk \
+    fonts-noto-core \
+    fonts-noto-extra \
+    fonts-noto-ui-core \
+    fonts-freefont-ttf \
+    fonts-dejavu-core \
+    fontconfig \
+    && rm -rf /var/lib/apt/lists/* \
+    && apt-get clean \
+    && fc-cache -fv
+
+# ── chrome-headless-shell (deterministic BeginFrame capture) ─────────────────
+# Pinned to the SAME build the producer regression baselines were generated
+# against so distributed renders are pixel-comparable. Bump together with the
+# producer's Dockerfile.test pin and a baseline regen.
+RUN npx --yes @puppeteer/browsers install chrome-headless-shell@148.0.7778.167 \
+      --path /opt/puppeteer \
+    && CHS="$(find /opt/puppeteer/chrome-headless-shell -name chrome-headless-shell -type f | head -n1)" \
+    && mkdir -p /opt/chrome \
+    && ln -s "$CHS" /opt/chrome/chrome-headless-shell \
+    && /opt/chrome/chrome-headless-shell --version
+
+# The chromium.ts resolver reads this first; pointing the engine straight at
+# the symlinked binary avoids the runtime cache scan.
+ENV HYPERFRAMES_CHROME_PATH=/opt/chrome/chrome-headless-shell
+ENV PRODUCER_HEADLESS_SHELL_PATH=/opt/chrome/chrome-headless-shell
+ENV PUPPETEER_SKIP_CHROMIUM_DOWNLOAD=true
+ENV CONTAINER=true
+
+WORKDIR /app
+
+# Install bun (the repo's package manager / build driver). Pin the version:
+# the container runs `bun dist/server.js` and relies on bun's ESM `require`
+# interop to load the producer bundle, so a future bun release changing that
+# behaviour shouldn't silently break the next image rebuild. Bump deliberately.
+RUN curl -fsSL https://bun.sh/install | bash -s "bun-v1.3.9"
+ENV PATH="/root/.bun/bin:$PATH"
+
+# Install workspace dependencies. Copy manifests first for layer caching.
+COPY package.json bun.lock ./
+COPY packages/core/package.json packages/core/package.json
+COPY packages/engine/package.json packages/engine/package.json
+COPY packages/player/package.json packages/player/package.json
+COPY packages/producer/package.json packages/producer/package.json
+COPY packages/cli/package.json packages/cli/package.json
+COPY packages/studio/package.json packages/studio/package.json
+COPY packages/shader-transitions/package.json packages/shader-transitions/package.json
+COPY packages/aws-lambda/package.json packages/aws-lambda/package.json
+COPY packages/gcp-cloud-run/package.json packages/gcp-cloud-run/package.json
+RUN bun install --frozen-lockfile
+
+# Copy source for the packages the render path needs.
+COPY packages/core/ packages/core/
+COPY packages/engine/ packages/engine/
+COPY packages/producer/ packages/producer/
+COPY packages/gcp-cloud-run/ packages/gcp-cloud-run/
+
+# Build core runtime artifacts (needed by the renderer) + producer, then the
+# adapter. Generate embedded font data so glyph layout matches production.
+RUN bun run --filter @hyperframes/core build:hyperframes-runtime:modular \
+    && (cd packages/producer && bunx tsx scripts/generate-font-data.ts) \
+    && bun run --cwd packages/producer build \
+    && bun run --cwd packages/gcp-cloud-run build
+
+# Cloud Run injects PORT (default 8080). The server reads it.
+ENV PORT=8080
+EXPOSE 8080
+
+WORKDIR /app/packages/gcp-cloud-run
+# Run under bun, not node. The repo is bun-native and `@hyperframes/producer`'s
+# bundled `distributed.js` relies on a `require` being available at runtime
+# (its esbuild interop shim); bun provides one in ESM, bare `node` does not.
+CMD ["bun", "dist/server.js"]

package/README.md

@@ -0,0 +1,128 @@
+# @hyperframes/gcp-cloud-run
+
+Google Cloud Run + Cloud Workflows adapter for HyperFrames distributed
+rendering. The OSS render primitives (`plan` → `renderChunk` × N →
+`assemble`) are pure functions over local file paths; this package is the
+deployment, orchestration, and storage glue that runs them on Google Cloud —
+the GCP counterpart to [`@hyperframes/aws-lambda`](../aws-lambda).
+
+Two surfaces, one package:
+
+- **Server-side handler** (`./server`) — a Cloud Run HTTP service that
+  dispatches `plan` / `renderChunk` / `assemble` on the request body's
+  `Action` field, bridging GCS ↔ the container's filesystem around each OSS
+  primitive. This is what the bundled `Dockerfile` runs.
+- **Client-side SDK** (`./sdk`) — `renderToCloudRun`, `getRenderProgress`,
+  `deploySite`, `validateDistributedRenderConfig`, and `computeRenderCost`.
+  Call these from a Node process (CI, CLI, app backend) to drive a deployed
+  stack without writing GCS / Workflows boilerplate.
+
+The package is **not** a dependency of `@hyperframes/producer`; install it
+separately.
+
+## Architecture
+
+```
+GCS bucket  ←→  Cloud Run service (plan / renderChunk / assemble)
+                     ▲
+                     │ OIDC-authenticated http.post, one per step
+                     │
+                Cloud Workflows  (Plan → parallel RenderChunk → Assemble)
+```
+
+- **Plan** downloads the project tarball, runs `plan()`, uploads the planDir
+  tarball (+ audio) to GCS, and returns the chunk count.
+- **RenderChunk** runs in a parallel `for` loop in the workflow, fanned out
+  up to the plan's chunk count. Each invocation renders one chunk and uploads
+  it.
+- **Assemble** downloads every chunk + audio, stitches the final
+  deliverable, and uploads it.
+
+Every step is a `POST` to the same Cloud Run URL with a different `Action`.
+The workflow accumulates each step's small result body and returns
+`{ Plan, Chunks, Assemble }` so `getRenderProgress` can read frame totals and
+per-step durations on success.
+
+## Chrome runtime
+
+Unlike the Lambda adapter — which fights a 250 MB ZIP ceiling and
+decompresses `@sparticuz/chromium` into `/tmp` at runtime — Cloud Run runs a
+container image. The `Dockerfile` installs the same pinned
+`chrome-headless-shell` build and font set the production renderer uses, at a
+fixed path, and exports `HYPERFRAMES_CHROME_PATH`. CDP-level `BeginFrame`
+works because the command lives in the protocol, not the binary. There is no
+runtime decompression step and no packaging ceiling.
+
+## Deploying
+
+The `terraform/` module provisions everything: the GCS render bucket, the
+Cloud Run service, the Cloud Workflows definition, two least-privilege
+service accounts (the service reads/writes the bucket; the workflow invokes
+the service), and a runaway-request alert.
+
+```bash
+# 1. Build + push the image (Cloud Build or local docker).
+gcloud builds submit . \
+  --tag REGION-docker.pkg.dev/PROJECT/REPO/hyperframes-render:TAG
+
+# 2. Apply the module.
+terraform -chdir=node_modules/@hyperframes/gcp-cloud-run/terraform init
+terraform -chdir=node_modules/@hyperframes/gcp-cloud-run/terraform apply \
+  -var project_id=PROJECT \
+  -var region=us-central1 \
+  -var image=REGION-docker.pkg.dev/PROJECT/REPO/hyperframes-render:TAG
+```
+
+Terraform outputs `render_bucket_name`, `service_url`, `workflow_name`, and
+`region` — pass them straight into the SDK.
+
+## Using the SDK
+
+```ts
+import { renderToCloudRun, getRenderProgress } from "@hyperframes/gcp-cloud-run/sdk";
+
+const handle = await renderToCloudRun({
+  projectDir: "./my-composition",
+  config: { fps: 30, width: 1920, height: 1080, format: "mp4" },
+  bucketName: "hyperframes-render-my-project", // from terraform output
+  projectId: "my-project",
+  location: "us-central1",
+  workflowId: "hyperframes-render",
+  serviceUrl: "https://hyperframes-render-abc.us-central1.run.app",
+});
+
+// Poll until done.
+let progress = await getRenderProgress({ executionName: handle.executionName });
+while (progress.status === "running") {
+  await new Promise((r) => setTimeout(r, 5000));
+  progress = await getRenderProgress({ executionName: handle.executionName });
+}
+console.log(progress.status, progress.outputFile, progress.costs.displayCost);
+```
+
+`deploySite` is called implicitly when you pass `projectDir`; call it
+yourself to pre-upload once and reuse the `siteHandle` across many renders
+(e.g. personalised template batches).
+
+## Running tests
+
+```bash
+bun test          # unit tests over an in-memory GCS double — no network
+bun run typecheck
+```
+
+The live end-to-end smoke (build image → terraform apply → render a fixture
+through the workflow → PSNR-compare → destroy) lives at
+`examples/gcp-cloud-run/scripts/smoke.sh` and needs a GCP project with
+billing enabled.
+
+## What's still ahead
+
+- **Mid-flight per-chunk progress.** `getRenderProgress` reports coarse
+  `running` progress and exact numbers on success. Reading the Cloud
+  Workflows step-entries API would give per-chunk progress while the render
+  is in flight; tracked as a follow-up.
+- **Cloud Run Jobs / Firebase Functions variants.** This first version
+  targets Cloud Run services + Workflows (the closest analog to Lambda +
+  Step Functions). The same handler runs unchanged under Cloud Run Jobs;
+  only the orchestration trigger differs.

package/dist/chromium.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Cloud Run Chrome resolver.
+ *
+ * `renderChunk()` (the only primitive that needs a browser) launches Chrome
+ * via the engine's `BrowserManager`. Because Cloud Run runs a container
+ * image rather than a size-capped ZIP, the Chrome story is far simpler than
+ * the Lambda adapter's: the `Dockerfile` installs `chrome-headless-shell`
+ * (the same BeginFrame-capable build the K8s deploy uses) into the image at
+ * a known path and exports `HYPERFRAMES_CHROME_PATH`. There is no runtime
+ * decompression-into-/tmp step and no 250 MB packaging ceiling to fight.
+ *
+ * Resolution order:
+ *   1. `PRODUCER_HEADLESS_SHELL_PATH` — the engine's own override. If a
+ *      caller (or the Docker image) already set it, honour it untouched.
+ *   2. `HYPERFRAMES_CHROME_PATH` — set by the Dockerfile to the installed
+ *      `chrome-headless-shell` binary.
+ *   3. A small list of conventional install paths, as a last resort for
+ *      images built outside our Dockerfile.
+ *
+ * Throws {@link ChromeBinaryUnavailableError} when nothing resolves, so a
+ * misconfigured image fails loudly at the first chunk rather than emitting
+ * a confusing puppeteer-core "executablePath must be specified" assertion.
+ */
+/**
+ * Thrown when the Chrome binary resolver can't produce a usable path. The
+ * class name is the workflow's non-retryable error discriminator.
+ */
+export declare class ChromeBinaryUnavailableError extends Error {
+    readonly name = "ChromeBinaryUnavailableError";
+    readonly resolvedPath: string | null;
+    constructor(resolvedPath: string | null, hint: string);
+}
+/**
+ * Resolve the absolute path to a Chrome binary suitable for BeginFrame.
+ * Pure (no env mutation) so callers decide whether to export the result
+ * into `PRODUCER_HEADLESS_SHELL_PATH`.
+ */
+export declare function resolveChromeExecutablePath(): string;
+//# sourceMappingURL=chromium.d.ts.map

package/dist/chromium.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chromium.d.ts","sourceRoot":"","sources":["../src/chromium.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH;;;GAGG;AACH,qBAAa,4BAA6B,SAAQ,KAAK;IAGrD,SAAkB,IAAI,kCAAkC;IACxD,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;gBACzB,YAAY,EAAE,MAAM,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM;CAItD;AAgBD;;;;GAIG;AAEH,wBAAgB,2BAA2B,IAAI,MAAM,CAiCpD"}

package/dist/events.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Request + result types for the HyperFrames distributed render handler
+ * running on Cloud Run.
+ *
+ * The Cloud Workflows definition in `packages/gcp-cloud-run/terraform/workflow.yaml`
+ * dispatches on the `Action` field of the JSON request body. 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 GCS — the handler downloads inputs into a
+ * per-request workdir under the container's writable `/tmp`, invokes the
+ * primitive, uploads outputs back to GCS, and returns a small JSON payload
+ * that fits inside a Cloud Workflows step variable (Workflows caps a single
+ * step's memory; chunk results stay well under 1 KB so the orchestration
+ * can hold one per Map iteration).
+ *
+ * These shapes are intentionally identical to `@hyperframes/aws-lambda`'s
+ * `events.ts` apart from the URI scheme (`gs://` vs `s3://`): the wire
+ * contract is the adapter's, the primitives underneath are shared.
+ */
+import type { DistributedFormat, SerializableDistributedRenderConfig } from "@hyperframes/producer/distributed";
+export type { SerializableDistributedRenderConfig } from "@hyperframes/producer/distributed";
+/** Discriminator for the three roles the one Cloud Run image fulfills. */
+export type CloudRunAction = "plan" | "renderChunk" | "assemble";
+/**
+ * Top-level shape of any request body the handler may receive.
+ *
+ * Cloud Workflows passes the step's `body` through verbatim, but a caller
+ * driving the service directly (or a Workflows definition that wraps the
+ * payload) may nest it under `Payload` / `Input`; the handler unwraps both
+ * before dispatching, matching the Lambda adapter's envelope tolerance.
+ */
+export type CloudRunEvent = PlanEvent | RenderChunkEvent | AssembleEvent | {
+    Payload: CloudRunEvent;
+} | {
+    Input: CloudRunEvent;
+};
+/** Activity A: produce a planDir, upload to GCS. */
+export interface PlanEvent {
+    Action: "plan";
+    /** GCS URI pointing at a `tar -czf`-archived project directory (`gs://bucket/key.tar.gz`). */
+    ProjectGcsUri: string;
+    /** GCS URI prefix where the planDir tar should be uploaded (`gs://bucket/{prefix}/`). */
+    PlanOutputGcsPrefix: string;
+    /** `DistributedRenderConfig` minus runtime-only fields (logger, abortSignal). */
+    Config: SerializableDistributedRenderConfig;
+}
+/** Activity B: fetch planDir, render one chunk, upload result. */
+export interface RenderChunkEvent {
+    Action: "renderChunk";
+    /** GCS URI of the plan tar produced by a PlanEvent invocation. */
+    PlanGcsUri: 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
+     * workflow 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;
+    /** GCS URI prefix where the chunk output should be uploaded (`gs://bucket/{prefix}/`). */
+    ChunkOutputGcsPrefix: string;
+    /** Output container format from the plan's encoder.json; drives file vs frame-dir handling. */
+    Format: DistributedFormat;
+}
+/** Activity C: fetch planDir + all chunks + audio, assemble, upload final. */
+export interface AssembleEvent {
+    Action: "assemble";
+    /** GCS URI of the plan tar produced by a PlanEvent invocation. */
+    PlanGcsUri: string;
+    /** GCS URIs of every chunk, ordered by chunk index. Length must equal `chunkCount`. */
+    ChunkGcsUris: string[];
+    /** GCS URI of the planDir's `audio.aac` if the composition has audio; `null` otherwise. */
+    AudioGcsUri: string | null;
+    /** Final output GCS URI (`gs://bucket/key.mp4`). */
+    OutputGcsUri: string;
+    /** Output container format; drives file vs frame-dir handling. */
+    Format: DistributedFormat;
+    /**
+     * Optional exact-CFR re-encode at assemble time. When `true`, the final
+     * assembled video is re-encoded with `-fps_mode cfr -r <fps>` so the
+     * stream's `avg_frame_rate` matches the container's `r_frame_rate`
+     * exactly (and the file's duration is exact, not PTS-derived). Trade-off
+     * is ~2-5x the assemble wall-clock. mp4 only — webm / mov stream-copy
+     * paths already produce exact avg_frame_rate. Default `false` /
+     * unset preserves current `-c copy` behavior.
+     */
+    Cfr?: boolean;
+}
+/** Result of a `plan` invocation. Carries enough to size the Map(N) state. */
+export interface PlanResultBody {
+    Action: "plan";
+    PlanGcsUri: string;
+    PlanHash: string;
+    ChunkCount: number;
+    TotalFrames: number;
+    Fps: 24 | 30 | 60;
+    Width: number;
+    Height: number;
+    Format: DistributedFormat;
+    HasAudio: boolean;
+    AudioGcsUri: string | null;
+    FfmpegVersion: string;
+    ProducerVersion: string;
+    DurationMs: number;
+}
+/** Result of a `renderChunk` invocation. Sized ≤200 bytes. */
+export interface RenderChunkResultBody {
+    Action: "renderChunk";
+    ChunkGcsUri: string;
+    ChunkIndex: number;
+    Sha256: string;
+    FramesEncoded: number;
+    DurationMs: number;
+}
+/** Result of an `assemble` invocation. */
+export interface AssembleResultBody {
+    Action: "assemble";
+    OutputGcsUri: string;
+    FramesEncoded: number;
+    FileSize: number;
+    DurationMs: number;
+}
+export type CloudRunResult = PlanResultBody | RenderChunkResultBody | AssembleResultBody;
+//# 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":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EACV,iBAAiB,EACjB,mCAAmC,EACpC,MAAM,mCAAmC,CAAC;AAE3C,YAAY,EAAE,mCAAmC,EAAE,MAAM,mCAAmC,CAAC;AAE7F,0EAA0E;AAC1E,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,aAAa,GAAG,UAAU,CAAC;AAEjE;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GACrB,SAAS,GACT,gBAAgB,GAChB,aAAa,GACb;IAAE,OAAO,EAAE,aAAa,CAAA;CAAE,GAC1B;IAAE,KAAK,EAAE,aAAa,CAAA;CAAE,CAAC;AAE7B,oDAAoD;AACpD,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,8FAA8F;IAC9F,aAAa,EAAE,MAAM,CAAC;IACtB,yFAAyF;IACzF,mBAAmB,EAAE,MAAM,CAAC;IAC5B,iFAAiF;IACjF,MAAM,EAAE,mCAAmC,CAAC;CAC7C;AAED,kEAAkE;AAClE,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,aAAa,CAAC;IACtB,kEAAkE;IAClE,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;;OAMG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB,yDAAyD;IACzD,UAAU,EAAE,MAAM,CAAC;IACnB,0FAA0F;IAC1F,oBAAoB,EAAE,MAAM,CAAC;IAC7B,+FAA+F;IAC/F,MAAM,EAAE,iBAAiB,CAAC;CAC3B;AAED,8EAA8E;AAC9E,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,UAAU,CAAC;IACnB,kEAAkE;IAClE,UAAU,EAAE,MAAM,CAAC;IACnB,uFAAuF;IACvF,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,2FAA2F;IAC3F,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,oDAAoD;IACpD,YAAY,EAAE,MAAM,CAAC;IACrB,kEAAkE;IAClE,MAAM,EAAE,iBAAiB,CAAC;IAC1B;;;;;;;;OAQG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAID,8EAA8E;AAC9E,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,iBAAiB,CAAC;IAC1B,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,8DAA8D;AAC9D,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,aAAa,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,0CAA0C;AAC1C,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,UAAU,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,cAAc,GAAG,cAAc,GAAG,qBAAqB,GAAG,kBAAkB,CAAC"}

package/dist/formatExtension.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Map a distributed `format` to the file extension the assembled output
+ * should carry on disk + in GCS. Shared by `src/server.ts` (chunk +
+ * assemble output paths) and `src/sdk/renderToCloudRun.ts` (final
+ * output key construction) so the two sides agree on what an mp4
+ * looks like vs a png-sequence.
+ */
+import type { DistributedFormat } from "@hyperframes/producer/distributed";
+export type { DistributedFormat } from "@hyperframes/producer/distributed";
+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,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAE3E,YAAY,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAc3E,wBAAgB,eAAe,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAEjE"}

package/dist/gcsTransport.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Thin GCS transport for the Cloud Run handler.
+ *
+ * The OSS distributed primitives are pure functions over local file paths;
+ * the handler bridges GCS ↔ the container's writable `/tmp` filesystem on
+ * each request. Functions here are intentionally narrow: parse a URI,
+ * download an object to a local path, upload a path, tar-pack a planDir,
+ * tar-extract a planDir back out.
+ *
+ * Tar (not zip) for planDir transit:
+ *   - planDirs contain symlinks (the extract stage materializes them but
+ *     the compiled/ subtree may include linked assets); tar preserves them,
+ *     zip does not.
+ *   - We use the `tar` npm package (pure JS over `node:zlib`) so the
+ *     archive format doesn't depend on a system `tar`/`unzip` being present
+ *     in the container image.
+ *
+ * Apart from the `gs://` scheme and the `@google-cloud/storage` client this
+ * is the same shape as `@hyperframes/aws-lambda`'s `s3Transport.ts`.
+ */
+import type { Storage } from "@google-cloud/storage";
+/** Parsed `gs://bucket/key` URI. */
+export interface GcsLocation {
+    bucket: string;
+    key: string;
+}
+/** Parse `gs://bucket/key/path` → `{ bucket, key }`. Throws on malformed input. */
+export declare function parseGcsUri(uri: string): GcsLocation;
+/** Build `gs://bucket/key` from a location. */
+export declare function formatGcsUri(loc: GcsLocation): string;
+/** Stream a GCS object to a local file path. */
+export declare function downloadGcsObjectToFile(storage: Storage, uri: string, destPath: string): Promise<void>;
+/**
+ * Upload a local file's contents to a GCS URI using a resumable upload.
+ * GCS objects have no practical size ceiling for the artifacts this adapter
+ * handles (plan tarballs ≤ 2 GB, chunks ≤ a few hundred MB), so a single
+ * upload call works for every case.
+ */
+export declare function uploadFileToGcs(storage: Storage, localPath: string, uri: string, contentType?: string): Promise<void>;
+/**
+ * Pack a directory into a `.tar.gz` at `destTarball`. Uses the `tar` npm
+ * package (pure JS over `node:zlib`) rather than spawning a system tar
+ * binary so the archive format is independent of the container's userland.
+ */
+export declare function tarDirectory(sourceDir: string, destTarball: string): Promise<void>;
+/**
+ * Extract a `.tar.gz` produced by {@link tarDirectory} into `destDir`.
+ * The directory is created (or cleared) before extraction so a retried
+ * request doesn't observe stale files from a prior run on the same warm
+ * container instance.
+ */
+export declare function untarDirectory(tarballPath: string, destDir: string): Promise<void>;
+//# sourceMappingURL=gcsTransport.d.ts.map

package/dist/gcsTransport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gcsTransport.d.ts","sourceRoot":"","sources":["../src/gcsTransport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAKH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAGrD,oCAAoC;AACpC,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;CACb;AAED,mFAAmF;AAEnF,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAepD;AAED,+CAA+C;AAC/C,wBAAgB,YAAY,CAAC,GAAG,EAAE,WAAW,GAAG,MAAM,CAErD;AAED,gDAAgD;AAChD,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC,CAQf;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC,CAaf;AAED;;;;GAIG;AACH,wBAAsB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAMxF;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAYxF"}

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `@hyperframes/gcp-cloud-run` — Google Cloud Run + Workflows adapter for
+ * the HyperFrames distributed render pipeline.
+ *
+ * Two surfaces, one package:
+ *
+ *  - **Server-side handler.** `dispatch`, `createApp`, the request/result
+ *    types, Chrome resolution, and GCS transport. These power the Cloud Run
+ *    service built from the package `Dockerfile`.
+ *  - **Client-side SDK.** `renderToCloudRun`, `getRenderProgress`,
+ *    `deploySite`, `validateDistributedRenderConfig`, and `computeRenderCost`.
+ *    Adopters call these from their Node process (CI scripts, CLIs) to drive
+ *    a deployed stack without writing GCS / Workflows boilerplate.
+ *
+ * The Terraform module that provisions the bucket + service + workflow lives
+ * under `terraform/` in the published package; see the README. The package
+ * is NOT a dependency of `@hyperframes/producer`; consumers install it
+ * separately.
+ */
+export { createApp, dispatch, type HandlerDeps, startServer, unwrapEvent } from "./server.js";
+export { type AssembleEvent, type AssembleResultBody, type CloudRunAction, type CloudRunEvent, type CloudRunResult, type PlanEvent, type PlanResultBody, type RenderChunkEvent, type RenderChunkResultBody, type SerializableDistributedRenderConfig, } from "./events.js";
+export { ChromeBinaryUnavailableError, resolveChromeExecutablePath } from "./chromium.js";
+export { downloadGcsObjectToFile, formatGcsUri, type GcsLocation, parseGcsUri, tarDirectory, untarDirectory, uploadFileToGcs, } from "./gcsTransport.js";
+export { deploySite, type DeploySiteOptions, type SiteHandle } from "./sdk/deploySite.js";
+export { renderToCloudRun, type RenderHandle, type RenderToCloudRunOptions, } from "./sdk/renderToCloudRun.js";
+export { getRenderProgress, type GetRenderProgressOptions, type RenderError, type RenderProgress, type RenderStatus, } from "./sdk/getRenderProgress.js";
+export { type BilledCloudRunInvocation, computeRenderCost, type RenderCost, } from "./sdk/costAccounting.js";
+export { InvalidConfigError, validateDistributedRenderConfig } from "./sdk/validateConfig.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC9F,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,mCAAmC,GACzC,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,4BAA4B,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAC1F,OAAO,EACL,uBAAuB,EACvB,YAAY,EACZ,KAAK,WAAW,EAChB,WAAW,EACX,YAAY,EACZ,cAAc,EACd,eAAe,GAChB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC1F,OAAO,EACL,gBAAgB,EAChB,KAAK,YAAY,EACjB,KAAK,uBAAuB,GAC7B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,iBAAiB,EACjB,KAAK,wBAAwB,EAC7B,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,YAAY,GAClB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,KAAK,wBAAwB,EAC7B,iBAAiB,EACjB,KAAK,UAAU,GAChB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,kBAAkB,EAAE,+BAA+B,EAAE,MAAM,yBAAyB,CAAC"}