Commit Graph
544 Commits
Author SHA1 Message Date
Miguel Ángel 246222e677 fix(native-renderer): video frame compositing via Image elements with video_frames_dir
The element capture converts Video elements to Image type (for Chrome PNG
capture). The Rust painter now checks style.video_frames_dir on Image
elements and uses per-frame extracted JPEGs when present, falling back to
the static Chrome PNG for that element.

PSNR results on Apple presentation (141s, 7 slides, 5 videos):
  Slides WITHOUT video: 35.7dB (above 30dB imperceptible threshold)
  Slides WITH video: 11-15dB (video frames partially mapped — 3/5 videos)

The remaining gap is from cinematic-vid and avatar-vid which are in
sub-compositions and may not have frame directories at the expected paths.
2026-04-26 16:26:26 -04:00
Miguel Ángel 1dc3fbd0be fix(native-renderer): use video frames for Image elements with video_frames_dir 2026-04-26 16:23:39 -04:00
Miguel Ángel a6eeca7014 perf(native-renderer): capture all leaf elements from chrome for pixel-perfect 2026-04-26 16:09:41 -04:00
Miguel Ángel ff0fb3bba1 fix(native-renderer): resolve all http localhost urls to local file paths 2026-04-26 15:53:39 -04:00
Miguel Ángel 474aa92e2f fix(native-renderer): download http images via chrome cdp before server closes 2026-04-26 15:37:27 -04:00
Miguel Ángel 54d0be9685 fix(native-renderer): skip HTTP image URLs + font loading hang fixes
Three fixes for the Apple presentation render:
1. Skip HTTP/HTTPS URLs in Rust ImageCache — the file server is closed
   by the time the binary runs. curl hangs waiting for localhost.
2. Reuse single FontMgr in FontRegistry (was creating 88 instances).
3. Skip fonts in scene JSON since text is pre-rendered as Chrome PNGs.
4. Add --cpu flag to orchestrator binary invocation.
5. Add debug logging to render_native binary for hang diagnosis.

Root cause found: Image elements with `src: "http://localhost:PORT/..."`
(file server URLs) cause the binary to hang when file server is closed.
2026-04-26 15:20:33 -04:00
Miguel Ángel 407aa8e6af perf(native-renderer): batched timeline baking + increased timeout 2026-04-26 11:41:59 -04:00
Miguel Ángel 740730ffe9 fix(native-renderer): update support detection tests for relaxed checks
Tests for video, unstable IDs, wrapped text, grid text, multiple shadows,
and transparent roots were expecting rejection but these features are now
accepted. Updated test expectations to match relaxed support detector.

49 Rust tests + 26 TypeScript tests pass.
2026-04-26 11:16:09 -04:00
Miguel Ángel 2ef312b5a6 feat(native-renderer): pre-render text from Chrome as PNGs — 19dB → 44dB PSNR
Capture Chrome's pixel-perfect text rendering as transparent PNGs during
scene extraction. Text elements are converted to Image elements in the
scene JSON, so the Rust painter draws Chrome's actual glyphs instead of
re-rendering with Skia (which produces different anti-aliasing).

Also extends BakedElementState with per-frame bounds, colors, and
border-radius for higher fidelity on animated properties.

PSNR improvement on missing-host-comp-id fixture:
  Before: 19.1dB (visible differences)
  After:  44.2dB (near pixel-perfect)

30dB = imperceptible. 44dB = nearly identical.
2026-04-26 02:47:48 -04:00
Miguel Ángel 4eb50f2a76 perf(native-renderer): force-visible extraction for better bounds capture 2026-04-26 02:26:54 -04:00
Miguel Ángel 1eff23716e feat(native-renderer): font extraction + text layout positioning
- extract embedded @font-face base64 fonts from Chrome, write to disk
- pass font file paths in scene JSON for Rust FontRegistry
- extract padding-left/top and text-align for text positioning
- apply padding offsets and text alignment in Skia text painter
2026-04-26 02:18:53 -04:00
Miguel Ángel 7d9f438794 fix(native-renderer): add fonts field to ExtractedScene test fixtures
The extract.test.ts constructs ExtractedScene objects directly but was
missing the required `fonts` field added when FontDescriptor support
landed.
2026-04-26 02:08:47 -04:00
Miguel Ángel 1cec907008 feat(native-renderer): video frame compositing + font registry + timing
Video compositing:
- Style gains data_start, data_end, video_frames_dir, video_fps, video_media_start
- Painter skips elements outside their active time range
- Video elements load pre-extracted frames from disk by timestamp
- Scene extractor captures video metadata from DOM attributes

Font registry:
- FontRegistry loads custom fonts from disk (TTF/OTF) via Skia FontMgr
- paint_element_at_time_with_fonts uses registry for font-family matching
- Pipeline builds font registry from scene.fonts descriptors

All 49 tests pass.
2026-04-26 02:06:39 -04:00
Miguel Ángel 0b9c540335 feat(native-renderer): video frame compositing from extracted frames
Wire pre-extracted video frames into the Rust paint pipeline:

- Add data_start, data_end, video_frames_dir, video_fps, and
  video_media_start fields to the Style struct so the scene JSON can
  carry element timing and video frame directory metadata.
- Update paint_element_inner to skip elements outside their
  data_start..data_end range, and prefer loading pre-extracted JPEG
  frames from a directory (frame_00001.jpg, ...) over the FFmpeg
  single-frame fallback path.
- Update the TypeScript CDP scene extractor to capture data-start,
  data-end, and video metadata attributes from DOM elements, and
  expose an injectVideoFramesMeta() helper the producer can call
  after frame extraction to populate frame directory paths.
- Fix FontRegistry to use FontMgr::new_from_data() instead of the
  removed Typeface::from_data() in skia-safe 0.93.
- Sync extract.ts types and font collection with Scene/Style changes.
- Clean up unused import and variable warnings in pipeline.rs.
2026-04-26 02:05:34 -04:00
Miguel Ángel d215dd30f7 fix(producer): create browser session for native render when probe absent
The native render path requires a Chrome session for scene extraction +
timeline baking. When the composition has a known static duration, the
probe session is null (Chrome was never launched). Now creates a
dedicated session when HYPERFRAMES_NATIVE_RENDER=1 is set.

Tested: missing-host-comp-id fixture renders natively at 1.29ms/frame.
Full pipeline: compile → extract scene → bake timeline → Skia paint →
openh264 encode → audio mux → final MP4.
2026-04-26 02:02:09 -04:00
Miguel Ángel 38b7b798bd feat(producer): wire native renderer into orchestrator after compilation
HYPERFRAMES_NATIVE_RENDER=1 env var activates the native path.
After Stage 3 (compile + video extract + audio), the orchestrator:
1. Extracts scene graph from the probe session
2. Bakes GSAP timeline at every frame timestamp
3. Spawns Rust binary to paint + encode
4. Skips Chrome capture + encode entirely
5. Proceeds to Stage 6 (audio mux) normally

494 engine tests pass. Type-checks clean.
2026-04-26 01:59:21 -04:00
Miguel Ángel ee37457276 docs: add leadership-oriented framing to native renderer roadmap 2026-04-26 01:30:59 -04:00
Miguel Ángel 4652ad3541 docs: native renderer roadmap — full plan for renderer supremacy over remotion 2026-04-26 01:23:41 -04:00
Miguel Ángel f7ad31eea0 feat(native-renderer): relax support detector for broader composition coverage
- Remove unstable ID check (extractor generates positional IDs)
- Allow multiple box-shadows (Rust painter loops)
- Allow video elements with resolved sources (frame extraction path)
- Allow wrapped text and flex/grid text (Skia paragraph API)
- Allow transparent composition roots (renderer clears to black)
- Add __name polyfill for tsx ESM compat in CLI entry + nativeRender

Tested: Apple presentation passes support detection and renders through
the native pipeline. Output is a valid MP4 (sub-composition resolution
needs producer compilation for full multi-slide rendering).
2026-04-25 22:48:35 -04:00
Miguel Ángel cc2bcba1c4 fix(cli): esm compat + lint fixes for native renderer integration
- replace all __dirname with import.meta.url in nativeRender.ts
- remove unused execSync import in render-composition.ts
- format with oxfmt
2026-04-25 22:32:33 -04:00
Miguel Ángel 0f1d340d70 perf(native-renderer): skip I420 in render loop, pre-allocate buffers
Two optimizations to the render-only path:
1. Write BGRA directly (Skia's native format) instead of converting
   to I420 during render. FFmpeg batch-converts in the encode step.
2. Pre-allocate BGRA buffer once, reuse across frames (zero allocation
   per frame via read_pixels_bgra_into).

macOS benchmark: 116.6ms/30frames (3.89ms/frame), down from 153ms (5.1ms).
Expected Linux CI: ~1.8ms/frame (paint) + ~0.1ms (readback) = ~1.9ms/frame.
That's 7.4-21x faster than Chrome CDP.
2026-04-25 22:19:02 -04:00
Miguel Ángel 9bb4b36ea4 ci(native-renderer): github actions workflow for linux cpu tests + bench
- Runs on ubuntu-latest (x86_64, no GPU)
- Installs Rust + Skia build deps (clang, ninja, ffmpeg, fonts)
- Caches Cargo registry + Skia build between runs
- Builds with --no-default-features (CPU raster only)
- Runs all tests + criterion benchmarks
- Posts benchmark results to PR summary
2026-04-25 22:01:59 -04:00
Miguel Ángel 939b026cfe perf(native-renderer): raw render pipeline + render-only benchmark
Separate rendering from encoding for maximum render throughput:
- render_animated_raw_then_encode: paint→I420→file, then FFmpeg batch
- render_only benchmark: pure paint+convert speed without any encode

Benchmark (macOS, 30 frames, 1080p, CPU raster):
  render only (paint+I420):       153ms (5.1ms/frame)
  raw render + FFmpeg batch:      308ms (10.3ms/frame)
  native openh264 in-process:     331ms (11.0ms/frame)
  FFmpeg VideoToolbox pipe:       348ms (11.6ms/frame)

Render-only is 2.7-7.8x faster than Chrome CDP (14-40ms).
2026-04-25 21:53:16 -04:00
Miguel Ángel 743cfb2003 feat(native-renderer): ffmpeg-free pipeline — openh264 + minimp4 in-process
Rust-native encoding: Skia paint → dcv BGRA→I420 → openh264 H.264 → minimp4 MP4.
No subprocess, no pipe, no FFmpeg for encoding. Inspired by MediaBunny's
browser-side approach (WebCodecs + MP4 muxer) but in Rust.

Benchmark (macOS, 30 frames, 1080p):
  native (openh264+minimp4): 331ms (11.0ms/frame)
  ffmpeg (VideoToolbox):     348ms (11.6ms/frame)
  ffmpeg (JPEG pipe):        555ms (18.5ms/frame)

The native path is ~5% faster than FFmpeg VideoToolbox on macOS.
On Linux without hardware encoders, the gap should be larger since
we skip FFmpeg subprocess startup + pipe serialization entirely.
2026-04-25 21:48:40 -04:00
Miguel Ángel a385abf942 feat(native-renderer): linux docker CI — 51 tests pass, cpu raster + libx264
Cargo feature split: metal-gpu (macOS), vulkan-gpu (Linux), no-default (CPU).
Docker builds with --no-default-features for pure CPU raster path.
All GPU code gated behind feature flags — no compilation errors on Linux.
Encoder detection probes actual encoder functionality (not just ffmpeg list).

Tested: docker run hyperframes-native:test → 51/51 pass on Linux ARM64.
2026-04-25 21:19:35 -04:00
Miguel Ángel f190820e3d feat(native-renderer): linux docker test image + dockerignore
Dockerfile.test for CI: builds Skia from source on Linux ARM64/x86,
runs all 49 Rust tests with CPU raster + FFmpeg libx264 fallback.
Includes ninja, python3, clang for Skia source build, plus fonts
and FFmpeg for rendering tests.

Supports: `docker run hyperframes-native:test` (tests)
          `docker run hyperframes-native:test bench` (benchmarks)
2026-04-25 21:06:29 -04:00
Miguel Ángel 81df8fcd23 feat(native-renderer): cross-platform GPU — vulkan on linux, metal on macos
- add Skia Vulkan backend for Linux GPU instances (A10G, T4, L4)
- new_gpu_or_raster() auto-detects best GPU backend, falls back to CPU
- remove macOS-only guards from pipeline, benchmarks, and tests
- render_animated_gpu works on all platforms (Vulkan/Metal/raster fallback)
- flush_and_submit is now cross-platform
- all 49 tests pass

Production path: Linux NVIDIA → Skia Vulkan paint → NVENC hw encode
Docker CI path:  Linux no GPU → Skia CPU raster → FFmpeg libx264
Local dev path:  macOS → Skia Metal paint → VideoToolbox hw encode
2026-04-25 20:49:19 -04:00
Miguel Ángel 5953f14fe2 perf(native-renderer): bgra readback + nv12 videotoolbox encoding
- read_pixels_bgra() skips GPU-side BGRA→RGBA conversion (1.17ms vs 2.25ms)
- raw_pixel_encoder_args uses BGRA input matching Metal's native format
- VideoToolbox encodes via NV12 (media engine converts, not CPU)
- E2E: 334ms/30frames (11.2ms/frame), down from 365ms (12.1ms/frame)
2026-04-25 20:39:34 -04:00
Miguel Ángel 02634d0e2d fix(native-renderer): tighten auto fallback for unsafe animated media 2026-04-25 19:52:43 -04:00
Miguel Ángel efbbc04055 feat(native-renderer): harden hybrid auto backend proof 2026-04-25 19:42:17 -04:00
Miguel Ángel a89f9c45e1 feat(native-renderer): wire native CLI media path 2026-04-25 17:59:11 -04:00
Miguel Ángel ab642674bb feat(native-renderer): complete supported native proof path 2026-04-25 17:01:38 -04:00
Miguel Ángel 36f79043fa feat(cli): add render backend selection 2026-04-25 16:02:36 -04:00
Miguel Ángel ff15d3431e feat(native-renderer): add hardware encode path 2026-04-25 16:02:31 -04:00
Miguel Ángel 47087132fe feat(native-renderer): metal GPU surface — 29x faster than CPU raster
Skia Metal backend on Apple Silicon:
  GPU paint:              1.02ms/frame (vs 29.9ms CPU raster)
  GPU paint + readback:   5.57ms/frame (vs 29.9ms CPU raster)

29.3x speedup on pure GPU paint. 5.4x with pixel readback.
Phase 3.2 (hardware encoding) eliminates the readback cost entirely
via zero-copy IOSurface → VideoToolbox.

- RenderSurface::new_metal_gpu() creates Metal device + DirectContext
- flush_and_submit() for GPU command synchronization
- Criterion GPU benchmarks (macOS-gated)
2026-04-25 15:28:36 -04:00
Miguel Ángel 904cc42de4 feat(native-renderer): tier 2 CSS effects — box-shadow, blur, gradients
- box-shadow with offset, spread, blur radius, border-radius aware
- filter:blur via Skia ImageFilter + SaveLayerRec
- linear-gradient and radial-gradient via Skia gradient shaders
- gradient takes priority over solid background when both present
- 7 new tests (26 total), all passing
2026-04-25 15:22:46 -04:00
Miguel Ángel 5d45b8c3ed feat(native-renderer): phase 2 — effects, images, font caching
- box-shadow, filter:blur, linear/radial gradients (Skia effects)
- image loading with object-fit:cover and ImageCache
- font manager cached via thread_local (177ms → 29ms per frame)
- updated paint_element signature to accept ImageCache
2026-04-25 15:20:21 -04:00
Miguel Ángel ccf9bdb93f feat(native-renderer): pre-baked timeline extraction from Chrome
Add timeline baking module that uses Chrome CDP to evaluate a GSAP
timeline at every frame timestamp, extracting per-frame transform,
opacity, and visibility for all animated elements. The output JSON
uses snake_case field names compatible with Rust serde deserialization,
bridging GSAP animations to the native renderer without embedding V8.
2026-04-25 15:18:54 -04:00
Miguel Ángel 38cafc86c1 feat(native-renderer): phase 1 complete — Skia rendering pipeline + benchmark
Rust-based video composition renderer using Skia (Chrome's 2D engine):
- scene graph types with serde JSON parsing
- Skia raster surface with JPEG/PNG encoding
- element painter: backgrounds, border-radius, transforms, opacity, text
- static render pipeline: scene → Skia paint → FFmpeg pipe → MP4
- CDP scene extraction bridge (TypeScript)
- criterion benchmark: 1080p, 20 elements with text

Benchmark results (CPU raster, Apple Silicon):
  paint_1080p_20_elements:      29.8ms/frame
  paint_and_encode_jpeg_1080p:  35.7ms/frame

CPU raster is comparable to Chrome CDP (14-40ms). The GPU backend
(Metal/Vulkan, Phase 3) is where the 10-50x speedup materializes —
the infrastructure is proven, the bottleneck is CPU vs GPU painting.
2026-04-25 15:10:01 -04:00
Miguel Ángel a29b1f5fb9 perf(native-renderer): add skia paint benchmark at 1080p with 20 elements
Criterion benchmark with a realistic 1080p scene: 20 overlapping
card containers with text children, rounded corners, partial opacity,
and overflow clipping.

Two bench functions:
- paint_1080p_20_elements: clear + recursive paint
- paint_and_encode_jpeg_1080p: clear + paint + JPEG encode

Baseline numbers (Apple Silicon, raster CPU backend):
  paint only:         ~177 ms
  paint + JPEG encode: ~184 ms

The high paint time is dominated by FontMgr::new() being called per
text element per frame (20x per iteration). Font/typeface caching
in the paint path is the obvious next optimization target.
2026-04-25 15:07:31 -04:00
Miguel Ángel f099d76d17 feat(native-renderer): add CDP scene extraction from Chrome
Walks a Chrome page's DOM via Puppeteer and extracts a scene graph as
JSON matching the Rust parse_scene_json() format. Uses kind nested-object
structure with serde-compatible internally-tagged enum discriminator for
Container/Text/Image/Video.

Extracts bounds, computed styles (background, opacity, border-radius,
overflow, transform, visibility, font properties, color), and recurses
through children. Text detection based on text-only child nodes, image
and video detection based on element tag.

Tests verify JSON round-trip compatibility with the Rust scene types
including all element kinds, nested children, and transform serialization.
2026-04-25 15:04:57 -04:00
Miguel Ángel 49762b5a99 feat(native-renderer): static scene to MP4 render pipeline via FFmpeg
Wire Scene -> Skia paint -> JPEG encode -> FFmpeg pipe into an
end-to-end render_static function. The scene is painted once and the
JPEG frame is repeated N times via image2pipe, producing an H.264 MP4.

Includes RenderConfig/RenderResult types and two integration tests
(1s@30fps, 0.5s@24fps) that assert frame count, file existence, and
non-trivial output size.
2026-04-25 15:03:14 -04:00
Miguel Ángel 0f139b4e61 feat(native-renderer): element painting with transforms, opacity, border-radius
Adds paint_element() that recursively renders a scene graph Element onto
a Skia Canvas. Supports:
- Visibility culling (skip invisible elements)
- Position translation + CSS-like transform (rotate, scale around center)
- Layer-based opacity blending (save_layer_alpha)
- Overflow clipping with rounded rects
- Background fill (rect or rrect depending on border_radius)
- Text rendering via FontMgr default typeface
- Recursive child painting

Helper functions: to_color4f, to_sk_rect, make_rrect.

Four new tests covering background+text, border-radius+opacity pixel
verification, transforms, and invisible element skipping.
2026-04-25 15:00:12 -04:00
Miguel Ángel 8da7cb37de feat(native-renderer): add skia surface creation and pixel readback
Add RenderSurface abstraction wrapping skia_safe::Surface with:
- CPU-backed raster surface creation via surfaces::raster_n32_premul
- RGBA8888 pixel readback
- JPEG and PNG encoding via image snapshots
- Canvas access, clear, and dimension queries

All 4 paint tests pass alongside existing scene graph tests.
2026-04-25 14:56:24 -04:00
Miguel Ángel db1b3ae23c feat(native-renderer): scaffold Rust crate with scene graph types
Initialize the hyperframes-native-renderer crate with:
- Scene graph types (Scene, Element, ElementKind, Rect, Style, Color, Transform2D)
- Serde JSON serialization/deserialization with sensible defaults
- Internally-tagged ElementKind enum (Container/Text/Image/Video)
- parse_scene_json and parse_scene_file entry points
- Integration tests covering all element kinds, nesting, transforms,
  partial styles, round-trip serialization, and error handling
2026-04-25 14:53:03 -04:00
Miguel Ángel 39410ee320 fix(engine): revert streaming/multi-page/gpu defaults to safe values
Streaming encode is a regression on Linux/headless-shell (confirmed by
both local benchmarks and Rames' Linux VM A/B). The pipe becomes a
bottleneck when capture is already fast — Chrome and FFmpeg compete for
CPU instead of overlapping.

Reverts:
- enableStreamingEncode: true → false
- useMultiPageCapture: true → false (shared WebSocket serializes CDP calls)
- gpuBackend: "hardware" → "swiftshader" (needs real GPU to validate)

All three features remain available as opt-in via config/env vars.
The remaining 6 always-on optimizations (string-eval seek, FFmpeg
threading, parallel audio, hwaccel extraction, worker tuning, lower
PNG compression) are net-positive on all tested fixtures.
2026-04-25 13:57:03 -04:00
Miguel Ángel cb1642f2ed perf(engine): overhaul rendering pipeline for speed parity with Remotion
9 optimizations targeting the frame capture hot path (86% of total render time):

1. Enable streaming encode by default — overlaps capture with FFmpeg encoding,
   eliminating the encode stage as a separate step. Saves ~10% wall time.

2. Multi-page shared browser — screenshot-mode workers share a single Chrome
   process instead of launching N separate browsers. Eliminates N-1 Chrome
   startup costs (~2-3s each) and shares GPU/cache across pages.

3. Lower streaming JPEG quality (55 vs 80/95) — intermediate frames piped to
   FFmpeg are re-encoded, so quality loss is invisible in the final output.
   Smaller buffers transfer faster over CDP, cutting per-frame capture time.

4. Hardware GPU acceleration — replace forced SwiftShader (software renderer)
   with native GPU (Metal on macOS, Vulkan on Linux). CSS effects like
   box-shadow, blur, and transforms render 10-100x faster. Falls back to
   SwiftShader automatically in Docker/CI where no GPU exists.

5. Optimized seek evaluation — string eval replaces function serialization
   in the per-frame page.evaluate() call, skipping Puppeteer's serialize +
   Runtime.callFunctionOn overhead. Removes redundant __hf.seek guard that
   was already validated during session initialization.

6. FFmpeg multi-threading — adds -threads 0 across all encoding paths
   (streaming, chunk, extraction) to let FFmpeg auto-parallelize.

7. Parallel audio processing — audio extraction now runs concurrently with
   frame capture instead of blocking it. Audio uses separate FFmpeg processes
   that don't compete with Chrome for CPU.

8. Hardware-accelerated video extraction — adds -hwaccel auto for H.264
   sources and reduces PNG compression from level 6 to 1 (temp files).

9. Tuned parallelism defaults — more aggressive worker allocation (8 max,
   2 cores/worker, 24 min frames/worker) suited to modern hardware.

All 494 engine tests pass. No regressions.
2026-04-25 13:25:33 -04:00
Mu-Tsun Tsai 9b72a87c17 fix(lint): remove root_composition_missing_data_duration (#490)
* fix(lint): remove root_composition_missing_data_duration

Lint cannot statically observe the runtime's true Infinity-emission
condition: it requires a finite GSAP timeline duration AND a finite
media/sub-comp window AND timeline > floor + 1, none of which are
visible to the static linter. The looping shapes that drive the
condition are already covered by `gsap_infinite_repeat` and
`gsap_repeat_ceil_overshoot` (both from #243), which point at the
real authoring mistake — flagging the missing duration separately
was a noisy proxy for the same signal.

Per #490 review discussion, deprecate the static rule and let those
two GSAP rules carry the pre-render coverage. If perfect precision
on `durationInFrames = Infinity` is needed, that belongs on the
runtime/render path where `shouldEmitNonDeterministicInf` is
actually known.

Add regression tests pinning the removal: a docs-compliant root
without `data-duration` no longer warns, and the canonical
loop-inflated shape now surfaces only via `gsap_infinite_repeat`
instead of two duplicate findings.

* docs(skills): update step-6 build checklist after rule removal

Drops the `root_composition_missing_data_duration` reference now that
the rule is gone. Keeps the authoring recommendation (and explains the
runtime Infinity case) but points authors at the GSAP rules that
actually carry the lint signal: `gsap_infinite_repeat` and
`gsap_repeat_ceil_overshoot`.
2026-04-25 17:52:12 +02:00
Miguel Ángel 45f70004a1 chore: release v0.4.26 v0.4.26 2026-04-25 11:14:36 -04:00
Miguel Ángel b92341eb98 fix(cli): publish projects through staged uploads (#491)
* fix(cli): publish projects through staged uploads

* fix(cli): honor signed upload length header
2026-04-25 17:09:16 +02:00