CT54.A6.CombinedSwarms — context file

Read this first to resume. CT54.A6 = CT54.A5 with the movie timing and sharpness fixed, a new science document for this version only, and option 5 described as an experiment based on the author's observations. The simulation and every hash are CT54.A1's. Then read CT54.A6.CombinedSwarms_AUDIT.md (how to run it) and CT54.A6.CombinedSwarms_SCIENCE.md (the science of A6 only, no history).

• Harness: Claude harness v4 (2026-10-13). New rule in v4: "In the case where video is requested, try to avoid using a batch process, and the process does not have to be in real time, what is desired is the result to be at the speed and resolution of the display as if video was not being recorded."
• Built: 2026-10-13 from C:\Users\micha\Downloads\claude\CT54.A5.CombinedSwarms (renamed A5 → A6).
• Rebuild of _main.js: all A6 edits to the renderer were made by one script applied to A5's _main.js (kept in the build session, not shipped); the diff is described below.

The user's request (CT54.A6)

The video continues to be at the wrong speed and the images appear to be soft. I need a document created which is the science of the current version, not the previous versions. The hovering swarm should be described as an experiment based on the observations of the author

Diagnosis

• Speed. A5 stamped each movie frame with the real time since the previous capture ('live' timing). Recording itself slows the page (encoding + the per-frame sound), so the movie copied the slowed screen, and the file had a variable frame rate (1/120..3 s per frame) that some players mistime. Before that, A4/A5-film used 1/30 s per frame while the screen stepped 4 sim steps per drawn frame, so on a machine drawing < 30 fps the screen itself ran slower than ×1 and the movie looked fast. Root cause: the screen's speed was tied to its frame rate.
• Softness. The picture was always rendered at a fixed 1920×1080 and CSS-scaled to the window; on a high-DPI or larger screen both the page and the movie were up-scaled. Also some hardware H.264 encoders do not honour the bit rate they are given (not confirmed on the user's machine).

What CT54.A6 changed (_main.js, index.html)

• One clock (tick()): not recording → sim steps = SPEEDS·FPS·wall dt (fractional accumulator stepAcc; wall dt capped at MAX_WALL_DT 0.25 s), camera springs use FRAME_DT = wall dt (FRAME_DT is now a let). Recording (filming = recording && recMode && direction≠0) → exactly SPEEDS[speedIdx] steps and FRAME_DT = 1/FPS per frame, then captureFrame(). pace.frac (screen speed ÷ chosen speed, per second) is shown on the HUD's movie line.
• Recorder (Rec): constant frame rate — frame i: timestamp round(i·1e6/30), duration to the next; audio exactly round((i+1)·48000/30) − written samples (1,600). TIMING, ?timing=, #timingSel removed; resetClock() is a no-op. Encoder candidates (candidates()): avc1.42E0LL prefer-software quantizer (q = ?q=, default 18) → avc1.42E0LL software bitrate → avc1.6400LL / 4d00LL / 42E0LL no-preference bitrate → vp09 quantizer → vp09 bitrate; LL = 2a (≤ 8,704 MBs) else 33. ?encoder=hw puts prefer-hardware first. Each candidate must pass isConfigSupported and probe() (encode one real frame at the size with the same options, output within 6 s). latencyMode: 'quality'. Rec.mbps (actual bit rate), Rec.started, Rec.resize(w,h). busy() queue limit 3. Prepare backstop 120 s (each step has its own limit); the note says "Preparing the movie recorder…" meanwhile.
• Size: SIZE_MODE 'screen' (default; no ?w/?h) → screenPictureSize() = 16:9 contain-fit of <main>'s box × devicePixelRatio, even, ≥ 640×360, ≤ 3840×2160 area. W, H are let; UI_K = H/1080 scales MIN_BEE_PX (3 px), the close-up's 2.5 px, the PIP margins/border. placePip(). Until Rec.started, resize / fonts.ready / a 1.2 s timer re-fit the picture (Rec.resize re-checks the encoder); after, a note says the take's size is fixed. #sizeSel: "Screen — W×H (default)" + 1280×720…3840×2160 (a fixed size reloads with ?w=&h=).
• Option 5 = experiment (labels): OPTIONS[5].name "Hovering ball (experiment)", label "5 · Hovering ball — EXPERIMENT (author's observation)"; page title plate CT54·A6; card tag "experiment · author's observation"; card text, .note5 box, banner, HUD and Option tooltip reworded. Still documented: false, not the default.
• Docs: _SCIENCE.md rewritten from scratch for A6 only (sections 0–11: summary, swarm, scene, bees, shared model, options 1–4, option 5 experiment, sound, what comes next, time/determinism/movie, tuned-vs-measured, sources). _AUDIT.md rewritten for A6 (the A2–A5 change logs dropped; history lives here).

Verified (CT54.A6)

• Node: option 1, 2,000 bees, 30 s = 4fe60707; option 5, 2,000 bees, 40 s = fbbc0818 (unchanged).
• Headless Chromium (SwiftShader, file://): recorder ready via VP9 constant quality (no H.264 encoder in that build); recording 10 frames advanced exactly 40 steps; MP4 0.333 s, r_frame_rate 30/1, Opus 0.34 s; screen-size mode gave the device-pixel size of the shown picture (1.5× scaling); no console errors.
• Not testable here: Chrome/Edge H.264 (software/hardware) on Windows; real-GPU speed.

Next ideas (not requested)

• If the user's movie is still soft, ask for the HUD's movie line (encoder + Mbit/s) or the file itself (ffprobe).

CT54.A5 context (still valid except where A6 changed it above)

The user's request (CT54.A5)

First, I would rather not run a batch file to get a movie. Second, getting the movie seems to fail. Third the movie that is produced does not have audio. Fourth the movie that is produced is too low resolution. Can any of this be fixed?

(Context: A4's index.html showed nothing for the user; the user's movies so far came from A3's PNG frames, which I encoded with ffmpeg here: 1280×720, no sound.)

What CT54.A5 changed (_main.js)

• Startup never waits on the recorder: checkServer() is called without await; Rec.prepare() has a 2.5 s limit per isConfigSupported call and 8 s overall. (Suspected cause of A4's blank page: the awaited prepare hung.)
• FilmSound: a software re-creation of Sound (wavetable bee wave, 10-voice bed with ±25-cent LFOs + LP 1400, noise BP 260/Q0.9 and BP 5000/Q1.2, 16 nearest-bee voices with Doppler (tmult = SPEEDS·DT·FPS·direction, i.e. film time) and equal-power pan; the same gains and time constants, smoothed per frame and ramped within it); frame(pos) returns 1,600 stereo f32-planar samples; ×6 make-up (?moviegain=) + tanh. lastPos (set in renderNow) feeds it. Sound.vol getter added. Measured −19 dBFS RMS / −7 peak; ~2 ms per frame. window.CT54.filmSound for tests.
• Rec: VideoEncoder + AudioEncoder (AAC mp4a.40.2, else Opus; 192 kbit/s) → mp4-muxer (video + audio, firstTimestampBehavior: 'offset'); codec list by size (≤1080p: avc1.640028…; 1440p: 640032…; 4K: 640033…; VP9 last). MediaRecorder fallback removed. busy() also watches the audio queue.
• Size: W/H default 1920×1080 (even); #sizeSel (1280×720 / 1920×1080 / 2560×1440 / 3840×2160) reloads with ?w=&h=; bit rate by size 12/20/32/50 Mbit/s.
• UI: #btnRec shows ● Recording m:ss / ○ Paused m:ss; the note says size, codec and sound.
• The server/frames code paths remain in _main.js but are dead (no server).
• Verified: headless Chromium from file://, fresh start (title → card → Start); recorder ready (1920×1080 + sound); a recording downloaded as MP4 with video (VP9 there; H.264 in Chrome/Edge) + Opus audio; ffprobe OK.

CT54.A5 fix (same day): "The video still seems to be at a different (much faster than live) speed. The imagery is softer than what I see on the screen"

• Timing: TIMING ('live' default, ?timing=film, #timingSel). In Rec.add each frame's duration = real time since the previous capture (1/120..3 s; first frame and after Rec.resetClock() — called by setDir and the Recording button — 1/FPS). Movie clock tUs; audio gets round(tUs·SR) − aSamples samples per frame: FilmSound.frame(pos, N) now takes N and smooths with DTF = N/SR; Doppler tmult = SPEEDS·DT·direction / DTF.
• Sharpness: bit rates 25/50/80/120 Mbit/s by size; ≤1080p codecs now start at avc1.64002a (level 4.2, allows 62.5 Mbit/s).
• Memory: mp4-muxer StreamTarget (chunked, 8 MiB, fastStart false); chunks kept as Blobs and stitched in Rec.finish() (late writes patch earlier bytes).
• Verified: 41 s wall at ~0.5 fps → 20.0 s video + 20.0 s audio (1 s cap at the time; now 3 s); decodes cleanly.

CT54.A4 context (still valid except where A5 changed it above)

The user's request (CT54.A4)

The audit says that ffmpeg could not be found, to reextract the zip, I did but it still did not work. I need a way to make a movie of this.

Diagnosis

On disk, A3's folder held the bundled ffmpeg.exe, and the user had also extracted the zip into it (nested CT54.A3.CombinedSwarms/CT54.A3.CombinedSwarms/). New frames (18:47) were written by a server rooted in the outer folder, and the page showed the "not found" note. Most likely the server process was the pre-fix A3 server (started before bundled_ffmpeg() existed) still holding port 8739; the new launcher could not bind and exited. Not confirmed, but A4 removes the dependency anyway. I made movies from both of the user's A3 takes with the bundled Linux ffmpeg: CT54.A3.CombinedSwarms_movies/…182003.mp4 (19 s) and …185022.mp4 (4 s).

What CT54.A4 changed

• In-browser recorder (Rec in _main.js): WebCodecs VideoEncoder (codec picked by isConfigSupported: avc1.640028 → 4d0028 → 42002a → 42001f → vp09.00.10.08), 12 Mbit/s (?mbps=), keyframe every 2 s; VideoFrame(canvas) timestamped i/FPS; output → Mp4Muxer.Muxer (ArrayBufferTarget, fastStart in-memory). Backpressure: encodeQueueSize > 6 skips the tick. Fallback: MediaRecorder on canvas.captureStream(0) + requestFrame().
• recMode: 'browser' (default), 'server' (?frames=1 + server + ffmpeg: the A3 PNG path), 'none'.
• Finish (finishBrowser()): flush → finalize → Blob; POST to /api/save_movie?name= when served by the launcher (written to _movies/), else an <a download>; the player shows it with a "save another copy" link.
• Server: /api/save_movie (streams the body to _movies/); at start, if the port is busy it POSTs /api/shutdown to the old server, retries, then tries the next 19 ports. The page compares /api/status label with its own and warns about a stale server.
• lib: CT54.A5.CombinedSwarms_mp4-muxer.5.2.1.js (+ LICENSE, MIT, Vanilagy), loaded before _sim.js.
• The ffmpeg bundle is left in the folder for ?frames=1 but excluded from the zip (keeps it ~2 MB).
• Verified: headless Chromium through the server (saved to _movies/) and from file:// (download); ffprobe: 1280×720, 30 fps, all frames decode (VP9 there; H.264 in Chrome/Edge).

CT54.A3 context (still valid except where A4 changed it above)

The user's request (CT54.A3)

Please mark the compact swarm option 2 as the default in a way that is obvious to anyone running this. Right now it comes up with the anomalous hover swarm as the default. Please start with the displays OFF, but a little notice for how to turn them on, maybe a little discreet text that says "Hit D to show displays" or something.

What CT54.A3 changed

• Why 5 came up: A2's code already defaulted to 2 for a plain open (verified), but any ?option=5 left in the address bar (switching options reloads with ?option=N&intro=0) was honoured. Fix: FRESH = intro !== '0'; a fresh start forces OPTION = DEFAULT_OPTION (2). Only ?intro=0 reloads (option switches, tests) honour ?option.
• ★ DEFAULT marking: .star badge on option 2 in the card (.opt.def: gold, glowing outline) and in the banner (#optBanner.def); selector label "★ 2 · Compact — cool, tightly bound — DEFAULT" (OPTIONS[2].label in _sim.js); gold .defline at the top of the card; Start reads "▶ Start option 2 — Compact (the default)". Non-default: banner .notdef "not the default · press 2…", #btnDefault "★ Go to the default". .opt.five toned down to grey-rose.
• Displays off at start: showHud = ?panels==='1'; setPanels(on) toggles #hudPlate, #camHelp and the hint #dHint ("Press D to show displays", dim, lower left of the picture, clickable; placed by placeHelp()). D/H call setPanels(!showHud).
• Verified (headless Chromium, file://): fresh start with ?option=5 → option 2 with all default markings; panels hidden + hint; D shows them and hides the hint; ?option=5&intro=0 → not-default note + Go-to-default button; no errors.

CT54.A3 fixes (same day, after the user's report "movie failed, ffmpeg not found for windows" and "the type needs to be reduced so that the options menu fits without a scroll bar")

• ffmpeg bundled in CT54.A5.CombinedSwarms_ffmpeg/: ffmpeg.exe (ffmpeg 7.1 win-x86_64) and ffmpeg-linux (7.0.2 static), extracted from the imageio-ffmpeg 0.6.0 wheels (BSD-2 wrapper licence copied; the binaries are GPL static builds). _server.py bundled_ffmpeg() is tried first (chmod +x on Linux if the zip lost it), then the old search (next to the script, PATH, imageio_ffmpeg).
• Gaps no longer abort the movie: frames go to ffmpeg through an ffconcat list (-f concat, duration 1/fps, -r fps -fps_mode cfr); missing is reported in the JSON, the sidecar and the browser note.
• Recovered the user's failed take: 570 frames (4 lost) in the A3 folder → CT54.A5.CombinedSwarms_movies/ CT54.A5.CombinedSwarms_movie_seed3906_20261012-182003.mp4 (19.07 s, 1280×720, H.264). The frames could not be deleted from here; the next run's "new take" clears them. The zip excludes _frames/ and _movies/.
• Option card fits: base size clamp(10px, .45vw+.6vh, 16px); #card is position:fixed over the whole window (max 96vh, z 50); fitCard() in _main.js shrinks font-size by 0.5 px until .fx-in doesn't overflow (on open, resize, fonts ready). Tags scale (.68em), the ★ DEFAULT star sits in the title line, descriptions span both columns. Measured: 1920×1080 → 15.1 px, 1600×1000 → 13.2 px, 1366×768 → 10.8 px, no overflow.

CT54.A2 context (still valid except where A3 changed it above)

The user's request (CT54.A2)

This is the same as CT54.A1.CombinedSwarm Except that it should make clear that item 5 is an anomaly and it should default to one of the more common swarms, a tightly bound one. Also there should be a keystroke to make the displays that take up so much space in the upper left and lower left go away (perhaps 'D') It should also make clear in the herald that the simulation takes minutes to resolve.

What CT54.A2 changed

• Default option 2 (Compact, cool, tightly bound) instead of 1: _main.js OPTION = … : 2. The card's option 2 reads "Compact · default", its description says "The default … tightly bound … one of the commonest shapes"; the banner and HUD add "default"; the selector label is "2 · Compact — cool, tightly bound (default)" (OPTIONS in _sim.js). optionOf() in the sim still falls back to 1 for unknown names (kept so the sim API is unchanged).
• Option 5 = anomaly: OPTIONS[5].name "Hovering ball (anomaly)", label "… ANOMALY: observed, NOT in the literature"; card tag "anomaly · not in the literature"; description starts "AN ANOMALY … Seen once; no study describes it."; the red note is headed "Option 5 is an anomaly"; banner/HUD "ANOMALY — observed in the wild, NOT documented in the literature". Labels only — the sim's numbers and hashes are unchanged.
• D key (and H as before) toggles #hudPlate (upper left) and #camHelp (lower left); a line "D — hide these panels" was added to the camera help and the footer key list; a short note in the footer confirms it.
• "Takes minutes to resolve" (the herald): a highlighted .wait box at the top of the option card, the title-art caption line, and the card footer.
• Verified: Node option 2, 7,500 bees, 150 s = b525ef4c (same as A1). Headless Chromium from file://: default loads option 2; card shows the wait box, default and anomaly badges; D hides/shows both panels; option 5 banner reads anomaly; no console errors.

CT54.A1 context (still valid except where A2 changed it above)

(File names below were renamed A1 → A2 in this folder.)

The user's request (CT54.A1)

Combine CT39 and CT52 into one combined swarm structure. Make it clear which of the 5 options one is picking. There should be one index.html file Make it clear that option #5 was observed (hovering in air) but not documented in the literature. At the top level have an audit .md and .html file to describe how to run this application and what the science is behind it.

The five options

The 5 options are the four CT39.C7/C8 Weather presets plus the CT52 ball. "Hangs from" (stem / flat beam) is kept as a secondary setting for 1–4 and shows "nothing — the queen hovers" (disabled) for 5.

What CT54.A1 changed

Simulation (CT54.A5.CombinedSwarms_sim.js)

• Base: CT39.C8's sim. CT52.A2's additions were grafted in and gated on P.hover, which is set by opts.option === 5:
• parameters (station, queenCruise/Drift, moveDX, follow, scentDrift, moveSpeed, pole, visRange, ball*, scentFrac, flightScentEmit, loseScent) added to DEFAULTS with hover: false;
• _buildBall / _sampleBall (the bee-density grid), _ballStep (mode 3), _diffuse (field diffusion split out), the separate queen-pheromone grid qfield (allocated only for option 5, checkpointed);
• in _stepOnce: the hovering queen's controller, mode 3, the CT52 version of "attracted" flight (lose the scent, fly at the queen within visRange, join the ball), and the under-the-beam approach rule switched off — each behind hover;
• in-flight scent emission in _slow, the pole in _stone (only when this.pole exists), requestMove / clearMoves / stationNow / _movesDone, ballShape(), and the option-5 census.
• Changes that are no-ops for 1–4: the fliers' centroid and neighbour hash skip mode ≥ 2 instead of mode 2 (mode 3 never exists in 1–4).
• OPTIONS table (1–5: key, weather, hover, documented, name, labels) and optionOf() exported in window.CT54Sim (was CT39Sim / CT52Sim). The constructor takes { option }; an explicit weather still works for 1–4.
• Result: bit-identical to both originals (Audit §5.2): option 1 and 4 = CT39.C8 mild / windy; option 5 = CT52.A2, including the move.

Page and renderer (index.html, CT54.A5.CombinedSwarms_main.js)

• ?option=1…5 (or names) chooses; HOVER in _main.js switches option-5 parts on: the pole, ballBox() framing (CT52's settledBox), close-up elevation −0.18 rad (1–4: −0.55), aims queen/ball centre, phase text, HUD ball line, odometers In ball / Milling / Scenting, scent slice through the station, Move queen (G) and Follow (L). Hidden for 5: Chains, Grips, Load. Hidden for 1–4: Move, Follow.
• The option card (#card, the C8 help card reworked): "Choose one of five swarms" — five big numbered keys with a description and a badge (green documented / red observed · not in the literature), the current one outlined, a red note explaining option 5, and Start. Shown after the title, and again from ? Options or the banner.
• The banner (#optStrip / #optBanner, a strip between the controls and the picture): "N · OPTION N OF 5 · NAME" plus the badge; red-edged for 5. The HUD's second line says the same.
• Switching (chooseOption()): the Option selector, keys 1–5, or a card key reload with ?option=N&intro=0. The bee count resets to the option's default (7,500 for 1–4, 5,000 for 5) when crossing between hanging and hovering.
• The test handle is window.CT54.
• The CT39 About file is replaced by the Audit (_AUDIT.md / .html); the title line and the footer link to it.

Results (seed 3906, default counts; Node = Chromium)

(1–4: length × width of the settled bees from clusterShape().)

Verified

• Node: hashes equal to CT39.C8 and CT52.A2 (Audit §5.2 lists them).
• Headless Chromium (SwiftShader, file://): the option card (options 1 and 5 selected), option 5 at 120 s, option 1 at 150 s, Move queen, key 3 switching to option 3; no console errors.
• Not re-tested: recording, the movie pipeline, sound (code unchanged).

Next ideas (not requested)

• A "streaker" rule for the option-5 move (SCIENCE §9.5).
• Option 5 on a hidden twig: a plausible explanation of the observation (Audit §4.3) that could be shown side by side.

Context inherited from CT39.C8.Swarm (options 1–4)

(File names below are the CT39.C8 names; in CT54 the prefix is CT54.A1.CombinedSwarms and the About file is the Audit.)

CT39.C8.Swarm — context file

• C8 = C7 plus a 'how to use' card. After the title (15 s, or Space), a card over the dawn scene says what you will see (the beard, about 8 × 4 in, in ~2 min), how to get the other shapes (Weather, Hangs from), how to see the chains (N) and how to work the camera. The sim waits until Start, Space or Enter. The ? Help button in the footer (or the ? key) shows the card again. Reloads from the selectors skip the title and the card (?intro=0).
• User's request (2026-10-09): "Could you please put these instructions into the startup of the simulation/app".
• Code: the #card in index.html (the C2-era Zoltar style); openHelp() and runIntro() in _main.js. The sim is unchanged from C7.
• Verified (headless Chromium): the card opens after the title, Start closes it and the bees appear, and Help reopens it; no errors.

CT39.C7.Swarm context (still valid)

Browser simulation (WebGL + three.js r186, vendored; works from disk) of a honeybee reproductive swarm. The bees mill around, then cluster under an old, broken wooden arbor at the brink of a summit high above the Adriatic, just before dawn. Open index.html (or run CT39.C8.Swarm_start.bat / .sh to record movies).

• Harness: Claude harness v3 (index.html top page, assets relative, libraries local). Built 2026-10-09.
• Lineage: C7 = C6 with a dense outer shell over the chains, Weather / support selectors that change the cluster's shape, a thin vine-stem support, and the opening text replaced by an About file. The C6 and earlier contexts follow below.
• To resume: read this file, then CT39.C8.Swarm_SCIENCE.md §6.7 (the C7 model) and the header of _sim.js.

The user's C7 request

Real clusters don't show loose, dangling strands of bees on the outside. The chains are hidden under a smooth, tightly packed outer layer. Cover the cluster with a dense outer shell of bees, with the chains inside it. Add a Weather or Support setting that changes the shape: warm and calm on a thin branch gives the beard, while cold, wind, or a flat surface gives a compact ball. Also remove the text from the start of the simulation, just put a reference to an MD or whatever file that describes the situation.

(Background: the user's friend Craig Reynolds disputed the beard shape; a report that morning found that both shapes occur, depending on conditions.)

What C7 changed

Sim (_sim.js)

• Envelope + shell (shell on by default; ?shell=0 = the C6 model). The cluster's outline is a shape of revolution around the queen (_envG, _envelope, _contain), its volume set by the settled bees and the packing. Bees outside are drawn in each pass; inside, a light gravity (sagShell 0.0005 ft/tick) and 2 + 3 packing passes. The shell (outer 2.2 contact distances; _findShell) packs at 0.62 and is drawn facing up.
• Grips no longer pull (gripSoft 0). They are still taken and tracked (chains, loads, N view); stretched ones are re-taken (_regripStretched). Why: with ropes alone, a narrow support gave a thin curtain and bees under a shared hold crushed together (median neighbour distance fell to 0.3–0.5 of contact). With the envelope it is ~0.84.
• Honesty: the proportions are presets chosen from the observations; they are not derived (SCIENCE §6.7).
• Weather presets (CONDITIONS):
• mild & calm 22 °C: beard, length/width 1.7.
• cool 11 °C: compact, ~1.0.
• hot 32 °C: expanded, short and broad, 0.8.
• windy 18 °C: 0.62; gusts every 1.7 s push the hanging bees across the beam and lean the envelope; the milling cloud drifts.
• The user's wording was "warm"; the J. Exp. Biol. 2022 paper shows hot clusters flatten, so the beard is labelled mild, and hot is a separate preset.
• Support:
• branch (default): a dead vine stem, a cylinder of radius 0.075 ft, slung 0.42 ft below the beam at mid-span (_stemAxisY); bees grip its lower half, and nothing climbs above its axis.
• beam: the C6 flat underside, with the top widened and the length capped at 0.9 × the width.
• Attachment: new bark only within the envelope's top radius of the queen (_inFootprint). Two bark-holders that overlap may shuffle apart along the bark.
• Determinism: the envelope is saved in checkpoints. Rewind = fresh run. Node = Chromium: mild/branch 7,500 bees at 150 s gives 1279a438 (before the late preset tweaks; recheck with window.CT39.sim.hash()).

Page (index.html, _main.js)

• Opening: the title art alone (15 s), with one line linking CT39.C8.Swarm_ABOUT.html; the C6 captions are gone. The footer has an ⓘ About link.
• Selectors: Weather and Hangs from; each reloads with ?weather=mild|cool|hot|windy and ?support=branch|beam.
• Chains (N): hidden (default) → shown (x-ray of the 16 longest chains) → contrast.
• The vine stem is drawn (bark-ridged tube, ends climbing over the beam, tendrils round it).
• HUD: the conditions → shape, and the cluster's size under the stem or beam.

C7 results (Node, seed 3906, 7,500 bees, 150 s; depth × width of the settled bees, 1–99 %)

• ~99.9 % settled by 90–120 s (faster than C6, because the fanning surface is now the envelope's outer layer).
• In the browser (SwiftShader), 150 s of sim took 88 s, so the sim runs about 1.7× real time on the test machine; C7's sim costs ~40 % more than C6's.

Known limits (C7)

• The shape is imposed by the envelope (see above); the chain network no longer shapes it.
• Load figures (HUD "bee-wts each") can exceed the measured mean grip (35 ± 14) on the thin stem: there are fewer bark-holders, and bees wrapping the top half of the stem are not simulated.
• The stem is a perfect cylinder where bees can grip it; flying bees can pass through it (it is thin).
• A few stray bees can hang briefly below the tip before they are drawn in.

CT39.C6.Swarm context (still valid except where C7 changed it above)

The user's C6 request

The following title cards will replace the one you wrote, with these 4, they will just be type overlays on top of the 3D environment but before any bees are present. Each card, so-called, fades in and then out. After the final card, the queen and the bees appear in the space and the audio begins. 1. "The following is a simulation of what is apparently considered a typical bee reproductive swarm." 2. "In this case, when the hive gets overcrowded, the old queen and some number of drones and workers are ejected from the hive, and the original hive grows new queens." 3. "In the mean time, the old queen and some loyal workers, attach themselves to a branch or some other handy surface, while scouts go out to find a place for the new hive." 4. "So this is a simulation of the queen and workers, having been ejected, as they create a temporary home. The bees are literally hanging from each other in long chains of bees."

The captions are used word for word. Only one stray comma is dropped, in card 3 ("loyal workers, attach" → "loyal workers attach").

Pending from the conversation (not in C6): the user saw a real swarm, a ~10 ft sphere of bees contracting to a 12–18 in ball that seemed unattached and not gripping. They will describe it, and a "hovering ball" mode can be built from that later.

What C6 changed

The opening sequence (runIntro() in _main.js; #caption in the page)

1. Title: the title art (swarm 3) for 15 s, as in C4.
2. The empty scene: the art fades, and the dawn scene comes up out of black: the arbor, the cliff, the sea, the moon. No bees are drawn. * beesHidden hides the five bee meshes and the chain lines; the close-up window is not drawn. * The HUD and the camera help are faded out (body.intro). * The simulation stays paused at t = 0, so the scene is a still dawn.
3. The four captions: * Look: each one, in turn, fades in (1.6 s), holds, and fades out (1.7 s). They are type only: Metamorphous in pale gold, with a dark glow behind the letters and a soft vignette for legibility, placed in the lower third over the scene. * Hold time: reading time, max(5, 2 + 0.33 × words) s, so about 7 s for card 1 and about 12 s for cards 2–4. The whole sequence is about 75 s. * Hint line: a small "Click to turn on the sound · Space to go on" sits under the text.
4. The bees: after the last caption the bees appear, the HUD and the camera help fade back in, and the simulation starts. The sound of the bees rises as it starts (as before, the sound is silent while paused). * Browsers allow audio only after a click or key press. The first click wakes the sound without skipping; later clicks, or Space / Enter / Esc, step on through the sequence.

URL options: * ?intro=0 skips everything. * ?title=<s> sets the title's time. * ?captions=<x> scales the captions' hold times.

Removed: the C2 Zoltar-style card (#card) is gone from the page. Its CSS remains, unused.

Simulation: unchanged. The hash is the same as C5.

C6 verified (headless Chromium, SwiftShader, from file://)

• Title, then empty scene: the title shows, then the dawn scene appears with no bees, and the captions fade in over it, legible over the sky and the arbor. During the captions, beesHidden = true and the sim step is 0.
• After the last caption: the bees appear, the sim runs, and the HUD, the camera help and the close-up are back.
• No console errors.

CT39.C5.Swarm context (still valid except where C6 changed it above)

The user's C5 request

There should be some text with camera instructions, probably on the lower left of the main viewscreen window. It should probably advise the user to use the mouse to change the camera pov and the scroll wheel to move in or out. I think the wide viewscreen is pointing at the queen at the top of the cluster, but it would be nice if there was some more flexibility to change the camera pov to get a better idea of the structure of the swarm as it is being built. The close in viewscreen could be closer as long as it keeps the entire "settled, hanging" swarm in window.

What C5 changed (_main.js "C5:", CT39.C6.Swarm.html)

1. Camera help, lower-left of the picture (#camHelp)

A small translucent plate in gold monospace type: * Drag: orbit around the swarm. * Wheel: move in / out. * Right-drag or Shift-drag: pan the view. * T: aim at the queen · centre · tip. * Double-click: re-centre. * A: auto camera.

Placement and behaviour: * placeHelp() puts it in the corner of the rendered picture, not the window: the canvas is letterboxed, and the plate follows on resize. * It is not part of the WebGL canvas, so it never appears in recorded movies. * H hides it together with the HUD.

2. More freedom for the main camera

• Aim (T / new "Aim" button):
• cycles between the queen (the top of the cluster, as before), the cluster's centre and the cluster's tip (its lowest point);
• the centre and tip come from a box around the settled, hanging bees (settledBox(), recomputed every frame from the displayed positions);
• the aim moves there smoothly on the existing spring;
• ?aim=centre|tip sets it from the URL.
• Pan (right-drag or Shift-drag):
• moves the look-at point across the screen at its depth (an offset added after the aim spring, so it responds immediately);
• works in AUTO and ORBIT;
• is limited to 40 ft;
• double-click, or changing the aim, clears it.
• The browser's right-click menu is suppressed on the picture.
• Orbit elevation now goes from −69° to +86° (was −14° to +83°). You can orbit right underneath and look up into the chains; the camera still never goes below the ground.
• HUD camera line: "… ft from the queen / the cluster centre / the cluster tip (panned)".

3. The close-up comes in as close as it can

• Where it looks: at the centre of the settled-bee box, grown by a bee's length.
• How close: each frame it computes the distance at which all eight corners of that box, seen from the close-up's current direction (it still circles slowly, from below), fall inside 92 % of its window; the distance follows a spring.
• Before: the distance was 5 × the cluster's size.
• Result: at 200 s it is 2.0–2.7 ft from the cluster, instead of 3.5 ft, and the whole beard fills most of the window. Early on, with fewer than 30 bees settled, it frames the queen at ~0.5–1 ft.

Simulation: unchanged. The hash is the same as C4 (seed 3906, 7,500 bees, 200 s: 648fafb6).

C5 verified (headless Chromium, SwiftShader, from file://)

• AUTO at 60 s and 200 s:
• the help plate sits in the lower-left of the picture;
• the close-up shows the whole cluster, much larger than in C4.
• T, T: the aim goes to the tip (HUD "from the cluster tip"), and the button reads "Aim: tip".
• Orbit from 52° below at 3 ft, aimed at the centre: looking up at the whole hanging beard against the beam and rafters.
• Real mouse: a right-drag pans (HUD "(panned)"), and a double-click re-centres.
• No console errors.

Known limits (C5)

• Help text: it is fixed. Hide it with H, which also hides the HUD.
• Pan in AUTO mode: the auto camera stands still, so panning only turns its view.

CT39.C4.Swarm context (still valid except where C5 changed it above)

The user's C4 request

Please change the opening splash graphic to "swarm 3.webp" as found in the folder "C:\Users\micha\Downloads\claude\CT39.artwork"

The rest of the message repeated the earlier specs and lists, all already in place.

What C4 changed

• The opening title is now the user's swarm 3.webp, copied unchanged as CT39.C6.Swarm_title.webp.
• It is a portrait (816 × 1456): a gold clockwork bee with wings spread, surrounded by mechanical insects and instruments, with "THE SWARM" at the foot.
• The B1–C3 title was swarm 9.webp.
• Unchanged: the title still holds 15 s and then fades to the plain-language card from C2. The page layout (height 94 %, centred) fits the portrait without changes.
• Nothing else changed. The sim hash is the same as C3.

C4 verified (headless Chromium, SwiftShader, from file://)

• 2.5 s in: the new title is shown whole, centred, on black.
• The card follows it.
• No console errors.

CT39.C3.Swarm context (still valid except where C4 changed it above)

The user's C3 request

The rendering should default at the start to "shadows off".

The rest of the message repeated the C1 spec and the B2, B3 and C2 lists, all already in place.

What C3 changed

• Shadows start OFF (_main.js: shadowsOn = qs.get('shadows') === '1'). Q or the Shadows button turns them on, and ?shadows=1 starts with them on.
• Still on at the start: shading, reflections and crystal wings.
• Still off at the start: the bee outline (as since B2; U turns it on).
• Nothing else changed. The sim hash is the same as C2 (seed 3906, 7,500 bees, 200 s: 648fafb6).

C3 verified (headless Chromium, SwiftShader, from file://)

• At startup: the Shadows button is unlit and the HUD reads shaded·reflect·crystal.
• After Q: the button lights, the HUD reads shaded·shadows·reflect·crystal, and the shadows render.
• No console errors.

CT39.C2.Swarm context (still valid except where C3 changed it above)

The user's C2 request

There appears to be some sort of repeating pattern, visible artifact on the ocean seen at a distance that looks bad. I think we should rewrite the text explanation used at the beginning of the simulation, to explain what is going on in more concise, less arcane language. Among other things it should explain that we are using the scent model of bee organization, and that the bees are organized in chains with the top bee gripping the surface of whatever material it is hanging from.

The rest of the message repeated the C1 spec and the B2 and B3 lists. These were handled as in C1 (see below).

What C2 changed

1. The sea (_main.js, "C2: the waves")

The cause. Since B3 the sea's ripples were a 256-px canvas normal map tiled 900 times across the 200,000-ft plane, so the pattern repeated every ~220 ft. Far out, the tiles and their mip levels lined up into a visible regular grid and moiré.

The fix: the waves are computed per pixel from the world position (seaMat.onBeforeCompile). There is no texture any more. * Wave trains: 13 of them, with incommensurate wavelengths from 1.7 to 173 ft and directions spread around a wind direction, so the sum never repeats. The long ones are kept gentle (slope ≤ 0.013) so they never read as stripes; a first try with a stronger 309-ft swell drew parallel bands. * Irregular chop: the gradient of value noise at 5, 13 and 31 ft. * Patchiness: a slow noise (260 and 900 ft scales) varies the wave strength across the sea. * No aliasing: every wave train and noise octave fades out once it is finer than about a pixel. The fade is computed from the pixel's footprint on the water, fwidth(world xz). * Far sea: the detail that fades away is replaced by extra roughness (up to +0.33). The far sea goes smoothly to a soft mirror, and the glitter path widens the way real sub-pixel chop widens it. * Settings: base roughness 0.12, metalness 0.85, customProgramCacheKey 'sea-c2'.

2. The opening card (CT39.C6.Swarm.html, #card)

The card is rewritten in plain language, in the same CT46-style frame and fonts. * Heading: "The Exiled Queen and Her Swarm", with the kicker "The Swarm · What you are watching". * Three short paragraphs: 1. why a hive swarms: the old queen leaves with about half the workers and some drones, and they wait while scouts search for a new home; 2. the scent model: the queen, then each settled bee, gives off a scent that drifts through the air; every bee flies toward it and steers by its neighbours; 3. chains: a bee lands where it touches the cluster; the top bee of each chain grips the wood of the arbor and every bee below holds on to the bees above; a new bee starts a chain or joins one. * Styling: the drop cap is on the first paragraph only, and the key terms are in gold. * Footer: "Click to turn on the sound · Space to continue".

Simulation: unchanged. The hashes are the same as C1 (seed 3906, 7,500 bees, 200 s: 648fafb6, in Chromium and Node).

C2 verified (headless Chromium, SwiftShader, from file://)

• High oblique view and the view from under the arbor out to sea:
• no grid, no moiré and no stripes on the distant water;
• fine irregular chop near the cliff;
• a soft, widening glitter path under the moon.
• The card: fits the frame at 1500 × 950.
• Default AUTO view at 200 s: as C1.
• W wire look: works.
• No console errors.

Known limits (C2)

• The waves are static (they do not move with time). Moving them would only need a time uniform, but at 1,400 ft below it would be barely visible.
• The card is a fixed size and can be clipped on very short windows (under ~700 px).
• Everything else as in C1.

CT39.C1.Swarm context (still valid except where C2 changed it above)

The user's C1 request (abridged)

An ancient site, possibly the Adriatic, at altitude, just before dawn; the sky lightening, the moon visible. We are overlooking the ocean from a high place. There is an old wooden arbor here, in bad shape. That is what the queen attaches herself to. Natural lighting, diffusely lit, occasionally backlit. Metal bees with narrow black and broad gold stripes, crystal wings, five red eyes, outline rendered. UI toggles for shaded/wireframe, shadows and reflection mapping. Title 'swarm 9' for 15 s, then the arcane card. Scent, neighbours, land on contact. Two viewports. Gold status type. Bee audio.

The B2 and B3 lists were repeated with it.

How the repeated lists were read: * Kept from B3: the distant Adriatic, no outlines on the stone, a degraded surface, and only one or two stars. * Stars: B2 asked for Rigel, Betelgeuse, the Pleiades and three planets; B3, the later request, asked to remove all but one or two. B3 wins: Venus and Jupiter and the crescent moon. * Gone with the stone: the B2/B3 items that only applied to the arch and ruins (a thin arch without gaps, crepidoma, stones) no longer apply. * Unchanged: 7,500 bees, outline off by default (U turns it on), the close-up placed low and looking up, and the compact HUD.

What C1 changed

The arbor (_main.js, "C1: THE ARBOR"; _sim.js, arborBoxes())

1. The arch, the crepidoma and every stone block are gone. In their place is an old wooden pergola: * Posts: four, 0.5 ft square. * Beams: two long ones along X, 0.55 ft wide × 0.75 ft deep, 10.4 ft long, one at the front (z = siteZ) and one 5.5 ft behind it. * Rafters: five across the beams, overhanging by 1.1 ft. Two are missing, and the gap is over the queen. * Slats: four thin ones across the rafters.

Its bad shape: * Sag. Both beams sag 0.18 ft at mid-span, a parabola that is lowest where the queen hangs. * The fallen rafter still hooks on the back beam and its other end lies in the grass behind. * A loose brace has come away and lies against the front-left post. * Splintered ends on the back beam, on the rafters and on one slat. * Offcuts lie in the grass. * A dead vine: a gnarled stem winds up the front-left post and along the top of the front beam, and dry tendrils hang from the rafters. * A few bare rocks lie about the summit. 2. Weathered timber (woodBox()). Each piece is a finely subdivided box pushed into the wood by grain-aligned noise, stretched along the length: * raised grain; * long checks (splits); * rounded, crumbled arrises; * rot at the post feet and the beam ends; * optional splintered ends, where each "fibre" stops at a different length.

Surface and material: * Vertex colours: silver-grey wood, dark in the cracks and the rot, damp-dark toward the ground, lichen on the upper faces. * Texture: a generated canvas with grain lines, knots and checks. * Material: roughness 1 and almost no reflection (envMapIntensity 0.08): a dull, dry surface. * Where the bees hang: weathering of the front beam's underside is capped at 0.02 ft into the wood, and it follows the sim's sag. * Wire look: the arbor uses a faint, translucent wireframe. 3. The sim and the picture use the same boxes. Swarm.arborBoxes() lists every solid part (posts, beams, rafters, slats) as an axis-aligned box. The renderer builds the timber from exactly these boxes, and the sim keeps flying bees out of all of them (_stone(), which now pushes out through the nearest box face). * Cosmetic only: the fallen rafter, the brace, the vine and the rocks are not solid. 4. Attachment. * _soffitY(x) is now the underside of the sagging front beam: attachY + beamSag·min(1, (dx/arborHalf)²), with attachY 9.0 ft. * _underArch keeps footholds 0.05 ft inside the beam's edges and 0.55 ft clear of the posts. * Steering: a bee arriving above the beam flies out past its front or back face and comes in from below, as it did for the arch. 5. The high place. The summit is now a polar mesh, fine near the arbor and coarse far away. 16–23 ft beyond the arbor, on the sea side, it breaks off at a ragged brink and drops in cliffs toward the Adriatic ~1,400 ft below. Steep ground is coloured as bare rock. * From the default view (the camera on the landward side): the arbor is seen against the sea and the brightening east, so the swarm is diffusely lit by the sky and backlit by the dawn. 6. Text. * Card: the queen alights "upon the grey and broken timbers of a forsaken bower high above the sea". * HUD: it now speaks of the arbor and the beam.

A determinism fix (_sim.js, Swarm.RING)

The foothold search pattern introduced in B1 was built with Math.cos / Math.sin. Those are not bit-identical between JavaScript engines, and in B1–B3 the browser's runs differed from Node's (each was self-consistent, so rewinds still matched). The pattern is now built from exact 30°/60° values and sqrt(3), plus two literal constants. Browser and Node now give the same hash.

C1 results (seed 3906, 7,500 bees, 20 °C; Node = Chromium)

• Load: at 250 s, 1,061 bees grip the timber, carrying 6.4 bee-weights each on average. That is within the measured grip of 35 ± 14 bee-weights (Shishkov et al. 2022), and 126 bees exceed their own grip.
• The beam is narrower than the arch's soffit (0.45 ft of usable width against 1.44 ft), so fewer bees reach the wood and each carries more than in B3, where ~2,030 carried ~2.8.
• Shape: the cluster is a compact beard about 5 in deep and 8 in along the beam.
• No flying bee is ever inside the timber.
• Determinism:
• rewinding from 150 s to 120 s and a fresh run to 120 s give the same hash, e08b22d8;
• Chromium at 200 s gives 648fafb6, the same as Node;
• the server test (1,000 bees: forward, rewind, pause) gives a3ff60d6 at step 1180, the same as a fresh Node run.

C1 verified (headless Chromium, SwiftShader, from file://)

• AUTO at 200 s: the cluster hangs under the sagging front beam, framed by the posts, rafters, vine tendrils and the fallen rafter. The close-up is from below, looking up past the beam at the rafters and the sky.
• Wide view from the camera (t = 10 s): the arbor in silhouette on the summit, the brink, the sea below with the moon's glitter path, the moon and Venus.
• High oblique view: the whole arbor on the edge of the cliff above the rippled sea.
• Close view at 200 s: weathered grey timber, checks, rotten and splintered ends, the islands, the moon.
• W (wire look), the title and card, recording, rewind and the movie (ffmpeg MP4): all work.
• No console errors.

Known limits (C1)

• Dawn is artistic licence, as before.
• Non-solid parts: the cosmetic pieces (the fallen rafter, the brace, the vine, the rocks) are not solid, so a bee can pass through them. They are thin and mostly out of the flight path.
• Posts and beams are perfectly upright and level apart from the sag; the decay is in their surfaces and ends.
• Islands: still simple dark domes.
• The headless renders wash the main view's sky out (SwiftShader, q=low). A real GPU shows the full dawn gradient.

CT39.B3.Swarm context (still valid except where C1 changed it above)

The user's B3 request

Off in the distance is the adriatic · Remove all outlines from the stone · Remove most of the stones, except for the arch and some of the crepidoma · All stones should be severely degraded, both in terms of geometry and surface reflectivity · Remove all but one or two stars

"Outlines" is taken to mean B2's glowing symbol tracery on the stones. The bee outline switch (U, off by default) is unchanged.

What B3 changed (_main.js)

1. The Adriatic. - Terrain: on the side facing the sunrise, the summit falls away in a steep slope beyond ~55 ft, so the sea is in plain view. - The sea: ~1,400 ft below (B2: 2,600 and mostly hidden), out to the horizon. It is a dark, rippled mirror (a generated normal map of small waves, metalness 0.85, roughness 0.16) reflecting the dawn sky, with a column of reflected glow running toward the viewer. - Islands: three low islands far to the north-east, as the Tremiti islands lie off Monte Gargano. - The near ridges stay open to the east.
2. No symbols. All of B2's ~600 glowing decals and the symbol masks are gone. CT39.C6.Swarm_symbols.js is no longer shipped; the artwork stays in CT39.artwork.
3. Almost all the stones are gone. - Removed: the altar, the wall fragment, the fallen attic blocks and the scattered stones. There were already no columns. - Left:
   • the arch: two piers sunk 0.4 ft into the ground, and the ring;
   • some of the crepidoma: broken runs of the three steps along the front and left side of the old platform, gaps where blocks are missing, the rest sunk, tilted and shifted; plus a short half-buried run where the far right corner was;
   • one tumbled block at the foot of each pier.
4. Severely degraded stone (erodedBox()). Every stone is a finely subdivided box whose vertices are pushed into the stone by: - fine pitting; - rounded and chipped edges; - missing chunks (large-scale noise).

The push direction depends only on position, so faces stay joined. For the ring, the eroded box is bent into the half-annulus. - Surface: vertex colours put dirt in the hollows, darken toward the ground, add lichen patches and streaks. The material is fully rough and matte (roughness 1, no reflections, strong bump): no sheen at all. - Where the bees hang: soffit erosion is capped at 0.025 ft, always upward into the stone, so the sim's circle stays where the bees grip. The sim now keeps footholds 0.18 ft from the soffit's chipped edges and 0.35 ft from the springing (B2: 0.03 / 0.25). - Joints: the ring's feet run 0.35 ft down into the piers, so there is no gap at the springing. - Wire look: the ruins use a wireframe material, as the terrain does (no edge-line twins). 5. Sky. Only Venus (low over the sea, brilliant) and Jupiter (high south-east) remain, with the crescent moon. Orion, the Pleiades, Sirius, Mars and the background star field are removed.

Sim: only the foothold margins changed. With seed 3906 and 7,500 bees the results are identical to B2 (hash at 250 s 0d03ec0f; ~2,030 bees grip the stone, ~2.8 bee-weights each; the cluster is 4.2 × 11.5 in), because the cluster never reaches the edges.

B3 verified (headless Chromium, SwiftShader, from file://)

• AUTO at t = 5 s: twilight, Venus, the swarm cloud, the arch silhouette, the sea with its glow path.
• t = 200 s: the cluster under the eroded soffit; the close-up from below.
• ORBIT 30 ft: the arch, the broken crepidoma runs, the slope down to the sea, the glint, a headland.
• Close view through the arch: pitted, chipped piers and ring, Venus, the moon, the islands, the sea.
• No console errors.

Known limits (B3)

• As before: dawn is artistic licence, and bees only collide with the arch.
• Islands: they are simple low domes, dark in silhouette.
• Erosion cost: the eroded stones are dense meshes (~6,000 vertices for the ring). That is cheap next to the bees, but the shadow map draws them too.

CT39.B2.Swarm context (still valid except where B3 changed it above)

Browser simulation (WebGL + three.js r186, vendored; works from disk) of a honeybee reproductive swarm. The bees mill around, then hang from the stone underside of an arch at a ruined mountain-top sanctuary above the Adriatic, just before dawn.

• Harness: Claude harness v2. Built 2026-10-06.
• Lineage: B2 = B1 plus the user's B2 list. The B1 context follows below and still holds except where noted here.
• Science: CT39.C6.Swarm_SCIENCE.md (+ .html). New for B2: §4e The sky before dawn, and B2 results in §4d.

The user's B2 request

Stars: Rigel, Betergeuse, Pleiades · Planets visible: venus, jupiter, mars · Crescent moon visible · No columns or partial columns · The arch can be much thinner, with no visible gaps between stones · Much more outlines visible on all flat stones, the outlines can be self illuminating · The close in viewport should have the camera lower, looking up · Start with more bees, 7500 · Start with outline off · The text viewport should take up less space, fewer lines by half

(The B1 request text was repeated above it unchanged.)

What B2 changed

1. The sky (skyDir(), SKY_OBJ, updateSkyObjects() in _main.js). - Positions: real altitude and azimuth at 41.7° N (Monte Gargano), sidereal time 7.0 h (sun ~9° below the horizon), rotated so the sun's azimuth lies on the scene's eastern glow. - Objects: Betelgeuse (orange) and Rigel (blue-white) with the rest of Orion (Bellatrix, the belt, Saiph); the Pleiades (7 stars at catalogue positions); Sirius; Venus (low east, brilliant), Jupiter (high south-east) and Mars (reddish). - Crescent moon: recomputed from the same table, ~24° up near Venus. - Drawing: additive glow sprites, fixed size on screen. - Dawn fade: each object fades on its own schedule, Venus last. - Background: the procedural stars are fewer and fainter, so the named ones stand out; the moon's halo is smaller. - Accuracy: the planets' positions are plausible, not an ephemeris for a particular date (SCIENCE §4e).
2. No columns. Every column, column stump, capital, architrave piece and fallen column drum is gone. What remains: the three-step platform, the fragment of cella wall, the altar, the arch, the fallen attic blocks and the scattered stones.
3. The arch is slender and seamless. - Ring: one smooth stone with no joints; its inner edge is a true arc of 64 points. It is 0.75 ft thick (B1: 1.7) and 1.8 ft deep (B1: 2.2). - Keystone: slightly proud, its underside clamped to the soffit circle. - Piers: single dressed stones 1.3 ft wide (B1: 2.2) on plinths, with slim imposts. - The sim uses the same numbers: archDepth 1.8, archRing 0.75, pierW 1.3.
4. Glowing symbols on every flat face. - Where: carve() tiles gold tracery over the faces of every worked block: arch piers and plinths, altar, platform steps (tops and risers), wall blocks, fallen and scattered stones. Each face gets up to 6 × 4 symbols, up to 3 ft each, picked at random from the four, top faces in random quarter turns. - The arch: 10 symbols follow the curve of each face of the ring, plus one on the keystone and a 7-ft plate in the temple floor. - Count: ~600 decals in total, merged into 4 meshes, one per symbol: 4 draw calls. - Material: metal gold, plus self-illuminated gold emission (1.7 in the dark, falling to 0.9 as dawn comes). - Blending: alpha-blended rather than alpha-tested, and the masks are thickened (3×3 max filter), so the fine lines fade softly with distance instead of vanishing. - Wire look: the symbols are drawn in both looks.
5. Close-up from below: the small window's camera is now 31° below the cluster, looking up (B1: 7° above), kept at least 0.6 ft above the ground.
6. 7,500 bees by default; the Bees selector now offers 500 / 1,000 / 2,000 / 4,000 / 7,500 / 10,000 / 12,000 / 20,000.
7. Outline off by default (?outline=1 or U turns it on). Shaded, shadows, reflections and crystal wings stay on.
8. Half-height status panel: six short lines, against B1's 12–13. - Line 1: run (seed, bees, time, direction and speed), dawn %, fps and ms. - Line 2: phase. - Line 3: cluster size and its grip on the stone. - Line 4: camera and lens. - Line 5: what is drawn, and the hash. - Line 6: recording. - The odometers are unchanged.

B2 results (seed 3906, 7,500 bees; Node)

• Hash at 250 s: 0d03ec0f, the same after a re-seek.
• Same seed, different swarm from B1, because the arch is now narrower.

B2 verified (headless Chromium, SwiftShader, from file://)

• AUTO at t = 3–5 s: twilight, Venus and the crescent with its halo, the swarm cloud, the slender arch covered in glowing gold symbols.
• t = 200 s: the cluster under the arch; the close-up from below shows the cluster against the soffit.
• ORBIT 24 ft at t = 60 and 200 s: symbols on every stone face.
• A look toward the south-west: Orion (Betelgeuse orange, Rigel blue-white, the belt), Sirius and the Pleiades, all correctly oriented.
• No console errors. One bug was fixed during testing: a stray comment had disabled the star sprites' settings.
• Not re-tested: recording and rewind, whose code is unchanged from B1 (verified there).

Known limits (B2)

• Same as B1: dawn is artistic licence, and bees only collide with the arch.
• Planet positions are plausible, not for a particular date.
• Inlay cost. ~600 alpha-blended decals cost fill rate when the camera is close to big faces. If frames are slow, try P (no close-up) or V (no crystal wings).

CT39.B1.Swarm context (still valid except where B2 changed it above)

B series, first version. Browser simulation (WebGL + three.js r186, vendored locally; works from disk) of a honeybee reproductive swarm: the bees dash around madly, then gather and hang as a living cluster under the stone arch of a ruined mountain-top sanctuary above the Adriatic, just before dawn.

Harness: Claude harness v2 (2026-09-27). Built 2026-10-06. Built on CT39.A12.Swarm, the highest A version, which lives at C:\Users\micha\Downloads\claude\CT39.A12.Swarm\. * Kept from the A series: - the deterministic simulation (scent field, each bee's own decisions, landing on contact, hanging chains with grip loads, strands); - the sound; - the two views (wide shot plus a small close-up), the camera that always aims at the queen, with drag to orbit and the wheel for distance; - the metal-plate UI with gold status type, rewind and recording. * Replaced: the world, the look of the bees, and the opening. * Science: CT39.C6.Swarm_SCIENCE.md (+ .html). New for B1: §4d (the stone arch, the climbing rule, a dawn note, sacred bees) and §5b (the metal bees).

The user's B1 request (abridged)

CT39.B1.Swarm. … the 3D environment and visual design has changed. The locale is … an ancient setting, possibly the adriatic, at an abandoned sacred site, at altitude. It is just before dawn, the sky is lightening, and the moon is still visible. There are the remains of an ancient stone altar and some ruins of a temple … there is an arch that would provide a base for the queen to attach to and for the swarm to form around. The illumination is all natural … the swarm is diffusely lit from the sky and is occasionally backlit. The ruins, the altar and the foundation have embedded in them designs and hieroglyphs barely visible that contains esoteric symbology … a cult of mechanical and divine swarms. Artwork … "swarm outline 2-5" … This symbology and the bees themselves are made of metal. The honeybees … metallic, with alternating narrow stripes of black and broader stripes of gold. The wings are … very thin and semi-transparent crystal. The five eyes of the bee are red. The outline of the bee is also rendered … The user interface should make it possible to turn on shading vs wireframe, turn on or off shadows, and other shading elements, such as the reflectivity (reflection mapping) of the metal. By default, shading, shadows, reflectance mapping and bee outlines should be enabled. … The web program begins with the title card artwork, which holds for 15 seconds, and then fades to the text that describes in arcane language the nature of the reproductive swarm, the deposed queen, and the loyal drones. … Bees land wherever they touch the growing cluster and either start a new chain or add themselves to an existing chain. There are two viewports … The camera is always pointed at the queen … mouse to orbit … scrollwheel … The second viewport is much smaller and is a closeup … The status … in gold type … audio … The opening splash / title card should be "swarm 9.webp" …

The request gives the title 15 s in one place and "about 10 seconds" in another; 15 s is used.

What B1 does

Opening

1. Title card. CT39.C6.Swarm_title.webp (copy of CT39.artwork\swarm 9.webp, 816×1456) fades in and holds 15 s.
2. Story card. It fades to the CT46-Zoltar-style card (velvet, gold frame, Metamorphous lettering): - heading ✦ LIBER EXAMINIS · FOLIUM PRIMUM ✦, title Of the Queen Deposed and the Faithful Swarm; - new arcane text: the hive dividing like a seed, the new sovereign, the mother-queen deposed and exiled, the daughters and the drones following her, waiting for the seekers to find a hollow; - it holds 32 s.
3. Scene. The card fades, the dawn scene fades up, the bees' sound rises, and the simulation starts.
4. Controls during the opening: the first click wakes the sound; later clicks, or Space / Enter / Esc, skip ahead. URL: ?intro=0, ?title=, ?card=.

The world (_main.js, "B1: an abandoned sacred site")

Everything is generated in code except the inlaid symbols. * Sky. A shader dome: deep-blue twilight, a warm glow along the eastern horizon (over the sea, a little left of behind the arch from the default view), a rose band above it, and stars that fade as it brightens. - Dawn follows simulation time: from 0 (sun 12° below the horizon) to 1 (1° below) over 300 sim-seconds (?dawn=). Movies are therefore identical on any PC, and rewinding darkens the sky again. - Moon: a waning crescent ~12° up just south of the glow, its lit limb toward the hidden sun, with a faint earthshine disc and a halo. * Light (all natural): - sky light (hemisphere, bluish, growing with dawn); - the glow of the east: a warm directional light from 5–8° above the eastern horizon. It casts soft shadows (4096² map, PCF radius 4) and is the light that backlights the swarm from the default view; - faint moonlight. - ACES tone mapping, exposure 1.45, and exponential fog whose colour follows the dawn. * Reflections. The sky alone, plus a dark ground, is pre-filtered into a PMREM environment map. It is rebuilt each time dawn advances 3 %, and every metal reflects it (bees, inlays, crystal wings, sea). * Land. - A summit plateau of thin turf and rock, flat at the shrine, falling away beyond ~180 ft. - Two rings of ridges: the near one below eye level, far inland mountains to the west, north and south a few degrees above it. Both open to the east. - The sea far below to the east, catching the glow. * Ruins (rough limestone, procedural texture with bump, soft lichen, cracks): - The arch: two ashlar piers with plinths and impost mouldings, and a ring of 15 voussoirs with a proud keystone. Its two attic blocks have fallen to its feet. - The arch's stone is exactly the sim's: soffit radius archR 4 ft about (siteX, attachY − archR), crown 11 ft up, depth 2.2 ft, ring 1.7 ft, piers 2.2 ft wide. The voussoirs' undersides are true arcs. - The altar: a moulded block (base, die, cornice, cracked top slab) 11 ft in front of the arch, with a few fallen offerings. - The temple behind the arch: - a three-step stylobate with fluted column stumps; - four standing columns with capitals, an architrave on two of them and a beam askew on a third; - fallen drums, a fragment of the cella wall, and scattered ashlar. * Inlaid symbols (CT39.B2.Swarm_symbols.js, data URIs): - Masks are made from "swarm outline 2–5.webp": the engraved gold lines of each plate are extracted (high-pass on brightness and warmth), de-speckled, and stored as 512² greyscale. - They are drawn as thin gold metal tracery set into the stone: alpha-tested decals, metalness 1, roughness 0.42, extra reflection. - Placed on both faces of both piers, the keystone, the altar's front, sides and top, six small plates along the stylobate riser, and a large plate in the temple floor. - Barely visible by design: dark in shadow, catching glints of the sky when Reflections are on. - (CT39.artwork also holds "swarm outline 1" and "swarm 1–10"; only 2–5 and 9 are used, as asked.)

Sim changes (_sim.js; STRIDE 23 unchanged)

• Attachment = the arch's soffit:
• _soffitY(x) (semicircle) and _underArch(x, z) (inside the soffit's footprint, 0.03 ft margin from the faces, 0.25 ft from the springing);
• _branchGap is the distance below the soffit;
• a grip on the stone hangs at most half a body below it; the stone is solid (a bee stays a body radius below it).
• Flying bees can't enter the stone: _stone() tests the ring and the piers and pushes a bee out through the nearest face, reflecting its heading. A scent-following bee (or the settling queen) above the arch flies out past a face and comes in from below.
• Footholds (SCIENCE §4d): a strained bee steps up onto free stone from within climbReach = 1.6 body lengths (A7–A10: 1.0), trying the spot above it and then two rings of nearby spots (Swarm.RING). Without this only ~1 % of bees gripped the flat stone.
• Parameters: attachY 11, branchRadius 0, archR 4, archDepth 2.2, archRing 1.7, pierW 2.2, climbReach 1.6 (?climb=). A10's wire parameters are removed.
• Results (seed 3906, 4,000 bees): 97 % settled at 200 s, 99.9 % at 250 s; ~1,160 bees grip the stone, each carrying ~3 bee-weights (Shishkov et al. measured 3.8 under a flat board); the cluster is ~5 in deep × 9 in wide. With 12,000 bees: all settled by 90 s, a mat 14 × 3.5 in.
• Determinism: fresh run and re-seek give the same hash, e.g. 1,000 bees, step 1116 → 1dd99bd5, also after rewind and pause in the browser. 4,000 bees at 250 s → 908190b3.

The bees (_main.js, "B1: metal honeybees")

• Body (abdomen, thorax and head, ~250 triangles): narrow black and broad gold stripes computed per pixel in the bee's own frame (bands 0.095 body lengths, ~1/3 black); bronze thorax, black head. Gold is metal (roughness 0.3); black is dark lacquered metal.
• Five red eyes: two compound eyes and three ocelli, emissive red.
• Crystal wings: MeshPhysicalMaterial, 26 % opacity, roughness 0.04, iridescence 0.9 (thin film), plus a fine edge and vein. They are posed in the vertex shader as before (spread and shimmering in flight, folded when hanging, beating on fanners), now with a correct normal for lighting.
• Outline: the A12 inverted hull, black, 0.035 body lengths (?outlinew=).
• Strands (N): brightness contrast between strands and the chains view, as in A10–A12.
• Wire look: stripes in gold and dark brown on the wire bodies; plain faint wings.

UI

• Defaults: shaded, shadows, reflections, outline and crystal all on.
• Buttons and keys:
• Look (W): shaded / wire. In wire, each ruin has an edge-line twin, the inlays become gold outlines, and the terrain, ridges and sea become wire.
• Shadows (Q).
• Reflections (X): reflection mapping on / off for every metal.
• Outline (U).
• Crystal (V): crystal wings / plain.
• Shadows, Reflections, Outline and Crystal are dimmed in the wire look.
• Junk (J) is removed.
• Status line: what is drawn, the dawn %, fps and ms per frame.
• Bee count: the Bees selector reloads with the same switches. Default 4,000.
• URL options: look=wire, shadows=0, reflect=0, outline=0, crystal=0, dawn=<s>, climb=, shadow=<map size>, q=low, pip=0, bees=, seed=, intro=0, title=, card=, cam=orbit&dist=.

B1 verified (headless Chromium, SwiftShader)

• From file://:
• title and card; t = 1 s (deep twilight: silhouettes, stars, the arch);
• t = 150 s backlit view of the cluster under the arch;
• ORBIT 0.9 ft: gold/black striped bees, red eyes, crystal wings and outlines, and the carpet of bees gripping the stone with chains below;
• ORBIT 22 ft and 60 ft at t = 250 s: the ruins, the moon, the sea glint, long soft shadows;
• close view of the altar: faint gold tracery in the stone;
• no console errors after fixing one shader (the wing pose was in a block not compiled for basic materials).
• Through the server (1,000 bees, q=low): forward ×16, backward, then pause gives hash 1dd99bd5, the same as a fresh Node run; Finish & Make Movie wrote the MP4 and deleted all 28 frames.
• Not measured: the frame rate, which needs a real GPU.

Known limits (B1)

• Dawn is artistic licence. Real swarms fly mid-day; at this hour a mountain top is too cold to fly (SCIENCE §4d).
• Bees only collide with the arch. They fly through columns, the altar and fallen stones; the cluster hangs only from the arch.
• 12,000 bees make a flat mat. It may be too flat for a big swarm under a flat stone; tune with ?climb=.
• Faint inlays. At a distance the tracery is sub-pixel and only glints occasionally (intended: "barely visible").
• The far sea is a flat plane; there are no waves.
• Cost. Crystal wings with iridescence and transparency cost more than A12's wings. Turn off Crystal (V) or the close-up (P) if frames are slow.

A12 context (still valid except where B1 changed it above)

What A12 changed (user's request)

There should be a button to toggle between wireframe & shaded. There should be a button to turn shadows on or off. I would like to start with fewer bees and see if it affects performance substantially. There should be lest debris, sofas, whatever in the empty lot. If shaders are working it would be nice to render the bees with an outline shader.

"lest debris, sofas, whatever" could be read as less or as lots. Because it names sofas, which the lot didn't have, I read it as more, and made the amount switchable so both readings are covered.

1. Look: wire / shaded (W / Look button; ?look=shaded). Wireframe (A11) is the default. - Every prop has both forms. Each solid keeps its shaded mesh and gets an edge-line twin; applyLook() shows one set. The shaded look brings back A10's textured ground and oil stains, the sun, sky light, streetlight spot, metal reflections and filmic tone mapping. The wire look shows A11's dark ground and grid. - Bees:
   • wire: striped wire bodies, unlit;
   • shaded: the same black/red stripes as a lit, slightly metallic enamel (metalness 0.35, roughness 0.45), with the faint wing membrane (?wingfill=0/1 forces it off or on).
2. Shadows (Q / Shadows; ?shadows=0). The sun's 4096² shadow map, redrawn for each view. They only appear in the shaded look, so the button is dimmed in wire. Off means no shadow passes at all.
3. Bee count. - 4,000 by default (A5–A11: 12,000). - The Bees selector in the header offers 500 / 1,000 / 2,000 / 4,000 / 8,000 / 12,000 / 20,000. Changing it reloads the page with ?bees=N, skips the opening, and keeps the look, shadows, outline and junk settings. - FPS odometer (new, first in the row) and a HUD line: the look in use, 1 or 2 views, the junk setting, frames drawn per second (the loop is capped at 30, the film rate, so 30 = full speed), and the average milliseconds to prepare and submit a frame.
4. Junk (J / Junk button; ?junk=lots|some|none; default lots). - some = A10's set: the car hulk, tyres, oil drums, pallets, refrigerator, cinder blocks and scrap heap. - lots adds:
   • two sofas (one dumped upright, one tipped onto its back), an armchair and loose cushions;
   • two mattresses, one leaning on the back fence;
   • a shopping cart on its side;
   • a washing machine, an old CRT television and a claw-foot bathtub;
   • a stack of crates, plywood sheets leaning on the fence, traffic cones (one tipped) and more tyres.
   • none hides it all.
5. Outline shader (U / Outline; ?outline=0; ?outlinew= sets the width, default 0.035 body lengths). It is an "inverted hull": the bee body drawn a second time in black, back faces only, pushed out along its normals in the vertex shader. That gives a black rim around each bee's silhouette. It shares the bees' instance matrices, so it costs one extra pass of the bee bodies. It is drawn in the shaded look only.
6. Keys: W look · Q shadows · U outline · J junk (in addition to A11's keys).

A12 verified (headless Chromium, SwiftShader, from file://, 4,000 bees)

• Wire look at t = 60 s with lots of junk.
• W → shaded with shadows and outlines.
• Shaded ORBIT 0.8 ft: striped bees with black outline rims, wing membranes, the hanging cluster under the shiny conductor, and the junk.
• No console errors.
• The FPS readout was not meaningful under SwiftShader. Measure on your own PC: try wire vs shaded, shadows on and off, and 4,000 vs 12,000 bees.

What to expect for speed (rough guide, not measured)

• Bee count: bee work scales with the number of bees, in both the simulation (CPU) and drawing (GPU). 4,000 bees should cost roughly a third of 12,000.
• Shaded look: each extra pass of all bees costs about the same:
• shaded + shadows + outlines + close-up = 2 views × (body + outline + shadow pass);
• wire with the close-up = 2 passes;
• P (close-up off) halves either.

Known limits (A12)

• The HUD plate is large. H hides it.
• Some junk is close to the camera. Some 'lots' junk sits in the foreground of the wide shot (the dumped sofa); J removes it.
• Abdomen stripes are soft. The stripe colours are per vertex, so on the low-poly abdomen they blend into soft bands.

A11 context (still valid except where A12 changed it above)

What A11 changed (user's request)

The legend / fortune card before the simulation starts should hold longer. The type that describes the status should be larger and the color should be metallic gold. The camera of the window that is close up on the swarm should be further away from the queen. The color scheme of the bees should be striped black and red. The renderer should be wireframe as we need a better frame rate.

1. Story card holds 32 s (A10: 18 s). ?card=<s> still overrides it, and Space / Enter / Esc or a second click still pass on.
2. Status type (HUD). Raised from 11 px/16 px to 15 px/22 px, in metallic gold: a polished-brass gradient that repeats on every 22-px line, with a dark drop shadow and a faint warm glow. The long "hanging chains" line now wraps onto two lines. The odometer drums are unchanged.
3. Close-up window camera is further back. - It stands 5× the cluster's size away (A10: 2.2×), clamped to 1.8–18 ft (A10: 0.6–8). - Before a cluster exists it frames the queen as if the cluster were 0.6 ft (A10: 0.3), i.e. 3 ft away. - At t = 100 s it stands ≈ 2.8 ft from the cluster. The A10 lens (32°) and orbit (one turn every ~57 s) are unchanged.
4. Bees striped black and red (vertex colours): - the abdomen is banded along its length, alternating black / red every 0.09 of the body length, with a black tip; - the thorax and head are black; - the eyes are still small, self-lit and pale; - the wings are outlines only by default; ?wingfill=1 brings back the faint membrane. - The strand-contrast view (N) scales how bright each strand's red is; the chains view lights the longest chains in bright red. - Real honeybees are amber and black, not red (SCIENCE §5a).
5. Wireframe renderer. - Removed: the shadow map (it was rendered twice per frame, once per view), the sun, sky light, spotlight and metal reflections, and tone mapping. - Materials: all unlit, no lighting. - Props: every solid in the lot is replaced by its edges (creases over 25°), in a grey matching its old shade. The chain-link fence becomes a diamond lattice of lines. The poles, line, streetlight, junk and hive are all wire. - Ground: a flat dark-grey plane under a wire grid (5-ft squares near the site, 25-ft to the horizon). - Background: the grey sky dome is kept, so the black stripes show. - Lamp: the streetlight's lit glass and halo are kept. - Bees: low-poly wire bodies, about 100 triangles against ~280 in A10. - Draw passes: each frame draws 12,000 bees 2 times (wide view + close-up) instead of 4. - Removed URL options: shadow= and lampshadow=.

A11 verified (headless Chromium, SwiftShader, from file://)

• AUTO at t = 60 and 100 s, with the close-up 2.8 ft back.
• ORBIT 1 ft at t = 60: striped wire bees with wing outlines, and the strand contrast in the hanging cluster.
• HUD hidden and shown; no console errors.
• The sim, recording and rewind code are unchanged from A10, so A10's server test still applies.
• Not measured: the frame rate. It needs a real GPU. Expect a clear gain over A10, mainly from dropping the two shadow passes and the lit materials.

Known limits (A11)

• Wire bees are still many lines. About 100 triangles drawn as edges, for 12,000 bees, in two views. If the frame rate is still low, try ?q=low (fewer segments), ?pip=0 (no close-up), or fewer bees (?bees=6000).
• Some wire lines draw twice. WebGL wireframe draws shared triangle edges twice; real line rendering speed depends on the GPU and driver.
• The HUD plate is taller with the bigger type. H hides it.

A10 context (still valid except where A11 changed it above)

What A10 changed (user's request)

When the program starts, the main title card is displayed for about 10 seconds, then it fades and is replaced by a card in the style of CT46 Zoltar that says in arcane language that refugees from a hive have been expelled from the home that they had built and, with their deposed and exiled leader, their queen have embarked on a journey to find a place for a new home. This card also fades and the audio sound of the bees becomes audible, and the 3D background becomes visible, an empty lot with one streetlight, such as you might find in a junk yard a power line, sagging, that runs across the lot. This power line is the anchor to which the bees will follow the scent and create a temporary home. At this point the simulation begins. Instead of using color to reveal the chains of living bees, perhaps we can use contrast or varying intensity to outline the chains. There are two windows, one containing a wide shot of all the bees, and one a much smaller window which is close up on the emerging swarm architecture. The bees are represented by a simple geometry of a main body, a head, two eyes and two wings. The wings are transparent or perhaps just an outline of the geometry. The rest of the bee body appears to be made out of iron. The bridge, metal arch, whatever can go away. The rendering should be shaded and cast shadows.

The A9 prompt's cut-off line turned out to be: "The bees themselves should be luminous, like a mystical life form that is self illuminated." A10's iron bodies take precedence; the luminous idea survives as self-lit eyes.

1. Opening (runIntro in _main.js, #title / #card in the page)

• Title card. CT39.B1.Swarm_hive_title.webp (unchanged) fades in, drifts very slightly larger for 10 s, then fades out. It no longer docks in the corner.
• Story card. A card in the style of CT46.A7 Zoltar's fortune window fades in:
• dark burgundy velvet, double gold frame, diamond corner studs;
• Metamorphous lettering (bundled from CT46: CT39.C6.Swarm_fonts/Metamorphous-Regular.ttf, SIL OFL);
• a "✦ LIBER APIUM · FOLIUM PRIMUM ✦" heading, the title Of the Exiles of the Waxen City, a gold rule, and justified arcane text with a gold drop capital.
• The text tells of the exiles and their deposed, banished queen. It is shown for 18 s, then fades.
• Scene. The lot fades up out of black (3 s), the simulation starts, and the bees' sound rises (0.8 s time constant).
• Controls during the opening:
• Browsers hold audio until a click or key, so the card's foot says "Touch the glass to waken the hum · Space to pass on". The first click only wakes the sound; later clicks, or Space / Enter / Esc, skip to the next stage.
• Other keys are ignored during the opening.
• URL: ?intro=0 skips it; ?title=<s> and ?card=<s> set the times.

2. The lot

Everything is generated in code; there are no model or texture files. It is a junk-yard lot, monochrome. * Ground. Packed dirt and gravel (a canvas noise texture) with oil stains. * Fence. Chain-link at the back and sides, alpha-tested so it casts a lattice shadow. * Junk. A stripped car hulk on its sills, a tyre stack and loose tyres, oil drums (one on its side), a stack of pallets, a dumped refrigerator, cinder blocks and a scrap heap. * The hive they left, ~100 ft off. * The streetlight. Tapered steel pole, curved arm, cobra-head lamp with a lit glass and halo, and a spotlight on the ground below. It casts no shadow by default; ?lampshadow=1 turns it on. * The power line. Wooden poles with crossarms, braces, porcelain pin insulators, and a transformer can on the right-hand pole. Two conductors run 84 ft between poles, with an extra span each side, and sag 12 ft: 24 ft up at the insulators, 12 ft at mid-span over the lot. The swarm hangs from the front conductor (0.72 in across) at the bottom of the sag. * Light. - Low late-afternoon sun: a directional light that casts the shadows (4096² map over ±55 ft; ?shadow= sets the size). - Sky fill from a hemisphere light; a grey sky dome brighter toward the sun. - ACES tone mapping and fog. - Metals (bees, conductors, steel) reflect a generated, pre-filtered grey environment; dirt, wood and stone don't. * Removed: the arch, the A4–A9 wireframe grid and the black void.

3. Sim changes (_sim.js; STRIDE 23 unchanged)

• Attachment. DEFAULTS: attachY 12.0, branchRadius 0.03, poleX 42, poleWireY 24, wireA 73.5.
• _axisY(x) = attachY + r + dx²/(2·wireA), a parabola standing in for the catenary.
• Flying bees collide with the conductor along its whole span.
• Removed: A9's arch parameters, the deck/abutment collisions and the over-deck steering.
• Same seed, different swarm from A9.

4. Iron bees (beeBody, beeEyes, beeWingRim, beeWingFill in _main.js)

• Meshes. Four instanced meshes share one instance matrix per bee:
• body: abdomen, thorax and head merged; shaded iron, metalness 0.65, roughness 0.5; casts and receives shadows;
• eyes: self-lit, unshaded;
• wing outline: opaque, with a central vein;
• wing membrane: 16 % opacity, no depth write.
• Proportions: SCIENCE §5a. Width is scaled by caste (queen slim, drones broad).
• Wings are posed in the vertex shader from two per-bee values:
• aFold: 0 = spread … 1 = folded over the abdomen;
• aFlap: stroke angle.
• Flying bees: spread, with a stroke of ±0.75 rad at a new phase every frame (a shimmer, like 230 Hz wings filmed at 30 fps).
• Hanging bees: folded.
• Fanners: half-spread and beating.
• Orientation:
• Flying bees point along their heading, back up. While rewinding, the heading comes from the previous cached position.
• Hanging bees point their head at the hold they follow up their strand, back turned out from the cluster's axis.
• Visible size. In the wide view, bees are scaled up until a worker is ≥ 3 px long (MIN_BEE_PX); the HUD shows the factor. The close-up is at true size unless a bee would be under 2.5 px.
• Quality. ?q=low halves the sphere segments for slower GPUs.

5. Strands by contrast (N / Chains button)

?strands=contrast|chains|off sets the starting view. * contrast (default): each strand's iron gets one of 5 brightness levels (×0.12, 0.38, 0.75, 1.2, 1.8), chosen by a golden-ratio sequence of its top bee, so neighbouring curtains differ. Eye glow follows the level; the queen's strand is brightest. * chains: the 16 longest chains are bright iron with white lines along them; all other hanging bees go dark and shrink to 40 %. * off: plain iron. * G grips are drawn in grey at the strand's level. K load and C caste shading are still available.

6. Two windows

• Wide shot (main view). The A8 camera: AUTO aimed at the queen, or ORBIT. Auto-zoom now keeps it wide: the cluster fills at most ~7 % of the picture height.
• Close-up window. In the lower right of the same picture, 31 % of its width, 16:9, with a grey border. Because it is drawn into the frame, it is also in recorded movies.
• It looks at the forming cluster (before there is one, at the queen) from 2.2× the cluster's size (0.6–8 ft), with a 32° lens.
• It circles slowly (one turn every ~57 s while running) at 7° elevation, with springs on the aim and distance.
• P / Close-up toggles it; ?pip=0 starts with it off.
• Rendering. Each frame draws two views. The bee matrices are rewritten at each view's scale, and the shadow map is redrawn for each view, so the close-up's shadows are true size.

7. UI

• Buttons: Chains (N) and Close-up (P) replace Strands, Arch (T) and Bee size (L).
• Keys removed: I (no docked logo now).
• Unchanged: the HUD, the A9 metal plates and the odometers.

A10 results (seed 3906, 12,000 bees, 20 °C; Node)

• Settling is a little slower than A9, because the wire offers fewer footholds: 91 % settled at 90 s against 99.8 %.
• Top bees hold ~75 bee-weights on average, about twice their grip strength (SCIENCE §4c).
• Hashes: 150 s → 265a5747; 2,000 bees, step 924 → c8aaea1a.

A10 verified (headless Chromium, SwiftShader)

• From file://:
• the title (1.0) then the card (2.0) show and the scene follows;
• views checked: AUTO at t = 1, 60 and 100 s; ORBIT at 1.6 ft (t = 60: iron bees with wings, flyers and the hanging cluster); ORBIT at 75 ft (the whole lot: poles, line, fence, junk, streetlight, shadows);
• chains and contrast views;
• no console errors.
• Through the server (2,000 bees, q=low):
• forward ×16, backward, then pause gives hash c8aaea1a, the same as a fresh Node run;
• Finish & Make Movie wrote the MP4 (with the close-up window in the frame) and deleted all 31 frames.
• Not checked: the frame rate. SwiftShader is far slower than a real GPU.

Known limits (A10)

• Rendering load. Each frame draws 12,000 bees about 4 times: two views, each with a shadow pass (~280 triangles per body). On a weak GPU use ?q=low, ?shadow=2048, ?pip=0, or fewer bees (?bees=).
• Overloaded top bees. The thin wire leaves them holding ~2× their grip; the model spreads the attachment too little (SCIENCE §4c).
• Bees only collide with the front conductor. They fly through poles, fence and junk (all well away from the cluster).
• Wings are one surface per side. There are no separate fore and hind wings, and no legs or antennae.
• The streetlight casts no shadow by default.
• Movies are silent, as before.

A9 context (still valid except where A10 changed it above)

What A9 changed (user's request)

The swarm should hang from a cast iron arch, such as might have been used to build a bridge in England in the 19th century. The text should appear to be mechanical, and made of metal. It would be nice if the individual strands of bees could be more clearly visible, possibly through a color per strand? Th…

(The request ended mid-word at "Th"; whatever came next was not received.)

1. The cast-iron arch

bridge in _main.js, geometry parameters in the sim's DEFAULTS. * The bridge. A Telford-style road bridge modelled on the type of Cantlop Bridge, Shropshire, 1818 (SCIENCE §4b): - one 31-ft segmental span, rise 6 ft, intrados radius 23 ft; - 4 lattice ribs, 4 ft apart, each with bottom and top chords and an X-lattice web, cast in 5 segments with bolted flange joints (none at the crown); - 5 transverse members, X-braced between the ribs; - ring spandrels with vertical standards and a deck bearer; - cambered cast-iron deck plates; - railings with a top rail, dog-rail, dog-bars, posts and end balusters; - sandstone ashlar abutments with a string course, cast-iron skewbacks and road embankments. * Where the swarm hangs. Under the crown of the front rib, which faces the camera. The bees grip its half-round bottom bead (radius 0.09 ft). * Sim changes (STRIDE unchanged at 23): - _axisY(x): the bead's centre line, a circle of radius archR. - _branchGap, _branchFree, the grip pass, the solid-iron pass and the climb onto free iron all use the local height of the bead at each bee's x. A8 used a straight branch. - Flying bees collide with the deck slab and the two abutments: pushed out of the nearest face, heading reflected. The lattice ribs and spandrels are open; only the front bead is solid. - A scent-following bee above the deck flies out past the front edge and drops below it before going in. - New DEFAULTS: archR 23, archSpan 31, ribDepth 1, ribs 4, ribPitch 4, deckThick 0.35, deckOver 0.25, deckCamber 0.0044, abutOut 22, deckEdge 0.7. * Looks: T / Arch button cycles three modes: - wire (default): hidden-line wireframe, with a black fill so the ironwork hides what is behind it, grey edges and masonry joint lines; - iron: shaded grey cast iron and sandstone, lit by a hemisphere light, a sun and a fill light; - off: hidden. - URL: ?arch=wire|iron|off.

2. Colour per strand

• What a strand is. sim.strands(root, parent, depth) is derived, never written to the state. Each hanging bee is followed up its highest hold (fewest links to the iron) to the bee at the top of its strand that grips the iron; a strand is everything hanging from that one foothold.
• N / Strands button cycles three views:
• colour (default): one colour per strand. Hue and lightness come from golden-ratio sequences of the top bee's index, shaded by the A4 light. Flying bees stay grey; the queen's strand is white. G grips are drawn in their strand's colour.
• chains: the 16 longest strands are picked (deepest tip first, one per strand). The chain from each tip up to the iron is lit, with a line along it. Other hanging bees shrink to 28 % size and dim grey, so you can see into the cluster.
• off: the A8 grey look.
• URL: ?strands=colour|chains|off.
• Rewinding. The rewind cache now also stores root, parent and depth per kept step, so the colours are right while running backwards (≈ +36 MB at 12,000 bees).
• HUD: strand count, plus the length of the longest chain in chains view.

3. Mechanical, metal text (CT39.B1.Swarm.html)

• Plates. The header, HUD and footer are riveted cast-iron plates (brushed gradient, bevel, corner rivets).
• Keys. Buttons are stamped steel keys with engraved Cinzel caps. They press in when clicked; when on they stay down and turn brass (red for Recording and Finish).
• Lettering. The title is polished steel and brass. The HUD is in Share Tech Mono with a metal sheen repeating on every line.
• Odometers. Brass odometer drums for Time, Settled, Aloft and Strands: each digit wheel rolls to the new digit.
• Sliders. Brass knobs in steel slots.
• Title logo. The docked hive logo gets an iron frame.
• Fonts. Bundled in CT39.C6.Swarm_fonts/ (woff2), no internet: Cinzel 400/700/900 and Share Tech Mono, both under the SIL Open Font Licence (licences included). Taken from the @fontsource npm packages 5.3.0.
• Not in movies. All of this is HTML, so it is not in recorded movies, as before.
• The server knows the .woff2 MIME type.

A9 results (seed 3906, 12,000 bees, 20 °C; Node)

• Compared with A8 (branch): settled numbers are about the same; A8 at 150 s was 5.8 × 6.0 in. Same seed now gives a different swarm, because the attachment curves and the deck is solid.
• Over the deck: about 3,000 milling bees are above the deck while the cloud is airborne, and none by 90 s, so no bee gets stuck on top.
• Hashes: 150 s → be42b5b6; 3,000 bees, step 1440 → 3aa6d977. A fresh run and a re-seek give identical hashes.
• Performance: as A8 (≈ 96 s of Node time for 150 s of sim at 12,000 bees).

A9 verified (headless Chromium, SwiftShader)

• From file://: t = 1, 60 and 100 s in AUTO; ORBIT at 5 ft and 2.2 ft; strands colour and chains; arch wire and iron; HUD hidden. No console errors.
• Through the server (3,000 bees):
• the title shows, then docks;
• running forward ×16, then backward (rewind cache with strands), then pause gives hash 3aa6d977, the same as a fresh Node run;
• Finish & Make Movie wrote the MP4 and deleted all 44 frames.

Known limits (A9)

• Bees vs the bridge: they collide only with the deck, the abutments and the front bead. The ribs, bracing and railings are open ironwork they fly through, which is mostly realistic for lattice, not for the solid chords.
• Scent ignores the bridge.
• No sun-heated iron.
• Strands are always roughly vertical curtains, because holds are always above. Real festoons also run sideways.
• Strand colours can change when a top bee lets go of the iron, because its strand joins another.
• The UI is wide. At window widths under ~1500 px the header wraps to three rows, and the HUD plate is large (H hides it).

A8 context (still valid except where A9 changed it above)

What A8 changed (user's request)

When in auto mode, the camera should aim for the queen, and should not constantly jiggle around. When not in auto mode … the camera will orbit around the swarm/queen. The user should be able to adjust the distance from the queen/swarm. The program should begin by displaying the artwork hive_title.webp … then repositioning to the lower left, at which point the simulation begins. There should be audio that is the sound of the bees.

1. Camera: AUTO (default; A key / Camera button). Same POV as before (fixed at 6 ft up, (0, 6, 0)), but the aim is the queen (bee 0) instead of the median of sampled bees. Why it jiggled before: the aim was a median of ~700 moving bees and the zoom was the 90th percentile of their spread, both chased at α = 0.07 per frame. Now: aim = queen through a critically damped spring (ω 1.1 rad/s, ~1 s settle); zoom = spring (ω 0.7) with a 10 % dead band (it only re-targets when the framing it wants is clearly different). Springs run per film frame (1/30 s), so recorded movies are the same on any PC. Z (auto-zoom) still works in AUTO.
2. Camera: ORBIT. Circles the queen (aim still the smoothed queen). Drag on the picture = orbit (horizontal → bearing, vertical → elevation −14°…83°); mouse wheel, the Distance slider (1–250 ft, log scale) or [ ] = distance (eased with a spring); O / Orbit spin = slow automatic orbit (0.06 rad/s, ~1¾ min per turn, only while running). Dragging or touching the slider in AUTO switches to ORBIT starting from where the auto camera was. Lens fixed at 50° in ORBIT; near plane shrinks with distance (min 0.02 ft) so you can get within inches. Camera never goes below 0.4 ft. URL: ?cam=orbit&dist=20.
3. Ground grid now covers all sides of the site (±60 ft at 5 ft, ±400 ft at 25 ft), cut into one segment per square so no line crosses far behind the camera (the A4 clipping problem).
4. Title. CT39.B1.Swarm_hive_title.webp (copy of CT39.artwork\hive_title.webp, 816×1456 portrait) fades in filling the view on black, holds 3.2 s, then glides (1.6 s, CSS transition) to the lower-left corner at 24 % of the view height while the black backdrop fades; then the simulation starts (it is paused during the title). Click or any key skips ahead. I hides/shows the corner logo. ?intro=0 skips the title. The logo is HTML, like the HUD, so it is not in recorded movies.
5. Sound (Sound module in _main.js, Web Audio, synthesised — no sound files, no internet). Details and sources in SCIENCE §7b. Cloud chorus (10 buzz tones 196–256 Hz) + band-passed wing noise (260 Hz) + faint 5 kHz hiss, level (√flying + 0.35√settled)/distance; 16 voices on the nearest flying bees (pitch by caste/size, 1/d loudness, stereo by screen side, Doppler from velocity × sim speed × direction). Silent while paused; fades on Finish. Browsers block audio until a click/key: the first click or key anywhere starts it (the button says "Sound (click page)" until then). M / Sound button mutes; Vol slider. ?sound=0 starts muted.
6. Server: .webp MIME type added. HUD: a camera line (mode, distance, bearing, elevation).

A8 verified (headless Chromium, SwiftShader, from file://, 3,000 bees)

• Title shows, docks to the lower left, sim starts at t = 0 afterwards; no console errors.
• AUTO at t = 8–9 s: zoom held steady (dead band), aim on the queen; at t = 100 s the cluster is centred under the branch.
• Drag → ORBIT from the auto camera's position; ?cam=orbit&dist=3 close-up of the hanging cluster at t = 100 s.
• Sound starts after a click, button states correct, no errors. (Audio itself not listened to in testing — headless.)
• Sim unchanged from A7 → A7's determinism/recording verification still applies.

Known limits (A8)

• The queen is the aim even while she is milling (first 12 s) — the springs smooth her loops, but the view does move with her. Once she alights the view is still.
• In ORBIT the aim is the queen at the top of the cluster, so the beard hangs below the centre of the frame.
• Sound is synthetic; no piping/lift-off sounds; no recorded-movie audio (movies are silent).

A7 context (still valid except where A8 changed it above)

What A7 changed (user: "Can we implement this: settled bees are spheres that slide, rather than bees hanging from one another in chains. Then what happens after this?")

1. Grips in the state. STRIDE is now 23. - Slots 18–20: up to 3 grips (−1 none, −2 bark, else a bee index). - Slot 21: load held (bee-weights, refreshed every relaxation tick). - Slot 22: grip strength, drawn per bee from 35 ± 14 bee-weights (Shishkov et al. 2022), clamped to 8–80. - this.wgt[i] is the bee's weight in mean-worker units, by volume. - Grips live in the state, so checkpoints, seek and the hash cover them.
2. Holds. A bee may hold the lower half of the branch (barkBand 1 = up to the axis), one bee per spot (0.9 contact), or settled bees above it. - holdBelow −0.1: the held bee must be at least 0.1 link higher. - A bee can be held by at most maxHeldBy 4 others, counted from the state by _holderCount (determinism). - A landing bee that can't take any hold doesn't land (_settle returns false) and keeps flying.
3. Links = body length. Centre distance ≤ ½(Lᵢ + Lⱼ)·linkBody (≈ 13 mm). Searches use ±2 cells of the 0.035-ft hash. Contact-length links collapsed the network into a crust.
4. Relaxation every 16 steps (7.5 Hz), P.relaxEvery (RELAX_EVERY export = 16):
5. drop holds on bees that flew off;
6. _topology(): BFS from bark-holders gives depth and order; loads are passed up, shared equally among supporting holds;
7. orphans re-grip or fall (they fly back);
8. each bee has a 2 % chance per tick to re-grip:
   • an over-strength hold is swapped for one above;
   • an empty slot is filled;
   • a strained bee within one body length of free bark climbs onto it;
9. gravity (sag 0.016 ft per tick) plus a slow sideways crawl toward the queen;
10. 2 × [grip pass top-down in BFS order, then a Gauss–Seidel half-stencil overlap pass]. Bark-holders and the queen are anchored. The last pass is overlap, so bees never end a tick inside one another.
11. Bark taken only under strain. _branchFree allows a new bark spot only while the cluster is founding (< 40 bees), or next to bark-holders carrying > barkComfort (0.25) × their grip strength.
12. Renderer. - K (button Load) shades bees by load ÷ grip strength. - G (button Grips) draws the grip links as grey line segments; live state only, hidden while rewinding. - HUD line: bark-holders, mean top load vs grip strength, longest chain, number over their grip. - Phase 4 text reads "clustered, hanging in chains". - clusterShape().load carries the stats.

A7 results (seed 3906, 12,000 bees, 20 °C)

• Settled: 5 % at 45 s, 25 % at 60 s, 64 % at 75 s, 99 % at 90 s, 99.96 % at 150 s.
• Shape: a hanging bell ≈ 7 in deep, 8.5 in along the branch, 3.6 in across (HUD moments 5.8 × 6.0 in). The beard is deepest (≈ 8 in) during the landing rush at 75 s, then reorganises.
• Loads: ~450 bark-holders carry ~27 bee-weights each on average (grip strength 35 ± 14). ~3 % of bees are over their own grip, at bottlenecks. The longest chain is 16–25.
• Layers: bee count per 1-in layer narrows toward the tip, as Shishkov et al. found. The measured top load (3.8, on a flat board) is lower than ours because a 2-in branch offers far fewer attachment spots (SCIENCE §6.4).
• Rejected while tuning (recorded in SCIENCE §6.4):
• contact-length links;
• holds on lower bees (the cluster rests on itself, giving a sleeve);
• load-sharing climbing (climbRatio > 0, giving a sleeve);
• releasing holds that sag below (letGoBelow small, causing cascades);
• an inverted bark-band formula (fixed).
• Performance (Node): ≈ 10 ms per step on average over 0–100 s (the milling cloud dominates); 4–6 ms per step once clustered; A6 was 4–6. Recording is frame-locked, so movies are unaffected.
• Determinism: re-seek and fresh-run hashes are identical (Node). In the browser, the hash after rewinding and resuming equals a fresh simulation's.

A7 verified

• Headless Chromium from file:// at DPR 1 and 1.5: t = 75 and 150 s, load view and grips view all rendered with no console errors.
• Rewind (backward) then resume: hash matches a fresh simulation.
• Through the server: recording plus Finish & Make Movie (see below).

Known limits

• Grips are idealised: distance links, equal load sharing, no legs or body orientation.
• Bees don't walk over the surface.
• Tuned chain parameters.
• Scent, timing and the given queen spot are as in A6.
• No thermoregulation, scouts or lift-off yet (SCIENCE §7, the A8 candidate).

A6 context (still valid except where A7 changed it above)

What A6 changed (user's request, from my own A5 review)

"The queen and the first settlers give off a scent that spreads through the air; each bee follows the scent toward its source and steers by reacting to its neighbours; bees land wherever they touch the growing cluster." All three done — nothing is scripted any more (no join times, no pre-assigned slots, no prescribed cluster shape or size): 1. Scent field: 64×28×64 grid of 1-ft cells around the site; explicit finite-difference diffusion (2 ft²/s) + decay (0.08/s) every 1/30 s; ground reflects. Sources: queen (0.35 flying, 1.0 settled), fanning surface bees (0.03 each, 35 % of surface bees, emitted 1 ft outward = fanning away from the queen, Nguyen et al. 2021 PNAS). S shows a slice. 2. Each bee: own threshold (threshold × (0.3 + 5.7u²), threshold 0.05); above it → attracted → turns up the trilinear scent gradient (gain 9); within 1.5 ft of the cluster edge flies at it. Neighbours: separation < 3 in (1-ft hash of flying bees), cohesion to the centre of mass of bees within a ~12-ft block (4-ft density cells), and stay-with-the-swarm turn-back beyond 0.7 × cloud radius around the flying centroid; radius ∝ cbrt(flying/total). 3. Landing on contact: fine hash (0.035-ft cells) of settled bees; attracted bee lands touching the first settled bee it meets (contact = (ri+rj)·spacing, spacing = cbrt(0.6/packing)). Queen mills to 12 s, then alights under the branch. 4. Cluster physics (every 1/15 s): crawl toward the queen (0.25/s sideways, 0.0085/s vertical, ≤0.02 ft/s), two Jacobi overlap-resolution passes (queen anchored), branch collision, surface detection (neighbours < 0.7 × mean) → fanning; surface bees re-launch with p = 0.0004 per tick and may not re-land for 2–6 s (a few dozen bees always flying). - Results (seed 3906, 12,000 bees, 20 °C): settled 9 % at 45 s, 33 % at 60 s, 94 % at 90 s, 99.6 % at 150 s; cluster ≈ 8.3 in long × 4.5 in wide, measured packing ≈ 0.6; cloud ≈ 35–40 ft across while milling. - Removed: ?shape=sphere, ?dia=, ?gather= (nothing to set — it emerges). Added: ?threshold=, ?fan=, ?temp=. - Performance: ≈ 4–6 ms per 1/120-s step for 12,000 bees in Node (≈ 20–25 ms per film frame at x1) — about real time on a normal PC; recording is frame-locked so movies are unaffected. Optimisations kept: staggered (1-in-4) smell / cohesion / separation checks, face-aware neighbour cells, cache-friendly symmetric pair loop for the cluster, relaxation at 15 Hz. - Determinism: checkpoints now also store the scent field (+ surface flags); the cluster hash is rebuilt after every relaxation (index order) — required for exact backward seeking (verified: re-seek and fresh-run hashes identical). - Renderer: HUD shows census (milling / following scent / settled / fanning), emerged cluster size; branch always on (T toggles); shading and auto-zoom use the live cluster; S scent slice (grey dots, brightness ∝ (c/max)^¼).

A6 verified

Node: full run 0–180 s (numbers above), determinism (re-seek + fresh). Headless Chromium from file://: t = 1, 45 (+ scent slice), 90, 150 s — no console errors; through the server: forward, backward (rewind cache), pause → hash equals a fresh simulation; Finish & Make Movie wrote an MP4 and deleted the frames.

Known limits (see SCIENCE.md 6.5)

Tuned (not measured) emission/threshold/gain values; time still compressed ~8×; smooth scent (no turbulence/wind); queen's landing spot given; settled bees slide as spheres (no hanging chains); no thermoregulation, scouts or lift-off.

A5 context (still valid except where A6/A7 changed it above)

What A5 changed (the user asked "is the 1-foot sphere accurate?", then "all of the above")

The "foot across" came from the user's own prompt ("perhaps a foot in diameter"), not from research. Checked against the literature it is too big for a normal swarm, and real clusters hang as a beard, they do not hover. A5 does all three fixes: 1. Beard hanging from a branch (default). Branch shown by default (T still toggles it); the limb's underside is at attachY = 8.6 ft. Profile: clings along the branch at 0.75 of its greatest width, widest 30 % down, tapers to a blunt tip; cross-section 1.1 × 0.9 (along × across the branch); length = 1.6 × width (beardAspect). Grows from the queen's spot just under the branch outward/downward. ?shape=sphere restores the hovering ball (centred 8 ft up). 2. Size computed from the bees: cluster volume = Σ(equal-volume bee spheres) ÷ packing fraction. Packing from Ocko & Mahadevan 2014 (0.2–0.8) and Heinrich's ~2× volume change 15→30 °C: packing = 0.6 at 15 °C → 0.3 at 30 °C (clamped). ?temp= sets the air temperature (default 20 °C → 0.50). ?dia= still forces a sphere of a given size (HUD then shows the resulting packing, e.g. 0.10 for 1 ft — implausibly loose). 3. Typical size by default: 12,000 bees (≈1.4 kg, Seeley's ~1.5 kg swarm) at 20 °C → 3.0 L: beard ≈ 9.8 in long × 6.1 in wide (sphere mode ≈ 7.0 in). 12 °C → 8.9 × 5.6 in; 30 °C → 11.6 × 7.2 in. - HUD shows shape, dimensions, litres, packing, temperature and kg of bees. - Sim changes: _geometry() (size/shape/centroid; P.siteY becomes the centroid so the cloud and swirl centre on it), deterministic cbrt() (Newton, + − × ÷ only — Math.cbrt is not guaranteed bit-identical across engines), beardProfile(u), castes are now drawn in a first pass and positions in a second → different swarm than A4 for the same seed (still deterministic: repeat runs give identical hashes, e.g. seed 3903/12,000 bees at t=150 s → ce17be0a). - Renderer: branch placed from sim.cluster.attachY; ball shading and the auto-zoom limit use the cluster's own width/length.

A5 verified (headless Chromium, SwiftShader; Node)

Node: 12,000 bees to t = 150 s → 11,756 clustered + 244 fliers, cluster bees between y 7.88 and 8.61 ft (hanging under the 8.6 ft branch); repeat run identical hash. Browser from file://: t = 1, 85, 150 s (beard) and ?shape=sphere at 150 s; no console errors. Recording/rewind code unchanged since A3.

A4 context (still valid except where A5 changed it above)

What A4 changed (user's requests) — kept in A5

1. Trees removed. (Hive kept as a wire box ~100 ft away; the optional branch, T, stays — off by default.)
2. Black and white. Black background, white/grey lines only; no lights, no shadows, no colour. Distant lines fade to black (fog 45–230 ft). Caste toggle (C) now uses grey levels: workers dim, drones bright, queen pure white.
3. Wireframe. Ground = line grid (5 ft squares near the site, 25 ft to the horizon, built only in front of the camera — GridHelper lines that cross behind the camera vanished in testing). Hive = box edges. Branch = wireframe cylinders. Bees = 20-face wire icospheres with a black "hidden-line" core (polygon-offset), so front bees hide the wires behind them. The bees in the ball get a grey light term (light from upper right/front) so the ball reads as a sphere of wire dots, not a flat white disc.
4. Bees much smaller, still varying. Spheres now have the same volume as the bee's body (ellipsoid L×W×W): d = (L·W²)^⅓ → worker ≈ 6.1 mm (range 4.8–7.2 mm), drone ≈ 7.8 mm, queen ≈ 7.6 mm — vs A3's d = L (≈ 13 mm). Width/length used: worker 4.2/12.8, drone 5.5/16, queen 4.8/19. "Visible size" minimum lowered 2.5 px → 1.2 px. L (or the "Bee size" button, or ?size=length) switches back to A3's body-length spheres. Simulation (CT39.A6.Swarm_sim.js) is unchanged from A3 — same seed gives the same swarm and the same state hash.

A4 verified (headless Chromium, SwiftShader)

file:// at DPR 1 and 1.5, 10,000 bees: screenshots at t = 1, 62, 85, 150 s (wide wire cloud over the grid → shaded wire ball at ~400 mm); C / T / Z / L toggles; no console errors. Sim, rewind and recording code paths are unchanged from A3 (verified there: exact resume hash, MP4 made, frames deleted).

A3 context (still valid except where A4 changed it above)

Lineage

• CT39.A1.Swarm (found at C:\Users\micha\Downloads\claude\CT39.A1.Swarm\CT39.A1.Swarm\): 300 bees milling inside an 8 ft sphere resting on the ground, head-height camera, schematic trees, sphere+arrow glyphs; deterministic sim core (fixed step, mulberry32, only + − × ÷ √, exact checkpoints), Forward/Backward/Pause/speed controls, frame recording through a local Python server and "Finish & Make Movie" (ffmpeg MP4, frames deleted after a verified encode).
• CT39.A2.Swarm: not found on the computer (Downloads\claude, Downloads\claude\zips) or in past chats. If it exists elsewhere, point a later chat at it.
• CT39.A3.Swarm: keeps A1's determinism, controls, rewinding, recording server and movie pipeline; replaces the scene and behaviour with the researched swarm → cluster sequence, 10,000 bees, spheres only, auto-framing camera.

How to run

• Just look: double-click CT39.B1.Swarm.html (works from disk — classic scripts, no modules). Recording is off.
• Record a movie: double-click CT39.C6.Swarm_start.bat (Windows; needs Python 3, and ffmpeg for the MP4) or run ./CT39.C6.Swarm_start.sh (macOS/Linux/WSL). It serves http://127.0.0.1:8739/ and opens the page; every frame while running is saved; Finish & Make Movie encodes CT39.B1.Swarm_movies/CT39.B1.Swarm_movie_seed<seed>_<time>.mp4 (+ _info.json) and deletes the frames. ffmpeg: winget install ffmpeg, or drop ffmpeg.exe next to the server.
• URL options (B1: see the list above; A12 added look=wire|shaded, shadows=0|1, outline=0|1, outlinew=, junk=lots|some|none; default bees is now 4000; A11 added wingfill=1 and removes shadow=/lampshadow=; A10 added intro=0, title=, card=, strands=contrast|chains|off, pip=0, q=low, shadow=, lampshadow=1; A9 added arch=wire|iron|off, strands=colour|chains|off; A8: cam=orbit, dist=, intro=0, sound=0; A5): ?seed=3903&bees=12000&w=1280&h=720&gather=55&shape=beard|sphere&temp=20&dia= (gather = mean seconds for workers to join after the queen; temp = air °C → packing; dia = force a sphere of that diameter in ft).

Controls

What happens (default seed 3903, 10,000 bees)

Files

Key technical decisions (reuse in A4+)

• Sim state per bee (STRIDE 18 doubles): position, heading, speed, size (body length, ft), OU turn-rate (or crawl offset when clustered), OU target speed, join time, cluster slot xyz, mode (0 milling, 1 joining, 2 clustered, 3 perpetual flier), caste (0 worker, 1 drone, 2 queen). DT = 1/120 s; 4 steps per film frame at x1 (30 fps). ~1.25 ms per step for 10,000 bees (Node).
• Cluster slots generated once (rejection sampling in the ball, mantle 1.8× denser), sorted by radius; bees sorted by join time get slots inside-out (the queen innermost). The milling cloud's radius shrinks with the joined fraction.
• Checkpoints every 5 s (exact Float64 copies, 1.6 MB each at 10k bees). Rewind cache: running backwards simulates the current 5-s block once and keeps Float32 positions every 2nd step (~36 MB), so backward frames are instant; leaving backward mode does an exact sim.seek() → determinism intact (verified: same hash as a fresh run).
• Camera: fixed at (0, 6, 0) ft; aim = smoothed coordinate-wise median of ~700 sampled bees; auto-zoom frames the 90th-percentile angular extent ×1.3, never tighter than the ball filling 42 % of the frame; smoothing α = 0.07 per film frame. Lens shown as 35 mm-equivalent focal length.
• Visible size: bees are drawn ≥ 2.5 px (workers) by a single global factor that keeps relative sizes; factor shown in HUD; becomes ×1 (true size) once zoomed on the ball.
• Rendering while paused stops after the camera settles (settle frames) — important for software-GPU testing.
• Shadow map 2048² covering ±45 ft around the site (4096² stalled SwiftShader; real GPUs are fine either way).
• Scenery: meadow, faint 5-ft grid, tree line ~170 ft behind the site (so the swarm is seen against the sky in the wide shot), hive box ~100 ft away (Seeley: clusters form ~30 m from the hive), optional branch (T).

Verified (headless Chromium, SwiftShader WebGL)

• From file:// at DPR 1 and 1.5: no console errors; screenshots at t = 1, 62, 85, 110, 150 s show cloud → condensing → ball.
• Through the server: forward, backward (rewind cache), pause; hash after resume equals a fresh simulation's hash at that step; branch and caste toggles; Finish & Make Movie produced an MP4 + info JSON and deleted the frames.
• Node: 10,000 bees to t = 150 s; census 9,805 clustered / 195 fliers; re-seek and fresh-run hashes identical.

Ideas for A4

• Thermoregulation: ball contracts/expands with air temperature (Heinrich 1981); mantle/core visible in a cut-away.
• Beard/bell shape hanging from the branch as the "realistic" option; scouts dancing and the lift-off.
• Real bee meshes with wings (A1 planned this) / motion blur; Nasonov fanning bees on the surface.

Context inherited from CT52.A2.SphereSwarm (option 5)

(File names below are the CT52.A2 names.)

CT52.A2.SphereSwarm — context file

This is a browser simulation (WebGL and three.js r186, bundled locally, so it works from disk) of a honeybee swarm. It does not hang from anything. The queen hovers in the open, and about 5,000 bees fly in a close ball around her, ~15 in across. New in A2: * a Move queen button sends her slowly 10 ft to the right, next to a 10-ft measuring pole, and a second press sends her back; * a Follow switch picks how the bees keep with her: by sight or by her scent alone.

• Harness: Claude harness v3 (2026-10-08). Built 2026-10-08.
• Lineage: A2 = A1 plus the move, the pole and the follow switch. A1 is built on CT39.C6.Swarm. The A1 context follows below and still holds except where noted here.
• Science: CT52.A2.SphereSwarm_SCIENCE.md (plus .html). §9.6 is new: the move.
• Start: open index.html, or run the _start.bat / _start.sh launcher (needed for recording movies).

The user's A2 request

(The A1 request was repeated above it and is quoted in the A1 section below.)

In this version there should be a button, that when clicked, causes the queen to move 10 feet or so to the right (or whatever). There should be a pole near to that new position, vertical, maybe 10 feet high, 1 inch in diameter, and with a band every foot that could be used to estimate height and size. When the button is clicked, the queen should move in the designated direction reasonably slowly and we will see what the other bees do. FWIW Many years ago, I observed the original large swarm, I observed a sphere of dense bees, and I observed a similar sphere in a different position. I did not see the swarm move, nor did I see the smaller sphere coalesce.

What A2 changed

1. Move queen (button, or G)

• When it works: once the queen holds her station (from ~28 s). Before then the button says to wait.
• The move: she flies to station B, 10 ft to the right of station A as seen from the camera (+x), at the same height (7 ft) and depth: (siteX + 10, 7, siteZ + 4).
• Speed: moveSpeed = 0.8 ft/s (~0.25 m/s), so the trip takes ~13 s. ?movespeed= changes it (0.1–8 ft/s).
• A velocity controller eases her in at the end, and she hovers there.
• Pressing again sends her back to A, and so on. The button reads "Move queen ▶" or "◀ Move queen back".
• How it is recorded: in the sim, requestMove() writes an event (the step at which she is told) into sim.moves. Her current station is A or B by the parity of the events already passed (stationNow()).
• Events are not part of the bee state, but replay, rewind and recorded movies honour them.
• A request made while viewing a rewound moment acts from that moment. Later events and later checkpoints are dropped (the old future is forgotten).
• Reset clears all events.
• Same input, same result: a run stopped and resumed in pieces, a straight run and a rewound replay give identical hashes.
• A fix made along the way: the queen's own velocity is now stored in her unused slots 21, 22 and 14. In A1 it was rebuilt from her heading, which is turned slowly while she hovers for looks. That could leave her stuck at almost zero speed for several seconds after a move order.

2. The measuring pole

• Where: 1.25 ft behind station B (further from the camera), so the ball hovers just in front of it.
• Size: 1 in across (poleR 1/24 ft) and 10 ft above the ground.
• Look: dark grey, with a 1-in white band at every foot and red bands at 5 and 10 ft, plus a red cap.
• Solid: it is solid for flying bees (_stone() pushes them out radially).
• It is drawn in both looks.

3. Follow: sight / scent (button; reloads with ?follow=)

• sight (default; A1's rule):
• a bee that has picked up the scent flies straight at the queen once she is within 6 ft;
• in the ball, every bee is pulled toward her.
• scent: a bee never knows where she is.
• Outside the ball: it follows the scent gradient all the way in.
• In the ball: it is pulled toward the centre of the ball bees it can see (this.ball, the centroid of mode 3), and drifts up the gradient of her own pheromone at scentDrift 5 ft/s².
• Joining is measured from the ball's centre.
• The queen's pheromone is kept in its own air grid (qfield; same diffusion and decay; checkpointed). It is diffused only in this mode.
• Why the separate grid: the ball's in-flight scenters put out ~15× more scent than the queen. With one shared field, the scent-following ball stayed put and let her go (tested: she left, and the ball stayed at A).
• Scenting bees add to the total scent (attraction, giving up) but not to her pheromone.

4. HUD

• Phase 5: "the queen is moving — x ft to go …".
• Ball line: adds how far the ball's centre is from her, and the follow mode.

A2 results (seed 3906, 5,000 bees; Move pressed at 150 s; Node = Chromium)

The ball is measured about its own centre, so a ball lagging behind the queen is not counted as "big".

What this shows: * The ball keeps its size and shape in both modes: ~15 in across (90 % of its bees within 7.1–7.8 in of its centre). Its 5–95 % extent is 10–11 in along and across the path. It does not stretch out. * By sight: the ball goes with her as one body. The bees are pulled toward her far harder than her slow move needs, so it lags about an inch. * By scent: * At rest: she sits near the edge of the ball (7–10 in from its centre). The 1-ft air grid places the scent peak a little off her. * When she moves: her pheromone reaches the bees with a delay and their drift up its gradient is limited, so she flies out of the ball. * During the trip: the intact ball follows ~2.5 ft behind her (30 in at most). It closes to ~10 in 2 s after she stops, and to its resting 7–8 in after ~6 s. * Almost no bee is lost in either mode: about 50 are following and 30–50 milling at any time, as before the move. Fewer than 5 are within 2 ft of the old spot 6 s after she leaves. * Hashes (move at step 18000):

• The 150 s and 158 s hashes are the same in Node and Chromium.
• The 210 s hashes are the same after rewinding to 170 s and replaying, and for a run stopped and resumed in pieces.
• The sight run differs from A1: with the same seed, its 60 s hash is f1dd1d4b (A1: 9503df3c), because the pole deflects a few milling bees.

Verified (headless Chromium, SwiftShader, from file://)

• The button. Moving the queen at 150 s:
• the note reads "The queen is moving to the pole (0.8 ft/s)";
• the button turns into "◀ Move queen back";
• the HUD shows Phase 5 with the distance to go;
• the hashes match Node.
• Pictures:
• mid-move (158 s), orbit 9 ft: the ball in the open between the arbor and the pole;
• 172 s, 6 ft from the queen: the ball hovers in front of the pole at the 7-ft mark, about 1.5 bands across;
• the pole: white bands every foot, red at 5 ft, red cap at 10 ft.
• Both follow modes run with no console errors.
• One page bug was found and fixed: the button's label did not change right after a press.

Known limits (A2)

• The move is a teleport of the target, not a decision. She simply heads for B. Nothing in the swarm makes her go. Real relocations follow scouts and streakers (SCIENCE §9.5–9.6).
• Scent following uses a 1-ft air grid. Inside a 1-ft ball the gradient is coarse, which is why, at rest, the queen sits near the edge of the scent ball rather than at its centre. A finer grid near the queen would fix it, at a cost.
• The pole is only solid to flying bees. Nobody lands on it (no landing in CT52).
• Everything in the A1 limits still applies.

CT52.A1.SphereSwarm — context file

This is a browser simulation (WebGL and three.js r186, bundled locally, so it works straight from disk) of a honeybee reproductive swarm. It does not hang from anything. The queen flies with the milling cloud for a while, then holds a point in the open and hovers there. The bees that pick up her scent gather around her and keep flying in a close ball, about 15 inches across.

• Harness: Claude harness v3 (2026-10-08). Built 2026-10-08.
• Lineage: CT52.A1 is the first version of a new project. It is built on CT39.C6.Swarm, the latest CT39 version, found at C:\Users\micha\Downloads\claude\CT39.C6.Swarm.zip. The A12–C6 context is not repeated here: read CT39.C6.Swarm.md in that zip. The scene, the bees' look, the UI, the sound, recording and rewind all come from C6 unchanged unless noted below.
• Science: CT52.A1.SphereSwarm_SCIENCE.md (plus .html). §9 is new: the flying ball and the evidence for it. §1–8 are the CT39 science and still apply to the milling and scent parts.
• Start: open index.html (works from disk), or run CT52.A1.SphereSwarm_start.bat (Windows) or CT52.A1.SphereSwarm_start.sh (WSL / Linux). The launcher starts the local frame server, which is needed for recording movies.

The user's request (CT52.A1)

This is a variation on the latest CT39.Cx.Swarm simulations. The geometry used can be the same. As with the previous version(s) there is no wind, as if it were in a courtyard or other protected environment. Instead of the queen moving off to attach itself to some horizontal geometry, after flying around in the swarm for a while, the queen should position herself in the swarm somewhere and hold a mostly static position for the first phase of this simulation. When the bees sense the scent, they should fly reasonably close to queen and continue to fly around her in a reasonably close formation to the extent they continue to sense the organizing scent. If it makes sense to have other bees use their wings to beat the sense around, that is ok, otherwise, presumably the scent is diffused in a gradient around the queen. It is hoped that the bees will begin to form a "close in" shape around the queen, while still flying. When observed in the wild, the "close in" swarm of bees was roughly spherical and perhaps 12-18 " in diameter. No initial splash page or descriptive text is necessary at this time. The initial number of bees can be about 5,000 The rest of the user interface can stay the same. The simulation will run for several minutes, total time unknown. In a later version, after several minutes, the queen will fly to a location about 10-20 feet away, in a tree, but not attached to the tree. We want to see what is involved with the close in swarm following the queen.

Background from the CT39 conversation

The user once watched a real swarm: a sphere of bees about 10 ft across that contracted to a 12–18 in ball. The ball seemed unattached and the bees did not seem to be gripping anything. In C6 this was noted as a possible "hovering ball" mode for later. CT52 is that mode.

What A1 does

The run (seed 3906, 5,000 bees; Node and Chromium give the same hashes)

What happens: * 0–20 s: the milling cloud, as in CT39. The queen flies among the bees, slower and calmer than the workers. * About 20–28 s: the queen flies to her station and holds it. The station is 7 ft up and 4 ft in front of the arbor's front beam, toward the camera: in the open, inside the arbor's frame from the default view. She hovers there, drifting a few inches (rms 0.08 ft). * From about 28 s: her scent spreads. The bees that smell it fly to her and join the ball. Scenting bees in the ball add their own scent, so the gathering speeds up. * By about 140 s: 98 % of the bees are in the ball. About 50 bees are on their way in or out at any time, and about 30 still mill. * The steady ball: * Size: 90 % of its bees are within 7.6–7.8 in of the queen, so it is about 15 in across. Half are within 5 in. The rms-equivalent diameter is 14.2 in. * Speed: the bees fly at about 2.1 ft/s (0.65 m/s) on average, in all directions. * The queen: she stays at its centre. * Bee count changes the size: * 1,500 bees: 90 % within ~7 in. Gathering is slower (less scent), and about half still mill at 240 s. * 15,000 bees: 90 % within 8.6–10 in, so about 17–20 in across. * Hashes: * at 10 s: e671b582; * at 60 s: 9503df3c; * at 25 s (3,000 steps): 2a31c95c, the same after seeking back from 60 s; * at 300 s: a2158f5e.

The simulation (_sim.js; STRIDE 23 unchanged)

New mode 3, "in the ball". The modes are now: * 0: milling. * 1: following the scent. * 3: flying in the ball.

Mode 2 ("settled") is never used in A1. The hanging-chain machinery (grips, loads, strands, _relax) is kept but unused.

The queen (bee 0): * Before queenSettle (20 s): she mills. * After that: a velocity controller flies her to the station. Her cruising speed is 6 ft/s, slowing as she nears it, and her acceleration is capped at 25 ft/s². * Hovering: her drift is a slow Ornstein–Uhlenbeck (OU) offset kept in her otherwise unused grip slots 18–20, so it is part of the saved state. * At the station: within 0.5 ft of it, she becomes mode 3. She emits queenEmit (1.0/s); while flying she emits queenFlyingEmit (0.35/s). * When she turns: with almost no speed she slowly turns about the vertical, so her body orientation is defined.

Following the scent (mode 1): * Becoming attracted: as in CT39, when the scent passes the bee's own threshold. * Giving up (new): a bee goes back to milling if the scent falls below loseScent (0.5) × its threshold. This is "to the extent they continue to sense the scent". * Steering: * within visRange (6 ft) of the queen it flies straight at her; * otherwise it flies up the scent gradient; * it slows as it nears her. * Joining: within ballJoin (1.6 ft) it joins the ball (mode 3). A share scentFrac (20 %) of the joiners become in-flight scenters. * Landing and the C1 under-the-beam approach rule: both are switched off.

The ball (mode 3, _ballStep): each bee carries a velocity and feels four things. 1. A pull toward the queen: ballPull 24 ft/s², plus ballPullOut 80 ft/s² per ft beyond ballEdge 0.35 ft. 2. Personal space: a push down the gradient of the local density of ball bees. * The density comes from a 40³ grid of 0.12-ft cells that follows the queen. It is rebuilt at 30 Hz, with each bee spread over its 8 nearest grid points (cloud-in-cell). * Strength: ballPress (2.2 ft²/s²) × ∇n / n0, stiffening as (n/n0)² once the density n passes n0. * n0 = 1 / (ballSpacing × worker length)³, with a spacing of 1.35 body lengths (17 mm). That is ~5,500 bees/ft³. 3. Erratic flight: OU wander, at 0.55 of the milling wander strength. 4. Speed and drag: its own slow speed (ballSpeed 1.6 ft/s × the bee's OU speed factor, 0.7–4 ft/s; response 8/s) and drag (3/s).

The size is not set anywhere. It comes from the bees' speed against the pull (a kinetic "temperature") plus personal space against crowding.

Other rules in the ball: * Leaving: a ball bee goes back to mode 1 if it is flung beyond ballLeave (5 ft), or to mode 0 if it loses the scent. * Excursions: a ball bee darts out for 1–3 s at a rate of ballExcursion 0.004 per second, then comes back. This keeps the edge alive. * In-flight scenting: each scenter emits flightScentEmit (0.015/s) where it flies. * The timber is solid for ball bees too. * The milling neighbour hash and the cloud centroid use only modes 0 and 1. The ball would otherwise make the separation loop quadratic and pull the cloud's "stay together" centre.

API: * census() returns [milling, following, in the ball incl. the queen, scenting in the ball]. * ballShape() returns {n, cx, cy, cz, diameter (rms-equivalent), queenHolding, station}. * window.CT52Sim is the sim's global.

Determinism: as in CT39, the sim uses only + − × ÷ and sqrt, a fixed step (1/120 s), and integer RNG. Checkpoints carry the whole state, so rewinding is exact.

Cost: about 0.35 s of CPU per simulated second at 5,000 bees (Node), so 1× runs comfortably in real time. At 15,000 bees it takes about 1 s per simulated second.

The renderer and UI (_main.js, index.html)

• No opening. The C6 title art and the four captions are removed. The page starts straight into the scene with the sim running. Sound starts on the first click or key, because browsers hold audio until then.
• ?run=0 opens it paused (used for testing).
• 5,000 bees by default. The Bees selector offers 500 / 1,000 / 2,000 / 5,000 / 7,500 / 10,000 / 15,000 / 20,000.
• Odometers: FPS · Time · In ball · Milling (milling plus following) · Scenting.
• HUD:
• Phases: 1 milling (the queen flies among them), 2 the queen flies to her place, 3 gathering, 4 the close-in ball.
• Line 3: "ball ≈ N in across (90 % within r90 of the queen, half within r50) · queen y ft up, hovering".
• Camera:
• T now cycles the queen and the ball's centre (C5's "tip" is gone).
• The ball's box (settledBox()) is the 2nd–98th percentile box of the ball bees, so darting bees don't swing it. While rewinding, it uses the bees within 5 ft of the queen.
• AUTO: the wide shot from 6 ft above the ground, as before; it keeps the ball at ≤ 7 % of the frame height (C-series rule).
• Close-up (P): frames the ball's box as C5 did. It is now only 10° below the ball (C2–C6: 31°), so the ball is seen against the sea and sky rather than up into the arbor.
• Scent (S): the vertical slice now passes through the queen's station (z = siteZ + 4).
• Hidden (nothing hangs): the Chains, Grips and Load buttons and their keys (N, G, K). The code remains.
• The test handle is window.CT52 (was window.CT39).

Verified (headless Chromium, SwiftShader, from file://)

• At 60 s: the milling cloud over the sea, with the dense ball forming in front of the arbor. The close-up shows the ball. The HUD reads "ball ≈ 13.9 in across".
• Same hash as Node: at 10 s and 60 s.
• No console errors.
• Not re-tested: recording, the movie pipeline and the sound. Their code is unchanged from C6, apart from the page name (the server now redirects to and opens index.html).

Known limits / honest notes

• Biology: a flying ball this dense is not documented (SCIENCE §9).
• Measured swarm clouds in flight hold 17–80 bees/m³ (Beekman, Fathke & Seeley 2006).
• This ball holds ~190,000 bees/m³, with bees 17 mm apart, about one wingspan.
• A queen that hovers in one spot for minutes is also not documented.
• The likely explanation for a free-looking 12–18 in ball is bees clustering on something small or hidden: a thin twig, a fence wire, or the queen landed on a leaf. They can look as if they are not gripping anything.
• The model shows what the request describes. §9 sets out what is real and what is assumed.
• No collisions between ball bees: only the density field keeps them apart, so a few bees can overlap briefly.
• No air flow: the bees' own wash is not modelled (the brief says still air). The scent spreads by diffusion plus the in-flight scenters.
• Dawn is still artistic licence (CT39 B1).

Next (asked for in the request)

A2 or later: after several minutes, the queen flies 10–20 ft to a spot in a tree, but does not attach to it, and the ball follows her. Much of this is already in place: * the station is a parameter (stationDX/Y/Z); * she flies to it with a velocity controller; * the ball's density grid follows her.

What is needed: * a tree in the scene (the arbor scene has none); * a time for the move; * a choice of how the ball travels. A1's bees would follow her pull directly. Real swarms are steered by a few fast "streakers" (SCIENCE §9).