@autoaiai/aicut 0.1.11 → 0.1.13

package/skills/ai-product-video/references/shots/camera/depth-layer-moves.md

@@ -1,40 +0,0 @@
----
-name: depth-layer-moves
-一句话: 分层深度两款运镜——多层视差滑轨（3 层速度梯度横移出纵深）与伪 dolly-zoom（主体钉死、背景膨胀压来）
-适用: 平面截图要"有厚度"的段落；戏剧性蓄力时刻用 dolly-zoom（一支片 ≤1 次）
-时长: 视差滑轨 4–5s 持续；dolly-zoom 3–4s 单向行程
-能量: 视差=中（质感型）；dolly-zoom=中高（压迫感渐强）
----
-
-## 意图
-整页平移是"看页面"，分层深度是"在页面的空间里"。视差滑轨给横移
-加纵深（迪士尼多平面摄影机原理，Linear 片同款质感）；伪 dolly-zoom
-反过来——主角纹丝不动、全世界压过来，给戏剧性时刻蓄力。
-
-## 动效核心
-- **视差滑轨（3 层）**：背景整页（系数 0.35 + blur 2px + 降饱和
-  0.92 + opacity 0.85，退成环境）、中景真实卡切片（系数 0.7，
-  主阅读层，无 blur）、前景浮块（系数 1.4 + blur 3px，掠过镜头）。
-  同一条 drive 位移乘各层系数
-- **伪 dolly-zoom**：主体高清卡固定 px 钉屏中（不参与任何变换）；
-  背景层（整页 + 卡群一体）scale 1→2.25 从画面中心膨胀 + blur 0→3.5px
-  渐深；主体落影随进程加深（12→28px offset）强化"钉住感"
-- 两款都不拆真实页面排版：整页作为一体成层，独立元素用切片另起层
-  ——层间关系是"景深"，不是"页面被撕开"
-
-## 参数表
-| 参数 | 典型值 | 调节手感 |
-|------|--------|----------|
-| 视差层系数 | 0.35 / 0.7 / 1.4 | 梯度 ≥2 倍层间才可辨；层数 ≤4 防过载 |
-| 层次锚 | 前后景 blur + 背景降饱和 | 没有 blur/饱和锚，读作"贴片乱飞" |
-| dolly 膨胀行程 | scale 1→2.0–2.5 | 行程小了压迫感不足；背景 opacity ≤0.6 防读作故障 |
-
-## 已知坑
-- 主阅读层/主体必须高清纹理且无 blur——观众在读它
-- 视差与 PageCam rot 3D 的组合（斜拍视差）未验证，实战先渲 still 确认
-- dolly-zoom 是"戏剧调料"：一支片 ≤1 次，日常段落用视差滑轨
-- 参数经占位素材调校转正，非实战定稿，首次实战后回验
-
-## 参考实现
-demos/camera/depth-layer-moves/
-（DollyZoomReal.tsx / MultiplaneReal.tsx）

package/skills/ai-product-video/references/shots/camera/graze-face-tour.md

@@ -1,57 +0,0 @@
----
-name: graze-face-tour
-一句话: 大倾角贴面游走特写——镜头贴着 UI 表面低飞掠过（侧栏树/顶栏/列表当地形），页面文字初始悬浮在界面上空带同形软影，随镜头行进先后加速贴落回界面
-适用: 功能区巡礼（把 UI 当地景飞掠）；配合暗场+霓虹缘光做产品"内部世界"段落；界面内容逐区登场
-时长: 单段 4–5s；可多段接力延长
-能量: 中高（运镜持续推进+元素连续落位，信息密度高）
-标签: ui-entrance
----
-
-## 意图
-把 UI 拍成地形：大倾角特写让侧栏树、导航、列表行变成掠过的地貌，
-浅景深强化"贴面"。戏眼是**文字空中贴落**：文字/组件不是原地淡入，
-而是悬浮在界面上空（3D z 轴抬高），在空中时往界面投同形软影，
-随镜头行进先后加速贴落、影子随高度收敛消失——观众看见界面在
-镜头经过时"完成自己"。影子是可感命门：没有影子，悬浮读作
-普通位移入场；有影子，空间关系瞬间成立。
-
-## 动效核心
-- 机位：CSS perspective + rotateX/rotateY 大倾角（面几乎侧掠），
-  沿界面一条路径持续推进；浅景深＝远处 blur 渐强
-- 悬浮元素：初始悬浮高度 H≈120–180px（沿面法线方向抬起），
-  easeFall 加速下落+软着陆（落地不回弹或极微回弹）
-- 同形软影：元素原位渲染模糊压暗投影，blur/offset/opacity 全部
-  随当前悬浮高度变化（高＝影大而糊而淡，落地＝影与本体重合消失）
-- 错峰贴落：各元素落地时刻按镜头行进方向排布（先经过的先落），
-  界面在镜头前"依次完成"
-- 长镜可拆段接力：段间用相邻段交叉淡化（判例：透明度窗口不重叠
-  会产生黑闪帧）
-
-## 参数表
-| 参数 | 典型值 | 调节手感 |
-|------|--------|----------|
-| 悬浮高度 | 120–180px | <80px 影子和位移都读不出；>250px 落地砸得太重 |
-| 影子参数 | blur/offset/opacity 随高度线性收敛 | 影子恒定不随高度变＝贴纸感；落地影必须归零 |
-| 贴落错峰 | 按镜头行进方向 0.2→0.85 归一化排布 | 同帧齐落读作开关；乱序落读作 bug；**错峰=错开起点但下落过程重叠并行**，串行等待（一个落完另一个才开始）被裁（runway 判例） |
-| 下落曲线 | easeFall 加速+软着陆 | ease-out 下落读作气球飘落，重力感靠加速 |
-| 段间接力 | 相邻段交叉淡化 ≥8f | 透明度窗口不搭接会黑闪（返工判例 f100 纯黑帧） |
-| 景深 | 远处 blur 渐强 | 全清晰读作平面滚动，浅景深才有"贴面"体感 |
-
-## 已知坑
-- demo 在灰阶/占位素材上调校通过——参数是调校起点非实战定稿，
-  首次实战须以真实素材回验
-- 悬空元素别被环境压黑带吞掉（邻候选 runway 判例）：空中元素
-  需追光/提亮 ~1.3x，否则悬浮状态不可感等于没做
-- 与 space-camera-moves/tension-camera-moves 分工：那两张是相机
-  语言本身；本卡=贴面机位 **+ 元素贴落** 的组合签名，缺一半就
-  改用相机卡
-- **贴落节奏语义判例**（与 neon-frame-orbit-drop 互为反例）：
-  本卡巡礼镜=错峰并行；整体登场镜必须全体同帧齐落（那张卡的
-  错峰版被裁）。选错语法两边都会被裁
-- 原片（clickup-30）是一条连续上行长镜；复刻用三段接力，段落
-  切换藏在交叉淡化里——实战若做真单长镜，路径规划成本高得多
-
-## 参考实现
-demos/camera/graze-face-tour/
-（GrazeFaceTour.tsx）
-原片出处：clickup-30.mp4

package/skills/anidoodle/SKILL.md

@@ -1,185 +0,0 @@
----
-name: anidoodle
-description: "Code-drawn stills, drawing timelapses, films, explainers and interactive web animations in 32 styles, with composed scores. Matches a reference style, keeps characters consistent, teaches drawing. Deterministic, no generated assets. Runs in AICUT: the film is film.html, a page per shot, drawn by `aicut look` and `aicut render`."
-license: Apache-2.0
-source: "alexgreensh/anidoodle"
----
-
-# anidoodle
-
-## Running it in AICUT
-
-AICUT's film is `film.html`: it cuts pages, footage, pictures and sound together on tracks. A page is a web page that
-sets `window.film = { frame(t) }` and draws that moment — no framework, no build step, no composition object, no
-`registerRoot`. Five shots are five pages cut together, not one page that changes scene, so each shot stays trimmable
-and replaceable in Studio.
-
-```sh
-npx -y @autoaiai/aicut@latest          # the manual: the format and the commands, always current
-npx -y @autoaiai/aicut@latest open .   # make this folder a film and print Studio's address
-npx -y @autoaiai/aicut@latest look     # a contact sheet of the whole film, its sound, and a determinism check
-npx -y @autoaiai/aicut@latest look 4.5 # one frame, full size — look at the PNG, not at the code
-npx -y @autoaiai/aicut@latest render   # the MP4, beside film.html
-```
-
-Run the manual before the first film: it is authoritative for the format, and this skill is about the method above it.
-
-Where the words below name another program's part, it becomes this:
-
-| elsewhere | in AICUT |
-|---|---|
-| composition, timeline, project file | `film.html`; tracks and clips inside it |
-| a scene, a sequence, a slide | a page (`pages/<name>.html`) cut onto a track |
-| `useCurrentFrame()`, `interpolate()` | `frame(t)` — the picture depends only on `t`, never on state or `Date.now()` |
-| a still, a screengrab | `aicut look <t>` |
-| `render` / `build` / `export` | `aicut render` (the person can also export from Studio) |
-| a dev server, a preview window | `aicut open` and the Studio address it prints |
-
-Hard rules that hold whatever the method says: the picture depends only on `t`; every value in the person's prompt is
-binding; look at the frames `look` writes before saying a film is done.
-
-
-Pictures, films and interactive pieces drawn entirely in code. One pure function paints every
-frame; another composes the score and plays it. The same source rebuilds the same pixels and the
-same sound on any machine, at any size, at any length. Eight acoustic instruments can play recordings
-of real ones from an optional download. ASK the user before any score work; never download unasked.
-
-The engine is the easy half. Work gets thrown away because it had no point, because the subject
-was an icon of itself, because a style was only a palette swap, because the music had no form,
-or because the person spent their patience approving fragments. This skill carries the craft
-that prevents each of those.
-
-## Start by asking, then build
-
-Read `references/workflows/start-here.md` and run its intake: one question at a time, only
-what the request leaves open, your recommendation first. **What** are they making, in **which
-style** (show the gallery sheet, https://github.com/alexgreensh/anidoodle/blob/main/skills/anidoodle/assets/styles.jpg; the list is `references/styles/INDEX.md`), what
-**shape** (1x1, 9x16, 16x9, 4x5 or any W x H), how **long** (any length; never cap it), what
-**sound** (silent or a music style and mood), which **characters**. "You pick" means pick and
-say why in one line. Write the answers into a short brief before drawing.
-
-## What are you making?
-
-| Making | Read |
-|---|---|
-| A still: hero, spot, cover, card, poster, a series | Still workflow below, `references/formats.md` |
-| A picture that draws itself (timelapse, making-of) | `references/workflows/drawing-process.md` |
-| A loop, sticker, animated logo, ambient header | Loop workflow below, `references/formats.md` |
-| A story film, any length | Film workflow below, `references/workflows/long-film.md` |
-| An explainer or infographic; a machine that comes apart to explain an idea, in any style | `references/workflows/explainer.md`, `references/workflows/machines.md` |
-| A launch or product video (their screenshots welcome) | `references/workflows/launch-video.md`; build it on `references/workflows/launch-video-kit.md`; its claims: `references/workflows/facts.md` |
-| Art for a site (hero by a headline, tiles, spots, share card) on its page colour and brand; or a web animation that reacts to the UI | `references/workflows/site-art.md`; `references/workflows/interactive.md` |
-| A drawing lesson, or "how do I draw this?" | `references/workflows/teach-drawing.md` |
-| A character kept identical in any style (woodcut to toy brick) | `references/workflows/character-consistency.md`, `references/anatomy.md` |
-| A style matched from their image | `references/workflows/adapt-a-style.md` |
-| A score or soundtrack | `references/music/README.md` |
-
-- Music: pick a style vocabulary and mood, sketch the tension arc and motif, compose your own harmony, motif and form (references/music/compose.md, craft in references/music/theory/), revise until node tools/music.mjs craft shows only findings you chose, then check must PASS before a human listens. Styles give sound, never notes.
-- Sound effects: references/music/sound-design.md. 14 layered, seeded effects cued by film frame (filmSfx); the score ducks, and every cue must be within 6 dB of it. Effects only on real direction changes, one riser + one impact per film.
-- Launch films: `launchTemplate.ts` renders a product's launch from data (prompts, plates or its own UI, a score composed for it, words, install lines) in every shape from one timeline; `launch.mjs new|ship`. Habits that save tokens: `references/working-method.md`.
-
-## The seven laws
-
-1. **Every piece has a point.** A still: one idea, one focal subject, one light. A film: one
-   transformation, one payoff, one token that returns. → `references/storytelling.md`
-2. **State the realism.** Name the anatomy, the view and the reference you opened, for animals,
-   objects and people alike. → `references/realism-and-craft.md`, `references/anatomy.md`
-3. **A style is a way of making marks.** Change the medium, the edge and the order of the marks,
-   beyond the palette. → `references/styles.md`
-4. **Prove the look on ONE still, then build end to end.** After that, gates cost more than they
-   save. → `references/working-method.md`
-5. **The contract is absolute.** Pure in `(frame, env)` (and the input log, for interactive
-   pieces), `rng(seed)` only, no clock, no `ctx.filter`. Nothing generated; images they bring may be
-   embedded by hash, and the sound pack is a separate, hash-pinned download. → `references/determinism-and-contract.md`
-6. **Music gets a plan, never an adjective.** A style, a mood per section, the notes as data, then
-   measurements. You cannot hear it, so one human listens before it ships. → `references/music/`
-7. **One directs, one builds, both write everything down.** When a session degrades, reset; the
-   files are the memory. → `references/working-method.md`
-
-## Workflows
-
-**Still.** (1) Say the idea in one sentence; name the focal subject and the light. (2) Open real
-reference for anything that exists, and note which. (3) Pick the style and read its plate's
-header first. (4) Draw in that medium's order. (5) Render with `still.mjs` at full size, run the
-**detail pass** on crops (faces, hands, feet, joins; `references/craft-bar.md`), critique in writing. ✋ **One approval.** (6) Deliver every
-size and shape asked for from the same source, and say `reproducible` was printed.
-
-**Loop.** As a still, plus: every motion is periodic over the loop, the subject never stops,
-something moves every second. Check the seam (last frame against frame 0). ✋ **One approval,
-on the moving file.**
-
-**Film.** (1) **The story in three sentences** (setup, transformation, payoff) and the token; for
-longer films, a spine plus one line per chapter. If you cannot write it, stop. (2) **The grid**:
-a beat is 60 x fps / bpm frames, the bpm from the brief's score; one cue table holds every frame number and a checker
-runs at load. (3) **Real reference** for anything that exists. (4) **ONE look still**, the hardest
-frame, critiqued in writing. ✋ **Approval.** (5) **ONE 8-second music sample.** ✋ **Approval.**
-(6) **Build the whole film**; mechanical checks run continuously. (7) **A fresh critic reviews, never you**
-(`references/workflows/review.md`): after the storyboard, each scene and the full render, a new subagent that saw none of the building returns ranked, timestamped problems and a verdict. Fix the biggest, a NEW critic rechecks; 3 rounds at most, logged in `ledger.md`.
-(8) ✋ **Final approval.** Say what you verified and what you cannot.
-
-Three approval gates at most. Approval is a budget; spend it where being wrong is expensive.
-
-## The craft bar
-
-The test: would a proud human illustrator ship this, or is it mechanical shape-assembly? The
-full table of tells is `references/craft-bar.md`. The ones that sink most work: subjects built
-from ellipses, one style recoloured into another, things that fade in instead of being drawn,
-people with rubber joints, and a character drawn differently from shot to shot.
-
-**No dead air** in anything that moves: something visibly changes every second. A film that
-draws itself declares `kind: "drawing"` and is judged on a finer floor; a freeze still fails.
-
-## The engine
-
-`engine/` is the portable art core plus the tooling. `engine/src/canvas-core` knows nothing
-about the DOM or any backend. `W`, `H`, `fps` and `durationFrames` come from the film's `meta`.
-Camera moves (pans, dollies, lens and dolly zooms, parallax, shake) and slow motion or freeze frames: `engine/src/canvas-core/camera.ts`, `engine/src/canvas-core/timeRemap.ts`, `references/camera.md`.
-Seams between scenes: `references/motion-grammar.md` (cuts that carry motion: `seams.ts`; `tools/deck.mjs deal` deals each film different moves; `deck.mjs find "<name>"` turns a move's everyday name into its card). `render.mjs --blur auto` renders with motion blur (subframes per frame
-from its measured on-screen speed, averaged in linear light, `--shutter 180`); the default path is untouched.
-
-```bash
-node <skill>/engine/tools/scaffold.mjs ~/art --film intro --format 9x16 --duration 12   # seconds
-cd ~/art && npm install && npx playwright-core install chromium
-node <skill>/engine/tools/soundfetch.mjs list    # no network. Nothing installed and not declined: ask the user now
-node <skill>/engine/tools/soundfetch.mjs get piano rooms  # on their yes (piano 233 MB, all 373 MB). On no: soundfetch.mjs decline
-```
-```
-| Tool | What it does |
-|---|---|
-| `scaffold.mjs` | a project with a still and/or film; `--duration`, `--format` or `--size`, `--fps`, `--bpm` |
-| `still.mjs` / `render.mjs` | frames drawn twice with hashes (`--frames a,b,c --sheet` in one browser) / the piece in any format (`--from/--to`, `--poster-frame`, `--hashes`) |
-| `gate.mjs` | determinism, contract, dead air, artifact; `--self-test` proves it can fail |
-| `registry.mjs` / `gallery.mjs` | the style list from the plates themselves / the gallery sheet |
-| `docs-check.mjs` | fails when any doc's style count, length or path disagrees with the code |
-| `verify-export.mjs` | QA on the rendered file: frames, duration, score, A/V sync, true peak after the encode; opt-in first frame, loop seam, `--delivery` |
-| `launch.mjs` | a launch film: `new <name>` scaffolds the spec; `ship <name> --shapes 16x9,9x16` renders, posters, captions, verifies and framechecks each (`framecheck.mjs`: text whole, up long enough to read, clear of the 9:16 phone zones) and checks `facts.json` (`facts.mjs`) |
-| `test.mjs` (`npm test`) | unit suites in `engine/test/`, no browser |
-| `music.mjs` | `vocab` prints a style's vocabulary; `check` gates your composed score (key, master, guards, stems, novelty, which parts played recordings) and prints its shape (ARC); `render`, `meter` |
-| `soundfetch.mjs` | the sound pack: `list`, `get <id...\|all>`, `where`, `verify`, `remove <id>` |
-| `sfx.mjs` | the sound-effects kit: `list`, `one`, `kit <dir>`, `test` |
-
-Four backends, one art core: `playwright`, `html-player`, `remotion`, `hyperframes`.
-→ `references/backends-and-adapters.md`
-```
-
-## Worked examples
-
-- **The style plates** in `engine/src/canvas-core/`: every hand has a still and a film of it being
-  drawn, with the recipe in the header and `references/styles/<id>.md`.
-- **MECHANICAL LEPIDOPTERA** in `example/`: a 47 s scored film. `scaffold.mjs ~/study --example`.
-
-**Study them. Do not copy them.** The craft bar is not satisfied by inheritance.
-
-## Honest limits
-
-You cannot hear the score, watch the film move, or use the interactive piece. Every claim about
-them comes from a measurement or from a human; say which. A green checkmark is a claim until you
-re-run it. Render one frame at `--scale 2` before trusting a still: a layer blitted through the
-wrong transform looks right at 1x and breaks at 2x.
-
-## Source
-
-Rewritten for AICUT from [`alexgreensh/anidoodle`](https://github.com/alexgreensh/anidoodle)
-(Apache-2.0), skills/anidoodle/SKILL.md. The method is that skill's own; the way it runs is AICUT's.
-
-The repository holds 2 skills; this is the one its entry stands for.

package/skills/anidoodle/references/anatomy.md

@@ -1,91 +0,0 @@
-# Human anatomy in code
-
-> Structure first, marks last: the rule `butterfly/alive/anatomy.ts` applied to a wing, applied to
-> a person. A human drawn from outlines is the road-sign icon of a human. A human built from a
-> skeleton, volumes and a camera gets foreshortening, overlap, contact and balance for free, and
-> gets every one of them checkable. Code: `engine/src/canvas-core/character/human/`.
-
-**The scar.** The first mannequin we built had arms hanging in a gap beside a box torso: a
-wooden doll. Its hands were rakes, its thumb left the wrist as a stick, its pinch never closed, a
-nine-year-old's shins were 16% short, and a 37-degree ankle bend and a 46-degree hip slipped into
-poses we "tuned by eye". The checks below caught the last four. The eye caught the first three.
-You need both.
-
-## The pipeline
-
-| Layer | File | What it owns |
-|---|---|---|
-| Canon | `canon.ts` | landmark heights in head units per canon ROW (adult 7.5, storybook child 5.2 declared over a real 6.2); heads-by-age and eye-line-by-age tables |
-| Skeleton | `skeleton.ts` | bone lengths from the canon; forward kinematics; joint limits and cones; **a pose outside them throws at load** |
-| Mannequin | `mannequin.ts` | ribcage egg, pelvis bowl, shoulder girdle, limbs as chains of ellipsoids with muscle profiles |
-| Head | `head.ts` | Loomis ball + jaw; features placed ON the face surface; eleven expression parameters |
-| Hands | `hands.ts` | 5 digits, 14 phalanges, knuckle arc, thumb from the wrist with thenar mass, pose library, solved pinch |
-| Balance, reach | `balance.ts` | centre of mass (Winter segment masses) inside the support polygon; analytic leg IK; numeric reach; contrapposto |
-| Walk | `walk.ts` | a walk from footsteps: heel, ankle and forefoot rockers, swing arcs, pelvis bob and counter-rotation |
-| Clothing | `clothing.ts` | garments are inflated body blobs cut to length; they turn and swing with the body |
-
-A body part is a UNION of convex polygons (a limb is its blob chain swept pairwise), projected
-through a pinhole camera with a real focal length. The outline is every boundary point not inside
-a sibling polygon, minus seams where a part grows out of its parent: so an elbow has no seam, but a
-forearm crossing its own upper arm still gets its overlap line.
-
-**Mannequin is the checker, not the look (in progress).** Rendering those volumes literally reads as
-a mannequin. The drawing layer (`character/design.ts`) keeps the rig as pose source and checker and
-draws designed sweeps over it: a gesture curve through the joints, an authored section table, the
-silhouette perpendicular to the curve. Mira's clothing and Theo the baker (`characters/theo/baker.ts`,
-coloured pencil) use it. Still open: sleeve caps and forearms read tubular, clothing drape from contact
-points is partial, anatomical landmarks are not yet expressed as contour breaks on the drawn layer.
-
-## Canon (checked, not asserted)
-
-- Heads tall by age (Loomis): 1 y 4, 3 y 5, 6 y 5.75, 8 y 6, 9 y 6.2, 12 y 7, adult 7.5, heroic 8.
-- Eye line: half the head in adults, lower in children (0.44 at nine, 0.38 at one).
-- Adult: crotch at half height, elbow at the waist, wrist at the crotch, hand = face, foot = forearm.
-- Every canon: limb segments as fractions of (body) height from Winter's anthropometric table:
-  upper arm 18.6%, forearm 14.6%, hand 10.8%, thigh 24.5%, shank 24.6%, foot 15.2%, within 16%.
-- A stylised canon is a declared row. The storybook child enlarges the head 1.19x and is measured
-  against the body height a real 6.2-head child of her height would have.
-
-## Joints
-
-Ranges (AAOS / Norkin & White, rounded): elbow 0-150, knee 0-140, hip flexion -20..125 but only 95
-with the knee straight (hamstrings), ankle -45..25, neck total rotation 80, fingers MCP -20..90, PIP
-0..110, DIP -5..80. Wrist, neck and shoulder are CONES (an ellipse of combined motion), not boxes.
-Anything that solves a pose (leg IK, reach, the walk) either stays inside or throws; an ankle at its
-limit lifts the heel instead of folding further, which is what a real heel does.
-
-## Hands, the known weak spot
-
-- Knuckles on an ARC (middle furthest from the wrist, little finger well back); fingers in length
-  order middle > ring >= index > little; a web of skin a third of the way up the fingers.
-- The thumb's metacarpal is buried in the thenar eminence: the visible thumb leaves the palm at its
-  MCP, not the wrist. At rest it lies alongside the index, pointing down and forward.
-- Contact is SOLVED, never typed: the pinch pulls thumb pad onto index pad; a grip pulls every
-  finger joint onto the cylinder it holds (none inside it); a wave turns the forearm until the palm
-  faces the lens.
-- Nails on the dorsal face of the distal phalanx, drawn only when that face turns to the camera.
-
-## Poses from reference, built like a teacher builds them
-
-Name the reference you opened (Loomis, Hogarth, Williams, Perry and Burnfield are cited in the
-files). Place the feet, solve the legs, carry the centre of mass over the support, send each hand
-to a target. Contrapposto: weight foot near the midline, pelvis drops on the free side, shoulders
-tilt against it. Tiptoe: toes bend flat to the floor and the mass goes over the balls. A seated
-figure's support includes the seat.
-
-## The look-at-it list (no check proves these)
-
-Render the figure sheet and look, at full size, for: arms that hang in a gap (missing shoulder
-girdle); rake hands; a thumb from the wrist; a face that turns but whose far eye does not narrow;
-a hand that covers the face; a pinch that does not meet; feet that float or sink; a coat that sits
-on the lap like a plate; a pointed finger that does not read as aimed. Each of those shipped in a
-draft of our figure sheet and was caught only by eye.
-
-## Gate
-
-`node tools/character-check.mjs` : canon ratios, limits for every library pose, bone lengths
-constant, left/right symmetry, five digits in length order with the knuckle arc, pinch contact,
-balance, feet on (not through) the floor, identity per view, palette hue families per hand, and
-for a film the planted feet (no slide over 4 mm a frame). Then its negative twins, each of which
-must fail: elbow 170, knee backwards, wrist outside its cone, straight-leg kick, finger bent back,
-owl neck, a figure toppling, a blue coat, missing glasses.

package/skills/anidoodle/references/backends-and-adapters.md

@@ -1,82 +0,0 @@
-# Backends and adapters
-
-One art core, four backends, and the core cannot see any of them. An adapter is the only thing
-that knows how a film becomes pixels.
-
-## The interface
-
-Every adapter exports the same four things, so `tools/gate.mjs` can hold any of them to the same
-bar without knowing which it has:
-
-```js
-export const name = "html-player";
-export const describe = () => "one sentence: what this adapter DELIVERS";
-export const probe = () => ({ ok, why });        // can it run here, and if not, why not
-export const open = async (film, { scale, workers }) => session;
-```
-
-A session is:
-
-```js
-{ workers,                  // how many independent draw contexts it actually opened
-  info(),                   // -> film.meta
-  frame(n, w),              // -> { png: Buffer, shot, drawMs }
-  hash(n, w),               // -> stable digest of the drawn pixels
-  audio(sampleRate),        // -> { sampleRate, frames, pcm16 } | null
-  artifact(),               // -> the adapter's own deliverable, or null
-  close() }
-```
-
-`workers` is the number of independent contexts, and the gate uses it to redraw the same frames a
-different way. That is a stronger test than it sounds: each instance has its own texture tiles,
-its own layer pool and its own cache, so two instances agreeing means the caches are genuinely
-keyed on what the pixels depend on and not on the order somebody happened to ask for frames in.
-
-## The four
-
-| Adapter | Delivers | Needs |
-|---|---|---|
-| `playwright` | frames, as a means to an MP4 | playwright + a chromium build |
-| `html-player` | **the page**: one self-contained offline HTML file | playwright + a chromium build |
-| `remotion` | frames through a Remotion `<Composition>` | `remotion`, `@remotion/bundler`, `@remotion/renderer` |
-| `hyperframes` | frames seeked in headless Chrome by the Hyperframes engine | `@hyperframes/engine`, Node >= 22, ffmpeg |
-
-## Warm and cold catch different bugs
-
-This is the one thing to carry away.
-
-- **`html-player` shares one warm cache across frames.** It can catch a cache key that fails to
-  name everything its pixels depend on, because it draws frame 512 and then frame 128 into the
-  same session and compares.
-- **`remotion` renders every frame COLD** — each still is its own page, its own module state, its
-  own cache. It proves frame N owes nothing to the frames before it, and it **cannot** catch a
-  stale cache, because there never is one.
-
-On this film a real order-dependence sat in the plate composer: five cached surfaces baked the
-line's "boil" into their pixels while leaving it out of their key. The warm adapter found it and
-named the poisoning frame. The cold adapter passed happily. **Run both. Neither is the whole bar.**
-
-## Writing a new one
-
-Ninety percent of an adapter is plumbing; the film is already a pure function of the frame number,
-which is what every one of these backends actually wants. Two traps, both paid for:
-
-- **Remotion screenshots when React commits**, and a committed `<canvas>` is a blank one until the
-  effect runs. Hold the frame with `delayRender` / `continueRender` around the draw or you will
-  ship empty plates that pass every hash check, because they are consistently empty.
-- **Do not pass the film through props.** A `Film` carries functions (every shot's `draw`, the
-  score) and most frameworks serialize props. Close over it instead.
-
-For a backend that drives a **seekable page** rather than a component, the page-side contract is
-small and this engine already satisfies it: a finite frame count, forward, backward and random
-seeks, and the same state whenever the same frame is asked for again. `window.FILM.seek(n)` is the
-whole implementation. `tools/verify-frame-adapter.mjs` holds such an adapter to that contract
-using playwright, which means you can prove the page-side half **before** the backend is installed.
-
-## If a backend is not installed
-
-Say so. Keep every reference behind a dynamic import inside `open()` so the file imports clean,
-make `probe()` name what is missing and how to get it, and let the gate report `CANNOT RUN`
-(exit 2) rather than failing. Then check that the module really exports what you are about to
-call, and if it does not, say what it exported instead. A backend that is not installed should
-report that it is not installed — it should never quietly produce a wrong answer.

package/skills/anidoodle/references/camera.md

@@ -1,148 +0,0 @@
-# The camera: one dolly and one lens, keyed on the frame grid
-
-`engine/src/canvas-core/camera.ts` is the camera. A film either draws in world coordinates
-inside `begin()`/`end()` (the transform path: dirty boxes stay right because the camera rides
-the `Gfx` transform stack), or asks `toScreen()` where a world point lands and draws there (the
-projector path). Both come from the same state, so a caption pinned to the frame and the world
-it floats over can never disagree. Everything is a pure function of the frame: the same camera
-question gets the same answer on any machine, in any order.
-
-## The move
-
-```ts
-import { Camera } from "./camera";
-
-const cam = new Camera([W / 2, H / 2], [
-  { f: 0,   look: [400, 300], zoom: 1, ease: "inout" }, // ease governs the segment this key LEAVES
-  { f: 90,  look: [900, 300], zoom: 2 },
-  { f: 150, look: [900, 300], zoom: 2 },                // a hold: say it, don't imply it
-  { f: 240, look: [400, 300], zoom: 1 },
-]);
-cam.shake({ from: 96, to: 126, amp: 14, seed: 7, rot: 0.004 }); // an impact, ringing down
-```
-
-- **The `zoom` key is the dolly**: how close the camera stands (see Lens and dolly below). It is
-  interpolated in log2, because it is a ratio: halving the apparent size twice should take twice
-  as long as halving it once. Ease the value itself and a long push-in sprints at the near end
-  and crawls at the far one; easing log2(zoom) spends time evenly per stop. A `lens` key eases
-  the same way.
-- **Easing per segment, `inout` (easeInOutCubic) by default.** A camera move with no live
-  operator should accelerate gently and arrive gently. `linear` reads as mechanical, `out`
-  alone reads as interrupted, `in` alone as a fall.
-- **A dolly path with several keys** breathes at every key under per-segment easing. Pass
-  `monoZoom: true` to run one monotone cubic through all the `zoom` keys in log2 instead: smooth,
-  never overshooting into a scale it was not given, never reversing.
-- **Authored paths**: for a camera that follows a creature or a curve, pass
-  `path: (f) => ({ look, zoom, lens? })` instead of keys. Same camera, same shake, same projections.
-
-## Depth planes (parallax)
-
-The camera sits at distance D = 1/zoom from the hero plane (z = 0). A plane at depth z scales
-by `lens/(D + z)` and moves with it: near planes swing wide, far ones barely stir, and every
-element at a depth agrees with every other, because there is only one camera. Positive z
-recedes; a negative z crosses the lens (grass across the glass). Pass the plane's z to
-`begin(g, f, z)` or `toScreen(p, f, z)`. One dolly, one number, and the parallax is true for
-every element at once: do not hand each plane its own drift.
-
-## Lens and dolly
-
-Two different moves make the subject bigger, and directors name them apart:
-
-- **A dolly** moves the camera: the `zoom` key, distance D = 1/zoom. Near planes grow faster than
-  far ones, so the depth changes as it goes. This is a push-in, a pull-back, a dolly in or out.
-- **A lens zoom** changes the focal length with the camera standing still: the `lens` key (1
-  when no key sets it; once one does, frames before the first lens key hold that key's value, so
-  key `lens: 1` where the zoom starts, as below). It multiplies every plane by the same factor about the frame's centre, so nothing
-  shifts against anything else; the picture is magnified, flat. A crash zoom or punch-in is this.
-  It reads as an operator's or a documentary's move, more noticed than a dolly. Use it when that
-  is the voice; for travelling into a world, dolly.
-- **A dolly zoom** does both against each other: the camera dollies while the lens is solved on
-  every frame so the hero plane keeps its size, and the planes behind stretch away (dolly in) or
-  loom (dolly out). The subject holds still in a world that has just changed shape: the moment of
-  realisation (deck card `cam-vertigo-realisation`). It needs at least two planes behind the
-  subject; with nothing behind it, nothing visibly happens.
-
-```ts
-import { Camera, dollyZoom, heroScale } from "./camera";
-
-const lensIn = new Camera(c, [{ f: 0, look, zoom: 1 }, { f: 40, lens: 1, ease: "out" }, { f: 52, lens: 2.2 }]); // a crash zoom
-const dolly = new Camera(c, [{ f: 0, look, zoom: 1 }, { f: 60, zoom: 2.4 }]);
-const vertigo = new Camera(c, [], { path: dollyZoom((f) => dolly.at(f)) }); // holds frame 0's hero scale
-// dollyZoom(path, { hold: 1.5 }) holds a given scale; { at: 30 } holds the scale the path has at frame 30
-```
-
-`heroScale(cam)` is the hero plane's screen scale (dolly times lens), and the line-weight
-compensation `weight(cam)` follows it, for a lens zoom as for a dolly.
-
-## Time: speed ramps, slow motion, freeze frames
-
-`engine/src/canvas-core/timeRemap.ts` maps the film's frame to the scene's frame: draw the world at
-`t.at(f)` instead of `f`. Speed is what you key and scene time is its exact integral, so time is
-continuous, never runs backwards, and stays a pure function of the frame.
-
-```ts
-import { timeRemap } from "./timeRemap";
-
-const t = timeRemap([
-  { f: 84,  speed: 0.3, ramp: 8 },                              // ease into slow motion before the peak
-  { f: 120, speed: 0, keepsMoving: "her name writes itself" },    // freeze: the world stops, the writing does not
-  { f: 150, speed: 1, ramp: 14 },                               // ease back to real time
-]);
-world(g, t.at(f));          // the remapped scene
-name(g, f);                 // the writing, on the film's own frame
-cues.push({ frame: t.filmFrameOf(LANDING), kind: "paper" }); // a sound on a remapped event
-```
-
-- **A ramp eases the speed**, on a smoothstep (or `curve: "linear"`), so it starts and ends with
-  no kick. `ramp` defaults to 0, a deliberate hard change of speed; give it frames to glide. A slowed scene is asked for frames between its frames, so it must
-  draw at fractional time (motion is a function of time, never of a frame counter).
-- **Score and sound stay on real time.** The score never slows; effects are cued by film frame.
-  `filmFrameOf(sceneFrame)` gives the first film frame that shows a scene event, which is where
-  its sound goes.
-- **A freeze must keep something moving.** A `speed: 0` key without `keepsMoving` (in words)
-  throws, and so does a speed under 0.01 (`MIN_SPEED`), which looks frozen without saying so: a frozen frame with nothing moving is dead air, and the gate fails it. Drive the thing
-  that moves (the name being written, the camera still creeping in) from the film's frame `f`.
-  `t.freezes` lists each stop with what keeps moving.
-- **Once a film for each.** One slow motion at the peak, one freeze on the telling pose (deck
-  cards `emph-time-ramp`, `type-freeze-and-name`). The second halves the first.
-
-## Shake
-
-`shake({ from, to, amp, seed, freq, rot, attack })` registers an impact or a handheld stretch:
-
-- **amp in SCREEN pixels**, so the shake reads the same at any dolly or lens; **rot** in radians at full
-  strength, about the frame's centre. A small rotation is what actually sells handheld.
-- The envelope is an **attack ramp** (default 2 frames) into a **squared decay**: full strength
-  at the hit, gone a beat later. An impact rings down; it does not stop mid-air.
-- The motion is **low-frequency gradient noise**, seeded, never white noise per frame. Static
-  per frame reads as a faulty projector; smooth noise reads as mass. `freq` is cycles per frame
-  (default 0.35, about 10 Hz at 30 fps; drop it for a heavier camera).
-- Shake is folded into `shaken(f)`, which `begin` and `toScreen` read, so the drawn world and
-  any projected overlay shake together. `at(f)` stays clean for driving things that must not
-  shake (the score, a cue grid).
-
-## Line weight at close range
-
-Ink is authored at some view; at a screen scale S (dolly times lens) the same nib reads S times
-heavier. Divide stroke widths by `weight(cam)` = S^0.35. Not S: a little weight gain is what
-makes a close-up feel close rather than enlarged.
-
-## The two drawing paths
-
-```ts
-// transform path: the world moves, you draw in world units
-cam.begin(g, f);                    // hero plane
-meadow(g, f);
-cam.end(g);
-cam.begin(g, f, 2.2);               // a farther plane
-hills(g, f);
-cam.end(g);
-
-// projector path: ask where things are, draw them there (cached surfaces, screen-space type)
-const at = cam.toScreen(flower.centre, f, flower.z);
-const k = cam.scaleAt(cam.at(f), flower.z);
-```
-
-`toWorld(s, f, z)` inverts `toScreen`, for hit-testing or for pinning world content to a screen
-point. The camera never touches the context itself, the clock, or `Math.random`: it is
-arithmetic over `(frame, keys, seed)`, which is what keeps the determinism contract intact.