Repository navigation
Conversation
Package R1's first pass (20d0106 on weather/p1-r1, merged by SHA because R1 continues on that branch) is the light's references under apps/ingest/src/transport/: an adding-doubling oracle that solves a cloud's slab and agrees with PythonicDISORT and iadpython, a backward Monte Carlo that checks it, the oracle's interior as a source table, and the generator that writes slabReference.generated.ts, slabSource.generated.ts and cloudOctaves.ts, two whole runs of which are byte-equal. The tables say the scaled medium and three terms both miss. Nothing drawn reads them yet. Nothing conflicted: R1 branched at 78f6b3e, and none of its twenty files changed on this branch since. R1 widened the shapes of `SLAB_REFERENCE` and `SLAB_SOURCE` inside its own files, where C left stubs. Co-Authored-By: Claude <[email protected]>
…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]>
…ery thread at work The instrument traced sixteen samples of a 256² view to their end and timed it, which prices a run by its one deepest pixel and says nothing of the rest: a thread holds one pixel, so a pixel through the core of today's cumulus, a line of sight of 87, is still walking when 57,000 pixels of clear sky have long been idle. It traces each view for 20 s with no last sample, so every thread works for all of it, and a pixel's samples in that time are its rate. Measured on this Mac mini (Mac18,5, Apple M6), today's fair-weather cumulus at 256², the three views: - 36,000 to 38,800 dispatches of 64 events in 20 s, 7.6 to 8.1 × 10⁹ event slots a second. - The slowest pixel finishes 287 to 313 samples of three bands in the 20 s, 0.064 to 0.070 s a sample, so the design's 1,024 samples in every pixel are 66 to 71 s a case. - Shared by need the same work is 0.0042 to 0.0047 s a sample of the whole image, fifteen times less. That scheduling is not built. - One sample's relative deviation over the 8,400 cloudy pixels, green: 1.8 to 2.2 at the median and 2.5 to 3.1 at the ninetieth percentile. The spread is counted over pixels above a tenth. Clear sky is one value summed 10⁵ times in float32, and the last bits of that sum and of its squares read as a deviation of a hundredth: at a floor of a percent they were 30,000 of a view's pixels and put its median at 0.01. The always-on comparison with the float64 tracer records what it measured: of 432 values two beyond three combined errors, the farthest at 3.93, and a mean of 0.81 where a normal's is 0.80. Co-Authored-By: Claude <[email protected]>
The analytic cumulus's 32-pixel image holds 268 pixels with cloud on their line of sight, counted from `mediumDepth` on the CPU. The test asserted more than 200 and its comment said "some 290", which nobody had counted, and the kernel's commit repeats the figure. It asserts 268, so a change to the fixture's shape or to a pixel's ray shows here before it shows as a radiance. Co-Authored-By: Claude <[email protected]>
Package G (weather/p1-g, 25ab716) holds the weather field to ISCCP-H and the slab oracle. Earth's zonal law is refitted by least squares to ISCCP-H's zonal table, 2007 to 2016, where the plan's targets were MODIS offsets the data does not match; the altocumulus regime stands 400 m thick, its genus's range, where 800 m put its detected pixels' mean depth 66% over ISCCP-H's altocumulus and 400 m puts it 3.2% under; and weatherCalibration.test.ts holds the rubric's rows 9, 10 and 16 on the resolved CPU field, each pass where it passes and each miss at its measured figure. Nothing conflicted: G branched at e62db00, and none of its five files changed on this branch since. Two joins follow: the calibration test moves to the slow suite, and the cornerstone ledger's snapshot takes the one line G's field moves. Co-Authored-By: Claude <[email protected]>
Package G's weatherCalibration.test.ts lays 640,000 columns of the CPU
field through the slab oracle and takes 40 to 57 s alone, so in the root
suite it lengthened the gate every later package runs after each turn.
It is renamed weatherCalibration.slow.test.ts: the slow suite
(apps/game/vitest.slow.config.ts) takes `{apps,packages}/*/src/**/*.slow.test.ts`,
which covers packages/rendering/src, and the root config excludes the
suffix, so no list changes. `pnpm check` and CI still run it, as they run
the transport references' slow tests.
`pnpm test:slow weatherCalibration` runs it, 30 of 30, in 31.0 s of wall
time; `pnpm vitest run weatherCalibration` from the root finds no file.
Co-Authored-By: Claude <[email protected]>
…nd the volume without its 50 m level A grid read filters eight cells, and in broken cloud the depth of their mean transmittance and their mean depth are two numbers: first order wants the first and the light after first order the second. One channel of opacity handed that light the shallower mean, 2.27 against 2.12 RMS through four taps in a climate's low level at 45°, and 4.77 against 2.58 at a sample the early out skipped (the sun instrument, Mac mini M6). The depth channel costs 1,048,576 B and no fetch, and first order's 18 rows match to 1e-4 RMS. The 50 m level is cut: no row moves by more than +0.0006 RMS over 22.5 km and none loses more than 0.0104 inside 4 km, for 4,456,448 B and 34 slices a rebuild. 64 heights are recorded as measured and not landed: 2.23 against 2.12 and 2.82 against 2.90, where the rule asked 0.4 lower. The depth is asked for when the sun is formed. Held up front it took a cloud-only program from 2 grid fetches to 6; formed at its first read it escaped its block three ways (a sibling branch, a memoized Fn, a loop of no turns), each refuted by a CPU build of the WGSL. The memory table, the device census (74,334,796 B at 1080p with one served body) and the consequences follow. The refresh bullet states the spread rebuild the code runs, since SUN_DEPTH_FRAME_CAP is gone. Co-Authored-By: Claude Opus 5.5 <[email protected]>
…t from what the cloud scatters Ruling 008: the light's gate on the sky term compares scattered light with scattered light. Under the air's own sky the sky behind a cloud, seen level, is 8.2 to 10.7 times the linear sky's at a 15 degree sun, and it is half of a rim's pixel; the product draws it in the atmosphere's pass, not in the march's sky term. The tracer takes `straight: false`, which leaves out a path that leaves the medium unscattered: the eye's own line, the one ray no vertex drew. That part needs no path. It is `e^(−τ)` on the scaled medium along the eye's line times the sky on that line, read by the tracer's own read, so it is held exactly (`straightOf`) and the trace holds only the light the cloud scatters, at less variance than a difference would. Under the air's sky and the linear one the rows are now that light (`airScattered`, `linearScattered`), and `airSplit` and `linearSplit` hold both parts by case, mask and band. The table's block keeps every path: `scaled.rest` was traced so. The first pass's whole sky less the exact straight part agrees with the new scattered rows over 10,212 values at a mean z of 0.006 and an RMS of 0.81, the two runs sharing streams; no scattered value is negative. Twelve sky processes, four at a time on the Mac mini (Mac18,5, Apple M6), 22:49:56 to 22:51:47, 7.2 core-minutes. The sun's blocks and the table's are the same rows' hashes; the reference is 1,063,557 B. Co-Authored-By: Claude Opus 5.5 <[email protected]>
… 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]>
`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]>
🚀 Deploying Preview to Cloudflare 🚀Preview URL: https://the-weather-inertialrefd.jaquers.workers.dev (commit c34cd9f)This URL reflects your latest Preview deploymentPreview Deployments by commit
|
|
Note 🤖 Claude Opus 5.5 responding on behalf of jonjaques The first look round: the clouds are litThree judges, blind against photographs, put the light at 4.6 of 10 where it was 2.8, and the shapes at 4.3 where they were 3.5. The bar is 7. What they name, in their order:
Two of those are being fixed inside the two packages now running: the blocky edges (Y2, the composite's air) and the row of blocks on the limb (X, the far march's light). The small cells are not yet planned, and a study of them comes next. The round's archive and the panel's ledger are in the main checkout's ignored For the Retina default, later: the held cast ran at 43 to 45 Hz with the clouds on at 2880 × 1800, and 66 to 67 with them off. Each sheet is before M2 on the left and with M2's light on the right. The E2 sheet adds the textured deck as a third panel. The sheets' own captions read "phase 1" on both sides.
Play it: https://the-weather-inertialrefd.jaquers.workers.dev/?clouds=1 |





The weather is volumetric clouds for InertialRef, replacing the textured cloud deck, on three.js TSL and WebGPU. Everything sits behind
?clouds=1. This is its integration pull request: every package lands onthe-weatheras it goes green, and this branch's Cloudflare preview always carries the latest clouds.Play with it: https://the-weather-inertialrefd.jaquers.workers.dev/?clouds=1. The preview needs WebGPU. Without
?clouds=1, a page loads none of the cloud code.The cornerstones
The clouds draw on the ten cornerstone scenes, which no list in the app shows yet. Each link opens one in the planetarium with the clouds on. Earth keeps its textured deck until phase 3, so the E scenes change least.
Where it stands
The plan is
design/plans/the-weather.md, anddesign/plans/weather/README.mdsays where the work stands. The definition of done is a unanimous council verdict againstdesign/plans/weather/mvp.md.How it lands
Packages branch from
the-weather. A merger merges each one here with an ordinary push once its Sol review, the full check, the GPU suite and CI are green. Nothing is rebased or force-pushed. This pull request stays a draft until the council's verdict, and it merges intomainonly on Jon's word.🤖 Generated with Claude Code