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

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

@@ -0,0 +1,19 @@
+import type { FrameGraph } from './frameGraph.js';
+import { type Passes, type Target, type Values } from './passes.js';
+import { type ResultLayout } from './rasterUniforms.js';
+/** The surface's material into the material target: a presentation treatment (context menu
+ * backdrop/preview, alert, sheet), the clear variant, or the material bar/menu material with
+ * its tint; a context menu then gets its shadow. */
+/** Whether a surface's resting material is the bar kernel (not a menu, a presentation
+ * treatment or clear glass). */
+export declare function usesBarKernel(spec: ResultLayout['spec']): boolean;
+/** Whether the blur pyramid is the bar material's (areaMips.ts): exact area averages over
+ * storage padded to whole coarse texels, so the glass's interior brightness over a still
+ * backdrop does not follow the surface's size. Every surface the bar kernel draws: the tab bar,
+ * its accessory, toolbar and glass buttons. Menus and presentation treatments keep the chained
+ * pyramid their materials were fitted on. */
+export declare function usesAreaMips(spec: ResultLayout['spec']): boolean;
+export declare function encodeMaterial(encoder: GPUCommandEncoder, passes: Passes, targets: Record<string, Target>, layout: ResultLayout, material: Values): void;
+/** The tab bar's selection pill (native selection recipe) and, while the pill lifts, its lens,
+ * over a composed scratch of the backdrop and the bar material. */
+export declare function encodeTabSelection(encoder: GPUCommandEncoder, passes: Passes, targets: Record<string, Target>, graph: FrameGraph, layout: ResultLayout, baseKey: string): void;

package/dist/glass/webgpu/rasterMaterial.js

@@ -0,0 +1,197 @@
+import { morphFieldUniforms, morphFieldSampleBounds } from '../morphField.js';
+import { contextBackdropFit, contextPreviewShadow, contextMenuShadow } from './contextComposite.js';
+import { viewOf } from './passes.js';
+import { alertDiffusionUniforms } from './presentationDiffusion.js';
+import { presentationBlurUniforms, presentationUniforms } from './presentationMaterial.js';
+import { clearRestValues } from './restMaterial.js';
+import { fieldInkUniforms } from './fieldInk.js';
+import { touchLightUniforms } from './touchLight.js';
+import { dockGlyphAnchors, glyphVibrancy, inputUniforms, outputUniforms, selectionBaseUniforms, selectionBlurUniforms, selectionPillUniforms, shapeUniform, } from './rasterUniforms.js';
+// The material and tab-selection passes of a raster's result (raster.ts encodeResult).
+/** The surface's material into the material target: a presentation treatment (context menu
+ * backdrop/preview, alert, sheet), the clear variant, or the material bar/menu material with
+ * its tint; a context menu then gets its shadow. */
+/** Whether a surface's resting material is the bar kernel (not a menu, a presentation
+ * treatment or clear glass). */
+export function usesBarKernel(spec) {
+    const material = !spec.treatment || spec.treatment === 'contextMenu';
+    return material && spec.variant !== 'clear' && spec.materialProfile !== 'menu';
+}
+/** Whether the blur pyramid is the bar material's (areaMips.ts): exact area averages over
+ * storage padded to whole coarse texels, so the glass's interior brightness over a still
+ * backdrop does not follow the surface's size. Every surface the bar kernel draws: the tab bar,
+ * its accessory, toolbar and glass buttons. Menus and presentation treatments keep the chained
+ * pyramid their materials were fitted on. */
+export function usesAreaMips(spec) {
+    return usesBarKernel(spec);
+}
+export function encodeMaterial(encoder, passes, targets, layout, material) {
+    const { spec, appearance, resolution, sampleWidth, sampleHeight } = layout;
+    const fieldBounds = morphFieldSampleBounds(spec);
+    const fieldScissor = fieldBounds?.map(value => value * resolution);
+    const first = spec.shape.first;
+    if (spec.treatment === 'contextBackdrop' || spec.treatment === 'contextPreview') {
+        const fit = contextBackdropFit[appearance];
+        const preview = spec.treatment === 'contextPreview';
+        const values = {
+            uResolution: [sampleWidth, sampleHeight],
+            uShape: shapeUniform(spec, first),
+            uRadius: first.radius,
+            uFilter: [preview ? 0 : fit.sigma, 1, 0, 0],
+            uAxis: [1, 0],
+            uShadow: [0, 0, 0],
+        };
+        passes.kernel(encoder, 'contextComposite', targets.presentationHorizontal, values, {
+            uTexture: preview ? targets.glyphs : targets.source,
+        });
+        passes.kernel(encoder, 'contextComposite', targets.material, {
+            ...values,
+            uAxis: [0, 1],
+            uShadow: preview ? contextPreviewShadow : [0, 0, 0],
+            uFilter: [preview ? 0 : fit.sigma, preview ? 1 : fit.gain, preview ? 0 : fit.bias, 0],
+        }, { uTexture: targets.presentationHorizontal });
+    }
+    else if (spec.treatment === 'alert' ||
+        spec.treatment === 'confirmation' ||
+        spec.treatment === 'sheet') {
+        const diffusion = spec.treatment === 'sheet' ? 'sheetDiffusion' : 'presentationDiffusion';
+        const mip = Math.max(0, Math.log2(resolution * 0.5));
+        passes.kernel(encoder, diffusion, targets.presentationHorizontal, alertDiffusionUniforms(sampleWidth, sampleHeight, [1, 0], targets.pyramid.width, targets.pyramid.height, resolution * 0.5, mip), { uTexture: targets.pyramid });
+        passes.kernel(encoder, diffusion, targets.presentationVertical, alertDiffusionUniforms(sampleWidth, sampleHeight, [0, 1], targets.presentationHorizontal.width, targets.presentationHorizontal.height), { uTexture: targets.presentationHorizontal });
+        passes.kernel(encoder, 'presentation', targets.material, presentationUniforms(spec, appearance), {
+            uTexture: targets.presentationVertical,
+        });
+    }
+    else if (spec.treatment && spec.treatment !== 'contextMenu') {
+        passes.kernel(encoder, 'presentationBlur', targets.presentationHorizontal, presentationBlurUniforms(spec, [1, 0]), { uTexture: targets.source });
+        passes.kernel(encoder, 'presentationBlur', targets.presentationVertical, presentationBlurUniforms(spec, [0, 1]), { uTexture: targets.presentationHorizontal });
+        passes.kernel(encoder, 'presentation', targets.material, presentationUniforms(spec, appearance), {
+            uTexture: targets.presentationVertical,
+        });
+    }
+    else if (spec.variant === 'clear') {
+        const values = {
+            ...clearRestValues(spec),
+            ...inputUniforms(targets.source, sampleWidth, sampleHeight),
+        };
+        passes.kernel(encoder, 'clearBlur', targets.clearHorizontal, { ...values, uAxis: [1, 0] }, { uTexture: targets.source });
+        passes.kernel(encoder, 'clearBlur', targets.clearVertical, { ...values, uAxis: [0, 1] }, { uTexture: targets.clearHorizontal });
+        passes.kernel(encoder, 'clear', targets.material, values, { uTexture: targets.clearVertical });
+    }
+    else {
+        const kernel = usesBarKernel(spec) ? 'bar' : 'menu';
+        passes.kernel(encoder, kernel, targets.material, material, { uTexture: targets.pyramid, uSource: targets.source }, false, fieldScissor);
+        if (spec.tint?.[3]) {
+            passes.kernel(encoder, 'tint', targets.tinted, {
+                ...morphFieldUniforms(spec),
+                uTint: spec.tint,
+                uResolution: [sampleWidth, sampleHeight],
+                uShape: shapeUniform(spec, first),
+                uRadius: first.radius,
+                ...touchLightUniforms(undefined, 0, 0),
+            }, { uTexture: targets.material }, false, fieldScissor);
+            const previousMaterial = targets.material;
+            targets.material = targets.tinted;
+            targets.tinted = previousMaterial;
+        }
+        // Ink inside the field (a menu's rows and trigger glyph), lensed by its rim, over the material.
+        if (spec.ink && spec.shape.members?.length) {
+            const field = morphFieldUniforms(spec);
+            for (const layer of spec.ink.layers)
+                passes.kernel(encoder, 'ink', targets.material, fieldInkUniforms(spec, spec.ink.atlas, layer, field, resolution), { uTexture: targets.glyphs }, true, fieldScissor);
+        }
+    }
+    const highlight = spec.memberHighlight;
+    const highlightedMember = highlight && spec.shape.members?.[highlight.member];
+    if (highlightedMember && (highlight.amount > 0 || (highlight.light?.intensity ?? 0) > 0)) {
+        // Reuse the tint kernel with a singleton mask. The material and final aperture
+        // remain the complete blended field, including all untouched neighbours. The member's
+        // touch light is drawn here too, so it stays inside the pressed member.
+        const mask = {
+            ...spec,
+            shape: {
+                ...spec.shape,
+                first: highlightedMember,
+                members: [highlightedMember],
+                blendRadius: 0,
+            },
+        };
+        passes.kernel(encoder, 'tint', targets.tinted, {
+            ...morphFieldUniforms(mask),
+            uTint: [1, 1, 1, highlight.amount],
+            uResolution: [sampleWidth, sampleHeight],
+            uShape: shapeUniform(spec, highlightedMember),
+            uRadius: highlightedMember.radius,
+            ...touchLightUniforms(highlight.light, spec.sampleInsetX, spec.sampleInsetY),
+        }, { uTexture: targets.material }, false, fieldScissor);
+        const previousMaterial = targets.material;
+        targets.material = targets.tinted;
+        targets.tinted = previousMaterial;
+    }
+    if (spec.treatment === 'contextMenu') {
+        passes.kernel(encoder, 'contextComposite', targets.presentationVertical, {
+            uResolution: [sampleWidth, sampleHeight],
+            uShape: shapeUniform(spec, first),
+            uRadius: [first.radius, 1],
+            uFilter: [0, 1, 0, 0],
+            uAxis: [0, 0],
+            uShadow: contextMenuShadow,
+        }, { uTexture: targets.material });
+        passes.copy(encoder, viewOf(targets.presentationVertical.texture), viewOf(targets.material.texture));
+    }
+}
+/** The tab bar's selection pill (native selection recipe) and, while the pill lifts, its lens,
+ * over a composed scratch of the backdrop and the bar material. */
+export function encodeTabSelection(encoder, passes, targets, graph, layout, baseKey) {
+    const { spec, appearance, resolution, sampleWidth, sampleHeight } = layout;
+    passes.copy(encoder, viewOf(targets.source.texture), viewOf(targets.composed.texture));
+    passes.copy(encoder, viewOf(targets.material.texture), viewOf(targets.composed.texture), 'rgba8unorm', true, true);
+    const selection = spec.tabSelection;
+    const lensMix = selection.lensMix ?? 0;
+    const base = selectionBaseUniforms(layout, targets.composed);
+    if (lensMix < 1) {
+        const blur = selectionBlurUniforms(layout, targets.composed);
+        passes.kernel(encoder, 'gaussian', targets.horizontal, {
+            ...blur,
+            __viewport: [sampleWidth * resolution * 0.25, sampleHeight * resolution * 0.25],
+        }, { uTexture: targets.composed });
+        passes.kernel(encoder, 'gaussian', targets.vertical, {
+            ...blur,
+            ...inputUniforms(targets.horizontal, sampleWidth, sampleHeight),
+            uStep: [0, 1 / targets.vertical.height],
+            uCross: [0, 0],
+        }, { uTexture: targets.horizontal });
+        passes.kernel(encoder, 'pill', targets.result, selectionPillUniforms(layout, base, targets.vertical), { uTexture: targets.composed, uSelectionTexture: targets.vertical }, true);
+    }
+    // Ink over a single-shape surface (the scope bar's labels, in its foreground atlas's sample
+    // space) sits above the pill like the page text it replaces; the lens that follows bends it.
+    if (spec.ink && !spec.shape.members?.length) {
+        const field = morphFieldUniforms({
+            ...spec,
+            shape: { ...spec.shape, members: [spec.shape.first] },
+        });
+        for (const layer of spec.ink.layers)
+            passes.kernel(encoder, 'ink', targets.result, {
+                ...fieldInkUniforms(spec, spec.ink.atlas, layer, field, resolution),
+                ...outputUniforms(layout, sampleWidth, sampleHeight),
+            }, { uTexture: targets.glyphs }, true);
+    }
+    if (lensMix > 0) {
+        const count = Math.max(1, selection.glyphCount ?? 4);
+        passes.kernel(encoder, 'lens', targets.result, {
+            ...base,
+            uMaterialMix: selection.materialMix * lensMix,
+            uGlyphAnchors: selection.glyphAnchors
+                ? selection.glyphAnchors.map(x => x + spec.sampleInsetX)
+                : dockGlyphAnchors(spec, count),
+            uGlyphCount: count,
+            uDockShape: shapeUniform(spec, spec.shape.first),
+            uGlyphVibrancy: glyphVibrancy(appearance),
+        }, {
+            uTexture: targets.composed,
+            uClearSource: targets.composed,
+            uGlyphSource: targets.glyphs,
+        }, true);
+    }
+    graph.mark(targets.composed, baseKey);
+}

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

@@ -0,0 +1,7 @@
+export declare const compositeSource = "@vertex fn vertex(@builtin(vertex_index) i:u32)->@builtin(position) vec4f {let p=array<vec2f,3>(vec2f(-1,1),vec2f(3,1),vec2f(-1,-3))[i];return vec4f(p,0,1);}\nstruct P { size:vec4f, origin:vec4f, background:vec4f, source:vec4f, route:vec4f, atlas:array<vec4f,8>, atlasCount:vec4f, viewportScale:vec4f, zoom:array<vec4f,8>, clip:array<vec4f,8> }\n@group(0) @binding(0) var<uniform> p:P;\n@group(0) @binding(1) var s:sampler;\n@group(0) @binding(2) var front:texture_2d<f32>;\n@group(0) @binding(3) var rear:texture_2d<f32>;\nfn openFill(v:f32)->bool {\n let open=u32(p.source.w);\n return (v<0 && (open&1u)!=0u) || (v>1 && (open&2u)!=0u);\n}\n@fragment fn fragment(@builtin(position) pos:vec4f)->@location(0) vec4f {\n let point=pos.xy/p.size.z*p.viewportScale.xy+p.origin.xy;\n let x=point.x-p.route.x;\n let rearX=point.x-p.route.y;\n var c=p.background;\n if(p.atlasCount.x>0){\n  for(var i=0u;i<u32(p.atlasCount.x);i++){\n   if(p.zoom[i].z>0){\n    let window=p.clip[i];\n    let radius=min(p.zoom[i].w,min(window.z,window.w)*0.5);\n    let delta=abs(point-window.xy-window.zw*0.5)-window.zw*0.5+vec2f(radius);\n    let distance=length(max(delta,vec2f(0)))+min(max(delta.x,delta.y),0)-radius;\n    let coverage=1-smoothstep(-0.5,0.5,distance);\n    if(coverage>0){\n     let local=(point-p.zoom[i].xy)/p.zoom[i].z+p.atlas[i].zw;\n     let sample=textureSampleLevel(front,s,vec2f((local.x/p.size.w+f32(i))/p.atlasCount.x,local.y/p.source.x),0)*coverage;\n     c=vec4f(sample.rgb*(1-p.atlas[i].y),sample.a)+c*(1-sample.a);\n    }\n    continue;\n   }\n   let local=point.x-p.atlas[i].x;\n   if(local>=0&&local<p.size.w){let sample=textureSampleLevel(front,s,vec2f((local/p.size.w+f32(i))/p.atlasCount.x,point.y/p.source.x),0);c=vec4f(sample.rgb*(1-p.atlas[i].y),sample.a)+c*(1-sample.a);}\n  }\n  return c;\n }\n let fill=vec4f(p.atlasCount.yzw,1);\n if(rearX>=0 && rearX<p.size.w){let v=(point.y+p.source.z)/p.source.y;c=textureSampleLevel(rear,s,vec2f(rearX/p.size.w,v),0);if(openFill(v)){c=fill;}c=vec4f(c.rgb*(1-p.route.w),c.a);}\n if(x>=0 && x<p.size.w){let v=(point.y+p.source.z)/p.source.x;c=textureSampleLevel(front,s,vec2f(x/p.size.w,v),0);if(openFill(v)){c=fill;}c=vec4f(c.rgb*(1-p.route.z),c.a);}\n return c;\n}";
+/** The composite and present pipelines for a device, created once per device. */
+export declare function rasterPipelines(device: GPUDevice, format: GPUTextureFormat): {
+    composite: GPURenderPipeline;
+    overlay: GPURenderPipeline;
+    present: GPURenderPipeline;
+};

package/dist/glass/webgpu/rasterShaders.js

@@ -0,0 +1,105 @@
+/// <reference types="@webgpu/types" />
+import { renderPipeline, shaderModule } from './errors.js';
+// The raster's own two pipelines (raster.ts): the backdrop composite (capture, navigation pose and
+// route atlas into the source target) and the present (a result texture onto its layer canvas).
+// The material kernels live in shaders.ts / passes.ts.
+const vertex = `@vertex fn vertex(@builtin(vertex_index) i:u32)->@builtin(position) vec4f {let p=array<vec2f,3>(vec2f(-1,1),vec2f(3,1),vec2f(-1,-3))[i];return vec4f(p,0,1);}`;
+// `source` is (front height, rear height, scroll, open edges); `atlasCount` is (atlas routes,
+// fill rgb). A capture window's open edge (BackdropLayer.openEdges) has uncaptured content beyond
+// it: there the plane's fill is shown. Without the test the clamping sampler stretched the
+// window's last row over everything beyond it.
+export const compositeSource = `${vertex}
+struct P { size:vec4f, origin:vec4f, background:vec4f, source:vec4f, route:vec4f, atlas:array<vec4f,8>, atlasCount:vec4f, viewportScale:vec4f, zoom:array<vec4f,8>, clip:array<vec4f,8> }
+@group(0) @binding(0) var<uniform> p:P;
+@group(0) @binding(1) var s:sampler;
+@group(0) @binding(2) var front:texture_2d<f32>;
+@group(0) @binding(3) var rear:texture_2d<f32>;
+fn openFill(v:f32)->bool {
+ let open=u32(p.source.w);
+ return (v<0 && (open&1u)!=0u) || (v>1 && (open&2u)!=0u);
+}
+@fragment fn fragment(@builtin(position) pos:vec4f)->@location(0) vec4f {
+ let point=pos.xy/p.size.z*p.viewportScale.xy+p.origin.xy;
+ let x=point.x-p.route.x;
+ let rearX=point.x-p.route.y;
+ var c=p.background;
+ if(p.atlasCount.x>0){
+  for(var i=0u;i<u32(p.atlasCount.x);i++){
+   if(p.zoom[i].z>0){
+    let window=p.clip[i];
+    let radius=min(p.zoom[i].w,min(window.z,window.w)*0.5);
+    let delta=abs(point-window.xy-window.zw*0.5)-window.zw*0.5+vec2f(radius);
+    let distance=length(max(delta,vec2f(0)))+min(max(delta.x,delta.y),0)-radius;
+    let coverage=1-smoothstep(-0.5,0.5,distance);
+    if(coverage>0){
+     let local=(point-p.zoom[i].xy)/p.zoom[i].z+p.atlas[i].zw;
+     let sample=textureSampleLevel(front,s,vec2f((local.x/p.size.w+f32(i))/p.atlasCount.x,local.y/p.source.x),0)*coverage;
+     c=vec4f(sample.rgb*(1-p.atlas[i].y),sample.a)+c*(1-sample.a);
+    }
+    continue;
+   }
+   let local=point.x-p.atlas[i].x;
+   if(local>=0&&local<p.size.w){let sample=textureSampleLevel(front,s,vec2f((local/p.size.w+f32(i))/p.atlasCount.x,point.y/p.source.x),0);c=vec4f(sample.rgb*(1-p.atlas[i].y),sample.a)+c*(1-sample.a);}
+  }
+  return c;
+ }
+ let fill=vec4f(p.atlasCount.yzw,1);
+ if(rearX>=0 && rearX<p.size.w){let v=(point.y+p.source.z)/p.source.y;c=textureSampleLevel(rear,s,vec2f(rearX/p.size.w,v),0);if(openFill(v)){c=fill;}c=vec4f(c.rgb*(1-p.route.w),c.a);}
+ if(x>=0 && x<p.size.w){let v=(point.y+p.source.z)/p.source.x;c=textureSampleLevel(front,s,vec2f(x/p.size.w,v),0);if(openFill(v)){c=fill;}c=vec4f(c.rgb*(1-p.route.z),c.a);}
+ return c;
+}`;
+// `alpha` is (opacity, occluder radius). `occluder` is a capsule (centre, half size) in output
+// pixels with glass drawn above this surface: the present leaves it empty (see SurfaceRenderSpec).
+const present = `${vertex}
+struct P { origin:vec4f, alpha:vec4f, occluder:vec4f }
+@group(0) @binding(0) var<uniform> p:P;
+@group(0) @binding(1) var s:sampler;
+@group(0) @binding(2) var source:texture_2d<f32>;
+@fragment fn fragment(@builtin(position) pos:vec4f)->@location(0) vec4f {
+ let uv=(pos.xy-p.origin.xy)/p.origin.zw;
+ if(any(uv<vec2f(0))||any(uv>vec2f(1))){return vec4f(0);}
+ var c=textureSampleLevel(source,s,uv,0)*p.alpha.x;
+ if(p.occluder.z>0){
+  let q=abs(pos.xy-p.occluder.xy)-p.occluder.zw+vec2f(p.alpha.y);
+  let distance=length(max(q,vec2f(0)))+min(max(q.x,q.y),0)-p.alpha.y;
+  c*=smoothstep(-0.5,0.5,distance);
+ }
+ return c;
+}`;
+const devicePipelines = new WeakMap();
+/** The composite and present pipelines for a device, created once per device. */
+export function rasterPipelines(device, format) {
+    let cached = devicePipelines.get(device);
+    const pipeline = (label, code, blend = false) => {
+        const module = shaderModule(device, { label, code });
+        return renderPipeline(device, {
+            label,
+            layout: 'auto',
+            vertex: { module, entryPoint: 'vertex' },
+            fragment: {
+                module,
+                entryPoint: 'fragment',
+                targets: [
+                    {
+                        format,
+                        blend: blend
+                            ? {
+                                color: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha' },
+                                alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha' },
+                            }
+                            : undefined,
+                    },
+                ],
+            },
+        });
+    };
+    if (!cached) {
+        cached = {
+            composite: pipeline('composite', compositeSource),
+            overlay: pipeline('backdrop-overlay', compositeSource, true),
+            present: pipeline('present', present, true),
+        };
+        devicePipelines.set(device, cached);
+    }
+    return cached;
+}

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

@@ -0,0 +1,304 @@
+import type { Appearance } from '../lens/theme.js';
+import type { RasterSetup } from '../worker/protocol.js';
+import type { Target, Values } from './passes.js';
+import type { NavigationPose } from './productionTracks.js';
+type Spec = RasterSetup['spec'];
+type ShapePart = Spec['shape']['first'];
+type Lift = NonNullable<RasterSetup['lift']>;
+type Optics = NonNullable<Lift['optics']>;
+type Capsule = Pick<ShapePart, 'centerX' | 'centerY' | 'halfWidth' | 'halfHeight' | 'radius'>;
+/** Where a surface's result lives: its layer, sample rectangle and result texture. */
+export type ResultLayout = {
+    spec: Spec;
+    appearance: Appearance;
+    resolution: number;
+    /** Layer size, CSS px. */
+    width: number;
+    height: number;
+    /** Sample rectangle size, CSS px. */
+    sampleWidth: number;
+    sampleHeight: number;
+    /** A local result covers the sample rectangle (plus one pixel), not the whole layer. */
+    local: boolean;
+    /** The sample rectangle's origin inside the result texture, device px. */
+    resultSampleX: number;
+    resultSampleY: number;
+    result: Target;
+};
+/** The grouped page background (light) or black behind every backdrop. */
+export declare const pageBackground: (appearance: Appearance) => number[];
+/** Glass-vibrant glyph ink offsets per appearance. */
+export declare const glyphVibrancy: (appearance: Appearance) => number[];
+/** Composite shader uniform (struct P in raster.ts): sample frame, source extents, navigation
+ * pose (the live pose, or the tab-drag fallback) and the eight route-atlas slots. */
+export declare function compositeUniforms(setup: RasterSetup, navigation: NavigationPose | undefined, scrollY: number, x: number, background: readonly number[], frontHeight: number, rearHeight: number): number[];
+/** Fill outside capture windows or real scrolling content. Band clipping uses openEdges alone. */
+export declare const backdropFillEdges: (layer: {
+    openEdges?: number;
+    fillEdges?: number;
+}) => number;
+/** Composite uniform for a backdrop plane other than the content plane: its own capture,
+ * scrolled, no navigation pose and no atlas. */
+export declare function planeCompositeUniforms(size: readonly [number, number], resolution: number, layer: {
+    width: number;
+    height: number;
+    origin: {
+        x: number;
+        y: number;
+    };
+    fill: readonly number[];
+    scroll: {
+        x: number;
+        y: number;
+    };
+    openEdges?: number;
+    fillEdges?: number;
+}, rect: readonly number[], scale?: readonly [number, number]): number[];
+/** A kernel's input texture: logical size and a half-texel clamp. */
+export declare const inputUniforms: (source: Target, logicalWidth: number, logicalHeight: number) => {
+    uInputSize: number[];
+    uInputClamp: number[];
+};
+/** A shape part in sample-rectangle coordinates: [centerX, centerY, halfWidth, halfHeight]. */
+export declare const shapeUniform: (spec: Spec, part: ShapePart) => number[];
+/** A kernel's output frame inside the result texture (local result) or the layer. */
+export declare function outputUniforms(layout: ResultLayout, frameWidth: number, frameHeight: number): {
+    __outputFrame: number[];
+    __outputTexture: number[];
+    __filterScale: number[];
+};
+/** The material regular material (bar or menu kernel) sampling the backdrop pyramid. A menu
+ * draws its two-part morph outline and trigger regime, and outputs over its padded pyramid. */
+/** The bar's darker band just inside its top edge: [amount, rise end, fall start, fall end], the
+ * distances in points inside the edge. Fitted 2026-09-30 to the native tab bar (ParityReference
+ * `--tab-glass-scroll`, iOS 27.0 Simulator) over a flat white card, a flat dark card and a photo
+ * in both appearances: 4 luma darker than the interior from 8 to 12 pt over mid and bright
+ * content, 1 over the dark card, none by 20 pt. The amount enters as P * (1 + a * w * (3 - 2P)),
+ * where w fades the shade out over dark glass (smoothstep of the glass luminance, 0.05 to 0.5). */
+export declare const BAR_TOP_INNER_SHADE: readonly [-0.0145, 8, 11, 20];
+/** Whether a bar-kernel surface is the tab bar. The tab bar's optics were fitted to the native
+ * tab bar: full-resolution detail, a four-tap fill, no highlight floor, the inner shade (all in
+ * the bar shader, switched by `uTabBarOptics`). Every bar surface, the tab bar included, reads
+ * the same area-average blur pyramid (rasterMaterial.ts usesAreaMips). Every other
+ * bar surface (toolbar buttons, glass buttons, a merged group, a button opening into its menu)
+ * keeps the optics the morph engine's material was fitted and approved on: under the tab bar's
+ * optics an open menu's backdrop read sharper and brighter than in that build. */
+export declare function usesTabBarOptics(spec: ResultLayout['spec']): boolean;
+export declare function materialUniforms(layout: ResultLayout, setup: RasterSetup, pyramid: Target, scale: number): Values;
+/** The selection pill's shared uniforms: the capsule over the composed (material) scratch. */
+export declare function selectionBaseUniforms(layout: ResultLayout, composed: Target): Values;
+/** The native selection recipe's separable Gaussian over the composed scratch (quarter scale). */
+export declare function selectionBlurUniforms(layout: ResultLayout, composed: Target): {
+    uInputSize: number[];
+    uInputClamp: number[];
+    uStep: number[];
+    uCross: number[];
+    uWeights0: number[];
+    uWeights1: number[];
+};
+/** The selection pill (recipe colour matrix and contour) over the blurred scratch. */
+export declare function selectionPillUniforms(layout: ResultLayout, base: Values, vertical: Target): {
+    uSelectionSize: number[];
+    uSelectionRow0: number[];
+    uSelectionRow1: number[];
+    uSelectionRow2: number[];
+    uSelectionContourAngular: number[];
+    uSelectionContourProfile: number[];
+};
+/** Anchors of the dock's first and last glyphs, evenly spaced inside the bar's first shape. */
+export declare function dockGlyphAnchors(spec: Spec, count: number): number[];
+/** How much of a lift is visible: its amount, or any lens field / lighting clock still showing.
+ * Geometry-only diffuse height/spread tails do not keep an invisible layer alive. */
+export declare function liftVisibleAmount(lift: RasterSetup['lift'], appearance: Appearance): number;
+/** The lighting fit a lift uses: its explicit profile (a held control thumb), else a glass button's
+ * (composed source, no tab selection) or a tab's. */
+export declare function liftLighting(lift: Lift, spec: Spec, appearance: Appearance): {
+    faceGain: number;
+    faceBias: number;
+    diffuseGain: number;
+    crestGain: number;
+    crestTopGain: number;
+    crestBottomGain: number;
+    crestCenterPt: number;
+    crestSigmaPt: number;
+    bandScale: number;
+    diffusionSigmaPt: number;
+    shadowOpacity: number;
+    shadowOffsetPt: number;
+    shadowSigmaPt: number;
+    capBandScale: number;
+    bottomBandScale: number;
+    straightFringeGain: number;
+    capFringeGain: number;
+    straightFringeWidthPt: number;
+    capFringeWidthPt: number;
+    faceSaturation: number;
+    faceRadialMix: number;
+    depthShade: number[];
+    rimLineGain: 0;
+    rimLineWidthPt: 0;
+    topShade: readonly [0, 0, 1, 1];
+    lensMap: readonly [9, 36, -17.5];
+    fieldGain: readonly [1, 1, 1, 1];
+} | {
+    faceGain: number;
+    faceBias: number;
+    diffuseGain: number;
+    crestGain: number;
+    crestTopGain: number;
+    crestBottomGain: number;
+    crestCenterPt: number;
+    crestSigmaPt: number;
+    bandScale: number;
+    diffusionSigmaPt: number;
+    shadowOpacity: number;
+    shadowOffsetPt: number;
+    shadowSigmaPt: number;
+    capBandScale: number;
+    bottomBandScale: number;
+    straightFringeGain: number;
+    capFringeGain: number;
+    straightFringeWidthPt: number;
+    capFringeWidthPt: number;
+    faceSaturation: number;
+    faceRadialMix: number;
+    depthShade: number[];
+    rimLineGain: 0;
+    rimLineWidthPt: 0;
+    topShade: readonly [0, 0, 1, 1];
+    lensMap: readonly [9, 36, -17.5];
+    fieldGain: readonly [1, 1, 1, 1];
+} | {
+    faceGain: number;
+    faceBias: number;
+    diffuseGain: number;
+    crestGain: number;
+    crestCenterPt: number;
+    crestSigmaPt: number;
+    bandScale: number;
+    diffusionSigmaPt: number;
+    shadowOpacity: number;
+    shadowOffsetPt: number;
+    shadowSigmaPt: number;
+    crestTopGain: number;
+    crestBottomGain: number;
+    faceSaturation: number;
+    faceRadialMix: number;
+    capBandScale: number;
+    bottomBandScale: number;
+    straightFringeGain: number;
+    capFringeGain: number;
+    straightFringeWidthPt: number;
+    capFringeWidthPt: number;
+    depthShade: number[];
+    rimLineGain: 0;
+    rimLineWidthPt: 0;
+    topShade: readonly [0, 0, 1, 1];
+    lensMap: readonly [9, 36, -17.5];
+    fieldGain: readonly [1, 1, 1, 1];
+} | {
+    faceGain: number;
+    faceBias: number;
+    diffuseGain: number;
+    crestGain: number;
+    crestCenterPt: number;
+    crestSigmaPt: number;
+    bandScale: number;
+    diffusionSigmaPt: number;
+    shadowOpacity: number;
+    shadowOffsetPt: number;
+    shadowSigmaPt: number;
+    crestTopGain: number;
+    crestBottomGain: number;
+    faceSaturation: number;
+    faceRadialMix: number;
+    capBandScale: number;
+    bottomBandScale: number;
+    straightFringeGain: number;
+    capFringeGain: number;
+    straightFringeWidthPt: number;
+    capFringeWidthPt: number;
+    depthShade: number[];
+    rimLineGain: 0;
+    rimLineWidthPt: 0;
+    topShade: readonly [0, 0, 1, 1];
+    lensMap: readonly [9, 36, -17.5];
+    fieldGain: readonly [1, 1, 1, 1];
+} | {
+    faceGain: number;
+    faceBias: number;
+    diffuseGain: number;
+    crestGain: number;
+    crestTopGain: number;
+    crestBottomGain: number;
+    crestCenterPt: number;
+    crestSigmaPt: number;
+    rimLineGain: number;
+    rimLineWidthPt: number;
+    bandScale: number;
+    diffusionSigmaPt: number;
+    shadowOpacity: number;
+    shadowOffsetPt: number;
+    shadowSigmaPt: number;
+    capBandScale: number;
+    bottomBandScale: number;
+    straightFringeGain: number;
+    capFringeGain: number;
+    straightFringeWidthPt: number;
+    capFringeWidthPt: number;
+    faceSaturation: number;
+    faceRadialMix: number;
+    depthShade: number[];
+    lensMap: number[];
+    fieldGain: number[];
+    topShade: number[];
+} | {
+    faceGain: number;
+    faceBias: number;
+    diffuseGain: number;
+    crestGain: number;
+    crestTopGain: number;
+    crestBottomGain: number;
+    crestCenterPt: number;
+    crestSigmaPt: number;
+    rimLineGain: number;
+    rimLineWidthPt: number;
+    bandScale: number;
+    diffusionSigmaPt: number;
+    shadowOpacity: number;
+    shadowOffsetPt: number;
+    shadowSigmaPt: number;
+    capBandScale: number;
+    bottomBandScale: number;
+    straightFringeGain: number;
+    capFringeGain: number;
+    straightFringeWidthPt: number;
+    capFringeWidthPt: number;
+    faceSaturation: number;
+    faceRadialMix: number;
+    depthShade: number[];
+    lensMap: number[];
+    fieldGain: number[];
+    topShade: number[];
+};
+/** The lift's lighting clocks (seven phases), all at the lift amount when the optics carry none. */
+export declare function liftLightingClocks(lift: Lift, optics: Optics, appearance: Appearance): import("../lens/lensPress.js").LensLighting;
+/** The shared-lift kernel: the lens aperture, its lighting and the lifted foreground glyphs. */
+export declare function sharedLiftUniforms(layout: ResultLayout, lift: Lift, optics: Optics, capsule: Capsule, lensDebug: number, lensAmount: number): Values;
+/** The plain lens kernel for a lift without fitted optics. */
+export declare function lensLiftUniforms(layout: ResultLayout, lift: Lift, capsule: Capsule, source: Target): {
+    uInputSize: number[];
+    uInputClamp: number[];
+    __outputFrame: number[];
+    __outputTexture: number[];
+    __filterScale: number[];
+    uResolution: number[];
+    uShape: number[];
+    uRadius: number;
+    uMaterialMix: number;
+    uGlyphAnchors: readonly [number, number];
+    uGlyphCount: number;
+    uDockShape: number[];
+    uGlyphVibrancy: number[];
+};
+export {};