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

package/dist/glass/regions.d.ts

@@ -0,0 +1,262 @@
+import type { AccessoryTrack, AccessoryViewportTrack } from './webgpu/accessoryTrack.js';
+import type { GlassShapeTrack } from './shapeTrack.js';
+/** Serializable renderer contract. No DOM, Pixi, or GPU handles cross this boundary. */
+export type GlassLayer = Readonly<{
+    id: string;
+    /** Ordered within the host stacking context. DOM placement remains authoritative. */
+    depth: number;
+    attachment: Readonly<{
+        kind: 'fixed';
+    }> | Readonly<{
+        kind: 'scroll';
+        scrollId: string;
+    }>;
+}>;
+export type GlassScrollSnapshot = Readonly<{
+    id: string;
+    offsetX: number;
+    offsetY: number;
+    viewportX: number;
+    viewportY: number;
+    width: number;
+    height: number;
+}>;
+/** Each layer can own multiple presenters. WebGPU shares one device across canvases. */
+export type GlassSceneSnapshot = Readonly<{
+    revision: number;
+    /** Source-images revision whose capture demand this scene was measured against. */
+    sourceRevision?: number;
+    /** Top-layer dialog owners, back to front, when region exclusions were measured. */
+    backdropOwners?: readonly string[];
+    layers: readonly GlassLayer[];
+    scrolls: readonly GlassScrollSnapshot[];
+    regions: readonly GlassRegion[];
+}>;
+export type GlassShape = 'capsule' | 'circle' | Readonly<{
+    kind: 'roundedRectangle';
+    cornerRadius: number;
+    /** @internal Concentric sheet bottom edge; independent of the floating top corners. */
+    bottomCornerRadius?: number;
+    cornerStyle?: 'continuous' | 'circular';
+}>;
+type GlassRect = Readonly<{
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}>;
+/** Normalized RGBA channels in 0...1. Glass.tintRGBA rejects nonfinite or out-of-range channels. */
+export type GlassTint = readonly [red: number, green: number, blue: number, alpha: number];
+export type GlassMaterial = Readonly<{
+    variant: 'regular' | 'clear';
+    tint?: GlassTint;
+    interactive: boolean;
+    /** @internal Kind of interactive glass (GLASS_CONTACT_PHYSICS): content buttons press as
+     * buttons, toolbar and navigation-bar buttons as bar buttons, a menu's trigger as a menu
+     * trigger; app glassEffect surfaces default to the surface response. */
+    press?: 'button' | 'bar' | 'menu';
+    /** @internal Interactive glass hosting one text editor: it presses with the field row of
+     * GLASS_CONTACT_PHYSICS (a native field grows twice a card's growth). */
+    field?: true;
+    /** @internal Contact light without press growth or foreground feedback. */
+    touchLight?: boolean;
+    /** @internal The held thumb lens of a Toggle or Slider (CONTROL_LIFT): hidden at rest, it
+     * lifts at the page's activation and follows the contact's lens centre. */
+    control?: 'toggle' | 'slider';
+    /** @internal A bar-glass surface with its own parameter row: the search drawer's field
+     * (SEARCH_FIELD_RECIPE), a more transparent glass than bar buttons. */
+    recipe?: 'searchField';
+    treatment?: 'sheet' | 'expandedSheet' | 'alert' | 'confirmation' | 'contextBackdrop' | 'contextPreview' | 'contextMenu';
+}>;
+/** What a menu morphs out of, other than a glass button: a plain text label (a menu-style
+ * Picker's value), a plain glyph (an icon-only button with no glass), or a context source. */
+export type MenuSourceKind = 'label' | 'glyph' | 'context';
+/** A plain source has no glass at rest: its glass is held transparent until the menu is ready
+ * and fades out with the close, since there is no glass button to hand back to. */
+export declare function isPlainMenuSource(kind: MenuSourceKind | undefined): kind is "glyph" | "label";
+export declare const POPOVER_ARROW_HEIGHT = 14;
+/** @internal Tip x in measured frame points; scale is the frame's presentation scale. */
+export type PopoverArrow = Readonly<{
+    edge: 'top' | 'bottom';
+    x: number;
+    scale: number;
+}>;
+export type GlassRegion = Readonly<{
+    id: string;
+    namespace?: string;
+    union?: string;
+    transition?: 'matchedGeometry' | 'materialize' | 'identity';
+    layer: GlassLayer;
+    /** @internal Top-layer owners painted at or above this material. */
+    backdropExclusions?: readonly string[];
+    /** @internal During zoom, in-content glass samples this route in its resting coordinates. */
+    zoomRoute?: number;
+    /** Fixed: viewport coordinates. Scroll: coordinates in the named scroll content. */
+    frame: Readonly<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    shape: GlassShape;
+    /** @internal Native sheet material animation, independent of detent geometry. */
+    sheetOpaqueMix?: number;
+    /** @internal A confirmation popover's arrow: its edge, tip x and presentation scale. */
+    popoverArrow?: PopoverArrow;
+    /** @internal A segmented selection drawn inside the region (the search scope bar's thumb):
+     * the selected segment of `count` equal segments. The renderer moves the thumb
+     * (webgpu/selectionThumb.ts); the page sends its finger as interactions. */
+    selection?: Readonly<{
+        index: number;
+        count: number;
+    }>;
+    material: GlassMaterial;
+    /** @internal Sampling follows the compositor even when ink stays in the document. */
+    accessoryViewportTrack?: AccessoryViewportTrack;
+    /** @internal Rigid sheet motion; nested glass remains in the parent resting frame. */
+    presentationViewportTrack?: AccessoryViewportTrack;
+    /** @internal Submit nested sheet pixels for this admitted show before content is revealed. */
+    presentationContentEpoch?: number;
+    /** @internal Experimental retained accessory aperture and ink. */
+    accessoryTrack?: AccessoryTrack;
+    /** @internal The glass changes size inside a still `frame` (shapeTrack.ts). */
+    shapeTrack?: GlassShapeTrack;
+    /** @internal Everywhere a held-still accessory canvas carries its glass (accessoryMorph.ts).
+     * Its presenter covers this as well as `frame`, at rest too. */
+    accessoryReach?: Readonly<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    container?: Readonly<{
+        id: string;
+        spacing: number;
+        continuous?: boolean;
+    }>;
+    morph?: Readonly<{
+        namespace: string;
+        id: string;
+    }>;
+    /** @internal A fixed-layer region that emerges from (and on `closing` returns into) a trigger
+     * rectangle in viewport points: a glass Menu from its glass button (GLASS_MENU_MORPH). */
+    emerge?: Readonly<{
+        from: Readonly<{
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+            radius: number;
+        }>;
+        /** Released source endpoint; the open begins at the pressed aperture. */
+        returnTo?: Readonly<{
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+            radius: number;
+        }>;
+        sourceRegionId?: string;
+        /** Page-owned pose used by the asynchronous trigger atlas capture. */
+        sourceSnapshot?: number;
+        /** The trigger's material: a glass button when absent. A plain source (`label`, `glyph`)
+         * draws no glass at rest: a text label emits one transient drop; a plain glyph swells into
+         * a glass bubble that becomes the drop, as a glass button's does. */
+        sourceKind?: MenuSourceKind;
+        /** A context menu on content (not a row) opens on the native content spring. */
+        content?: boolean;
+        /** Context preview and glass share this epoch across main/worker preparation. */
+        recognitionEpoch?: number;
+        /** Centre of the menu's own button (viewport points) when the trigger glass is wider than it:
+         * a member of a toolbar group. The drop forms there; the trigger's centre when absent. */
+        anchor?: Readonly<{
+            x: number;
+            y: number;
+        }>;
+        closing?: boolean;
+        /** Keep the last presented morph geometry and ink while its owner fades out. */
+        fading?: boolean;
+        /** Identifies one open/close transition: a settle report names the transition it ends. */
+        generation?: number;
+        /** Prewarm the trigger shape without consuming the visible emerge timeline. */
+        ready?: boolean;
+        /** Ink drawn inside the morphing glass: regions of the region's foreground atlas (points)
+         * and the viewport rectangles they settle at (the menu's rows, the trigger's glyph). */
+        ink?: Readonly<{
+            atlas: Readonly<{
+                width: number;
+                height: number;
+            }>;
+            rows?: Readonly<{
+                source: GlassRect;
+                frame: GlassRect;
+            }>;
+            glyph?: Readonly<{
+                source: GlassRect;
+                frame: GlassRect;
+            }>;
+        }>;
+        /** The page shows its live rows (after `open-settled`); the glass stops drawing them. */
+        inkDom?: boolean;
+        /** Which recorded menu morph applies (lens/menuMorphMotion.ts); iPad when absent. */
+        idiom?: 'phone' | 'pad';
+    }>;
+    /** @internal The region's presenter is held: it keeps the pixels it last drew and is not
+     * redrawn for backdrop changes. Set while the region sits in an inactive tab (a backdrop
+     * scrolling under an invisible region costs no frame work), and after its tab is selected again
+     * until that tab's own backdrop is installed (the previous tab's backdrop is never drawn into
+     * it). A change of the region's own inputs (appearance, geometry, ink) still repaints it. */
+    suspended?: boolean;
+    /** @internal Glass inside an open menu's panel other than the menu's own (a submenu platter).
+     * It sits on the menu's plane, so it samples the menu's dim as the menu does. */
+    inMenuPanel?: boolean;
+}>;
+/** The smallest frame holding both. A held-still canvas covers every place its glass passes. */
+export declare function frameUnion(a: GlassRegion['frame'], b: GlassRegion['frame']): GlassRegion['frame'];
+/** Presenter bounds of a region: its frame (and any emerge source) plus the sample inset. */
+export declare function glassPresenterBounds(frame: GlassRegion['frame'], inset: number, emerge?: GlassRegion['emerge']): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/** Provisional allocation guard, not a measured device performance promise.
+ * Two 440×894 sheets at 3× with 20pt sample margins need 8,069,760 pixels.
+ * The 12M guard permits that stack plus chrome; it is not a memory benchmark. */
+export declare const GLASS_REGION_LIMIT = 16;
+export declare const GLASS_REGION_PIXEL_LIMIT = 12000000;
+/** Immutable SwiftUI-style material values. RGBA channels use the range 0...1. */
+export declare class Glass {
+    static readonly regular: Glass;
+    static readonly clear: Glass;
+    /** Calibrated iOS 27 presentation body treatments; shared renderer owns their response. */
+    static readonly sheet: Glass;
+    static readonly alert: Glass;
+    static readonly confirmation: Glass;
+    static readonly expandedSheet: Glass;
+    /** @internal Non-lensing context isolation, implemented by the shared WebGPU renderer. */
+    static readonly contextBackdrop: Glass;
+    static readonly contextMenu: Glass;
+    static readonly contextPreview: Glass;
+    readonly variant: 'regular' | 'clear';
+    private readonly colour?;
+    private readonly responds;
+    private readonly treatment?;
+    private constructor();
+    tint(colour?: GlassTint): Glass;
+    interactive(enabled?: boolean): Glass;
+    get material(): GlassMaterial;
+}
+export declare function glassRadius(shape: GlassShape, width: number, height: number): number;
+export declare function validateGlassRegions(regions: readonly GlassRegion[], resolution: number): {
+    regions: number;
+    samplePixels: number;
+};
+/** Projection is for sampling only. Presenters stay attached to their DOM layer. */
+export declare function glassViewportFrame(region: GlassRegion, scrolls: readonly GlassScrollSnapshot[]): Readonly<{
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}>;
+export {};

package/dist/glass/regions.js

@@ -0,0 +1,147 @@
+/** A plain source has no glass at rest: its glass is held transparent until the menu is ready
+ * and fades out with the close, since there is no glass button to hand back to. */
+export function isPlainMenuSource(kind) {
+    return kind === 'label' || kind === 'glyph';
+}
+export const POPOVER_ARROW_HEIGHT = 14;
+/** The smallest frame holding both. A held-still canvas covers every place its glass passes. */
+export function frameUnion(a, b) {
+    const x = Math.min(a.x, b.x), y = Math.min(a.y, b.y);
+    return {
+        x,
+        y,
+        width: Math.max(a.x + a.width, b.x + b.width) - x,
+        height: Math.max(a.y + a.height, b.y + b.height) - y,
+    };
+}
+/** Presenter bounds of a region: its frame (and any emerge source) plus the sample inset. */
+export function glassPresenterBounds(frame, inset, emerge) {
+    const from = emerge?.from;
+    const x0 = Math.min(frame.x, from?.x ?? frame.x), y0 = Math.min(frame.y, from?.y ?? frame.y);
+    const x1 = Math.max(frame.x + frame.width, from ? from.x + from.width : -Infinity), y1 = Math.max(frame.y + frame.height, from ? from.y + from.height : -Infinity);
+    return { x: x0 - inset, y: y0 - inset, width: x1 - x0 + 2 * inset, height: y1 - y0 + 2 * inset };
+}
+/** Provisional allocation guard, not a measured device performance promise.
+ * Two 440×894 sheets at 3× with 20pt sample margins need 8,069,760 pixels.
+ * The 12M guard permits that stack plus chrome; it is not a memory benchmark. */
+export const GLASS_REGION_LIMIT = 16;
+export const GLASS_REGION_PIXEL_LIMIT = 12_000_000;
+/** Immutable SwiftUI-style material values. RGBA channels use the range 0...1. */
+export class Glass {
+    static regular = new Glass('regular');
+    static clear = new Glass('clear');
+    /** Calibrated iOS 27 presentation body treatments; shared renderer owns their response. */
+    static sheet = new Glass('clear', undefined, false, 'sheet');
+    static alert = new Glass('regular', undefined, false, 'alert');
+    static confirmation = new Glass('regular', undefined, false, 'confirmation');
+    static expandedSheet = new Glass('clear', undefined, false, 'expandedSheet');
+    /** @internal Non-lensing context isolation, implemented by the shared WebGPU renderer. */
+    static contextBackdrop = new Glass('clear', undefined, false, 'contextBackdrop');
+    static contextMenu = new Glass('regular', undefined, false, 'contextMenu');
+    static contextPreview = new Glass('clear', undefined, false, 'contextPreview');
+    variant;
+    colour;
+    responds;
+    treatment;
+    constructor(variant, colour, responds = false, treatment) {
+        this.treatment = treatment;
+        this.variant = variant;
+        this.colour = colour;
+        this.responds = responds;
+        Object.freeze(this);
+    }
+    tint(colour) {
+        if (colour &&
+            (colour.length !== 4 ||
+                !colour.every(value => Number.isFinite(value) && value >= 0 && value <= 1)))
+            throw new Error('Glass.tint requires four finite RGBA channels in 0...1.');
+        return new Glass(this.variant, colour && Object.freeze([...colour]), this.responds, this.treatment);
+    }
+    interactive(enabled = true) {
+        return new Glass(this.variant, this.colour, enabled, this.treatment);
+    }
+    get material() {
+        return {
+            variant: this.variant,
+            tint: this.colour,
+            interactive: this.responds,
+            ...(this.treatment ? { treatment: this.treatment } : {}),
+        };
+    }
+}
+export function glassRadius(shape, width, height) {
+    const maximum = Math.min(width, height) / 2;
+    if (typeof shape === 'string')
+        return maximum;
+    if (!Number.isFinite(shape.cornerRadius) || shape.cornerRadius < 0)
+        throw new Error('Glass cornerRadius must be finite and nonnegative.');
+    if (shape.bottomCornerRadius !== undefined &&
+        (!Number.isFinite(shape.bottomCornerRadius) || shape.bottomCornerRadius < 0))
+        throw new Error('Glass bottomCornerRadius must be finite and nonnegative.');
+    return Math.min(shape.cornerRadius, maximum);
+}
+export function validateGlassRegions(regions, resolution) {
+    if (!Number.isFinite(resolution) || resolution <= 0)
+        throw new Error('Invalid glass resolution.');
+    if (regions.length > GLASS_REGION_LIMIT)
+        throw new Error(`Glass supports at most ${GLASS_REGION_LIMIT} app regions.`);
+    const ids = new Set(), morphs = new Set(), layers = new Map();
+    let pixels = 0;
+    for (const region of regions) {
+        if (ids.has(region.id))
+            throw new Error(`Duplicate glass region: ${region.id}`);
+        ids.add(region.id);
+        const layerKey = JSON.stringify(region.layer);
+        if (layers.has(region.layer.id) && layers.get(region.layer.id) !== layerKey)
+            throw new Error(`Conflicting glass layer: ${region.layer.id}`);
+        layers.set(region.layer.id, layerKey);
+        if (!region.layer.id || !Number.isFinite(region.layer.depth))
+            throw new Error('Invalid glass layer.');
+        if (region.layer.attachment.kind === 'scroll' && !region.layer.attachment.scrollId)
+            throw new Error('Scroll-attached glass requires a scroll owner.');
+        const { x, y, width, height } = region.frame;
+        if (![x, y, width, height].every(Number.isFinite) || width <= 0 || height <= 0)
+            throw new Error(`Invalid glass frame: ${region.id}`);
+        glassRadius(region.shape, width, height);
+        if (typeof region.shape === 'object' &&
+            region.shape.bottomCornerRadius !== undefined &&
+            (region.container ||
+                region.union ||
+                region.material.interactive ||
+                !['sheet', 'expandedSheet'].includes(region.material.treatment ?? '')))
+            throw new Error('Independent bottom corners require a noninteractive, separate sheet region.');
+        if (region.shape === 'circle' && Math.abs(width - height) > 0.5)
+            throw new Error('Circle glass requires equal width and height.');
+        if (region.container &&
+            (!Number.isFinite(region.container.spacing) || region.container.spacing < 0))
+            throw new Error('Glass container spacing must be finite and nonnegative.');
+        if (region.morph) {
+            const key = JSON.stringify([
+                region.container?.id ?? null,
+                region.morph.namespace,
+                region.morph.id,
+            ]);
+            if (morphs.has(key))
+                throw new Error(`Duplicate active glassEffectID: ${key}`);
+            morphs.add(key);
+        }
+        pixels += Math.ceil((width + 40) * resolution) * Math.ceil((height + 40) * resolution);
+    }
+    if (pixels > GLASS_REGION_PIXEL_LIMIT)
+        throw new Error(`Glass sample budget exceeded: ${pixels} > ${GLASS_REGION_PIXEL_LIMIT} pixels.`);
+    return { regions: regions.length, samplePixels: pixels };
+}
+/** Projection is for sampling only. Presenters stay attached to their DOM layer. */
+export function glassViewportFrame(region, scrolls) {
+    const attachment = region.layer.attachment;
+    if (attachment.kind === 'fixed')
+        return region.frame;
+    const scroll = scrolls.find(value => value.id === attachment.scrollId);
+    if (!scroll)
+        throw new Error(`Missing glass scroll snapshot: ${attachment.scrollId}`);
+    return {
+        ...region.frame,
+        x: region.frame.x + scroll.viewportX - scroll.offsetX,
+        y: region.frame.y + scroll.viewportY - scroll.offsetY,
+    };
+}

package/dist/glass/regularMaterialContext.d.ts

@@ -0,0 +1,45 @@
+/** A retained source-image index. No DOM reads, GPU readbacks or canvas writes
+ * occur when an aperture moves. Disc rows are clipped and renormalized against
+ * the visible window, not extended by repeating the boundary pixel.
+ */
+export declare class RegularMaterialContext {
+    private readonly rows;
+    readonly width: number;
+    readonly height: number;
+    constructor(image: Readonly<{
+        data: ArrayLike<number>;
+        width: number;
+        height: number;
+    }>);
+    get memoryBytes(): number;
+    sample(centerX: number, centerY: number, radius: number, visibleTop?: number, visibleBottom?: number): {
+        rgb: number[];
+        luminance: number;
+        deviation: number;
+        count: number;
+    } | undefined;
+}
+/** The same index, integrated per row on first use and bit-identical to
+ * `RegularMaterialContext`: apertures touch a few dozen rows, so a new source
+ * revision no longer pays for integrating every row up front. The WebGPU source
+ * pipeline uses it; the Pixi renderer keeps the eager index unchanged. */
+export declare class LazyRegularMaterialContext {
+    private readonly data;
+    private readonly rows;
+    readonly width: number;
+    readonly height: number;
+    constructor(image: Readonly<{
+        data: ArrayLike<number>;
+        width: number;
+        height: number;
+    }>);
+    get memoryBytes(): number;
+    /** Per-row prefix sums of r, g, b and luminance squared; entry x holds columns [0, x). */
+    prefixRow(y: number): Float64Array<ArrayBufferLike>;
+    sample(centerX: number, centerY: number, radius: number, visibleTop?: number, visibleBottom?: number): {
+        rgb: number[];
+        luminance: number;
+        deviation: number;
+        count: number;
+    } | undefined;
+}

package/dist/glass/regularMaterialContext.js

@@ -0,0 +1,118 @@
+/** A retained source-image index. No DOM reads, GPU readbacks or canvas writes
+ * occur when an aperture moves. Disc rows are clipped and renormalized against
+ * the visible window, not extended by repeating the boundary pixel.
+ */
+export class RegularMaterialContext {
+    // Variance subtracts two nearly equal second moments. Float32 prefix sums
+    // fabricate visible context deviation even on a perfectly uniform source.
+    rows;
+    width;
+    height;
+    constructor(image) {
+        this.width = image.width;
+        this.height = image.height;
+        this.rows = new Float64Array((image.width + 1) * image.height * 4);
+        for (let y = 0; y < image.height; y++)
+            for (let x = 0; x < image.width; x++) {
+                const src = (y * image.width + x) * 4, prev = (y * (image.width + 1) + x) * 4;
+                const r = image.data[src] / 255, g = image.data[src + 1] / 255, b = image.data[src + 2] / 255;
+                const l = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+                this.rows[prev + 4] = this.rows[prev] + r;
+                this.rows[prev + 5] = this.rows[prev + 1] + g;
+                this.rows[prev + 6] = this.rows[prev + 2] + b;
+                this.rows[prev + 7] = this.rows[prev + 3] + l * l;
+            }
+    }
+    get memoryBytes() {
+        return this.rows.byteLength;
+    }
+    sample(centerX, centerY, radius, visibleTop = 0, visibleBottom = this.height) {
+        const sum = [0, 0, 0, 0];
+        let count = 0;
+        for (let y = Math.max(0, Math.ceil(visibleTop - 0.5), Math.ceil(centerY - radius - 0.5)); y < Math.min(this.height, visibleBottom - 0.5, centerY + radius - 0.5); y++) {
+            const dy = y + 0.5 - centerY, half = Math.sqrt(Math.max(0, radius * radius - dy * dy));
+            const left = Math.max(0, Math.ceil(centerX - half - 0.5)), right = Math.min(this.width, Math.ceil(centerX + half - 0.5));
+            if (right <= left)
+                continue;
+            const a = (y * (this.width + 1) + left) * 4, b = (y * (this.width + 1) + right) * 4;
+            for (let c = 0; c < 4; c++)
+                sum[c] += this.rows[b + c] - this.rows[a + c];
+            count += right - left;
+        }
+        if (!count)
+            return undefined;
+        const rgb = sum.slice(0, 3).map(v => v / count);
+        const luminance = rgb[0] * 0.2126 + rgb[1] * 0.7152 + rgb[2] * 0.0722;
+        return {
+            rgb,
+            luminance,
+            deviation: Math.sqrt(Math.max(0, sum[3] / count - luminance * luminance)),
+            count,
+        };
+    }
+}
+/** The same index, integrated per row on first use and bit-identical to
+ * `RegularMaterialContext`: apertures touch a few dozen rows, so a new source
+ * revision no longer pays for integrating every row up front. The WebGPU source
+ * pipeline uses it; the Pixi renderer keeps the eager index unchanged. */
+export class LazyRegularMaterialContext {
+    // Variance subtracts two nearly equal second moments. Float32 prefix sums
+    // fabricate visible context deviation even on a perfectly uniform source.
+    data;
+    rows;
+    width;
+    height;
+    constructor(image) {
+        this.width = image.width;
+        this.height = image.height;
+        // Own the pixels: integration is deferred, so a caller's buffer may be reused.
+        this.data = new Uint8ClampedArray(image.data);
+        this.rows = new Array(image.height);
+    }
+    get memoryBytes() {
+        return this.data.byteLength + this.rows.reduce((n, row) => n + (row?.byteLength ?? 0), 0);
+    }
+    /** Per-row prefix sums of r, g, b and luminance squared; entry x holds columns [0, x). */
+    prefixRow(y) {
+        let row = this.rows[y];
+        if (row)
+            return row;
+        const width = this.width, data = this.data;
+        row = this.rows[y] = new Float64Array((width + 1) * 4);
+        // Same operations in the same order as `row[i + 4] = row[i] + v`: bit-identical sums.
+        let sr = 0, sg = 0, sb = 0, sl = 0;
+        for (let x = 0, src = y * width * 4, out = 4; x < width; x++, src += 4, out += 4) {
+            const r = data[src] / 255, g = data[src + 1] / 255, b = data[src + 2] / 255;
+            const l = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+            row[out] = sr = sr + r;
+            row[out + 1] = sg = sg + g;
+            row[out + 2] = sb = sb + b;
+            row[out + 3] = sl = sl + l * l;
+        }
+        return row;
+    }
+    sample(centerX, centerY, radius, visibleTop = 0, visibleBottom = this.height) {
+        const sum = [0, 0, 0, 0];
+        let count = 0;
+        for (let y = Math.max(0, Math.ceil(visibleTop - 0.5), Math.ceil(centerY - radius - 0.5)); y < Math.min(this.height, visibleBottom - 0.5, centerY + radius - 0.5); y++) {
+            const dy = y + 0.5 - centerY, half = Math.sqrt(Math.max(0, radius * radius - dy * dy));
+            const left = Math.max(0, Math.ceil(centerX - half - 0.5)), right = Math.min(this.width, Math.ceil(centerX + half - 0.5));
+            if (right <= left)
+                continue;
+            const row = this.prefixRow(y), a = left * 4, b = right * 4;
+            for (let c = 0; c < 4; c++)
+                sum[c] += row[b + c] - row[a + c];
+            count += right - left;
+        }
+        if (!count)
+            return undefined;
+        const rgb = sum.slice(0, 3).map(v => v / count);
+        const luminance = rgb[0] * 0.2126 + rgb[1] * 0.7152 + rgb[2] * 0.0722;
+        return {
+            rgb,
+            luminance,
+            deviation: Math.sqrt(Math.max(0, sum[3] / count - luminance * luminance)),
+            count,
+        };
+    }
+}

package/dist/glass/regularTriggerMaterial.d.ts

@@ -0,0 +1,19 @@
+export declare const REGULAR_TRIGGER_MATERIAL: {
+    readonly radiusPt: 52;
+    readonly thresholds: {
+        readonly light: 49.25;
+        readonly dark: 228;
+    };
+    readonly models: {
+        readonly 'light-0': readonly [0.23357323336904154, -0.12025038168260119, 0.7223854586442838, -0.3451911179708627, 1];
+        readonly 'light-1': readonly [0.4425394744439445, -0.003838997933491911, 0.34505442834797134, 0.21213920995723007, 0.9999999999998385];
+        readonly 'dark-0': readonly [0.5358530945042601, 0.06152028922900846, 0.7019229824978999, -0.24774618727435888, 0.7674240204118238];
+        readonly 'dark-1': readonly [0.4425394744439445, -0.003838997933491911, 0.34505442834797134, 0.21213920995723007, 0.9999999999998385];
+    };
+    readonly neutralCurves: readonly [readonly [readonly [0, 0.07450980392156863], readonly [0.06274509803921569, 0.09019607843137255], readonly [0.12549019607843137, 0.10980392156862745], readonly [0.18823529411764706, 0.13333333333333333], readonly [0.19215686274509805, 0.13333333333333333], readonly [0.2, 0.1411764705882353], readonly [0.2196078431372549, 0.1450980392156863], readonly [0.25098039215686274, 0.1607843137254902], readonly [0.2823529411764706, 0.18823529411764706], readonly [0.32941176470588235, 0.2392156862745141], readonly [0.39215686274509803, 0.2901960784313769], readonly [0.4549019607843137, 0.32941176470588235], readonly [0.5019607843137255, 0.34509803921568627], readonly [0.5176470588235295, 0.35294117647057927], readonly [0.5803921568627451, 0.3686274509803948], readonly [0.6431372549019608, 0.3803921568627337], readonly [0.7058823529411765, 0.3882352941176591], readonly [0.7686274509803922, 0.4078431372548884], readonly [0.8313725490196079, 0.4196078431372463], readonly [0.8470588235294118, 0.4196078431372549], readonly [0.8627450980392157, 0.4235294117647119], readonly [0.8784313725490196, 0.42745098039215684]], readonly [readonly [0.2, 0.6666666666666666], readonly [0.2196078431372549, 0.6705882352941176], readonly [0.25098039215686274, 0.6784313725490196], readonly [0.2823529411764706, 0.6980392156862745], readonly [0.32941176470588235, 0.7215686274509999], readonly [0.39215686274509803, 0.7450980392156805], readonly [0.4549019607843137, 0.7764705882353182], readonly [0.5019607843137255, 0.8], readonly [0.5176470588235295, 0.8156862745097768], readonly [0.5803921568627451, 0.8549019607843014], readonly [0.6431372549019608, 0.8823529411764569], readonly [0.7058823529411765, 0.9058823529411764], readonly [0.7686274509803922, 0.9294117647058983], readonly [0.8313725490196079, 0.9529411764705527], readonly [0.8470588235294118, 0.9568627450980393], readonly [0.8627450980392157, 0.9607843137254903], readonly [0.8784313725490196, 0.9647058823529412], readonly [0.9098039215686274, 0.9725490196078431], readonly [0.9568627450980393, 0.9843137254902143], readonly [0.9725490196078431, 0.9882352941176471], readonly [1, 0.9921568627450981]]];
+    readonly identifiability: {
+        readonly 'dark-1': 'Only neutral fitting scenes; response parameters tied to light bright, whose observed neutral response is identical.';
+    };
+};
+export declare function regularTriggerRegime(contextLuminance: number, appearance: 'light' | 'dark'): 0 | 1;
+export declare const REGULAR_TRIGGER_MATERIAL_GLSL: string;