2a:I[30972,["$2","$13","$14","$15","$16"],"LiveRun"] 2b:T5f6,mkdir -p .crew/sprint/36 && cat > .crew/sprint/36/decisions.md <<'EOF' # Sprint 36 (B4d): decisions 1. **The work** (Atlas): the roadmap's next sprint is B4d, the hull on `/crew` with one mark per moment under Full/Calm/Off and the control in `/crew`'s bar (`.crew/sprint/28/b4-plan.md`, B4.4). No owner goal, no PR open or waiting. M: Quill's contract with Iris's calls, Probe's checks red first, Pixel builds the 3D and Forge the control and the 2D marks, Iris looks early. Riders: Lens's nit on #90 (abort a poll that never settles), Lens's two nits on 9b8743a (`lib/model/mount.ts`), and Iris's chip over the copper dot on a short seat if the layer moves. EOF cat > .crew/sprint/36/pr.md <<'EOF' # Sprint 36: the hull on /crew (B4d) **Goal:** the roadmap's next sprint, B4d (not an owner goal): on `/crew` the card model sits on the drawing, one mark per moment on the pencil plank, under Full/Calm/Off, with the control in `/crew`'s bar. **Size:** M. The contract, its results and the decisions follow as the sprint lands (`.crew/sprint/36/`). 🤖 Generated with [Claude Code](https://claude.com/claude-code) https://claude.ai/code/session_01QrjXvdJC9qJR4aHc8kQPQC EOF git add .crew/sprint/35/merge.json .crew/sprint/36 && git commit -qm "Sprint 36: the merge record for 35, and the sprint's first decision Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01QrjXvdJC9qJR4aHc8kQPQC" && git push -q -u origin sprint/36-b4d-crew-hull 2>&1 | tail -22c:T7da,You are Quill, writing sprint 36's contract: B4d, the hull on `/crew` (the plan's B4.4 in `.crew/sprint/28/b4-plan.md`). Atlas leads; the branch is `sprint/36-b4d-crew-hull` (PR #91), checked out at /home/user/theseus-portfolio. Work in that checkout (notes only; don't edit product code or e2e/). **What it's for.** A visitor on `/crew` sees the crew's run as the card model on the drawing: the camera close on the working plank (or the newest seat at rest), one mark per moment of the run on the pencil plank, new marks drawn on demand as B4c's poller adds moments; Full (one camera move on open), Calm (settled), Off (the 2D drawing with the marks as strokes, no WebGL). The Full/Calm/Off control joins `/crew`'s bar. It reuses B5c's second-route mount (sprint 33, `lib/model/mount.ts`, `.crew/sprint/33/contract.md` and `decisions.md`). **Read first:** `.crew/STATE.md`; the B4.4 section and "Riders" in `.crew/sprint/28/b4-plan.md`; `.crew/sprint/33/contract.md` + `decisions.md` (the format and the mount); `.crew/sprint/34/contract.md` (the pencil layer, `data-pencil`) and `.crew/sprint/35/contract.md` + `decisions.md` (B4c, the poller); the frame `.crew/sprint/17/design/crew-1440.webp` and `.crew/sprint/17/direction-iris.md`; `app/crew/page.tsx`, `components/crew*.tsx`, `components/model.tsx`, `lib/model/*.ts`, `lib/live-layer.ts`; the existing specs in `e2e/` for /crew, the model, and B2.3 (the control in the bar). **Deliver** `.crew/sprint/36/contract.md`, one to two pages like sprint 35's: the outcome, the calls you made, numbered checks B4.33 onward a visitor would notice (marks count = moments shown in 2D and 3D; 0 frames at rest and after a mark; Off and hidden never request the chunk and the shared Off paths hold on /crew; cost: ≤8 draws, ≤30k triangles desktop / ≤12k phones, chunk ≤250 kB gzip, as B3.6 measures; B2.3 rewritten with the same assertions for /crew's bar; /crew's script budget B4.14 re-measured — say whether this sprint's client code fits it), the li2d:T7d6,You are Iris, making sprint 36's design calls for B4d: the card model (the hull) on `/crew`, one mark per moment of the run on the pencil plank, under Full/Calm/Off, with the control joining `/crew`'s bar (the plan's B4.4 in `.crew/sprint/28/b4-plan.md`). Atlas leads; branch `sprint/36-b4d-crew-hull` (PR #91) at /home/user/theseus-portfolio. Quill (agent `quill`) writes the contract in parallel and may message you; answer quickly. **The calls I need from you**, decided, not surveyed: 1. What one mark is, in 3D on the pencil plank and in 2D on the Off drawing (the direction's "each event type gets one mark"; is it one stroke per moment, does kind change it, where on the plank do they run, what happens past ~40 moments on a plank that short). 2. The camera: "close on the working plank, or the newest seat at rest" — how close, at 1440 and 390, and Full's one move vs Calm's settled pose. 3. The control's place in `/crew`'s bar at every width (compare `/` and `/log`'s; below 768 on `/` it sits at the drawing's foot, sprint 27 decision 8). 4. Whether copper on the tip (live only) and the marks interact; and Iris's own open item: the chip covering the copper dot on a short seat at 1024 and below (ROADMAP.md, B4b bullet) — fix it here or not. **Read:** `design/brief.md`, `design/rubric.md`, `.crew/sprint/17/direction-iris.md` and the frames in `.crew/sprint/17/design/` (`crew-1440.webp`, `crew-390.webp`, `loft.webp`), your memory in `.claude/agent-memory/`, `.crew/sprint/33/notes-iris.md` and `.crew/sprint/34`/`35` notes, and production `https://theseus-portfolio.vercel.app/crew`, `/` and `/log` in a browser at 1440 and 390 (production is reachable). **Deliver** `.crew/sprint/36/notes-iris.md`, short, with numbers a builder can type in, and commit it on the branch (don't push). Send the calls to `quill` as soon as you have them. Later Atlas will ask you for an early look at Pixel's running build — keep your context. Report to Atlas: the calls in a few lines, and anything2e:T7d0,S=/tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad; cd $S/wt && python3 - <<'EOF' import re p='app/crew/page.tsx' s=open(p).read() s=s.replace('import { LinesPlan } from "@/components/lines-plan";','import { LinesPlan } from "@/components/lines-plan";\nimport { Model, MotionControl } from "@/components/model";') s=s.replace('','} />') s=s.replace('','\n ') s=s.replace('','} />') s=s.replace('','') open(p,'w').write(s) p='components/crew-live.tsx' s=open(p).read() s=s.replace(''' const response = await fetch("/api/crew", { cache: "no-store" });''',''' const abort = new AbortController(); const timer = setTimeout(() => abort.abort(), 30_000); const response = await fetch("/api/crew", { cache: "no-store", signal: abort.signal, }).finally(() => clearTimeout(timer));''') s=s.replace('export function CrewLive({ crew: first, facts }: { crew: Crew; facts: Facts }) {','''export function CrewLive({ crew: first, facts, marks, sprint, }: { crew: Crew; facts: Facts; marks: string[]; sprint: number | null; }) {''') s=s.replace(''' return ( } />`, Read as page left, control right, as on /. 4. Your #87 rider (the chip covering the copper dot on a short seat, 3.0, at 1024 and below) rides, since /crew's drawing now carries the pencil and the fixtures' sprint 31 sits on 3.0. What I need from you: a. A mark, in 2D and 3D: its shape, length, spacing, colour (my assumption: graphite/--pencil, never copper), where the first one starts relative to the tip, and order (oldest nearest the tip?). Max 10 (the panel shows 10 moments). b. The framing: the settled view on /crew at 1440, 1024, 390 (yaw/pitch/zoom, what's cropped, as crew-1440.webp crops the bow), and whether Off's 2D is today's whole drawing or cropped to match. c. Confirm (3), or the control's place 30:Tfa0,# B4d contract: the hull on `/crew`, one mark per moment Quill, 2026-10-31, during sprint 36, for the run that builds it (PR #91). It is the plan's B4.4 (`.crew/sprint/28/b4-plan.md`), drawn to `crew-1440.webp` (`.crew/sprint/17/design/`). It reuses, by reference: - the model, the modes and the control as sprints 25 to 27 shipped them; - B5c's second-route mount (`.crew/sprint/33/contract.md`, calls 2, 3 and 6, "The view", "Calm", "Off"); - B4b's pencil plank, tip and hull (`.crew/sprint/34/contract.md`, "The drawing" and "The hull"); - B4c's poller and its rules (`.crew/sprint/35/contract.md`). Their data rules hold word for word except where this one changes them. Numbers come from three sources, each cited where it's used: - this branch (`1294677`); - a scratch build of it with `` and `` on `/crew`, plus a sketch of the abort and the marks (thrown away; see "Measured"); - the sprints that measured them. Iris's calls are written in where she has made them. Where her call is still pending, the text says **[Iris pending]** and gives my default. ## Outcome A visitor on `/crew` sees the crew's run on the drawing, as a card model: - The hull stands up off the sheet, close on the plank the crew is drawing now. That plank is in pencil, with the copper tip while the crew is live. - It carries one pencil mark for each moment the panel lists. When the poll brings a new moment, a new mark appears, without motion. - At rest, the hull is close on the newest seat, with no pencil and no marks. Full plays one camera move on opening. Calm opens settled. Off is the 2D drawing with the same pencil, tip and marks, and downloads no 3D. The choice is the one the visitor made on `/` and `/log`, and Full/Calm/Off now sits in `/crew`'s bar. ## The calls I made 1. **Marks are pencil, so they live only on the pencil plank.** In `live` and `open` with a sprint number, the marks count equals the moments shown (at most 10, B4c). At rest and in `down` there are none. - Pencil is the drawing's word for "in progress" (B4b). A merged plank is inked, so its marks go with the pencil. - This is also the only rule that keeps "marks = moments shown" true in every state without a plank to put a resting run's marks on. 2. **The camera's plank is fixed at first paint, and no poll moves it.** `[data-plan]` carries `data-focus`: - in `live` and `open`, the pencil seat, by B4b's rule; - otherwise, the newest retro's seat (the revision block's top sprint, `readSprintLog()[0]`). Today these are 6.1 for sprint 36 (k = 34, `ORDER[12]`) and 0.2 for 35. The fixtures' 31 is on 3.0. A camera move on a poll would be motion on an update, which B4c ruled out in every mode (Iris, `.crew/sprint/35/notes-iris.md`). 3. **The drawing follows the poll for its own sprint, and claims nothing for any other.** The server draws the page's state, as B4b's data rules do (pencil, number, tip and marks). The drawing has no client geometry, so it can't seat a new plank. Each told answer then sets the drawing to one of four states: | The answer tells | The drawing shows | |---|---| | `live`, the drawing's sprint | the pencil, the tip, and marks = moments shown | | `open`, the drawing's sprint | the pencil, no tip, and marks = moments shown | | `resting`, with `last.sprint` the drawing's sprint | **inked**: the plank seated (card fill, solid ink edge, number n kept), no tip, no marks. The merge took the seat | | anything else: another sprint, a run with no number, or `down` once B4c's 10 minutes are up | **the record**: the drawing exactly as the default (down) server draws it, with no pencil, tip or mark | So a run that starts while the visitor watches gets its pencil on the next load. The panel tells it at once. Copper stays only while the poll says live (B4b's rule, now on `/crew`). 4. **The loader doesn't change.** `components/model.tsx` stays byte for byte as it is (B2.10 leave31:T449,cd /home/user/theseus-portfolio/.claude/agent-memory/product-owner && python3 - <<'EOF' p='MEMORY.md' s=open(p).read() old="- Check the code before trusting the roadmap's boxes or a follow-up list: both go stale after a big PR (sprints 3 and 11)." new="- Check the code before trusting the roadmap's boxes, a follow-up list or a rider line: all go stale after a big PR (sprints 3 and 11; sprint 36's two mount.ts riders were done in sprint 34, found with `git log -S`)." assert old in s s=s.replace(old,new) s=s.rstrip("\n")+"\n"+"""- A route that already ships a client chunk gets `model.tsx` folded into it (`/crew`: +1,891 B in its own file, not `/`'s 2,039 B one), so its budget is its own allowance plus B2.10's loader allowance, measured in a scratch build (`.crew/sprint/36/contract.md`, call 7). - A script-byte check read with WebGL on counts the 600 kB 3D chunk once a route mounts the model: B4.14's "within 2,048 B of /log's" was vacuous for that reason. Read byte budgets with WebGL refused (`.crew/sprint/36/contract.md`). """ open(p,'w').write(s) EOF tail -3 MEMORY.md | cut -c1-12032:T7d9,Iris: here are my B4d calls for the contract. Everything is final except the 3D pose numbers (yaw/pitch/lift/duration), which I'll send within the hour after a render check. Your 1 to 4 stand, with the adjustments below. ON YOUR 1 (marks only on the pencil, 0 at rest/down): agreed. Each mark is a tick on the plank, and the approved frame already draws them (crew-390.webp and crew-1440.webp: small ticks on the copper run, ending at the dot). a. THE MARK - Form: one short straight tick per moment, the same for every kind. Kind is told by the list's words. A glyph per kind would need a legend and can't be read on a 3D sliver. The research's "each event type gets one mark" means one form per channel: "a pencil stroke on the plank". - Where: it stands on the pencil plank's lower edge (the same edge as the tip: the seam, or the keel's outline on lift 6) and rises into the plank. - 2D: vertical, from (x, bandAt bottom) to (x, bottom − h). - 3D: nearSide(x, bottom) to nearSide(x, bottom − h). - Both use the same hull units, so frame 1 registers. - Size, in hull units: h = 3.5. That clears a 13 px number chip at the band's middle from 768 up. - Spacing: pitch 4 hull units, by order, never by time. Live sprint 36 shows 4 tickets inside 3 s; laid by time they would sit on one spot. Pacing is what keeps bursts readable. - Order: newest nearest the copper dot. Tick i (0 = newest, up to 9) sits at x_i = tip − (6 + 4i)·f, where tip is the dot's x (7/8 of the body, PENCIL.tip.to, unchanged from /). So the newest tick is 1.5 pitches aft of the dot and clears its 8 px at every width. - Short seats: f = min(1, (tip − xs) / 54), where xs is the sternmost x on the plank whose band is at least 6 units deep. f is 1 on every seat except the short stern ones (3.0, 5.0, and possibly 6.0 and 1.0; my prototype will list them). f depends on the seat, never on the count, so no tick ever moves when a moment arrives. - At most 10 ticks: the ticks equal the moments shown. On a new moment pa33:Tfa0,# B4d contract: the hull on `/crew`, one mark per moment Quill, 2026-10-31, during sprint 36, for the run that builds it (PR #91). It is the plan's B4.4 (`.crew/sprint/28/b4-plan.md`), drawn to `crew-1440.webp` and `crew-390.webp` (`.crew/sprint/17/design/`). It reuses, by reference: - the model, the modes and the control as sprints 25 to 27 shipped them; - B5c's second-route mount (`.crew/sprint/33/contract.md`, calls 2, 3 and 6, "Calm", "Off"); - B4b's pencil plank, tip and hull (`.crew/sprint/34/contract.md`, "The drawing" and "The hull"); - B4c's poller and its rules (`.crew/sprint/35/contract.md`). Their data rules hold word for word except where this one changes them. Numbers come from three sources, each cited where it's used: - this branch (`1294677`); - a scratch build of it with `` and `` on `/crew`, plus a sketch of the abort and the marks (thrown away; see "Measured"); - the sprints that measured them. Iris's calls (her message to Quill this sprint) are written in and marked "Iris". One is still open, the 3D pose numbers, marked **[Iris pending]**. ## Outcome A visitor on `/crew` sees the crew's run as a detail drawing of the hull, close on the plank the crew is drawing now: - That plank is in pencil, with the copper tip while the crew is live. - It carries a tally: the sprint's number, then one graphite tick for each moment the panel lists, then the copper pen. A tick is added when the poll brings a moment, without motion. - At rest, the detail is centred on the newest seat, with no pencil and no ticks. Full lifts the card model off that detail in one move when the page opens. Calm opens settled. Off is the same detail in 2D, with the same pencil, tip and ticks, and downloads no 3D. The choice is the one the visitor made on `/` and `/log`, and Full/Calm/Off now sits in `/crew`'s bar. ## The calls I made 1. **Marks are pencil, so they live only on the pencil plank** (Iris agrees). In `live` and `open` with a sprint number, the ticks equal the moments shown (at most 10, B4c). At rest and in `down` there are none. - Pencil is the drawing's word for "in progress" (B4b). A merged plank is inked, so its marks go with the pencil. - This is also the only rule that keeps "marks = moments shown" true in every state without a plank to put a resting run's marks on. 2. **The focus plank is fixed at first paint, and no poll moves it.** `[data-plan]` carries `data-focus`: - in `live` and `open`, the pencil seat, by B4b's rule; - otherwise, the newest retro's seat (the revision block's top sprint, `readSprintLog()[0]`). Today these are 6.1 for sprint 36 (k = 34, `ORDER[12]`) and 0.2 for 35. The fixtures' 31 is on 3.0. The crop is server-rendered around it (Iris, below). Moving the crop or the camera on a poll would be motion on an update, which B4c ruled out in every mode. 3. **The drawing follows the poll for its own sprint, and claims nothing for any other.** The server draws the page's state. The drawing has no client geometry, so it can't seat a new plank. Each told answer sets `data-run`: | The answer tells | `data-run` | The drawing shows | |---|---|---| | `live`, the drawing's sprint | `live` | the pencil, the tip, and ticks = moments shown | | `open`, the drawing's sprint | `open` | the pencil, no tip, and ticks = moments shown | | `resting`, with `last.sprint` the drawing's sprint | `inked` | the plank seated (card fill, solid ink edge), number n in ink 700 with no chip, no tip, no ticks. The merge took the seat | | anything else: another sprint, a run with no number, or `down` once B4c's 10 minutes are up | `record` | every plank as the down page seats it (`data-sprint` and fill), the focus plank's number its holder's in ink 700, and no pencil, tip or tick | So a run that starts while the visitor watches gets its pencil on the next load. The panel tells it at once. Copper stays only while the poll says live (B4b's 34:T7d0,B4d's contract is written and committed on `sprint/36-b4d-crew-hull`. It has two commits, not pushed: 6accef2 (the contract and my memory lines) and 626e126 (Iris's calls written in). The only design call still open is Iris's 3D pose numbers (yaw, pitch, lift), which she promised within the hour after a render check. I asked her to send them to you. The contract is `/home/user/theseus-portfolio/.crew/sprint/36/contract.md`. **What the visitor gets.** `/crew` shows a detail drawing of the hull, centred on the plank the crew is drawing now. That plank is in pencil, with the copper tip while live, and carries a tally: the sprint's number, then one graphite tick per moment shown (at most 10), then the copper pen. A tick is added when the poll brings a moment, with no motion. At rest the detail is centred on the newest seat, with no pencil and no ticks. Full lifts the model off the detail in one 1.8 s move, once a visit. Calm opens settled. Off is the same detail in 2D and downloads no 3D. Full/Calm/Off goes in `/crew`'s bar from 768 px, and below 768 in the foot beside Read as page. **The calls I made:** - **Marks only on the pencil plank.** Ticks equal the moments shown in `live` and `open`; at rest and in `down` there are none. Iris agreed. - **The focus plank is fixed at first paint.** `[data-plan]` carries `data-focus`. No poll moves the crop or the camera, following B4c's no-motion-on-update rule. - **The drawing follows the poll only for its own sprint.** `data-run` is `live`, `open`, `inked` or `record`: - live to open drops the tip; - a merge of the same sprint "inks" the plank (seated, number kept, no ticks); - anything else (another sprint, a run with no number, down past 10 minutes) returns the drawing to the record. - A run that starts while someone watches gets its pencil on the next load. This means copper never shows while the panel says resting. - **`components/model.tsx` doesn't change.** The 3D chunk reads the drawing's attributes, as in spr35:T5ad,git log --oneline -4 && cat >> .crew/sprint/36/decisions.md <<'EOF' 2. **Quill's contract** (`contract.md`, B4.33 to B4.42) is accepted as written. Lens's two nits on 9b8743a were already done in sprint 34 (e770a54), so the roadmap's B5c rider line comes off at the close-out. 3. **`/crew`'s 18,432 B script budget needs no Owner's pick** (Atlas): it is the poller's allowance plus B2.10's loader allowance, both in plans the owner merged; the loosening is Lens's to accept with the contract's reason (call 7), named in the PR. 4. **CI's 25-minute cap:** Probe measures the full suite with the new specs at CI's worker count before the label; if it can't fit, the fix is in `.github/` and goes as an Owner's pick, never as a weaker check. 5. **Probe, Forge and Pixel build in parallel** in their own worktrees from the contract's head: `e2e/` is Probe's; `lib/model/*` and the model layer's CSS are Pixel's; `lib/hull-layouts.ts`, the 2D drawing, `app/crew/`, `components/crew*.tsx`, the poller and the rest of the CSS are Forge's. Nobody edits `components/model.tsx`. Forge pushes `MARKS` and the layouts first. EOF git add .crew/sprint/36/decisions.md && git commit -qm "Sprint 36: decisions 2 to 5 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01QrjXvdJC9qJR4aHc8kQPQC" && git push -q origin sprint/36-b4d-crew-hull 2>&1 | grep -v remote; git rev-parse --short HEAD36:T6f4,You are Probe, writing sprint 36's checks (B4d, the hull on `/crew`) red first, before the build. Atlas leads; branch `sprint/36-b4d-crew-hull`, PR #91, head 36360de. **Contract:** `.crew/sprint/36/contract.md` (B4.33 to B4.42, plus the rewrites of B4.1, B4.6, B4.9, B4.13, B4.14, B4.31 with the same `expect(`s, and the three `/crew` specs moving to the WebGL-refused path as sprint 33 did for `/log`). Decisions: `.crew/sprint/36/decisions.md`. Iris's calls: `notes-iris.md` when it lands (pose numbers may still be pending — the contract says the checks don't depend on them). **Setup:** you're in your own worktree; `git fetch origin sprint/36-b4d-crew-hull && git checkout -B probe/36 origin/sprint/36-b4d-crew-hull`, then `pnpm install --frozen-lockfile`. Use your own port (e.g. `PLAYWRIGHT_PORT=3341`). **Deliver:** the checks in `e2e/`, red on the current head for the new behaviour and green for what already holds; prove a check against a mutant only where it could pass on main without the change. Forge and Pixel build in parallel against the contract's data attributes (`data-focus`, `data-run`, the tally/ticks, `MARKS` in `lib/hull-layouts.ts`), so keep to the names the contract writes down; if one is unspecified, choose, tell me, and I'll pass it to them. **Push each commit as it lands** to `origin probe/36` (I cherry-pick). Also, per decision 4: measure the full suite's wall time with the new specs at CI's worker count (read `.github/workflows` and `playwright.config.ts` for it) and report it against CI's 25-minute cap (main's job takes ~21–22 min). **Report:** the commits, which checks are red and why, the mutants, the suite timing, any name you chose, and your memory lines (at most three, citing `.crew/sprint/36/`) committed on your branch.37:T7d4,You are Forge, building your half of sprint 36 (B4d, the hull on `/crew`). Atlas leads; branch `sprint/36-b4d-crew-hull`, PR #91, head 36360de. **For whom:** a visitor (often a hiring executive) on `/crew` who should see the crew's run drawn on the hull: a detail centred on the plank being drawn now, one tick per moment, following the poll without motion; and the Full/Calm/Off control in `/crew`'s bar. **Contract:** `.crew/sprint/36/contract.md` — read it whole. **Your files** (decision 5): `lib/hull-layouts.ts` (the layouts and `MARKS` — commit and push these FIRST, at once, so Pixel can build on them), the 2D drawing on `/crew`, `app/crew/`, `components/crew*.tsx`, the poller's abort (B4.42, Lens's #90 nit: abort after ~30 s with AbortController + setTimeout so page.clock drives it) and `data-run`, the control in `/crew`'s bar (from 768) and in the foot below 768, and the CSS outside the model layer. **Not yours:** `lib/model/*` and the model layer's CSS (Pixel, agent `pixel`, building in parallel), `e2e/` (Probe, agent `probe`, writing failing checks to `probe/36`), and `components/model.tsx` (nobody edits it). Iris's calls: `.crew/sprint/36/notes-iris.md` when it lands; message `iris` for a taste question, `pixel` for an interface question. **Setup:** own worktree; `git fetch origin sprint/36-b4d-crew-hull && git checkout -B forge/36 origin/sprint/36-b4d-crew-hull`, `pnpm install --frozen-lockfile`, your own port (not 3000). Push each commit as it lands to `origin forge/36`. Cherry-pick Probe's commits from `origin/probe/36` locally to run them, but don't push them on your branch. **Done means:** `pnpm verify` passes; Probe's checks for your part pass (`PLAYWRIGHT_PORT= pnpm test:e2e`, or the relevant specs); `/crew`'s script budget measured against 18,432 B; checked in a real browser at 1440 and 390, all four states and Off. **Report:** commits, evidence, what fails, deviations, and your memory lines (at most three, citing `.crew/sprint/36/`) committ38:T7dc,You are Pixel, building the 3D half of sprint 36 (B4d, the hull on `/crew`). Atlas leads; branch `sprint/36-b4d-crew-hull`, PR #91, head 36360de. **For whom:** a visitor on `/crew` who sees the card model lift off the detail drawing (Full: one 1.8 s move once a visit; Calm: settled; Off: no WebGL), centred on the plank being drawn now, with one tick per moment on the pencil plank, a new tick drawn on demand (1 frame per tick, 0 at rest). **Contract:** `.crew/sprint/36/contract.md` — read it whole; cost: ≤8 draws (Iris's design uses 7), ≤30k triangles desktop / ≤12k phones, the chunk within 250 kB gzip, as B3.6 measures. It reuses B5c's second-route mount (`lib/model/mount.ts`, `.crew/sprint/33/`) and B4b's pencil (`lib/model/pencil.ts`, `.crew/sprint/34/`). The 3D chunk reads the drawing's attributes (`data-focus`, `data-run`, the ticks); `components/model.tsx` does not change. **Your files:** `lib/model/*` and the model layer's CSS. **Not yours:** `lib/hull-layouts.ts`, the 2D drawing, `app/crew/`, `components/crew*.tsx`, the rest of the CSS (Forge, agent `forge`, pushing the layouts and `MARKS` first to `origin/forge/36` — fetch it and build on it); `e2e/` (Probe, agent `probe`, on `origin/probe/36`). Iris's calls and pose numbers: `.crew/sprint/36/notes-iris.md`, or message `iris`; she'll want an early look at your running build — send her a message with how to see it once it lifts. **Setup:** own worktree; `git fetch origin sprint/36-b4d-crew-hull && git checkout -B pixel/36 origin/sprint/36-b4d-crew-hull`, `pnpm install --frozen-lockfile`, your own port (not 3000). Push each commit as it lands to `origin pixel/36`. **Done means:** `pnpm verify` passes; Probe's 3D checks pass with Forge's commits merged in locally; the B3 suites on `/` and B5c's on `/log` still green; cost measured. **Report:** commits, evidence (counts, screenshots in your scratchpad), what fails, deviations, and your memory lines (at most three, citing `.crew/sprint/36/`) committed on your39:T44f,Pixel here (sprint 36, the 3D on /crew): what shape will CREW_WIDE, CREW_NARROW and MARKS take in lib/hull-layouts.ts, and when do they land on origin/forge/36? The 3D needs, per detail drawing, a Layout it can feed makeLoft (box, ox, oy, s) and the crop's ox depends on the focus seat and the run. My preference, so the chunk can't disagree with the drawing: export a pure function from lib/hull-layouts.ts (no SVG, no half-model drawing code beyond bandAt-like maths), e.g. `crewLayout(base: CREW_WIDE | CREW_NARROW, focus: string, pencil: boolean): Layout` returning ox; plus `MARKS` = { h: 3.5, step: 4, first: 6, count: 10, width: 1.4, span: 54, minDepth: 6 } and a pure `markF(seat)` / `markXs(seat, n)` the 2D and the 3D both call. Also: (1) which class names do the two detail drawings carry (I'd mount on `.plan-wide`/`.plan-narrow` as on /, or tell me e.g. `.plan-crew-wide`); (2) how is a tick marked up: `path[data-mark]` one per tick, or one path; (3) what `order` does `.crew-page > [data-plan]` get below 1024, so the layer's rule matches. I'm building against my guesses until your push.3a:T7d0,python3 - <<'EOF' import re p='lib/hull-layouts.ts' s=open(p).read() s=s.replace('import { BUTTS, ends, LENGTH, seamDepth } from "./half-model";','import { BUTTS, ends, LENGTH, profile, seamDepth, sheer } from "./half-model";') open(p,'w').write(s) EOF cat >> lib/hull-layouts.ts <<'EOF' // --- A plank's depth and body --------------------------------------------------------------- /** A plank's depth at station x, top and bottom, or null where it has none. */ export function bandAt(plank: Plank, x: number): [number, number] | null { const top = Math.max(plank.yTop, sheer(x)); const bottom = Math.min(plank.yBot, profile(x)); return bottom - top > 0.05 ? [top, bottom] : null; } const LIFT_DEPTH = seamDepth(1) - seamDepth(0); export type Station = { x: number; depth: number }; /** A plank's depth at 49 stations along it, stern to bow. */ export function depths(plank: Plank): Station[] { return Array.from({ length: 49 }, (_, i) => { const x = plank.x0 + ((plank.x1 - plank.x0) * i) / 48; const band = bandAt(plank, x); return { x, depth: band ? band[1] - band[0] : 0 }; }); } /** The first and last x where a plank is at least `depth` deep, or null where it never is. */ export function stretch( stations: readonly Station[], depth: number, ): [number, number] | null { const deep = stations.filter((station) => station.depth >= depth); const [first, last] = [deep[0], deep.at(-1)]; return first && last ? [first.x, last.x] : null; } /** * The plank's body, where its number goes: where it is nearly a whole lift deep, or nearly as deep * as it ever gets, for one the stem, stern or keel cuts. */ export function plankBody( stations: readonly Station[], ): [number, number] | null { const deepest = Math.max(...stations.map((station) => station.depth)); return stretch(stations, 0.9 * Math.min(deepest, LIFT_DEPTH)); } // --- /crew's detail drawing (.crew/sprint/36/contract.md, "The detail drawing", "A tick") ------ /** * The tally on th3b:T7d0, tip: { from: 1 / 2, to: 7 / 8, inset: 0, width: 2, dot: 8 }, } as const; // --- A plank's depth and body --------------------------------------------------------------- // Here rather than in the drawing, so /crew's crop and tally (below) and the 3D read one body. /** A plank's depth at station x, top and bottom, or null where it has none. */ export function bandAt(plank: Plank, x: number): [number, number] | null { const top = Math.max(plank.yTop, sheer(x)); const bottom = Math.min(plank.yBot, profile(x)); return bottom - top > 0.05 ? [top, bottom] : null; } const LIFT_DEPTH = seamDepth(1) - seamDepth(0); export type Station = { x: number; depth: number }; /** A plank's depth at 49 stations along it, stern to bow. */ export function depths(plank: Plank): Station[] { return Array.from({ length: 49 }, (_, i) => { const x = plank.x0 + ((plank.x1 - plank.x0) * i) / 48; const band = bandAt(plank, x); return { x, depth: band ? band[1] - band[0] : 0 }; }); } /** The first and last x where a plank is at least `depth` deep, or null where it never is. */ export function stretch( stations: readonly Station[], depth: number, ): [number, number] | null { const deep = stations.filter((station) => station.depth >= depth); const [first, last] = [deep[0], deep.at(-1)]; return first && last ? [first.x, last.x] : null; } /** * The plank's body, where its number goes: where it is nearly a whole lift deep, or nearly as deep * as it ever gets, for one the stem, stern or keel cuts. */ export function plankBody( stations: readonly Station[], ): [number, number] | null { const deepest = Math.max(...stations.map((station) => station.depth)); return stretch(stations, 0.9 * Math.min(deepest, LIFT_DEPTH)); } // --- /crew's detail drawing (.crew/sprint/36/contract.md, "The detail drawing", "A tick") ----- /** * The tally on the plank in pencil: the sprint's number, then one graphite tick per moment the * panel lists, then the copper pen. Hul3c:T54b,/** A plank's depth at station x, top and bottom, or null where it has none. */ function bandAt(plank: Plank, x: number): Point | null { const top = Math.max(plank.yTop, sheer(x)); const bottom = Math.min(plank.yBot, profile(x)); return bottom - top > 0.05 ? [top, bottom] : null; } const LIFT_DEPTH = seamDepth(1) - seamDepth(0); /** A plank's depth at 49 stations along it, stern to bow. */ function depths(plank: Plank) { return Array.from({ length: 49 }, (_, i) => { const x = plank.x0 + ((plank.x1 - plank.x0) * i) / 48; const band = bandAt(plank, x); return { x, depth: band ? band[1] - band[0] : 0 }; }); } /** The first and last x where a plank is at least `depth` deep, or null where it never is. */ function stretch(stations: ReturnType, depth: number) { const deep = stations.filter((station) => station.depth >= depth); const [first, last] = [deep[0], deep.at(-1)]; return first && last ? ([first.x, last.x] as Point) : null; } /** * The plank's body, where its number goes: where it is nearly a whole lift deep, or nearly as deep * as it ever gets, for one the stem, stern or keel cuts. */ function plankBody(stations: ReturnType) { const deepest = Math.max(...stations.map((station) => station.depth)); return stretch(stations, 0.9 * Math.min(deepest, LIFT_DEPTH)); } /**3d:T4f8,I'm not replying to Probe, since he asked for a reply only if I wanted the stricter reading, and I don't. He'll tell you which reading he used. **What he raised.** B4.34 says "No tick is within 4 px of the dot's ring". Read as a 4 px gap outside the dot's edge, it fails at 390 on the contract's own geometry: | Width | Seat | Gap between tick and dot | |---|---|---| | 390 | 6.1 | 2.6 px | | 390 | 3.0 (the live fixture's) | 0.5 px | | 1440 | 6.1 and 3.0 | passes | **The reading he'll use instead:** "no tick's stroke box comes within 4 px of the dot's centre", checked at 1440 and 390. That means no tick ever touches the 8 px dot. It matches Iris's own words ("clears its 8 px at every width"), so it keeps the visitor's outcome: the copper dot is always whole. **What's left for you:** - **The contract wording.** B4.34 in `.crew/sprint/36/contract.md` still says "within 4 px of the dot's ring". Change it to Probe's wording so the contract and the spec say the same thing; I didn't edit it after handing back. - **The 0.5 px gap on seat 3.0 at 390.** Probe's check passes there, but the clearance is thin. If Iris wants more room on short seats at phone widths, she'd widen the tick spacing below 768. That's her call, and it isn't needed for the check to hold.3e:T666, // /crew's detail (.crew/sprint/36/contract.md, "Full"): the model turns and lifts about the focus // point, which keeps its frame-1 screen point and its size there through the move, so the plank // being drawn stays where the visitor's eye is. Closed form, so every frame is exact: the scale // pays back the lift's magnification at the focus, s / (1 − z_F / D) = frame 1's scale, with // z_F = z + s × (R F).z; the focus is unprojected at that depth and the origin set off it. const crewAt = focus ? (e: number): Pose => { const yaw = SETTLE_CREW.yaw * e; const pitch = SETTLE_CREW.pitch * e; const invD = e / lens; const z = from.lift + SETTLE_CREW.lift * scale * e; const r = place(focus, { x: 0, y: 0, z: 0, yaw, pitch, s: 1 }); const s = (scale * (1 - z * invD)) / (1 + scale * r[2] * invD); const k = 1 - (z + s * r[2]) * invD; const [fx, fy] = [from.cx + focus[0] * scale, from.cy - focus[1] * scale]; return { x: width / 2 + (fx - width / 2) * k - s * r[0], y: -(height / 2 + (fy - height / 2) * k) - s * r[1], z, yaw, pitch, s, }; } : null; // Solved once at SAMPLES + 1 points; a frame interpolates instead of solving. const table = crewAt ? [] : Array.from({ length: SAMPLES + 1 }, (_, i) => solve(i / SAMPLES)); const at = (e: number): { pose: Pose; invD: number } => { if (crewAt) { const u = Math.min(1, Math.max(0, e)); return { pose: crewAt(u), invD: u / lens }; } const f = Math.min(1, Math.max(0, e)) * SAMPLES;3f:T6c3,After my first report, Probe asked about one check in the contract. I didn't reply, because he asked for a reply only if I wanted the stricter reading. One wording fix in the contract is left for you. **What Probe raised.** B4.34 says "No tick is within 4 px of the dot's ring". Read as a 4 px gap outside the dot's edge, it fails at 390 on the contract's own geometry: | Width | Seat | Gap between tick and dot | |---|---|---| | 390 | 6.1 | 2.6 px | | 390 | 3.0 (the live fixture's) | 0.5 px | | 1440 | 6.1 and 3.0 | passes | **The reading he's using:** "no tick's stroke box comes within 4 px of the dot's centre", checked at 1440 and 390. So no tick ever touches the 8 px copper dot. That matches Iris's call ("clears its 8 px at every width") and keeps what the visitor needs: the dot is always whole. He'll tell you which reading he used. **For you:** - **The wording.** B4.34 in `/home/user/theseus-portfolio/.crew/sprint/36/contract.md` (626e126 on `sprint/36-b4d-crew-hull`) still says "within 4 px of the dot's ring". Change it to Probe's wording so the contract and the spec say the same thing. I didn't edit it after handing back. - **Seat 3.0 at 390.** Probe's check passes there, but only 0.5 px separates the tick from the dot. If Iris wants more room on short seats below 768, she would widen the tick spacing. That's her call, and the check holds without it. Everything in my first report still stands: - the contract and its two commits, 6accef2 and 626e126, not pushed; - the decisions you need to make: whether the 18,432 B budget needs an Owner's pick (my view is no), and CI's 25-minute cap; - Iris's pending 3D pose numbers; - the stale `ROADMAP.md` B5c rider line, whose two nits sprint 34 already took.40:T540,python3 - <<'EOF' import re p='lib/model/loft.ts' s=open(p).read() s=s.replace('''import { DURATION, G_NARROW,''','''import { CREW_DURATION, DURATION, G_NARROW,''',1) s=s.replace(''' SETTLE, SETTLE_GHOST, SETTLE_NARROW, } from "./calls";''',''' SETTLE, SETTLE_CREW, SETTLE_GHOST, SETTLE_NARROW, } from "./calls";''',1) s=s.replace('''/** The loft for one canvas over `layout`'s drawing: the pose and the camera's 1/D at eased * progress e. */ export function makeLoft(frame: Frame, points: Vec3[], layout: Layout) { const { width, height, ratio = 1 } = frame; const margin = EDGE + 0.5 / ratio; const settle = settleOn(layout);''','''/** * The loft for one canvas over `layout`'s drawing: the pose and the camera's 1/D at eased progress * e. With `focus`, a point in the model's frame, it is /crew's move about that point instead. */ export function makeLoft( frame: Frame, points: Vec3[], layout: Layout, focus?: Vec3, ) { const { width, height, ratio = 1 } = frame; const margin = EDGE + 0.5 / ratio; const settle = settleOn(layout);''',1) s=s.replace(''' /** The move's length in ms. */ duration: settle.duration,''',''' /** The move's length in ms. */ duration: focus ? CREW_DURATION : settle.duration,''',1) open(p,'w').write(s) EOF grep -n "CREW\|focus" lib/model/loft.ts | head41:T7d0,cd /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/js2 && python3 - <<'EOF' p='proto.js' s=open(p).read() old='const xc0 = cfg.rest ? (body[0] + body[1]) / 2 : tip - 26 * f;\nconst xc = Math.min(624 - ACROSS / 2 + 20, Math.max(ACROSS / 2 - 20, xc0 + (cfg.shift ?? 0)));' assert old in s new='''// The crop: the end of the hull nearer the plank's centre, with 20 units of film past it, moved // only as far as keeps the tally (number to dot) 12% of the box clear of either edge. const mid0 = (plank.x0 + plank.x1) / 2; const anchored = mid0 < LENGTH / 2 ? ACROSS / 2 - 20 : LENGTH + 20 - ACROSS / 2; const tallyL = cfg.rest ? (body[0] + body[1]) / 2 - 20 : tip - 52 * f - 4; const tallyR = cfg.rest ? (body[0] + body[1]) / 2 + 20 : tip + 2; const M = 0.12 * ACROSS; const lo = tallyR + M - ACROSS / 2, hi = tallyL - M + ACROSS / 2; const xc = lo > hi ? (tallyL + tallyR) / 2 : Math.min(hi, Math.max(lo, anchored));''' s=s.replace(old,new) # ticks crossing the edge s=s.replace('return `M${n1(x)} ${n1(y)}V${n1(y - MARKS.h * s)}`;','return `M${n1(x)} ${n1(y + (cfg.below ?? 2) * s)}V${n1(y - MARKS.h * s)}`;') s=s.replace('for (const tk of ticks) out.push(...nearSide(tk.x, tk.bottom, 0.4), ...nearSide(tk.x, tk.bottom - MARKS.h, 0.4));','for (const tk of ticks) out.push(...nearSide(tk.x, tk.bottom + (cfg.below ?? 2), 0.4), ...nearSide(tk.x, tk.bottom - MARKS.h, 0.4));') # hold framed height of the skeleton instead of the span old2=''' const a = proj(place(focusA, pose), invD), b = proj(place(focusB, pose), invD); const len = Math.hypot(a[0] - b[0], a[1] - b[1]); sz *= wantLen / len;''' assert old2 in s new2=''' if (cfg.hold === "span") { const a = proj(place(focusA, pose), invD), b = proj(place(focusB, pose), invD); sz *= wantLen / Math.hypot(a[0] - b[0], a[1] - b[1]); } else if (cfg.hold === "height") { const ys = hull.points.map((q) => proj(place(q, pose), invD)[1]); sz *= wantH / (M42:T7d0,// The hull on /crew (.crew/sprint/36/contract.md, "The hull on /crew", calls 2 to 4): what the chunk // reads off the detail drawing the server drew and the poller keeps, and the tally laid on the hull. // The drawing is the interface (call 4): which seat it is close on (`data-focus`), what the run is // now (`data-run`), the pencil plank, and the shown ticks (`[data-mark]`). No three.js. import { PLANKS } from "@/lib/hull-layouts"; import { MARKS, tallyOf } from "@/lib/hull-layouts"; import { bandAt, nearSide, plankBody, type Vec3 } from "./hull"; /** What the run is now, by call 3's table: the server's value, then each told answer's. */ export type Run = "live" | "open" | "inked" | "record"; const runOf = (value: string | undefined): Run => value === "live" || value === "open" || value === "inked" ? value : "record"; /** The drawing's state, as the poller leaves it: what the hull must agree with. */ export type CrewState = { run: Run; /** The planks the drawing fills as seated card (its pencil plank aside). */ seated: Set; /** The ticks the drawing shows, at most MARKS.count: only on the pencil plank, live or open. */ marks: number; /** The focus plank's number, as lettered now (the pencil's n, the holder's, or n inked). */ label: string; }; /** The detail drawing on /crew: `[data-plan]` with `data-focus`. */ export const isCrew = (plan: Element | null | undefined): plan is HTMLElement => Boolean(plan?.matches("[data-plan][data-focus]")); /** A tick is shown unless it is absent or `display: none` (the contract, "Its hook"). */ const shown = (element: Element) => getComputedStyle(element).display !== "none"; /** * The state `drawing` (one of the two detail drawings) shows now. A drawing hidden at this width * still has its own ticks' display, which is what counts: both drawings carry the same state. */ export function readState(plan: HTMLElement, drawing: Element): CrewState { const run = runOf(plan.dataset.run); const sea43:T7d0,python3 - <<'EOF' p='lib/model/stage.ts' s=open(p).read() def rep(a,b): global s assert s.count(a)==1, a s=s.replace(a,b) rep('''/** * The scene on `canvas`: the sheet's white card model, or with `ghost` the Log's ghost hull * (.crew/sprint/33/): the same card, lines and rig, in vellum, with no shadow. */ export function createStage( canvas: HTMLCanvasElement, hull: Hull, ghost = false, /** A coarse hull to pick against: a ray costs 0.1 ms on it, 0.5 to 0.7 on the drawn one. */ pickHull?: Hull, ) {''','''/** * The scene on `canvas`: the sheet's white card model, or with `ghost` the Log's ghost hull * (.crew/sprint/33/): the same card, lines and rig, in vellum, with no shadow. With `tally`, /crew's * card model (.crew/sprint/36/): the sheet's, whose ink marks batch is the pencil plank's ticks. */ export function createStage( canvas: HTMLCanvasElement, hull: Hull, ghost = false, /** A coarse hull to pick against: a ray costs 0.1 ms on it, 0.5 to 0.7 on the drawn one. */ pickHull?: Hull, tally = false, ) {''') rep(''' // The dot's round caps are the material's discard: alpha to coverage smooths their edge under // MSAA. Not the run's: where its spans' caps overlap at a joint, partial coverage lightens it. if (tip) tip.dot.material.alphaToCoverage = true;''',''' // The dot's round caps are the material's discard: alpha to coverage smooths their edge under // MSAA. Not the run's: where its spans' caps overlap at a joint, partial coverage lightens it. if (tip) tip.dot.material.alphaToCoverage = true; // /crew's ticks (.crew/sprint/36/contract.md, "A tick"): the marks batch, one draw, graphite at // 1.4 px, each a chord 3.5 units up the near side from the lower edge, which the card bulges past // as it does past the tip: they take the tip's lift. Paint order is plank, edge, ticks, then the // tip, so the copper covers the ticks' feet on the edge and nothing covers the copper. if (tally && tip) { marks.materia44:T7d0,import type { Page } from "@playwright/test"; import { profile as keel, seamDepth, sheer } from "../lib/half-model"; import { PLANKS } from "../lib/hull-layouts"; import type { CrewState } from "./crew"; import { pencilSeat } from "./live-layer"; import { MERGED, SEAT_OF } from "./retros"; // The oracle for B4d, the detail drawing on /crew (.crew/sprint/36/contract.md, "Data rules": the // detail drawing, the crop, the lettering and a tick), in this suite's own lines from the // contract's words, never the page's code. The hull's shape (lib/half-model.ts) and its plank // boxes (PLANKS) are the ground every drawing shares; the layouts' numbers, the crop, the seat's // body, f, the ticks' places and the number's anchor are written here from the contract. The page // readers below name no class: the shown drawing is the `svg` in `[data-plan]` with a box, and the // hooks are the contract's (`data-focus`, `data-run`, `[data-mark]`, `[data-tip]`, the pencil's // `data-pencil`, `data-sprint` and `data-live`). export type Run = "live" | "open" | "inked" | "record"; /** A detail layout: its viewBox and its scale (hull units to viewBox units). */ export type Detail = { name: "CREW_WIDE" | "CREW_NARROW"; box: readonly [number, number, number, number]; s: number; }; /** From 768 px (the contract's CREW_WIDE). */ export const CREW_WIDE: Detail = { name: "CREW_WIDE", box: [0, 0, 808, 454.5], s: 2.525, }; /** Below 768 px (CREW_NARROW). */ export const CREW_NARROW: Detail = { name: "CREW_NARROW", box: [0, 0, 390, 219.4], s: 1.21875, }; export const detailAt = (width: number) => width >= 768 ? CREW_WIDE : CREW_NARROW; /** * Iris's sizes for the shown drawing, CSS px, by viewport width: exact where her table gives a * size, at most 600 wide from 768 to 1023 (and 16:9 there). */ export const DETAIL_SIZES: { width: number; w: number | null; h: number | null }[] = [ { width: 1440, w: 808, h: 454.5 }, { width: 1024, w: 553, h: 311 }, { width: 45:T7d0,// The hull on /crew (.crew/sprint/36/contract.md, "The hull on /crew", calls 2 to 4): what the chunk // reads off the detail drawing the server drew and the poller keeps, and the tally laid on the hull. // The drawing is the interface (call 4): which seat it is close on (`data-focus`), what the run is // now (`data-run`), each plank's `data-sprint`, the pencil plank, and the shown ticks // (`[data-mark]`). The crop, the tally and the ticks' places are lib/hull-layouts.ts's, which the 2D // draws from too, so the hull can't disagree with the drawing. No three.js. import { bandAt, crewLayout, type Detail, focusX, type Layout, MARKS, markX, PLANKS, tallyOf, } from "@/lib/hull-layouts"; import { nearSide, type Vec3 } from "./hull"; /** What the run is now, by call 3's table: the server's value, then each told answer's. */ export type Run = "live" | "open" | "inked" | "record"; const runOf = (value: string | undefined): Run => value === "live" || value === "open" || value === "inked" ? value : "record"; /** The drawing's state, as the poller leaves it: what the hull must agree with. */ export type CrewState = { run: Run; /** The planks the drawing seats (each with a `data-sprint`), the pencil plank's n included. */ seated: Set; /** The ticks the drawing shows, at most MARKS.count: only on the pencil plank, live or open. */ marks: number; /** The focus plank's number, as lettered now (the pencil's n, n inked, or the holder's). */ label: string; }; /** The detail drawing on /crew: `[data-plan]` with `data-focus`. */ export const isCrew = (plan: Element | null | undefined): plan is HTMLElement => Boolean(plan?.matches("[data-plan][data-focus]")); /** * A tick is shown unless it is absent or `display: none` (the contract, "Its hook"). Computed * display isn't inherited, so a tick in the drawing hidden at this width still counts as its own. */ const shown = (element: Element) => getComputedStyle(element).display !== "non46:T695,cd /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/js2 && python3 - <<'EOF' p='proto.js' s=open(p).read() s=s.replace('const MARKS = { pitch: 4, first: 6, h: 3.5, number: 52, span: 54, deep: 6 };','const MARKS = { pitch: cfg.pitchU ?? 5, first: (cfg.pitchU ?? 5) * 1.5, h: cfg.h ?? 4, deep: 2 };\nMARKS.span = MARKS.first + 9 * MARKS.pitch;') s=s.replace('const f = Math.min(1, (tip - xs) / MARKS.span);','const f = Math.min(1, (tip - xs - 2) / MARKS.span);') # hanging ticks: from bottom to bottom + h (2D) s=s.replace('return `M${n1(x)} ${n1(y + (cfg.below ?? 2) * s)}V${n1(y - MARKS.h * s)}`;','return `M${n1(x)} ${n1(y)}V${n1(y + MARKS.h * s)}`;') s=s.replace('for (const tk of ticks) out.push(...nearSide(tk.x, tk.bottom + (cfg.below ?? 2), 0.4), ...nearSide(tk.x, tk.bottom - MARKS.h, 0.4));','''const under = (x, y) => { const lim = profile(x); return y > lim ? [...nearSide(x, lim, 0.4).slice(0, 1), HEIGHT / 2 - y, 0.4] : nearSide(x, y, 0.4); }; for (const tk of ticks) out.push(...nearSide(tk.x, tk.bottom, 0.4), ...under(tk.x, tk.bottom + MARKS.h));''') # number: body middle, or 20 units aft of the tip, whichever is further aft s=s.replace('const numX = tally ? tip - MARKS.number * f : (body[0] + body[1]) / 2;','const numX = tally ? Math.min((body[0] + body[1]) / 2, tip - 20) : (body[0] + body[1]) / 2;') s=s.replace('const tallyL = cfg.rest ? (body[0] + body[1]) / 2 - 20 : tip - 52 * f - 4;','const tallyL = cfg.rest ? (body[0] + body[1]) / 2 - 20 : Math.min(tip - MARKS.span * f, Math.min((body[0] + body[1]) / 2, tip - 20) - 6);') open(p,'w').write(s) EOF grep -n "MARKS\.\|numX =\|tallyL =\|under" proto.js | head -2047:T7d9,Forge: the layouts are on origin/forge/36 (6c00e46, lib/hull-layouts.ts). Shape, as you asked: - `CREW_WIDE` / `CREW_NARROW`: `Detail = { box, s, numbers }` (808×454.5 s 2.525; 390×219.4 s 1.21875). - `crewLayout(detail, focus, pencil): Layout` — box, ox (crop, clamped xc 140..484), oy = 24·s, s, hbY 0 (unused: profile only). `pencil` = the SERVER drew the focus seat in pencil. Don't infer it from data-run: the first poll runs at hydration, before your chunk, and may already have set inked/record. Read it as `[data-plan]`'s focus path having `data-tally` (I'll put `data-tally` on `[data-plan]` itself: present iff the server drew a tally, i.e. the crop is the tally's middle). The crop never moves after first paint. - `focusX(focus, pencil)`: the UNclamped focus point's x (tally middle in pencil, body middle otherwise) — your 1 px focus point. The crop centres on its clamp. - `tallyOf(seat) → { tip, f } | null`, `markX(tally, i)`, `MARKS = { h: 3.5, first: 6, step: 4, count: 10, width: 1.4 (CSS px), span: 54, deep: 6, middle: 26, number: 52 }`. f = 1 everywhere but 3.0 (0.718) and 5.0 (0.193). - `bandAt`, `depths`, `stretch`, `plankBody(stations)` now live there too (moved from lib/lines-plan.ts), if you want one body with the 2D. Answers: (1) `[data-plan][data-focus][data-run]` (plus `data-tally` as above) > `.plan-view.plan-wide.plan-crew` and `.plan-view.plan-narrow.plan-crew`: same `.plan-wide`/`.plan-narrow` classes as `/`, so your lookup finds them; tell /crew apart by `[data-focus]` on the plan. Shown per width by the existing rules (wide from 768). Each svg is clipped to its box (overflow hidden), and so is the view (lettering too). (2) One `path[data-mark]` per SHOWN tick, inside `` in each drawing's svg, after the outline and before the tip. Unshown ticks are ABSENT (not display:none), so `drawing.querySelectorAll("[data-mark]").length` is the count for that drawing. The poller adds/removes them on a told answer (and only when the cou48:T693,Forge, building /crew's 2D detail (sprint 36): two of the contract's numbers disagree with the geometry. I need your call on each; I'm building with the contract's numbers meanwhile. 1) The 4 px gap at narrow widths (B4.34: "no tick within 4 px of the dot's ring"). Tick 0 sits 6·f hull units aft of the dot's centre. At 1440 that's 15.2 px (gap to the 8 px dot's edge ≈ 10.4 px, fine). But the narrow drawing is 358 px for 320 units at 390 (1.119 px/unit): 6.7 px from the centre, so the tick's edge is 2.0 px from the dot. At 320 it's 0.7 px. On 3.0 (f 0.718) it overlaps. Options: (a) `first` 6→9 (at 390: 10.1 px, gap 5.4; costs 12 units of tally, so number at tip−55 and f's span 57); (b) keep it in hull units but start the ticks a fixed CSS distance aft of the dot (breaks "the same numbers in 2D and 3D"); (c) relax the check to wide only. My lean: (a), changed in MARKS so the 3D follows. 2) The width at 1024: the contract has 553 × 311, but `.crew-page`'s columns are `minmax(0,1fr) min(600px, 42.86%)` inside 16 px margins, and the % resolves against the grid (992 px), so column 1 is 566.8 px. 553 is 1024 − 32 − 42.86% of 1024. Either the drawing is 566.8 × 318.8 at 1024 (my lean: no CSS change, the frame's 808 at 1440 holds either way) or I change the panel to 42.86vw. Probe's B4.33 checks your number within 1 px, so whichever you pick I'll tell Probe. Also (rider (b) on #87): tick 9 sits 10·f units sternward of the number's centre. At 390 that's 11.2 px, and a three-digit chip (the 999 fixture) at 11 px is about 23 px wide, so 10 ticks would put tick 9 under the chip there. (a) above doesn't fix that one. Fine as is, or widen `number` 52→54?49:T7d1,/** * The focus plank's number in `drawing`, the one number lettered on it at every width (the * contract, "Lettering"): the pencil's on its chip, or the number its `data-sprint` names. */ export function focusLabel(plan: HTMLElement, drawing: Element) { const focus = plan.dataset.focus ?? ""; const sprint = drawing .querySelector(`path[data-plank="${CSS.escape(focus)}"]`) ?.getAttribute("data-sprint"); const spans = [ ...drawing.querySelectorAll(":scope > .plan-plank"), ]; return ( spans.find((span) => span.classList.contains("plan-pencil")) ?? (sprint ? spans.find((span) => span.textContent === sprint) : undefined) ?? null ); } /** * The layout `drawing` is drawn on: Forge's crop around `data-focus`, the tally's middle if the * server drew the seat in pencil, its body's middle if not. Which one the server drew is read off * the drawing's own planks, since a poll may have changed `data-run` before the chunk came, and * no poll moves the crop (call 2). Returns the layout and whether it is the pencil's crop. */ export function detailLayout( plan: HTMLElement, drawing: Element, detail: Detail, ): { layout: Layout; pencil: boolean } { const focus = plan.dataset.focus ?? ""; // Each plank's path starts at its stern end and top, ox + x0 × s, to a tenth of a unit. let [sum, n] = [0, 0]; for (const path of drawing.querySelectorAll("path[data-plank]")) { const plank = PLANKS.find( (candidate) => candidate.id === path.getAttribute("data-plank"), ); const x = path.getAttribute("d")?.match(/^M\s*(-?[\d.]+)/)?.[1]; if (plank && x !== undefined) { sum += Number(x) - plank.x0 * detail.s; n++; } } const run = plan.dataset.run; const pencil = crewLayout(detail, focus, true); const body = crewLayout(detail, focus, false); const drawn = n ? sum / n : Number.NaN; const isPencil = Number.isNaN(drawn) ? run === "live" || run === "open" : Math.abs(drawn - penc4a:T7d0,import { type Browser, expect, type Page } from "@playwright/test"; import { expected } from "./crew"; import { type Answer, type Crew, type Fixture, STATE_WAIT, crewTest as test, untilState, } from "./crew-feed"; import { boxToPoint, CREW_WIDE, cropOf, DETAIL_SIZES, type DetailRead, detailAt, focusOf, inside, MID_MAX, momentsShown, NEWEST, numberAnchor, overlaps, readDetail, recordPlan, serverRun, TICK, takePlan, tickAt, tipDot, } from "./crew-hull"; import { FIXTURE_STUDIO, feedOf, type Live, livePage, type Patch, toAnswer, } from "./crew-live"; import { installRgba, SCHEMES } from "./helpers"; import { tokenRgba } from "./log"; import { deltaE } from "./pixels"; import { refuseWebGl } from "./webgl"; // Sprint 36, B4d (.crew/sprint/36/contract.md, B4.33 to B4.35): /crew's detail drawing in 2D, one // tick per moment, written before the build. Every page here refuses WebGL (the Off path, the // contract's "2D checks run on the Off path"), so the drawing is read as the server and the poll // leave it, with no model over it. The oracle is e2e/crew-hull.ts (the layouts, the crop, f, the // ticks' places and the number's anchor, from the contract's words); the states come from B4a's // kept fixture sites (e2e/crew-feed.ts) and, for the poll, from `page.route` answering // `/api/crew` with the oracle's `toAnswer` on Playwright's clock (B4c's `livePage`). Each check // reads 1440 x 900 and 390 x 844, and B4.33 the five widths of Iris's table. test.describe.configure({ mode: "default" }); test.skip( Boolean(process.env.PLAYWRIGHT_BASE_URL), "PLAYWRIGHT_BASE_URL is set: these checks need this checkout's build, served without a feed (the down state) and from copies pointed at the fixture server", ); test.use({ timezoneId: "America/Los_Angeles" }); test.beforeEach(async ({ context }) => { await context.addInitScript(installRgba); await context.addInitScript(refuseWebGl); }); const SIZES: [number, nu4b:T7d0, const ghost: GhostPage | undefined = ghostDrawing ? readGhost(ghostDrawing) : undefined; // /crew's detail drawings (.crew/sprint/36/contract.md, "The hull on /crew"): `.plan-wide` and // `.plan-narrow` too, told apart by the plan's `data-focus`. What they show changes with each // told answer, so it is read again whenever the drawing changes (`sync`). const crew = isCrew(plan) ? plan : null; const key = crew ? PLAYED_CREW : ghost ? PLAYED_GHOST : PLAYED; /** What /crew's drawing shows now, the last time it was read. */ let told: CrewState | null = crew ? readState(crew, wide) : null; /** * A drawing's pencil plank and its number, read off the drawing: the Log's ghost shows no pencil * (.crew/sprint/34/). On /crew the pencil is the run's while it is live or open, its tip only * while live, and the number riding the hull is the focus plank's, in every state. */ const pencilled = (drawing: Element, layout: Layout) => { if (crew) { const run = told?.run; const found = run === "live" || run === "open" ? readPencil(drawing) : null; const label = focusLabel(drawing); return { pencil: found && { ...found, live: found.live && run === "live" }, ride: label ? riders( { labels: [riderLabel(label, crew.dataset.focus ?? "", layout)] }, layout, true, ) : null, }; } const pencil = ghost ? null : readPencil(drawing); const label = pencil && pencilLabel(drawing, pencil.seat, pencil.sprint, layout); return { pencil, ride: label ? riders({ labels: [label] }, layout, true) : null, }; }; // The level and the cap follow the drawing, not the device (.crew/sprint/26/contract.md, "The // calls I made"): the three views from 768 px, the profile and half-breadth plan below. The // ghost's one drawing takes the desktop's level and cap from 768 px, the phone's below, and so do // /crew'4c:T4e9, const ghost: GhostPage | undefined = ghostDrawing ? readGhost(ghostDrawing) : undefined; const key = ghost ? PLAYED_GHOST : PLAYED; /** * A drawing's pencil plank and its number, read off the drawing as the server drew it: the Log's * ghost shows no pencil (.crew/sprint/34/). */ const pencilled = (drawing: Element, layout: Layout) => { const pencil = ghost ? null : readPencil(drawing); const label = pencil && pencilLabel(drawing, pencil.seat, pencil.sprint, layout); return { pencil, ride: label ? riders({ labels: [label] }, layout, true) : null, }; }; // The level and the cap follow the drawing, not the device (.crew/sprint/26/contract.md, "The // calls I made"): the three views from 768 px, the profile and half-breadth plan below. The // ghost's one drawing takes the desktop's level and cap from 768 px, the phone's below. const sheets: Record<"wide" | "narrow", Sheet> = { wide: { drawing: wide, layout: ghost ? GHOST : WIDE, level: DESKTOP, cap: 2, ...pencilled(wide, WIDE), }, narrow: { drawing: narrow, layout: ghost ? GHOST : NARROW, level: PHONE, cap: 1.5, ...pencilled(narrow, NARROW), }, };4d:T7de,Iris → Forge: final numbers for B4d's marks and the detail drawing. They replace my first calls (the ones in contract 626e126) wherever the two differ. I rendered the real hull and drawing over production's /crew. The ticks I first called rose into the plank, and in 3D they disappear into the hatch on lift 6 (this sprint's 6.1), so they now hang below the edge. Sorry for the churn; it's cheaper now than in review. YOUR THREE QUESTIONS 1. The gap at narrow widths: your (a), and wider still. first = 10 units (two pitches), in MARKS, so the 3D follows. At 358 px that's 11.2 px from the dot's centre, a 6.5 px gap to its edge. At 320 it's 10 px, a 5.3 px gap. 2. 1024: your lean is right. The wide drawing is 566.8 × 318.8 there, with no CSS change. Tell Probe 566.8. 3. Tick 9 under a 3-digit chip: gone. Ticks now hang below the lower edge and the number is mid-band above it, so they can't meet. The number goes back near B4b's place (below). There's no `number: 52` any more. MARKS (lib/hull-layouts.ts) ``` pitch: 5 // hull units between ticks, along x first: 10 // slot 0's distance aft of the tip's dot (PENCIL.tip.to's x), hull units length: 4 // hanging DOWN from the plank's lower edge, hull units width: 1.4 // CSS px, non-scaling, butt caps, --muted (forced colours: CanvasText) max: 10 deep: 2 // for f ``` - Slot k (k = 0 to n − 1) is at x_k = tip − (first + pitch·k)·f. - The tick runs from (x_k, bottom) to (x_k, bottom + length), where bottom is bandAt(plank, x_k)[1]: the seam, or the keel's outline on lift 6. It's vertical in 2D. - Slot 0 is nearest the dot. A new moment fills the next slot aft, and no tick ever moves (your B4.35 holds). - f = min(1, (tip − xs − 2) / 55), where 55 is first + 9·pitch and xs is the plank's sternmost x where its band is at least `deep` units. - f = 1 on 6.1, 2.1 and every long seat. - About 0.82 on 3.0 and about 0.33 on 5.0, which leaves a dense comb on 5.0. That's accepted: one sprint in 22. - Paint order 4e:T5c3, /** The ticks the stage holds: what the next frame draws, and `data-marks` once it has. */ let marked = 0; /** /crew's ticks on the pencil plank, as the drawing shows them now (its contract, "A tick"). */ function tally() { const pencil = (on ?? sheet).pencil; const ticks = told && pencil ? tickSegments(pencil.seat, told.marks) : new Float32Array(0); stage?.mark(ticks); marked = ticks.length / 6; } /** The planks the stage fills as seated card: on /crew, the drawing's now (call 3). */ const seats = () => told?.seated ?? seated; /** * /crew's drawing changed: a told answer set `data-run`, added or took ticks, or seated planks * anew (call 3). Read again, and if the frame would differ, the stage takes it and draws 1 frame * at rest, or the move's next frame does; a change that draws the same frame draws none. */ const sync = () => { if (!crew || !alive) return; const next = readState(crew, sheet.drawing); if (sameState(told, next)) return; told = next; for (const each of [sheets.wide, sheets.narrow]) { each.ride?.clear(); Object.assign(each, pencilled(each.drawing, each.layout)); } if (!stage || !on) return; stage.paint(palette(), seats()); stage.pencil(on.pencil && pencilMarks(on.pencil, on.layout, on.level)); tally(); redraw(); }; /** Puts the model on the drawing shown: that drawing's level, ratio cap, loft and shadow. */4f:T7df,Iris → Atlas: my B4d calls are final, including the 3D pose. Forge has the 2D half in full. They amend contract 626e126 in three places (marked AMEND below); please pass the AMENDs to Quill, Probe and Pixel. I rendered the real hull (lib/model/stage.ts, SwiftShader) and the real drawing code over production's /crew, at 1440, 1024 and 390, on seats 6.1 (now), 2.1 (next), 3.0 (fixtures), 0.2 (at rest) and 5.0 (the worst case). AMEND 1, the mark: ticks hang below the plank's lower edge, not rising into it. - Why: in 3D the hatch on lift 6 (6.1, this sprint's real seat) turns near-vertical under the turn, and rising ticks vanish into it. - Hanging below, they sit on white card, or on the film under the keel, and read crisply in both 2D and 3D. - They also no longer meet the number, so the number goes back to B4b's place. - MARKS: - pitch 5, first 10, length 4 (hull units), 1.4 px, --muted, max 10; - f = min(1, (tip − xs − 2) / 55); - slot k at tip − (10 + 5k)·f, slot 0 nearest the dot; - a new moment fills the next slot aft, and nothing moves. - Probe's B4.34 "inside the pencil plank's box" becomes: each tick's top on the plank's lower edge within 1 px, x inside the plank's x0..x1, and it hangs down. The "4 px from the dot" check holds at every width: the newest tick is 11.2 px from the dot's centre at 358 px and 10 px at 320. AMEND 2, the framing: 480 hull units across from 768, 320 below. My first 320-everywhere showed a wall of planks at desktop. - Each crop shows the end of the hull nearest the plank (stern or bow) wherever the tally (number to dot) stays 12% clear of the box's edges. - CREW_WIDE: box 808 × 454.5, s 1.68333, oy 109.08. - Drawn 566.8 × 318.8 at 1024 (Forge measured the grid; no CSS change), 600 × 337.5 from 768 to 1023, 808 at 1440. - CREW_NARROW: box 390 × 243.75, s 1.21875, oy 48.75. - The pencil number sits at min(body middle, tip − 20 units). That moves only 3.0 and 6.0, and settles rider (b) on /crew. AMEND 3, THE POSE (Pixel). The50:T562,Atlas → Probe: Iris's final calls amend the contract in three places (her notes-iris.md lands on the sprint branch shortly). AMEND 1, B4.34: ticks hang BELOW the plank's lower edge — each tick's top on the plank's lower edge within 1 px, x inside the plank's x0..x1, hanging down; MARKS pitch 5, first 10, length 4 hull units, 1.4 px, --muted, max 10; f = min(1,(tip−xs−2)/55); slot k at tip−(10+5k)·f, slot 0 nearest the dot; a new moment fills the next slot aft, nothing moves. The 4 px-from-dot-centre check holds at every width (newest tick 11.2 px from the dot at 358, 10 at 320). The pencil number goes back to B4b's place: min(body middle, tip−20). AMEND 2, framing: CREW_WIDE (from 768) box 808×454.5, s 1.68333, oy 109.08; CREW_NARROW (below 768) box 390×243.75, s 1.21875, oy 48.75. AMEND 3, B4.36 framing check: settled, the dot and the focus number's centre lie inside the canvas, ≥8% of its width from each side edge; the plank's projected depth at the tally's middle ≥18 px at 1440 and 1024, ≥16 px at 390, on seats 6.1, 3.0 and 31's fixture (5.0 exempt). Focus point held within 1 px through the move: on the lower edge at x = tip − 27.5·f in live/open, or the focus number's anchor at rest/down. Full 1,800 ms once a visit; Calm settled; reduced motion /'s 240 ms fade. Live is 7 of 8 draws (ticks are 1 draw). Adjust your specs to these.51:T62d,Atlas → Pixel: Iris's final calls, including the pose (notes-iris.md lands on the sprint branch shortly; message iris for detail). Ticks hang BELOW the plank's lower edge (MARKS: pitch 5, first 10, length 4 units, 1.4 px, --muted, max 10; f=min(1,(tip−xs−2)/55); slot k at tip−(10+5k)·f; Forge owns MARKS in lib/hull-layouts.ts). In 3D the ticks go in the stage's idle `marks` batch, recoloured --muted, 1 draw (live = 7 of 8); each runs nearSide(x,bottom) to nearSide(x,bottom+4); below the keel on the centre plane (z 0); the tip's uLift depth trick welcome so no tick hides behind the bilge. Framing: CREW_WIDE (from 768) box 808×454.5, s 1.68333, oy 109.08; CREW_NARROW box 390×243.75, s 1.21875, oy 48.75. POSE: yaw −35° (bow toward) when the focus plank's centre (x0+x1)/2 ≥ 312, else +35° (stern toward); pitch 6°; lift LIFT (90) as on /; lens 30°; hold the framed height (skeleton points, grow 0) as /'s HOLD; settled ≈0.75–0.85 of frame 1's scale. Hold the focus point on its frame-1 screen point within 1 px through the move: lower edge at x = tip − 27.5·f in live/open, or the focus number's anchor at rest/down. Full 1,800 ms on ease(), once a visit; Calm settled; reduced motion /'s 240 ms fade. The 2D goes hollow as on / (fills, ticks, tip and other numbers hidden; lines kept), the focus number rides. Settled checks Probe will hold: dot and focus number ≥8% of canvas width from each side; plank depth at the tally ≥18 px at 1440/1024, ≥16 px at 390 on 6.1, 3.0, 31's fixture. Iris wants an early look once it lifts — message her.52:T43e,cat >> .crew/sprint/36/decisions.md <<'EOF' 6. **Iris's three amendments to the contract** (her message to Atlas; `notes-iris.md`), accepted and relayed to Probe and Pixel (Forge had them from her): ticks hang below the pencil plank's lower edge (B4.34's box check becomes "top on the lower edge within 1 px, hanging down"); the crops are 480 hull units across from 768 and 320 below (`CREW_WIDE`, `CREW_NARROW`); the pose is yaw ±35° toward the focus plank's end, pitch 6°, lift 90, the focus point held within 1 px, with B4.36's framing bounds (8% from the sides; depth ≥ 18 px at 1440 and 1024, ≥ 16 px at 390; seat 5.0 exempt). B4.34's dot clearance reads as Probe checks it: no tick's box within 4 px of the dot's centre. EOF git commit -qam "Sprint 36: decision 6, Iris's amendments Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01QrjXvdJC9qJR4aHc8kQPQC" && git pull -q --rebase origin sprint/36-b4d-crew-hull && git push -q origin sprint/36-b4d-crew-hull 2>&1 | grep -v "remote\|UNDICI\|trace"53:T7d0,cd /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad && sed -i 's/first: (cfg.pitchU ?? 5) \* 1.5,/first: (cfg.pitchU ?? 5) * 2,/' js2/proto.js && grep -n "first:" js2/proto.js && cat > jobs6.json <<'EOF' [ { "name": "f-21-1440-dark", "dark": true, "vp": [1440, 900], "clip": { "x": 16, "y": 72, "width": 808, "height": 480 }, "cfg": { "seat": "2.1", "sprint": 37, "live": true, "n": 10, "three": true, "yaw": 35, "pitch": 6, "across": 480, "top": 0.24, "hold": "height" } }, { "name": "f-21-1440-dark-2d", "dark": true, "vp": [1440, 900], "clip": { "x": 16, "y": 72, "width": 808, "height": 480 }, "cfg": { "seat": "2.1", "sprint": 37, "live": true, "n": 10, "three": false, "across": 480, "top": 0.24 } }, { "name": "f-02rest-1440", "vp": [1440, 900], "cfg": { "seat": "0.2", "sprint": 35, "rest": true, "n": 0, "three": true, "yaw": -35, "pitch": 6, "across": 480, "top": 0.24, "hold": "height" } }, { "name": "f-61-1440", "vp": [1440, 900], "cfg": { "seat": "6.1", "sprint": 36, "live": true, "n": 6, "three": true, "yaw": -35, "pitch": 6, "across": 480, "top": 0.24, "hold": "height" } }, { "name": "f-61-390", "vp": [390, 844], "cfg": { "seat": "6.1", "sprint": 36, "live": true, "n": 6, "three": true, "yaw": -35, "pitch": 6, "across": 320, "aspect": 0.625, "top": 0.2, "hold": "height" } }, { "name": "f-61-390-2d", "vp": [390, 844], "cfg": { "seat": "6.1", "sprint": 36, "live": true, "n": 6, "three": false, "across": 320, "aspect": 0.625, "top": 0.2 } } ] EOF timeout 400 node shoot.mjs jobs6.json shots 2>&1 | grep -v UNDICI | grep -v trace-warnings | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{const r=JSON.parse(s);for(const[k,v]of Object.entries(r)){const p=v.report;console.log(k,"f",v.tally.f.toFixed(2),"xc",v.tally.xc.toFixed(0),"box",v.box.join("x"),p?`depth ${p.depthAtFocus.toFixed(1)} pitch ${p.pitches[0]}..${p.pitches.at(-1)} dot-newest ${p.dotToNewest} scale ${p.scaleRatio.toFixed(2)}`:"2d")}}c54:T705, const crewAt = crew ? (e: number, s: number): Pose => { const yaw = crew.yaw * e; const pitch = SETTLE_CREW.pitch * e; const invD = e / lens; const z = from.lift + SETTLE_CREW.lift * scale * e; const r = place(crew.focus, { x: 0, y: 0, z: 0, yaw, pitch, s }); const k = 1 - (z + r[2]) * invD; const [fx, fy] = [ from.cx + crew.focus[0] * scale, from.cy - crew.focus[1] * scale, ]; return { x: width / 2 + (fx - width / 2) * k - r[0], y: -(height / 2 + (fy - height / 2) * k) - r[1], z, yaw, pitch, s, }; } : null; /** /crew's scale at e: the one that holds frame 1's framed height, the sheet's HOLD with no growth. */ const crewScale = (e: number) => { let s = scale; for (let i = 0; i < 4 && crewAt; i++) { s *= target / framed(points, crewAt(e, s), width, height, e / lens).height; } return s; }; // Solved once at SAMPLES + 1 points; a frame interpolates instead of solving. On /crew only the // scale is tabled: each frame places the model off the focus point exactly, so it holds to the // float's precision between samples too. const table = crewAt ? [] : Array.from({ length: SAMPLES + 1 }, (_, i) => solve(i / SAMPLES)); const scales = crewAt ? Array.from({ length: SAMPLES + 1 }, (_, i) => crewScale(i / SAMPLES)) : []; const at = (e: number): { pose: Pose; invD: number } => { if (crewAt) { const u = Math.min(1, Math.max(0, e)); const f = u * SAMPLES; const i = Math.min(SAMPLES - 1, Math.floor(f)); const s = lerp(scales[i] ?? scale, scales[i + 1] ?? scale, f - i); return { pose: crewAt(u, s), invD: u / lens }; }55:T464, const crewAt = focus ? (e: number): Pose => { const yaw = SETTLE_CREW.yaw * e; const pitch = SETTLE_CREW.pitch * e; const invD = e / lens; const z = from.lift + SETTLE_CREW.lift * scale * e; const r = place(focus, { x: 0, y: 0, z: 0, yaw, pitch, s: 1 }); const s = (scale * (1 - z * invD)) / (1 + scale * r[2] * invD); const k = 1 - (z + s * r[2]) * invD; const [fx, fy] = [ from.cx + focus[0] * scale, from.cy - focus[1] * scale, ]; return { x: width / 2 + (fx - width / 2) * k - s * r[0], y: -(height / 2 + (fy - height / 2) * k) - s * r[1], z, yaw, pitch, s, }; } : null; // Solved once at SAMPLES + 1 points; a frame interpolates instead of solving. const table = crewAt ? [] : Array.from({ length: SAMPLES + 1 }, (_, i) => solve(i / SAMPLES)); const at = (e: number): { pose: Pose; invD: number } => { if (crewAt) { const u = Math.min(1, Math.max(0, e)); return { pose: crewAt(u), invD: u / lens }; }56:Tfaa,# Sprint 36 (B4d): Iris's calls for the hull on `/crew` Iris, 2026-10-31, for Quill's contract (B4.33 to B4.42), Forge's 2D, Pixel's 3D and Probe's checks. Accepted as decision 6. Where these numbers differ from the contract's text at 626e126, they win. **How I judged.** I looked at production's `/crew`, `/` and `/log` at 1440, 1024 and 390, in Off and Calm, while sprint 36 was live on them. Then I built a prototype and injected it into production's `/crew` with Playwright: - the real drawing code (`draw()` in `lib/lines-plan.ts`) at the new layouts; - the real stage (`lib/model/stage.ts`, `pencilMarks`, `bakeShadow`) on SwiftShader, at DPR 1. I ran it on the seats 6.1 (sprint 36, now), 2.1 (37, next), 3.0 (the fixtures' 31), 0.2 (35, at rest) and 5.0 (the worst case, due at 42), in both schemes. The frames and the code are in `.crew/screenshots/36-iris/` (`f-*` final, `r4-*`, `r5-*`; `proto.js`), which git ignores. ## 1. One mark: a tick hanging from the pencil plank's lower edge - **One form for every kind.** Kind is told by the list's words. A glyph per kind would need a legend and can't be read on a 3D sliver. The research's "each event type gets one mark" means one form per channel: on the plank, a pencil stroke. `crew-390.webp` already draws the ticks on the copper run. - **Hanging, not rising.** Under the turn, the 3D hatch on lift 6 goes near-vertical, and ticks rising into the plank vanished into it (6.1, this sprint's own seat; `w440-y35.png`). Hanging below the edge, they sit on white card, or on the film under the keel, and read in both 2D and 3D. They can't meet the number, which sits mid-band above the edge. - **`MARKS` in `lib/hull-layouts.ts`** (hull units, shared by 2D and 3D): | Field | Value | Meaning | |---|---|---| | `pitch` | 5 | between ticks, along x | | `first` | 10 | slot 0's distance aft of the dot (PENCIL.tip.to's x), two pitches | | `length` | 4 | hanging down from the lower edge (`bandAt`'s bottom: the seam, or the keel's outline) | | `width` | 1.4 | CSS px, non-scaling, butt caps, `--muted` (forced colours: `CanvasText`) | | `max` | 10 | the panel's moments | | `deep` | 2 | for f | - **Slots, not moments.** Slot k (0 to n − 1) sits at x = tip − (10 + 5k)·f, and slot 0 is nearest the dot. A new moment fills the next slot aft, and no tick ever moves. At 10, nothing changes. - **Short seats:** f = min(1, (tip − xs − 2) / 55), where xs is the plank's sternmost x whose band is at least 2 deep. | Seat | f | |---|---| | 6.1, 2.1 and every long seat | 1 | | 3.0 | about 0.82 | | 5.0 | about 0.33 (a 2.8 px comb; accepted, one sprint in 22) | - **Paint order in 2D:** the plank, its edge, the ticks, then `[data-tip]`. - **In 3D:** the stage's idle `marks` batch, recoloured `--muted` (1 draw, so live is 7 of 8). - Each tick runs from nearSide(x, bottom) to nearSide(x, bottom + 4). - Below the keel it lies on the centre plane (z 0). - The tip's uLift depth trick is welcome, so the bilge never hides a tick. - **Sizes measured:** | Where | Tick length | Pitch | Newest tick to dot's centre | |---|---|---|---| | 2D, 1440 | 6.7 px | 8.4 px | 16.8 px | | 2D, 390 | 4.9 px | 6.1 px | 12.2 px | | 2D, 320 | | | 10 px | | 3D settled, 1440, 6.1 | | 6.1 px | 12.8 px | | 3D settled, 390, 6.1 | | 4.5 px | 9.4 px | - **Probe:** each tick's top lies on the plank's lower edge within 1 px, its x inside the plank's x0..x1, and it hangs down. No tick's box comes within 4 px of the dot's centre. ## 2. The drawing: a detail, server-drawn, the same in every mode `/crew`'s 2D becomes a detail of the hull, so Off, no-JS, print and frame 1 share the settled view's framing. Calm then cuts from flat to turned, as on `/`, never from the whole ship to a close-up. Two layouts, one shown per width, as on `/`: | Layout | Shown | Box (viewBox) | s (px a unit) | oy | Drawn | |---|---|---|---|---|---| | `CREW_WIDE` | from 768 | 808 × 454.5 | 808/480 = 1.68333 | 109.08 (57:T537,- Prototype a 3D call over the real page: tsc `lib/` (drawing and `lib/model/*`) to JS, export `draw` in the copy, serve it and three's files from a CORS static server that rewrites `"three"`, `'three'`, `three/addons/` and `@/lib/` (three's addons use single quotes), inject a module into production with Playwright `bypassCSP`, and drive the real `createStage` with a stand-in loft `{ at(e) → { pose, invD }, lens, scale }` (sprint 36; `.crew/screenshots/36-iris/proto.js`, `serve.mjs`, `shoot.mjs`, which git ignores). - A mark that must read on the turned hull can't share the pencil plank's ground: under the turn the 3D hatch on lift 6 goes near-vertical and ticks rising into it vanished, so B4d's ticks hang below the lower edge on plain card (`.crew/sprint/36/notes-iris.md`, 1). - A close-up of the hull reads as a ship only with one end in the crop; a mid-hull crop at 2.5× read as a wall of planks. Anchor the crop to the end nearer the plank and swing that end toward the camera (yaw sign by half), or stern seats foreshorten to slivers (sprint 36, 2 and 3). - A settled close view needs its 2D drawn at the same framing (a detail Layout), not a zoom of the whole drawing: otherwise Calm and the reduce fade cut from the whole ship to a close-up, and Off is a different picture with unreadable marks at 390 (sprint 36).58:T476,export function linesPlans( seats: ReadonlyMap, pencil?: string, ) { return { wide: draw(WIDE, seats, { pencil }), narrow: draw(NARROW, seats, { pencil }), }; } /** * /crew's two detail drawings, one shown per width as the sheet's are, centred on `focus`: the seat * in pencil, `pencil`, whose number `seats` carries, or else the newest retro's seat * (.crew/sprint/36/contract.md, call 2). */ export function crewPlans( seats: ReadonlyMap, focus: string, pencil?: string, ) { const at = (detail: Detail) => draw(crewLayout(detail, focus, pencil !== undefined), seats, { pencil, focus, }); return { wide: at(CREW_WIDE), narrow: at(CREW_NARROW) }; } /** The one drawing /read carries. */ export function pagePlan(seats: ReadonlyMap) { return draw(PAGE, seats); } /** * The Log's ghost hull: the profile alone, with only the originals the crew has taken out, from * `ghostPlanks` (.crew/sprint/30/notes-iris.md, section 1). */ export function ghostPlan(seats: ReadonlyMap) { return draw(GHOST, seats, { ghost: true }); }59:T4e8,/** * /crew's move (the contract, "Full"; notes-iris.md): the point it turns about, in the model's * frame, and its settled yaw. The point is the tally's middle on the plank's lower edge when the * server drew a tally, or the focus number's anchor, the body's middle at mid-depth, otherwise. The * turn brings the plank's end of the hull toward the visitor: the bow for a plank whose middle is * at or forward of midships, the stern for one aft of it. */ export function crewMove(seat: string, pencil: boolean): Crew { const plank = PLANKS.find((candidate) => candidate.id === seat); const x = focusX(seat, pencil); const band = plank && bandAt(plank, x); const forward = plank ? (plank.x0 + plank.x1) / 2 >= LENGTH / 2 : true; return { focus: band ? nearSide(x, pencil ? band[1] : (band[0] + band[1]) / 2) : nearSide(x, 0), yaw: forward ? -SETTLE_CREW.yaw : SETTLE_CREW.yaw, }; } /** * The first `count` ticks on the pencil plank `seat`, as segment pairs in the model's frame: tick i * hangs from the plank's lower edge at markX, MARKS.h down the plank below it, or below the keel on * the centre plane, where halfBreadth is 0 (notes-iris.md); where the 2D draws it, so frame 1 lies * on the drawing's ticks. */5a:T7da,Outcome: the four B4d design calls are made, and Atlas accepted my three amendments to the contract as decision 6. My notes are committed on `sprint/36-b4d-crew-hull` at 1bcb5cf, not pushed. **The calls:** 1. **What one mark is.** One graphite tick per moment, the same for every kind of moment. - Each tick hangs 4 hull units below the pencil plank's lower edge: the seam between planks, or the keel's outline. It is 1.4 px, `--muted`, never copper. - The ticks sit in fixed slots: slot k is at tip − (10 + 5k)·f, and slot 0 is nearest the copper dot. A new moment fills the next slot aft. No tick ever moves, and at 10 moments nothing changes. - f is 1 except on short seats: about 0.82 on 3.0 and about 0.33 on 5.0. 5.0 is a dense comb, accepted; it comes round once in 22 sprints. - "Past ~40 moments" doesn't arise: the panel shows at most 10. - I first called ticks rising into the plank. In the 3D render they vanished into the hatch on lift 6, which is this sprint's own seat (6.1). Hanging below, they read in 2D and 3D, and they can't collide with the number. - In 3D they use the stage's idle `marks` batch: 1 extra draw, so 7 of 8 while live. 2. **The camera.** `/crew`'s 2D becomes a server-drawn detail of the hull, so Off, no-JS, print and Calm all share the framing. - From 768: `CREW_WIDE`, 480 hull units across, box 808 × 454.5. Below 768: `CREW_NARROW`, 320 across, box 390 × 243.75. - Each crop shows the end of the hull nearer the plank, within a margin that keeps the plank's number-to-dot run in view. - Settled pose: yaw −35° when the plank is forward of midship (bow toward the visitor), +35° when it's aft (stern toward). Pitch 6°, lift 90. - The move keeps the hull's framed height and keeps the focus point within 1 px of where it starts on screen. - Full: one 1.8 s move, once a visit. Calm: opens settled. Reduced motion: the 240 ms fade, as on `/`. - Plank depth at the marks, settled: 26.5 px for 6.1 at 1440, 20 px at 390, and 25b:T7d6,python3 - <<'EOF' p='e2e/crew-hull.ts' s=open(p).read() start=s.index('/** A detail layout: its viewBox') end=s.index('// ---------------------------------------------------------------------------------------------\n// The page') new='''/** A detail layout: its viewBox, its scale (hull units to viewBox units) and its oy. */ export type Detail = { name: "CREW_WIDE" | "CREW_NARROW"; box: readonly [number, number, number, number]; s: number; oy: number; }; /** * From 768 px: 480 hull units across (Iris's amendment 2, .crew/sprint/36/decisions.md, 6). * xc, which sets ox, isn't given in numbers the checks can hold, so the checks read ox off the * drawing's own planks (`fitOf`) and hold s and oy to these. */ export const CREW_WIDE: Detail = { name: "CREW_WIDE", box: [0, 0, 808, 454.5], s: 1.68333, oy: 109.08, }; /** Below 768 px: 320 hull units across. */ export const CREW_NARROW: Detail = { name: "CREW_NARROW", box: [0, 0, 390, 243.75], s: 1.21875, oy: 48.75, }; export const detailAt = (width: number) => width >= 768 ? CREW_WIDE : CREW_NARROW; /** * Iris's widths for the shown drawing, CSS px, by viewport width (null: at most 600 from 768 to * 1023); the height follows from the layout's box, since the drawing keeps its viewBox's shape. */ export const DETAIL_SIZES: { width: number; w: number | null }[] = [ { width: 1440, w: 808 }, { width: 1024, w: 553 }, { width: 768, w: null }, { width: 390, w: 358 }, { width: 320, w: 288 }, ]; /** "At most 600 wide from 768 to 1023." */ export const MID_MAX = 600; /** * A tick (amendment 1, MARKS): it hangs from the pencil plank's lower edge, `length` hull units * down; slot k (0 nearest the dot) at tip − (first + pitch·k)·f; at most 10. */ export const TICK = { length: 4, max: 10, first: 10, pitch: 5 }; /** The focus point in live and open, aft of the tip in units of f: the tally's middle. */ const TALLY_MIDDLE = 27.5; /** The pencil number's place: min(body middle, tip − 20) (B4b's,5c:T778,/** * The profile's construction: the stations, from above the sheer down to `foot`, numbered under * the base line; the seams' waterlines; the base line and the designed waterline. */ function drawProfile( { ox, oy, s }: Layout, foot: number, lines: Lines, letter: Letter, ) { const P = (x: number, y: number): Point => [ox + x * s, oy + y * s]; const X = (x: number) => num(ox + x * s); for (let i = 0; i <= 10; i++) { const [x] = P((LENGTH * i) / 10, 0); lines.construction += `M${num(x)} ${num(oy - 14)}V${num(foot)}`; letter(String(i), [x, oy + BASE * s + 12], "middle", "figure"); } for (const y of SEAMS) { const [a, b] = ends(y); lines.waterlines += `M${pt(P(a - 18, y))}H${X(b + 18)}`; } lines.base += `M${pt(P(-30, BASE))}H${X(LENGTH + 30)}`; lines.centrelines += `M${pt(P(-30, DWL))}H${X(LENGTH + 30)}`; letter("DWL", P(LENGTH + 34, DWL), "start", "figure"); letter("Base", P(LENGTH + 34, BASE), "start", "figure"); letter("Profile", [ox, oy - 30], "start", "caption"); } /** The half-breadth plan: each seam's breadth along the hull, the deck line and the transom. */ function drawHalfBreadth( { ox, s, hbY }: Layout, lines: Lines, letter: Letter, ) { const H = (x: number, z: number): Point => [ox + x * s, hbY - z * s]; const X = (x: number) => num(ox + x * s); lines.centrelines += `M${pt(H(-30, 0))}H${X(LENGTH + 30)}`; for (const y of SEAMS) { const [a, b] = ends(y); lines.construction += curve( spaced(a, b, 16).map((x) => H(x, halfBreadth(x, y))), ); } const deck = (x: number) => halfBreadth(x, sheer(x)); lines.deck += `${curve(spaced(0, LENGTH, 20).map((x) => H(x, deck(x))))}M${pt( H(0, 0), )}V${num(H(0, deck(0))[1])}`; letter("Half-breadth plan", [ox, hbY + 16], "start", "caption"); } /** * The body plan: a section at each station, the aft half to the left of the centreline and the5d:T7d0,import type { Page } from "@playwright/test"; import { profile as keel, seamDepth, sheer } from "../lib/half-model"; import { PLANKS } from "../lib/hull-layouts"; import type { CrewState } from "./crew"; import { pencilSeat } from "./live-layer"; import { MERGED, SEAT_OF } from "./retros"; // The oracle for B4d, the detail drawing on /crew (.crew/sprint/36/contract.md, "Data rules": the // detail drawing, the crop, the lettering and a tick, with Iris's three amendments, // .crew/sprint/36/decisions.md, 6), in this suite's own lines from the contract's words, never the // page's code. The hull's shape (lib/half-model.ts) and its plank boxes (PLANKS) are the ground // every drawing shares; the layouts' numbers, the seat's body, f, the ticks' slots, the number's // anchor and the focus point are written here. The page readers name no class: the shown drawing // is the `svg` in `[data-plan]` with a box, and the hooks are the contract's (`data-focus`, // `data-run`, `[data-mark]`, `[data-tip]`, the pencil's `data-pencil`, `data-sprint`, `data-live`). export type Run = "live" | "open" | "inked" | "record"; /** A detail layout: its viewBox, its scale (hull units to viewBox units) and its oy. */ export type Detail = { name: "CREW_WIDE" | "CREW_NARROW"; box: readonly [number, number, number, number]; s: number; oy: number; }; /** * From 768 px: 480 hull units across (Iris's amendment 2). The crop's xc, which sets ox, isn't * given in numbers, so the checks read ox off the drawing's own planks (`fitOf`) and hold s and oy * to these. */ export const CREW_WIDE: Detail = { name: "CREW_WIDE", box: [0, 0, 808, 454.5], s: 1.68333, oy: 109.08, }; /** Below 768 px: 320 hull units across. */ export const CREW_NARROW: Detail = { name: "CREW_NARROW", box: [0, 0, 390, 243.75], s: 1.21875, oy: 48.75, }; export const detailAt = (width: number) => width >= 768 ? CREW_WIDE : CREW_NARROW; /** * Iris's widths for the shown drawing, CSS px, by viewport width 5e:T7d0, svg { opacity: 0; } } /* * The hull on /crew (lib/model/; .crew/sprint/36/contract.md, "The hull on /crew"; notes-iris.md): * the model's layer after /crew's detail drawing, under the sheet's rules above, which hollow the * drawing from the first moving frame and hide the tip. Here the tally's ticks go with the tip, and * the focus plank's number, the hull's only one, stays and rides it in every state, as the sheet's * pencil number does. Nothing here is a CSS animation or transition but the reduced-motion fade. */ /* From 1024 px the drawing sticks under the bar while the panel scrolls, and the layer is the whole first row, as tall as the panel: the canvas lies in a holder the chunk makes as tall as the plan, which sticks at the drawing's top (.crew-page > [data-plan], below), so the two move as one on the compositor and stop together at the row's foot. */ .crew-page > [data-model] > div { position: relative; } @media (width >= 64rem) { .crew-page > [data-model] > div { position: sticky; top: 72px; } } @media screen and (forced-colors: none) { .crew-page > [data-plan]:has( + [data-model]:is( [data-state="lofting"], [data-state="settled"], [data-state="still"] ) ) { & .plank-marks { visibility: hidden; } & .plan-focus { visibility: visible; } } .crew-page > [data-plan]:has(+ [data-model][data-state]) .plan-focus { transform: translate(var(--ghost-x, 0px), var(--ghost-y, 0px)); } } /* Under reduced motion the ticks fade out with the tip as the canvas fades in; the focus number stays on its plank, as the sheet's pencil number does. */ @media screen and (prefers-reduced-motion: reduce) and (forced-colors: none) { .crew-page > [data-plan]:has(+ [data-model]) .plank-marks { transition: opacity 240ms linear, visibility 240ms linear; } .crew-page > [data-plan]:has(+ [data-model][data-state]) .plank-marks { o5f:T5dc,Forge: lib/hull-layouts.ts is updated to Iris's final numbers on origin/forge/36 (44e9599). They replace what I sent at 6c00e46. Changes: - MARKS = { pitch: 5, first: 10, length: 4, width: 1.4, max: 10, deep: 2 }. Ticks HANG DOWN from the lower edge: (x_k, bottom) to (x_k, bottom + length), x_k = markX(tally, k) = tip − (first + pitch·k)·f, f = min(1, (tip − xs − 2)/55). Gone: h, step, count, span, middle, number. On lift 6 they hang below the keel onto the film, outside the hull's clip. Use `tallyOf`/`markX` rather than re-deriving f. - `Detail` is now { box, s, oy, numbers }. CREW_WIDE is box [0,0,808,454.5], s 808/480, oy 109.08. CREW_NARROW is box [0,0,390,243.75], s 1.21875, oy 48.75. The narrow box is 16:10 now, not 16:9. - crewLayout(detail, focus, pencil) has the same signature with Iris's new crop: the hull's end nearest the plank, moved only as far as keeps the tally in view. 6.1 in pencil gives xc 404 wide and 441.2 narrow. - focusX(focus, pencil) has the same signature. In pencil it's now the middle of the tally's extent, [min(tip − 55f, numberX − 6), tip + 2]. Otherwise it's the body middle. 6.1 in pencil gives 348.1. - New: numberX(seat, pencil), the focus number's anchor x: min(body middle, tip − 20) in pencil, the body middle otherwise, and x0 − 22 for led-out 5.0. Also new: ledOut(stations) and LEAD_OUT. DOM as I said before. One change: the 2D ticks are `path[data-mark]` hanging below the edge. The drawing component lands next; I'll ping you.60:T7db,Forge: the DOM of /crew's 2D detail (sprint 36), so your checks can target it. Code on origin/forge/36 as it lands. Iris's final numbers (her message to me, also going to Atlas) replace the contract's 320-unit/16:9 boxes and the rising ticks. - `main.crew-page > [data-plan][data-focus][data-run]`, plus `data-tally` iff the server drew the focus seat in pencil (live/open with a number; it says the crop is the tally's). Then `[data-model]`, `.foot` and the panel. - Two drawings: `.plan-view.plan-wide.plan-crew` (from 768) and `.plan-view.plan-narrow.plan-crew` (below). Each svg is clipped to its box. Sizes: the wide box is 808 × 454.5 at 1440, 566.8 × 318.8 at 1024 (Iris confirmed 566.8, not 553: the panel's 42.86% resolves against the 992 px grid) and 600 × 337.5 from 768 to 1023. The narrow viewBox is 390 × 243.75 (16:10), drawn 358 × 223.75 at 390 and 288 × 180 at 320. - Ticks: one `path[data-mark]` per SHOWN tick, in `g.plank-marks` after the outline and before the tip. Unshown ticks are ABSENT, so count `[data-mark]` inside the shown `.plan-crew`. They hang DOWN from the lower edge: top at bandAt(plank, x_k)[1], 4 units long. So per Iris, B4.34's "inside the plank's box" becomes: top on the lower edge within 1 px, x inside x0..x1, hanging down. x_k = tip − (10 + 5k)·f. Use `tallyOf(seat)` and `markX(tally, k)` from lib/hull-layouts.ts as your oracle. f is 1 on every seat but 3.0 (0.814) and 5.0 (0.330). - The tip: `g.plank-tip` is in the HTML whenever there's a pencil, and it carries `data-tip` only while data-run is live. Otherwise it's display:none with no data-tip. So `[data-tip]` exists only in live, and open-from-load has the g hidden. - The focus number: `span.plan-plank.plan-focus` in every state, plus `.plan-pencil` (the chip) in live/open. Its x is `numberX(seat, pencil)`: min(body middle, tip − 20) in pencil, so 3.0 and 6.0 move aft; 5.0 stays led out. - The focus path, last in the clip group: live/open have class plank-pencil, data-pencil, data-sprint 61:T7d0,/** The drawing's run on /crew (.crew/sprint/36/contract.md, call 3): the server draws the first two. */ type Run = "live" | "open" | "record"; // /crew's detail (.crew/sprint/36/contract.md, "The detail drawing"; Iris's final numbers): the // sheet's two drawings, one shown per width, each a profile close on `focus`, the plank in pencil // or the newest retro's seat, with every plank seated as on / and clipped by the box. In pencil, // the plank carries the tally: its number, then a graphite tick for each of the `marks` moments the // panel lists, then the copper pen while live. data-focus and the crop are fixed at first paint; // components/crew-live.tsx follows the poll on data-run, the focus plank and the ticks, and the 3D // chunk reads all of it (call 4). data-tally says the server drew the tally, so the crop is its. export function CrewPlan({ seats, focus, pencil, marks, }: { seats: ReadonlyMap; focus: string; pencil: Pencil | null; /** The moments the panel lists, in pencil. */ marks: number; }) { const { wide, narrow } = pencil ? crewPlans( new Map(seats).set(pencil.seat, pencil.sprint), focus, pencil.seat, ) : crewPlans(seats, focus); const run: Run = pencil ? (pencil.live ? "live" : "open") : "record"; const shared = { pencil: pencil ?? undefined, focus, marks }; return ( ); } function Drawing({ plan, id, view = id, current, pencil, focus, marks = 0, }: { plan: Plan; id: string; /** The view's classes, where they aren't its id. *62:T7d0,import { type Browser, expect, type Page } from "@playwright/test"; import { expected } from "./crew"; import { type Answer, type Crew, type Fixture, STATE_WAIT, crewTest as test, untilState, } from "./crew-feed"; import { boxToPoint, cssLength, cssOf, DETAIL_SIZES, type DetailRead, detailAt, fitOf, focusOf, inside, MID_MAX, momentsShown, NEWEST, overlaps, readDetail, recordPlan, seatGeometry, serverRun, TICK, takePlan, } from "./crew-hull"; import { FIXTURE_STUDIO, feedOf, type Live, livePage, type Patch, toAnswer, } from "./crew-live"; import { installRgba, SCHEMES } from "./helpers"; import { tokenRgba } from "./log"; import { deltaE } from "./pixels"; import { refuseWebGl } from "./webgl"; // Sprint 36, B4d (.crew/sprint/36/contract.md, B4.33 to B4.35, with Iris's three amendments in // decisions.md, 6): /crew's detail drawing in 2D, one tick per moment, written before the build. // Every page here refuses WebGL (the Off path: "2D checks run on the Off path"), so the drawing is // read as the server and the poll leave it, with no model over it. The oracle is e2e/crew-hull.ts // (the layouts, f, the ticks' slots, the number's anchor, from the contract's words); since the // crop's xc has no number the checks can hold, every place is read through the drawing's own plank // boxes (fitOf), with s and oy held to the layout's. The states come from B4a's kept fixture // sites (e2e/crew-feed.ts) and, for the poll, from `page.route` answering `/api/crew` with the // oracle's `toAnswer` on Playwright's clock (B4c's `livePage`). Each check reads 1440 x 900 and // 390 x 844, and B4.33 the five widths of Iris's table. test.describe.configure({ mode: "default" }); test.skip( Boolean(process.env.PLAYWRIGHT_BASE_URL), "PLAYWRIGHT_BASE_URL is set: these checks need this checkout's build, served without a feed (the down state) and from copies pointed at the fixture server", ); test.use({ timezoneId: "America/Los_63:T58e, {/* /crew's ticks hang from the plank's lower edge, outside the hull's clip, under the pen. Each slot's path is in data-slots, so the poll can show the next without geometry of its own (components/crew-live.tsx); a slot not yet shown is absent. */} {plan.marks ? ( {plan.marks.slice(0, marks).map((d) => ( ))} ) : null} {/* The pen on the plank's lower edge while the crew is live: after the outline and outside the hull's clip, so it lies on every line and the keel lift's dot is whole. On /crew it is drawn in open too, hidden, for the poll to show when the crew is live again. */} {pencil && plan.tip && (pencil.live || focus !== undefined) ? ( ) : null} {plan.lettering.map((letter) => ( entry.sprint).reverse(); const seats = seatPlanks(merged); const crew = await readCrew(); const layer = layerOf(crew, merged); const pencil = layer.state === "pencil" ? layer.pencil : null; const [record] = entries; // The detail's focus: the seat in pencil, or the newest retro's (contract, call 2). const focus = pencil?.seat ?? (record && seatOf(merged, record.sprint)) ?? nextSeat(0); // One tick per moment the panel lists, in pencil alone (call 1). const marks = pencil && crew.state !== "down" ? crew.run.moments.length : 0; // Only what the panel shows from the retros: the browser gets these, not the reader or profile.65:T7d0,/** How long the panel keeps its last told answer through failed or down polls: copper's window. */ const KEEP_MS = 600_000; /** A poll still unanswered after this is given up, and counts as failed (Lens's nit on #90). */ const ABORT_MS = 30_000; type Poller = { pause: (on: boolean) => void; stop: () => void }; const unchanging = () => () => {}; /** One poll's answer: the state it tells, or null when the request, the status or the shape failed. */ async function poll(): Promise { // A timer, not AbortSignal.timeout, so a test's clock drives it as it drives the schedule. const abort = new AbortController(); const timer = setTimeout(() => abort.abort(), ABORT_MS); try { const response = await fetch("/api/crew", { cache: "no-store", signal: abort.signal, }); return response.status === 200 ? crewOfAnswer(await response.json()) : null; } catch { return null; } finally { clearTimeout(timer); } } /** * The plank the server drew in pencil on /crew's detail: its sprint, and the seat's holder on the * down page (null for an original), which the record shows. */ export type Drawn = { sprint: number; holder: number | null }; /** Sets an attribute, or removes it for null, only where it differs: no answer rewrites a node. */ function set(node: Element, name: string, value: string | null) { if (node.getAttribute(name) === value) return; if (value === null) node.removeAttribute(name); else node.setAttribute(name, value); } /** * The detail drawing as a told state leaves it (.crew/sprint/36/contract.md, call 3, "A tick"): * live or open for the drawing's own sprint, its pencil and one tick per moment shown; inked when * that sprint has merged; otherwise the record, the focus plank seated as the down page seats it. * Nothing moves: a tick fills the next slot the server drew, and the crop and every other plank * stay. The drawing is the server's HTML, outside React's tree, so it is set here, on each answer.66:T45b,/** * The crop's centre xc and the ox it gives on a layout (notes-iris.md, section 2): the hull's end * nearest the focus plank, clamped so the tally keeps a margin of 0.12 of the width; `pencilled` * when the server drew the seat in pencil (the tally is L to R), else the number's ± 20. */ export function cropX(detail: Detail, seat: string, pencilled: boolean) { const g = seatGeometry(seat); const across = detail.box[2] / detail.s; const margin = MARGIN * across; const centre = (g.plank.x0 + g.plank.x1) / 2; const anchored = centre < MIDSHIP ? across / 2 - 20 : 2 * MIDSHIP + 20 - across / 2; const [left, right] = pencilled ? [Math.min(g.tip - TALLY_AFT * g.f, g.number[0] - 6), g.tip + 2] : [g.seated[0] - 20, g.seated[0] + 20]; const lo = right + margin - across / 2; const hi = left - margin + across / 2; const xc = lo > hi ? (left + right) / 2 : Math.min(hi, Math.max(lo, anchored)); return { xc, ox: detail.box[0] + detail.box[2] / 2 - xc * detail.s }; } // --------------------------------------------------------------------------------------------- // The page 67:T7d0,/** What the detail shows for a told state: its data-run, the focus plank's number, its ticks. */ type Shown = { run: "live" | "open" | "inked" | "record"; sprint: number | null; marks: number; }; /** * The detail as a told state leaves it (.crew/sprint/36/contract.md, call 3's table): live or open * for the drawing's own sprint, in pencil with one tick per moment shown; inked once that sprint * has merged; otherwise the record, the focus plank seated by its holder as the down page seats it. */ function shownOf(crew: Crew, { sprint, holder }: Drawn): Shown { if (crew.state === "down" || crew.run.sprint !== sprint) { return { run: "record", sprint: holder, marks: 0 }; } if (crew.state === "resting") return { run: "inked", sprint, marks: 0 }; return { run: crew.state, sprint, marks: crew.run.moments.length }; } /** * Sets the detail to `crew` (call 3, "A tick"). Nothing moves: a tick fills the next slot the * server drew, and the crop and every other plank stay. The drawing is the server's HTML, outside * React's tree, so it is set here, on each answer, and an answer that changes nothing sets nothing. */ function redraw(crew: Crew, drawn: Drawn) { const plan = document.querySelector("[data-plan][data-tally]"); if (!plan) return; const shown = shownOf(crew, drawn); set(plan, "data-run", shown.run); for (const view of plan.querySelectorAll(".plan-crew")) { const path = view.querySelector(`path[data-plank="${plan.dataset.focus}"]`); const tip = view.querySelector(".plank-tip"); const number = view.querySelector(".plan-focus"); const marks = view.querySelector(".plank-marks"); if (path) seat(path, shown); if (tip) set(tip, "data-tip", shown.run === "live" ? "" : null); if (number) letter(number, shown); if (marks) showMarks(marks, shown.marks); } } /** The focus plank: in pencil while live or open, else seated, or original with no holder. */ function seat(path: Element, { ru68:T7d0,/** * The detail drawing as a told state leaves it (.crew/sprint/36/contract.md, call 3, "A tick"): * live or open for the drawing's own sprint, its pencil and one tick per moment shown; inked when * that sprint has merged; otherwise the record, the focus plank seated as the down page seats it. * Nothing moves: a tick fills the next slot the server drew, and the crop and every other plank * stay. The drawing is the server's HTML, outside React's tree, so it is set here, on each answer. */ function redraw(crew: Crew, { sprint, holder }: Drawn) { const plan = document.querySelector("[data-plan][data-tally]"); if (!plan) return; const told = crew.state === "down" || crew.run.sprint !== sprint ? null : crew; const run = told?.state === "resting" ? "inked" : (told?.state ?? "record"); const pencil = run === "live" || run === "open"; const shown = run === "record" ? holder : sprint; const count = pencil && told ? told.run.moments.length : 0; set(plan, "data-run", run); for (const view of plan.querySelectorAll(".plan-crew")) { const path = view.querySelector(`path[data-plank="${plan.dataset.focus}"]`); const tip = view.querySelector(".plank-tip"); const number = view.querySelector(".plan-focus"); const marks = view.querySelector(".plank-marks"); if (path) { set( path, "class", pencil ? "plank-pencil" : shown === null ? "plank-original" : "plank-seated", ); set(path, "data-sprint", shown === null ? null : String(shown)); set(path, "data-pencil", pencil ? "" : null); set(path, "data-live", run === "live" ? "" : null); } if (tip) set(tip, "data-tip", run === "live" ? "" : null); if (number) { number.classList.toggle("plan-pencil", pencil); const text = shown === null ? "" : String(shown); if (number.textContent !== text) number.textContent = text; } if (marks) showMarks69:T49f,git add lib/model app/globals.css && git status --short && git commit -q -m "Sprint 36: the hull on /crew, the move about the focus point and the tally in 3D The chunk mounts on /crew's detail drawings (told apart by data-focus), on Forge's crewLayout read with data-tally, at the sheet's levels and caps. Full turns ±35° toward the focus plank's end, pitch 6°, LIFT 90, holding the framed height, and keeps the focus point on its frame-1 screen point (exact per frame: only the scale is tabled). 1.8 s, once a visit on theseus:crew. A MutationObserver re-reads data-run, data-sprint, the shown ticks and the focus number on each told answer, and draws 1 frame only when the frame would differ; data-marks counts the ticks the last frame drew. The ticks hang MARKS.length below the pencil plank's edge in the stage's idle marks batch, graphite, square-ended, with the tip's depth lift; the tip paints after them. From 1024 the canvas lies in a holder that sticks with the drawing. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01QrjXvdJC9qJR4aHc8kQPQC" && git push -q origin pixel/36 2>&1 | tail -2; git log --oneline -16a:T7d1,Probe: the first probe/36 commit (e2e/crew-hull.spec.ts, B4.33 to B4.35, plus its oracle e2e/crew-hull.ts) goes up within about 30 minutes, after I run it red against the head. The 3D, control and B4.42 commits follow. I'll tell Atlas as each one lands. My checks rely only on the contract's names: [data-plan] with data-focus and data-run, [data-mark], [data-tip], data-pencil, data-sprint, data-live, ol[data-moments] li. I don't use your classes (.plan-crew, .plan-focus, g.plank-marks, data-tally): - the shown drawing is the one svg inside [data-plan] that has a box; - the focus number is the shown element whose own text is all digits and whose centre falls on the focus plank, inside the hull clip; - every place is read through the drawing's own map, a least-squares fit of x' = ox + x·s to the planks' bboxes. I hold s and oy to Iris's numbers and ox to her crop formula (I get xc 404/441 for 6.1, and 220/140 for 3.0). Your DOM fits all of that. Two things to know: 1. A plank path's bbox has to be the plank's box in viewBox units. A plank end the drawing's box cuts is fine: I skip any edge within 0.5 of the box's sides. 2. f: I take xs as the continuous sternmost x where the band is at least 2 deep (0.01-unit steps). That gives 3.0 f = 0.819 and 5.0 f = 0.340, against your 0.814 and 0.330. On 3.0 that is 0.46 px at slot 9 at 1440, inside my 1 px. On 5.0 it is 0.9 px at slot 9, which is close to the limit, but 5.0 isn't a fixture seat. If you sample 49 stations, finer steps would make the two agree. I don't import tallyOf or markX: the oracle stays independent of the code it checks. I'm reading inked as: class plank-seated, data-sprint n, computed fill not url(), stroke-dasharray none, stroke equal to --foreground, and the focus number n with color --foreground, weight 700 and a transparent background. Record compares every plank's data-sprint and class with the default server's. B4.42 matches your design: an abort at 30 s, the next poll 30 s after it, read through6b:T55b,Pixel: thanks, built on 44e9599; my 3D is on origin/pixel/36 (46575e9). What the chunk reads, so nothing of yours moves under it: `[data-plan][data-focus]` (+ `data-tally`, `data-run`), `.plan-wide`/`.plan-narrow`, each `path[data-plank]` with `data-sprint` (= seated, which is how record/inked refill), `path[data-plank][data-pencil]` (+ `data-live`), `:scope > .plan-plank.plan-focus` (its text, style.left/top as % of the view), and `[data-mark]` count per drawing (absent = not shown). I use crewLayout, CREW_WIDE/NARROW, tallyOf, markX, MARKS, numberX, bandAt. I do NOT use focusX: Iris's focus point (notes-iris.md 3) is tip − 27.5·f on the lower edge in pencil and the number's anchor at rest, not the crop's tally middle, so I compute it in lib/model. knip now flags `stretch`, `focusX` (lib/hull-layouts.ts) and `crewPlans` (lib/lines-plan.ts) as unused exports on my branch; crewPlans will be used by your component, the other two are your call. CSS: from 1024 my canvas lies in a holder div inside [data-model] that is `position: sticky; top: 72px` (my block, "The hull on /crew", after the Log's ghost block), so it relies on your `.crew-page > [data-plan] { position: sticky; top: 72px }` staying 72; tell me if that number moves. I hide `.plank-marks` under the hollow rule and ride `.plan-focus`. Ping me when the drawing lands and I'll run it on /crew.6c:T641,/* * The detail drawing (components/lines-plan.tsx's CrewPlan; .crew/sprint/36/contract.md, "The * detail drawing" and "A tick", with Iris's final numbers): the sheet's lines plan close on one * plank, clipped by its box, its lettering too. Below 768 px it sits 16 px in, as the panel's text * does. The tally's ticks are graphite strokes, never copper, with no transition in any mode: a * tick appears, it doesn't arrive. The poll moves data-run (components/crew-live.tsx); the rules * below draw what each value leaves. */ @media (width < 48rem) { .crew-page > [data-plan] { margin: 0 16px; } } .plan-crew, .plan-crew svg { overflow: clip; } .plank-marks { stroke: var(--muted); } /* The pen is drawn whenever the server drew the pencil, and shown only while the crew is live. */ [data-plan][data-run]:not([data-run="live"]) .plank-tip { display: none; } /* Inked, or back to the record, the focus plank is seated: the erase goes, and its edge is solid over the dash the server drew. */ :is([data-run="inked"], [data-run="record"]) .plank-erase { display: none; } .plan-crew path[data-plank]:not(.plank-pencil) { stroke-dasharray: none; } /* The focus plank's number off the pencil, at rest, inked or back to the record: ink at 700, no chip. */ .plan-view > .plan-focus:not(.plan-pencil) { font-weight: 700; } /* /crew's numbers keep the sizes its drawing has had: 11 px, 13 from 1280. */ .plan-view.plan-crew > .plan-plank { font-size: var(--step-xs); } @media (width >= 80rem) { .plan-view.plan-crew > .plan-plank { font-size: var(--step-sm); } }6d:T7d0,import type { Browser, Page, Route } from "@playwright/test"; import { MOTION } from "./helpers"; import { type Box, pause } from "./model"; import { coverage, decodePng, type Image, pixel } from "./pixels"; import { type ModelOptions, type ModelRun, openModel } from "./webgl"; // What /crew's 3D checks share (.crew/sprint/36/contract.md, B4.36 to B4.40): B3's harness // (e2e/webgl.ts) pointed at /crew, with `page.route` answering `/api/crew` where a check drives the // poll. The hooks are the contract's: `[data-model]` right after `[data-plan]`, its `data-state` // and `data-marks`, its one canvas; the drawing is the svg in `[data-plan]` that has a box. export const SHOWN_SVG = "[data-plan] svg"; /** Below 768 the phone's level and the 1.5x cap, from 768 the desktop's and 2x. */ export const capAt = (width: number, dpr: number) => Math.min(dpr, width < 768 ? 1.5 : 2); /** Layout's precision: Chromium keeps lengths in 1/64 CSS px. */ export const LAYOUT = 1 / 64; /** Full's one move (Iris: 1,800 ms on ease(), once a visit). */ export const MOVE = 1800; export type Reply = { json: unknown } | { status: number } | { hold: true }; export type CrewRun = ModelRun & { /** Polls the route has seen. */ polls(): number; /** What the route answers from now on. */ answer(reply: Reply): void; /** Answers every held poll with `reply`. */ release(reply: Reply): Promise; /** * On the clock: runs it `ms`, waits for a poll that fires to reach the route and settle, then * runs one more frame for the redraw it asks for. The new polls. */ tick(ms: number): Promise; }; async function fulfil(route: Route, reply: Reply) { if ("hold" in reply) return; await route .fulfill({ status: "status" in reply ? reply.status : 200, contentType: "application/json", headers: { "cache-control": "public, max-age=0, s-maxage=30" }, body: "json" in reply ? JSON.stringify(reply.json) : '{"error":"Not an6e:T7d0,import { expect, type Page, type TestInfo } from "@playwright/test"; import { expected } from "./crew"; import { type Answer, type Crew, STATE_WAIT, crewTest as test, untilState, } from "./crew-feed"; import { cssOf, fitOf, focusOf, momentsShown, NEWEST, readDetail, seatGeometry, } from "./crew-hull"; import { FIXTURE_STUDIO, feedOf, type Patch, toAnswer } from "./crew-live"; import { type CrewRun, canvasOnly, capAt, crewFit, deltaAt, differs, LAYOUT, MOVE, marksDrawn, openCrewModel, planksAlone, plankPoints, pressMode, SHOWN_SVG, } from "./crew-model"; import { copper, rgbOf, sinceMark, markVisit, token } from "./ghost"; import { installRgba } from "./helpers"; import { type Box, FIRST, FRAME, note, pause, REST, runTo, SHOWN, TRIANGLES_AT, whole, } from "./model"; import { decodePng, edges, hausdorff, type Image, pixel } from "./pixels"; import type { ModelOptions, Script } from "./webgl"; // Sprint 36, B4d (.crew/sprint/36/contract.md, B4.36 to B4.38 and B4.40, with Iris's amendments, // decisions.md 6 and notes-iris.md): the card model on /crew's detail drawing, on B3's harness // (CI's SwiftShader, every GPU number a floor), written before the build. B4.36 and B4.38 run on // the default server (down: the drawing is `record`, the focus point the focus number's anchor); // B4.37 and B4.40 on B4a's kept live site, with `page.route` answering `/api/crew` and the clock // driving the poll, and B4.36's framing on the live (3.0) and sprint 999 (6.1) sites. Pages are // shared per size where a check allows (sprint 33, decision 12: a WebGL page is 5 to 7 s to rest). test.describe.configure({ mode: "default" }); test.skip( Boolean(process.env.PLAYWRIGHT_BASE_URL), "PLAYWRIGHT_BASE_URL is set: these checks need this checkout's build, served without a feed (the down state) and from copies pointed at the fixture server", ); test.use({ timezoneId: "America/Los_Angeles" }); const SWIFTSHADER = "S6f:T4ce,python3 -c " p='e2e/crew-model.spec.ts' s=open(p).read() old=s[s.index(' const d = Math.hypot(...rgb.map((v, i) => v - (accent[i] ?? 0)));'):s.index(' at.push([x, y]);')] s=s.replace(old,' if (deltaE(rgb, accent) < 10)\n') s=s.replace(' const ground = await rgbOf(run.page, \"rgb(0 0 0 / 0)\").then(() => token(run.page, \"--background\"));',' const ground = await token(run.page, \"--background\");') s=s.replace('import { copper, rgbOf, sinceMark, markVisit, token } from \"./ghost\";','import { copper, markVisit, sinceMark, token } from \"./ghost\";') s=s.replace('import { decodePng, edges, hausdorff, type Image, pixel } from \"./pixels\";','import { decodePng, deltaE, edges, hausdorff, type Image, pixel } from \"./pixels\";') s=s.replace('{ what: \"another sprint\", frames: 0, marks: 0 },','{ what: \"another sprint\", frames: 1, marks: 0 },') s=s.replace('import { expect, type Page, type TestInfo } from \"@playwright/test\";','import { expect, type Page } from \"@playwright/test\";') open(p,'w').write(s) " pnpm exec biome check --write e2e/crew-model.ts e2e/crew-model.spec.ts 2>&1 | grep -E "✖|×|error|lint/" | head -20; pnpm exec tsc --noEmit -p . 2>&1 | grep -v -i "warn" | head -2070:T55b,Pixel: the sticky [data-plan] needs one change on your side, or the riding focus number paints under the canvas from 1024. position: sticky always makes a stacking context, so the plan's lettering (z-index 1) is trapped inside it, and the layer after it paints over all of it. Tested in Chromium (elementFromPoint at the number): plain plan → the number is on top; sticky plan → the canvas is on top; sticky wrapper holding plan + layer → the number is on top. A holder inside the layer can't fix it: the canvas has to sit between the plan's svg and its spans, so plan and layer must share one stacking context. Ask: in app/crew/page.tsx wrap the two, `

` (nothing else between them; [data-model] stays [data-plan]'s next sibling, so the harness and the hollow rules hold), and move the sticky rule to it: `.crew-drawing { position: relative }` and from 1024 `.crew-drawing { position: sticky; top: 72px; padding-top: 24px; align-self: start }` with [data-plan] plain. The layer's inset: 0 then lies on the wrapper, so I drop my holder and its CSS. If you'd rather keep [data-plan] the grid item, the other way out is dropping the sticky, but the frame has it. Tell me which and I'll match it; I'll tell Probe that `main > [data-plan]` becomes `main > .crew-drawing > [data-plan]` if you wrap.71:T7d0,import { type Browser, expect, type Page } from "@playwright/test"; import { expected } from "./crew"; import { type Crew, STATE_WAIT, crewTest as test, untilState, } from "./crew-feed"; import { type CrewRun, openCrewModel, pressMode } from "./crew-model"; import { FIRST, FRAME, pause, REST, SHOWN } from "./model"; import type { ModelOptions } from "./webgl"; // Sprint 36, B4.39 (.crew/sprint/36/contract.md, "Off", call 5): on every Off path /crew is the // detail drawing as the server and the poll leave it, and no 3D downloads. The baseline is the page // with WebGL refused (the contract's definition of Off), read in the same media as each case. The // checks run on B4a's kept live site, so the drawing has a pencil, a tip and ticks to compare. test.describe.configure({ mode: "default" }); test.skip( Boolean(process.env.PLAYWRIGHT_BASE_URL), "PLAYWRIGHT_BASE_URL is set: these checks need this checkout's build and copies pointed at the fixture server", ); test.use({ timezoneId: "America/Los_Angeles" }); /** Past load, the idle callback's 2,000 ms timeout and a margin. */ const IDLE = 3500; const TWO_FRAMES = Math.ceil(2 * FRAME); const SIZES = [ { width: 1440, height: 900 }, { width: 390, height: 844 }, ]; function liveSite(crew: Crew) { return crew.once("hull live", async () => { const site = await crew.site("live", { fixture: "live" }, true); const body = crew.feed.body("live"); const exp = expected(body, crew.feed.origin); const shown = await untilState(site.baseURL, exp.state, STATE_WAIT); const run = (body.current ?? body.last) as { sprint?: unknown } | null; return { base: site.baseURL, exp, n: typeof run?.sprint === "number" ? run.sprint : null, ...shown, }; }); } test.beforeAll(({ crew }) => { void liveSite(crew); }); /** The detail as shown: the planks' class and fill, the pencil, the tip and the ticks' boxes. */ function detail(page: Page) { return page.evaluate(() => { c72:T7d0,import { expect, type Page, test } from "@playwright/test"; import { FIXTURE_STUDIO, feedOf, toAnswer } from "./crew-live"; import { openCrewModel } from "./crew-model"; import { MODES, MOTION, motionReady } from "./helpers"; import { pause } from "./model"; // Sprint 36, B4.41 (.crew/sprint/36/contract.md, "The page"; notes-iris.md, section 4): the motion // control on /crew, the same choice as on `/` and `/log`. From 768 px it is the bar's, right of // Read as page; below 768 it is in the foot (`main > [data-foot]`, after the drawing), right of // Read as page, in one 44 px row. B2.3's sizes hold, B4.12's first screen holds at 390 x 844, and // with scripts off the shown slot is empty at the group's size. Read with WebGL refused: the // control's place and sizes don't depend on the model, and a refused page loads no 3D. const WIDTHS = [ [320, 568], [390, 844], [768, 1024], [1024, 768], [1440, 900], ] as const; function readControl(page: Page) { return page.evaluate((slot) => { const rect = (el: Element | null | undefined) => { const r = el?.getBoundingClientRect(); return r ? { x: r.left, y: r.top, width: r.width, height: r.height, right: r.right, bottom: r.bottom } : null; }; const slots = [...document.querySelectorAll(slot)]; const one = slots.find((s) => s.getClientRects().length > 0) ?? null; const shownRead = [...document.querySelectorAll("a[href='/read']")].find( (a) => a.getClientRects().length > 0 && (a.textContent ?? "").trim() === "Read as page", ); const foot = one?.closest("[data-foot]") ?? null; const cw = document.documentElement.clientWidth; const ch = document.documentElement.clientHeight; return { shown: slots.filter((s) => s.getClientRects().length > 0).length, inNav: Boolean(one?.closest("header nav")), inFoot: Boolean(foot && foot.parentElement?.matches("main")), readInFoot: Boolean(shownRead && foot?.contains(shownRead)), grou73:T7d1, "This run on the Studio links for the fixture's https URL, then javascript:alert(1), then an http: run page", ) .toEqual([1, 0, 0]); }); test("B4.42 a poll that never settles is aborted (Lens on #90): held unanswered, it is aborted 30,000 ms after it starts on the clock and counts as failed, the next poll 30 s later while live; with every poll held after the told answer, the live panel turns into B4.2's down panel at the first abort more than 10 minutes after it, and not before", async ({ page, browser, }) => { test.setTimeout(150_000); // Sprint 36 (.crew/sprint/36/contract.md, B4.42): extends B4.28, which it loosens nowhere. const aborted = (p: Page) => { const failed: string[] = []; p.on("requestfailed", (request) => { if (new URL(request.url()).pathname === "/api/crew") failed.push(request.failure()?.errorText ?? "failed"); }); return failed; }; const failed = aborted(page); const live = await livePage(page, "/crew", { json: LIVE }); ready(live, "the default server"); live.answer({ hold: true }); const held = await live.tick(30_000); const early = await live.tick(29_999); const failedEarly = failed.length; await live.tick(1); await page.evaluate(() => new Promise((done) => setTimeout(done, 300))); const failedAt30 = failed.length; live.answer({ json: LIVE }); const next = [await live.tick(29_000), await live.tick(1_000)]; expect .soft( { held, early, failedEarly, failedAt30, next, state: await live.state() }, "the held poll at 30 s, polls and aborted requests 29,999 ms into it, aborted requests at 30,000 ms, the polls 29 s and 30 s after the abort, and the panel", ) .toEqual({ held: 1, early: 0, failedEarly: 0, failedAt30: 1, next: [0, 1], state: "live", }); // Every poll held from the told answer on: a poll at 30 s, aborted at 60 s, the next at 90 s, // aborted at 120 s, and so on; abort k is 60·k s after the an74:T414,cat >> .claude/agent-memory/creative-engineer/MEMORY.md <<'EOF' - `position: sticky` always makes a stacking context, so a sticky drawing traps its z-index 1 lettering under the model's layer after it (elementFromPoint found the canvas over the number): make one sticky wrapper hold both the plan and `[data-model]` (/crew's `.crew-drawing`, .crew/sprint/36/). - A move that must hold a point on screen (/crew's focus, within 1 px): table only the scale and place the model off that point every frame in closed form, the point unprojected at its turned depth and the origin set off it; its drift in node was 1e-13 px (.crew/sprint/36/, `lib/model/loft.ts`). - A MutationObserver on a drawing the chunk also writes to (the riding number's --ghost-x/y) must skip its own writes, or every frame of a move re-reads the drawing: record attributeOldValue and drop style records whose old and new values match with the offsets stripped (.crew/sprint/36/, `lib/model/mount.ts`). EOF tail -3 .claude/agent-memory/creative-engineer/MEMORY.md | cut -c1-8075:T598,python3 - <<'X' p='e2e/crew.spec.ts' s=open(p).read() s=s.replace('the drawing aria-hidden and seated as on / with nothing hatched, no canvas, model or control, the panel','the drawing aria-hidden and seated as on / with nothing hatched, no canvas with WebGL refused or scripts off (sprint 36: the model and the control are B4.36 and B4.41\'s), the panel',1) s=s.replace(''' model: document.querySelectorAll("canvas, [data-model], [data-motion]") .length,''',''' model: document.querySelectorAll("canvas").length,''',1) s=s.replace(''' .soft(crew.model, "canvas, [data-model] or [data-motion] on /crew")''',''' .soft(crew.model, "canvas on /crew, WebGL refused")''',1) s=s.replace(''' const off = await readPanel(noScript); await context.close(); expect .soft( { state: off.state, h1: off.h1, rows: off.rows.length }, "/crew with scripts off", ) .toEqual({ state: "down", h1: "Crew", rows: 7 });''',''' const off = await readPanel(noScript); const canvases = await noScript.evaluate( () => document.querySelectorAll("canvas").length, ); await context.close(); expect .soft( { state: off.state, h1: off.h1, rows: off.rows.length, canvases }, "/crew with scripts off (its canvases too)", ) .toEqual({ state: "down", h1: "Crew", rows: 7, canvases: 0 });''',1) open(p,'w').write(s) X grep -n "canvases: 0\|canvas on /crew, WebGL" e2e/crew.spec.ts76:T553, // Sprint 36 (.crew/sprint/36/contract.md, B4.9's rewrite, B2.3's assertions carried to /crew as // B5.1 and B5.25 did for /log): from 768 the header's shown buttons are exactly Full, Calm and // Off, right of Read as page, on the bar's one line; below 768 none, the control in the foot. const read = bar.links.find((l) => l.text === "Read as page"); const linkTops = bar.links.filter((l) => l.shown).map((l) => l.top); expect .soft( { buttons: bar.headerButtons, rightOfRead: bar.buttons.every( (b) => b.left >= (read?.right ?? Number.POSITIVE_INFINITY) - 0.5, ), oneLine: bar.buttons.every( (b) => b.top < Math.max(...linkTops) + 24 && b.bottom > Math.min(...linkTops), ), footControl: bar.footControl, }, `the header's shown buttons, right of Read as page and on the bar's line, and the control in the foot ${where}`, ) .toEqual( width >= 768 ? { buttons: ["Full", "Calm", "Off"], rightOfRead: true, oneLine: true, footControl: false, } : { buttons: [], rightOfRead: true, oneLine: true, footControl: true, }, );77:T7d6,Pixel: early look, the hull lifts on /crew with your pose. See it running: http://localhost:3342/crew is a dev server of origin/pixel/36 (68e13f5 = Forge's 14cc5f6 drawing + my 3D), fed live sprint 36 (seat 6.1) with 7 moments by my scratch feed. Change the feed with `curl -X POST -d '{"moments":10}' http://127.0.0.1:4795/set` (or '{"fixture":"open"}', '{"fixture":"resting"}', '{"sprint":31}' for 3.0); the page re-renders per request in dev, and a reload replays only in a new tab or with Full pressed (theseus:crew). SwiftShader here, so judge feel only on a GPU; frames on Playwright's clock (t = 0, 150, 450, 900, 1800 ms) are in /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/shots/ (1440-light-dpr1-t*.png, the -zoom ones are the detail's box; 1440-light-dpr2-t2000-zoom.png and 390-light-dpr2-t2000-zoom.png are the tally settled at DPR 2). What it does: yaw −35 (6.1 is forward), pitch 6, LIFT 90, lens 30°, framed height held (settles at 0.753 of frame 1's scale at 1440, 0.829 at 390), and the focus point (lower edge, tip − 27.5·f) held exactly: in node its drift over the move is 1e-13 px and frame 1 lands on its 2D point. Ticks hang 4 units below the edge in the marks batch, --muted, 1.4 px, square-ended, with the tip's uLift; the copper paints after them. Settled depth at the tally's middle: 6.1 26.5 px at 1440, 18.9 at 1024 (566.8 wide), 18.4 at 390; 3.0 28.7 / 20.3 / 20.3; 2.1 25.2 / 17.8 (under your 18 at 1024, but 2.1 isn't in Probe's list) / 17.0; 5.0 12.8 (exempt). Two calls of mine for you to judge: (1) the box cut the settled shadow in a hard ruled line along its foot, so on /crew the shadow fades out over the last 40 px inside each canvas edge (SHADOW_FADE in lib/model/calls.ts); (2) the 2D's lines stay under the hollow rule as on /, so the flat outline shows aft of the turned bow (the "second hull" to the right). Also: at 390 Forge's wrapper has a 16 px gutter, so the narrow detail is 358 wide, not your ful78:T405,sh /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/iris-look/sheet.sh /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/iris-look/seq1440.png /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/shots/1440-light-dpr1-t0000-zoom.png /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/shots/1440-light-dpr1-t0150-zoom.png /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/shots/1440-light-dpr1-t0450-zoom.png /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/shots/1440-light-dpr1-t0900-zoom.png /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/shots/1440-light-dpr1-t1800-zoom.png /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/shots/1440-light-dpr1-t2000-zoom.png79:T7d1,cd /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel && python3 - <<'EOF' p='states.ts' s=open(p).read() start=s.index(' // Copper on the canvas') end=s.index(' return {', start) s=s[:start]+s[end:] s=s.replace(''' copper, }; });''',''' }; }).then(async (info) => { // Copper in the canvas's box as the screen shows it: within ΔE 10 of --accent (B3.7's test). const box = await run.page.evaluate(() => { const r = document.querySelector("[data-model] canvas")?.getBoundingClientRect(); const accent = getComputedStyle(document.documentElement).getPropertyValue("--accent").trim(); return r ? { x: r.left, y: r.top, width: r.width, height: r.height, accent } : null; }); if (!box) return { ...info, copper: -1 }; const png = await run.page.screenshot({ clip: { x: box.x, y: box.y, width: box.width, height: box.height } }); const img = decodePng(png); const probe = await run.page.evaluate((c) => { const d = document.createElement("div"); d.style.color = c; document.body.append(d); const v = getComputedStyle(d).color; d.remove(); return v; }, box.accent); const want = (probe.match(/[\\d.]+/g) ?? []).slice(0, 3).map(Number); let copper = 0; for (let i = 0; i < img.data.length; i += 4) { if (deltaE([img.data[i] ?? 0, img.data[i + 1] ?? 0, img.data[i + 2] ?? 0], want) < 10) copper++; } return { ...info, copper }; });''') s=s.replace('''const { openModel } = await import(`${REPO}/e2e/webgl.ts`);''','''const { openModel } = await import(`${REPO}/e2e/webgl.ts`); const { decodePng, deltaE } = await import(`${REPO}/e2e/pixels.ts`);''') s=s.replace(''' await run.step(61_000); await run.page.waitForTimeout(1500); await run.step(100);''',''' await run.step(61_000); await run.page.waitForTimeout(3000); await run.step(100); await run.page.waitForTimeout(500);''') open(p,'w').write(s) EOF grep -n "delt7a:T4b0,sh /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/iris-look/sheet.sh /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/iris-look/seq390.png /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/shots/390-light-dpr2-t0000-zoom.png /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/shots/390-light-dpr2-t0150-zoom.png /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/shots/390-light-dpr2-t0450-zoom.png /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/shots/390-light-dpr2-t0900-zoom.png /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/shots/390-light-dpr2-t1800-zoom.png /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/shots/390-light-dpr2-t2000-zoom.png && ffprobe -v error -show_entries stream=width,height -of csv=p=0 /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/iris-look/seq390.png7b:T62e,cd /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel && python3 - <<'EOF' p='states.ts' s=open(p).read() s=s.replace(''' await run.step(61_000); await run.page.waitForTimeout(3000); await run.step(100); await run.page.waitForTimeout(500);''',''' // Step the clock a second at a time until the poller asks, then let the answer land in real time, // short of B4.42's 30 s abort. const asked = asks; for (let i = 0; i < 70 && asks === asked; i++) await run.step(1000); for (let i = 0; i < 40 && answers < asks; i++) await run.page.waitForTimeout(250); await run.page.waitForTimeout(400); await run.step(50);''') s=s.replace('''run.page.on("requestfinished"''','''let asks = 0; let answers = 0; run.page.on("request", (r: { url(): string }) => { if (r.url().includes("/api/crew")) asks++; }); run.page.on("requestfinished", (r: { url(): string }) => { if (r.url().includes("/api/crew")) answers++; }); run.page.on("requestfinished"''') s=s.replace('''r.url().includes("/api/crew") && console.log(" poll answered", new Date().toISOString().slice(11, 19)));''','''false && console.log(r.url()));''') open(p,'w').write(s) EOF cd /home/user/theseus-portfolio/.claude/worktrees/agent-a09f8a217125dda9b && REPO=$PWD timeout 600 node --import /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/register.mjs /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/states.ts 2>&1 | grep -v "Warning\|trace-warn\|Reparsing\|To eliminate"7c:T7e1,Iris: early look at 68e13f5. On track: the pose and the move are as I called them, and nothing in the 3D needs changing. What I looked at: - your frame sequences at 1440 and 390 (DPR 1 and 2); - your dev server at 320, 390, 768, 1024 and 1440 in Calm and Off; - dark at 1440 and 390, and forced colours at 1440; - the record state through your feed (the camera stays on 6.1, and "13" rides in ink with no chip: right). Shots are in /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/iris-look/. Measured on your server: - data-marks 7 = 7 ticks drawn at every width; - canvas on the box in whole px (808 × 455 at 1440, 567 × 319 at 1024, 600 × 338 at 768, 358 × 224 at 390, 288 × 180 at 320); - overflow 0 at 320; - the bar's control at 1258–1400 × 32 at 1440 and 566–752 × 44 at 768; - forced colours: no canvas, the 2D's look, the dot in Highlight. Your two calls: 1. SHADOW_FADE (40 px inside each canvas edge, on /crew only): approved. The ruled foot was a real defect. 2. The flat 2D outline behind the turned bow: keep it. It's /'s grammar and loft.webp frame 5's ("its own drawing stays behind it"). The second bow reads as the drawing the hull was built from. Waterline stubs show between the two bows, as on /. Depths: your 18.4 px for 6.1 at 390 (358 wide) meets the ≥ 16 bound. 2.1's 17.8 px at 1024 is accepted: it isn't a checked seat, and it reads fine. Leave the bounds as they are. Not mine to fix in your files; I'm sending these two to Forge: - At 768–1023 the drawing is max 600 px, centred, so the crop's cut edges float 84 px inside the page at 768 (iris-look/calm-768.png). - Below 768 `.foot`'s −12 px margin lays Calm/Off over the canvas's bottom 12 px. The fade hides most of it; in dark the shadow is black at 0.6. What I couldn't judge: the move's feel at 30 fps on a GPU, and the 3.0 seat on your server. Your feed's sprint 31 didn't reach the server render in 40 s; I trust your 28.7 / 20.3 / 20.3 and my prototype's +35 fra7d:T6c4,Iris → Forge: two CSS changes for /crew from my early look at Pixel's 68e13f5, which runs on your 14cc5f6 drawing. Shots: /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/iris-look/calm-768.png and calm-390.png. 1. 768 to 1023: let the drawing take the content width. - Drop `.crew-page > [data-plan]`'s `max-width: 600px; margin: 0 auto` from B4a, which suited the whole-ship drawing. - The detail is a crop. Centred at 600 its cut edges float 84 px inside the page at 768, with the hull and the drawing sliced by invisible lines. - Full width inside the 16 px gutters frames it like 390 and 1024+, where the cut lands on the gutter or the panel's rule. - Result: 736 × 414 at 768, 991 × 557.4 at 1023. - Tell Probe: B4.33 and B4.36's boxes from 768 to 1023 change from 600 × 337.5. 2. Below 768: `.crew-page > .foot { margin-top: 0 }`. - `.foot`'s −12 px top margin was made for /'s drawing, whose bottom is empty margin. On /crew the canvas runs to the box's foot, so the row's top 12 px sit on the canvas: at 390 the canvas ends at 275.8 and the foot starts at 263.8. - The shadow then shows through Calm and Off's transparent cells. Pixel's fade hides most of it in light; in dark the shadow is black at 0.6. - Cost: the panel moves 12 px down. The h1 is at 341.7 at 390 today, so 353.7, inside B4.12's first screen. Everything else I measured is as called: - Off at 1440: all the numbers. - Below 768: only the focus number. - 7 ticks for 7 moments. - The bar's control at 1258–1400 at 1440 and 566–752 at 768. - The foot's Read as page left, control right, at 390 and 320. - Overflow 0 at 320. - Forced colours: CanvasText ticks, a Highlight dot.7e:T7df,Early look at Pixel's /crew build (origin/pixel/36 at 68e13f5, built on Forge's 14cc5f6 drawing): on track. The 3D needs no changes. Forge has two CSS changes, which I sent him directly. **What I looked at** - Pixel's move frames on Playwright's clock (0, 150, 450, 900, 1800, 2000 ms) at 1440 and 390, DPR 1 and 2. - His dev server (localhost:3342, fed by his scratch feed) at 320, 390, 768, 1024 and 1440, in Calm and Off. - Dark at 1440 and 390, forced colours at 1440, and the record state. - Everything is SwiftShader. Shots are in `/tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/iris-look/`. **Built as called** - The pose is yaw −35 / pitch 6 / lift 90, holding the framed height. The focus point holds exactly through the move. - 7 moments draw 7 ticks (`data-marks` 7) at every width. - The canvas sits on the drawing's box in whole pixels: | Width | Canvas | |---|---| | 1440 | 808 × 455 | | 1024 | 567 × 319 | | 768 | 600 × 338 | | 390 | 358 × 224 | | 320 | 288 × 180 | - No horizontal overflow at 320. - The bar's control sits at 1258–1400 × 32 at 1440 and 566–752 × 44 at 768. Below 768 it's in the foot, with Read as page on the left. - Off at 1440 shows all plank numbers. Below 768 only the focus number shows. - Record state: the camera stays on 6.1, and the seat's holder "13" rides in ink with no chip. - Forced colours: no canvas, the ticks in CanvasText, the dot in Highlight. - Dark: the ticks and the copper both read. **Pixel's two calls** - **Shadow fading out over the last 40 px inside the canvas edges (/crew only):** approved. Without it the drawing's box cut the shadow in a hard line along its foot. - **The flat 2D outline left behind the turned bow:** kept. It's `/`'s grammar and loft.webp frame 5's ("its own drawing stays behind it"). **Depth bounds:** 6.1 is 18.4 px deep at 390, where Forge's 16 px gutter makes the drawing 358 wide, not 390; that passes the ≥ 16 bound. 2.1 at 1024 is 17.8 px; tha7f:T426,Forge: Iris's early look changed two things (origin/forge/36, 036d34e). (1) From 768 to 1023 the detail takes the content width inside 16 px gutters, so B4.33/B4.36's boxes there change from 600 × 337.5 to 736 × 414 at 768 and 991 × 557.4 at 1023 (width = viewport − 32, height = width × 454.5/808). 1024+ and below 768 are unchanged. (2) Below 768 the foot no longer overlaps the drawing by 12 px. It starts at the box's foot (275.8 at 390), so the panel sits 12 px lower: Iris puts the h1 at 353.7 at 390, inside B4.12. Also: on my branch alone (the old `/` mount), the default-path axe sweep times out on /crew. With Pixel's branch merged locally it passes (2/2), so run your checks on the merge. The kept crew specs fail as the contract's rewrites predict (B4.1, B4.6, B4.9, B4.13, B4.14, B4.31). B4.30 also failed with WebGL ON: after the 10-minute pause, the panel went down at the 503. I believe the 3D under page.clock delayed the unpause poll's answer past the new 30 s abort. With your shared WebGL refusal it should hold; if it doesn't, tell me.80:T473,Forge has landed my two early-look changes on origin/forge/36 at 036d34e. I read the rules in the commit but haven't seen them in a browser yet. **In app/globals.css at 036d34e:** - `.crew-drawing` (Forge's new wrapper around the drawing and the 3D layer) gets `margin: 0 16px` below 1024. B4a's 600 px max-width is gone, so between 768 and 1023 the cropped drawing's cut edges sit on the 16 px gutters instead of floating inside the page. - `.crew-page > .foot { margin-top: 0 }`: below 768 the foot no longer overlaps the canvas. **Forge's own measurements** (Off path, live sprint 36 on seat 6.1 with 7 moments; I didn't take these): | Width | Drawing | Note | |---|---|---| | 768 | 736 × 414 | | | 1023 | 991 × 557.4 | | | 1440 | 808 × 454.5 | unchanged | | 390 | 358 × 223.8 | unchanged; foot starts at 275.8, the drawing's bottom edge | | 320 | | foot at 232; no horizontal overflow | Forge is telling Probe about the 768–1023 boxes, which change from 600 × 337.5. I'll check these boxes in a browser on the integrated build at review: 768, 1023, 390 and 320, in Calm and in dark. Nothing else is open from my early look.81:T70c,Pixel: the 3D on /crew is on origin/pixel/36 (f128658, with Forge's 036d34e merged), for your B4.36 to B4.40 to run against. What it exposes and does, so your checks find it: [data-model] is [data-plan]'s next sibling inside Forge's div.crew-drawing (sticky from 1024; the layer's inset:0 box includes the wrapper's 24 px padding-top, the canvas lies on the shown .plan-wide/.plan-narrow box). data-state as on / and /log; data-marks = ticks the last frame drew (0 in inked/record). Once-a-visit flag theseus:crew in sessionStorage; 1,800 ms on ease(). Focus point (notes-iris.md 3): in live/open nearSide(tip − 27.5·f, bottom of bandAt) on the focus seat (data-focus, crop read from data-tally), at rest/down the number's anchor, numberX(seat, false) at band mid-depth; yaw −35 if the plank's centre ≥ 312 else +35, pitch 6, LIFT 90, framed height held. lib/model/crew.ts crewMove() and lib/model/loft.ts makeLoft(…, crew) are pure (no three.js) if your oracle wants the screen point: frame 1 lands it on its 2D point and the drift over the move is 1e-13 px in node. Ticks: the marks batch, nearSide(markX, bottom) to nearSide(markX, bottom + 4), centre plane under the keel, --muted, 1.4 px, butt ends. Shadow fades over the last 40 CSS px inside each canvas edge on /crew only (Iris approved). My own measurements on a production copy, page.route answers: unchanged answer 0 frames; +1 moment 1 frame and data-marks +1; to open 1 frame and copper 0; inked/record 1 frame, data-marks 0, record letters the holder (13); max 7 draws, 25,329 triangles at 1440 with 10 ticks, 7,935 at 390; 0 frames after rest; 3D chunk 154,410 B gzip -9 (602,426 decoded). Note for page.clock: a step past 30 s with a poll in flight trips B4.42's abort, so step to the poll, then let the answer land in real time.82:T591,- A MutationObserver an init script attaches to `document` records the HTML parser's own insertions, so a "hydration changes nothing" check sees hundreds of childList records; attach it to the panel once its last child is parsed (a document observer that waits for it), and only script mutations remain (`.crew/sprint/35/`). - /crew's detail is server HTML that the poller follows outside React's tree (components/crew-live.tsx `redraw`): every write is guarded (an attribute set only where it differs, `classList.toggle(name, force)`, `textContent` compared first), so an unchanged answer makes 0 MutationObserver records (`setAttribute` with the same value still queues one), and a new tick is cloned from the server's slot paths in `data-slots`, so the client carries no geometry (`.crew/sprint/36/`). - `position: sticky` always makes a stacking context, so a drawing's `z-index: 1` lettering inside a sticky box paints under the model's canvas layer beside it: /crew wraps the drawing and `[data-model]` in one sticky `.crew-drawing` (Pixel's finding, `.crew/sprint/36/`). - Under `page.clock`, `runFor` fires a poll's timer but the fetch resolves in real time, so a read right after `runFor` sees the previous answer; wait in real time (`page.waitForTimeout(400)`) before reading. A 30 s abort timer will also fire on a 30 s jump if the page hasn't processed an answer the route already fulfilled (`.crew/sprint/36/`). 83:T41a,git commit -q -F - <<'EOF' Sprint 36: B4d's checks, red first (B4.33 to B4.42), and /crew's specs on the Off path B4.33 to B4.35 (crew-hull.spec.ts, oracle crew-hull.ts): the detail drawing in 2D, one tick per moment, the drawing following the poll, with Iris's amendments (decision 6, notes-iris.md). B4.36 to B4.38 and B4.40 (crew-model.spec.ts), B4.39 (crew-model-off.spec.ts), B4.41 (crew-control.spec.ts) on B3's harness; B4.42 in crew-live.spec.ts beside B4.28. crew.spec.ts, crew-bar.spec.ts and crew-live.spec.ts refuse WebGL in every context, with the contract's rewrites of B4.1, B4.6, B4.9, B4.13, B4.14 and B4.31 (same expect( counts; B4.1's fence narrows to canvas, B4.14 and B4.31 read 18,432 B, B4.14's /log line 16,384 B). crew-feed.ts stops a worker's sites in parallel: one by one, 17 kept sites overran the fixture's 30 s teardown. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01QrjXvdJC9qJR4aHc8kQPQC EOF git push -q origin probe/36 2>&1 | tail -2; git log --oneline -184:T457,type MomentIn = { kind: string; at: string; who?: string; text: string }; /** The live fixture's moments as the route tells them: valid, newest first (9 of its 12). */ const LIVE_MOMENTS = (told("live").run as { moments: MomentIn[] }).moments; /** A moment newer than the live fixture's newest (01:58:40 UTC on 24 Oct), on the same day. */ const moment = (minute: number, text: string): MomentIn => ({ kind: "report", at: `2026-10-24T02:${String(minute).padStart(2, "0")}:00.000Z`, who: "qa-engineer", text, }); /** * The live fixture told with `count` moments (its own newest, then newer ones made up to reach a * count past its 9), plus `extra` newer ones. */ function liveWith(count: number, extra: MomentIn[] = []) { const made = Array.from( { length: Math.max(0, count - LIVE_MOMENTS.length) }, (_, i) => moment(20 + i, `Moment ${i + 1} made up for the count.`), ); return told("live", { current: { moments: [...extra, ...made, ...LIVE_MOMENTS.slice(0, count)], }, }); } /** The live fixture with 10 moments: the drawing's whole tally. */ const LIVE = liveWith(10);85:T65e,type MomentIn = { kind: string; at: string; who?: string; text: string }; /** The live fixture's moments as the route tells them: valid, newest first (9 of its 12). */ const LIVE_MOMENTS = (told("live").run as { moments: MomentIn[] }).moments; /** A moment newer than the live fixture's newest (01:58:40 UTC on 24 Oct), on the same day. */ const moment = (minute: number, text: string): MomentIn => ({ kind: "report", at: `2026-10-24T02:${String(minute).padStart(2, "0")}:00.000Z`, who: "qa-engineer", text, }); /** The live fixture told with `count` moments (made-up newer ones past its 9), plus `extra`. */ function liveWith(count: number, extra: MomentIn[] = []) { const made = Array.from( { length: Math.max(0, count - LIVE_MOMENTS.length) }, (_, i) => moment(20 + i, `Moment ${i + 1} made up for the count.`), ); return told("live", { current: { moments: [...extra, ...made, ...LIVE_MOMENTS.slice(0, count)], }, }); } /** * The shown figures in [data-plan] that sit on the hull: over a pixel the canvas covers at half or * more (station figures and captions lie off it), in CSS px relative to `clip`. */ async function onHull(page: Page, clip: Box) { const hull = await canvasOnly(page, clip); return (await figures(page)) .filter((f) => { const x = Math.round((f.box.left + f.box.right) / 2 - clip.x); const y = Math.round((f.box.top + f.box.bottom) / 2 - clip.y); if (x < 0 || y < 0 || x >= hull.image.width || y >= hull.image.height) return false; return (hull.alpha[y * hull.image.width + x] ?? 0) >= 0.5; }) .map((f) => f.text); }86:T439, // The fade: transitions in the drawing and the model layer (the panel's own, a dot's or a // button's, aren't the model's fade). const list: { property: string; end: number; target: string }[] = []; (window as Window & { __runs?: typeof list }).__runs = list; addEventListener( "transitionrun", (event) => { const e = event as TransitionEvent; const el = e.target as Element | null; if (!el?.closest?.("[data-plan], [data-model]")) return; const own = (el.getAnimations?.() ?? []).find( (a) => (a as Animation & { transitionProperty?: string }) .transitionProperty === e.propertyName, ); list.push({ property: e.propertyName, end: Number( own?.effect?.getComputedTiming().endTime ?? Number.NaN, ), target: `<${el.tagName.toLowerCase()} ${el.getAttribute("class") ?? ""}>`, }); }, true, );87:T736,Forge: I found the root cause of B4.30's failure on the integration (mine + pixel/36 + your 27aca12). It is in the harness, not the poller. Evidence, from your B4.30 run from a scratch copy with page console logging: - In "Paused: 10 minutes", `live.press()` returns aria-pressed "false": the pause never happens. The focus loop's `[data-evidence] a`.focus() scrolled the page to scrollY 498. button[data-pause] is then at viewport y −309.4 (innerHeight 720), and press() clicks at getBoundingClientRect coordinates with page.mouse.click, which misses off-screen. The second press then PAUSES it. - So polls keep running through `live.tick(600_000)`. That runFor fires each poll and its 30 s abort timer (B4.42) in one synchronous jump, before any route answer can be processed. Every poll aborts (logged: start, abort fired +30 s, start +60 s, …), the 10-minute keep window runs out, and the 503 then turns the panel down. That is B4.42's own rule working. - Before B4.42 the same missed press was hidden: one poll stayed in flight across the jump (run() returns while flight is set) and was answered afterwards. - Experiment: the same build with only `signal` removed passes B4.30. A minimal sequence (ticks, press, 10 min, press, 503) with no focus scroll passes WITH the abort: the panel stays live. Fix (yours): make press() scroll the button into view first (e.g. `el.scrollIntoView({block: "center"})` before reading the box, or locator.click()), and ideally assert it returns "true". Your other two failures on the integration: B4.34's "none under the number's chip" at 390 on the live fixture (seat 3.0, f 0.819; ticks at x 146.8 and 142.3 under the chip box 143–161 × 164.5–175.5, light and dark, live and open), and B4.35 (I'm reading it now). B4.33, crew-control, crew.spec, crew-bar and the rest of crew-live pass: 36 of 39.88:T42b,PROD=/tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/prod OUT=/tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/shots timeout 300 node --import /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/register.mjs /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/silhouette.ts 2>&1 | grep -v "Warning\|trace-warn\|Reparsing\|To eliminate"; WIDTH=390 HEIGHT=844 PROD=/tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/prod OUT=/tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/shots timeout 300 node --import /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/register.mjs /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/silhouette.ts 2>&1 | grep -v "Warning\|trace-warn\|Reparsing\|To eliminate"89:T414,Forge: B4.35's failures on the integration come from the oracle's moment count, not the drawing. With redraw logging in a scratch build, every told answer drew exactly its moment count: hydration LIVE 9 → 9 ticks; "one past ten" 10 → 10 (the +1 childList you saw); liveWith(4) → 4; liveWith(5) → 5; then 9, open 9, live 9, inked 0. Your own failure output shows the panel agreeing at each step: [["live",9],["live",9]], 9 against your expected 10, and [[4,4],4] against [[5,5],5]. The live fixture has 9 valid moments. lib/crew-run.ts's momentsOf drops unknown kinds, unparsable `at` AND empty text. Your liveWith filters only NaN dates and kind "meeting", so the no-text moment counts in your 10 and in the newest 5. Suggest liveWith filter as momentsOf does (kind in MOMENT_KINDS, Date.parse ok, text trimmed non-empty), and expect min(valid, 10) after hydration rather than TICK.max. B4.35's no-mutation-at-10 step then needs an answer that really holds 10 before the extra one. B4.34's chip case (seat 3.0 at 390) I'm measuring now.8a:T7d0,/** * The 2D hull's silhouette, as B3.1 reads `/`'s: the hull's outline filled black, with its own * stroke, everything else hidden. The outline is the drawn path whose `d` is the hull clip's (the * path the planks are clipped to), found by geometry, not class; it is marked `data-probe-hull`, * on a WebGL-refused page only, where no model reads the drawing. Without one, the planks filled * (their union is the hull, but without the outline's stroke). The clip paths stay visible: a * hidden clipPath child clips everything away. */ export async function planksAlone(page: Page, clip: Box) { const outlined = await page.evaluate(() => { const svg = [...document.querySelectorAll("[data-plan] svg")].find( (s) => !s.closest("defs, pattern") && s.getClientRects().length > 0, ); const id = svg ?.querySelector("[data-plank]") ?.closest("[clip-path]") ?.getAttribute("clip-path") ?.match(/url\(["']?#([^"')]+)/)?.[1]; const hull = id ? svg?.querySelector(`[id="${id}"] path`) : null; const d = hull?.getAttribute("d"); const drawn = d ? [...(svg?.querySelectorAll("path") ?? [])].find( (p) => !p.closest("defs, clipPath") && p.getAttribute("d") === d, ) : null; drawn?.setAttribute("data-probe-hull", ""); return Boolean(drawn); }); const handle = await page.addStyleTag({ content: `html, body, body * { visibility: hidden !important; background: transparent !important; box-shadow: none !important; text-shadow: none !important; } [data-plan] svg clipPath, [data-plan] svg clipPath * { visibility: visible !important; } ${ outlined ? "[data-probe-hull] { visibility: visible !important; fill: #000 !important; stroke: #000 !important; stroke-dasharray: none !important; opacity: 1 !important; }" : "[data-plan] svg path[data-plank] { visibility: visible !important; fill: #000 !important; stroke: #000 !important; stroke-width: 2px !important; stroke-dasharray: none !important; op8b:T784,Forge: one of your calls needs a ruling. Probe's B4.34 ("no tick under the number's chip") fails on the live fixture's seat 3.0 at 390. Measured on the integration (mine + Pixel + Probe), Off, 10 moments, chip box against tick tops (positive = the chip's bottom below a tick's top): - 1440: ticks 2–4 under the chip horizontally, all clear vertically (−6.2, −6.0, −2.7 px). - 1024: clear (−0.9 worst). 768: clear (−2.9). - 390: tick 4 −0.6 (Probe's slack counts it), tick 5 +1.6, OVERLAPPING. - 320: tick 4 +0.6, tick 5 +2.4. Why: "hanging ticks can't meet the mid-band number" assumes the lower edge is level under the chip. On 3.0 the profile rises aft: at numberX = 101.5 the band is 58–73 (15 deep, mid 65.5), but 8 units aft the bottom is 69.3 and 12 aft it is 67.4. Ticks k ≥ 2 are under the chip's x-span (f 0.819), and the chip's aft half overhangs the rising edge. The chip is 11 px tall: 9.8 units at 390, 12.2 at 320. 6.0 would do the same at 320 (bottom 114.2 at 12 aft). It isn't a fixture seat. Options I can build: (A) Set the number's y at the middle between the band's top and the SHALLOWEST bottom under the chip's span (x ± 10 units). 3.0 at 390: chip 58.3–68.1, clear of every tick by ≥ 0.3 units (0.3 px, tight), still under the seam above. At 320 it still overlaps by about 1 px: the band under the span (10.4 deep, 9.4 px) is shorter than the chip. Same rule on every seat; a no-op where the edge is level. (B) A plus: only where the span can't hold the chip, nudge the number forward by the shortfall, ≤ 4 units, keeping your ≥ 2 px dot clearance. That's 3.0 below about 360 px. (C) Keep your rule and narrow B4.34's chip clause to 768 and up, which pass with ≥ 0.9 px. My lean: (A). It's one hull-unit rule shared with Pixel's riding number (it takes my anchor), fixes 390 where Probe checks, and leaves 320 1 px tight on one seat in 22. Your call; I'll build whichever.8c:T7d5,Pixel: I ran your 27aca12 crew-model specs on my 5f36a4b (Forge's 036d34e merged), in a clean scratch build (not my worktree). B4.39 passes; B4.36, B4.37, B4.38 and B4.40 fail, each on something in the check as far as I can measure. Evidence and proposed fixes: 1. B4.36 silhouette 12 px at 1440 and 390: `planksAlone` sets `body * { visibility: hidden }`, which hides the `` geometry too, and SVG drops invisible clip children, so every clipped plank paints nothing: the 2D silhouette is empty, and 12 is hausdorff's R cap. Adding `[data-plan] svg clipPath * { visibility: visible !important; }` gives 2.24 px at 1440 (2 at 390). The rest is the 3D outline's 1.6 px stroke, which a planks-only silhouette leaves out (B3.1 on / compares against .ln-outline filled and stroked). With the outline's stroke in the 2D shot as well: 1.41 px at 1440, 1.0 at 390, within 1.5. Screens: /tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/pixel/shots/silhouettes-1440.png and -zoom.png; script pixel/silhouette.ts. 2. B4.36 depth: your pixel run reads 17 (3.0 and 6.1 at 1024) and 15 (3.0 at 390). The loft's own geometry at your viewports (1024×900, 390×844), the projected distance between the band's top and bottom at tip − 27.5·f, is 19.0 (6.1 at 1024), 20.4 (3.0 at 1024) and 20.2 (3.0 at 390). Iris's floors came from geometric depths (her 6.1 at 1440 is 26.5; mine is 26.5). The run of "differs by > 6" pixels loses the antialiased edge rows, and on 3.0 the near-vertical hatch over a fill within 6 levels of the record's breaks it. Either measure geometrically (lib/model/crew.ts crewMove and lib/model/loft.ts makeLoft are pure) or recalibrate with Iris. 3. B4.37/B4.40 data-marks 9 for 10 expected: the live site's panel shows 9 moments (your own [data-marks, momentsShown] read [9, 9]), and the 3D follows the 2D ticks. Likewise liveWith(5) shows 4. So your oracle and Forge's panel disagree on which moments survive the data rules. That's Forge's o8d:T7d3,Ruling sent to Forge: the pencil number's height on the plank changes, so its chip clears the ticks on seat 3.0 at 390. 320 stays about 1 px tight on two seats, which I accept. **The problem Forge found.** Probe's B4.34 check (no tick under the number's chip) fails on the live fixture's seat 3.0 at 390. On Forge's integration build (Off, 10 moments) ticks 4 and 5 overlap the chip by up to 1.6 px at 390, and by up to 2.4 px at 320. - At 1440, 1024 and 768 everything is clear by at least 0.9 px. - The cause is my mistake. I said hanging ticks can't meet a number sitting in the middle of its band, which assumed the plank's lower edge is level under the chip. On 3.0 the stern's curve rises under the chip's aft half, so the chip pokes below the plank's edge. **The ruling (Forge's option A):** - The number's height is the middle of the band's top at its x and the shallowest bottom anywhere within ±10 hull units of that x. Its x is unchanged: min(body middle, tip − 20). - It's one rule in hull units, and Pixel's riding number uses the same anchor. It changes nothing on seats where the edge is level. - At 390 it leaves 3.0's tick tops 0.3 px clear of the chip, by Forge's numbers. **Rejected:** - (B), a forward nudge of the number only below 360 px: it would apply on one seat in 22 at widths nobody checks. - (C), limiting B4.34's chip clause to 768 and up: 390 is where Probe checks, and (A) passes there. **Known and accepted:** at 320, seats 3.0 and 6.0 stay about 1 px tight. The band under the chip's span is shallower than an 11 px chip. 320 isn't a checked width, and I'll name it in my review. **For Probe (Forge is relaying):** - B4.34's chip clause stands at 1440 and 390. - If his slack makes 0.3 px flaky, he tells me rather than loosening the check. **Not verified by me:** these are Forge's numbers. I'll measure the chip against the ticks on 3.0 at 390 and 320 at review. **Memory line to bring over** (it corrects the one about hanging ticks): - Hanging ticks clear8e:T4af,Iris: build (A). Thanks for catching it. My claim that "hanging ticks can't meet the number" assumed a level lower edge under the chip, and on 3.0 the counter rises under the chip's aft half, so the chip pokes below the plank's edge. The rule: - The pencil number's y is the middle of the band's top at numberX and the shallowest bottom anywhere in numberX ± 10 units. - x stays min(body middle, tip − 20). - One hull-unit rule, shared with Pixel's riding number through your anchor. - It changes nothing where the edge is level, which is every seat but the counter and keel-end ones. No (B): a nudge that only applies below 360 px on one seat in 22 adds a rule nobody will ever see working. No (C) either: 390 is where Probe checks, and (A) passes there. For Probe, via you: - B4.34's chip clause stands at its widths (1440 and 390). - 320 isn't a checked width. 3.0 (and 6.0) stay about 1 px tight there, because the band under the chip's span is shallower than an 11 px chip. That's accepted, and I'll name it in my review. - At 390, (A) leaves 3.0's tick tops 0.3 px under the chip's foot. Tight, but clear. If Probe's slack makes 0.3 flaky, he should tell me rather than loosen the check.8f:T50c,git add e2e && git commit -q -F - <<'EOF' Sprint 36: B4d's checks corrected against the build (pixel/36 with forge/36) - The live fixture tells 9 valid moments, not 10: liveWith takes the route's own moments and makes up newer ones past 9, so B4.35, B4.37 and B4.40 reach 10 ticks honestly. - B4.34: a tick's stroke box follows its caps (MARKS has butt caps), and "under the chip" means more than half a pixel of overlap. - B4.36: the 2D silhouette is the hull's outline filled with its stroke, as B3.1 reads /'s (a hidden clipPath child had clipped the planks away); the depth is read in the focus point's column above the lower edge. - B4.37: "on the hull" is over the canvas's hull pixels (station figures lie off it); each poll at its schedule (60 s once open or resting), the redraw read one frame after it. - B4.38: the scroll gets room on a page that fits the screen; the reduce fade is read in the drawing and the layer. - crew-live.ts press() scrolls Pause into view first (Forge's trace of B4.30). - In-page waits on a paused clock moved to Node's time. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01QrjXvdJC9qJR4aHc8kQPQC EOF git push -q origin probe/36 2>&1 | grep -v -i warn | tail -1; git log --oneline -190:T517,Probe: 2b178f9 on origin/probe/36 fixes your points 1, 3, 4, 5 and 6, and leaves 2 and 7 open: 1. The silhouette is now the hull's outline filled, with its own stroke. I find it by geometry: the drawn path whose d equals the hull clip's. 3. liveWith now uses the route's validated moments: 9 from the fixture, plus made-up newer ones to reach 10. 4. A number counts as "on the hull" only if it sits over canvas pixels with alpha ≥ 0.5. 5. Each poll runs on its own schedule. 6. The scroll gets a spacer when the page doesn't scroll. 2. Depth stays in pixels, and I'm sending it to Iris. Here is the profile for 3.0 at 1024, in the focus point's column with the live frame against the record frame. The record frame's seam sits at −16 and −15 rows above the edge, 97,106,107 against card 177. Rows −32 to −17 are identical in both frames: that's the plank above. The changed rows run from −16 to 0, and the lower edge's ink is at +1 in both. So 3.0 is painted about 17 px deep there, against your geometric 20.4. The crop is depth-live.png in my scratchpad. Iris decides whether her floor means painted pixels or geometry. 7. The reduce fade still reads "opacity only", the contract's words, so the check stays red on fill and visibility. Atlas gets it as a needs-decision for Iris and Quill.91:T453,moving Pause 25 px; the resting answer takes the live run's sprint and goal, as a run that ends does (.crew/sprint/35/, Forge's finding, Atlas's call). - On a page on Playwright's paused clock, a wait inside `page.evaluate` (setTimeout, rAF, a smooth scrollIntoView) never ends: wait in Node's time. Since B4.42's 30 s abort, one `runFor` past a poll in flight aborts it before the route's answer lands: step each poll at its schedule (30 s live, 60 s open and resting) (.crew/sprint/36/). - Hiding `body *` to isolate a drawing also hides its `` children, and SVG drops invisible clip geometry, so every clipped plank paints nothing (B4.36's first silhouette was empty): keep `svg clipPath *` visible, and read a hull's silhouette as its outline filled with its own stroke, B3.1's method (.crew/sprint/36/). - The live fixture tells 9 valid moments of its 12 (an unknown kind, an unparsable `at`, an empty text): take a fixture's counts from the route's own answer (`toAnswer`), never by re-filtering the fixture, which counted 10 and sent three checks red on a correct build (.crew/sprint/36/). 92:T439, const tally = pencil ? tallyOf(seat) : null; return tally ? Math.min(middle, tally.tip - NUMBER_AFT) : middle; } /** How far either side of the pencil's number its chip reaches, in hull units, at any width. */ const NUMBER_SPAN = 10; /** * The y of a number set on its plank (not led out), at `numberX`: the band's mid-depth, as on /. In * pencil, the middle of the band's top there and the shallowest bottom within NUMBER_SPAN, so on a * seat whose lower edge rises under the chip (3.0's counter) the chip stays above the edge the * ticks hang from (Iris, .crew/sprint/36/). Null where the plank has no band. */ export function numberY(seat: string, pencil: boolean): number | null { const plank = plankOf(seat); const x = numberX(seat, pencil); const band = plank && bandAt(plank, x); if (!plank || !band) return null; if (!pencil) return (band[0] + band[1]) / 2; let bottom = band[1]; for (let dx = -NUMBER_SPAN; dx <= NUMBER_SPAN; dx += 0.5) { bottom = Math.min(bottom, bandAt(plank, x + dx)?.[1] ?? bottom); } return (band[0] + bottom) / 2; } 93:T500,Forge's fix for the plank number on seat 3.0 is in, on origin/forge/36 at 7b69f55. I've confirmed it from his close crops; this closes the B4.34 issue from my last report. **What changed:** a new `numberY(seat, pencil)` in `lib/hull-layouts.ts`, applied to the plank in progress only. The number's height now uses the shallowest bottom edge within ±10 hull units of the number, sampled every 0.5 units. **Gap from the number's chip to the nearest tick, by Forge's measurement** (seat 3.0, live, 10 moments, Off): | Width | Gap | Result | |---|---|---| | 1440 | 6.6 px | clear | | 1024 | 3.7 px | clear | | 768 | 6.4 px | clear | | 390 | 1.0 px | clear (Forge had estimated 0.3) | | 320 | 0.3 px overlap, slot 5 | the case I accepted | **What I checked:** his crops `/tmp/claude-0/-home-user-theseus-portfolio/cf0a3cf7-328e-5340-87af-21d3ceb552c9/scratchpad/shots/s30-zoom-390-light.png` and `s30-zoom-1440-dark.png`. - "31" clears every tick at 390 and at 1440 in dark. - The ticks hang along the stern's rising edge to the copper run and dot, as intended. **Not checked by me:** Forge reports that the drawings on `/`, `/read` and the Log are byte-identical to before. That claim is his, not my measurement. I'll check `/` at review. Nothing is open from me before review.94:T7d0,Outcome: my half of B4d is done and pushed on `origin/forge/36`, head 7b69f55. I merged it locally with Pixel's `pixel/36` (5f36a4b) and Probe's 27aca12 and 2b178f9. On that build, all 40 checks covering my part and the kept `/crew` specs pass, and `pnpm verify` passes on my branch. `/crew`'s script is 17,088 B beyond the 404's, against the 18,432 B budget. **Built (decision 5 files only):** - **`lib/hull-layouts.ts`:** the two layouts, `MARKS` and the tally maths, all to Iris's final numbers (her message to me; `.crew/sprint/36/notes-iris.md`, decision 6), which replace the contract's 320-unit, 16:9 boxes and its rising ticks. - `MARKS` is `{ pitch: 5, first: 10, length: 4, width: 1.4, max: 10, deep: 2 }`. Ticks hang down from the plank's lower edge. - `CREW_WIDE` and `CREW_NARROW` set the boxes and scales. `crewLayout(detail, focus, pencil)` is her crop; `tallyOf`, `markX`, `numberX`, and `numberY` (her call (A) below) are shared with Pixel. - `bandAt`, `depths`, `plankBody` and `ledOut` moved here from `lib/lines-plan.ts`. `/`, `/read` and the Log's drawings come out byte for byte as before: a JSON diff of all three plans is identical. - **`lib/lines-plan.ts` and `components/lines-plan.tsx`:** `crewPlans` and `CrewPlan` draw the two detail drawings. - Each is the profile alone, clipped to its box, with every plank kept. - The focus number shows at every width; other numbers show from 768. - The tally's ten slot paths are in `data-slots`; only shown ticks are `path[data-mark]`. - The tip's `g` is drawn whenever there's a pencil, and carries `data-tip` only while live. - `[data-plan]` carries `data-focus`, `data-run`, and `data-tally` when the server drew a pencil. - **`app/crew/page.tsx`:** the motion control in the bar and in the foot, and `` right after `[data-plan]`. Both sit inside a sticky `.crew-drawing` wrapper (Pixel's finding: a sticky box is a stacking context, so the numbers and the canvas have to share it). - **`components/crew-95:T7dc,Outcome: the hull on /crew is built and pushed to `origin/pixel/36` at a15e567, with Forge's branch up to 7b69f55 merged in. `pnpm verify` passes. The `/` and `/log` 3D suites are green. Of Probe's 3D checks, B4.37, B4.39 and B4.40 pass. B4.36 and B4.38 are still red, each on one open decision only: the depth floor (Iris) and the reduced-motion fade (Iris and Quill). **Commits (mine, on pixel/36)** - 46575e9 — the 3D on /crew. - It mounts on the detail drawings and tells /crew apart by `data-focus`. The crop comes from Forge's `crewLayout`, with `data-tally` saying whether the server drew a tally. - Desktop level and 2× cap from 768 px; phone level and 1.5× below. - The move uses Iris's pose, holds the framed height, and lasts 1,800 ms once a visit (`theseus:crew` in sessionStorage). - A MutationObserver re-reads the drawing on each answer and draws 1 frame only when the picture would change. `data-marks` reports the ticks the last frame drew. - The ticks are the stage's `marks` batch in graphite, with square ends and the tip's depth lift; the copper tip paints after them. - f905015 — the canvas sits directly in `[data-model]` inside Forge's `.crew-drawing`, plus my memory lines. - 68e13f5 — on /crew only, the shadow fades out over the last 40 px inside each canvas edge (`SHADOW_FADE`). Iris approved it: the box was cutting the shadow in a hard line. - 5f36a4b — the focus number rides the projection of its own anchor instead of the midpoint of its plank's edges. The midpoint strayed up to 0.55 px from the held point. - a15e567 — the focus point at rest reads Forge's `numberY`. Nothing drawn changes. - Files: `lib/model/crew.ts` (new), `loft.ts`, `mount.ts`, `stage.ts`, `calls.ts`, `ghost.ts`, and my own block "The hull on /crew" in `app/globals.css`. `components/model.tsx` is untouched. **Evidence** - **Focus point** - In node, the drift over the move is about 1e-13 px and frame 1 lands on the 2D point. - In Probe's B4.36 the focus number drifts 0.0096:T4fe,python3 - <<'EOF' p='.crew/sprint/36/contract.md' s=open(p).read() old="Under reduce, the fade is opacity only and\n ends within 300 ms." new="Under reduce, the fade is `/`'s: it\n transitions only opacity, fill and visibility, never a transform, position or size, and ends\n within 300 ms (amended, decision 7)." assert old in s open(p,'w').write(s.replace(old,new)) EOF cat >> .crew/sprint/36/decisions.md <<'EOF' 7. **B4.38's reduced-motion fade is `/`'s** (Atlas, on Pixel's and Probe's finding): the contract says `/crew` inherits `/`'s 240 ms fade, which also fades the planks' fill and the numbers', tip's and ticks' visibility, while B4.38's wording allowed opacity only. An opacity-only fade would leave the hull empty for an instant, which `/`'s fill fade exists to avoid, and reduced motion protects against movement, not a fade. B4.38 now allows opacity, fill and visibility transitions and still fails any transform, position, size or camera move, within 300 ms. EOF git commit -qam "Sprint 36: decision 7, B4.38's fade is /'s Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01QrjXvdJC9qJR4aHc8kQPQC" && git push -q origin sprint/36-b4d-crew-hull 2>&1 | grep -v "remote\|UNDICI\|trace"97:T403,Iris → Atlas: (a). The pose stays as it is, and the floor applies to the depth as painted. My 18 and 16 were geometric: the distance between the projected seam points, the same measure as Pixel's 20.4, 19.0 and 18.4. Probe reads painted pixels between the lines, and the seams' and outline's ink takes a consistent 3.0 to 3.4 px off that. The hull I approved is the one that paints 16 to 17 px at 1024 and 15 at 390. Nothing in it needs to grow. B4.36 as Probe reads it, painted, on the checked seats (6.1 and 3.0): - at least 15 px at 1440 and 1024; - at least 13 px at 390; - 5.0 stays exempt. That holds today's 16, 17 and 15 with 1 to 2 px of margin, and it still fails a pose that shrinks the plank by about 15%. Pixel's geometric numbers stay the design record in my notes, and nobody checks them. On B4.38: agreed. /crew keeps /'s reduced-motion fade (opacity, fill and visibility over 240 ms, no movement). That's what my notes meant by "/'s 240 ms fade". An opacity-only fade would empty the hull for an instant.98:T5df,B4.36 depth floor: I chose (a). The pose stays, and Probe now checks the depth as painted on screen. I sent the ruling to you and to Probe. The new floors, on the checked seats 6.1 and 3.0 at the tally's middle: - at least 15 px at 1440 and 1024; - at least 13 px at 390; - seat 5.0 stays exempt. Why: - My first floors (18 px, and 16 at 390) were geometric: the distance between the projected seam points. That is the same measure as Pixel's 20.4, 19.0 and 18.4. - Probe reads the painted pixels between the lines, and the seam and outline ink takes off a steady 3.0 to 3.4 px. You can see it by comparing his three reads with Pixel's figures. - The hull I approved is the one that paints 17 px (3.0 at 1024), 16 px (6.1 at 1024) and 15 px (6.1 at 390). Nothing needs to grow. - The new floors pass those three by 1 to 2 px and would still fail a pose that shrinks the plank by about 15%. - Pixel's geometric depths stay the design record in my notes, but no test checks them. B4.38: I agree with your ruling. /crew keeps /'s reduced-motion fade (opacity, fill and visibility over 240 ms, no movement), which is what my notes meant by "/'s 240 ms fade". An opacity-only fade would empty the hull for an instant. Not verified by me: Probe's painted reads are his numbers. I haven't run his check, and I have no painted read at 1440. At 1440 the 15 px floor is loose, since the geometric depth there is 26.5 px. I kept one floor for 1440 and 1024 rather than guess a painted value I haven't measured.99:T4fa,That notice is just the old watch on Probe's run timing out. The run had already finished and I read its results from the log, so nothing has changed since my report. **Where it stands:** the hull on /crew is pushed to `origin/pixel/36` at a15e567, with Forge's latest work merged in, and `pnpm verify` passes. The `/` and `/log` 3D suites still pass: 55 tests on a clean build. Of Probe's 3D checks, B4.37, B4.39 and B4.40 pass. Two of Probe's checks are still red, each waiting on a decision rather than on code: - **B4.36, plank depth at the tally.** Probe's check measures painted pixels and reads 15–17 px. The 3D geometry gives 18.4–20.4 px, and Iris set her 18 px floor (16 at 390) from geometric depths. Iris needs to say which she meant; if it's pixels, the fix is in her pose numbers. Probe has sent this to her. - **B4.38, the reduced-motion fade.** /crew uses `/`'s 240 ms fade, as the contract says, and that fade also changes the planks' fill and some elements' visibility. The check allows opacity only, as the contract's B4.38 wording says. Iris and Quill need to pick one; the opacity-only version is ready to write if they choose it. Probe is raising this with Atlas. Nothing of mine is still running. The only server left on the machine is Probe's.9a:T7df,Outcome: the hull on /crew is built and pushed to `origin/pixel/36` at a15e567, with Forge's branch up to 7b69f55 merged in. `pnpm verify` passes. The `/` and `/log` 3D suites are green. Of Probe's 3D checks, B4.37, B4.39 and B4.40 pass. B4.36 and B4.38 are still red, each on one open decision only: the depth floor (Iris) and the reduced-motion fade (Iris and Quill). **Commits (mine, on pixel/36)** - 46575e9 — the 3D on /crew. - It mounts on the detail drawings and tells /crew apart by `data-focus`. The crop comes from Forge's `crewLayout`, with `data-tally` saying whether the server drew a tally. - Desktop level and 2× cap from 768 px; phone level and 1.5× below. - The move uses Iris's pose (yaw ±35° toward the focus plank's end, pitch 6°, LIFT 90), holds the framed height, keeps the focus point on its frame-1 screen point, and lasts 1,800 ms once a visit (`theseus:crew` in sessionStorage). - A MutationObserver re-reads the drawing on each answer and draws 1 frame only when the picture would change. `data-marks` reports the ticks the last frame drew. - The ticks are the stage's `marks` batch in graphite, hanging MARKS.length below the edge, with square ends and the tip's depth lift; the copper tip paints after them. - f905015 — the canvas sits directly in `[data-model]` inside Forge's `.crew-drawing`, plus my memory lines. - A sticky `[data-plan]` would trap the riding number under the canvas, so Forge wrapped the plan and the layer in `.crew-drawing` (sticky) at my request. - 68e13f5 — on /crew only, the shadow fades out over the last 40 px inside each canvas edge (`SHADOW_FADE`). Iris approved it: the box was cutting the shadow in a hard line. - 5f36a4b — the focus number rides the projection of its own anchor instead of the midpoint of its plank's edges. The midpoint strayed up to 0.55 px from the held point. - a15e567 — the focus point at rest reads Forge's `numberY`. Nothing drawn changes. - Files: `lib/model/crew.ts` (new), `loft.ts`, `mount.ts`,9b:T7d0,Verdict: ship. B4.33 to B4.42 and the six rewrites are on origin/probe/36 at 2770b54. On the sprint head bff71c5, the full suite passes, 240 of 240, in 31.3 min at 2 workers. **Commits on origin/probe/36** - **27aca12**: the checks, red first. - New: `e2e/crew-hull.spec.ts` (B4.33 to B4.35) with its oracle `e2e/crew-hull.ts`; `e2e/crew-model.spec.ts` (B4.36 to B4.38, B4.40) with its harness `e2e/crew-model.ts`; `e2e/crew-model-off.spec.ts` (B4.39); `e2e/crew-control.spec.ts` (B4.41). - B4.42 is in `e2e/crew-live.spec.ts`, beside B4.28. - `crew.spec.ts`, `crew-bar.spec.ts` and `crew-live.spec.ts` now refuse WebGL in every context. Each has a beforeEach, and `crew-live`'s `freshContext` adds the refusal itself. - The contract's rewrites keep the same `expect(` count: B4.1's fence narrows to `canvas` (with WebGL refused and with scripts off), B4.6 allows `[data-tip]` in live, B4.9 expects Full/Calm/Off or the foot, B4.13 adds `