web: give the grain a size of its own, and read the count off the print

MONOCHROME GRAIN was one integer knob 0..10 with one meaning, how much. It is now
a strip of three: AMOUNT — the same knob, in half steps — SIZE, a percentage of
the stock's own grain cell (50..200%, so the same number means the same texture
relative to the picture on both platforms), and an inert readout of N/INCH, the
clump count the two knobs and the stock add up to in the print's own terms (300
dpi = 300px of the 1080-wide reference the knob was tuned at).

Emulsion is not one grain size across the frame: the coating settles unevenly.
The field now prints that — the same hash read slowly (ZONE_FREQ = 1/96 cells,
turned off the axes, smoothed so a border between two patches is a slope and not
a seam) swings each patch's own cell by half of ZONE_SWING either way, ±20%.
Nothing in it moves the field's mean: a coarser patch prints bigger clumps, not a
brighter one, which is why the strip can read out one number while the frame
carries a range.

A patch may not swing a cell under the pixel the target can print, or the clumps
are sub-pixel and print as static — aliasing, not a finer emulsion. The shader
takes that floor as a `mincell` uniform beside the cell (u, mincell, seed.xy, in
declaration order): an export passes one output pixel, a preview one device pixel
(1 / PixelRatio), which is the floor the phone's preview already needed.

SIZE is stored as an integer percent so no float noise reaches the recipe JSON,
and it is read by the same two engines that read grain: the web's
grainCell(width, stock, sizePct) and the phone's grainCell(width, minCell,
sizePct). The chip above the strip carries the amount in half steps the way TEMP
carries the kelvin, and the readout moves with SIZE, not with AMOUNT.

Measured:
  grain-controls-test.cjs 20/0 — the strip carries grp-grain, grain:amount,
    grain:size and grain-inch; the AMOUNT ruler is 0..10 step 0.5, and 3 -> 3.5
    moves the frame (sigma 18.53 -> 21.91, new hash) without moving the readout;
    10 -> sigma 60.43, 0 -> sigma 0; SIZE 200% -> 130/INCH (sigma 40.06), 50% ->
    522/INCH (66.56: under the preview's pixel floor what is printed is static,
    not finer grain); the region claim on an 8x8 grid of the flat frame gives
    tile sd 51.0..66.1, max/min 1.295, and a tile mean spread of 1.14 — a coarser
    patch is not a brighter one.
  grain-size-test.cjs 17/0 (was 12/0) — the SIZE rule and the readout on the
    module itself: 200% doubles the cell, 50% halves it, the output pixel still
    floors the smaller one. 4000px file cell 3.704 against 1.083 device px on a 3x
    preview, the old one-dp floor 2.77x coarser, rho1 0.627 against 0.074. The
    harness built its own 3-uniform array; it now passes [u, mincell, seed.xy]
    like every other caller.
  _grain-zone-ck.cjs — the zone's own contribution, at preview scale (cell 1.70,
    1600px, 8x8 tiles of 200px): zone on, tile sd 23.22..24.82 (ratio 1.069);
    zone off, 24.42..24.79 (ratio 1.015). Nothing else differs.
  _grain-ck.cjs — the clump field is otherwise what it was: rho1 0.62
    classic-neg / 0.12 velvia, residual autocorr 0.035 against 0.036 with the
    swing forced to 0, peak/median 32.3 against 27.6.
  _grain-spectrum.cjs (app, 1600px render) — residual autocorr 0.017..0.018,
    spectral peak/median 4.6..6.1: the slow lattice adds no peak of its own.
  grain-stock-test 53/0, sims-test 31/0, fx-mono-test 15/0, wb-preset-test 33/0,
    temp-swatch-test 33/0, wm-font-test 38/0, grain-analog-test 7/0 (its grain
    selectors moved to the strip).
  tsc: web clean; the phone's scoped config reports exactly the pre-change
    baseline (Viewfinder.tsx's own errors, none new).

ponytail: the amount is fractional now, so the two recipe-create forms read grain
through their own half() instead of the int() that would truncate the half the
ruler just spent — every other knob there is still whole. The SIZE knob is one
number for the whole strip: no way to dial a single patch, and no seed control.
The readout is the DESIGN count the field is built on, never a per-patch
measurement.

docker/frontend/shared/utils/grainShader.ts

@@ -187,11 +187,25 @@ export const GRAIN_SEED: readonly [number, number] = [Math.random() * 61.7, Math
 export const GRAIN_REF = 1080;
 
 // The cell GRAIN_SKSL is handed for a picture of `pictureWidth` px: the stock's
-// share of the reference, floored at one pixel because a cell smaller than the
-// target's own pixel cannot be resolved — it prints as static instead of grain,
-// which is aliasing, not a finer emulsion.
-export function grainCell(pictureWidth: number, stock: GrainStock, minCell = 1): number {
-  return Math.max((pictureWidth / GRAIN_REF) * stock.cell, minCell);
+// share of the reference, scaled by the SIZE knob (a percentage of the stock's
+// own cell), and floored at one pixel because a cell smaller than the target's
+// own pixel cannot be resolved — it prints as static instead of grain, which is
+// aliasing, not a finer emulsion. The floor is handed to the shader too, so the
+// field's own patch-to-patch swing cannot cross it.
+export function grainCell(pictureWidth: number, stock: GrainStock, sizePct = 100, minCell = 1): number {
+  return Math.max((pictureWidth / GRAIN_REF) * stock.cell * (sizePct / 100), minCell);
+}
+
+// The clump count the panel READS OUT: how many clumps the design puts across an
+// inch of a 300 dpi print, i.e. 300px of the GRAIN_REF frame. A statement about
+// the stock and the SIZE knob, never about one patch of the frame — the field
+// swings ±ZONE_SWING/2 patch by patch (see GRAIN_SKSL) — and never about the
+// screen, so the same stock reads the same number in the preview and in the
+// file.
+export const GRAIN_DPI = 300;
+
+export function grainPerInch(stock: GrainStock, sizePct = 100): number {
+  return Math.round(GRAIN_DPI / (stock.cell * (sizePct / 100)));
 }
 
 // The halo radius in px for the same picture: measured in reference units too,
@@ -213,8 +227,21 @@ export function halationSigma(pictureWidth: number, stock: GrainStock): number {
 // autocorrelation falls to 0.03 from 0.44 (measured) — nothing left to tile. The
 // hash behind the jitter is sin-free for the same reason: a float sinus whose
 // argument grows with the picture folds back on itself, a lattice of its own.
+//
+// Emulsion is not ONE grain size across the frame: the coating settles unevenly,
+// so the clumps run coarser in patches and tighter in others. The same hash read
+// as a SLOW value noise is what draws those patches — one every 1/ZONE_FREQ
+// cells, turned off the axes and smoothed, because a step at a patch border
+// would print as a seam — and each patch swings its own cell size by half of
+// ZONE_SWING either way. Nothing here moves the field's mean: a coarser patch
+// prints bigger clumps, not a brighter one, which is why the panel can read out
+// one number while the frame carries a range.
+export const ZONE_FREQ = 1 / 96;
+export const ZONE_SWING = 0.4;
+
 export const GRAIN_SKSL = `
   uniform float u;
+  uniform float mincell;
   uniform vec2 seed;
   uniform vec3 mixw;
   uniform float spread;
@@ -239,8 +266,22 @@ export const GRAIN_SKSL = `
     }
     return 1.0 - min(sqrt(near), 1.0);
   }
+  // The patches of grain size: the same hash read slowly, smoothed so a border
+  // between two patches is a slope and not a step.
+  float grainZone(vec2 p) {
+    vec2 i = floor(p);
+    vec2 f = p - i;
+    f = f * f * (3.0 - 2.0 * f);
+    return mix(mix(grainHash(i), grainHash(i + vec2(1.0, 0.0)), f.x),
+               mix(grainHash(i + vec2(0.0, 1.0)), grainHash(i + vec2(1.0, 1.0)), f.x), f.y);
+  }
   vec4 main(vec2 pos) {
-    vec2 q = pos.xy / max(u, 0.0001) + seed;
+    vec2 p = pos.xy / max(u, 0.0001) + seed;
+    // This patch's own cell: the design cell swung by its zone, never under the
+    // floor — under it the clumps are sub-pixel and print as static, which is
+    // aliasing, not a finer emulsion.
+    float cell = max(u * (1.0 + (grainZone(mat2(0.9397, -0.3420, 0.3420, 0.9397) * p * ${ZONE_FREQ.toFixed(6)}) - 0.5) * ${ZONE_SWING}), mincell);
+    vec2 q = pos.xy / cell + seed;
     // The stock's own field: three octaves, no two of them on the same grid.
     // Each is turned to its own angle — 20, 47, 73 degrees — and sits on its own
     // rung of the ladder, 1 / 0.53 / 0.29, off the dyadic 1 / 0.5 / 0.25 where
@@ -257,10 +298,11 @@ export const GRAIN_SKSL = `
   }
 `;
 
-// Flat uniform buffer for makeShader — declaration order above: u, seed, mix,
-// spread.
-export function grainUniformArray(cell: number, stock: GrainStock): number[] {
-  return [cell, GRAIN_SEED[0], GRAIN_SEED[1], stock.mix[0], stock.mix[1], stock.mix[2], stock.spread];
+// Flat uniform buffer for makeShader — declaration order above: u, mincell,
+// seed, mix, spread. `minCell` is the floor grainCell() applied, so the field's
+// own patch swing cannot take a cell under it.
+export function grainUniformArray(cell: number, stock: GrainStock, minCell = 1): number[] {
+  return [cell, minCell, GRAIN_SEED[0], GRAIN_SEED[1], stock.mix[0], stock.mix[1], stock.mix[2], stock.spread];
 }
 
 // HALATION: the highlight bleed the backing returns. Threshold first — a

docker/frontend/shared/utils/paramDefs.ts

@@ -195,12 +195,28 @@ export const PARAM_DEFS: {
       label: 'MONOCHROME GRAIN',
       min: 0,
       max: 10,
-      step: 1,
+      // Half a step: the grain is a look, not a switch, and the AMOUNT chip in
+      // the GRAIN strip is what spends the half.
+      step: 0.5,
       defaultValue: 0,
       display: String,
       get: (a) => a.grain,
       set: (v) => ({ grain: v }),
     },
+    {
+      // The SIZE knob: percent of the stock's own cell (grainShader.ts), so the
+      // same number means the same texture RELATIVE to the picture on both
+      // platforms and the readout beside it is the stock's, scaled.
+      key: 'grainSize',
+      label: 'GRAIN SIZE',
+      min: 50,
+      max: 200,
+      step: 5,
+      defaultValue: 100,
+      display: (v) => `${v}%`,
+      get: (a) => a.grainSize ?? 100,
+      set: (v) => ({ grainSize: v }),
+    },
     {
       key: 'hdf',
       label: 'HDF EFFECT',