[pull] main from heygen-com:main - #322
Merged
Merged
Conversation
…#3561) * fix(capture): let vision captioning authenticate the way a server can Three defects in one phase, all of which end with a capture that reports "Captioned N/N images" and then "0 images captioned with Gemini" — a successful-looking run that hands the agent nothing to see by. 1. Credential. The captioner only accepted an API key. A server deployment holds a service account, not a key, and a rejected key is indistinguishable from an unset one here: every request returns empty text and no error. Vertex is now a first-class provider, ranked above the bare key and below an explicit OPENROUTER_API_KEY opt-in, configured by HYPERFRAMES_VERTEX_SERVICE_ACCOUNT + HYPERFRAMES_VERTEX_PROJECT_ID (region via HYPERFRAMES_VERTEX_LOCATION). It carries its own model default because the Gemini API's flash-lite preview id is not resolvable on Vertex. 2. Empty captions. Thinking tokens are drawn from maxOutputTokens, so a model left free to think can spend the whole budget and return no text — a successful request with no caption. thinkingBudget is pinned to 0; a one-line factual caption needs no reasoning. 3. Native abort. Rasterizing a batch of SVGs concurrently drove up to SVG_BATCH simultaneous librsvg renders through libvips and corrupted the heap: `free(): unaligned chunk detected in tcache 2` (SIGABRT) during this phase, twice in fourteen days, losing the whole capture each time. A native abort cannot be caught, so the concurrency is removed rather than handled — rasterization is serialized and libvips' worker pool is bounded, while the vision requests, which are the slow leg, stay parallel. Throughput barely moves: 225 captions across three real captures, 0 failures, 13-25s each. * test(capture): pin the rasterization loop to one render at a time The serialization fix shipped without a regression test on the grounds that native heap corruption is not unit-testable. The corruption is not, but the property that prevents it is: `sharp` is mocked to record how many renders are in flight, and a six-SVG batch must never reach two. A deliberately slow caption stub makes overlapping renders the faster path, so a future refactor that "optimises" the loop back to `Promise.all` fails here instead of aborting in production. Also covered: `sharp.concurrency(1)` is applied — serializing the loop while leaving libvips' pool at the host core count still fans one render across every core — and an unrasterizable SVG is skipped without breaking serialization for its siblings. Verified as a real guard: reverting only contentExtractor.ts to origin/main fails 7 of the 22 cases in this file. * fix(capture): tell the truth in the asset-descriptions header when Vertex captioned The provider gate in `contentExtractor` accepts Vertex when a project and a service account are both set -- which is the configuration a server deployment actually has. The header written next to the captions still tested only for an API key, so a capture whose captions Vertex had just generated was labelled "GEMINI_API_KEY not set -- descriptions below are catalog-derived". That header is not cosmetic: it travels into the context the template editor reads, telling it to distrust captions that are real. Mirror the same two variables here, and name every provider in the fallback text instead of only the API key. * fix(capture): hand libvips' worker pool back after the renders `sharp.concurrency(1)` is process-global and was set once, for the whole life of the process. The bound is right for the rasterize loop -- a native abort in libvips cannot be caught, so the renders must not overlap -- but its scope was every later sharp caller in the process, none of which asked for captioning, all of them pinned to one thread from then on. Now the host's value is read first and restored in a `finally` around the rasterize loop, so a skipped SVG cannot cost the process its threads either. The vision requests below are network work and gain nothing from a pinned pool. The mock had to grow the getter half of sharp's API -- `concurrency()` with no argument reports the current value -- since save-and-restore is untestable without it. Verified as a real guard: dropping only the restore fails both new cases. Raised by Rames Jusso in review of #3561 and concurred by Magi.
…they sit (#3562) * feat(registry): say what a promoted template's slots mean, not where they sit Every declaration described its slot by position — appName was "small credit in the corner of every banner" — and every editing contract described the supplied brand only by what it may not touch, chatgpt-exchange going as far as "only the subject discussed inside the conversation". An agent filling those slots has nothing telling it that the video is an advertisement for that brand, and remixes shipped with an invented brand instead of the real one. Adds `portrays` to the 35 identity-bearing variables across seven templates: what the slot stands for, as a list, kept orthogonal to `role` (which says which aspect of the composition a knob affects, not what a value means to a viewer). Rewrites those variables' descriptions to state meaning, and gives every TEMPLATE.md the affirmative sentence it was missing. notes-reveal now records honestly that it declares no identity slot at all, which is why a remix of it cannot carry a brand. `portrays` is optional metadata: rendering ignores it, the promoted contract still projects {id, type, role}, and packages that predate it keep working. Variable ids, types, roles, labels, and defaults are untouched, so installs and renders see the same contract. * feat(notes-reveal): give the template somewhere to say whose ad it is This was the one promoted template that declared no identity slot at all, and the previous commit could only record that honestly. A remix of it could not name the advertiser, could not carry its domain, and had nowhere to place its mark — so the ad it produced was unattributable no matter how good the copy was. The closing card ends at y=1708, leaving 212px of dotted scene. A sign-off strip lives there: `brandLogo` (portrays subject_logo) above `brandDomain` (portrays subject_domain), in the card's own plum and Courier Prime. Putting it outside the card means the hand-lettered headline and the checklist keep the geometry they were designed with — verified by `hyperframes check`, which reports the same 0 errors and the same warning counts as origin/main, with one more contrast check (367/367 AA). No name slot: this template has no text slot that can hold a bare brand name. `cardTop`'s marker line continues into the fixed words "OF ONE FILE", and a name set beside a wordmark reads twice — rendering it proved that before this was committed. The mark plus the domain carry the attribution, which is what the other end-card templates do. Rendered to check rather than assumed: the packaged default reads as the HyperFrames wordmark over hyperframes.heygen.com, and a resolved symbol mark (Notion's cube over notion.com) sits correctly in the same strip. * fix(notes-reveal): make the note the ad, and stop the headline leaving the card Three defects, all visible in the reported gamma remix. The seven body lines carried their characters as pre-split `<span class="ch">` elements so the reveal animation could address them by id. That made the note permanently unwritable: 46% of the 24.9s runtime, and the only place the note says anything, was fixed copy about making videos with HyperFrames -- shipped inside an advertisement for a Dutch DIY chain. The spans are now built at runtime from seven declared variables, keeping the same ids, so the animation is untouched and the copy is the brand's. `cardMid` and `cardBottom` ("OF", "ONE FILE") were literals with no variable at all, so a remix could only ever change the first of the card's three lines. Every text slot sat at a fixed left edge on one line, guarded only by a character cap -- the wrong unit. `cardTop` allowed 12 characters; "THE POWER" (9) fits and "CREATE DECKS" (12) does not, which is why both reported gamma remixes shipped with the closing headline over the edge of the card. Slots are now fitted to their box at render time, shrinking type only as far as needed and never past the designed size. The card headlines also carried `data-layout-allow-overflow`, switching off the one check that would have caught it; those waivers are gone. The note's title and body keep theirs, because `#note-body` is translated across the whole scene and leaves the canvas by design. Timing is preserved rather than regenerated: each body line is revealed inside the frame window the packaged rhythm already used, so `JUMPS` and the hand-tuned `SCROLLS` curves stay valid and the composition is still 24.867s for any length of copy. A line whose length matches the packaged copy keeps its rhythm frame for frame. Verified: rendered with the packaged defaults, SSIM 1.000000 across all 746 frames against the previous template -- the design is bit-identical. Rendered with the gamma values that overflowed, and with a stress set of long and one-word values: both stay inside the card and the note, both still 24.867s. `hyperframes check` passes, with layout warnings down from 28 to 8 and no new issue class. Note that `check` takes no variable values, so it guards the template's defaults and the fit is what guards a remix. * fix(notes-reveal): make the fit floor and the character caps agree A cap that admits a string still too wide at the floor font size puts the text back outside its box -- the exact bug the fit was added for. With the floor at 0.6 and the title cap at 40, a 40-character title still overflowed `#note-body` by 30px, because "Things nobody told me" is 21 characters and 900px at 88px, so 42.9px per character, and 40 characters need to reach about 0.45 of the design size to fit. Floor to 0.45 and the caps in: titles 34, body lines 52, cardTop and cardBottom 16. Every cap is now satisfiable with room to spare, and the common case stays far from the floor. Found by probing all eight promoted templates with values about 1.8x the length of their packaged defaults, which is the length a real remix produces; short sentinel values only ever prove a slot is wired. Defaults are unaffected: SSIM 1.000000 across all 746 frames, still 24.867s, `hyperframes check` still passes. * fix(exchange): scroll the composer to follow the caret `prompt` is an editable slot in both templates, but `.comp-text` is a fixed-width single line with `white-space: pre` inside a composer that clips, and the packaged prompt already reaches the mic -- it has no headroom at all. A longer prompt therefore slid under the mic and the send button and lost its tail, with the caret hidden behind them: the remix read as having typed into nowhere, cut mid-word. Both now scroll the typed text left to keep the caret in view, the way a real single-line input does, on the very per-character times the reveal already uses. The limit is measured to the opaque round button rather than the mic, because the packaged prompt's caret already sits 2px past the mic's left edge in chatgpt-exchange -- measuring to the mic would scroll the packaged composition. Shrink-to-fit was the other option and it is worse: with no headroom it shrinks the packaged prompt too, and it still cannot absorb a prompt twice as long without unreadable type. It was tried, measured, and dropped. A prompt that fits emits no keyframes and the element is never handed to GSAP at all -- even a zero translate stamps a transform, which changes how the text rasterizes. claude-exchange puts this inside its existing `build()`, which already re-runs on `document.fonts.ready`, so it measures the final font. chatgpt-exchange builds once, so its scroll keyframes are kept in a list and rebuilt on the same event. Verified on the packaged defaults: claude-exchange SSIM 1.000000 across 1284 frames. chatgpt-exchange is not frame-deterministic -- rendering it twice unchanged gives 0.999959 with 249 frames under 0.9999, and before-vs-after gives 0.999967 with the same 249 -- so the change sits inside its own noise. Durations unchanged at 14.9s and 21.4s. `hyperframes check` reports byte-identical results to the unchanged templates. * fix(notes-reveal): fit the checklist cells instead of counting their characters The three checklist rows were the only text slots with no width fit, so their character cap was doing the job a measurement should: it was set to 8 because that was the widest the packaged strings needed, and a gamma.com remix delivered "DIRECT MEE" and rendered "DIRECT M". Fit the labels and values like every other text slot -- dividing the label's scaleX(0.86) back out of its column, since fitWidth measures the untransformed width -- and return the cap to a backstop at 18. "DIRECT MEE" needs no shrink at all: it ends at x=694 against a tick at x=715, so the truncation was never about room. Measured: the packaged defaults still render at their authored 44px and 50px, and all three values clear the tick. * fix(chatgpt-exchange): nest the caret scroll so its rebuild can be undone `tl.to()` returns the TIMELINE, not the tween it created, so `caretScrollTweens` held 49 references to the master timeline. The fonts-ready rebuild then called `.kill()` on the master timeline 49 times and re-added its keyframes on top of the ones it meant to replace. Measured with an overflowing prompt: master timeline detached from the global timeline (tl.parent -> null) scroll tweens on #cge-typed: 49 before the rebuild, 98 after 49 timestamps left with two competing tweens on the same property GSAP's `Animation.kill()` interrupts and detaches rather than killing children, so the composition kept rendering under an explicit seek -- which is why the packaged-defaults SSIM check passed and never saw this. It is still wrong: the timeline is off the ticker, and the stale keyframes were measured against the fallback font. Only an overflowing prompt reaches it, i.e. exactly the remix the scroll exists for. The packaged prompt emits no steps, so nothing is created and nothing is killed. Now one nested child timeline holds the steps: a real object that can be killed and replaced, and killing it cannot reach `tl`. Children sit at the same absolute times and the nest is added at 0, so the motion is unchanged. Verified: overflowing prompt holds at 49 scroll tweens across the rebuild with no duplicated timestamps and the timeline stays attached. Packaged defaults against the pre-feature baseline -- SSIM 0.999998 over 894 frames, 13 frames below 0.9999 against a 249-frame noise floor for this template, duration 14.9s unchanged. Found by Magi in review of #3562. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> * feat(lint): catch a timeline's return value being treated as a tween Magi asked for a regression that makes the caret-scroll failure unable to return. A render fixture cannot be that guard, and neither can a unit test. Both were measured before choosing this: - The unit-test DOM has no layout. In happy-dom `getBoundingClientRect()` is {left: 0, width: 0} and offsetWidth/offsetLeft are 0, so the template's own guard computes limit = -8 and returns before collecting a single keyframe, whatever the prompt length. `document.fonts` does not exist there either, so the rebuild never runs. Both preconditions are unreachable -- the test would pass on the broken code and the fixed code alike. Rames flagged this; verified. - A render fixture would not fail either. Rendering the long prompt through the real pipeline on the broken vs fixed template gives SSIM 0.999994 over 894 frames with ZERO frames below 0.999. The renderer drives the composition by explicit seek, and the duplicated keyframes are added last so they win, which is exactly why `.kill()` on the master timeline stayed invisible. A golden mp4 would have cost a fixture and a shard and guarded nothing. What is testable is the root cause, and it is a static property: `tl.to()` returns the TIMELINE, `gsap.to()` returns a Tween, and the two read identically. So the guard is a lint rule, which needs no DOM, fires on the source, and covers every composition in the registry rather than this one template. The rule keys on the timeline handles `collectTimelineVarNames` already finds, which is what keeps `gsap.to()` and `Array.from()` out of it. Pushing a timeline return into an array is flagged outright -- that is the collect-to-discard shape. A bound return is flagged only once something tween-scoped is aimed at it, so a pointless-but-harmless capture stays quiet. Verified against the real files, not just synthetic ones: the pre-fix chatgpt-exchange raises exactly one error and names the offending line; the fixed file is clean. Across all 642 HTML files under registry/ and examples/ the rule finds nothing, and lint output on the eight promoted blocks is identical to origin/main error-for-error and warning-for-warning, so error severity costs no existing template. 540 lint tests pass, 6 of them new. Requested by Magi in review of #3562; unit-test DOM measurement by Rames Jusso.
#3587) The ENAMETOOLONG regression writes 150 real clip files and the mixer existence-checks each one: ~58ms on Linux, but past vitest's 5s default on the Windows lane. packages/engine sets no global testTimeout, so heavy tests here carry an explicit one. On timeout its abandoned async work kept calling the shared runFfmpegMock after afterEach cleared it, so the next test saw 5 calls instead of 3 and lost its queued once-implementations to the leak. mockReset stops an aborted test from handing leftovers to the next one.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to subscribe to this conversation on GitHub.
Already have an account?
Sign in.
3 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
See Commits and Changes for more details.
Created by
pull[bot] (v2.0.0-alpha.4)
Can you help keep this open source service alive? 💖 Please sponsor : )