# Share-focus in DaVinci Resolve / Fusion

**Status: precise guide and actual external preparation, not a native app pass.**
No Resolve project was opened or exported for this handoff. The exact Remotion
replays are established separately. The workflow below preserves the authored
layers, all 57 frames and overlapping pointer optics. Native import, color,
alpha, image filtering and output still require a real Resolve check.

## 1. Frame domain and project setup

Use a custom **1840×1016**, square-pixel timeline and a 57-frame Fusion composition
at **30 fps**, progressive. Local composition frame 0 corresponds to source
S3630. If the project displays a nonzero timeline timecode, keep that display
offset separate; it does not change any local frame in this guide. Set the
composition's first included frame to 0 and last included frame to 56. Many
frame-range interfaces use inclusive ends: 0–56 is 57 frames, not 0–57.

Work at full resolution. Disable proxy/optimized-media substitutions, retiming,
optical flow, frame blending, stabilization, automatic fit/fill, extra transitions
and generated audio. Do not wrap the composition in a camera move. Do not apply
the source crop to the candidate again: its entire canvas already represents the
`x40/y64/w1840/h1016` viewport. Native source pixels and cropped source MP4 are
reference-only; neither belongs in the candidate node graph.

Use a non-managed comparison timeline first, without a creative LUT or grade.
Treat prepared graphics as full-range RGB and handle their alpha explicitly.
Do not infer that a bt709-tagged H.264 preview and the browser's RGBA PNGs have an
identical color-management path in Resolve. Compare displayed RGB and alpha
before choosing a final delivery transform. No native color equivalence is claimed.

## 2. Prepare from code, not the source clip

Use `README.md` to configure the pinned browser, existing dependencies, guard and
encoder lock. Run these two modes to fresh off-volume directories:

```sh
bash run.sh prepare "${FRESH_STATIC_PLATE_DIRECTORY:?}"
bash run.sh optics "${FRESH_OPTICAL_SEQUENCE_DIRECTORY:?}"
bash run.sh verify "$FRESH_STATIC_PLATE_DIRECTORY"
bash run.sh verify "$FRESH_OPTICAL_SEQUENCE_DIRECTORY"
```

Actual preparation for this handoff produced:

- **36 static PNGs:** 18 per specimen; two opaque RGB canvas plates 00 and 34 RGBA
  plates. Plates 00–12 are full 1840×1016
  canvases in exact scene coordinates. Plates 13–17 are 40×60 pointer primitives
  for the editable vector/control route, not complete positioned pointers.
- **285 optical RGBA PNGs:** five separate branch folders, 57 files each,
  `0000.png`–`0056.png`, all 1840×1016. These optics are identical for both content
  variants. They come from the unchanged recipe/renderer, not copied source pixels.

Each optical file is already positioned, exposed, masked and blurred by its own
original branch. Inactive branches have transparent frames rather than missing
files. The five branches are **not merged into one pointer movie**. The source
ZIP includes their exporter and strict inventory metadata, not generated PNGs.

Use the prepared static UI and branch sequences for the most practical guide
route. It preserves the exact browser typography and exposure implementation
without asking Fusion to imitate a CSS blur. Original vectors and all numerical
controls remain available for deeper edits. Preparing individual branches is not
proof that Fusion composites them identically.

## 3. Assemble the UI in this paint order

In the Media Pool, import the chosen specimen's **individual stills** 00–12.
Do not let numbered filenames combine these different layers into an image
sequence. In Fusion, place them on a transparent 1840×1016 background with a
serial Merge chain, each new layer in the foreground of the preceding result.
The intended operator is normal foreground-over-background. Start from plate 00
or transparent black; plate 00 contains the opaque canvas.

All these plates have full-canvas placement baked in. Keep each at identity:
center `(0.5,0.5)`, scale 1, angle 0; no crop, fit or translation. In particular,
do **not** add `(654,262)` again to the dialog plates. Their export already
includes that parent translation.

| Merge order / filename stem | Active local interval | Last included | Contents |
| --- | --- | --- | --- |
| `00-ui-static` | [0,57) | 56 | Canvas, sidebar and static prefix before hover |
| `01-initial-fifth-row-hover` | [0,6) | 5 | Fifth-row background only |
| `02-rect-34` | [6,25) | 24 | Fourth-row background only |
| `03-ui-static` | [0,57) | 56 | Following list/text/thumbnail primitives before target pill |
| `04-rect-174` | [0,15) | 14 | Resting target Share pill |
| `05-share-target-hover` | [15,25) | 24 | Hovered target Share pill |
| `06-share-target-after-hover` | [25,57) | 56 | Pill after modal cut-in |
| `07-ui-static` | [0,57) | 56 | Target label, subsequent rows and controls |
| `08-rect-272` | [25,57) | 56 | Black scrim, authored opacity 0.135 |
| `09-dialog-static` | [25,57) | 56 | Dialog card, heading, selected card, field and placeholder |
| `10-rect-284` | [25,40) | 39 | First caret interval |
| `11-rect-285` | [55,57) | 56 | Second caret interval |
| `12-dialog-static` | [25,57) | 56 | Access controls, owner and bottom actions |

Drive each Merge's Blend as a hard gate: 1 in its interval, 0 elsewhere. Use step
interpolation or a frame test such as `iif(time >= 25 and time < 57, 1, 0)` when
the composition's time starts at zero. Do not use eased transitions for these
gates. PNG pixels already include intrinsic opacity, shadows, borders and group
composition; **do not multiply scrim by 0.135 again**. With native primitives
instead of the prepared plate, 0.135 must be applied once to the black scrim.

These runs are split at every visibility change. Combining plates 00–07 into one
flat screenshot would cover hover or bury the target label and is not equivalent.
`controls/assembly.json` lists every constituent ID; the full original recipe
retains each editable primitive. Both the sidebar and list stay behind the scrim
for the complete modal interval; no invented background motion is added here.

## 4. Place five optical sequences above the entire UI

Import each branch folder as **one** 57-frame image sequence. Confirm source rate
30 fps, first file 0000 at local 0 and last file 0056 at local 56. Do not import 285
unrelated still clips or offset a branch to its first visible file. Full-canvas
identity placement applies here too. Do not enable additional motion blur.

Merge these in order after the last dialog plate:

1. `pointer-soft-shadow` — all 57 frames; its own offset, opacity and blur.
2. `pointer-white-rim-optics` — all 57; independent white contour and blur.
3. `pointer-rest-optics` — visible [0,40), then transparent.
4. `flight-tail-optics` — transparent until 40, then visible [40,57).
5. `flight-head-optics` — transparent until 40, then visible [40,57).

Keep branch Merge Blend 1 throughout: transparency already carries the visibility
gate. Do not animate their Center, Size or Blur again. No branch is parented to
the dialog, which would reset its clock or position at 25. The pointer passes
over the background, then over the modal's edge around 48, and across its controls.
The modal/scrim must not dim or occlude it. The shadow, rim and black branches
overlap; they are not five sequential phases.

### Alpha check before judging appearance

The optical exports and transparent static plates are 8-bit RGBA PNGs; each
specimen's opaque plate 00 is RGB. The verifier allows RGB only for those two
named full-canvas bases. Check the importer/MediaIn alpha interpretation
against a black, white and mid-gray background. If a Loader path exposes straight
RGB, multiply by alpha once before normal compositing; if it already provides
premultiplied RGB, do not multiply again. A dark or bright fringe is evidence of
a problem, not permission to change the pointer contour. Keep partial alpha at
the rim and blur. Do not clip transparent RGB by thresholding the edge. Native
premultiplication and color behavior remain unverified until this test is run.

## 5. Exact geometry and the fully editable optical alternative

If using SVG/native shapes rather than the prepared branches, keep the following
coordinate convention: top-left origin, X right, Y down, values in canvas pixels.
For a point `(px,py)`, normalized Fusion canvas coordinates are
`(px/1840, 1-py/1016)`. For a box `(x,y,w,h)` at scale 1, its center is
`((x+w/2)/1840, 1-(y+h/2)/1016)`. The dialog parent is `(654,262)`;
child coordinates are relative to it. Its card is 522×448 with radius 26 and the
authored shadow `0 5px 12px #00000012`. The field is local `(25,169,471,39)`,
radius 10, 2 px stroke `#2f8175`; caret is local `(35,179,1.5,21)`.

The list hover boxes are `(610,591,950,122)` for row5 and `(610,469,950,122)`
for row 4. The Share target is `(1420,512,69,35)`, radius 13. Pointer exposure groups
have a 40×60 local box; the actual path SVG is **37×57**, viewBox`0 0 37 57`, at
local(0,0), not stretched to40×60. The SVG viewport clips its own stroke as the
browser does. Preserve that crop before parent blur. The hotspot used by the
authored hit-test is local(4,3), transformed with pointer scale.

Use `controls/all-layers.csv` for every node at every integer frame. It contains
**local-to-parent** positions, dimensions, own opacity, scale, rotations, transform
origin, blur, radius, clipping insets, gate and sibling order. It is not a table
of final composited pixels or globally accumulated opacity. Static paints, border
widths, paths, shadow and text properties remain in the original recipe, SVGs and
text CSVs. Parent visibility is included in each row's `active` field.

### Exposure is not generic motion blur

For each active exposed group at integer frame `F`, make 49 ordered samples:

```text
sampleIndex = 0 ... 48
subframe = F + (sampleIndex/48 - 0.5)*0.55
wrapperOpacity = 1/(sampleIndex+1)
group transform = original tracks sampled at subframe
child render/visibility clock = F, NOT subframe
```

`controls/pointer-exposure.csv` supplies all **9,212 active sample rows**, including
subframe X/Y/scale, wrapper opacity and child clock. Composite samples in ascending
index order using normal over, then apply the containing optical group's treatment.
The first wrapper has opacity 1, not 1/49; averaging 49 silhouettes uniformly is not
the implementation. Sample tracks clamp outside their first/last keys. Between
keys, the left key selects linear, hold or smoothstep `u*u*(3-2*u)`; do not smooth
the fitted 57-frame position track with a spline.

The pointer parent maps a local pixel `(px,py)` to
`(x(subframe)+scale(subframe)*px, y(subframe)+scale(subframe)*py)`, with top-left
scale origin. If driving a small40×60 image by its center, use
`((x+20*scale)/1840, 1-(y+30*scale)/1016)` at that sample. Verify a marked corner
and the hotspot at scale 1 and 0.86 before accepting native Transform settings.
Do not assume a center-based scaling control already implements this mapping.

The complete optical hierarchy, in paint order:

```text
shadow: exposure(black contour, stroke7.5) -> parent offset(0.7,2.4), blur1.6,
        frame-varying parent opacity
rim:    exposure(white contour, stroke6.2) -> frame-varying parent blur
rest:   exposure(black arrow) -> blur0.35; gate[0,40)
tail:   exposure(black arrow) -> tail clip -> frame-varying blur and opacity;
        gate[40,57)
head:   exposure(black arrow) -> head clip -> frame-varying blur; gate[40,57)
```

Head and tail clips are in **full canvas coordinates**, evaluated at integerF:
tail keeps `y >= pointerY(F)+35`; head keeps `y <= pointerY(F)+39`. Their nominal
regions therefore overlap by **4 pixels**, before outer blur. Do not make them
complementary masks, put the clip before each exposure sample, or exchange their
order. At late frames the varying blur/opacity is as important as the path.
The exact values for all 57 frames are already in the controls; no blur knob in
Fusion is assumed to be numerically equivalent to CSS `blur(px)`.

The five prepared optical sequences are the provided, actually rendered way to
avoid these native implementation uncertainties while retaining separate branches.
For native SVG import, the exported 128 SVGs contain path geometry and paints only;
they do not carry the parent exposure tree, blur, masking, gates or CSS typography.
Importing a pointer SVG alone does not recreate this study.

## 6. Frame checks and export acceptance

Inspect at least the event boundaries in native resolution **and compare every
one of the 57 output positions** to the appropriate retained replay:

| Frames | Required observation |
| --- | --- |
| 0,5,6 | Fifth row then fourth row; arrow remains continuous, not row-snapped |
| 14,15,24 | Independent Share hover starts15; pointer shrinks into the press |
| 24,25,26 | One-frame scrim/dialog cut-in; arrow does not disappear or reset |
| 35,37,38 | Scale recovery complete at 35, positional hold through 37, later traverse |
| 39,40 | Caret blink-off and split black optics; shadow and rim do not disappear |
| 47,48,49 | Pointer crosses modal edge without being clipped by it |
| 54,55,56 | Caret returns at 55; pointer does not click the field or start a pullback |

Export only the 57-frame interval, at 30 fps, 1840×1016, no audio. First use a lossless
comparison sequence so encoder errors are not confused with alpha or node-order
errors. Compare all frames, dimensions and clock; preserve all mismatches by
frame and region. Then apply the desired delivery codec. Do not use a static
contact sheet to claim moving quality or waive numeric differences as “native.”

This kit's actual H.264 replay floor is unchanged: **57/57 exact RGB and YUV frames
against each retained candidate, two byte-identical movies**. Resolve has not met
that floor. The optional CPU plate-assembly diagnostic, when reported in
`bridge-diagnostic.json`, is not a Resolve render, and its differences from the
encoded replay are not a native-pass threshold.

## Manual grounding and limits

Blackmagic's *Fusion 19.1 Reference Manual*, chapter 3 (Getting Clips into Fusion,
page 80), distinguishes footage loading from SVG spline import. The older official
*Fusion 7 Tool Reference*, Transform entry page 385, documents Center, Pivot, Size
and transform concatenation. The official *Fusion 9 Tool Reference*, Alpha Multiply
entry page 436, describes multiplication by the alpha channel. These support node
terminology, not a claim that this graph was exercised in Resolve19,20 or21.

```text
https://documents.blackmagicdesign.com/UserManuals/Fusion19_Manual.pdf
https://documents.blackmagicdesign.com/UserManuals/Fusion7_Tool_Reference.pdf
https://documents.blackmagicdesign.com/UserManuals/Fusion9_Tool_Reference.pdf
```

Exact menus and available import controls depend on the installed Resolve/Fusion
version. No generic importer is assumed to reproduce browser SVG filters or font
metrics. The normative reference here is the shipped unchanged recipe/renderer;
the guide supplies a practical external-preparation bridge and explicit checks,
not a fabricated native application success.