@satinhq/kit 0.0.0-stage → 0.1.0-beta.0

package/dist/glass/webgpu/sharedLift.d.ts

@@ -0,0 +1,7 @@
+/** Shared clear transmission kernel. The resting reference graph is a separate input.
+ * Geometry is the frozen 11k fit. Optical point conversion remains provisional.
+ * Output belongs ABOVE semantic foreground. Inside an active aperture it replaces
+ * that foreground with one warped atlas image. Zero lift is exactly transparent.
+ * The optical field and directional highlight are independent of bar material.
+ */
+export declare const sharedLiftFragment = "\nprecision highp float;\nin vec2 vTextureCoord;\nin vec2 vFilterCoord;\nout vec4 finalColor;\nuniform sampler2D uClearSource;\nuniform sampler2D uRestSource;\nuniform sampler2D uGlyphSource;\nuniform vec2 uResolution;\nuniform vec4 uShape;\nuniform float uRadius;\nuniform float uLiftMix;\nuniform vec4 uLensField;\nuniform vec4 uLensMap;\n// (amplitude, centre pt below the rim, rim-side sigma, centre-side sigma): the top inner shadow.\nuniform vec4 uLensTopShade;\nuniform vec4 uLensDebug;\nuniform vec4 uLensLighting;\nuniform float uLensBandScale;\nuniform vec2 uLensBandDirections;\nuniform vec4 uLensFringe;\nuniform vec2 uLensFaceTreatment;\nuniform vec4 uLensDepthShade;\nuniform float uLensDepthIsotropic;\nuniform vec4 uLensCrestVertical;\nuniform vec3 uLensExteriorShadow;\nuniform float uLensLightRotation;\nuniform vec4 uLensLightStrength;\nuniform vec4 uLensLightingClock;\nuniform vec4 uLensLightingClock2;\nuniform float uMotionMix;\nuniform float uBackgroundWarpPt;\nuniform float uTravelWarpPt;\nuniform float uForegroundChroma;\nuniform float uForegroundScaleX;\nuniform float uForegroundScaleY;\nuniform float uForegroundLabelScaleX;\nuniform float uForegroundLabelScaleY;\nuniform vec2 uForegroundShiftPt;\nuniform vec3 uCapBendIcon;\nuniform vec3 uCapBendLabel;\nuniform float uRimGradient;\nuniform vec2 uGlyphAnchors;\nuniform float uGlyphCount;\nuniform vec4 uDockShape;\nuniform vec2 uGlyphVibrancy;\nfloat sdRoundRect(vec2 point,vec2 halfSize,float radius) {\n  vec2 q=abs(point)-halfSize+radius;\n  return min(max(q.x,q.y),0.0)+length(max(q,0.0))-radius;\n}\nvec3 dockColour(vec2 uv) {\n  // This is the actual surface behind this lens, including lower glass when\n  // present. Never substitute the lens's own frosted material for transmission.\n  return texture(uClearSource,clamp(uv,vec2(0.0),vec2(1.0))).rgb;\n}\nvoid movingLens(vec2 point, float sd, out vec3 background, out vec4 glyph, out vec2 displacement, out float rimMask) {\n  vec2 p=point-uShape.xy;\n  vec2 q=abs(p)-uShape.zw+uRadius;\n  vec2 a=max(q,0.0);\n  float len=length(a);\n  vec2 outward=len>0.0?sign(p)*a/len:(q.x>q.y?vec2(sign(p.x),0.0):vec2(0.0,sign(p.y)));\n  float inside=max(0.0,-sd);\n  // Distances here are explicit point-space hypotheses. The archived field\n  // texture scale was not material; it must be qualified against stills.\n  // Distance support is directional. The narrow cap must not inherit the\n  // straight edge's wider sampling band. Amplitudes and DPR stay unchanged.\n  float capWeight=outward.x*outward.x;\n  float verticalBand=outward.y>0.0?uLensBandDirections.y:uLensBandScale;\n  float band=mix(verticalBand,uLensBandDirections.x,capWeight);\n  float opticalDistance=inside/max(.001,band);\n  float displacementProfile=pow(max(0.0,1.0-opticalDistance/max(.001,uLensField.z)),1.0);\n  float depth=clamp(opticalDistance/max(.001,uLensField.y),0.0,1.0);\n  float edgeRefraction=uLensField.x*(1.0-sqrt(depth*(2.0-depth)));\n  float mode=uLensDebug.x;\n  bool allTerms=mode<4.0;\n  // Native selected-lens maps: +9 over 36 local points, -17.5 over\n  // 11.2. Inverse sampling subtracts map displacement. This analytic normal\n  // field substitutes for the unmaterial map texture, not its material IR.\n  // The fitted band scale converts field distance to window points without\n  // changing signed displacement amplitude. DPR is applied by rasterization only.\n  // uLensMap = (broad amplitude, broad support, edge amplitude, medial fade); the tab lens is (9, 36, -17.5, 0).\n  // A negative broad amplitude samples outward: a held control thumb shows the track slightly\n  // minified, so the row beyond the track edges reads as dark bands inside the rim.\n  // uLensMap.w > 0 (controls only): the broad map fades to 0 within w pt of the medial axis, where\n  // the normal flips, so a thin track through the lens centre passes at gain 1 (Slider).\n  float medialFade=uLensMap.w>0.0?smoothstep(0.5*uLensMap.w,uLensMap.w,max(0.0,uRadius-inside)):1.0;\n  float broadMap=uLensMap.x*uLiftMix*max(0.0,1.0-opticalDistance/max(.001,uLensMap.y))*medialFade;\n  float edgeMap=uLensMap.z*uLiftMix*displacementProfile;\n  vec2 sourcePoint=point;\n  if(allTerms||mode==17.0||mode==5.0)sourcePoint-=outward*broadMap;\n  if(allTerms||mode==17.0||mode==11.0)sourcePoint-=outward*edgeMap;\n  if(allTerms||mode==17.0||mode==6.0)sourcePoint+=outward*edgeRefraction+vec2(uTravelWarpPt*displacementProfile,0.0);\n  displacement=sourcePoint-point;\n  vec2 uv=sourcePoint/uResolution;\n  // Spectral support is independent from refraction support. Press height\n  // supplies its existing clock; straight edges and caps have fitted widths.\n  float fringeWidth=mix(uLensFringe.z,uLensFringe.w,capWeight)*uLensField.z/11.2;\n  float fringe=pow(max(0.0,1.0-inside/max(.001,fringeWidth)),2.0);\n  float fringeGain=mix(uLensFringe.x,uLensFringe.y,capWeight);\n  vec2 dispersion=outward*uLensField.w*fringeGain*fringe/uResolution;\n  if(!allTerms&&mode!=17.0&&mode!=7.0)dispersion=vec2(0.0);\n  background=vec3(dockColour(uv+dispersion).r,dockColour(uv).g,dockColour(uv-dispersion).b);\n  // Face/output treatment, background highlights, independent SDF key/fill\n  // and diffuse lobes, then foreground. Never brighten the resting bar input.\n  float height=uLensLighting.z;\n  float offset=uLensLighting.w;\n  float faceClock=uLensLightingClock.x;\n  float lightClock=uLensLightingClock.y;\n  // Measured output crest in window points. Unlike the former finite-support\n  // lobe, this has no discontinuity at an interior mask offset. Directional\n  // key/fill and symmetric background terms retain separate output clocks.\n  float crest=exp(-.5*pow((inside-offset)/max(.001,height),2.0));\n  float nx=dot(outward,vec2(cos(uLensLightRotation),sin(uLensLightRotation)));\n  float key=crest*pow(max(nx,0.0),2.0);\n  float fill=crest*pow(max(-nx,0.0),2.0);\n  // A broad smooth diffuse term replaces the offset onset that made an inner\n  // contour. Width is 8 times the native-derived 6pt projection estimate.\n  float diffuse=mix(1.0,exp(-.5*pow(inside/max(.001,48.0*uLensLightingClock.z),2.0)),uLensFaceTreatment.y)*uLensLightingClock.w;\n  if(allTerms||mode==12.0){\n    float faceLuma=dot(background,vec3(.2126,.7152,.0722));\n    vec3 face=mix(vec3(faceLuma),background,uLensFaceTreatment.x);\n    background=mix(background,clamp(face*uLensLighting.x+uLensLighting.y,0.0,1.0),faceClock);\n  }\n  float H=0.0;\n  if(allTerms||mode==8.0||mode==13.0)H+=key*uLensLightStrength.x*lightClock;\n  if(allTerms||mode==8.0||mode==14.0)H+=fill*uLensLightStrength.y*lightClock;\n  if(allTerms||mode==8.0||mode==16.0)H+=crest*(pow(max(-outward.y,0.0),2.0)*uLensCrestVertical.x+pow(max(outward.y,0.0),2.0)*uLensCrestVertical.y)*lightClock;\n  if(allTerms||mode==8.0||mode==15.0)H+=diffuse*uLensLightStrength.z;\n  rimMask=crest*lightClock;\n  background=mix(background,vec3(1.0),clamp(H,0.0,.95));\n  // Neutral output shading is independent of spectral sampling. The narrow\n  // output rim and broader directional key/fill projection have separate clocks.\n  float shadeCap=mix(capWeight,1.0,uLensDepthIsotropic);\n  float shade=uLensDepthShade.x*faceClock\n    +uLensDepthShade.y*exp(-inside/1.2)*lightClock\n    +(uLensDepthShade.z*shadeCap+uLensDepthShade.w*(1.0-shadeCap))*exp(-inside/6.0)*uLensLightingClock.w;\n  // Isotropic button shading consumes available tonal contrast. A constant\n  // additive shade dirtied white faces and made a bright perimeter around them.\n  float shadeLuma=dot(background,vec3(.2126,.7152,.0722));\n  shade*=mix(1.0,clamp(4.0*shadeLuma*(1.0-shadeLuma),0.0,1.0),uLensDepthIsotropic);\n  // Controls: native's held lens darkens the upper half below its top rim (a top inner shadow),\n  // deepest \u2248 9 pt in and gone by the lens centre line; the lower half stays at the face level.\n  // Depth below the top edge, not the SDF: a horizontal band, so it never curls through the caps.\n  float topOffset=(uShape.w+p.y)-uLensTopShade.y;\n  float topScaled=topOffset/max(.001,topOffset<0.0?uLensTopShade.z:uLensTopShade.w);\n  shade+=uLensTopShade.x*exp(-.5*topScaled*topScaled)*(1.0-smoothstep(-1.0,1.0,p.y))*uLensLightingClock.w;\n  if(allTerms||mode==8.0)background=clamp(background+vec3(shade),0.0,1.0);\n  float edgeShift=max(0.0,uGlyphAnchors.x-uShape.x)-max(0.0,uShape.x-uGlyphAnchors.y);\n  // The cap folds a foreground stroke inward; the flat top must not pull\n  // a second gear into the highlight. This foreground field is independent\n  // of the backdrop transmission field.\n  float foregroundResponse=clamp(uForegroundChroma/255.0,0.0,1.0);\n  float label=step(uDockShape.y,point.y);\n  vec2 magnification=vec2(1.0+mix(uForegroundScaleX,uForegroundLabelScaleX,label),\n    1.0+mix(uForegroundScaleY,uForegroundLabelScaleY,label));\n  float capBend=3.0*abs(outward.x)*displacementProfile*foregroundResponse;\n  // Native magnifies each tab's content at its own anchor. Magnifying the\n  // atlas around the travelling lens center makes glyphs slide sideways and\n  // disappear into the wrong cap as the aperture crosses between tabs.\n  float lastIndex=max(0.0,uGlyphCount-1.0);\n  float spacing=max(1.0,(uGlyphAnchors.y-uGlyphAnchors.x)/max(1.0,lastIndex));\n  float anchorIndex=clamp(floor((point.x-uGlyphAnchors.x)/spacing+.5),0.0,lastIndex);\n  float anchor=uGlyphAnchors.x+anchorIndex*spacing;\n  vec2 glyphPoint=vec2(anchor+(point.x-anchor)/magnification.x,uShape.y+p.y/magnification.y);\n  // Fitting glyph-crop centres shows a leading-cap fold beyond the interior\n  // magnification. Its sigmoid is spatial, so the nearer stroke bends more.\n  float lead=sign(uTravelWarpPt);\n  vec3 fold=mix(uCapBendIcon,uCapBendLabel,label);\n  float leadingDistance=lead>0.0?uShape.x+uShape.z-point.x:point.x-(uShape.x-uShape.z);\n  float leadingFold=lead*fold.x/(1.0+exp(clamp((leadingDistance-fold.y)/fold.z,-30.0,30.0)));\n  glyphPoint.x-=leadingFold;\n  vec2 glyphUv=(glyphPoint-outward*capBend+vec2(edgeShift/magnification.x-mix(uForegroundShiftPt.x,uForegroundShiftPt.y,label)*uMotionMix,0.0))/uResolution;\n  vec2 soften=outward*.75*abs(outward.x)*exp(-inside/6.0)*foregroundResponse/uResolution;\n  bool selected=true;\n  if(selected){\n    glyph=texture(uGlyphSource,clamp(glyphUv,vec2(0.0),vec2(1.0)))*.4\n      +(texture(uGlyphSource,clamp(glyphUv+soften*.5,vec2(0.0),vec2(1.0)))\n        +texture(uGlyphSource,clamp(glyphUv-soften*.5,vec2(0.0),vec2(1.0))))*.24\n      +(texture(uGlyphSource,clamp(glyphUv+soften,vec2(0.0),vec2(1.0)))\n        +texture(uGlyphSource,clamp(glyphUv-soften,vec2(0.0),vec2(1.0))))*.06;\n    glyph.gb=clamp(glyph.gb+uGlyphVibrancy*glyph.a*uMotionMix,vec2(0.0),vec2(glyph.a));\n  }\n  // Foreground edge opacity falls from one at -14 local units to zero\n  // at the contour in the held sample. The conversion remains provisional.\n  if(allTerms||mode==18.0)glyph*=mix(1.0,clamp(inside/14.0,0.0,1.0),uLensLightingClock2.z);\n  if(!allTerms&&mode!=10.0&&mode!=18.0)glyph=vec4(0.0);\n}\n\nvoid main() {\n  if(uLiftMix<=0.0){finalColor=vec4(0.0);return;}\n  vec2 point=vFilterCoord*uResolution;\n  float sd=sdRoundRect(point-uShape.xy,uShape.zw,uRadius);\n  // Control rim (uLensCrestVertical.zw = dark line gain, width pt): device-pixel edge, crisp line.\n  float rimAa=uLensCrestVertical.w>0.0?.5/max(1.0,uLensDebug.y):.4;\n  float coverage=smoothstep(rimAa,-rimAa,sd);\n  vec3 transmitted;vec4 glyph;vec2 displacement;float rimMask;\n  movingLens(point,sd,transmitted,glyph,displacement,rimMask);\n  // 1 point displaces d framebuffer pixels here. Neutral blue=0, red=32px.\n  if(uLensDebug.x==1.0){float m=clamp(length(displacement)*uLensDebug.y/uLensDebug.z,0.0,1.0);finalColor=vec4(vec3(m,4.0*m*(1.0-m),1.0-m)*coverage,coverage);return;}\n  if(uLensDebug.x==2.0){finalColor=vec4(vec3(rimMask)*coverage,coverage);return;}\n  // RG encode signed x/y displacement around 0.5, at +/-32 framebuffer px.\n  if(uLensDebug.x==3.0){finalColor=vec4(vec3(vec2(.5)+displacement*uLensDebug.y/(2.0*uLensDebug.z),0.0)*coverage,coverage);return;}\n  vec3 rest=texture(uRestSource,clamp(vFilterCoord,vec2(0.0),vec2(1.0))).rgb;\n  vec3 body=mix(rest,transmitted,clamp(uLiftMix,0.0,1.0));\n  float rimPx=.5/max(1.0,uLensDebug.y);\n  body*=1.0-uLensCrestVertical.z*(1.0-smoothstep(uLensCrestVertical.w-rimPx,uLensCrestVertical.w+rimPx,max(0.0,-sd)))*clamp(uLiftMix,0.0,1.0);\n  // Foreground is premultiplied. Do not crossfade two differently warped glyphs.\n  // Gaussian half-plane approximation of the measured exterior shadow.\n  // Fit opacity/offset/spread outside the aperture, independent of face light.\n  float shadowDistance=sdRoundRect(point-uShape.xy-vec2(0.0,uLensExteriorShadow.y),uShape.zw,uRadius);\n  float z=shadowDistance/max(.001,uLensExteriorShadow.z)/1.41421356;\n  float t=1.0/(1.0+.3275911*abs(z));\n  float erf=sign(z)*(1.0-(((((1.061405429*t-1.453152027)*t)+1.421413741)*t-.284496736)*t+.254829592)*t*exp(-z*z));\n  float shadow=.5*(1.0-erf)*uLensExteriorShadow.x*uLensLightingClock2.y;\n  if(uLensDebug.x>=4.0&&uLensDebug.x!=9.0)shadow=0.0;\n  finalColor=vec4((body*(1.0-glyph.a)+glyph.rgb)*coverage,coverage+(1.0-coverage)*shadow);\n}";

package/dist/glass/webgpu/sharedLift.js

@@ -0,0 +1,223 @@
+/** Shared clear transmission kernel. The resting reference graph is a separate input.
+ * Geometry is the frozen 11k fit. Optical point conversion remains provisional.
+ * Output belongs ABOVE semantic foreground. Inside an active aperture it replaces
+ * that foreground with one warped atlas image. Zero lift is exactly transparent.
+ * The optical field and directional highlight are independent of bar material.
+ */
+export const sharedLiftFragment = /* glsl */ `
+precision highp float;
+in vec2 vTextureCoord;
+in vec2 vFilterCoord;
+out vec4 finalColor;
+uniform sampler2D uClearSource;
+uniform sampler2D uRestSource;
+uniform sampler2D uGlyphSource;
+uniform vec2 uResolution;
+uniform vec4 uShape;
+uniform float uRadius;
+uniform float uLiftMix;
+uniform vec4 uLensField;
+uniform vec4 uLensMap;
+// (amplitude, centre pt below the rim, rim-side sigma, centre-side sigma): the top inner shadow.
+uniform vec4 uLensTopShade;
+uniform vec4 uLensDebug;
+uniform vec4 uLensLighting;
+uniform float uLensBandScale;
+uniform vec2 uLensBandDirections;
+uniform vec4 uLensFringe;
+uniform vec2 uLensFaceTreatment;
+uniform vec4 uLensDepthShade;
+uniform float uLensDepthIsotropic;
+uniform vec4 uLensCrestVertical;
+uniform vec3 uLensExteriorShadow;
+uniform float uLensLightRotation;
+uniform vec4 uLensLightStrength;
+uniform vec4 uLensLightingClock;
+uniform vec4 uLensLightingClock2;
+uniform float uMotionMix;
+uniform float uBackgroundWarpPt;
+uniform float uTravelWarpPt;
+uniform float uForegroundChroma;
+uniform float uForegroundScaleX;
+uniform float uForegroundScaleY;
+uniform float uForegroundLabelScaleX;
+uniform float uForegroundLabelScaleY;
+uniform vec2 uForegroundShiftPt;
+uniform vec3 uCapBendIcon;
+uniform vec3 uCapBendLabel;
+uniform float uRimGradient;
+uniform vec2 uGlyphAnchors;
+uniform float uGlyphCount;
+uniform vec4 uDockShape;
+uniform vec2 uGlyphVibrancy;
+float sdRoundRect(vec2 point,vec2 halfSize,float radius) {
+  vec2 q=abs(point)-halfSize+radius;
+  return min(max(q.x,q.y),0.0)+length(max(q,0.0))-radius;
+}
+vec3 dockColour(vec2 uv) {
+  // This is the actual surface behind this lens, including lower glass when
+  // present. Never substitute the lens's own frosted material for transmission.
+  return texture(uClearSource,clamp(uv,vec2(0.0),vec2(1.0))).rgb;
+}
+void movingLens(vec2 point, float sd, out vec3 background, out vec4 glyph, out vec2 displacement, out float rimMask) {
+  vec2 p=point-uShape.xy;
+  vec2 q=abs(p)-uShape.zw+uRadius;
+  vec2 a=max(q,0.0);
+  float len=length(a);
+  vec2 outward=len>0.0?sign(p)*a/len:(q.x>q.y?vec2(sign(p.x),0.0):vec2(0.0,sign(p.y)));
+  float inside=max(0.0,-sd);
+  // Distances here are explicit point-space hypotheses. The archived field
+  // texture scale was not material; it must be qualified against stills.
+  // Distance support is directional. The narrow cap must not inherit the
+  // straight edge's wider sampling band. Amplitudes and DPR stay unchanged.
+  float capWeight=outward.x*outward.x;
+  float verticalBand=outward.y>0.0?uLensBandDirections.y:uLensBandScale;
+  float band=mix(verticalBand,uLensBandDirections.x,capWeight);
+  float opticalDistance=inside/max(.001,band);
+  float displacementProfile=pow(max(0.0,1.0-opticalDistance/max(.001,uLensField.z)),1.0);
+  float depth=clamp(opticalDistance/max(.001,uLensField.y),0.0,1.0);
+  float edgeRefraction=uLensField.x*(1.0-sqrt(depth*(2.0-depth)));
+  float mode=uLensDebug.x;
+  bool allTerms=mode<4.0;
+  // Native selected-lens maps: +9 over 36 local points, -17.5 over
+  // 11.2. Inverse sampling subtracts map displacement. This analytic normal
+  // field substitutes for the unmaterial map texture, not its material IR.
+  // The fitted band scale converts field distance to window points without
+  // changing signed displacement amplitude. DPR is applied by rasterization only.
+  // uLensMap = (broad amplitude, broad support, edge amplitude, medial fade); the tab lens is (9, 36, -17.5, 0).
+  // A negative broad amplitude samples outward: a held control thumb shows the track slightly
+  // minified, so the row beyond the track edges reads as dark bands inside the rim.
+  // uLensMap.w > 0 (controls only): the broad map fades to 0 within w pt of the medial axis, where
+  // the normal flips, so a thin track through the lens centre passes at gain 1 (Slider).
+  float medialFade=uLensMap.w>0.0?smoothstep(0.5*uLensMap.w,uLensMap.w,max(0.0,uRadius-inside)):1.0;
+  float broadMap=uLensMap.x*uLiftMix*max(0.0,1.0-opticalDistance/max(.001,uLensMap.y))*medialFade;
+  float edgeMap=uLensMap.z*uLiftMix*displacementProfile;
+  vec2 sourcePoint=point;
+  if(allTerms||mode==17.0||mode==5.0)sourcePoint-=outward*broadMap;
+  if(allTerms||mode==17.0||mode==11.0)sourcePoint-=outward*edgeMap;
+  if(allTerms||mode==17.0||mode==6.0)sourcePoint+=outward*edgeRefraction+vec2(uTravelWarpPt*displacementProfile,0.0);
+  displacement=sourcePoint-point;
+  vec2 uv=sourcePoint/uResolution;
+  // Spectral support is independent from refraction support. Press height
+  // supplies its existing clock; straight edges and caps have fitted widths.
+  float fringeWidth=mix(uLensFringe.z,uLensFringe.w,capWeight)*uLensField.z/11.2;
+  float fringe=pow(max(0.0,1.0-inside/max(.001,fringeWidth)),2.0);
+  float fringeGain=mix(uLensFringe.x,uLensFringe.y,capWeight);
+  vec2 dispersion=outward*uLensField.w*fringeGain*fringe/uResolution;
+  if(!allTerms&&mode!=17.0&&mode!=7.0)dispersion=vec2(0.0);
+  background=vec3(dockColour(uv+dispersion).r,dockColour(uv).g,dockColour(uv-dispersion).b);
+  // Face/output treatment, background highlights, independent SDF key/fill
+  // and diffuse lobes, then foreground. Never brighten the resting bar input.
+  float height=uLensLighting.z;
+  float offset=uLensLighting.w;
+  float faceClock=uLensLightingClock.x;
+  float lightClock=uLensLightingClock.y;
+  // Measured output crest in window points. Unlike the former finite-support
+  // lobe, this has no discontinuity at an interior mask offset. Directional
+  // key/fill and symmetric background terms retain separate output clocks.
+  float crest=exp(-.5*pow((inside-offset)/max(.001,height),2.0));
+  float nx=dot(outward,vec2(cos(uLensLightRotation),sin(uLensLightRotation)));
+  float key=crest*pow(max(nx,0.0),2.0);
+  float fill=crest*pow(max(-nx,0.0),2.0);
+  // A broad smooth diffuse term replaces the offset onset that made an inner
+  // contour. Width is 8 times the native-derived 6pt projection estimate.
+  float diffuse=mix(1.0,exp(-.5*pow(inside/max(.001,48.0*uLensLightingClock.z),2.0)),uLensFaceTreatment.y)*uLensLightingClock.w;
+  if(allTerms||mode==12.0){
+    float faceLuma=dot(background,vec3(.2126,.7152,.0722));
+    vec3 face=mix(vec3(faceLuma),background,uLensFaceTreatment.x);
+    background=mix(background,clamp(face*uLensLighting.x+uLensLighting.y,0.0,1.0),faceClock);
+  }
+  float H=0.0;
+  if(allTerms||mode==8.0||mode==13.0)H+=key*uLensLightStrength.x*lightClock;
+  if(allTerms||mode==8.0||mode==14.0)H+=fill*uLensLightStrength.y*lightClock;
+  if(allTerms||mode==8.0||mode==16.0)H+=crest*(pow(max(-outward.y,0.0),2.0)*uLensCrestVertical.x+pow(max(outward.y,0.0),2.0)*uLensCrestVertical.y)*lightClock;
+  if(allTerms||mode==8.0||mode==15.0)H+=diffuse*uLensLightStrength.z;
+  rimMask=crest*lightClock;
+  background=mix(background,vec3(1.0),clamp(H,0.0,.95));
+  // Neutral output shading is independent of spectral sampling. The narrow
+  // output rim and broader directional key/fill projection have separate clocks.
+  float shadeCap=mix(capWeight,1.0,uLensDepthIsotropic);
+  float shade=uLensDepthShade.x*faceClock
+    +uLensDepthShade.y*exp(-inside/1.2)*lightClock
+    +(uLensDepthShade.z*shadeCap+uLensDepthShade.w*(1.0-shadeCap))*exp(-inside/6.0)*uLensLightingClock.w;
+  // Isotropic button shading consumes available tonal contrast. A constant
+  // additive shade dirtied white faces and made a bright perimeter around them.
+  float shadeLuma=dot(background,vec3(.2126,.7152,.0722));
+  shade*=mix(1.0,clamp(4.0*shadeLuma*(1.0-shadeLuma),0.0,1.0),uLensDepthIsotropic);
+  // Controls: native's held lens darkens the upper half below its top rim (a top inner shadow),
+  // deepest ≈ 9 pt in and gone by the lens centre line; the lower half stays at the face level.
+  // Depth below the top edge, not the SDF: a horizontal band, so it never curls through the caps.
+  float topOffset=(uShape.w+p.y)-uLensTopShade.y;
+  float topScaled=topOffset/max(.001,topOffset<0.0?uLensTopShade.z:uLensTopShade.w);
+  shade+=uLensTopShade.x*exp(-.5*topScaled*topScaled)*(1.0-smoothstep(-1.0,1.0,p.y))*uLensLightingClock.w;
+  if(allTerms||mode==8.0)background=clamp(background+vec3(shade),0.0,1.0);
+  float edgeShift=max(0.0,uGlyphAnchors.x-uShape.x)-max(0.0,uShape.x-uGlyphAnchors.y);
+  // The cap folds a foreground stroke inward; the flat top must not pull
+  // a second gear into the highlight. This foreground field is independent
+  // of the backdrop transmission field.
+  float foregroundResponse=clamp(uForegroundChroma/255.0,0.0,1.0);
+  float label=step(uDockShape.y,point.y);
+  vec2 magnification=vec2(1.0+mix(uForegroundScaleX,uForegroundLabelScaleX,label),
+    1.0+mix(uForegroundScaleY,uForegroundLabelScaleY,label));
+  float capBend=3.0*abs(outward.x)*displacementProfile*foregroundResponse;
+  // Native magnifies each tab's content at its own anchor. Magnifying the
+  // atlas around the travelling lens center makes glyphs slide sideways and
+  // disappear into the wrong cap as the aperture crosses between tabs.
+  float lastIndex=max(0.0,uGlyphCount-1.0);
+  float spacing=max(1.0,(uGlyphAnchors.y-uGlyphAnchors.x)/max(1.0,lastIndex));
+  float anchorIndex=clamp(floor((point.x-uGlyphAnchors.x)/spacing+.5),0.0,lastIndex);
+  float anchor=uGlyphAnchors.x+anchorIndex*spacing;
+  vec2 glyphPoint=vec2(anchor+(point.x-anchor)/magnification.x,uShape.y+p.y/magnification.y);
+  // Fitting glyph-crop centres shows a leading-cap fold beyond the interior
+  // magnification. Its sigmoid is spatial, so the nearer stroke bends more.
+  float lead=sign(uTravelWarpPt);
+  vec3 fold=mix(uCapBendIcon,uCapBendLabel,label);
+  float leadingDistance=lead>0.0?uShape.x+uShape.z-point.x:point.x-(uShape.x-uShape.z);
+  float leadingFold=lead*fold.x/(1.0+exp(clamp((leadingDistance-fold.y)/fold.z,-30.0,30.0)));
+  glyphPoint.x-=leadingFold;
+  vec2 glyphUv=(glyphPoint-outward*capBend+vec2(edgeShift/magnification.x-mix(uForegroundShiftPt.x,uForegroundShiftPt.y,label)*uMotionMix,0.0))/uResolution;
+  vec2 soften=outward*.75*abs(outward.x)*exp(-inside/6.0)*foregroundResponse/uResolution;
+  bool selected=true;
+  if(selected){
+    glyph=texture(uGlyphSource,clamp(glyphUv,vec2(0.0),vec2(1.0)))*.4
+      +(texture(uGlyphSource,clamp(glyphUv+soften*.5,vec2(0.0),vec2(1.0)))
+        +texture(uGlyphSource,clamp(glyphUv-soften*.5,vec2(0.0),vec2(1.0))))*.24
+      +(texture(uGlyphSource,clamp(glyphUv+soften,vec2(0.0),vec2(1.0)))
+        +texture(uGlyphSource,clamp(glyphUv-soften,vec2(0.0),vec2(1.0))))*.06;
+    glyph.gb=clamp(glyph.gb+uGlyphVibrancy*glyph.a*uMotionMix,vec2(0.0),vec2(glyph.a));
+  }
+  // Foreground edge opacity falls from one at -14 local units to zero
+  // at the contour in the held sample. The conversion remains provisional.
+  if(allTerms||mode==18.0)glyph*=mix(1.0,clamp(inside/14.0,0.0,1.0),uLensLightingClock2.z);
+  if(!allTerms&&mode!=10.0&&mode!=18.0)glyph=vec4(0.0);
+}
+
+void main() {
+  if(uLiftMix<=0.0){finalColor=vec4(0.0);return;}
+  vec2 point=vFilterCoord*uResolution;
+  float sd=sdRoundRect(point-uShape.xy,uShape.zw,uRadius);
+  // Control rim (uLensCrestVertical.zw = dark line gain, width pt): device-pixel edge, crisp line.
+  float rimAa=uLensCrestVertical.w>0.0?.5/max(1.0,uLensDebug.y):.4;
+  float coverage=smoothstep(rimAa,-rimAa,sd);
+  vec3 transmitted;vec4 glyph;vec2 displacement;float rimMask;
+  movingLens(point,sd,transmitted,glyph,displacement,rimMask);
+  // 1 point displaces d framebuffer pixels here. Neutral blue=0, red=32px.
+  if(uLensDebug.x==1.0){float m=clamp(length(displacement)*uLensDebug.y/uLensDebug.z,0.0,1.0);finalColor=vec4(vec3(m,4.0*m*(1.0-m),1.0-m)*coverage,coverage);return;}
+  if(uLensDebug.x==2.0){finalColor=vec4(vec3(rimMask)*coverage,coverage);return;}
+  // RG encode signed x/y displacement around 0.5, at +/-32 framebuffer px.
+  if(uLensDebug.x==3.0){finalColor=vec4(vec3(vec2(.5)+displacement*uLensDebug.y/(2.0*uLensDebug.z),0.0)*coverage,coverage);return;}
+  vec3 rest=texture(uRestSource,clamp(vFilterCoord,vec2(0.0),vec2(1.0))).rgb;
+  vec3 body=mix(rest,transmitted,clamp(uLiftMix,0.0,1.0));
+  float rimPx=.5/max(1.0,uLensDebug.y);
+  body*=1.0-uLensCrestVertical.z*(1.0-smoothstep(uLensCrestVertical.w-rimPx,uLensCrestVertical.w+rimPx,max(0.0,-sd)))*clamp(uLiftMix,0.0,1.0);
+  // Foreground is premultiplied. Do not crossfade two differently warped glyphs.
+  // Gaussian half-plane approximation of the measured exterior shadow.
+  // Fit opacity/offset/spread outside the aperture, independent of face light.
+  float shadowDistance=sdRoundRect(point-uShape.xy-vec2(0.0,uLensExteriorShadow.y),uShape.zw,uRadius);
+  float z=shadowDistance/max(.001,uLensExteriorShadow.z)/1.41421356;
+  float t=1.0/(1.0+.3275911*abs(z));
+  float erf=sign(z)*(1.0-(((((1.061405429*t-1.453152027)*t)+1.421413741)*t-.284496736)*t+.254829592)*t*exp(-z*z));
+  float shadow=.5*(1.0-erf)*uLensExteriorShadow.x*uLensLightingClock2.y;
+  if(uLensDebug.x>=4.0&&uLensDebug.x!=9.0)shadow=0.0;
+  finalColor=vec4((body*(1.0-glyph.a)+glyph.rgb)*coverage,coverage+(1.0-coverage)*shadow);
+}`;

package/dist/glass/webgpu/sourcePixels.d.ts

@@ -0,0 +1,42 @@
+export { takeSourcePixels } from './preparedSourcePixels.js';
+type Transport = Pick<Worker, 'postMessage' | 'terminate' | 'onmessage' | 'onerror' | 'onmessageerror'>;
+/** Stages the bytes a document-owned renderer uploads for a capture.
+ *
+ * A capture canvas is read back on the page (`getImageData`): no bitmap is taken from the canvas
+ * and nothing leaves the thread. Measured in the Catalyst host for an accelerated 1320 px wide
+ * canvas: 21 to 27 ms for 14 MB, 43 ms for 29 MB, 54 to 63 ms for 41 MB, the same pixels as a
+ * bitmap of the canvas, and the canvas then costs nothing to redraw or release. The worker path
+ * it replaces for canvases (a bitmap copied to a texture and read back in an upload worker) took
+ * 136 to 281 ms for the 41 MB capture, during which WebKit presented no frame of the page.
+ *
+ * The readback returns straight alpha and the renderer uploads premultiplied bytes: the two are
+ * the same only for an opaque capture. Backdrop planes are opaque (their fill is,
+ * `effectiveBackground`); translucent captures (glyphs, region foregrounds) are never staged here.
+ *
+ * Any other image (a bitmap with no canvas behind it) goes to the upload worker, which moves the
+ * external-image import off the presentation thread without an alpha round trip. */
+export declare class SourcePixels {
+    private worker?;
+    private next;
+    private failure?;
+    private pending;
+    private create;
+    constructor(create?: () => Transport);
+    /** The upload worker failed (its device was lost, or a reply never came). The instance stays
+     * failed for images that need the worker: the bounded recovery of a source preparation replaces
+     * it (`ProductionGlassRuntime.replaceFailedSourcePixels`), so a failure is reported once per
+     * attempt and never retried in a loop. Canvas readbacks do not use the worker and still work. */
+    get failed(): boolean;
+    private fail;
+    /** Stage `image`'s premultiplied bytes for its upload (`takeSourcePixels`). When `capture` is a
+     * canvas it is read back here (see the class comment) and the rest of this comment does not apply.
+     *
+     * The upload worker needs a bitmap of its own (a transferred bitmap is gone from this thread,
+     * and the renderer keeps `image` to restore a lost device). `capture` is what that second bitmap
+     * is taken from: pass the canvas `image` was snapshotted from, unchanged since. A second
+     * snapshot of the canvas took under 3 ms. Copying the snapshot itself
+     * (`createImageBitmap(image)`, the default) blocked the main thread for 5 to 6 ms per megabyte
+     * in WebKit (157 ms for a 1320 x 5091 capture in the Catalyst host), more than half of the
+     * stage. Measured for captures up to 1320 x 6495; the cause inside WebKit was not sampled. */
+    prepare(image: ImageBitmap, capture?: ImageBitmapSource): Promise<void>;
+}

package/dist/glass/webgpu/sourcePixels.js

@@ -0,0 +1,140 @@
+import { reportGlassError } from '../errors.js';
+import { glassNow, glassTiming } from './profile.js';
+import { keepSourcePixels, prepared } from './preparedSourcePixels.js';
+export { takeSourcePixels } from './preparedSourcePixels.js';
+/** The pixels of a capture canvas, read back from its 2D context (straight RGBA, rows top first);
+ * undefined when `capture` is not a canvas with a 2D context. */
+function canvasPixels(capture) {
+    const canvas = capture;
+    if (typeof canvas.getContext !== 'function' || !canvas.width || !canvas.height)
+        return undefined;
+    const context = canvas.getContext('2d');
+    if (!context || typeof context.getImageData !== 'function')
+        return undefined;
+    return context.getImageData(0, 0, canvas.width, canvas.height).data;
+}
+/** Stages the bytes a document-owned renderer uploads for a capture.
+ *
+ * A capture canvas is read back on the page (`getImageData`): no bitmap is taken from the canvas
+ * and nothing leaves the thread. Measured in the Catalyst host for an accelerated 1320 px wide
+ * canvas: 21 to 27 ms for 14 MB, 43 ms for 29 MB, 54 to 63 ms for 41 MB, the same pixels as a
+ * bitmap of the canvas, and the canvas then costs nothing to redraw or release. The worker path
+ * it replaces for canvases (a bitmap copied to a texture and read back in an upload worker) took
+ * 136 to 281 ms for the 41 MB capture, during which WebKit presented no frame of the page.
+ *
+ * The readback returns straight alpha and the renderer uploads premultiplied bytes: the two are
+ * the same only for an opaque capture. Backdrop planes are opaque (their fill is,
+ * `effectiveBackground`); translucent captures (glyphs, region foregrounds) are never staged here.
+ *
+ * Any other image (a bitmap with no canvas behind it) goes to the upload worker, which moves the
+ * external-image import off the presentation thread without an alpha round trip. */
+export class SourcePixels {
+    worker;
+    next = 0;
+    failure;
+    pending = new Map();
+    create;
+    constructor(create = () => new Worker(new URL('./sourcePixels.worker.js', import.meta.url), {
+        type: 'module',
+        name: 'satin-source-upload',
+    })) {
+        this.create = create;
+    }
+    /** The upload worker failed (its device was lost, or a reply never came). The instance stays
+     * failed for images that need the worker: the bounded recovery of a source preparation replaces
+     * it (`ProductionGlassRuntime.replaceFailedSourcePixels`), so a failure is reported once per
+     * attempt and never retried in a loop. Canvas readbacks do not use the worker and still work. */
+    get failed() {
+        return !!this.failure;
+    }
+    fail(error) {
+        this.failure = error;
+        this.worker?.terminate();
+        this.worker = undefined;
+        reportGlassError('worker-startup', error, 'source upload worker');
+        for (const job of this.pending.values()) {
+            clearTimeout(job.timer);
+            job.reject(error);
+        }
+        this.pending.clear();
+    }
+    /** Stage `image`'s premultiplied bytes for its upload (`takeSourcePixels`). When `capture` is a
+     * canvas it is read back here (see the class comment) and the rest of this comment does not apply.
+     *
+     * The upload worker needs a bitmap of its own (a transferred bitmap is gone from this thread,
+     * and the renderer keeps `image` to restore a lost device). `capture` is what that second bitmap
+     * is taken from: pass the canvas `image` was snapshotted from, unchanged since. A second
+     * snapshot of the canvas took under 3 ms. Copying the snapshot itself
+     * (`createImageBitmap(image)`, the default) blocked the main thread for 5 to 6 ms per megabyte
+     * in WebKit (157 ms for a 1320 x 5091 capture in the Catalyst host), more than half of the
+     * stage. Measured for captures up to 1320 x 6495; the cause inside WebKit was not sampled. */
+    async prepare(image, capture = image) {
+        const readbackStarted = glassNow();
+        const pixels = canvasPixels(capture);
+        if (pixels) {
+            const canvas = capture;
+            // The bytes are uploaded at the image's row length: they must be that image.
+            if (canvas.width !== image.width || canvas.height !== image.height)
+                throw Error(`Glass capture canvas ${canvas.width}x${canvas.height} is not its ${image.width}x${image.height} image`);
+            keepSourcePixels(image, pixels);
+            glassTiming('source-readback', readbackStarted, `${image.width}x${image.height}`);
+            return;
+        }
+        if (this.failure)
+            throw this.failure;
+        if (!this.worker) {
+            this.worker = this.create();
+            this.worker.onmessage = event => {
+                const data = event.data;
+                if (data.id === 0 && data.error) {
+                    this.fail(Error(data.error));
+                    return;
+                }
+                const job = this.pending.get(data.id);
+                if (!job)
+                    return;
+                this.pending.delete(data.id);
+                clearTimeout(job.timer);
+                if (data.error) {
+                    job.reject(Error(data.error));
+                    return;
+                }
+                if (!(data.buffer instanceof ArrayBuffer) ||
+                    data.width !== job.image.width ||
+                    data.height !== job.image.height ||
+                    data.buffer.byteLength !== job.image.width * job.image.height * 4) {
+                    job.reject(Error('Source upload worker returned invalid pixel dimensions'));
+                    return;
+                }
+                prepared.set(job.image, new Uint8Array(data.buffer));
+                job.resolve();
+            };
+            this.worker.onerror = event => this.fail(Error(event.message || 'Source upload worker failed'));
+            this.worker.onmessageerror = () => this.fail(Error('Source upload worker reply could not be decoded'));
+        }
+        const started = glassNow(), clone = await createImageBitmap(capture);
+        if (this.failure) {
+            clone.close();
+            throw this.failure;
+        }
+        const id = ++this.next;
+        try {
+            await new Promise((resolve, reject) => {
+                const timer = setTimeout(() => this.fail(Error('Source upload worker exceeded 10 seconds')), 10000);
+                this.pending.set(id, { image, resolve, reject, timer });
+                try {
+                    this.worker.postMessage({ id, bitmap: clone }, [clone]);
+                }
+                catch (error) {
+                    clone.close();
+                    this.pending.delete(id);
+                    clearTimeout(timer);
+                    reject(error);
+                }
+            });
+        }
+        finally {
+            glassTiming('source-worker-upload', started, `${image.width}x${image.height}`);
+        }
+    }
+}

package/dist/glass/webgpu/sourcePixels.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/glass/webgpu/sourcePixels.worker.js

@@ -0,0 +1,62 @@
+import { glassDeviceLimits } from './deviceLimits.js';
+// No 2D getImageData: unpremultiply/premultiply changes translucent edge bytes.
+const scope = globalThis;
+let gpu, serial = Promise.resolve();
+function device() {
+    return (gpu ??= (async () => {
+        const adapter = await navigator.gpu.requestAdapter();
+        if (!adapter)
+            throw Error('Source upload worker has no WebGPU adapter');
+        const result = await adapter.requestDevice({ requiredLimits: glassDeviceLimits(adapter) });
+        result.lost.then(info => scope.postMessage({
+            id: 0,
+            error: `Source upload device lost: ${info.reason} ${info.message}`,
+        }));
+        result.addEventListener('uncapturederror', event => scope.postMessage({
+            id: 0,
+            error: `Source upload GPU error: ${event.error.message}`,
+        }));
+        return result;
+    })());
+}
+scope.onmessage = ({ data: { id, bitmap } }) => {
+    serial = serial.then(async () => {
+        let texture, buffer, mapped = false;
+        try {
+            const gpu = await device(), width = bitmap.width, height = bitmap.height, pitch = Math.ceil((width * 4) / 256) * 256;
+            texture = gpu.createTexture({
+                size: [width, height],
+                format: 'rgba8unorm',
+                usage: GPUTextureUsage.COPY_DST |
+                    GPUTextureUsage.COPY_SRC |
+                    GPUTextureUsage.TEXTURE_BINDING |
+                    GPUTextureUsage.RENDER_ATTACHMENT,
+            });
+            gpu.queue.copyExternalImageToTexture({ source: bitmap }, { texture, premultipliedAlpha: true, colorSpace: 'srgb' }, [width, height]);
+            buffer = gpu.createBuffer({
+                size: pitch * height,
+                usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+            });
+            const encoder = gpu.createCommandEncoder();
+            encoder.copyTextureToBuffer({ texture }, { buffer, bytesPerRow: pitch }, [width, height]);
+            gpu.queue.submit([encoder.finish()]);
+            await buffer.mapAsync(GPUMapMode.READ);
+            mapped = true;
+            const source = new Uint8Array(buffer.getMappedRange()), bytes = new Uint8Array(width * height * 4);
+            for (let y = 0; y < height; y++)
+                bytes.set(source.subarray(y * pitch, y * pitch + width * 4), y * width * 4);
+            scope.postMessage({ id, width, height, buffer: bytes.buffer }, [bytes.buffer]);
+        }
+        catch (error) {
+            scope.postMessage({ id, error: String(error) });
+        }
+        finally {
+            if (mapped)
+                buffer?.unmap();
+            buffer?.destroy();
+            texture?.destroy();
+            bitmap.close();
+        }
+    });
+};
+export {};

package/dist/glass/webgpu/tabGlyphInk.d.ts

@@ -0,0 +1,14 @@
+/** The vertical band of the sample rectangle that a layered ink plane stores. Ink lives only
+ * inside the bar frame; the backdrop's vertical overscan (128 pt each side) never holds any, so
+ * storing it would make two planes cost twice the flat atlas instead of about half of it. */
+export declare function tabInkBand(spec: {
+    sampleInsetY: number;
+    frameHeight: number;
+}, resolution: number): {
+    top: number;
+    pixels: number;
+    height: number;
+};
+/** Complete semantic ink planes share one cached texture and one foreground composition.
+ * The legacy flat atlas remains available to optical fixtures and non-tab controls. */
+export declare const tabGlyphInkShader = "\nfn tabInkSample(uv: vec2<f32>, label: f32) -> vec4<f32> {\n    if (global.uGlyphLayers_slot.x == 0.0) {\n        return textureSample(uGlyphSource_texture, sourceSampler, clamp(uv, vec2(0.0), vec2(1.0)));\n    }\n    let size = vec2<f32>(textureDimensions(uGlyphSource_texture));\n    let halfTexel = 0.5 / size;\n    // Each plane stores only its band of the sample rectangle (tabInkBand): y = band top, scale.\n    let band = (uv.y - global.uGlyphLayers_slot.y) * global.uGlyphLayers_slot.z;\n    // Each plane has its own transparent border. Filtering must never reach the other plane.\n    let point = vec2<f32>(uv.x, (band + label) * 0.5);\n    let low = vec2<f32>(halfTexel.x, label * 0.5 + halfTexel.y);\n    let high = vec2<f32>(1.0 - halfTexel.x, (label + 1.0) * 0.5 - halfTexel.y);\n    return textureSample(uGlyphSource_texture, sourceSampler, clamp(point, low, high));\n}\n\nfn tabInkPlane(point: vec2<f32>, local: vec2<f32>, rimShift: vec2<f32>, outward: vec2<f32>,\n    inside: f32, label: f32) -> vec4<f32> {\n    let response = clamp(global.uForegroundChroma_slot.x / 255.0, 0.0, 1.0);\n    let scale = vec2<f32>(\n        1.0 + mix(global.uForegroundScaleX_slot.x, global.uForegroundLabelScaleX_slot.x, label),\n        1.0 + mix(global.uForegroundScaleY_slot.x, global.uForegroundLabelScaleY_slot.x, label));\n    let anchors = global.uGlyphAnchors_slot.xy;\n    let shape = global.uShape_slot;\n    let last = max(0.0, global.uGlyphCount_slot.x - 1.0);\n    let spacing = max(1.0, (anchors.y - anchors.x) / max(1.0, last));\n    let index = clamp(floor((point.x - anchors.x) / spacing + 0.5), 0.0, last);\n    let anchor = anchors.x + index * spacing;\n    let edgeShift = max(0.0, anchors.x - shape.x) - max(0.0, shape.x - anchors.y);\n    // Ink refracts with the backdrop: the rim term is the lens's own continuous displacement,\n    // zero in the flat interior. It never depends on travel direction, so a glyph straddling\n    // the rim is squeezed into the rim band like native, never translated out of the lens.\n    let source = vec2<f32>(anchor + (point.x - anchor) / scale.x, shape.y + local.y / scale.y) + rimShift;\n    let shift = mix(global.uForegroundShiftPt_slot.x, global.uForegroundShiftPt_slot.y, label);\n    let resolution = global.uResolution_slot.xy;\n    let uv = (source + vec2<f32>(edgeShift / scale.x - shift * global.uMotionMix_slot.x, 0.0)) / resolution;\n    let soften = outward * 0.75 * abs(outward.x) * exp(-inside / 6.0) * response / resolution;\n    let center = tabInkSample(uv, label);\n    // Flat interior/top/bottom regions have no horizontal edge softening. The five old reads\n    // were identical there. Keep the fitted filter at curved edges, without redundant reads.\n    if (all(soften == vec2(0.0))) { return center; }\n    return center * 0.4 +\n        (tabInkSample(uv + soften * 0.5, label) + tabInkSample(uv - soften * 0.5, label)) * 0.24 +\n        (tabInkSample(uv + soften, label) + tabInkSample(uv - soften, label)) * 0.06;\n}\n\nfn tabGlyphInk(point: vec2<f32>, local: vec2<f32>, rimShift: vec2<f32>, outward: vec2<f32>,\n    inside: f32) -> vec4<f32> {\n    var ink: vec4<f32>;\n    if (global.uGlyphLayers_slot.x > 0.0) {\n        let icon = tabInkPlane(point, local, rimShift, outward, inside, 0.0);\n        let label = tabInkPlane(point, local, rimShift, outward, inside, 1.0);\n        ink = label + icon * (1.0 - label.a);\n    } else {\n        ink = tabInkPlane(point, local, rimShift, outward, inside, step(global.uDockShape_slot.y, point.y));\n    }\n    ink = vec4<f32>(ink.r, clamp(ink.gb + global.uGlyphVibrancy_slot.xy * ink.a *\n        global.uMotionMix_slot.x, vec2(0.0), vec2(ink.a)), ink.a);\n    return ink;\n}\n";

package/dist/glass/webgpu/tabGlyphInk.js

@@ -0,0 +1,72 @@
+/** Transparent border kept above and below the bar frame in each layered ink plane. */
+const TAB_INK_MARGIN_PT = 8;
+/** The vertical band of the sample rectangle that a layered ink plane stores. Ink lives only
+ * inside the bar frame; the backdrop's vertical overscan (128 pt each side) never holds any, so
+ * storing it would make two planes cost twice the flat atlas instead of about half of it. */
+export function tabInkBand(spec, resolution) {
+    const pixels = Math.ceil((spec.frameHeight + TAB_INK_MARGIN_PT * 2) * resolution);
+    return { top: spec.sampleInsetY - TAB_INK_MARGIN_PT, pixels, height: pixels / resolution };
+}
+/** Complete semantic ink planes share one cached texture and one foreground composition.
+ * The legacy flat atlas remains available to optical fixtures and non-tab controls. */
+export const tabGlyphInkShader = /* wgsl */ `
+fn tabInkSample(uv: vec2<f32>, label: f32) -> vec4<f32> {
+    if (global.uGlyphLayers_slot.x == 0.0) {
+        return textureSample(uGlyphSource_texture, sourceSampler, clamp(uv, vec2(0.0), vec2(1.0)));
+    }
+    let size = vec2<f32>(textureDimensions(uGlyphSource_texture));
+    let halfTexel = 0.5 / size;
+    // Each plane stores only its band of the sample rectangle (tabInkBand): y = band top, scale.
+    let band = (uv.y - global.uGlyphLayers_slot.y) * global.uGlyphLayers_slot.z;
+    // Each plane has its own transparent border. Filtering must never reach the other plane.
+    let point = vec2<f32>(uv.x, (band + label) * 0.5);
+    let low = vec2<f32>(halfTexel.x, label * 0.5 + halfTexel.y);
+    let high = vec2<f32>(1.0 - halfTexel.x, (label + 1.0) * 0.5 - halfTexel.y);
+    return textureSample(uGlyphSource_texture, sourceSampler, clamp(point, low, high));
+}
+
+fn tabInkPlane(point: vec2<f32>, local: vec2<f32>, rimShift: vec2<f32>, outward: vec2<f32>,
+    inside: f32, label: f32) -> vec4<f32> {
+    let response = clamp(global.uForegroundChroma_slot.x / 255.0, 0.0, 1.0);
+    let scale = vec2<f32>(
+        1.0 + mix(global.uForegroundScaleX_slot.x, global.uForegroundLabelScaleX_slot.x, label),
+        1.0 + mix(global.uForegroundScaleY_slot.x, global.uForegroundLabelScaleY_slot.x, label));
+    let anchors = global.uGlyphAnchors_slot.xy;
+    let shape = global.uShape_slot;
+    let last = max(0.0, global.uGlyphCount_slot.x - 1.0);
+    let spacing = max(1.0, (anchors.y - anchors.x) / max(1.0, last));
+    let index = clamp(floor((point.x - anchors.x) / spacing + 0.5), 0.0, last);
+    let anchor = anchors.x + index * spacing;
+    let edgeShift = max(0.0, anchors.x - shape.x) - max(0.0, shape.x - anchors.y);
+    // Ink refracts with the backdrop: the rim term is the lens's own continuous displacement,
+    // zero in the flat interior. It never depends on travel direction, so a glyph straddling
+    // the rim is squeezed into the rim band like native, never translated out of the lens.
+    let source = vec2<f32>(anchor + (point.x - anchor) / scale.x, shape.y + local.y / scale.y) + rimShift;
+    let shift = mix(global.uForegroundShiftPt_slot.x, global.uForegroundShiftPt_slot.y, label);
+    let resolution = global.uResolution_slot.xy;
+    let uv = (source + vec2<f32>(edgeShift / scale.x - shift * global.uMotionMix_slot.x, 0.0)) / resolution;
+    let soften = outward * 0.75 * abs(outward.x) * exp(-inside / 6.0) * response / resolution;
+    let center = tabInkSample(uv, label);
+    // Flat interior/top/bottom regions have no horizontal edge softening. The five old reads
+    // were identical there. Keep the fitted filter at curved edges, without redundant reads.
+    if (all(soften == vec2(0.0))) { return center; }
+    return center * 0.4 +
+        (tabInkSample(uv + soften * 0.5, label) + tabInkSample(uv - soften * 0.5, label)) * 0.24 +
+        (tabInkSample(uv + soften, label) + tabInkSample(uv - soften, label)) * 0.06;
+}
+
+fn tabGlyphInk(point: vec2<f32>, local: vec2<f32>, rimShift: vec2<f32>, outward: vec2<f32>,
+    inside: f32) -> vec4<f32> {
+    var ink: vec4<f32>;
+    if (global.uGlyphLayers_slot.x > 0.0) {
+        let icon = tabInkPlane(point, local, rimShift, outward, inside, 0.0);
+        let label = tabInkPlane(point, local, rimShift, outward, inside, 1.0);
+        ink = label + icon * (1.0 - label.a);
+    } else {
+        ink = tabInkPlane(point, local, rimShift, outward, inside, step(global.uDockShape_slot.y, point.y));
+    }
+    ink = vec4<f32>(ink.r, clamp(ink.gb + global.uGlyphVibrancy_slot.xy * ink.a *
+        global.uMotionMix_slot.x, vec2(0.0), vec2(ink.a)), ink.a);
+    return ink;
+}
+`;

package/dist/glass/webgpu/touchLight.d.ts

@@ -0,0 +1,4 @@
+import type { GlassTouchLight } from '../renderSpecs.js';
+import type { Values } from './passes.js';
+/** The material kernel consumes the field in its sampling texture's CSS coordinates. */
+export declare function touchLightUniforms(light: GlassTouchLight | undefined, insetX: number, insetY: number): Values;

package/dist/glass/webgpu/touchLight.js

@@ -0,0 +1,15 @@
+/** The material kernel consumes the field in its sampling texture's CSS coordinates. */
+export function touchLightUniforms(light, insetX, insetY) {
+    if (!light)
+        return { uTouchLight: [0, 0, 1, 0], uTouchLightColour: [1, 1, 1, 0] };
+    if (![light.x, light.y, light.radius, light.intensity, ...light.colour].every(Number.isFinite) ||
+        light.radius <= 0 ||
+        light.intensity < 0 ||
+        light.intensity > 1 ||
+        light.colour.some(channel => channel < 0 || channel > 1))
+        throw Error('Invalid glass touch light');
+    return {
+        uTouchLight: [light.x + insetX, light.y + insetY, light.radius, light.intensity],
+        uTouchLightColour: [...light.colour, 0],
+    };
+}

package/dist/glass/worker/client.d.ts

@@ -0,0 +1,21 @@
+import type { GlassLayer } from '../webgpu/layers.js';
+import type { Request } from './protocol.js';
+export declare class WorkerGlassClient {
+    private worker?;
+    private nextId;
+    private pending;
+    private failed?;
+    private frames;
+    backend: 'webgpu';
+    private visibility;
+    readonly work: {
+        at: number;
+        ms: number;
+    }[];
+    init(canvas: HTMLCanvasElement, resolution: number): Promise<void>;
+    private initialize;
+    attachLayer(canvas: HTMLCanvasElement, layer: GlassLayer): Promise<unknown>;
+    request(request: Request, transfer?: Transferable[]): Promise<unknown>;
+    pose(x: number, at: number): void;
+    park(): Promise<unknown>;
+}