@hyperframes/gcp-cloud-run 0.8.230 → 0.9.0

package/terraform/workflow.yaml

@@ -1,20 +1,9 @@
-# HyperFrames distributed render orchestration on Cloud Workflows.
+# HyperFrames Plan v2 distributed render orchestration on Cloud Workflows.
 #
-#   Plan → BuildChunkList → AssertChunkCount → RenderChunks (parallel) → Assemble
+#   Plan → BuildChunkList → RenderChunks (parallel) → Assemble
 #
-# Mirrors the Step Functions state machine in
-# `examples/aws-lambda/template.yaml`. Every step POSTs to the same Cloud Run
-# service URL (passed in as `args.ServiceUrl`) and varies only the body's
-# `Action`. The service returns the step's small result body on 2xx; on a
-# non-retryable failure it returns HTTP 400, on a retryable failure HTTP 5xx —
-# the `retryable` predicate below keys off exactly that split.
-#
-# The final returned object accumulates every step's result body so
-# `getRenderProgress` can read frame totals + per-step durations on success:
-#   { Plan: {...}, Chunks: [{...}, ...], Assemble: {...} }
-#
-# Deploy with `gcloud workflows deploy` (the Terraform module / the
-# `hyperframes cloudrun deploy` command do this for you).
+# Every step POSTs to the same Cloud Run service URL and varies only the
+# body's Action. Plan v2 is the only supported transport.
 
 main:
   params: [args]
@@ -26,51 +15,20 @@ main:
           - planOutputGcsPrefix: ${args.PlanOutputGcsPrefix}
           - outputGcsUri: ${args.OutputGcsUri}
           - config: ${args.Config}
-          # Plan v2 is the default. Explicit v1 remains available during the
-          # deprecated monolithic-plan compatibility window.
           - planProtocol: ${default(map.get(args, "PlanProtocol"), "v2")}
 
-    # ── Plan (Activity A) ────────────────────────────────────────────────────
-    - selectPlanProtocol:
+    - checkPlanProtocol:
         switch:
-          - condition: ${planProtocol == "v1"}
-            next: planV1
           - condition: ${planProtocol == "v2"}
-            next: planV2
+            next: plan
         next: unsupportedPlanProtocol
+
     - unsupportedPlanProtocol:
         raise:
           code: PLAN_PROTOCOL_UNSUPPORTED
-          message: ${"PlanProtocol must be v1 or v2; got " + string(planProtocol)}
-    - planV1:
-        try:
-          call: http.post
-          args:
-            url: ${serviceUrl}
-            timeout: 1800
-            auth:
-              type: OIDC
-              audience: ${serviceUrl}
-            body:
-              Action: plan
-              PlanProtocol: v1
-              ProjectGcsUri: ${projectGcsUri}
-              PlanOutputGcsPrefix: ${planOutputGcsPrefix}
-              Config: ${config}
-          result: planRespV1
-        retry:
-          predicate: ${retryable}
-          max_retries: 6
-          backoff:
-            initial_delay: 2
-            max_delay: 60
-            multiplier: 2
-        next: capturePlanV1
-    - capturePlanV1:
-        assign:
-          - planResult: ${planRespV1.body}
-        next: validatePlanResult
-    - planV2:
+          message: ${"PlanProtocol must be v2 or absent; got " + string(planProtocol)}
+
+    - plan:
         try:
           call: http.post
           args:
@@ -85,7 +43,7 @@ main:
               ProjectGcsUri: ${projectGcsUri}
               PlanOutputGcsPrefix: ${planOutputGcsPrefix}
               Config: ${config}
-          result: planRespV2
+          result: planResp
         retry:
           predicate: ${retryable}
           max_retries: 6
@@ -93,46 +51,29 @@ main:
             initial_delay: 2
             max_delay: 60
             multiplier: 2
-        next: capturePlanV2
-    - capturePlanV2:
-        assign:
-          - planResult: ${planRespV2.body}
-        next: validatePlanResult
-    - validatePlanResult:
-        # Fail closed before fan-out. A v2 render may never fall back to a
-        # v1 PlanGcsUri, and a v1 render may never consume v2 locators.
-        switch:
-          - condition: ${planProtocol == "v1" and (not("PlanProtocol" in planResult) or planResult.PlanProtocol == "v1") and ("PlanGcsUri" in planResult) and not("PlanV2ManifestGcsUri" in planResult) and not("PlanV2ArtifactGcsPrefix" in planResult)}
-            next: captureChunkCount
-          - condition: ${planProtocol == "v2" and ("PlanProtocol" in planResult) and planResult.PlanProtocol == "v2" and ("PlanV2ManifestGcsUri" in planResult) and ("PlanV2ArtifactGcsPrefix" in planResult) and not("PlanGcsUri" in planResult)}
-            next: captureChunkCount
-        next: planProtocolLocatorMismatch
-    - planProtocolLocatorMismatch:
-        raise:
-          code: PLAN_PROTOCOL_LOCATOR_MISMATCH
-          message: "Plan response did not match the selected protocol's disjoint locator contract."
-    - captureChunkCount:
+
+    - capturePlan:
         assign:
-          - chunkCount: ${planResult.ChunkCount}
+          - planResult: ${planResp.body}
+          - chunkCount: ${planResp.body.ChunkCount}
 
-    # ── BuildChunkList + AssertChunkCount ──────────────────────────────────────
-    - assertChunkCount:
+    - validatePlanResult:
         switch:
-          - condition: ${chunkCount > 0}
+          - condition: ${planResult.PlanProtocol == "v2" and ("PlanV2ManifestGcsUri" in planResult) and ("PlanV2ArtifactGcsPrefix" in planResult) and not("PlanGcsUri" in planResult) and chunkCount > 0}
             next: buildChunkList
-        next: planProducedZeroChunks
-    - planProducedZeroChunks:
+        next: invalidPlanResult
+
+    - invalidPlanResult:
         raise:
-          code: PLAN_PRODUCED_ZERO_CHUNKS
-          message: "Plan returned ChunkCount=0 — the composition produced no frames. Non-retryable producer-side invariant violation."
+          code: PLAN_RESULT_INVALID
+          message: "Plan response did not satisfy the Plan v2 locator contract or produced no chunks."
+
     - buildChunkList:
-        # Pre-size the ordered chunk-URI + per-chunk result lists so the
-        # parallel branches below assign by index (distinct indices, no
-        # read-modify-write race on a shared accumulator).
         assign:
           - chunkIndexes: []
           - chunkUris: []
           - chunkResults: []
+
     - fillLists:
         for:
           value: i
@@ -144,53 +85,15 @@ main:
                   - chunkUris: ${list.concat(chunkUris, "")}
                   - chunkResults: ${list.concat(chunkResults, "")}
 
-    # ── RenderChunks (Activity B, fanned out) ──────────────────────────────────
     - renderChunks:
         parallel:
           shared: [chunkUris, chunkResults]
-          # Run up to chunkCount chunks at once, clamped to 20 — Cloud
-          # Workflows hard-caps concurrent branches/iterations per execution
-          # at 20 (https://cloud.google.com/workflows/quotas). Above that,
-          # iterations queue regardless of concurrency_limit, so a config with
-          # maxParallelChunks > 20 still renders correctly; the extra chunks
-          # just wait. All chunkCount iterations always run.
           concurrency_limit: ${math.min(chunkCount, 20)}
           for:
             value: idx
             in: ${chunkIndexes}
             steps:
-              - selectChunkProtocol:
-                  switch:
-                    - condition: ${planProtocol == "v2"}
-                      next: renderOneChunkV2
-                  next: renderOneChunkV1
-              - renderOneChunkV1:
-                  try:
-                    call: http.post
-                    args:
-                      url: ${serviceUrl}
-                      timeout: 1800
-                      auth:
-                        type: OIDC
-                        audience: ${serviceUrl}
-                      body:
-                        Action: renderChunk
-                        PlanProtocol: v1
-                        ChunkIndex: ${idx}
-                        PlanGcsUri: ${planResult.PlanGcsUri}
-                        PlanHash: ${planResult.PlanHash}
-                        ChunkOutputGcsPrefix: ${planOutputGcsPrefix}
-                        Format: ${planResult.Format}
-                    result: chunkResp
-                  retry:
-                    predicate: ${retryable}
-                    max_retries: 4
-                    backoff:
-                      initial_delay: 2
-                      max_delay: 60
-                      multiplier: 2
-                  next: storeChunk
-              - renderOneChunkV2:
+              - renderOneChunk:
                   try:
                     call: http.post
                     args:
@@ -216,49 +119,12 @@ main:
                       initial_delay: 2
                       max_delay: 60
                       multiplier: 2
-                  next: storeChunk
               - storeChunk:
                   assign:
                     - chunkUris[idx]: ${chunkResp.body.ChunkGcsUri}
                     - chunkResults[idx]: ${chunkResp.body}
 
-    # ── Assemble (Activity C) ──────────────────────────────────────────────────
-    - selectAssembleProtocol:
-        switch:
-          - condition: ${planProtocol == "v2"}
-            next: assembleV2
-        next: assembleV1
-    - assembleV1:
-        try:
-          call: http.post
-          args:
-            url: ${serviceUrl}
-            timeout: 1800
-            auth:
-              type: OIDC
-              audience: ${serviceUrl}
-            body:
-              Action: assemble
-              PlanProtocol: v1
-              PlanGcsUri: ${planResult.PlanGcsUri}
-              ChunkGcsUris: ${chunkUris}
-              AudioGcsUri: ${planResult.AudioGcsUri}
-              OutputGcsUri: ${outputGcsUri}
-              Format: ${planResult.Format}
-              # Forward the caller's exact-CFR request (Config.cfr) to assemble.
-              # `"cfr" in config` guards the optional key; when unset this is
-              # false, which the handler reads as the default -c copy path.
-              Cfr: ${("cfr" in config) and config.cfr}
-          result: assembleResp
-        retry:
-          predicate: ${retryable}
-          max_retries: 4
-          backoff:
-            initial_delay: 2
-            max_delay: 60
-            multiplier: 2
-        next: done
-    - assembleV2:
+    - assemble:
         try:
           call: http.post
           args:
@@ -274,8 +140,6 @@ main:
               PlanV2ArtifactGcsPrefix: ${planResult.PlanV2ArtifactGcsPrefix}
               PlanHash: ${planResult.PlanHash}
               ChunkGcsUris: ${chunkUris}
-              # Audio is an assembler-scoped v2 artifact and is materialized
-              # from the manifest, never carried through a v1 AudioGcsUri.
               AudioGcsUri: null
               OutputGcsUri: ${outputGcsUri}
               Format: ${planResult.Format}
@@ -288,7 +152,6 @@ main:
             initial_delay: 2
             max_delay: 60
             multiplier: 2
-        next: done
 
     - done:
         return:
@@ -296,11 +159,7 @@ main:
           Chunks: ${chunkResults}
           Assemble: ${assembleResp.body}
 
-# Retry predicate: retry transient/server failures (403 from Cloud Run IAM
-# propagation, 429, and 5xx), never the handler's non-retryable 400s (bad
-# input, plan-hash mismatch, unsupported format, …). The handler does not emit
-# 403, so that status is always from Cloud Run's authentication edge.
-# Connection / timeout errors carry no `.code`; retry those too.
+# Retry transient/server failures, never handler-classified HTTP 400s.
 retryable:
   params: [e]
   steps: