@thunderclap-engine/engine 0.0.0-stage → 1.1.0

package/dist/input/touch-zones.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Touch zones (ws/input-4): screen regions that turn thumbs into a stick, buttons or swipes and
+ * feed actions through an `Input`. A pointer that goes down inside a zone is claimed through the
+ * input's pointer dispatcher, so gestures and the router never see it (two thumbs never pinch);
+ * each zone tracks at most one pointer. Zone rects are in CSS px of the pointer target, computed
+ * from its size when a pointer lands, so they follow resizes.
+ *
+ * ```ts
+ * const zones = createTouchZones(input, {
+ *   zones: {
+ *     move: { kind: 'stick', rect: (w, h) => ({ x: 0, y: h / 2, w: w / 2, h: h / 2 }) },
+ *     act: { kind: 'buttons', rect: (w, h) => ({ x: w / 2, y: h / 2, w: w / 2, h: h / 2 }),
+ *            buttons: { jump: (w, h) => ({ x: w - 120, y: h - 120, w: 100, h: 100 }) } },
+ *   },
+ *   bindings: {
+ *     moveLeft: { zone: 'move', axis: 'x', dir: -1 },
+ *     moveRight: { zone: 'move', axis: 'x', dir: 1 },
+ *     jump: { zone: 'act', button: 'jump' },
+ *   },
+ * });
+ * // every tick, after input.update():
+ * zones.zones.move.vector; // [x, y] -1..1
+ * input.axis('moveLeft', 'moveRight'); // the same x through the actions
+ * ```
+ *
+ * Recordings capture zone thumbs through the input's existing pointer feed (the primary pointer
+ * only; see the README), so no new record kind is needed.
+ */
+import type { Input } from './input.js';
+import { type PointerRecordDevice } from './pointer-dispatch.js';
+/** A zone or button rect in CSS px of the pointer target, origin top-left. */
+export interface ZoneRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** `(targetWidth, targetHeight) => rect`, called when a pointer lands. */
+export type ZoneRectFn = (w: number, h: number) => ZoneRect;
+export type TouchZoneKind = 'stick' | 'buttons' | 'swipe';
+export interface StickZoneOptions {
+    kind: 'stick';
+    rect: ZoneRectFn;
+    /** Vector magnitude below which the stick reads 0 (rescaled above it). Default 0.12. */
+    deadZone?: number;
+    /** CSS px of travel for a full deflection. Default 64. */
+    radius?: number;
+    /** Where the stick's origin is: the down point (default) or the zone's centre. */
+    anchor?: 'down' | 'center';
+}
+export interface ButtonsZoneOptions {
+    kind: 'buttons';
+    rect: ZoneRectFn;
+    /** Sub-rects by name; a pointer landing in one presses it (and holds it until it lifts). */
+    buttons: Record<string, ZoneRectFn>;
+}
+export interface SwipeZoneOptions {
+    kind: 'swipe';
+    rect: ZoneRectFn;
+    /** CSS px of travel that makes a swipe. Default 24. */
+    threshold?: number;
+}
+export type TouchZoneOptions = StickZoneOptions | ButtonsZoneOptions | SwipeZoneOptions;
+export type SwipeDirection = 'left' | 'right' | 'up' | 'down';
+/** A `stick` zone's reading. */
+export interface StickZone {
+    readonly kind: 'stick';
+    /** True while a pointer is down in the zone. */
+    readonly active: boolean;
+    /** The deflection, -1..1 each (y down). One array, updated in place. */
+    readonly vector: readonly [number, number];
+    /** Shorthands for `vector[0]` / `vector[1]`. */
+    readonly x: number;
+    readonly y: number;
+    /** The stick's origin in target px (NaN while inactive). */
+    readonly originX: number;
+    readonly originY: number;
+}
+/** A `buttons` zone's reading. */
+export interface ButtonsZone {
+    readonly kind: 'buttons';
+    readonly active: boolean;
+    /** True on the tick a pointer landed on the button. */
+    pressed(name: string): boolean;
+    /** True while a pointer that landed on the button is down. */
+    held(name: string): boolean;
+    /** The button held now, or `null`. */
+    readonly down: string | null;
+}
+/** A `swipe` zone's reading. */
+export interface SwipeZone {
+    readonly kind: 'swipe';
+    readonly active: boolean;
+    /** The direction swiped this tick, once per gesture, else `null`. */
+    readonly swipe: SwipeDirection | null;
+}
+export type TouchZoneReading<O extends TouchZoneOptions> = O extends StickZoneOptions ? StickZone : O extends ButtonsZoneOptions ? ButtonsZone : SwipeZone;
+/**
+ * How an action reads a zone. `Z` is the zone names (ws/api-core: `createTouchZones` checks
+ * `zone` against its `zones`); default any string.
+ */
+export type TouchZoneBinding<Z extends string = string> = 
+/** A stick axis in one direction: 0..1 of the deflection along it. */
+{
+    zone: Z;
+    axis: 'x' | 'y';
+    dir: 1 | -1;
+}
+/** A button: 1 while held, with a fresh press each landing. */
+ | {
+    zone: Z;
+    button: string;
+}
+/** A swipe: 1 on the tick it is recognised. */
+ | {
+    zone: Z;
+    swipe: SwipeDirection;
+};
+export interface TouchZonesOptions<Z extends Record<string, TouchZoneOptions>, A extends string = string> {
+    zones: Z;
+    /**
+     * Actions fed through `input` from the zones. Typed (ws/api-core): the actions are the
+     * input's, the `zone`s are names in `zones`.
+     */
+    bindings?: Partial<Record<A, TouchZoneBinding<keyof Z & string> | readonly TouchZoneBinding<keyof Z & string>[]>>;
+    /** Pointer devices the zones take. Default `['touch']`. */
+    devices?: readonly PointerRecordDevice[];
+}
+export interface TouchZones<Z extends Record<string, TouchZoneOptions>> {
+    readonly zones: {
+        readonly [K in keyof Z]: TouchZoneReading<Z[K]>;
+    };
+    /** False stops the zones taking pointers (held ones are dropped). */
+    enabled: boolean;
+    /**
+     * Advance the per-tick edges (`pressed`, `swipe`). The linked `input.update()` calls this
+     * through its action source; do not call it yourself while the zones are linked.
+     */
+    update(): void;
+    /** Join the input's dispatcher (done on creation and on every `input.attach`). */
+    attach(): void;
+    /** Leave the dispatcher and drop every pointer. */
+    detach(): void;
+    /** Detach and unlink from the input (actions and attach events). */
+    destroy(): void;
+}
+export declare function createTouchZones<Z extends Record<string, TouchZoneOptions>, A extends string = string>(input: Input<A>, opts: TouchZonesOptions<Z, NoInfer<A>>): TouchZones<Z>;

package/dist/input/touch-zones.js

@@ -0,0 +1,300 @@
+import { POINTER_PRIORITY, } from './pointer-dispatch.js';
+const DEFAULT_DEAD_ZONE = 0.12;
+const DEFAULT_RADIUS = 64;
+const DEFAULT_SWIPE_PX = 24;
+const inRect = (r, x, y) => x >= r.x && x < r.x + r.w && y >= r.y && y < r.y + r.h;
+export function createTouchZones(input, opts) {
+    const devices = opts.devices ?? ['touch'];
+    const states = [];
+    const byName = new Map();
+    const readings = {};
+    for (const name of Object.keys(opts.zones)) {
+        const z = opts.zones[name];
+        const st = {
+            name,
+            opts: z,
+            pointer: -1,
+            left: 0,
+            top: 0,
+            width: 0,
+            height: 0,
+            rect: { x: 0, y: 0, w: 0, h: 0 },
+            vector: [0, 0],
+            originX: Number.NaN,
+            originY: Number.NaN,
+            down: null,
+            pendingPress: null,
+            pressedNow: null,
+            downX: 0,
+            downY: 0,
+            swiped: false,
+            pendingSwipe: null,
+            swipeNow: null,
+        };
+        states.push(st);
+        byName.set(name, st);
+        readings[name] = makeReading(st);
+    }
+    const bindings = new Map();
+    if (opts.bindings) {
+        for (const action of Object.keys(opts.bindings)) {
+            const b = opts.bindings[action];
+            bindings.set(action, Array.isArray(b) ? b : [b]);
+        }
+    }
+    let dispatcher = null;
+    let enabled = true;
+    const drop = (st) => {
+        if (st.pointer >= 0)
+            dispatcher?.release(st.pointer);
+        st.pointer = -1;
+        st.vector[0] = 0;
+        st.vector[1] = 0;
+        st.originX = Number.NaN;
+        st.originY = Number.NaN;
+        st.down = null;
+        st.swiped = false;
+    };
+    const holder = (id) => {
+        for (let i = 0; i < states.length; i++)
+            if (states[i].pointer === id)
+                return states[i];
+        return null;
+    };
+    const consumer = {
+        pointerDown: (p) => {
+            if (!enabled || !dispatcher || devices.indexOf(p.device) < 0)
+                return;
+            const b = dispatcher.bounds();
+            const x = p.clientX - b.left;
+            const y = p.clientY - b.top;
+            for (let i = 0; i < states.length; i++) {
+                const st = states[i];
+                if (st.pointer >= 0)
+                    continue;
+                const r = st.opts.rect(b.width, b.height);
+                if (!inRect(r, x, y))
+                    continue;
+                if (!dispatcher.claim(p.id, consumer))
+                    return;
+                st.pointer = p.id;
+                st.left = b.left;
+                st.top = b.top;
+                st.width = b.width;
+                st.height = b.height;
+                st.rect = r;
+                const o = st.opts;
+                if (o.kind === 'stick') {
+                    if (o.anchor === 'center') {
+                        st.originX = r.x + r.w / 2;
+                        st.originY = r.y + r.h / 2;
+                    }
+                    else {
+                        st.originX = x;
+                        st.originY = y;
+                    }
+                    stickMove(st, o, x, y);
+                }
+                else if (o.kind === 'buttons') {
+                    for (const name of Object.keys(o.buttons)) {
+                        if (inRect(o.buttons[name](b.width, b.height), x, y)) {
+                            st.down = name;
+                            st.pendingPress = name;
+                            break;
+                        }
+                    }
+                }
+                else {
+                    st.downX = x;
+                    st.downY = y;
+                    st.swiped = false;
+                }
+                return;
+            }
+        },
+        pointerMove: (p) => {
+            const st = holder(p.id);
+            if (!st)
+                return;
+            const x = p.clientX - st.left;
+            const y = p.clientY - st.top;
+            const o = st.opts;
+            if (o.kind === 'stick')
+                stickMove(st, o, x, y);
+            else if (o.kind === 'swipe' && !st.swiped) {
+                const dx = x - st.downX;
+                const dy = y - st.downY;
+                const threshold = o.threshold ?? DEFAULT_SWIPE_PX;
+                if (dx * dx + dy * dy >= threshold * threshold) {
+                    st.swiped = true;
+                    st.pendingSwipe =
+                        Math.abs(dx) >= Math.abs(dy) ? (dx > 0 ? 'right' : 'left') : dy > 0 ? 'down' : 'up';
+                }
+            }
+        },
+        pointerUp: (p) => {
+            const st = holder(p.id);
+            if (st)
+                drop(st);
+        },
+        pointerCancel: (p) => {
+            const st = holder(p.id);
+            if (st)
+                drop(st);
+        },
+        cancelAll: () => {
+            for (let i = 0; i < states.length; i++)
+                drop(states[i]);
+        },
+    };
+    const update = () => {
+        for (let i = 0; i < states.length; i++) {
+            const st = states[i];
+            st.pressedNow = st.pendingPress;
+            st.pendingPress = null;
+            st.swipeNow = st.pendingSwipe;
+            st.pendingSwipe = null;
+        }
+    };
+    const bindingValue = (b) => {
+        const st = byName.get(b.zone);
+        if (!st)
+            return 0;
+        if ('axis' in b) {
+            const v = st.vector[b.axis === 'x' ? 0 : 1] * b.dir;
+            return Math.max(0, v);
+        }
+        if ('button' in b)
+            return st.down === b.button ? 1 : 0;
+        return st.swipeNow === b.swipe ? 1 : 0;
+    };
+    const source = {
+        update,
+        value: (action) => {
+            const list = bindings.get(action);
+            if (!list)
+                return 0;
+            let v = 0;
+            for (let i = 0; i < list.length; i++) {
+                const x = bindingValue(list[i]);
+                if (x > v)
+                    v = x;
+            }
+            return v;
+        },
+        fresh: (action) => {
+            const list = bindings.get(action);
+            if (!list)
+                return false;
+            for (let i = 0; i < list.length; i++) {
+                const b = list[i];
+                if ('button' in b && byName.get(b.zone)?.pressedNow === b.button)
+                    return true;
+            }
+            return false;
+        },
+    };
+    let removeConsumer = null;
+    const detach = () => {
+        consumer.cancelAll();
+        removeConsumer?.();
+        removeConsumer = null;
+        dispatcher = null;
+    };
+    const attach = () => {
+        detach();
+        const d = input.dispatcher;
+        if (!d)
+            return;
+        dispatcher = d;
+        removeConsumer = d.add(consumer, POINTER_PRIORITY.zones);
+    };
+    const removeSource = input.addActionSource(source);
+    const offAttach = input.on('attach', attach);
+    const offDetach = input.on('detach', detach);
+    attach();
+    return {
+        zones: readings,
+        get enabled() {
+            return enabled;
+        },
+        set enabled(v) {
+            enabled = v;
+            if (!v)
+                consumer.cancelAll();
+        },
+        update,
+        attach,
+        detach,
+        destroy() {
+            detach();
+            removeSource();
+            offAttach();
+            offDetach();
+        },
+    };
+}
+function stickMove(st, o, x, y) {
+    const radius = o.radius ?? DEFAULT_RADIUS;
+    const dead = o.deadZone ?? DEFAULT_DEAD_ZONE;
+    let vx = (x - st.originX) / radius;
+    let vy = (y - st.originY) / radius;
+    const m = Math.sqrt(vx * vx + vy * vy);
+    if (m <= dead) {
+        vx = 0;
+        vy = 0;
+    }
+    else {
+        const scaled = Math.min(1, (m - dead) / (1 - dead));
+        vx = (vx / m) * scaled;
+        vy = (vy / m) * scaled;
+    }
+    st.vector[0] = vx;
+    st.vector[1] = vy;
+}
+function makeReading(st) {
+    const kind = st.opts.kind;
+    if (kind === 'stick') {
+        return {
+            kind,
+            get active() {
+                return st.pointer >= 0;
+            },
+            vector: st.vector,
+            get x() {
+                return st.vector[0];
+            },
+            get y() {
+                return st.vector[1];
+            },
+            get originX() {
+                return st.originX;
+            },
+            get originY() {
+                return st.originY;
+            },
+        };
+    }
+    if (kind === 'buttons') {
+        return {
+            kind,
+            get active() {
+                return st.pointer >= 0;
+            },
+            pressed: (name) => st.pressedNow === name,
+            held: (name) => st.down === name,
+            get down() {
+                return st.down;
+            },
+        };
+    }
+    return {
+        kind,
+        get active() {
+            return st.pointer >= 0;
+        },
+        get swipe() {
+            return st.swipeNow;
+        },
+    };
+}

package/dist/input/types.d.ts

@@ -0,0 +1,158 @@
+/**
+ * How a binding turns its raw input into an action (ws/input-3). `'press'` (the default) is
+ * active while the input is down. `'hold'` becomes active once the input has stayed down for
+ * `holdMs` (400) and stays active until it lifts; `ActionState.holdProgress` runs 0..1 meanwhile.
+ * `'doubleTap'` is active for one tick when the input goes down a second time within
+ * `doubleTapMs` (300) of the previous down. Times are measured in ticks of `Input.update()`
+ * (`InputOptions.tickMs`, default 1000/60), so a recording replays identically.
+ */
+export type Trigger = 'press' | 'hold' | 'doubleTap';
+/** The trigger fields every `Binding` may carry. */
+export interface TriggerOptions {
+    trigger?: Trigger;
+    /** Ms down before a `'hold'` fires. Default 400. */
+    holdMs?: number;
+    /** Most ms between the two downs of a `'doubleTap'`. Default 300. */
+    doubleTapMs?: number;
+}
+/** The input half of a `Binding`, without its trigger fields. */
+export type BindingSource = 
+/** `KeyboardEvent.code` (layout-independent), e.g. `'KeyZ'`, `'Space'`, `'ArrowLeft'`, `'Escape'`. */
+{
+    key: string;
+}
+/** `PointerEvent.button`: 0 primary (also touch/pen contact), 1 middle, 2 secondary. */
+ | {
+    mouse: number;
+}
+/** Wheel scrolled this tick. `1` = deltaY > 0 (down / towards the user), `-1` = up. */
+ | {
+    wheel: 1 | -1;
+}
+/** Standard-mapping gamepad button index (0 = A/Cross, 9 = Start …). `pad` omitted = any pad. */
+ | {
+    padButton: number;
+    pad?: number;
+    threshold?: number;
+}
+/** Gamepad axis past `threshold` (default 0.5) in direction `dir`. Value is analog 0..1. */
+ | {
+    padAxis: number;
+    dir: 1 | -1;
+    pad?: number;
+    threshold?: number;
+}
+/**
+ * A gesture from the `Gestures` linked with `Input.setGestures`. `tap` and `doubleTap` press
+ * for one tick; `longPress` holds until its pointer lifts; `pan`, `drag` and `pinch` hold
+ * from their start until they end. Reads inactive when no gestures are linked.
+ */
+ | {
+    gesture: GestureKind;
+}
+/**
+ * A button of any pointer the linked `PointerRouter` routes (`Input.setPointers`): `select` is
+ * mouse button 0, a touch or pen contact, the pad cursor's press button and an XR trigger or
+ * pinch; `secondary` is mouse button 2, the pad cursor's second button and an XR squeeze.
+ * Pressed when one goes down; held while any is down. Inactive with no router linked.
+ */
+ | {
+    pointer: PointerButton;
+}
+/**
+ * An XR controller or hand button from an XR `PointerSource` (`hand` omitted = either hand).
+ * `createGame({ xr })` adds an `XrPointerSource` to `ctx.pointers` for the session; with no XR
+ * source on the router this reads inactive.
+ */
+ | {
+    xr: XrButton;
+    hand?: Hand;
+}
+/**
+ * A chord (ws/input-3): active while every member binding is down, in any order; `pressed`
+ * fires once when the last one lands. Members are plain bindings (their own triggers are
+ * ignored); the members may also drive actions of their own.
+ */
+ | {
+    chord: readonly Binding[];
+};
+/**
+ * A physical input that can drive an action, with optional trigger fields (`trigger`, `holdMs`,
+ * `doubleTapMs`). The engine ships no default bindings; the game supplies them.
+ */
+export type Binding = BindingSource & TriggerOptions;
+/** Pointer buttons a `{ pointer }` binding can name. */
+export type PointerButton = 'select' | 'secondary';
+/** XR buttons a `{ xr }` binding can name: controller trigger, grip squeeze, hand pinch. */
+export type XrButton = 'trigger' | 'squeeze' | 'pinch';
+/** Which hand an XR pointer is in. */
+export type Hand = 'left' | 'right';
+/** The gestures `Gestures` recognises (and a `{ gesture }` binding can name). */
+export type GestureKind = 'tap' | 'doubleTap' | 'longPress' | 'pan' | 'drag' | 'pinch';
+export type Bindings<A extends string> = {
+    readonly [K in A]: readonly Binding[];
+};
+/** The device that last produced input (`Input.lastDevice`); `'xr'` once an XR button fires. */
+export type InputDevice = 'keyboard' | 'mouse' | 'touch' | 'pen' | 'gamepad' | 'xr';
+/** The `Gamepad.vibrationActuator` shape `Input.rumble` drives. */
+export interface GamepadActuatorLike {
+    readonly type?: string;
+    playEffect(type: string, params: {
+        duration: number;
+        startDelay?: number;
+        strongMagnitude?: number;
+        weakMagnitude?: number;
+    }): Promise<unknown> | unknown;
+}
+/** Minimal shape of a `Gamepad` (lets tests feed plain objects). */
+export interface GamepadLike {
+    readonly connected?: boolean;
+    readonly buttons: readonly {
+        readonly pressed: boolean;
+        readonly value: number;
+    }[];
+    readonly axes: readonly number[];
+    /** `Gamepad.id`, used to guess the button layout for prompt glyphs. */
+    readonly id?: string;
+    /** `Gamepad.vibrationActuator`, when the pad can rumble. */
+    readonly vibrationActuator?: GamepadActuatorLike | null;
+}
+/** Maps a client-space point (CSS px, `clientX/Y`) into game space, or `null` if outside it. */
+export type PointerTransform = (clientX: number, clientY: number) => {
+    x: number;
+    y: number;
+} | null;
+export interface PointerState {
+    /** Position in game space (after the transform). Holds the last inside position when outside. */
+    x: number;
+    y: number;
+    /** Movement since the previous `update()`, game space. */
+    dx: number;
+    dy: number;
+    /** True when the last known position mapped inside the game rect. */
+    inside: boolean;
+    /** Primary button / contact currently down. */
+    down: boolean;
+    /** Wheel accumulated since the previous `update()` (pixels, normalised). */
+    wheelX: number;
+    wheelY: number;
+    /** Device of the most recent pointer event. */
+    type: 'mouse' | 'touch' | 'pen';
+}
+export interface ActionState {
+    /** True on the first tick the action became active. */
+    pressed: boolean;
+    /** True while active (also for a tap that started and ended between two ticks). */
+    held: boolean;
+    /** True on the first tick after the action stopped being active. */
+    released: boolean;
+    /** Analog value 0..1 (digital inputs give 0 or 1). */
+    value: number;
+    /** Consecutive ticks held (0 when not held). */
+    heldTicks: number;
+    /**
+     * For `'hold'` bindings: how far the longest press in progress is towards `holdMs`, 0..1 (1
+     * once the hold fired, 0 while nothing is down or the action has no hold binding).
+     */
+    holdProgress: number;
+}

package/dist/input/types.js

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

package/dist/input/xr-source.d.ts

@@ -0,0 +1,53 @@
+/// <reference path="../platform/xr-types.d.ts" preserve="true" />
+/**
+ * XR controllers and hands as pointers (ws/xr; ARCHITECTURE "Input"). `XrPointerSource` is a
+ * `PointerSource` the router polls like any other: each `XRInputSource` of the session becomes
+ * one `PointerSample` whose ray is the source's target ray in the reference space (`x`, `y`
+ * NaN: there is no screen), with `xr.trigger` and `xr.squeeze` from the `xr-standard` gamepad
+ * (buttons 0 and 1) or, without a gamepad, from the session's select and squeeze events, and
+ * `xr.pinch` from the hand's index-finger tip and thumb tip when the Hand Input module reports
+ * joints. `select = trigger || pinch`, `secondary = squeeze`, `hand` is the handedness. Nothing in
+ * the router changes; `{ xr: 'trigger' | 'squeeze' | 'pinch', hand? }` bindings read these.
+ *
+ * Poses are only readable inside an `XRFrame`, so the source takes a getter for the frame that is
+ * running (`() => xrHost.frame`); polled outside one it reports no pointers.
+ */
+import { type PointerSample, type PointerSource } from './pointer-sources.js';
+import type { RayCamera } from './rays.js';
+export interface XrPointerSourceOptions {
+    /** Index tip to thumb tip distance (metres) at or under which a pinch starts. Default 0.02. */
+    pinchStart?: number;
+    /** Distance over which a pinch ends (hysteresis). Default 0.035. */
+    pinchEnd?: number;
+}
+export declare class XrPointerSource implements PointerSource {
+    readonly session: XRSession;
+    readonly referenceSpace: XRReferenceSpace;
+    /** The `XRFrame` running now, or null between frames (`() => xrHost.frame`). */
+    private readonly frame;
+    private readonly samples;
+    private readonly pressed;
+    private readonly pinching;
+    private readonly out;
+    private readonly pinchStart;
+    private readonly pinchEnd;
+    private nextKey;
+    private listening;
+    constructor(session: XRSession, referenceSpace: XRReferenceSpace, 
+    /** The `XRFrame` running now, or null between frames (`() => xrHost.frame`). */
+    frame: () => XRFrame | null, opts?: XrPointerSourceOptions);
+    /** Listens to the session's select and squeeze events (the router calls this; idempotent). */
+    attach(): void;
+    /** Stops listening and forgets every pointer. */
+    detach(): void;
+    poll(_camera: RayCamera | null): readonly PointerSample[];
+    /** Index tip to thumb tip under `pinchStart` starts a pinch; over `pinchEnd` ends it. */
+    private pinch;
+    private state;
+    private readonly onSelectStart;
+    private readonly onSelectEnd;
+    private readonly onSqueezeStart;
+    private readonly onSqueezeEnd;
+    /** A removed source's pointer ends (its key stops appearing) and its state is dropped. */
+    private readonly onSourcesChange;
+}