Przejdź do treści
Biblioteka skilli
Marketing i treści · Nauka i wyjaśnianie

hyperframes-core

/hyperframes-core

Opisuje kontrakt kompozycji HyperFrames: atrybuty czasowe data-*, ścieżki, podkompozycje i zasady deterministycznego renderowania.

Repozytorium
vidmuse-plugin ↗
Licencja
MIT
Ostatnia zmiana repozytorium
10.10.2026

Ocena i bezpieczeństwo

90/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść25 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
19
Skrypty
1
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 10.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • 1 skrypt w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: scripts/lib/frame-packets-core.mjs

Co robi i kiedy

Opisuje kontrakt kompozycji HyperFrames: atrybuty czasowe data-*, ścieżki, podkompozycje i zasady deterministycznego renderowania.

Wyzwalacze z opisu

clip
Oryginalny opis (EN)

The HyperFrames composition contract for VidMuse — build one renderable project. Use for composition structure, the `data-*` timing attributes, `class="clip"`, tracks, sub-compositions, variables, framework-owned media playback, deterministic-render rules, and validation without starting HyperFrames Studio/timeline UI or using HyperFrames-managed AI/media models. Read before writing composition HTML.

Jak działa

  1. References
  2. Building a composition
  3. Editing existing compositions
  4. Validation
Sekcje z nagłówków SKILL.md, w oryginale · 88 linii, 1 098 słów
Podgląd SKILL.md
---
name: hyperframes-core
description: The HyperFrames composition contract for VidMuse — build one renderable project. Use for composition structure, the `data-*` timing attributes, `class="clip"`, tracks, sub-compositions, variables, framework-owned media playback, deterministic-render rules, and validation without starting HyperFrames Studio/timeline UI or using HyperFrames-managed AI/media models. Read before writing composition HTML.
---

# HyperFrames Core

HyperFrames renders video from HTML. A composition is an HTML file whose DOM declares timing with `data-*` attributes, whose animation runtime is seekable, and whose media playback is owned by the framework.

This skill is the **technical contract** — how to build one HyperFrames project. The body below is the build guide; per-topic detail lives in `references/` (index next), read on demand. Other concerns live in `hyperframes-animation`, `hyperframes-cli`, `hyperframes-registry`, `vidmuse-design`, and `vidmuse-media`.

**VidMuse boundary:** never start HyperFrames Studio, `preview`, `beats`, or its timeline UI. Never select, download, cache, or execute HyperFrames-managed AI/media models. GSAP's paused code timeline and 3D geometry models remain valid composition mechanics.

## References

| File                                 | Read it to…                                                                                                                                                                        |
| ------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `references/minimal-composition.md`  | start from the smallest renderable composition skeleton                                                                                                                            |
| `references/composition-patterns.md` | choose monolithic vs modular; structure a modular `index.html`; pick a sub-comp archetype                                                                                          |
| `references/data-attributes.md`      | look up any `data-*` (root / clip / sub-comp host / legacy aliases); use `class="clip"`                                                                                            |
| `references/tracks-and-clips.md`     | pick `data-track-index`, handle same-track overlap / z-index, time a clip relative to another                                                                                      |
| `references/sub-compositions.md`     | wire a sub-composition (host attrs, `<template>`, per-instance vars) and animate inside it                                                                                         |
| `references/variables-and-media.md`  | declare variables; place `<video>`/`<audio>`, set volume, trim                                                                                                                     |
| `references/determinism-rules.md`    | build a seekable timeline; determinism bans; the animatable-property allowlist; layout / text fit                                                                                  |
| `references/full-screen-motion.md`   | author full-frame motion with shared backgrounds                                                                                                                                   |
| `references/storyboard-format.md`    | author a `STORYBOARD.md` plan (+ the parsed manifest)                                                                                                                              |
| `references/review-loop.md`          | run the plan → sketch → build review passes with text and snapshots                                                                                                                 |
| `references/production-loop.md`      | take an approved plan to a delivered video — the stage dependencies (audio, frames, assembly, transitions, captions, verify, deliver) a freeform build follows directly            |
| `references/brief-contract.md`       | the brief's ground rules — mode derivation (collaborative / autonomous), shared field registry, question invariants (the asking itself lives in `/hyperframes` → the intent layer) |
| `references/brief-format.md`         | author `BRIEF.md` — the confirmed intent document a workflow's Setup writes and every later step reads                                                                             |
| `references/script-format.md`        | author the optional `SCRIPT.md` locked narration                                                                                                                                   |
| `references/subagent-dispatch.md`    | map subagent dispatch verbs (parallel fan-out / background / wait) to your harness                                                                                                 |
| `references/frame-worker-core.md`    | the shared frame-worker role contract — each narrative workflow's packet builder prepends it to that workflow's `sub-agents/frame-worker.md` delta                                 |
| `references/tailwind.md`             | work in a Tailwind v4 project (`init --tailwind`; runtime contract differs from Studio's v3)                                                                                       |

For animation runtime specifics (GSAP API, Lottie, Three.js, etc.) go to `hyperframes-animation` → `adapters/<runtime>.md`.

## Building a composition

### Two root forms (not interchangeable)

- **Standalone** (top-level `index.html`) — root `<div data-composition-id="…">` sits directly in `<body>`, **no `<template>` wrapper** (wrapping it hides all content and breaks rendering).
- **Sub-composition** (loaded via `data-composition-src`) — root **must** be wrapped in `<template>`.

> ⚠ Transport rule: the runtime **only clones `<template>` contents**; everything outside (incl. `<head>` styles/scripts) is discarded — put `<style>`/`<script>` **inside** the template.
> ⚠ Host-id rule: the host slot's `data-composition-id` must **exactly equal** the inner template's `data-composition-id` **and** the `window.__timelines["<id>"]` key — no `-mount`/`-slot`/`-host` suffix.

File shape, host wiring, and the pre-render checklist → `references/sub-compositions.md`.

### Root must be sized (silent layout bug)

The standalone root needs an explicit **sized box** (`width`/`height` in px), and every ancestor down to a `height:100%` element must have a resolved height — otherwise a flex/`100%` child collapses to ~0 and content piles into the top-left corner. Do not rely on automated gates alone to catch this; inspect a snapshot. Skeleton → `references/minimal-composition.md`.

### One paused timeline

Each composition registers **exactly one** `gsap.timeline({ paused: true })` at `window.__timelines["<id>"]` (key = root `data-composition-id`), built **synchronously** at page load. Render duration = root `data-duration`, not timeline length. Don't manually nest sub-timelines into the host. Full contract (incl. non-GSAP runtimes) → `references/determinism-rules.md` + `hyperframes-animation/adapters/`.

### First-pass lint gotchas (a guaranteed first build failure)

Two rules that `lint` **does** catch, but only after the fact — write them right the first time:

- The **root** composition element must carry `data-start="0"` (alongside `data-composition-id`/`data-width`/`data-height`); omitting it fails `lint` with `root_composition_missing_data_start`.
- Never pair a CSS initial `transform` with a GSAP tween on the **same** property — the CSS value and the tween's start fight and `lint` rejects it with `gsap_css_transform_conflict`. Set the initial state inside the tween with `gsap.fromTo(el, { x: -40 }, { x: 0 })` instead of a CSS `transform: translateX(-40px)`.

### Non-negotiable rules (silent bugs automated gates may miss)

Surfaced here; full rationale in the linked reference. Do not violate:

- No render-time clocks / unseeded `Math.random` / network / input-state; no `repeat: -1` (use a finite count). → `determinism-rules.md`
- Animate only the visual-property allowlist; never tween `display` or raw `visibility`. GSAP `autoAlpha` and zero-duration timeline boundary sets are the only visibility exceptions, and only on non-clip elements or wrappers inside a clip. The framework alone controls `.clip` visibility. Do not `gsap.set` later-scene clips at page load. → `determinism-rules.md`
- No `<br>` in body text; transformed elements must be block-level + sized; pulsing absolute decoratives need peak clearance. → `determinism-rules.md`
- `<video>`/`<audio>` work at **any nesting depth** (including inside a sub-comp `<template>` or wrapper); the framework owns playback and seeks/decodes media wherever it lives. The one caveat is timelines, not placement: a sub-comp timeline can't animate host-root elements. → `variables-and-media.md`
- Every `id` must be unique across the **assembled** page; inside a sub-comp, prefix ids with the composition id (`#<id>-hero`). Duplicate `<video>`/`<img>` ids render **blank** — the producer injects frames by `getElementById`, and cross-file dupes slip past `lint`. → `composition-patterns.md`
- A full-screen scene fill goes on a full-bleed **child** (`position:absolute; inset:0`), never on the composition root itself — the producer's frame compositing can drop the root element's own `background` (the frame renders **black**) even though preview/`snapshot` show it correctly. → `composition-patterns.md`

## Editing existing compositions

- Read the files first. Preserve unrelated timing, tracks, IDs, variables, media paths.
- Match existing composition IDs and timeline keys.
- Adding a clip: pick a non-overlapping `data-track-index` or adjust surrounding timing intentionally.
- `data-hidden` on any composition element excludes it from rendered output while preserving the markup for later restoration.
- Adding a sub-composition: verify its internal `data-composition-id` before wiring the host.

## Validation

Use `hyperframes-cli` for command details

- [ ] `npx hyperframes check` passes (0 findings across lint, runtime, layout, motion, and contrast)
- [ ] Projects with sub-compositions: `npx hyperframes snapshot --at <midpoints>` and eyeball each frame
- [ ] Review representative `snapshot` output without starting Studio or a timeline UI
- [ ] `npx hyperframes render` only after the user approves
Pliki w paczce (19)
  • SKILL.md 10 KB
  • references/brief-contract.md 11 KB
  • references/brief-format.md 7 KB
  • references/composition-patterns.md 13 KB
  • references/data-attributes.md 13 KB
  • references/determinism-rules.md 7 KB
  • references/frame-worker-core.md 16 KB
  • references/full-screen-motion.md 3 KB
  • references/minimal-composition.md 2 KB
  • references/production-loop.md 7 KB
  • references/review-loop.md 2 KB
  • references/script-format.md 3 KB
  • references/storyboard-format.md 8 KB
  • references/sub-compositions.md 11 KB
  • references/subagent-dispatch.md 4 KB
  • references/tailwind.md 5 KB
  • references/tracks-and-clips.md 4 KB
  • references/variables-and-media.md 7 KB
  • scripts/lib/frame-packets-core.mjs 7 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · sandai-org/vidmuse-plugin90MIT
jamescai-md/motionframe-edit100MIT
eusilvio/motion-cena100MIT
EthanYoQ/Skill-hub100MIT
jstarfilms/vibecode-protocol-suite100ISC
coco-research/coco90MIT
calesthio/OpenMontage90AGPL-3.0
sma1lboy/rove85MIT

Migawka bazy z 13.11.2026 · wersja paczki 9ec97120af98 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 1 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100cutscene-compose
    Pisze i naprawia HTML projektu wideo Cutscene: strukturę, czasy klipów, ścieżki i bloki z katalogu.
  • 98hyperframes-video-composition
    Składa wideo HyperFrames z wygenerowanych lub źródłowych mediów: plan scen, animacje, napisy, audio, podgląd, zgodność dostępności i dostawę.
  • 100hyperframes-registry
    Instaluje bloki i komponenty z rejestru HyperFrames poleceniem hyperframes add i podłącza je w index.html oraz hyperframes.json.
  • 100hyperframes-production
    Buduje i renderuje deterministyczny film z kompozycji HTML i GSAP w HyperFrames albo we własnym potoku Playwright i FFmpeg, od konfiguracji po lokalny render.
  • 90hyperframes-studio
    Pomaga w projekcie HyperFrames Studio: ocenia, czy zmiana jest potrzebna, planuje scenorys i układa ścieżki na osi czasu.
  • 90hyperframes-studio
    Podpowiada, jak układać oś czasu projektu HyperFrames w Studio, by napisy i kluczowe treści były czytelne.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.