heygen-com/hyperframes

HyperFrames is a comprehensive platform for authoring, rendering, and distributing HTML-based video compositions. It provides a local CLI and Studio for creating and editing compositions, alongside a distributed rendering engine that supports AWS Lambda, Google Cloud Run, and Kubernetes for scalable video production. The system includes a web player for embedding and presenting these compositions, with extensive tooling for audio processing, Figma integration, and cloud asset management.

Captured website projects now include AGENTS.md, CLAUDE.md, and .cursorrules files that provide AI coding assistants with a structured data inventory of design tokens, extracted styles, and all downloaded assets (images, fonts, SVGs, Lottie animations). The capture pipeline now catalogs page animations (Web Animations API, CSS transitions, scroll triggers) and WebGL shaders to help recreate visual effects, and downloads every declared icon to intelligently select the best brand mark (bare mark over badges). Asset downloads are hardened with strict SSRF denylists that validate every redirect hop, and SVGs are automatically fixed with correct XML namespaces to ensure they render as standalone files.

packages/cli/src/capture · high confidence

The \packages/aws-lambda/scripts\ directory now includes the build and verification infrastructure for the Lambda deployment. \build-zip.ts\ bundles the handler into an ESM module, inlining dependencies and staging the \ffmpeg-static\ binary, \@sparticuz/chromium\, and a fallback \chrome-headless-shell\. To prevent runtime crashes on Node 22, \build-zip.ts\ uses \\handlerBanner.ts\ to inject \require\, \\\filename\, and \\\_dirname\ shims into the bundle, a fix verified by \build-zip.test.ts\. The build enforces strict size budgets (248 MiB unzipped, 150 MiB zipped) checked by \verify-zip-size.ts\ and \\_formatBytes.ts\. Additionally, \probe-beginframe.ts\ and its Dockerfile provide a regression guard for Chromium's \HeadlessExperimental\ (BeginFrame) support, while \probe-webgpu-adapter.ts\ checks for hardware WebGPU availability.

packages/aws-lambda/scripts · high confidence

The \examples/aws-lambda\ directory now provides a complete reference deployment for HyperFrames on AWS, including a SAM template that orchestrates a Lambda function with a Step Functions workflow (Plan, parallel RenderChunk, Assemble). The example defaults to the new distributed plan protocol v2, which uses separate manifest and content-addressed artifact locators, while retaining explicit v1 compatibility for staged migrations. To validate the deployment, a real-AWS smoke test script (\smoke.sh\) and a benchmark script (\eval.sh\) are included; these deploy the stack, run renders against fixtures, and perform semantic comparison of decoded video/audio output against local baselines. The example also ships sample event payloads for both v1 and v2 protocols to aid in local testing and handler dispatch verification.

examples/aws-lambda · high confidence

The \packages/core/src/beats\ module now provides the foundational logic for analyzing music tracks, including dynamic beat detection, BPM calculation, and beat strength computation. It introduces a lazy-loading mechanism for the \bpm-detective\ library that safely handles transient import failures and SSR environments by resetting the cache on error. The module also implements persistence for beat data, storing analysis results as JSON files in a \beats/\ directory and providing utilities to identify music tracks within composition HTML based on \data-timeline-role\ attributes or specific ID patterns.

packages/core/src/beats · high confidence

New Remotion source files have been added to the \remotion-to-hyperframes\ test corpus, providing reference assets for conversion testing. The tier-1 entry includes a single title card composition featuring a fade-in/out animation, while the tier-2 entry provides a multi-scene composition with three distinct sequences (title, image, outro) and background audio. These files serve as input data for the skill's conversion pipeline rather than end-user features.

skills/remotion-to-hyperframes/assets/test-corpus/tier-1-title-card/remotion-src, skills/remotion-to-hyperframes/assets/test-corpus/tier-2-multi-scene/remotion-src · high confidence

A new demo fixture, deck-audio-demo.html, has been added to the runtime fixtures to showcase the hyperframes-slideshow component with integrated sound effects. This file demonstrates how to configure slide sequences, hotspots, and fragment timing, while also implementing the necessary JavaScript to handle audio playback and mute state synchronization between the parent document and the embedded player iframe.

packages/core/src/runtime/fixtures · high confidence

Users deploying HyperFrames on Kubernetes Jobs, AWS ECS Fargate, Google Cloud Run Jobs, or Azure Container Apps can now use the provided \Dockerfile.example\ to build a self-contained runtime image. This image includes Node 22, \chrome-headless-shell\, \ffmpeg\, and the producer source, allowing adopters to run distributed render chunks outside of AWS Lambda while maintaining version pinning by building from source.

examples/k8s-jobs · high confidence

The CLI now supports a new \capture-video\ mode that downloads video assets from a project's manifest. This feature includes strict validation to ensure only valid video content types are downloaded, enforces a 250 MB size limit to prevent memory exhaustion, and handles filename collisions safely. It also provides options to list available videos or select specific ones by index or URL, improving the reliability and security of video asset retrieval.

packages/cli/src/commands/capture · high confidence

The audio generation scripts now support Gemini TTS models (including gemini-3.8-flash-tts) with service-account authentication, allowing users to generate speech using Google's Gemini models. Background music (BGM) handling has been improved with configurable volume levels for narration and silent films, and the system now supports both HeyGen retrieval and local generation via Lyria or MusicGen. Concurrency controls have been added to prevent overwhelming the system during TTS synthesis, and audio metadata handling has been enhanced to retain file identity and prevent overwrites during generation. Additionally, HeyGen integration now includes proper client source tagging for usage tracking.

skills/media-use/audio/scripts · high confidence

The engine now includes a dedicated audio processing pipeline in \packages/engine/src/services\. This adds an \audioMixer\ service that handles track mixing, fade-in/fade-out application, and level normalization using FFmpeg, alongside an \audioFxRender\ service that applies audio effects (like volume envelopes and FX chains) via the headless browser's OfflineAudioContext to ensure render parity with the studio preview. The change also introduces a \jpeg.ts\ fixture for testing. The entry is grounded in the added source files and the extensive suite of new tests (\audioMixer.test.ts\, \audioFxRender.test.ts\, etc.) that verify these behaviors.

packages/engine/src/services · high confidence

The CLI now supports silent, background auto-updates that install minor and patch versions without blocking the user, while explicitly skipping major version jumps, CI environments, and dev mode. It introduces a generated registry of global skills directories for dozens of AI agents (such as Cursor, Claude Code, and Copilot) to manage their installation paths. Process handling is hardened with a new cancellable process runner that reliably terminates entire process trees on abort or timeout, and font localization is improved to embed remote fonts deterministically in snapshots and checks, preventing render inconsistencies.

packages/cli/src/utils · high confidence

The CLI now includes a new timeline editing workflow. Users can stamp HTML files with stable IDs using the \ids\ command, which safely detects and refuses to overwrite files that have changed since the timeline was read. Additionally, the \edit\ command allows users to modify clips directly via verbs such as move, trim, split, delete, duplicate, and set (for volume, rate, or track). These mutations are applied to the project's source HTML files, with the CLI handling time expression parsing, overlap detection, and receipt generation.

packages/cli/src/timeline · high confidence

The scripts directory now includes a fetch-mirror system that records and replays font requests (Inter, Roboto) from Google Fonts, allowing catalog generation to run without network access. A new drift-check script compares generated catalog artifacts against committed snapshots to catch stale or missing files. Additionally, a backfill script normalizes preview metadata in registry block and component manifests, and a navigation builder regenerates the catalog sidebar from gallery data.

scripts · high confidence

The embedded captions skill now provides a single selection surface (catalog) where users choose a caption 'identity' (e.g., \cream\, \ink\, \anchor\) rather than manually selecting backend engines or modes. The skill automatically routes the chosen identity to the appropriate engine (cinematic or theme) and authoring file. Additionally, the skill now includes a \.gitignore\ file to manage the bundled PP-MattingV2 ONNX model and prevent stray render artifacts from being committed to the repository.

skills · high confidence

The engine's utility layer now includes a zero-dependency, in-memory PNG decoder and encoder (alphaBlit) that replaces per-frame FFmpeg spawns for HDR compositing, alongside utilities for validating that Chrome uses the SwiftShader software renderer (assertSwiftShader) to ensure pixel-identical distributed renders. It also adds GPU encoder detection and naming (gpuEncoder) supporting AMD AMF alongside NVENC, QSV, VAAPI, and VideoToolbox, even-dimension padding for 4:2:0 video encodes (evenDimensions), and hardened FFmpeg/ffprobe binary resolution and metadata extraction (ffmpegBinaries, ffprobe) with bounded output and CRC32 chunk handling (crc32).

packages/engine/src/utils · high confidence

The \packages/studio\ directory is introduced with a \.gitignore\ file to exclude build artifacts and test evidence, and an \AGENTS.md\ guide explaining the architecture (iframe-based preview with overlay chrome) and testing strategies for the new Studio package.

packages/studio · high confidence

This change introduces the \packages/cli\ package, providing a command-line interface for creating, previewing, and rendering HTML video compositions. The package includes commands for initializing projects (\init\), starting a live preview studio (\preview\), rendering compositions to MP4 (\render\), publishing projects (\publish\), linting compositions (\lint\), and managing the environment (\doctor\, \browser\). It also features audio normalization (\normalize-audio\) and benchmarking capabilities. The package is built with TypeScript, targets Node.js 22, and bundles core dependencies like the producer and engine while keeping native modules and cloud adapters external for efficient loading.

packages/cli, packages/producer · high confidence

The repository is initialized with foundational configuration files that establish the project's development environment and standards. This includes setting up the Bun package manager, configuring oxlint and oxfmt for code quality and formatting, defining .editorconfig and .gitignore rules, and adding documentation files such as AGENTS.md, CLAUDE.md, and ADOPTERS.md to guide contributors and AI agents.

(repo-wide) · high confidence

This change introduces the foundational template files for the core package, establishing the base HTML structure and associated CSS constants. The \base.ts\ module provides functions to generate a standard HTML5 document with a designated stage and zoom container, while \constants.ts\ defines the default styles for elements, media, and text, including the integration of the GSAP animation library via CDN. These components form the structural basis for rendering canvas-based content.

packages/core/src/templates · high confidence

This change introduces the new @hyperframes/aws-lambda package, providing a complete AWS Lambda adapter for HyperFrames distributed rendering. It includes a Lambda handler that wraps plan, renderChunk, and assemble primitives for Step Functions orchestration, a client-side SDK (renderToLambda, getRenderProgress, deploySite) for driving renders, and an AWS CDK L2 construct (HyperframesRenderStack) for provisioning the infrastructure. The package defaults to the v2 plan protocol for new renders, requiring a coordinated infrastructure upgrade before application updates, while maintaining backward compatibility with v1. It supports two Chromium sources (@sparticuz/chromium by default, or bundled chrome-headless-shell) and includes build tooling for creating the Lambda ZIP bundle with size verification.

packages/aws-lambda · high confidence

The new @hyperframes/player package provides an embeddable web component for playing HyperFrames compositions, supporting ESM, CommonJS, and global script builds. Key capabilities include automatic mobile audio playback via parent-frame media copies to bypass iframe autoplay restrictions, an audio-locked attribute to force-mute and hide volume controls (with a user-agent fallback for environments like Claude Desktop), and retained runtime data channels for delivering and tracking payload application. The player also exposes picture size, durationchange, and click-to-play opt-out events, supports slideshow mode via a separate component, and includes low-power idle checks for paused players to optimize performance on pages with many instances.

packages/player · high confidence

A new \@hyperframes/shader-transitions\ package enables WebGL-powered, GPU-accelerated scene-to-scene transitions driven by GSAP timelines. It pre-captures animated scene samples and composites them with fragment shaders (such as domain-warp, glitch, and gravitational-lens) during playback, allowing scene animations to continue without re-running DOM captures. The package supports native HTML-in-Canvas capture via \drawElementImage\ with an \html2canvas\ fallback, caches transition snapshots in IndexedDB for faster reloads, and includes a page-side WebGL compositor for engine render modes to maintain high-fidelity compositing.

packages/shader-transitions · high confidence

Adds a new adapter for running distributed renders on Google Cloud Run, including the server-side handler, GCS transport layer, and client-side SDK. The adapter supports the v2 plan protocol with content-addressed artifact storage, provides cost accounting for Cloud Run and Cloud Workflows usage, and includes a Chrome binary resolver for the container environment.

packages/gcp-cloud-run/src · high confidence

This change adds the core type definitions and utility functions for the Hyperframe runtime integration. It establishes the runtime contract (globals, bridge sources, and control actions like play, pause, seek, and color grading) and provides parity utilities for frame-accurate time quantization and snapping, ensuring consistent behavior between preview and render. Additionally, it introduces a picker API for element selection and a mechanism to build the runtime script via esbuild, supporting parity mode configuration.

packages/core/src/inline-scripts · high confidence

The CLI now includes an auto-generated TypeScript client (\HyperframesCloudClient\) and associated type definitions for interacting with the HyperFrames cloud-render API. This new code, derived from the OpenAPI spec, provides typed methods for creating renders and managing asset uploads via the \/v3/assets/direct-uploads\ endpoint, supporting presigned S3 uploads for files up to 200MB. Users benefit from improved type safety and structured error handling when invoking cloud rendering features.

_packages/cli/src/cloud/\gen · high confidence

The AWS Lambda adapter now supports the distributed plan protocol v2, which uses content-addressed S3 artifacts and a manifest for plan publication instead of the legacy v1 tarball transport. This change introduces new event types (PlanV2Event, RenderChunkV2Event, AssembleV2Event) and a dedicated S3 publisher (S3PlanV2ArtifactPublisher) to handle immutable blob uploads and manifest commits. Additionally, the adapter adds a robust Chrome binary resolver that supports both the @sparticuz/chromium runtime source and a bundled chrome-headless-shell fallback, featuring a typed ChromeBinaryUnavailableError to prevent silent failures and ensure non-retryable errors are correctly surfaced to Step Functions.

packages/aws-lambda/src · high confidence

A new \changelog-video\ skill has been added to the \.agents/skills/\ directory, enabling the automatic generation of \~45–60 second branded 1080×1080 MP4 changelogs from weekly markdown digests. This repo-native capability integrates a full production pipeline—including a master HTML scaffold, brand assets (fonts, background patterns, house BGM), and a two-layer script system that separates display text for captions from phonetic spoken text for HeyGen TTS. The skill enforces strict quality gates, such as non-optional caption rails, contrast checks, and seam-gate verification, ensuring that the resulting videos maintain brand consistency and technical correctness before rendering.

.agents, .claude/skills · high confidence

This change establishes the foundational type system for the registry in \packages/core/src/registry\. It defines strict TypeScript interfaces for \ExampleItem\, \BlockItem\, and \ComponentItem\, along with \FileType\ and \ItemType\ constants that are enforced against JSON schemas. The entry also includes a drift-guard test suite (\types.test.ts\) to ensure the TypeScript definitions remain synchronized with the underlying JSON schema enums, and a test (\catalogGeneratorInstructions.test.ts\) verifying that the catalog generator correctly preserves hand-written sections during regeneration.

packages/core/src/registry · high confidence

The \packages/aws-lambda/src/sdk\ directory introduces a new TypeScript SDK for orchestrating distributed video renders on AWS. It provides \renderToLambda\ to start a Step Functions execution (defaulting to plan protocol v2) and \getRenderProgress\ to poll a live snapshot of frame progress, errors, and estimated costs. The SDK includes \deploySite\ for content-addressed, idempotent uploads of project assets to S3, and a \costAccounting\ module that estimates Lambda GB-second and Step Functions transition costs from execution history. It also enforces client-side validation of render configurations and the 256 KiB Step Functions Standard input cap to fail fast with actionable errors.

packages/aws-lambda/src/sdk · high confidence

The CLI now includes a full set of subcommands for managing AWS Lambda-based renders: \deploy\ provisions the infrastructure via SAM, \destroy\ tears it down, \render\ and \render-batch\ execute single or batched renders, \progress\ tracks status, and \policies\ generates and validates the required IAM permissions. Additionally, \render\ and \render-batch\ now warn users when the specified \--width\/\--height\ flags conflict with the composition's actual dimensions, suggesting \--output-resolution\ for supersampling.

packages/cli/src/commands/lambda · high confidence

Developers can now deploy the HyperFrames rendering stack using the \HyperframesRenderStack\ AWS CDK construct instead of relying solely on the SAM template. This construct provisions the core infrastructure: a Node.js 22 Lambda function (10 GiB memory, 10 GiB ephemeral storage), a Standard Step Functions state machine with tracing enabled, an S3 bucket with public access blocked and a 7-day lifecycle rule for intermediates, and three CloudWatch alarms for runaway invocations, Lambda errors, and state machine failures. The construct exposes the bucket, function, and state machine as properties for easy wiring of additional resources and defaults to the v2 plan protocol while preserving v1 support.

packages/aws-lambda/src/cdk · high confidence

The CLI now includes dedicated commands for managing HeyGen authentication: \auth login\ supports both standard OAuth and a new \--device\ flow for headless or SSH environments, while \auth logout\ allows selective removal of OAuth sessions via \--keep-api-key\, and \auth refresh\ enables manual token rotation. The login process now persists a friendly user identity block (name, email, username) on successful sign-in, which \auth status\ surfaces to users and scripts, falling back to cached data if the live API probe fails. Onboarding guidance for unconfigured environments now explicitly recommends the \npx hyperframes auth login\ path and clarifies that local engines (Kokoro, MusicGen) are available as offline fallbacks.

packages/cli/src/commands/auth · high confidence

The CLI now includes a dedicated authentication module (\packages/cli/src/auth\) that supports multiple credential sources (environment variables, file-based JSON store, and legacy plaintext) and two interactive login flows: standard OAuth 2.0 with PKCE (using a local loopback server and browser auto-open) and device authorization. The module introduces typed error handling for auth states, automatic token refresh on 401 responses, credential redaction in error messages, and attribution headers (\X-HeyGen-Client-Source\) for usage tracking. This replaces or supplements previous ad-hoc auth logic with a centralized, testable implementation.

packages/cli/src/auth · high confidence

The CLI now includes dedicated commands for credential management (\auth\), batch video rendering (\batchRender\), and audio beat analysis (\beats\). The \auth\ command supports signing in via browser, SSH device flow, or API key, and manages stored credentials. The \batchRender\ command enables generating multiple video outputs from a single JSON input file, handling variable substitution and output path templating. The \beats\ command detects musical beats in a project's audio track and writes a JSON beat map for timeline synchronization.

packages/cli/src/commands · high confidence

The CLI now includes three new subcommands under \hyperframes figma\ to import design assets into the project. The \asset\ command renders Figma nodes (supporting batch imports, SVG sanitization, and provenance tracking) and freezes them as local media files. The \tokens\ command imports Figma variables as composition brand tokens, with an automatic fallback to style metadata when variables are Enterprise-gated. The \component\ command converts Figma frames into editable HTML components, resolving variable bindings and handling unrenderable nodes via rasterization fallbacks.

packages/cli/src/commands/figma · high confidence

This change introduces the core infrastructure for importing Figma assets and tokens into the project. It adds a typed Figma REST client with robust error handling (mapping 403/429/401 to specific codes like REQUIRES\_ENTERPRISE or RATE\_LIMITED) and exponential backoff for rate limits. A binding index system is added to persist and resolve mappings between Figma variable/style IDs and composition variables, supporting alias chains and upserts. Asset handling includes a manifest system for tracking imported images/videos, a 'freeze' mechanism to download and cache assets locally with SSRF protection and size caps, and utilities to generate HTML snippets for assets. Additionally, motion context is translated into GSAP timeline scripts for runtime animation.

packages/core/src/figma · high confidence

Added a new \@hyperframes/gcp-cloud-run\ package that enables distributed rendering on Google Cloud Run and Cloud Workflows. This includes a Dockerfile for the container image (pinned to \chrome-headless-shell\ and \bun\), a build script for subpath exports (\server\, \sdk\, \terraform\), and a workspace integrity checker to ensure the Dockerfile correctly copies and builds all required monorepo dependencies. The adapter supports v2 plan protocols by default and provides an SDK for programmatic render management.

packages/gcp-cloud-run · high confidence

This release introduces a new adapter for deploying HyperFrames distributed rendering on Google Cloud Run and Cloud Workflows. The included Terraform module provisions the Cloud Run service, Cloud Workflows orchestration, GCS storage, and associated service accounts, while the accompanying smoke test script enables owner-isolated end-to-end deployment and parity verification. The workflow defaults to the new Plan v2 protocol (using disjoint GCS locators) and retains explicit v1 compatibility for staged migrations, ensuring strict protocol adherence without silent fallbacks.

examples/gcp-cloud-run, packages/gcp-cloud-run/terraform · high confidence

The CLI now includes dedicated commands for managing cloud renders: \cloud render\ orchestrates the full lifecycle (uploading via the new 200MB direct-upload endpoint, submitting, polling, and downloading), \cloud list\ paginates through renders with cursor support, \cloud get\ fetches detailed status and signed URLs, and \cloud delete\ performs soft-deletion with mandatory confirmation. The render command also auto-detects aspect ratio from local composition dimensions when not explicitly provided and validates resolution/format combinations before upload.

packages/cli/src/commands/cloud · high confidence

The CLI now includes a new Parakeet ASR engine as a high-accuracy, local alternative to whisper.cpp, alongside comprehensive tests for the transcription pipeline. This update introduces a new \WhisperUnavailableError\ to distinguish missing binary setup issues from actual transcription failures, and adds tests for transcript normalization, format detection, and Parakeet token merging. It also includes tests for the Sherpa runtime installation and worker processes, ensuring reliable detection and handling of the Parakeet model and its dependencies.

packages/cli/src/whisper · high confidence

This change introduces the core logic and data models for advanced audio editing features, including parametric automation envelopes (for volume, speed, and FX parameters), a structured audio FX chain registry with normalization and validation, and a voiceover carve system that automatically analyzes audio to create sidechain-style frequency dips. It also adds a GSAP timeline frame adapter for animation integration. These new modules are accompanied by extensive unit tests covering parsing, normalization, range resolution, and edge-case handling to ensure stability.

packages/core/src · high confidence

The CLI now includes a \remove-background\ command that processes video or image inputs to produce a foreground cutout with transparency. For video, it outputs \.webm\ (VP9 with alpha) or \.mov\ (ProRes 4444 with alpha); for images, it outputs \.png\. An optional \--background-output\ flag allows generating a second file containing the inverse-alpha background plate. The feature uses the \u2net\_human\_seg\ ONNX model for inference and supports hardware acceleration via CPU, CoreML (macOS), or CUDA (Linux).

packages/cli/src/background-removal · high confidence

The producer package now includes a new benchmark harness (benchmark.ts) that runs test fixtures with configurable runs and tag filters, recording per-stage timing and peak memory usage. A new pluggable logging system (logger.ts) provides level filtering and ensures all log output goes to stderr to avoid corrupting machine-readable CLI stdout. Additionally, the package exports distributed render primitives (distributed.ts) supporting both Plan v1 and the new content-addressed Plan v2, allowing external adapters to execute chunked renders and assemble final outputs without networking dependencies.

packages/producer/src · high confidence

The CLI now includes dedicated modules for detecting and resolving common browser and media dependency issues. It provides distro-aware remediation for missing shared libraries on Linux/WSL and specific guidance for macOS 12 dyld crashes. The system also detects H.264 encoder availability to prevent silent render failures and offers platform-specific installation commands for FFmpeg. Additionally, it introduces a concurrency-safe installation lock to prevent race conditions during browser downloads and adds detailed path analysis for telemetry.

packages/cli/src/browser · high confidence

The \@hyperframes/lint\ package now exposes a browser-compatible entry point (\@hyperframes/lint/browser\) that allows client-side validation of compositions without Node.js dependencies, enabling editors to check HTML strings for errors entirely in the browser. Additionally, the lint engine now includes a new HEVC preview codec rule that detects video assets encoded with the HEVC codec, flagging them with an info-level note to warn users about potential playback compatibility issues. The package also introduces a \shouldBlockRender\ utility for strict linting gates and improves source location accuracy for findings across comments and templates.

packages/lint/src · high confidence

The \packages/core/scripts\ directory now includes a suite of new tooling to support the Hyperframe runtime and audio-FX pipeline. Build scripts (\build-hyperframes-runtime-artifact.ts\, \build-audio-fx-runtime.ts\, \build-position-edits-render.ts\) and a shared utility (\buildInjectedArtifact.ts\) generate and bundle runtime artifacts as injectable IIFEs. A new \writeGeneratedFile.ts\ utility ensures atomic file publication to prevent race conditions during concurrent builds. Validation and linting scripts (\check-hyperframe-static.ts\, \lint-runtime-preview-guards.ts\) enforce structural and behavioral constraints on the runtime source. Additionally, a comprehensive set of test scripts (\test-hyperframe-runtime-\*.ts\, \test-hyperframe-linter.ts\, \test-hyperframe-runtime-duration-guards.ts\) verifies the runtime contract, security guards, parity, and seek behavior, while \rewrite-esm-extensions.ts\ handles post-build ESM specifier rewrites.

packages/core/scripts · high confidence

The distributed rendering service now supports chunked, parallelized rendering via a new pipeline consisting of planning, per-chunk rendering, and final assembly. This change introduces \plan.ts\ to generate execution plans with chunking logic, \renderChunk.ts\ to handle individual chunk rendering, and \assemble.ts\ to stitch chunks into final outputs (mp4, mov, webm, png-sequence). The implementation includes support for WebM via concat-copy, configurable chunk sizes, and strict validation for distributed constraints (e.g., rejecting HDR MP4, enforcing software rendering). Comprehensive tests ensure byte-identical outputs across chunk boundaries and workers, with soft-skip handling for host environments lacking proper GPU support.

packages/producer/src/services/distributed · high confidence

A new browser-based playground has been added to the SDK workspace, providing a live editing environment for compositions. It features a sandboxed preview iframe with transport controls (play, pause, seek), an element tree, and a properties panel that allows users to modify text, typography, box layout, and GSAP animation timings via the SDK API. Composition state is persisted to disk via a file-backed adapter, supporting version history and restoration. The playground also includes an ops panel for direct SDK method invocation and an editor modal for raw HTML editing. Initialization errors are rendered as safe text to prevent injection, and message dispatch from the preview iframe is strictly scoped to the current preview instance.

packages/sdk-playground · high confidence

The CLI now includes a local text-to-speech command powered by the Kokoro-82M model, allowing users to generate speech without external APIs. This feature introduces a curated set of bundled voices across multiple languages (English, Spanish, French, Japanese, Mandarin, etc.) and automatically infers the correct phonemizer locale from the selected voice ID. A key behavioral fix ensures that Mandarin Chinese is correctly mapped to the 'cmn' code required by the underlying espeak-ng engine, preventing synthesis errors. Additionally, the system now robustly handles Python environment overrides, surfacing clear warnings if the \HYPERFRAMES\_PYTHON\ path is invalid, and implements a caching mechanism for the synthesis script to improve performance and manage disk space.

packages/cli/src/tts · high confidence

The CLI now includes a new \media-use\ library that manages media assets through several new capabilities. It can scan and adopt existing project assets, using token-based matching to find relevant files while avoiding false positives from short filenames. A global cache system allows assets to be reused across projects via content hashes. The library introduces a provider system for sourcing media, including bundled sound effects, brand logos from design specs, background music from HeyGen, and image generation via the Codex CLI. It also provides a candidate ranking system to surface the most relevant existing assets for reuse.

packages/cli/src/media-use · high confidence

The media-use skill now includes a suite of new script libraries that power core media operations. These include a manifest and index generator for tracking assets, a cutlist compiler for precise audio/video trimming (silence, fillers, words), and audio ducking logic for volume keyframes. Security is improved via a media fetcher that validates public URLs and blocks private redirects. The system also introduces a two-tier preference store (project and user) to remember brief answers, a recipe store for freezing and reusing video templates, and a telemetry module that tracks usage via PostHog while respecting opt-out settings.

skills/media-use/scripts · high confidence

The \packages/player/src\ directory now contains the core implementation files for the HyperFrames player web component, including \hyperframes-player.ts\ (the main component), \composition-probe.ts\ (for detecting composition readiness and injecting the runtime), \controls.ts\ and \controls-setup.ts\ (for the playback UI), \direct-timeline-clock.ts\ (for rAF-based timekeeping), \iframe-dom.ts\ (for iframe and style management), \media-element-guards.ts\, \mediaObserverScope.ts\ (for scoped media observation), and \parent-media.ts\ (for parent-frame audio proxies). Corresponding test files (\hyperframes-player.test.ts\, \controls.test.ts\, \composition-probe.test.ts\, \mediaObserverScope.test.ts\, \parent-media.test.ts\) have been added to verify these behaviors. A new script \verify-runtime-pin.mjs\ ensures the player bundles pin the correct runtime version.

packages/player/src · high confidence

The producer now includes a preflight check that validates local media assets match their authored element types (video, audio, or image) before rendering, failing fast with a clear error if a mismatch is detected. Additionally, animated GIFs are now automatically transcoded to muted, looped VP9 WebM videos during the preparation phase to ensure reliable playback and seek-syncing within the render pipeline, with loop behavior and padding handled explicitly.

packages/producer/src/services · high confidence

The registry now includes six new installable composition blocks. The AI Chat Reveal block simulates a mock chat conversation with a streaming AI assistant and a branded closing card, with editable variables for bot name, user message, answers, bullets, and end-card details. The App Showcase block displays a fitness app product demo across three floating smartphone screens. The Apple Money Count block features an Apple-style finance counter that animates from $0 to $10,000 with a green flash and money icon burst. The Bar Chart Race block visualizes ranked data series over time with dynamic axis rescaling and customizable labels, periods, and accent colors. The Beat Freeze Cut block provides a beat-driven speed ramp and freeze-frame transition for music-led promos. The Blue Sweater Intro Video block offers a warm AI creator intro sequence.

registry · high confidence

This change introduces a suite of new utilities and tests in the producer package to improve render reliability and cross-platform compatibility. It adds an audio regression harness that compares rendered audio against snapshots using RMS envelope correlation and sample-level residual RMS checks to detect subtle drift. Path handling is hardened with a new \toExternalAssetKey\ function that sanitizes Windows drive letters and UNC paths to prevent external asset rejection, alongside a robust \isPathInside\ containment check. Error reporting is improved by normalizing thrown values to prevent \\[object Object\]\ in telemetry. Additionally, the package now includes a concurrency semaphore to limit media probe operations and a contract test that automatically discovers and validates ffprobe argument terminators across the codebase.

packages/producer/src/utils · high confidence

The runtime now includes dedicated adapters for anime.js, CSS/WAAPI, D3, GSAP, Leaflet, Lottie (lottie-web and dotlottie-web), Mapbox, and Google Maps, enabling deterministic seeking and playback control for animations and visualizations created outside the engine. A new readiness adapter system allows the runtime to wait for external assets—such as D3 transitions, map tiles, or library instances—to fully initialize before proceeding, ensuring stable composition starts.

packages/core/src/runtime/adapters · high confidence

The PR-to-Video skill now uses a dedicated, standalone script architecture to handle video generation, replacing previous implementations. This change introduces a suite of new modules in \scripts/lib\ that manage the entire pipeline: a vendored storyboard parser for reading project plans, a frame contract validator to ensure worker output integrity, and logic to stage captured assets and fonts into the project directory. It also includes utilities for handling canvas dimensions, caption band geometry, and brand token parsing (colors and fonts). Additionally, the skill now features a vendored transition registry and logic to pad frame durations, ensuring that outgoing transitions fade out gracefully without clipping content.

skills/pr-to-video/scripts, skills/product-launch-video/scripts · high confidence

This change introduces a new \\<hyperframes-slideshow\>\ custom element and its underlying \SlideshowController\ to enable slideshow-style presentations within the player. The controller manages linear and branched navigation (via sequences), handling fragment-by-fragment reveals and slide transitions using synchronous seeks to ensure deterministic playback without auto-advancing. It supports presenter mode, which includes a dedicated bottom panel for speaker notes, an "up-next" preview, and branch navigation, while audience mode synchronizes with the presenter via a \BroadcastChannel\ to mirror position and media state. The component also introduces an \OwnedMediaRegistry\ to manage slide-specific media (like autoplay clips) and provides keyboard navigation (Arrow keys, Space, Backspace) with focus-aware behavior to prevent hijacking host page interactions.

packages/player/src/slideshow · high confidence

The storyboard module now includes a lenient parser for the canonical \STORYBOARD.md\ format and surgical writers that allow updating individual frame metadata (such as \voiceover\ and \status\) in place without re-serializing the entire file. This ensures that edits to specific frames preserve surrounding content, formatting, and comments. The changes also introduce a parity test suite to guarantee that the vendored parser copies used by standalone skills remain byte-identical and functionally consistent with the core implementation.

packages/core/src/storyboard · high confidence

Two new entry-point stubs have been added to the core package to support headless rendering and producer pipeline operations. The \audio-fx-runtime-entry\ stub exposes a \window.\_\_HF\_AUDIO\_FX.render\ API that processes audio clips through an FX chain using an OfflineAudioContext, ensuring that preview and render paths share the same graph builder and automation scheduling logic while correctly handling effect tails. The \position-edits-render-entry\ stub applies position edits and installs seek reapplication logic for the producer pipeline, ensuring that edit positions are correctly rendered in the headless environment.

packages/core/stubs · high confidence

The core text module now exposes a new \fitTextFontSize\ utility that automatically calculates the largest font size fitting within a specified container width, and adds a \pretext\ object to the public API surface. This \pretext\ object provides canvas-based text measurement functions (\prepare\, \layout\, \prepareWithSegments\, \measureLineStats\, \measureNaturalWidth\) for use in compositions, while deliberately excluding state-mutating functions like \clearCache\ to ensure deterministic rendering.

packages/core/src/text · high confidence

This location introduces design specifications and research documents for upcoming audio capabilities. The \audio-automation-lanes/SPEC.md\ defines a data model and UI for breakpoint envelopes on audio tracks, allowing users to automate volume and FX parameters with clip-local timing and live-edit support. The \audio-fx-presets.md\ document outlines a catalog of static and adaptive audio treatment presets (such as voice and character effects) built on existing DSP, while \audio-fx-ux/README.md\ details the user experience for the FX rack, including plain-language copy and collapsed states. Additional plans address shared automation lane rows, time selection gestures, and session handoff for audio groups.

plans · high confidence

The runtime package now includes a README detailing the stable surface, build artifacts, and security expectations. A new declarative variable binding system allows compositions to expose dynamic content via \data-var-src\ (for media URLs) and \data-var-text\ (for text content), with values applied as CSS custom properties on the composition root. This system includes strict security measures, such as restricting \data-var-src\ to media elements and sanitizing CSS values to prevent injection. Additionally, a new analytics module enables the runtime to emit events like composition load and play via postMessage for host application tracking.

packages/core/src/runtime · high confidence

The SDK package is scaffolded with an engine layer supporting model mutations, RFC 6902 patches, and a session API with optional history and a persist-queue. It introduces injectable persistence adapters (memory, file-system, headless, iframe) to decouple storage from the core, allowing compositions to be saved, versioned, and restored. Example scripts demonstrate headless editing agents (localization, brand restyling, A/B variants, asset swapping, GSAP animation, variable overrides) and editor integrations (vanilla and React) that utilize these adapters and the new typed composition API.

packages/sdk · high confidence

The core package now includes a system font locator that scans standard OS directories (macOS, Windows, Linux) to find installed fonts, supporting TTF, OTF, WOFF, and WOFF2 formats with a 5MB file size limit. It normalizes font names, caches results for performance, and provides a back-compat re-export of font alias mappings previously moved to the parsers package.

packages/core/src/fonts · high confidence

This change introduces several new utility modules in the core package to improve security and correctness. The \htmlAttrSafety\ module provides a centralized allowlist of safe HTML attributes and logic to block dangerous URI schemes (like javascript:), which is used to validate attribute values. The \cssSelector\ module adds a \queryByAttr\ function that queries the DOM by exact attribute match without interpolating values into selector strings, preventing CSS injection attacks. The \richTextSanitize\ module implements a strict sanitizer for rich text content, stripping out dangerous tags (like script, iframe), event handlers, and unsafe style values while preserving allowed formatting (colors, fonts) and internal tracking attributes. Additionally, the \renderOutputTimestamp\ module ensures output filenames use a consistent local timezone, and \urlPath\ re-exports a decoder from the parsers package for backward compatibility.

packages/core/src/utils · high confidence

The core generator now enforces strict security boundaries when producing HTML, CSS, and JavaScript for compositions. It sanitizes rich text content to strip executable markup (such as \<script\> tags, inline event handlers, and dangerous SVGs) while preserving safe formatting. It validates media and composition source URLs, rejecting dangerous schemes like javascript: or data: HTML. Additionally, it safely escapes HTML attribute values and CSS strings to prevent injection attacks, and validates numeric inputs to ensure they are finite numbers, throwing errors for unsafe inputs.

packages/core/src/generators · high confidence

The compiler module has been restructured into distinct, testable components to improve maintainability and correctness. \compositionAssembly.ts\ now centralizes the logic for identifying composition assets (styles, scripts, links) and scope identities, ensuring consistent behavior between the Node-based renderer and the browser-based runtime. \compositionScoping.ts\ handles CSS isolation, specifically remapping document-level selectors (like \html\, \body\, \:root\) to the composition's own box to prevent style clobbering in nested sub-compositions. \htmlBundler.ts\ manages the final bundling process, including rebasing asset paths, inlining resources, and injecting the runtime. \externalScripts.ts\ provides safe deduplication of external script tags while preserving integrity attributes. These changes are accompanied by comprehensive test suites (\\*.test.ts\) for each new module, verifying correct asset collection, CSS scoping edge cases, and bundling behavior.

packages/core/src/compiler · high confidence

The engine source has been reorganized into a structured module with a new typed configuration system (config.ts) that replaces the previous environment-variable sprawl with a unified EngineConfig interface, while adding a type augmentation for Chrome's HeadlessExperimental CDP domain to enable safe, typed access to experimental frame-capture APIs without unsafe casts.

packages/engine/src · high confidence

The GSAP parsing, writing, and spring-ease evaluation logic has been extracted from the core package into a dedicated \@hyperframes/parsers\ package. The files in this location now serve as deprecated re-export shims, ensuring that existing imports from \packages/core/src/parsers\ continue to work while directing users to the new package. This change improves modularity by separating motion-parsing concerns from the core runtime, though the functional behavior of the parser and spring-ease evaluator remains unchanged for consumers.

packages/core/src/parsers · high confidence

The parser logic has been extracted from the core package into a new standalone \@hyperframes/parsers\ package. This change introduces explicit subpath exports (defined in \package-subpaths.json\) for specific modules such as \gsap-parser\, \composition\, \media-duration\, and \asset-resolution\, allowing consumers to import only the necessary parts. The package is configured with a dedicated \tsconfig.json\ and \tsup.config.ts\ to build ES modules for Node, Bun, and browser environments, and includes a \vitest.config.ts\ for testing. This structural change improves modularity and reduces bundle sizes by enabling tree-shaking of unused parser components.

packages/parsers · high confidence

The render pipeline in the producer has been refactored into distinct, modular stages (audio, capture, encode, assemble) to improve maintainability and testability. This change introduces new stage implementations and corresponding unit tests for \assembleStage\ (handling final muxing, faststart, and HLS packaging), \audioStage\ (mixing and error reporting), and \captureHdrFrameShared\ (HDR frame capture logic and hybrid parallel path gating). The refactoring ensures that audio mix failures are properly surfaced to users instead of silently resulting in silent video, and that HLS packaging correctly normalizes audio duration before stream-copying.

packages/producer/src/services/render/stages · high confidence

The \@hyperframes/parsers\ package has been extracted from the core monolith into a standalone module, providing a shared, browser-safe foundation for composition parsing, asset path resolution, and color grading contracts. This change introduces a single, unified resolver for local asset paths (used by both lint and render) that safely clamps path traversals and handles templating placeholders, while also adding robust, linear-time scanning for sub-composition mounts to prevent ReDoS vulnerabilities. The parser now enforces a strict composition timing contract that distinguishes canonical attributes from legacy ones, correctly handles compiler-derived values without false-positive warnings, and exposes a comprehensive color grading contract with validation for professional controls.

packages/parsers/src · high confidence

The helper modules in packages/core/src/studio-api/helpers (including draft markers, finite mutation validation, manual edits render scripts, screenshot clipping, and motion render scripts) have been updated to re-export their implementations from the newly extracted @hyperframes/studio-server package. This change reflects the architectural separation of Studio-specific logic from the core package, ensuring that consumers of these helpers continue to work while the underlying implementation resides in the dedicated studio-server module.

packages/core/src/studio-api/helpers · high confidence

The studio-server logic is now a distinct \@hyperframes/studio-server\ package, exposing specific modules (such as \screenshot-clip\, \proxy-transcoder\, and \media-proxy-preview\) via a \package-subpaths.json\ configuration. This extraction introduces robust file safety mechanisms: writes are now performed atomically to prevent corruption, and a backup journal automatically snapshots files before they are overwritten to support undo and history operations. The server's API is structured around a Hono app that registers dedicated routes for projects, files, previews, media, and history, ensuring that edits and media processing are handled with strict concurrency and version control.

packages/studio-server · high confidence

The audio FX engine in the core package has been rebuilt to ensure preview and offline render behave identically. Automation envelopes are now scheduled via native AudioParam ramps and curves, guaranteeing sample-accurate timing and correct handling of bends, mid-segment starts, and playback-rate changes. FX tail calculation has been improved to account for automation-driven wetness and serial chain interactions, preventing reverb and delay tails from being cut off during render. Worklet processors now support explicit disposal to prevent audio-thread leaks, and LFOs for chorus and phaser are properly phased and unwired on dispose. Additionally, a new pitch-shift worklet is included, and the FX graph builder supports dynamic parameter updates without full rebuilds for immediate knob-to-ear feedback.

packages/core/src/audio · high confidence

The blank template in the CLI has been updated to provide a fully formed HTML5 document structure, including proper doctype, head metadata, and embedded styles. This ensures that generated projects start with a valid, self-contained page rather than a fragment, improving compatibility with browsers and development tools out of the box.

packages/cli/src/templates/blank · high confidence

The producer build process now embeds font data at build time rather than requiring it at runtime, eliminating the dependency on @fontsource packages in the final bundle. Additionally, the CI regression workflow no longer relies on a manually maintained shard matrix; a new script automatically discovers test fixtures and computes an optimized shard distribution based on recorded timings, ensuring all fixtures are accounted for and preventing silent test drift.

packages/producer/scripts · high confidence

The CLI build process now uses dedicated Node.js scripts to replace fragile shell commands, ensuring cross-platform compatibility (fixing Windows build failures) and correct packaging of runtime artifacts. This includes bundling the beat-detection analyzer for headless use, copying pre-built player and slideshow bundles so \present\ and \play\ commands work from npm, and shipping the runtime manifest alongside the CLI. A new skills manifest generator ensures deterministic skill content hashes, while an agent directory synchronizer mirrors upstream agent configurations for global skill installation. Additionally, test execution is isolated by using a temporary home directory, preventing interference with the user's actual configuration.

packages/cli/scripts · high confidence

The CLI registry installer now records SHA-256 hashes of installed files in a \hyperframes.lock.json\ manifest. On subsequent installs, it compares the manifest against the current disk state to detect local edits; if a file has been modified by the user, the installer preserves the local version instead of overwriting it, unless the \--force\ flag is used. Additionally, the installer now validates registry items against \minCliVersion\ and \deprecated\ metadata before installation, blocking installs of items that require a newer CLI version and surfacing deprecation warnings.

packages/cli/src/registry · high confidence

The CLI render command has been restructured into distinct plan, execute, and presentation phases, introducing several new capabilities and fixes. Users can now output to HLS format with configurable segment lengths, and segmented capture supports resuming prior renders and keeping segment files. The command now reports which catalog items were actually used in a render, rejects unsupported ProRes rate controls, and forwards GIF and frame-format options in batch renders. Startup lint output is collapsed to a one-line summary, and default quality settings for BeginFrame, agent blank, and looks have been updated.

packages/cli/src/commands/render · high confidence

The editing core now owns the logic for determining which UI sections and capabilities (select, edit styles, move, resize, crop, etc.) are available for a given element. This is implemented via a new \resolveEditingAffordances\ function in \packages/core/src/editing/affordances.ts\ that takes normalized element facts and returns capability flags and section applicability (e.g., layout, style, media, color grading, timing, animation, audio FX). The system gates layout and style sections on elements having a rendered box (excluding audio), supports non-destructive cropping for sub-composition hosts, and prevents editing for locked compositions or script-generated elements. A new \draftMarkers.ts\ module defines browser-safe CSS property constants for studio offset and size, and comprehensive tests in \affordances.test.ts\ validate the behavior across various element states.

packages/core/src/editing · high confidence

The cloud CLI now automatically detects the aspect ratio from composition dimensions when the --aspect-ratio flag is omitted, ensuring rendered output preserves the intended shape without manual configuration. Download failures no longer overwrite existing files, preserving previous renders when network errors or truncation occur. API error messages are now standardized with actionable hints for common issues like rate limits and oversized projects. Authentication is more resilient, with automatic token refresh on 401 errors to handle server-side revocations or clock skew. CLI flag parsing is stricter, rejecting invalid inputs like trailing garbage in numeric values. ANSI escape sequences are now properly handled for accurate text alignment in output.

packages/cli/src/cloud · high confidence

The theming system now enforces a strict 18-token contract (covering palette, typography, spacing, and motion) that theme packs must define in a single :root block, ensuring consistent composition scoping and preventing primitive HTML from leaking global declarations. This change introduces three new default themes—Bold, Editorial, and Neutral—each implementing this contract with distinct visual styles, and documents the rules for token usage and one-off violations in a new CONTRACT.md guide.

themes · high confidence

The @hyperframes/lint package now includes explicit configuration for its build process and module exports. A new package-subpaths.json file defines export paths for the main entry, a browser-specific entry, and the package.json itself, specifying supported environments (Node, Bun, Browser). The tsup.config.ts sets up dual builds: one for Node.js (targeting node22) and a browser-safe build (targeting es2022) that prevents Node.js builtins from leaking into the browser bundle. Additionally, a tsconfig.json standardizes TypeScript compilation settings, and a vitest.config.ts configures tests to run in a jsdom environment.

packages/lint · high confidence

The linting rules in packages/lint/src/rules now enforce that compositions using GSAP, Lottie, or Three.js include the corresponding script tags, preventing silent rendering failures. Additionally, new caption-specific rules ensure karaoke and subtitle animations use deterministic hard kills to prevent stuck text, warn about potential text overflow, and prevent layout-breaking CSS properties like relative positioning or overflow clipping on scaled words.

packages/lint/src/rules · high confidence

The linting functionality has been extracted from the core package into a dedicated @hyperframes/lint package. The core package now re-exports the linting logic from this new location, and users should update their imports to use @hyperframes/lint directly to avoid deprecation warnings.

packages/core/src/lint · high confidence

The liquid-glass-notification and liquid-glass-widgets blocks have been rewritten to render their effects via a dedicated WebGL canvas (LiquidGlassCanvas) and GPU shaders instead of previous methods. This change introduces hardware-accelerated rendering for the glass effect, including a 9-tap Gaussian blur and a core glass shader that handles refraction, chromatic aberration, edge highlighting, and beveling, while exposing the same CSS property map and default configuration options to users.

registry/blocks/liquid-glass-notification, registry/blocks/liquid-glass-widgets · high confidence

The CLI now includes a dedicated UI layer that displays a gradient ASCII banner on startup, routes all diagnostic messages (notices, warnings) to stderr to prevent corruption of machine-readable stdout output, and formats render summaries to clearly distinguish between output video length and wall-clock render time. Progress updates are now streamed as line-delimited output when running in non-TTY environments, and a new helper explains why Linux users may fall back to slower screenshot capture.

packages/cli/src/ui · high confidence

The studio API module in the core package is now a deprecated re-export of the newly extracted @hyperframes/studio-server package. Users importing from this location will see a deprecation warning and should update their imports to use @hyperframes/studio-server directly.

packages/core/src/studio-api · high confidence

The CLI's template system has been updated to fetch and install remote examples from the registry in addition to bundled templates. When a user initializes a project, the CLI now merges locally bundled options (like the 'Blank' template) with remote examples fetched from the registry. Crucially, the remote template installation process now resolves and installs transitive dependencies automatically, ensuring that templates relying on other registry items are fully functional. Compatibility checks are applied before installation to prevent errors, and the system verifies that the installed template contains a valid \index.html\ file.

packages/cli/src/templates · high confidence

The CLI now uses a centralized provider resolution system for voice and music generation that mirrors the media-use skill's priority order. For voice, it prefers HeyGen, then ElevenLabs, and finally falls back to the local Kokoro engine; for music, it prefers HeyGen, then Lyria, and falls back to the local MusicGen engine. The system automatically detects available cloud keys and local Python dependencies, providing specific pip installation hints if a local fallback is selected but its dependencies are missing.

packages/cli/src/audio · high confidence

A new \frame-packets-core.mjs\ module has been added to the \skills/general-video/scripts/lib\ directory. This module provides core utilities for processing video storyboards, including functions to split storyboards into frames, extract frame IDs, resolve blueprint and motion rule references, and build bounded frame packets. It also includes CLI execution logic to run these operations, ensuring that script imports remain within installed skill directories as intended by the fix.

skills/general-video/scripts · high confidence

The media processing engine now correctly handles animated GIFs by parsing their metadata (frame count, delays, loop count) and managing frame disposal logic. This ensures that GIFs with mixed RGB and transparent frames render correctly without visual artifacts, and that frame delays adhere to browser playback standards (clamping zero delays to the minimum).

packages/core/src/media · high confidence

The CLI binaries \hyperframes\ and \hyperframes-localize-fonts\ now check the running Node.js version before executing. If the version is unsupported, the tool exits immediately with a clear error message instead of failing later in an undefined way, ensuring users are notified of runtime incompatibilities upfront.

packages/cli/bin · high confidence

The faceless-explainer scripts now include a dedicated asset staging step that copies frame-named assets (images, videos, SVGs, screenshots) from capture directories into the project assets folder, ensuring they are available for rendering. Captured font subsets are now preserved and copied to assets/fonts, maintaining the original typography. Additionally, frame internal durations are padded to match the wrapper's transition duration, preventing content from vanishing abruptly during outgoing transitions. The pipeline also supports configurable video dimensions (landscape, portrait, square) and uses a vendored storyboard parser and transition registry to handle frame packing and animation effects consistently.

skills/faceless-explainer/scripts · high confidence

The CLI preview server now binds to loopback (127.0.0.1) by default to prevent unintended LAN exposure, and port-availability probes run sequentially to eliminate cross-platform race conditions that previously caused false port conflicts. File watching is more robust, correctly handling atomic saves, inotify limits, and generated caches, while runtime and bundle file reads are pinned to prevent stale content during replacements. Additionally, Studio-triggered renders now emit structured telemetry with full performance breakdowns and respect user opt-out preferences, ensuring accurate analytics and privacy compliance.

packages/cli/src/server · high confidence

The render pipeline now uses an \ArtifactTransaction\ system to atomically promote output files and directories, ensuring that partial or failed renders do not corrupt existing artifacts. Additionally, a new \audioPadTrim\ helper corrects audio duration drift by padding or trimming mixed audio to match the video's exact frame count, preventing silent audio cuts or frozen final frames in the final output.

packages/producer/src/services/render · high confidence

The producer now injects an early stub script into the page head that intercepts GSAP timeline operations. Instead of executing thousands of tween calls synchronously—which previously caused main-thread hangs and navigation timeouts—the stub batches these calls and drains them via requestAnimationFrame. This ensures the page remains responsive and DOMContentLoaded fires promptly, even for compositions with very large numbers of tweens.

packages/producer/src/generated, packages/producer/stubs · high confidence

Added TypeGPU/WebGPU adapter regression baseline; Added WebM transparency regression test; Added audio mux stream parity regression test; Added browser integration tests for engine scripts; Added chunk-boundary regression tests for animation adapters; Added contract tests for the Send-to guide fidelity and pricing instructions; Added distributed png-sequence test fixture; Added end-to-end regression test for the variables system; Added long-form render test fixtures and manual gate documentation; Added mp4 H.265 SDR distributed test fixture; Added parallel capture regression test suite; Added parity regression test fixtures and documentation; Added regression test fixture for VFR screen-recording freeze bug; Added regression test fixture for style-13-prod; Added regression test fixtures for style-2-prod; Added regression test for CDN script inlining; Added regression test for CDP viewport edge clipping on tall portrait compositions; Added regression test for GSAP call side effects during render seeks; Added regression test for HeyGen promo preview asset URL rewriting; Added regression test for Picture-in-Picture video timing in late-starting sub-compositions; Added regression test for SwiftShader layer persistence during GSAP yoyo animations; Added regression test for WYSIWYG sub-component CSS scoping; Added regression test for WebGL video texture rendering in headless mode; Added regression test for depth-3 nested sub-composition inlining; Added regression test for fast-capture GSAP animation rendering; Added regression test for id-less video rendering; Added regression test for id-less video rendering in sub-compositions; Added regression test for multi-composition montage with overlays; Added regression test for nested template video timing; Added regression test for page-side shader compositor capture; Added regression test for partial color metadata in Plan v2; Added regression test for rapid text and audio transitions; Added regression test for speed ramp rendering; Added regression test for static audio volume not affecting nested composition visibility; Added regression test for sub-composition height centering; Added regression test for sub-composition timeline activation; Added regression test for symlinked asset rendering; Added regression test for video sub-composition phantom duplicate; Added regression test suite for GSAP letters rendering compatibility; Added regression tests for CSS spinner and 3D capture rendering; Added regression tests for iframe and requestAnimationFrame render compatibility; Added regression tests for the D3.js runtime adapter; Added regression tests for the anime.js v4 runtime adapter; Added regression tests for video overlay geometry and style-9-prod fixture; Added smoke test for WebM VP9 concat-copy encoding; Added test assets and compliance reviews for style-1-prod; Added test baselines for chat and vignelli-stacking scenarios; Added test baselines for video composition with captions; Added test fixture for anime.js chunk-boundary validation; Added test fixture for missing host composition ID scenario; Added test fixture for unreproducible compositor shift; Added test fixtures for style-7, style-12, and style-18 producer themes; Added test for CSS var() font-family resolution; Added test for bare fragment sub-composition rendering; Added test for deferred Three.js WebGL boundary composition; Added test for font-variant-numeric layout stability; Added test harness for TypeGPU/WebGPU adapter; Added tests for playback rate audio-video parity; Added tests for the generated position-edits render script; Added visual regression test for Three.js WebGL boundary with GSAP batching; CLI test isolation, Node version enforcement, and diagnostic stamping; New player performance test infrastructure and scenarios; New telemetry tests for agent runtime detection, canary rollouts, and client policy; Regression test for sub-composition root class selector scoping; Updated regression test baselines for style-7-prod; Updated style-1-prod test baseline with embedded fonts; Updated style-12-prod test baseline; Updated test baseline for missing host component ID scenario.

The project initializes as a Bun-based monorepo with 22 workspace packages, establishing the foundational dependency graph. Key tooling includes Vitest v4 for testing, TypeScript v5, and oxlint/oxfmt for linting and formatting. The core rendering stack relies on Puppeteer v25 and Hono v4, while the CLI and AWS Lambda adapter integrate Google's @google/genai SDK and AWS CDK constructs. React v19 is explicitly pinned across the workspace to ensure type compatibility.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 36 → 46 (+10.3)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 67 → 62 (-4.8)
• Architecture 56 → 82 (+25.8)
• Maturity 58 → 78 (+19.8)
• Readiness 20 → 34 (+13.1)
• Security 40 → 66 (+25.7)
• Accessibility 48 (new)
• Performance 60 (new)

• Critical CVE: [GHSA redacted] (bun.lock)
• Critical CVE: [GHSA redacted] (bun.lock)
• Critical CVE: [GHSA redacted] (bun.lock)
• Dimension evaluation failed
• High CVE: [GHSA redacted] (bun.lock)
• High CVE: [GHSA redacted] (bun.lock)
• High CVE: [GHSA redacted] (bun.lock)
• High CVE: [GHSA redacted] (bun.lock)
• High CVE: [GHSA redacted] (bun.lock)
• High CVE: [GHSA redacted] (bun.lock)
• High CVE: [GHSA redacted] (bun.lock)
• High CVE: [GHSA redacted] (bun.lock)
• High CVE: [GHSA redacted] (bun.lock)
• High CVE: [GHSA redacted] (bun.lock)
• High CVE: [GHSA redacted] (bun.lock)
• High CVE: [GHSA redacted] (bun.lock)
• High CVE: [GHSA redacted] (bun.lock)
• High CVE: [GHSA redacted] (bun.lock)
• High CVE: [GHSA redacted] (bun.lock)
• High CVE: [GHSA redacted] (bun.lock)
• …and 164 more

• (anonymous) (cognitive 22) (packages/cli/src/commands/motion-sample.browser.js)
• (anonymous) (cyclomatic 20) (packages/cli/src/commands/motion-sample.browser.js)
• (anonymous)::arcHubForSvg (cognitive 20) (packages/cli/src/commands/layout-audit.browser.js)
• (anonymous)::auditLayout (cognitive 16) (packages/cli/src/commands/layout-audit.browser.js)
• (anonymous)::collectGeometryCandidates (cognitive 19) (packages/cli/src/commands/layout-audit.browser.js)
• (anonymous)::collectOffPivotRotationSample (cognitive 35) (packages/cli/src/commands/layout-audit.browser.js)
• (anonymous)::collectOffPivotRotationSample (cyclomatic 23) (packages/cli/src/commands/layout-audit.browser.js)
• (anonymous)::connectorDetachmentIssues (cognitive 41) (packages/cli/src/commands/layout-audit.browser.js)
• (anonymous)::connectorDetachmentIssues (cyclomatic 23) (packages/cli/src/commands/layout-audit.browser.js)
• (anonymous)::connectorOrphanIssues (cognitive 59) (packages/cli/src/commands/layout-audit.browser.js)
• (anonymous)::connectorOrphanIssues (cyclomatic 22) (packages/cli/src/commands/layout-audit.browser.js)
• (anonymous)::containerOverflowIssues (cognitive 21) (packages/cli/src/commands/layout-audit.browser.js)
• (anonymous)::escapedContainerIssues (cognitive 16) (packages/cli/src/commands/layout-audit.browser.js)
• (anonymous)::imageAlphaAt (cognitive 18) (packages/cli/src/commands/layout-audit.browser.js)
• (anonymous)::imageAlphaAt (cyclomatic 21) (packages/cli/src/commands/layout-audit.browser.js)
• (anonymous)::objectPositionOffsets (cognitive 17) (packages/cli/src/commands/layout-audit.browser.js)
• (anonymous)::panelOutOfCanvasIssues (cognitive 24) (packages/cli/src/commands/layout-audit.browser.js)
• (anonymous)::textOverflowFixHint (cyclomatic 17) (packages/cli/src/commands/layout-audit.browser.js)
• (anonymous)::textOverflowIssues (cyclomatic 16) (packages/cli/src/commands/layout-audit.browser.js)
• AnimationCard.AnimationCard (cognitive 36) (packages/studio/src/components/editor/AnimationCard.tsx)
• …and 2575 more

• 300 commits — 135 feature/other, 165 fixes

• packages/studio — 69 commits
• packages/core — 43 commits
• packages/cli — 37 commits
• packages/studio-server — 26 commits
• .claude-plugin/plugin.json — 22 commits
• (root) — 13 commits
• .github/workflows — 13 commits
• packages/producer — 13 commits
• packages/engine — 12 commits
• (repo) — 8 commits
• packages/lint — 8 commits
• registry/blocks — 7 commits
• packages/shader-transitions — 5 commits
• packages/player — 4 commits
• registry/components — 3 commits
• docs/changelog.mdx — 2 commits
• skills/media-use — 2 commits
• docs/catalog — 1 commit
• docs/examples.mdx — 1 commit
• docs/guides — 1 commit

• fix: Merge pull request #4368 from heygen-com/fix/ffprobe-nb-frames-duration-crosscheck
• fix: ci(regression): rebalance shards on current fixture timings (#4472)
• fix: fix(catalog): regenerating the texture-mask page no longer duplicates its section (#4302)
• fix: fix(catalog): registry set-delta check accepts intentional additions (#4287)
• fix: fix(ci): required checks fail instead of skipping when a job they need fails (#4470)
• fix: fix(ci): scope catalog dispatch and fail closed on detection errors (#4347)
• fix: fix(cli): --yes in an unattended run no longer overrides a no saved by another process (#4547)
• fix: fix(cli): Studio's catalog install records the item and honours paths, as add does (#4573)
• fix: fix(cli): a failed command sends one error report, naming its real cause (#4586)
• fix: fix(cli): add --vars refuses a value of the wrong type instead of writing it (#4369)
• fix: fix(cli): an update never replaces the CLI's files while a hyperframes command is running (#4637)
• fix: fix(cli): catalog --json carries each item's preview video and poster (#4443)
• fix: fix(cli): commands exit right away even when the network or DNS is broken (#4604)
• fix: fix(cli): keep live reload working after an atomic save on Linux (#4346)
• fix: fix(cli): render --quiet stops printing producer info and trace lines (#4478)
• fix: fix(cli): replace pre-planted links when writing capture files (#4298)
• fix: fix(cli): require non-empty feedback repro commands (#4263)
• fix: fix(cli): snapshot shows a short video's last frame instead of going black (#4552)
• fix: fix(cli): stop background update and skills checks from holding a finished command open (#4556)
• fix: fix(cli): stop check --at false alarms and name a stale CLI version (#4417)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

heygen-com/hyperframes was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.