Skip to content

feat(weather): phase 1's contracts, instruments, capture and panel are one branch, and no picture moves - #209

Merged
jonjaques merged 393 commits into
the-weatherfrom
weather/phase-1
Nov 14, 2026
Merged

jonjaques merged 393 commits into
the-weatherfrom
weather/phase-1

Conversation

@jonjaques

@jonjaques jonjaques commented Nov 10, 2026 •

Copy link
Copy Markdown
Owner

Phase 1 of the weather is the volume and its light: density from microphysics, the light's tables, the trace's higher orders, the far march and the history, judged on the nine cornerstones and the overlay guard (design/plans/weather/phase1/design.md). This is its draft, built in waves on weather/phase-1 and merged forward, never rebased. It stacks on #207, the cornerstones and their baseline, and retargets to the-weather once #207 merges.

What changed

Wave 1 is four packages built apart, merged here with --no-ff in the order I, U, J on C's tip, then joined.

  • C, the contracts (c18d96b0 to 78f6b3ee). Every phase 1 contract lands at once on the built system, and each reader's path moves with it. Where a change is not mechanical the new member stands beside the old one, drawing phase 0's picture until its owner completes it: ten frames at five stances are byte-equal to the base's. The weather lever replaces scenario and takes 'climate', which is the fair-cumulus regime until package D lands the climate. The weather's types, regimes and stand-in tables, the two ingest sources' records, and the three accuracy instruments as bounds are all here.
  • I, the instruments (084b5dc7 to 7029de7a). castSteps.mjs reads a cast's steps against its control, across its gaps. classify.mjs sorts a flagged step into an entry, an exit, an error or an unresolved finding, with the settled stills as its evidence. drift.mjs measures the drawn field against the CPU turn, and glory.mjs profiles the glory's first red ring against the Mie table. frameDiff.mjs exports changedPixels for the two of them that count pixels.
  • U, the capture's second pass (d9298d8a to 3b07dd8b). Every take carries its provenance and a role. A take is held to the build it photographs. The rubric's casts replace package K's, each kept with its drops listed and refused past 3% of its frames or three in a row. The overlay guard is the tenth cornerstone, 2.5 km off the ISS. G2 stands over a sea deeper than the drawn ground's tail, and ADR-0067 is amended to say so.
  • J, the panel's tools (06b58f99 to 7e3d0753). packet.mjs builds a seat's blind packet from capture records, validate.mjs reads its review, ledger.mjs judges a round and archive.mjs freezes it. crops.json cuts each still at its own rectangle, and the real-time anchors are frozen in references.md.

Nothing conflicted textually. C and U both edited pictureWeather.ts and its test, and both changes stay: C's lever name and type, U's release on a re-aimed observatory and its forcing that waits for a system to load.

Joining them took seven commits, each with a test that fails without it:

  • 9d28c51a The C4 cast (G6 slow under the world's climate) set scenario, a lever the merged engine refuses, so the capture would record it unavailable. It sets weather: 'climate' now, and a test holds every cast's levers to the engine's isCloudLevers.
  • 2a5d704f The packet builder reads U's record as written: each still through U's checkTake, the role by role.name, the levers as { hash, size }. The overlay guard is found by its id, because U put it in STILLS. Its deck plate is the old plate and its volume the new, until --guard-base names a later one. The merge alone had turned crops.json's test red.
  • fbcde197, 498a406d The classifier holds the cast it reads to checkTake(entry, true). It finds the cast's control by the name the record gives: the climate and injected casts are read against the slow descent's.
  • 7f68a8be The capture keeps its own changed-pixel count. frameDiff's resizes to a 480 px long edge first; the capture's counts native plates, and every noise floor in the record is of 5,184,000.
  • 51794ef0 A picture whose clouds serve no body read drawn. The outcome now follows the clouds' report: drawn once a frame drawn with the picture's levers served its body, and unavailable when it served another or none. The capture's own check stays as the second guard.
  • 121451e5, b7ca414a Two defects the checks found. The cornerstones' ledger snapshot cannot pass prettier and its own test at once, so both ledgers join .prettierignore. A solarTime property read a peak 5e-8 s away as a rising sun; the defect predates U, and U's stronger property exposed it.

c1a33f33 settles the docs debts. The README cites db65372f for the docs routing. The plan's phase 0 row has the history pass within its target, at 0.27 and 0.18 ms against 0.3. E2's fourth caption puts the sun 1.2° under the limb, under a dated note. G2's tail is 1.13 m on this body, measured from drawnDivergence; 1.25 m is the ceiling on any body. The README now records wave 1's facts and where the work stands.

Invariants

  • Rule 7: a picture's weather is written and released only through PictureWeatherHold, and its outcome is now read from the clouds' report rather than from the levers it wrote.
  • Rule 68: every GPU job here ran under the machine's lock, and the compare's rig was taken down after it.
  • No invariant is added or changed.

Screenshots

Media: none yet; wave 1 changes no picture (presets:compare 0 moved).

Verification

On the Mac mini (Mac18,5, Apple M6, 32 GB), at b7ca414a, with four packages of wave 2 building beside it. The tip, 6f0502ec, adds one line to the README naming this pull request, and passes prettier --check:

  • IR_CHECK_JOBS=4 pnpm check, full: 20 stages passed in 93.8 s of wall time. The root suite is 381 files and 4,488 tests, test:slow 5 files and 9 tests.
  • IR_GPU_WAIT=540 pnpm test:gpu, full: 76 files, 464 tests passed and 3 skipped, in 31.1 s of wall time while other builds shared the machine. The first run failed one test in upscale.gpu.test.ts: no GPU pass timing above zero. That file passed three runs alone, and the suite passed whole on its second run. Nothing the upscaler reads changed here.
  • pnpm presets:compare --all --base origin/weather/p1-cornerstones: 13 presets, 0 moved, against ddd0d76b.
  • pnpm presets:ledger and pnpm cornerstones:ledger: no diff.
  • pnpm spelling:check: 0 British declarations. pnpm sim --self-test: 12 of 12.
  • A flaky property is not fixed here. packages/rendering/src/weatherClock.test.ts, phase 0's file and wave 2's to own, failed once on a subnormal speed (seed −779636656, 1.779e-320 against a bound of 1.7786e-320), and passed on three reruns.

Left out

  • Waves 2 to 4: density and the climate, the light's tables, the frame and the history, the sun's depth, the over pass, and the rest of §10.2.
  • The campaigns and the capture's windows, including the baseline retaken on the second pass.
  • ADR-0068 to ADR-0074.
  • The council, which sits once for the phase on this pull request when it is ready.

🤖 Generated with Claude Code

jonjaques added a commit that referenced this pull request Nov 10, 2026
The branch table named `weather/phase-1`'s pull request "Draft" because
the commit that wrote it came before the pull request existed. It is
#209, a draft on `weather/p1-cornerstones`.

Co-Authored-By: Claude <[email protected]>
Base automatically changed from weather/p1-cornerstones to the-weather November 10, 2026 17:16
@cloudflare-workers-and-pages

cloudflare-workers-and-pages Bot commented Nov 10, 2026 •

Copy link
Copy Markdown

🚀 Deploying Preview to Cloudflare 🚀

Preview URL: https://weather-phase-1-inertialrefd.jaquers.workers.dev (commit 160959d)

This URL reflects your latest Preview deployment

Preview Deployments by commit

Status Deployment URL Commit Updated (UTC) See this deployment's details
  • Build: Success ✅
  • Deployment: Success ✅

View logs ↗
https://64b86c66-inertialrefd.jaquers.workers.dev 160959d 2026-11-13T08:40:39.611Z Visit the dashboard ↗
  • Build: Success ✅
  • Deployment: Success ✅

View logs ↗
https://d0469fe6-inertialrefd.jaquers.workers.dev 370ea92 2026-11-13T07:59:18.779Z Visit the dashboard ↗
  • Build: Success ✅
  • Deployment: Success ✅

View logs ↗
https://a4cc60fb-inertialrefd.jaquers.workers.dev 9cea4c2 2026-11-13T05:51:21.514Z Visit the dashboard ↗
  • Build: Success ✅
  • Deployment: Success ✅

View logs ↗
https://93da754e-inertialrefd.jaquers.workers.dev 885a032 2026-11-13T05:26:39.305Z Visit the dashboard ↗
  • Build: Success ✅
  • Deployment: Success ✅

View logs ↗
https://d979fa1f-inertialrefd.jaquers.workers.dev 9071504 2026-11-13T05:05:58.963Z Visit the dashboard ↗
  • Build: Success ✅
  • Deployment: Success ✅

View logs ↗
https://e99f6394-inertialrefd.jaquers.workers.dev e4ad12c 2026-11-13T04:41:11.791Z Visit the dashboard ↗
  • Build: Success ✅
  • Deployment: Success ✅

View logs ↗
https://b4dd3697-inertialrefd.jaquers.workers.dev ef5a540 2026-11-13T04:22:44.834Z Visit the dashboard ↗
  • Build: Success ✅
  • Deployment: Success ✅

View logs ↗
https://f6f03d5b-inertialrefd.jaquers.workers.dev d0e0b7d 2026-11-13T04:04:50.803Z Visit the dashboard ↗
  • Build: Success ✅
  • Deployment: Success ✅

View logs ↗
https://699bfda9-inertialrefd.jaquers.workers.dev df0ac23 2026-11-13T03:45:39.318Z Visit the dashboard ↗
  • Build: Success ✅
  • Deployment: Success ✅

View logs ↗
https://b42b2f4f-inertialrefd.jaquers.workers.dev 49e09a1 2026-11-13T03:29:18.525Z Visit the dashboard ↗

View all previews: View all previews ↗

jonjaques added a commit that referenced this pull request Nov 10, 2026
Pull request #207 merged weather/p1-cornerstones into the-weather at
aff433b, and #209 now targets the-weather. This merge brings only that
merge commit: every file it carries is already on this branch, which
grew from weather/p1-cornerstones, so the tree is unchanged.

Co-Authored-By: Claude <[email protected]>
jonjaques added a commit that referenced this pull request Nov 10, 2026
…age F's

Package L refreshes the sun's depth at the pace its content moves, so under
a held clock a whole cache is never redrawn. Until package F's maps land, a
slice baked from stale maps under a held clock stays stale, and a capture
from the branch in that interval would photograph it. The README's "where
the work stands" says so, in L's words. Its branch table also says what
merged: #207 into `the-weather`, which #209 now targets.

Co-Authored-By: Claude <[email protected]>
jonjaques and others added 25 commits November 10, 2026 12:50
…mentation can include them

The full `pnpm check` failed at `docs` on the tip that merged package R1's
first pass: TypeDoc refused `SLAB_REFERENCE`, whose type refers to
`SlabReferenceRow`, `SlabReferenceFlux` and `SlabMonteCarloRow`, three
interfaces slabReference.generated.ts declared without exporting. It is
the defect D's zonal law (3ca8e9d) and L's sun schedule (d0d0dad) had.

The interfaces are written by the generator, apps/ingest/src/transport/
slabTables.ts, and the tables take 39 minutes of four cores to generate,
so they are not regenerated here. The generator's template now writes
`export interface` for the three, and the committed file carries the same
three words, so a run of the generator reproduces it. Exported rather than
spelled out, unlike the earlier two: each is a named record of twelve
fields that `SLAB_REFERENCE` holds arrays of, and a reader of the table
names them. The docs stage passes, as do knip, lint, typecheck:core,
typecheck:ingest, R1's eight test files (87 tests) and the contracts
test.

Co-Authored-By: Claude <[email protected]>
… the capture's first run

Package U's third pass (weather/p1-u, 4d38451; it already holds this
branch at 8aa604e and D's second pass) holds every cornerstone's weather
on package D's CPU field. Each picture has a clause under its regime,
stated once in the new apps/headless/src/cornerstoneSolve.ts and asserted
by the ledger, and G5, E2 and the overlay guard are re-solved where the
field could not show their weather, then again on the field that no
longer repeats. The capture takes the fixes its first run on a real page
found: a cast's coverage counts path frames, a noise floor's run draws its
sheet, a cut or a scrub is not refused for its own load's hitch, and a
clock cast says where its reduction falls. It gains `--lever
<name>=<value>`, a named cast or arm alone, and `sameBuild(page, tree)`,
one equality of two build ids. ADR-0067 is amended to match.

Nothing conflicted: none of U's nine files changed on this branch since
8aa604e. The runner's join to `sameBuild` and to `--lever` follows.

Co-Authored-By: Claude <[email protected]>
…s own equality

Package Q's runner refused a page whose build id was not the tree's by
its own `page === tree`, and named package U's `sameBuild(page, tree)` as
the one function both tools should use. They are the same test on every
input a run meets: an equality of two `git describe --always --dirty
--abbrev=8` ids, so a tree measured dirty on purpose under `--allow-dirty`
is served as a clean one is. They differ only when both ids are absent,
which `sameBuild` refuses and the runner's form passed; the tree's id
comes from `git describe` and is never absent.

`buildRefusal` now asks `sameBuild`. frame.test.mjs keeps its cases (the
same id, a clean page under a dirty tree, a page that names no build),
adds the dirty-on-purpose case, equal `-dirty` ids, and holds the two
functions to one answer over all four. 126 of the runner's tests pass.

The runner's cast stages detect the capture's `--lever` by asking its
parser, so they are taken now without a change here: `campaign.mjs start
choices --dry-run --hold page` lists `casts` as seven commands, G6's
casts at `handoverBand` 1, 1.5, 2 and 3 and `clip` 1.25, 1.5 and 2, and
`sun-casts` as three, `sunRamp` 8, 16 and 32 with the cut from E1.

Co-Authored-By: Claude <[email protected]>
`markOverClouds` set a layer and kept nothing, so the only way to learn
whether a frame holds anything over the clouds was to walk the scene, and
the frame walked it a second time every frame to find out. The marks now
keep what they marked, and `overClouds(scene)` answers from them: nothing,
something none of which writes depth, or something that does.

Three things the obvious count gets wrong:

- A marked Group is not a drawn thing. The plumes' group stays visible for
  the page's life over meshes that hide themselves until a valve opens, so
  a count of marked roots reads every frame of a flight as a frame with a
  plume. Only a mesh, line, points or sprite is held, each by its own flag
  and every ancestor's up to the scene.
- A mark has no unmark. An orbit's line is dropped by its component when
  its path goes, so the set holds `WeakRef`s and prunes as it counts.
- The frustum is not tested. An overlay behind the camera counts as drawn,
  which costs a frame its second pass; the other error draws an overlay
  under the cloud it stands in front of.

An object put on the layer by hand is not counted, which is rule 69's one
way to mark. Nothing reads the count yet: the composite's forms do, next.

Co-Authored-By: Claude <[email protected]>
…at scatters

The composite gains a second form next, and two things about the first
were held by nothing (phase 0's council).

Every case set the render compression to 1. A body past the near field is
drawn smaller than life, the depth copy carries that factor and the
history does not, and the fragment divides and multiplies by it in four
places. One slab is now drawn at 1 and at 0.49, Earth's from 20,000 km,
over a scene scaled about the eye, and the two frames agree within a half
float's step in `output`, `motion` and `reactive`, with `motion.z` in
render meters.

The only air any case stood in scattered nothing, so the identity's
(1 − T_c)·L_a(0, t₁) was zero everywhere and could be deleted with the
suite green. One slab now stands in a gray air of constant extinction and
constant source, where the joint medium of air and cloud is uniform and
its march has a closed form: the limit of the 512-sample joint march the
composite error instrument takes. The composite's own segments integrate a
uniform medium's step exactly, so the bound of 1% is the design's and the
rest is a half float's rounding. With the term out of the fragment the
case reads 2.879 against 4.435, 35% low; watched failing that way on this
Mac mini (Mac18,5, Apple M6) before it was kept.

Co-Authored-By: Claude <[email protected]>
…run of the suite

The float64 tracer's walk as a compute kernel, a pixel a thread, imported by
its test alone. It reads the medium, the bricks, the phase's sampled form
and the cone about the sun from the definitions the CPU tier reads, and
draws from the same generator, `xoshiro128**`, which a test holds to `Rng`
state for state.

A path is a state in a storage buffer and a dispatch advances every path by
a fixed count of events. A path through a cumulus's core scatters hundreds
of times and each scattering sends a shadow ray and a chain, so a kernel
that ran a path to its end would hold the device for seconds in one pass,
and a path cut at a dispatch's end would bias the image toward short paths.
One event is one flight in one brick, on the walk's ray, a shadow ray's or a
chain's by the thread's mode, and a sample always runs to its end.

Two things the builder did that the source does not say. A TSL `select` on a
vector of conditions compiles to one branch on `all()` of them, so the slab
test and the distance to a brick's face, which choose an axis at a time, are
WGSL functions; written as vector selects every ray entered the domain and
stood at its face for 4,000 dispatches. And an expression over a variable is
computed where it is first used and not again, so the band's mask and the
mode's flags are variables set at the top of each event.

Always on: the furnace, exact in every pixel of 1,024 from four samples; the
uncollided beam at e^(−τ) in each of some 290 cloudy pixels; one order
through the cumulus against a quadrature of its own field; and every order
against the float64 tracer's 144 committed pixels of the analytic cumulus,
four cases at 1,024 samples, by §5.11's count of how many may stand beyond
three combined standard errors. The six tests run in 8 s on this Mac mini
(Mac18,5, Apple M6). A dispatch is sized to about four million events,
because at 256 events a thread a 32-pixel image spent its run on submits:
318 s for the same tests.

Each was watched failing with its defect put back in the kernel: a vertex
reached along the cone lit by the walk as well, a shadow ray's product a
tenth short, a chain's weight without the pair's worth, a ground that keeps
a tenth of a bounce.

Under IR_CLOUD_MEASURE the file prices a sample at the reference's 256² on
today's cumulus, and holds the reference's own cases to its 288 pixels each
once it has cases.

Co-Authored-By: Claude <[email protected]>
… second scene pass's cost

Placement A draws the scene twice on every frame the clouds draw: pass B
loads all four samples of every attachment, stores them again and resolves
the colors a second time, 185 B a pixel at the default picture, and walks
the scene a second time on the CPU to find what is on the OVER layer. On a
frame with nothing over the clouds it finds the composite alone. The `over`
lever now chooses among three forms a frame, and `passes`, the default,
draws the frame it drew.

`lean` is pass B storing its samples once. After pass B nothing reads a
color sample, only the resolve, so each multisampled color takes
`storeOp: 'discard'` under its resolve target, and where the marks say
nothing pass B draws writes depth, the depth attachment is read-only.
Three exposes no place to say so: it builds the descriptor, writes every
op, makes the encoder and begins the pass inside one `beginRender`, and
the pass timeline's hook runs before the ops are written. So the edit is a
hold two deep, each as short as it can be: the backend's `beginRender` for
pass B's one render, and inside the one call that is the scene target's,
the device's `createCommandEncoder`, whose encoder begins its first pass
from a copy of three's descriptor. Three's own objects are not written. A
pass three resumes after a framebuffer copy loads the samples the edit
dropped, so a second begin on that encoder turns the form off for the
node and says so once.

`chain` is no second scene pass. With nothing marked over the clouds the
scene is drawn once, on every layer, and the composite alone is drawn over
the scene target's resolved rows, in place. The design had the chain's
term hand each reader a node in place of the attachment; the readers are
compute kernels and multi-tap quads (the upscaler, the meter, defocus,
motion, the clouds' own meters), none of which can take a node, and a
target of its own would be 16 B a pixel the phase's memory row does not
have. In place needs neither: a `RenderTarget` whose attachments are
`ExternalTexture`s over the GPU textures the scene pass resolves into, so
every reader reads the texture it reads without the clouds. Three records
no format for an external texture outside its WebXR path, and builds a
pipeline's color targets from that record, so the format is written there
when a row is pointed at a texture. Both forms draw one plane with one
material: one fragment, one blend (`compositeOver`), and the frame node
inside it, so the cloud work and its exception guard are the same code at
either draw.

Held on this Mac mini (Mac18,5, Apple M6):

- pass B and the chain form within one half float's step in `output` and
  `motion`, 1/255 in `reactive`, `meterMask` untouched, at four samples
  and at the temporal rows, on a scene whose edges fall inside pixels;
- a frame bit for bit under `lean`, with pass B's descriptor read off the
  device: every color discarded under its resolve, depth stored when
  something over the clouds writes it and read-only when nothing does;
- through the system's own composite: a marked mesh in front of the deck
  and one behind it drawn over the clouds, an unmarked one behind it
  under them; the frame's form following the lever and the marks; a frame
  whose cloud work throws compositing none of its history in each form;
- the overlay guard's frame, an opaque object in front of the deck and
  nothing marked: two walks of the scene under `passes` and `lean`, one
  under `chain`;
- no pipeline on the first frame of any form, nor on the frame the chain
  form gives way to pass B or takes over from it;
- on, then off, in each form: the next frame is the frame of a chain that
  never had the clouds, bit for bit.

Co-Authored-By: Claude <[email protected]>
Package W (weather/p1-w, 6c2712f) makes the objects drawn through a
cloud see the cloud in front of them (design §10.2). The ring, the plumes
and the entry trace's inks read the trace's knots through the engine's
front handle along their own pixel's ray: the plumes take `color·T`, the
ring and the inks `color·T + L` with their own coverage. Without a handle,
which is every page without `?clouds=1`, each builds the graph it built
on the base. `cloudFront` reads each knot's predecessor once, so a
material pays 5.4 to 11.9 KB of fragment WGSL for the handle where it paid
16 to 37 KB more. `ir.lightEngine` holds a drive lit in front of the lens,
drawn only, so the runner's `overlay` stance has something over the
clouds without the drive moving the ship.

Nothing conflicted: W branched at bd6daea, and none of its seventeen
files changed on this branch since; harness.ts and its test hold U's
first-pass edits from before that base and W's three lines.

Co-Authored-By: Claude <[email protected]>
`weather/phase-1` at `a8d982f5`: the runner (package Q) with its `over`
batch, the slab references, the blue-noise mask and the phase atlas's
second pass, none of which touches a file of the over pass. The figures
the package reports are taken on this merge, so they are the tree the
package joins and not the one it was cut from.

Co-Authored-By: Claude <[email protected]>
…ask's or the gradient's

The trace read the gradient twice, `at(texel).x` for the first step's share
and `at(2·texel + phase)` for the point inside the history pixel, and had no
third number for the handover's ξ. It reads `draw(texel, frame)` once a ray:
`.x` the share, `.yz` the point, `.w` the ξ the march does not read yet.
`CloudJitterNodes` gains `draw`, and the stand-in jitter with it, so a kernel
built over the stand-ins binds the mask as the system's does.

The census moves with the mask's binding, which is in the program whichever
draw the lever takes: the system's trace binds 11 sampled textures of the
stage's 16, four of them 3D, where it bound 10 and three; the stand-ins'
kernel 12 where it bound 11. The jitter holds 65,536 B once a trace is built
over it. `cloudJitter.gpu.test.ts`'s two cases about a trace that does not
read the draw are restated for one that does.

Under `'ign'`, the default, the picture is the gradient's:

- on the stand-ins' broken slab, two traces, one over the field's jitter and
  one over a draw written out of `at`, store the same half floats in all four
  outputs at each of the four phases and at frames 0, 5, 2³¹ + 7 and 2³² − 1
  (`cloudTrace.gpu.test.ts`, 16 dispatches, each a different set of rays);
- on the real field (the system's rig at 96 × 64, overcast and cirrus over
  cumulus, 16 dispatches, 73,728 values of `light` and `aux`), every value
  is equal but one: the blocked air's red at one texel of overcast's third
  phase, −0.0037556 against −0.0037537, one half-float step. Written into
  the outputs bit by bit, the draw's three numbers are identical in the two
  kernels at every texel of those dispatches, so the ray is the same ray and
  the step is two programs' float32 arithmetic differing in a last bit
  across a rounding boundary;
- the rig's frames, hashed over 24 frames at six stances before and after:
  four hashes are unchanged and two move (overcast under a forced reset,
  cirrus over cumulus converging). With the draw written out of `at` in the
  trace all six are unchanged.

So the draw is `at`'s to the bit and the frame is not held to the byte across
two compilations of the kernel: it moves by a half-float step in about one
value of 70,000. Which operation rounds differently was not found; a fused
multiply and add in the first step's length is a guess.

Co-Authored-By: Claude <[email protected]>
The ice rows, the convolution on the pool, the runner, the mask and the slab
references, merged before any figure of this package is taken.

Co-Authored-By: Claude <[email protected]>
…sets

The law's twelve amplitudes, ι and its width are refitted by least squares
to ISCCP-H's zonal table (2007 to 2016): every month of the twelve bands
from 60°S to 60°N, each level's cover taken from above as the satellite
counts it (a level under higher ones only where they are clear, random
overlap), the total weighted twice, each band by its area, each month at
the sub-solar latitude of its 15th, with the synoptic factor integrated
over its spread. Positive amplitudes are held as a bound.

The plan's targets did not all match the data. 20°S is 0.07 to 0.08 under
the mean, not 0.15; the equator is 0.01 over, not 0.10; the global mean
is 0.6475, not MODIS's 0.675. The old law missed the band totals by up to
0.30 (the 80°S band) and 0.26 inside 60°S to 60°N (30°S to 40°S).

Old: base 0.4718 0.2595 0.3538, itcz 0.0306 0.0168 0.023, dry 0.3741
0.2058 0.2806, storm 0.3551 0.1953 0.2663, ι 0.3, w 8°.
New: base 0.2867 0.1482 0.0873, itcz 0.0545 0.0691 0.2424, dry 0.0308
0.063 0, storm 0.3355 0.2587 0.1742, ι 0.2975, w 13.84°.

The refit's residual: global 0.6403 against 0.6475; no band from 40°S to
40°N more than 0.051 off; 40° to 60° are 0.046 to 0.070 under in the south
and 0.062 to 0.068 over in the north, which a law symmetric about the
equator cannot split; month by month the total is 0.056 RMS off and 0.146
at worst (August, 30°N to 40°N). Two starts converge to one fit. κ and the
Hadley edge are not fitted: the table counts cover, not convection.

weatherClimate.test.ts's first zonal test keeps its intent, the law's own
figures at an equinox: mean 0.675 → 0.6445, the equator's offset 0.10 →
0.0026, 20°'s −0.125 → −0.1179, 60°'s 0.20 → 0.1208. Its MODIS ranges
give way to ISCCP-H's offsets, and the high level's dry amplitude is
allowed to be zero, where the fit puts it.

Co-Authored-By: Claude <[email protected]>
The altocumulus regime stood 800 m thick, outside its genus's 100 to
400 m. Held to ISCCP-H, the range was right and the regime was wrong:
over 40,000 resolved columns of the field at the deck's 0.7 of cover, 400
to a 5 km pixel, the detected pixels' radiative mean depth (the black-
surface flux at μ₀ 0.7 from the slab oracle, averaged and inverted) is
1.329 at 400 m against ISCCP-H's altocumulus 1.373, −3.2%; at 800 m it was
2.283, +66%. Both thicknesses put over 93% of the detected pixels under
3.55, so the genus's class row holds either way; only the mean decides.

Measured at 300, 400, 500, 600 and 800 m: 1.053, 1.329, 1.592, 1.827,
2.283. 400 m is the range's top and the nearest to ISCCP-H inside it.

`altocumulus` and `dusk-altocumulus` share the deck, so G3 moves. On the
cornerstones' clauses (`cornerstoneSolve.ts` on weather/phase-1), G3's
share of columns under the full deck holding cloud (τ ≥ 0.3) falls from
0.771 to 0.625 against its floor of 0.5; its edge (96 km), its clear slot
(110 km) and every other clause are unchanged. The base and the sun's dip
under it are unchanged, so the ledger's sun clauses are too.

`two-decks` keeps its 800 m deck: it is a measurement regime phase 0's
ladders priced, not a genus's typical cover.

Co-Authored-By: Claude <[email protected]>
…ure flag

The composite's forms had no figure of any kind before the campaign's
`over` batch, which needs the machine whole. Under IR_CLOUD_MEASURE=1 the
over pass's GPU test now times each form's frame on the pass timeline at
1920 × 1080 and 2880 × 1800 and writes `.data/clouds/overForms.json`. It
is not a campaign figure: the scene is the rig's one plane under the deck,
on Node's WebGPU, with no page, compositor or presentation, so it says
which way a form moves the frame and roughly how far at a size, and
nothing about a stance.

Two runs on this Mac mini (Mac18,5, Apple M6), 40 frames a row, GPU busy
time over the clouds-off frame, ms:

                        1080p          2880 × 1800
  passes                3.09, 3.11     5.49, 5.51
  lean                  2.93, 2.96     4.99, 5.03
  chain                 2.68, 2.66     4.18, 4.13
  passes, one overlay   3.18, 3.18     5.62, 5.60
  lean, one overlay     2.89, 2.90     5.03, 5.02

`scene over clouds` is 1.44 and 3.70 of `passes`; the chain form's
`cloud composite` in its place is 0.90 to 0.92 and 2.23 to 2.25, which is
the composite's own fragment with the break gone. The overlay is one
blended ball that writes no depth, so `lean`'s depth is read-only there.

`leanDescriptor` is the over pass's own and is no longer exported.

Co-Authored-By: Claude <[email protected]>
…t with every page's worker and main chunk

`render.convolvePhase` imported the committed droplet and ice tables
statically, and its file is in two bundles every page loads: the universe
worker, and the main chunk, through `atmosphereLuts.ts`. Measured with
`pnpm build` at e62db00 on this Mac mini (Mac18,5, Apple M6), shared with
other packages' builds: the worker chunk was 606,778 bytes raw and 345,261
gzipped (`gzip -9`), and the main chunk `App.*.js` 2,437,409 raw and
881,085 gzipped, both holding the tables, on pages without `?clouds=1`
that never ask the task.

The task now reaches the tables through `import()` of `phaseTables.ts`,
on its first ask, and keeps the module; a failed load is not kept, so the
next ask loads again. Vite builds the worker as ES modules
(`worker.format: 'es'`), which splits a dynamic import into a chunk of its
own with no change to the build's configuration. The module holds the
decode and the convolution itself rather than only re-exporting them: a
chunk of nothing but re-exports carried no source map, and
`requireSourceMaps` refused the build.

After, the same build: the worker chunk is 146,767 raw and 56,590 gzipped,
against 146,487 and 56,490 before the convolution existed, and holds no
table. The tables are a chunk of their own in each bundle:
`phaseTables-*.js`, 460,162 raw and 286,958 gzipped, imported only by the
task's `import()` in the worker; and in the main build `iceTable.*.js`,
460,316 raw and 286,983 gzipped, imported statically by the cloud
system's chunk and by the main build's `phaseTables.*.js` alone, which are
themselves reached only by `import()`: the cloud system's from
`withClouds` in `App.tsx`, under `?clouds=1`. No page's HTML names
either, and the service worker precaches no chunk. The main chunk is
1,977,162 raw and 593,230 gzipped and holds no table.

The first ask pays the module's load and the decode once, in the worker:
59 to 66 ms in Node against 33 to 56 ms for the asks after it (load
average 15). The chunk's fetch in a browser is not measured. The atlas
keeps the table it has until the answer lands, as before, and the main
thread's share is still the ask and the upload.

A test counts the tables' module's loads through its mock's factory: none
when the registry is built, one across two concurrent first asks, with one
decode. Imported statically again, it fails.

Co-Authored-By: Claude <[email protected]>
…map holds the cover alone

The orchestrator's ruling: eleven megabytes, a second texture bound in the
trace and a fifth read a step are too much for a field that varies over
twenty kilometers. Each wave's phase is linear in a sample's offset,
`θ = θ_eye + k·(M·offset)`, so from one call of the fine medium to the next
it moves by `k·(M·Δoffset)`. The six waves' sines and cosines are carried
from call to call in invocation-wide variables and turned through that step
by their Taylor series to x⁹ and x¹⁰; a call in another level, or more than
1.5 rad from the last, starts over from sines (two of each over three waves
a vector, once a level a ray). The march's longest step is 1 km and its
farthest tap 800 m along the sun, so two calls are at most 0.67 rad apart at
a 1,000 m cell and 1.33 at fog's 500 m, where the series' first omitted
terms are under 3e-10 and 2.2e-6.

Measured on this Mac mini (Mac18,5, Apple M6, 32 GB): over 960 calls, 192
steps of 1 km each with its four taps, the carried displacement is within
8.4e-6 of a cell at 1,000 m and 2.1e-5 at 500 m of the float64 sines, so it
needs no renormalization. The oracle improves without the clipmap's
interpolated displacement: median 1.5e-4 to 2.8e-3 and p99 5.0e-4 to 6.2e-3
of σ′ over the three stances, three regimes and the far media, against
1.08e-2 before; the taps on a ray's own chain 3.4e-3 at p99; E1's tile peaks
at 0.249, as `cloudFieldAt` does. With the rotation's sign flipped every
chained test fails, the frames' opacity by up to 1.0.

The clipmap is one RG8 texture, a layer a cloud level, cover and convective
share: one binding and one fetch a step (two in a fade band), 2.36 MB where
the first pass held 14.16 MB and the design 3.15. The trace binds the 10 it
bound before the port.

Named regimes are laid out as the field lays them out: `weatherLevels` takes
every level's numbers from `levelProfile`, a regime's as a fitted climate's,
so the frame draws the weather `cloudFieldAt` describes. Against the
scenarios' own numbers σ′ falls 11 to 48% (overcast 0.057 to 0.0298,
fair-cumulus 0.068 to 0.0428), the radius rises (cumulus 8 to 13.3 µm), and
broken-horizon and inside take their genus's cell and erosion.
`cloudFrame.test.ts` holds every regime's frame to its profile, and the
density test's regimes run through `drawnWeather`, the frame's own path.

Co-Authored-By: Claude <[email protected]>
…id, cut at the grid's own resolution before it is taken

Merging phase 1 brought package D's second pass, which displaces the noise by
six long waves, and three things that held on the field before it did not.

The generator's search took the largest cloud of its lattice of columns that
fit the grid, and on the new field that cloud ran out through the grid's
faces: 177,270 cloudy voxels in one body from the east face to the north
one. Two clouds the lattice sees apart at 80 m can be joined by a bridge
narrower than its spacing. So the candidates are tried largest first and
each is cut at the grid's 20 m before it is taken, which costs a place 5 s
where it cost 3.4 s.

`isolateCumulus` kept the body that held the cloudy voxel nearest the
grid's middle, which is the right cloud only while the middle is cloudy. It
keeps the largest body that no face cuts, and a grid is refused unless that
body is at least half of the cloud in it, so a scrap beside a cut cloud is
not taken for the subject.

The fixture's test wrote its place down, and the place went from 2,000
cloudy voxels to 51: its own claim, that a reference cannot go stale in
silence, shown on itself. It searches a 19 km square for the place with the
most cloud, and takes its base and its other thickness from the level, so
package G's calibration does not move it again.

On the merged field the search finds a cumulus with a deepest line of sight
of 87.3 and a congestus of 83.9, each with all 288 pixels in every view.
Sixty-four samples of a case trace in 1.7 to 2.4 s of one core (this Mac
mini, Mac18,5, Apple M6, beside other packages' builds), so a case's 4,096
are two to three minutes.

Co-Authored-By: Claude <[email protected]>
…m, and takes R1's two figures itself

Package R1's oracle is merged, so a slab is held to it as the design asked,
beside the closed forms, which stay. Three committed rows of
`SLAB_REFERENCE` in the gate, 10 µm and 16 µm, reflected and transmitted,
at R1's own bound for its Monte Carlo, three standard errors and the half
percent its streams converge to: the tracer is 0.02, −1.5 and 1.0 of its
errors from the oracle, with errors of 1.9% to 3.0%. The two share no code
and not quite a phase function: the oracle reads the Mie series at the
radius itself and the tracer blends two rows of the half-float table.

R1 measured two things of the renderer's scaled medium against the true
one, and the tracer takes both in a slow test, tens of seconds of a core:

- Where the scaling is worst in the rubric's domain, 8.93% (6 µm, 680 nm,
  τ 5, transmitted 6.4° from the sun): 0.1795 ± 0.0025 against the oracle's
  0.1837 on the true medium and 0.2001 on the scaled one. A second seed at
  the same count gave 0.1831 ± 0.0029. That direction is inside the
  tracer's cone, so the light is an eye's chain.
- The glory's red ring over the trough inside it, 10 µm at τ 10 from
  straight above, a point sun: 1.068 ± 0.007, and 1.064 ± 0.006 from
  another seed, against R1's 1.061 ± 0.002 traced, 1.060 by the oracle and
  1.139 on the scaled medium.

So the tracer stands with the true medium both times and is eight and ten of
its errors from the scaled one.

The flux balance takes half the views it took: the reworked chains hold it
to 1.4% from 20,000, and it was the slowest test of the file at 7.9 s.

Co-Authored-By: Claude <[email protected]>
`weather/phase-1` at `7e51edb0`: the ring, the plumes and the entry trace
read the cloud in front of them, in pass B's list. Each is marked over the
clouds, so a frame that draws one is a frame the marks count, and the
chain form gives way to the two passes for it. Package Y's tests run
again on this merge, so the forms are held against the world they ship
with.

Co-Authored-By: Claude <[email protected]>
The warm-up compiled the clipmap's bakes with `warmSensorPass`, which
builds a program for a four-channel output; an RG8 target's draw writes a
vec2, so the first frame built the three pipelines of level 0's layers
again (cloudWarm.gpu.test.ts, 'the defaults builds no pipeline'). The
volume's RG8 bake already warms by drawing (`warmByDrawing`), and so does
this. A warm-up after a bake draws over level 0's low layer, so every level
is owed again then.

Co-Authored-By: Claude <[email protected]>
…ion's first ask

Package T1's third pass (weather/p1-t1, 64cbe22) moves the committed
droplet and ice tables out of the two bundles every page loads. T1's
second pass imported them statically into `render.convolvePhase`, whose
file is in the universe worker and, through atmosphereLuts.ts, in the
main chunk: the worker grew from 56,490 to 345,289 bytes gzipped
(a2e3e3f to a6081d6), and both chunks held the tables on pages without
`?clouds=1`, which never ask the task. The task now reaches them through
`import()` of the new phaseTables.ts on its first ask, and keeps the
module; a failed load is not kept, so the next ask loads again.

Nothing conflicted: T1 branched at e62db00, and none of its three files
changed on this branch since. No join.

Co-Authored-By: Claude <[email protected]>
weatherCalibration.test.ts holds the rubric's rows 9, 10 and 16 on the
resolved CPU field, each where it passes and each miss at its measured
figure, so a change that makes a miss worse fails and one that cures it
asks for the declaration to go.

Row 9 lays each genus at its row's cover over the thickness its regime
gives it: 40,000 `columnDepth` columns at 500 m, 400 pixels of 5 km. A
pixel is the mean of its columns' black-surface reflectance from the slab
oracle (`SLAB_REFERENCE.flux`, μ₀ 0.7, read in ln τ, linear to zero under
0.1 and two-stream past 100), detected at 0.03, inverted through the same
law; a genus's mean is its detected pixels' reflectance averaged and
inverted, as ISCCP-H averages a type. A linear mean is what the plan
forbids: for stratus ISCCP-H's two are 43.66 and 50.66.

Passing: cumulus's shares (0.978 under 3.55), stratus's over 3.55 (0.935),
altocumulus (1.0 under, mean 1.329 against 1.373), altostratus at 900 m
(0.923 in class, mean 8.785 against 8.537), cumulonimbus (0.93 over 22.63).
Declared: stratocumulus at its range's top, 500 m, 0.4075 in class against
0.60, and 19 points between the two suns; stratus at its top, 700 m, 0.0075
over 22.63 against 0.30; cirrus, no pixel seen (largest column 0.146);
the means of cumulus −30%, stratocumulus −55%, stratus −80%, cumulonimbus
+125%. The resolved field's in-cloud extinction is about half each
genus's σ, which is why the low decks are thin.

Row 10 labels fair-cumulus's cloudy columns (τ ≥ 0.3) over a 60 km square
at 100 m and fits n(D) ∝ D^−α by maximum likelihood on 200 m to 2 km:
α = 1.23 over 443 cells, under Mieslinger's 2.19 ± 0.4. Declared; the cure
is finer octaves in the base noise, a mechanism. The fit itself recovers
2.19 from draws of that law.

Row 16 is held as far as the climate carries it, the law's drawn cover
before any pixel: global 0.6403 against 0.6475; seven bands past 0.05
declared at their figures (three polar, and 30°S to 60°S and 40°N to 60°N,
which a symmetric law cannot split). The detected count, land and ocean
are phase 3's, with the land mask.

Each was watched failing: the altocumulus deck back at 800 m fails its
mean (+66%), and the old zonal law fails the bands (0.30 at 80°S).

The file takes 40 to 57 s on this Mac mini (Mac18,5, Apple M6) alone,
nearly all of it the 280,000 row-9 columns and the 360,000 row-10 ones.

Co-Authored-By: Claude <[email protected]>
The chain form draws into the GPU textures the scene pass resolves into,
through a target whose attachments are external textures over them. A
resize makes the scene target again and its textures with it, and three
caches a target's attachment views by size alone, so a form still pointed
at the textures it first found draws into ones the pass has left.

The case draws a frame, doubles the renderer's size and draws two more,
through a stand-in for the composite that adds a quarter of blue. With the
re-pointing taken out the device answers "Destroyed texture [Texture
"output"] used in a submit"; watched failing that way on this Mac mini
(Mac18,5, Apple M6) before it was kept.

Co-Authored-By: Claude <[email protected]>
jonjaques and others added 23 commits November 12, 2026 22:59
… sun

The shipped sun forms `CloudSun.depth` only for a sun built to carry it,
in its own block, and a read of a depth nobody asked for throws as the
program is built: the depth reaches the ray's far end, a fetch of the
grid's own, and a march that reads `cloud` alone keeps its two. The
march forms its sun with `{ depth: true }` and reads the depth beside
first order's transmittance, into one variable of that block, which a
resolved step and a statistical one's two points read from branches
under it. The depth test asks the same way.

Through the RG16F grid's depth channel, under an overcast with the sun
37.5° up, the depth to the sun is within 5.5% of the CPU field's march
from 1 to 21 and the whole within 8.4%, where the opacity cell read 5.6%:
the mean depth of eight cells stands over the march by 0.4 to 1.6 in the
deck's upper half and under it by 0.5 to 0.9 in its lower. The test's
tenth and 0.3 hold at 73% of the bound at worst, at samples with taps and
at samples the early out skipped.

The comment at `CloudSun.depth` said both depths came from the one
opacity cell. It quotes the depth channel now: 1.46 to 2.90 in RMS and
-0.20 to +0.87 in the mean through four taps, in the broken levels of the
sun instrument's union (`cloudSunAccuracy.landed.json`).

Co-Authored-By: Claude <[email protected]>
…he volume without its 50 m level

docs/adr alone: ADR-0064's amendment for L's fourth pass. The sun's grid
is RG16F, opacity and depth from one bake and one fetch; the volume holds
the 200 m and 800 m levels; the far crossing's floor quotes the pin's
figures. Nothing under apps/ or packages/.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
skyRowsOf weighs the gas's and the haze's columns, and where both are
zero it answered NO_SKY_ROWS, so every height read row 0. Such an air
still has a sky, lit by its detached layer and its ground: over a layer
at 3 km with no gas and no haze (Sol's probe), the read at 11% of the
air under a sun at 15/31 was 3.4% off on the mean, 0.049 on Delta and
0.017 on Delta_s.

The fallback is the same closed form with one column 64 air depths
tall (SKY_EVEN_SCALE), so the rows stand within 1% of evenly in height
and the last stays 1/64 under the top, and the bake and both readers
share it with no new branch. At the same point the read is now 0.43%,
0.0146 and 0.0012 off, the worst band of each, measured on the Mac mini
(Mac18,5, Apple M6). The regression test fails on the old mapping, where
one cell spans the whole air. On the GPU the form is unchanged; with
a = 65.5 and b = 1/64 a float32 read is within about 6e-5 of a row.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
…der 1.9

Delta under 1.9 does not say light comes down on a face: at the air's
top, where E_above is zero, every band at every sun tested passed it
(Sol's probe). The test now bounds the upper side's own irradiance over
pi L, 1 + Delta/2 + c, above 0.005 at the last row. It measures 0.011 to
0.24 there at suns of cosine -0.1, 0.3 and 0.9 on the Mac mini (Mac18,5,
Apple M6), and 0 at the top.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
`weather/p1-sky-rows` at 7328def lays the table's rows evenly in the
air's optical depth and adds the `upper` block. At 1.7 km under the
reference's suns its read now stands within 0.7% of the quadrature's
mean and 0.003 of its Δ, where the committed cases' `sky` stood 4.6% to
17.8% off. Nothing it changes is read by the sky by direction or the
quadrature's moments, so no block of the reference moves; the merger
takes the two branches together.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
…ew, not to the table as it reads now

`cumulusTables.slow.test.ts` held each committed case equal to a fresh
`fieldCase`, which reads the sky table at 1.7 km. With the table's rows
even in the air's optical depth (weather/p1-sky-rows) that read moves
4.6% to 17.8% in the mean, and the hosted slow stage went red there.

The case's `sky` is the table's read when `probes`, `scaled` and the
table's sky block were traced, and those are traced again under it in
the same test, so it is a record of what they were lit by. The sky term
is judged under the air's own sky and the linear sky on the
quadrature's moments (ruling 007), neither of them the table's. So the
test holds the case to the search and the view in every member but
`sky`, and holds the linear rows' moments to the quadrature's at the
case's height and sun, as they are taken now. The slow stage passes on
the combination: 119.9 s on the Mac mini (Mac18,5, Apple M6).

Co-Authored-By: Claude Opus 5.5 <[email protected]>
skyRowsOf normalized the gas's and the haze's columns as they stood.
At a thickness of 1e-322 both are subnormal, and the whole and the last
row's 63/64 of it rounded to one number, 1.5e-323 (Sol's re-check), so
the inverse placed row 15 at the air's top, where no light comes down.

Only the columns' ratio places the rows, so they are weighed against
the larger before the whole is formed, and the even fallback takes any
air whose last row still fails to stand under its whole. Earth's and
the cornerstones' world's rows are unchanged to the printed figures; the
regression test, at that thickness, fails before the change with the
last row at share 1.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Sol's review: `airSkyRadiance` at height 0 took a downward ray's ground
hit at no distance as no hit, so straight down under a sun 15 degrees up
it returned black where the bake's march reads 0.00861, 0.00775,
0.00693. On the datum a ray aimed down starts in the ground, which the
bake lights at the point's own sun cosine with no air between; this
does the same. A datum test holds that ray and the moments of every
direction there to `marchSkyMoments`, and failed before the fix.

The reference's cases stand at 1,700 m, where nothing changes: both
generated files rebuild byte-equal.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
The subnormal columns' last row, the air with no column, and phase 1 at
9071504. None of it reads the quadrature's directions or moments at
the reference's height, so neither generated file moves.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
…sky split at the level met

Six items from ruling 009, with ruling 008's standing lines for the
briefs that follow.

§5.1's sky gave a point the whole datum sky by the cover over it, and
under an air about half that sky is made under the level, by the beam:
the critic of R-C1 read a deck's thrown shadow +60% to +90% at 30° and
kilometer cells' dark third +12% to +20%. The sky's line is now R-C3's
form a, split at `h_b`, the base of the level the sun meets, with the
part made under it lit by `B̄`. No form met every bar; a is the best
measured (dark thirds −6.3% to +10.7%, the thin high level +1.0% and
−0.2%, the mean within 2.1%), and "What it still misses" declares the
deck's thrown shadow (+19% to +36% a kilometer inside it at 30°), ground
200 m under a base (−10.6%), and R-C1's 35 of 36 as a figure under a sky
made wholly over the cloud. Split at the cumulus's base under a cirrus,
the mean reads −5.9% and −9.2%, so the light map's fourth channel names
the level met, and each ray's deposit lies at its own in-cloud centroid
(laid at the middle height, a dark third moves +14.9% to +19.0%).

§4.1 and S hold the map's mean within 0.004 over texels whose oracle is
under 0.1, since each 0.004 of beam in an umbra moves a dark third 0.9
to 1.5 points. §4.2 judges L2 at the level's scale by the larger of 10%
and 0.01 of the beam: by footprint no single number meets 10% (a 12 km
place of broken cumulus holds 0.45 cloudy where its level holds 0.38),
and the one miss at the level's scale is 0.009 of a beam of 0.065. A
level's mean takes 30,000 rays (8,192 read +16%); the atlas's handover
is measured at S6; S may feed a texel its own share.

`Ā` is declared at 6% on dark ground 1 to 4 km past a snow line; H adds
no light to shadowed ground and measures the return's gather by band
(1.9 to 4.4 points through a coarser level). §7 gains R-C3, the critic's
re-check, R-S, and R-G's place in the order.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
… second round

Six sentences the ruling did not name now disagreed with its items or
with round one's.

§3 still picked the light map's levels at `log2(h/250 m)` where §5.1
picks at `+ 0.75`, which two bilinear levels need to come within 0.025
RMS of the kernel. §5.1's "`F` and `E_sky` at two heights" now reads the
sky at a third, `h_b`. Its "Who proves it" named R-C1 and R-C2 alone,
where the form is now R-C3's under the critic's air and waits on the
critic's re-check. V waited on R-C1, where ruling 009 has it wait on
R-C3's channel, phase 1's landing, K's census, S and O's block. H waited
on R-E, where its sky rows are R-E2's and its form waits on the re-check.
§12's register held L2 at 10% over a 10° sun, where the bar is now the
larger of 10% and 0.01 of the beam at the level's scale.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
design.md alone: the sky split at the level met, and a second commit that
brings the sentences the ruling did not name into agreement with it.
Nothing under apps/ or packages/.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
…er the air's own sky

The sky table's rows stand where the sky changes: skyRowsOf maps a
height to a row by the gas and haze columns, the last row stands under
the air's top, and an air with no columns falls back to rows even in
height. The cloud sky node hands on three moments (L̄, Δ, c) through one
more vec4 uniform. The cumulus reference is regenerated under the air's
sky by direction, with the linear sky and the committed block kept in
cumulusLinearSkies.generated.ts, and the slow test holds each case to
the search and the view rather than to the table as it reads now.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
…ith c, and the reference under the air's own sky

The sky's term reads `c` from the sky table's alpha, which the sky's rows
give, and its gate compares scattered light against the reference's two
blocks, which R2's fourth pass gives: neither is on this branch before
the merge. No conflict.

Co-Authored-By: Claude <[email protected]>
…it thickens, and the system reads the sky table

The sky's light on a cloud leans the sky's mean toward the side a column
is nearer, and at a deck's face that lean is the side's irradiance over π
only under a sky linear in direction. The air's own sky is a band at its
horizon: each side's irradiance is under the linear sky's by c, the same
number at both, -0.37 to -0.39 of π·L̄ under a 15° sun and -0.16 to -0.20
under a 45° one. On 72 slabs under that sky, against a path tracer, the
term with c·s is the nearer on every one (RMS 41% for 65%; +2% to +10% on
a deck 10 and 30 deep under a 45° sun for +17% to +82%), and on two
cumulus it is the farther on 19 masks of 24: a deck without edges takes
the sky through its two faces, and a cumulus takes the horizon's band on
its flanks. So the term is (1 − v)·c·s, v the column's cumuliform share,
which the factor of the sun reads too, and a cumuliform column is the
lean and the flux to the bit. The `transport` lever turns the factor off
and leaves the sky its share.

c is the sky table's fourth number a band, in its blocks' alpha, so it
costs no byte and no fetch. The contract's sky carries it, the sky node
hands on what the table's read returns, and the term is a pair of twins:
`skySource` in `cloudMix.ts` and on the CPU in `cloudOverlap.ts`. The
node is its CPU reference to 2.0e-7; through the march a slab's sky light
is that reference summed along the ray to 0.056% of the sky's mean, and a
deck 4,000 deep reads each side's irradiance over π to 0.45%. From the
table's own four numbers the two faces are the quadrature's two sides to
0.77%, where the lean alone reads the upper side 18% to 200% high.

The system's trace is built to read the table, its thirteenth sampled
texture, and `CloudSystemDeps.skyTable` builds it without: the frame the
term's cost is taken against, which the cost instrument takes under
`IR_CLOUD_COST_SKY=ambient`.

The cumulus gate compares the light a cloud scatters with the light a
cloud scatters, by mask: the sky seen straight through a rim is half its
pixel and no part of the term. Under the air's own sky by direction, the
march reading the table's four numbers, a rim and an edge read half the
tracer's light toward a 15° sun and away from it (-46% to -53%), a core
+95% and +105% toward it and -34% and -39% from behind, and every mask
within 10% across a 45° sun. Under the linear sky on the quadrature's
moments, the term's own, rims, edges and bases are within 16% and the
cores stay +50% to +54% and -42% to -46%: the view term's, declared.
Each mask is held at its figure. Row 6 reads as it did, 0 of 6 cases and
30 and 24 measures, its sun's parts against the block `rest` was traced
under.

Co-Authored-By: Claude <[email protected]>
…s, on the step's own weights

The sky's source leans linearly with the column's depth under a sample,
which a ray crosses in step with its own, so across a step it is a ramp
and the ramp's integral is exact. The log-linear rule the sun's light
takes is exact for a source that falls exponentially, which the sky's
does not, and takes two logarithms a band. The ramp reads the step's
transmittance and its far end's weight, which the sun's light past first
order forms already: `stepWeights` forms them once for the two.

Through the march the sky's light is its CPU reference summed along the
ray to 0.056% of the sky's mean, as it was, and rows 1 and 2 and the
furnace read as they did. By one take against three the frame is 0.04 to
0.09 ms the cheaper on five rows of eight at 1080p and unmoved on three:
the logarithms are not where the sky's term spends its time.

Co-Authored-By: Claude <[email protected]>
…the ramp's figures

The system's trace reads the sky table, so the design's count of what it
binds as built is thirteen sampled textures, with the twelve a system
built without the sky's term binds beside it, and the sky term's row of
what an addition costs is a read of three blocks a segment and five
registers, where it said one fetch and one.

The cumulus gate's figures for the sky's scattered light were measured
through the log-linear step. Through the ramp they move by 0.3 points at
most, inside the margin, and the test now holds the figures it draws.

Co-Authored-By: Claude <[email protected]>
…e of an unread table is taken on a trace built without the sky's term

The system's trace reads the served air's sky table, so a chain with the
clouds asks the device for one texture the clouds did not ask for before:
on the airless rig its stand-in of one row, 816 B, and under an air the
body's own 102 × 16, which the air owns and the design's budget counts.
The census names it, 2,456 undeclared bytes where it held 1,640.

The premise that a table on the air's bundle costs the graphs that do not
read it nothing was held on the trace too, while no graph read the sky
table. The trace reads it now, so the premise is taken on the five other
sites and on a trace built without the sky's term, where stripping the
table still moves no WGSL and stripping one a graph reads still throws.

Co-Authored-By: Claude <[email protected]>
…, not the figure one adapter read

The ramp's node stands off its CPU reference by 5.0e-4 of the larger end
times the depth on the Mac mini and by 8.1e-4 on the hosted adapter, under
a bound of 1e-3 written from the first figure. What limits it is
`1 − e^(−τ)` in float32 at the thinnest step tested: one step under one,
1.2e-7, over a depth of 10⁻⁴ is 1.2e-3. The bound is 2e-3 and names it.

Co-Authored-By: Claude <[email protected]>
…rm share

The march blends the factor of the sun and the sky's two sides' mean by
a column's cumuliform share, and reads it from the climate's uniforms,
which hold a regime's one share a level. Earth's own climate is a zonal
law whose share varies by place, and the field's medium computed it at
every column and did not return it: under a zonal or a measured climate
every column was lit as stratiform. A cumulus under a 15° sun took no
factor, 1 for 1.38, and the sky's term took the sides' mean off it, which
is the form a cumulus is the worse for on 19 masks of 24.

`recipe` returns the share it already holds. At 20° of latitude on the
rig's Earth, where the law gives the low level 0.82 and the middle level
0.41, the medium's share is the climate's to 0.0019, a half step of the
clipmap's eight bits. The march over the shipped medium is then the march
told that share outright to 0.01% in the sun's light past first order and
in the sky's, where the march told none stands 31% off in the first and
14% to 44% in the second. With the line out the medium holds no share and
the march is 23.7% off the one told the climate's.

Co-Authored-By: Claude <[email protected]>
…'s term on

The march lights a cloud past first order: the sun's light through the
slab's two faces by the medium's convective share, and the sky's term
(1 − v)·c·s read from the sky table's moments, on by default
(ruling 012); CloudSystemDeps.skyTable builds the system without it.
The trace binds thirteen. A medium hands the march its column's
cumuliform share (recipe in cloudDensity.ts), so a zonal or measured
climate's cumulus takes the factor and the sky's term. SLAB_SOURCE and
stage three go; cloudOverlap.ts is the CPU twin. The device's census
names the sky table: 2,456 B undeclared where it held 1,640.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
…600 m until package X retakes it

Since the light after first order, the fine march the far comparison
takes as its reference carries every order and the far atlas first
order alone. The reference's mean light rose 1.4 to 36 times, so every
footprint radiance figure is now relative to a light the far march does
not draw. No footprint transmittance moved in the twelve cases.

Four figures passed their bars (ruling 014), each now declared at the
figure of one measured run on the merged tree, rounded up, with the
landed bar beside it:

  cirrus over cumulus at 1600 m, the atlas      1.0355 (bar 0.991)
  cirrus over cumulus at 1600 m, the handover   1.0355 (bar 0.991)
  broken cumulus at 1600 m, the atlas           0.9573 (was 0.8468)
  broken cumulus at 1600 m, the handover        0.9136 (was 0.8269)

No other entry moves, the 13 radiance figures that fell keep their
ceilings, and cloudFarCompare.landed.json is phase 0's record, which X
retakes with the instrument.

Footprint radiance, atlas / handover, at 9cea4c2 and on M2's merge:

  cirrus over cumulus at 400 m   1.933 / 1.933 -> 1.210 / 1.198
  cirrus over cumulus at 800 m   1.206 / 1.206 -> 1.071 / 1.068
  cirrus over cumulus at 1600 m  0.970 / 0.970 -> 1.035 / 1.035
  broken cumulus at 400 m        1.120 / 1.120 -> 0.984 / 0.949
  broken cumulus at 800 m        0.927 / 0.925 -> 0.960 / 0.918
  broken cumulus at 1600 m       0.801 / 0.784 -> 0.957 / 0.914
  anvil at 400 m                 0.419 / 0.430 -> 1.006 / 0.998
  anvil at 800 m                 0.687 / 0.693 -> 1.011 / 0.992
  anvil at 1600 m                1.139 / 1.146 -> 1.030 / 0.986
  grazing at sunset at 400 m     0.243 / 0.782 -> 0.401 / 0.615
  grazing at sunset at 800 m     0.891 / 0.129 -> 1.074 / 0.091
  grazing at sunset at 1600 m    1.830 / 0.372 -> 1.764 / 0.338

Co-Authored-By: Claude Opus 5.5 <[email protected]>
@jonjaques

Copy link
Copy Markdown
Owner Author

Note

🤖 Claude Opus 5.5 responding on behalf of jonjaques

The light after first order (M2), merged as 370ea92

G1, fair cumulus from the ground under a high sun:

Before (9cea4c2) After (370ea92)
G1 before G1 after

The clouds go from flat dark slate to lit white cumulus with gray undersides.

E1, cumulus from orbit:

Before (9cea4c2) After (370ea92)
E1 before E1 after

The cloud field goes from dim slate patches barely separable from the dark ocean to bright white cells that stand out sharply against it.

A blind look round on these plates is running; its findings follow.

jonjaques and others added 2 commits November 13, 2026 02:30
`capture.mjs` takes E1's and E2's deck on every run and has no flag to
leave it out, so every experiment record holding E1 or E2 carries two deck
plates. `gather` set every plate under `--experiment` in the experiment arm,
and `checkArm` refused the first deck there: round 1 of the look council
could not show the sun-off experiment beside the candidate.

Under `--experiment`, a deck plate is now skipped when its record holds a
volume plate beside it. The deck's picture is already the deck arm's, taken
from the baseline or `--deck`, so nothing is lost. A record whose only
plates are decks forms no experiment and is still refused by its first
deck, by name, as before. Every other refusal stands: a plate of any other
role under `--experiment`, a wrong rig, stance, fixtures or processing.

The second test passes on the unfixed code, since it holds behavior the fix
keeps; it fails against the obvious fix that skips every deck, which builds
an empty experiment silently.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
… deck plates to the deck arm

scripts/panel alone: packet.mjs and its test. Tooling for the look
round; nothing under apps/ or packages/, nothing drawn.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
@jonjaques
jonjaques marked this pull request as ready for review November 14, 2026 17:49
@jonjaques
jonjaques merged commit c34cd9f into the-weather Nov 14, 2026
3 checks passed
@jonjaques
jonjaques deleted the weather/phase-1 branch November 14, 2026 17:50
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant