@vitreajs/vitrea 0.19.0 → 0.21.0

package/dist/index.d.ts

@@ -1993,8 +1993,88 @@ interface MaterialRim {
 interface MaterialOuterShadow {
     /** Downward translation of the shadow's silhouette, CSS px. */
     readonly offsetPx: number;
-    /** Gaussian σ the silhouette is blurred by, CSS px. A `box-shadow` blur is 2σ. */
+    /**
+     * Gaussian σ the silhouette is blurred by, CSS px. A `box-shadow` blur is 2σ.
+     *
+     * Since W30 G2 this is the σ at the reference span rather than the σ full
+     * stop: the three leaves below grade it with the casting span, and at their
+     * inert defaults the law returns exactly this number for every span. The
+     * header above records the macOS 26.5 material's own span-invariance as a
+     * positive measurement, which is why that material can go on expressing
+     * itself with three zeros.
+     */
     readonly sigmaPx: number;
+    /**
+     * The σ law's slope: CSS px of σ per CSS px of casting span, dimensionless.
+     *
+     * macOS 27 blurs the outer shadow wider under a wider surface. Over spans 96
+     * to 160 the measured σ is linear in the span on every bed of the macOS 27
+     * capture — slope 0.128 to 0.134, holding to 2 % on the median and scale-
+     * invariant in CSS px to 11 % at its worst cell (claims §5.156 §2) — while
+     * the shipped single σ draws 4.2 to 7.2 times too wide below span 96 and
+     * about a third too narrow at 128 and above. The whole law is
+     *
+     *     σ_css(span) = sigmaPx + max(sigmaThinOffsetPx,
+     *                                 sigmaSlopePerSpan · (span − sigmaSpanRefPx))
+     *
+     * evaluated PER CASTER: the GPU tier reads the casting surface's own span per
+     * pixel from the field pass's `shadowAux.z`, and the CSS tier writes one blur
+     * radius per surface from `surface.spanPx`. It takes no device ratio, because
+     * the cut rejected the device-px reading of the thin regime in both directions
+     * (§5.156 §2's two signatures) — one function of CSS span is one mirror fewer
+     * for the CSS tier to keep.
+     *
+     * **Ships at 0, which is a multiplied zero**: the whole span term is
+     * `0 · (span − sigmaSpanRefPx)`, so the `max` sees two zeros and σ is
+     * `sigmaPx` identically, at every span and every scale. Fitted in the macOS 27
+     * documents by claims §5.159; the frozen macOS 26.5 material keeps the zero,
+     * where it is the measurement.
+     */
+    readonly sigmaSlopePerSpan: number;
+    /**
+     * The casting span, CSS px, at which σ equals `sigmaPx` — the span the line
+     * pivots about.
+     *
+     * The law has one flat direction: shifting `sigmaPx`, `sigmaThinOffsetPx` and
+     * this constant together leaves σ unchanged at every span, so a fit has to
+     * hold one of the three. **The fit holds this one, at 96** (W30 Decision Log
+     * 3 (c)) — the span every bed carries sixteen cells at, and the span the
+     * amplitude's own anchor `thickOcclusionAt96` is keyed to — and fits the slope
+     * and the offset around it, refitting `sigmaPx` as the σ at span 96.
+     *
+     * **Ships at 0**, which is unreachable while the slope is 0 and which the
+     * identity does not depend on: a pivot multiplied by a zero slope contributes
+     * nothing whatever its value. 96 is the fit's value in claims §5.159, not the
+     * default's.
+     */
+    readonly sigmaSpanRefPx: number;
+    /**
+     * The width the thin regime holds, CSS px, SIGNED, stated as an offset from
+     * `sigmaPx` — the floor the line is clamped below at.
+     *
+     * A floor is structurally necessary rather than a fit of the thin cells: the
+     * measured line crosses zero at a span of 23.6 to 30.4 on every bed and the
+     * smallest declared span in the bed is 32, so without one the law emits
+     * 0.27 CSS px on a 32 px surface and a negative σ on a 24 px one
+     * (claims §5.156 §2).
+     *
+     * **Its unit is CSS px and its value is a declared reading rather than a fit**
+     * (W30 Decision Log 2 (b)). The thin cells are a position on the instrument's
+     * valley, not a measurement of Apple's blur: the reader's (amplitude, σ) pair
+     * trades at a nearly constant product there, and the thin σ bifurcates on the
+     * author's TINT — untinted cells read a 1x/2x ratio of 1.86–2.57 and their
+     * tinted siblings 0.51–0.56 on the same geometry, which the material's blur
+     * cannot depend on. So no order statistic over those cells is a measurement,
+     * and §5.159 sets this by declaration with the statistic it is checked
+     * against named.
+     *
+     * **Ships at 0**, an added zero under a `max` whose other arm is also zero.
+     * The knee — where the floor gives way to the line — is DERIVED from the three
+     * (`sigmaSpanRefPx + sigmaThinOffsetPx / sigmaSlopePerSpan`) rather than being
+     * a fourth leaf, because a knee stated beside a slope and a floor is a third
+     * name for a quantity two of them already fix.
+     */
+    readonly sigmaThinOffsetPx: number;
     /** Outward spread of the silhouette before the blur, CSS px. */
     readonly spreadPx: number;
     /**
@@ -2827,6 +2907,88 @@ interface MaterialProfile {
      */
     readonly sizeHeavyTapSigma: number;
     readonly sizeHeavyTapSigma2x: number;
+    /**
+     * The second heavy tap's Gaussian width in CSS px, per scale — candidate (i)'s
+     * width, on `sizeHeavyTapSigma`'s own pattern and resolved by the same
+     * `rampAtScale`.
+     *
+     * It is a second `PyramidResources` texture and a second separable pair, not a
+     * uniform the optics pass evaluates, for `sizeHeavyTapSigma`'s measured
+     * reason: a grid of taps at the fragment costs +1.1 ms on the mobile bench row
+     * against 0.070 ms for two separable passes the chain already runs (W26
+     * Decision Log 2 (b)). So the width, like the first one, is one per SOURCE.
+     *
+     * **Ships at 0, and the width is not what makes it inert** —
+     * `sizeHeavySecondShare` is. At share 0 no texture is allocated, no pass is
+     * encoded and the optics pass never reads one, so this width is unread
+     * whatever it holds; 0 is chosen because it is the value at which
+     * `heavyTapPlan` would also decline. A profile that names a width and leaves
+     * the share at 0 gets nothing, deliberately: the share is the single gate, so
+     * that the off path has exactly one condition.
+     */
+    readonly sizeHeavySecondSigma: number;
+    readonly sizeHeavySecondSigma2x: number;
+    /**
+     * The second heavy sample's weight in the deep mix — a SIGNED fraction, and
+     * the scheme-conditioned leaf of candidate (i).
+     *
+     * The deep sample becomes `heavy + share · (heavy2 − heavy)`, so a positive
+     * share widens the deep component toward the second width and a NEGATIVE one
+     * subtracts it — an unsharp mask on the backdrop, which is a kernel that
+     * passes the middle pitch less than both ends and is the only shape on offer
+     * that can do what the residual asks. The sign is what the colour scheme
+     * flips: on the gated 16 px cell vitrea passes 1.57× the native structure in
+     * 1x light and 0.75× in 1x dark, so the light document wants structure removed
+     * at that pitch and the dark document wants it added (claims §5.156 §3, §6).
+     *
+     * **It is also the GATE.** The second heavy texture is built, bound and read
+     * only where this is non-zero, so at 0 the mechanism costs no allocation, no
+     * pass and no sample, and the deep mix is the expression W26 left — which is
+     * what the 34 renderer goldens prove, since they render an explicit patch over
+     * the default and every one of them is byte-identical across this commit.
+     *
+     * **Ships at 0, a multiplied zero**: the lerp's second term is
+     * `0 · (heavy2 − heavy)`, and the branch that would read `heavy2` at all is
+     * not taken.
+     */
+    readonly sizeHeavySecondShare: number;
+    /**
+     * The gain on `kScatter` per unit of the source's measured scale statistic
+     * about `sizeScatterScaleRef` — candidate (ii)'s scheme-conditioned leaf, a
+     * fraction per unit of statistic, signed.
+     *
+     * `kScatter` is the share of the deep component in the body's mix, and this
+     * adds `sizeScatterScaleGain · (stat − sizeScatterScaleRef)` to it before the
+     * clamp — so a backdrop whose structure sits at a finer scale than the
+     * reference takes a different share of the heavy component from one whose
+     * structure is coarser, which is a transmission that depends on the backdrop's
+     * scale rather than only on the surface's span. The statistic is the analysis
+     * pass's per-source EDGE DENSITY (mean luminance-gradient magnitude per texel,
+     * a reciprocal length), resolved on the CPU where the readback is and handed
+     * to the optics pass as one number per group.
+     *
+     * The sign is the scheme's, for `sizeHeavySecondShare`'s reason and read off
+     * the same cell.
+     *
+     * **Ships at 0, a multiplied zero**: the added term is
+     * `0 · (stat − sizeScatterScaleRef)` and `kScatter` is already clamped to
+     * [0, 1], so the clamp that follows is the identity on it.
+     */
+    readonly sizeScatterScaleGain: number;
+    /**
+     * The reference value of the per-source scale statistic the gain above is
+     * measured about — the backdrop scale at which the operator does nothing.
+     *
+     * Not scheme-conditioned: a spatial scale is a property of the source raster
+     * and the raster is the same in both schemes. Fitted in §5.159 as the edge
+     * density of the pitch the two sides of the residual straddle, once the ladder
+     * has a macOS 27 reading.
+     *
+     * **Ships at 0**, and the argument for its inertness is not a multiplied zero
+     * but a different one and sufficient on its own: the gain that multiplies the
+     * difference from it is 0, so no value of this constant can reach the mix.
+     */
+    readonly sizeScatterScaleRef: number;
     /**
      * The occlusion gain — "a larger size is more opaque. A smaller size is
      * clearer" (S284). The fraction of the *remaining* transparency the size law
@@ -3104,6 +3266,60 @@ interface MaterialProfile {
      * it at every ratio and this anchor is the identity on the landed material.
      */
     readonly collapseTransmission2x: number;
+    /**
+     * **How much of the blurred backdrop's CHROMATICITY the body restores** (W31;
+     * claims §5.161 §5, fitted in §5.164) — a fraction in [0, 1], inert at 0.
+     *
+     * The body is a neutral plate composited over the blurred backdrop, so what a
+     * photograph's hues survive the composite at is `1 − sizedAlpha` — 0.513 on the
+     * macOS 27 light document and 0.095 on the dark one, against a reference that
+     * reads 0.90–0.97 of its own backdrop's chroma on the same cells. Apple's body
+     * at the same LEVEL keeps the hue, which is what a darkening acting on the
+     * backdrop's luma while leaving its chromaticity alone does and what a plate
+     * does not. No constant the material had could close that (W29 Decision Log
+     * 6 (c)): it is a mechanism, and this is the one leaf that adds it.
+     *
+     * Applied immediately after `colour = mix(backdrop, adapted, presentAlpha)`
+     * and before the tint composition, so an author's tint still displaces the
+     * result. The colour is mixed toward `backdrop · (Y / Y_backdrop)` — the
+     * backdrop's chromaticity carried to the colour's OWN linear luma — by this
+     * fraction, so **luma is preserved by construction rather than by
+     * correction**: both endpoints of the mix have linear luma exactly `Y`,
+     * `dot(rgb, (0.2126, 0.7152, 0.0722))` is a linear functional, and the mix has
+     * luma `Y` in exact arithmetic. (OKLab `L` is NOT linear luma, which is why the
+     * formulation is in linear RGB: holding `L` while moving toward a saturated
+     * chromaticity moves `Y` by −22 % at sRGB blue and +10 % at green.) Gamut is
+     * taken by scaling chroma toward the neutral at fixed luma, never by clipping
+     * per channel.
+     *
+     * **No `toneAdapt` gate**, and the reason is measured rather than assumed
+     * (claims §5.161 §11, finding N1). A retention toward the backdrop's
+     * chromaticity is the identity wherever the backdrop is achromatic, and the
+     * only region `backdropToneAdaptation` can fire in on the macOS 27 documents
+     * is `x < backdropToneHigh` = 1e-4 of linear light — achromatic to within the
+     * capture's own quantisation. A future document that re-opens
+     * `backdropToneHigh` must re-examine that, and must read it at a span at or
+     * below `sizeSpanMin` where `backdropToneSizeBias` is not there to help.
+     *
+     * Conditioned by SCHEME (two values across the light and dark documents) and
+     * by POSE: each receded document carries its own, read on the inactive cells,
+     * because the recede's untinted body has no chroma law at all otherwise —
+     * W27c's collapse acts on the tint SEED inside `if (tintK > 0.0)`. The
+     * accessibility documents inherit the light value.
+     *
+     * **Ships at 0, a multiplied zero**: the mix's second term is `0 · (target −
+     * colour)` and `colour` leaves the composite exactly as
+     * `mix(backdrop, adapted, presentAlpha)` produced it, which is why the 34
+     * renderer goldens are byte-identical across the commit that added it and why
+     * `MATERIAL_IDENTITY_TABLE` can drop it from the fingerprint.
+     *
+     * One place it cannot act, declared rather than discovered: on the unsampled
+     * layer path (`flags.x <= 0.5` and not `domMaterial`) the shader overwrites
+     * `colour` with `adapted` and writes a layer for the browser to composite, so
+     * there is no backdrop in hand and no chromaticity to restore toward. The
+     * retention is silently the identity there.
+     */
+    readonly bodyChromaRetention: number;
     /**
      * **The rim that survives the collapse (W23)** — the one mark the collapsed
      * appearance keeps.
@@ -3320,6 +3536,11 @@ interface MaterialProfilePatch {
     readonly sizeToneLevelFar?: number;
     readonly sizeHeavyTapSigma?: number;
     readonly sizeHeavyTapSigma2x?: number;
+    readonly sizeHeavySecondSigma?: number;
+    readonly sizeHeavySecondSigma2x?: number;
+    readonly sizeHeavySecondShare?: number;
+    readonly sizeScatterScaleGain?: number;
+    readonly sizeScatterScaleRef?: number;
     readonly sizeOcclusionGain?: number;
     readonly sizeShadowGainMax?: number;
     readonly lensRefractionGain?: number;
@@ -3349,6 +3570,7 @@ interface MaterialProfilePatch {
     readonly backdropToneSizeBias?: number;
     readonly collapseTransmission?: number;
     readonly collapseTransmission2x?: number;
+    readonly bodyChromaRetention?: number;
     readonly rimCollapsed?: number;
     readonly rimCollapsedTinted?: number;
     readonly rimTintChroma?: number;
@@ -4176,6 +4398,19 @@ interface PyramidResources {
      * says the material can afford that.
      */
     readonly heavy: GPUTexture | undefined;
+    /**
+     * The **second** heavy blur (W30 G2; `MaterialProfile.sizeHeavySecondSigma`
+     * gated on `sizeHeavySecondShare`) — the same construction one width along,
+     * and `undefined` wherever the material leaves the share at 0, which is
+     * everywhere on the landed material.
+     *
+     * It is a second texture and a second separable pair rather than a second tap
+     * in the optics pass for the reason the first one is: the price of a width at
+     * the fragment is +1.1 ms on the mobile bench row against 0.070 ms here (W26
+     * Decision Log 2 (b)). The price of having it at all is therefore paid by the
+     * material that names it and by nothing else.
+     */
+    readonly heavy2: GPUTexture | undefined;
     readonly stats: GPUBuffer;
     /** Source size epoch this allocation was made for. */
     readonly sizeEpoch: number;
@@ -4221,6 +4456,11 @@ interface PyramidResources {
      * texture from the same clean source.
      */
     readonly heavySigmaCss: number;
+    /**
+     * The SECOND heavy blur's σ in **CSS px** the build converted with (W30 G2),
+     * on `heavySigmaCss`'s own rule and for the same staleness reason.
+     */
+    readonly heavy2SigmaCss: number;
 }
 interface PyramidInstrumentation {
     /** Successful rebuilds since the store was created. */
@@ -4256,6 +4496,14 @@ interface PyramidBuildRequest {
      * material that names no heavy width pays for none of this.
      */
     readonly heavySigmaCss: number;
+    /**
+     * The SECOND heavy blur's σ in **CSS px** (W30 G2), 0 where the material
+     * leaves `sizeHeavySecondShare` at 0 — at which point nothing is allocated
+     * and nothing is drawn, exactly as for the first one. The share is the gate
+     * and `heavySecondTapSigmaAtScale` applies it, so this arrives already 0
+     * rather than being re-decided here.
+     */
+    readonly heavy2SigmaCss: number;
     readonly viewportCss: readonly [number, number];
     /**
      * Where the source sits on the plane, in CSS px relative to the viewport, if

package/dist/index.js

@@ -1092,7 +1092,7 @@ function isHealthy(state) {
 
 // src/renderer-seam.ts
 async function loadWebGPURendererModule() {
-  return import('./dist-VQPRX7BX.js');
+  return import('./dist-N437MSRG.js');
 }
 async function loadWebGPURenderer() {
   const { createWebGPURenderer } = await loadWebGPURendererModule();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitreajs/vitrea",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "description": "Framework-agnostic Liquid Glass material runtime: scene model, capability resolution, material policy, accessibility policy.",
   "license": "Apache-2.0",
   "homepage": "https://github.com/SSFSKIM/designer",