@ggts-sh/svelte 0.43.0

package/dist/surface/surface-description.js

@@ -0,0 +1,11 @@
+export function buildSurfaceDescription(activeTool, inspectPinEnabled) {
+    if (activeTool === "select-area")
+        return "Press Enter or Space to set the first selection corner. Use Arrow keys to move the opposite corner; hold Shift for larger steps. Press Enter or Space to complete the selection. Press Escape to cancel.";
+    if (activeTool === "zoom-area")
+        return "Press Enter or Space to set the first zoom corner. Use Arrow keys to move the opposite corner; hold Shift for larger steps. Press Enter or Space to complete the zoom. Press Escape to cancel.";
+    if (activeTool === "point")
+        return "Use Arrow keys to inspect data. Press Enter or Space to toggle the focused point selection. Press Escape to dismiss.";
+    return inspectPinEnabled
+        ? "Use Arrow keys to inspect data. Press Enter or Space to pin. Press Escape to dismiss."
+        : "Use Arrow keys to inspect data. Press Escape to dismiss.";
+}

package/dist/surface/surface-handlers.svelte.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Surface DOM/event handler implementation, extracted from
+ * surface-state.svelte.ts for S5 (plan §4).
+ *
+ * Receives LIVE accessors and actions only (reducer thunk, construction-time
+ * derived reads, brush-draft get/set, sibling controller ports, selection
+ * sinks) and reads them at event time — handlers never snapshot rune values:
+ * `activeTool()`, `brushing()`, and `getBrushRect()` are re-read whenever the
+ * event or rAF frame fires.
+ *
+ * Handler-private non-rune mutable state lives here (touch-inspect start/
+ * moved, queued area source, click-suppress deadline); the brush draft stays
+ * $state in surface-state, mutated only through `setBrushRect`. Tool
+ * selection (`chooseTool`) stays in surface-state and is injected as an
+ * action for the Escape dismissal side effects. Pure decision tables remain
+ * in pointer.ts, keyboard.ts, area-brush.ts, and capability.ts — this module
+ * owns the switches and side effects.
+ */
+import type { InteractionContext } from "../interaction/interaction-context.svelte.js";
+import type { InteractionSource, InteractionTool } from "../interaction/interaction.js";
+import type { BrushRect, InteractionReducer, SurfaceStateOptions } from "./surface-state.svelte.js";
+/** Live ports for the handlers; sibling ports re-picked from SurfaceStateOptions. */
+export type SurfaceHandlersPorts = {
+    /** Shared interaction context (live getters; handler-only invocation). */
+    readonly context: InteractionContext;
+    /** Reducer thunk — the reducer is constructed after this factory. */
+    readonly reducer: () => InteractionReducer;
+    /** Construction-time deriveds, read live at event time — never snapshotted. */
+    readonly activeTool: () => InteractionTool;
+    readonly brushing: () => boolean;
+    readonly areaAwaitingSecond: () => boolean;
+    /** Brush draft lives in surface-state $state; mutated only via this pair. */
+    readonly getBrushRect: () => BrushRect | null;
+    readonly setBrushRect: (rect: BrushRect | null) => void;
+    /** Tool selection action (owned by surface-state) for Escape side effects. */
+    readonly chooseTool: (next: InteractionTool) => void;
+} & Pick<SurfaceStateOptions, "inspection" | "interval" | "zoom" | "emitSelection" | "togglePointKeys" | "pointSelectEnabled">;
+export declare function createSurfaceHandlers(ports: SurfaceHandlersPorts): {
+    applyAreaMove: (point: Readonly<{
+        x: number;
+        y: number;
+    }>, source?: InteractionSource) => void;
+    clearTouchInspect: () => void;
+    onPointerMove: (event: PointerEvent) => void;
+    onPointerDown: (event: PointerEvent) => void;
+    onPointerUp: (event: PointerEvent) => void;
+    onPointerLeave: () => void;
+    onPointerCancel: () => void;
+    onLostPointerCapture: () => void;
+    onCaptureClick: (event: MouseEvent) => void;
+    onSurfaceKeyDown: (event: KeyboardEvent) => void;
+    onSurfaceBlur: (event: FocusEvent) => void;
+};

package/dist/surface/surface-handlers.svelte.js

@@ -0,0 +1,418 @@
+import { resolveTarget } from "../interaction/target.js";
+import { resolveSurfaceBlurAction } from "../inspection/teardown.js";
+import { applyInspectionDismissSideEffects } from "../interaction/transition-owner.js";
+import { buildIntervalSelectionFromScene, intervalQuerySceneFromModel, } from "../interval/query.js";
+import { BRUSH_SECOND_CORNER_ANNOUNCEMENT } from "../assembly/labels.js";
+import { normalizedRect, panelBoundsFrom } from "../scene/geometry.js";
+import { advanceTouchInspectMoved, resolveCaptureClickAction, resolveLostPointerCaptureAction, resolvePointerDownAction, resolvePointerMoveAction, resolvePointerUpAction, shouldClearInspectionOnPointerLeave, TOUCH_INSPECT_CLICK_SUPPRESS_MS, } from "./pointer.js";
+import { brushAtPoint, brushWithEnd } from "./area-brush.js";
+import { resolveSurfaceKeyAction } from "./keyboard.js";
+export function createSurfaceHandlers(ports) {
+    const { context } = ports;
+    const reducerOf = ports.reducer;
+    let queuedAreaSource = "pointer";
+    let touchInspectStart = null;
+    let touchInspectMoved = false;
+    let suppressClickUntil = 0;
+    function clearTouchInspect() {
+        touchInspectStart = null;
+        touchInspectMoved = false;
+    }
+    function plotPoint(event) {
+        const model = context.model();
+        if (model === null)
+            return { x: 0, y: 0 };
+        const target = event.currentTarget;
+        if (target === null)
+            return { x: 0, y: 0 };
+        return model.viewport.locate(event.clientX, event.clientY, target.getBoundingClientRect());
+    }
+    function panelAtPoint(point) {
+        return context.model()?.viewport.panelAtOrOnly(point) ?? null;
+    }
+    function onPointerMove(event) {
+        const p = plotPoint(event);
+        // Sticky threshold is pure; host only advances on touch + start set.
+        if (event.pointerType === "touch" && touchInspectStart !== null) {
+            touchInspectMoved = advanceTouchInspectMoved(touchInspectMoved, touchInspectStart, p);
+        }
+        // Decision table is pure (surface/pointer); this switch owns queues.
+        const action = resolvePointerMoveAction({
+            pointerType: event.pointerType,
+            activeTool: ports.activeTool(),
+            touchInspectMoved,
+            hasTouchInspectStart: touchInspectStart !== null,
+            brushing: ports.brushing(),
+            hasBrushDraft: ports.getBrushRect() !== null,
+            inspect: context.inspectConfig(),
+        });
+        switch (action.type) {
+            case "touch-inspect-drag-cancel":
+                ports.inspection().cancelPointerInspect({ pendingPinned: "preserve" });
+                return;
+            case "queue-area-move":
+                queuedAreaSource = action.source;
+                reducerOf().queuePointer({ type: "move-area", point: p });
+                return;
+            case "queue-inspect":
+                // Pure snapshot: no re-gate; inspection owns nearest lookup/token.
+                ports.inspection().schedulePointerInspect({
+                    point: p,
+                    source: action.source,
+                    mode: action.mode,
+                    maxDistance: action.maxDistance,
+                });
+                break;
+            case "none":
+                break;
+        }
+    }
+    function applyAreaMove(point, source = queuedAreaSource) {
+        const draft = ports.getBrushRect();
+        if (!ports.brushing() || draft === null)
+            return;
+        const next = brushWithEnd(draft, point);
+        ports.setBrushRect(next);
+        if (ports.activeTool() === "select-area")
+            ports.emitSelection(selectionEvent("change", normalizedRect(next), source));
+    }
+    /** Map the live render model into the pure interval query scene adapter. */
+    function intervalQueryScene() {
+        const model = context.model();
+        if (model === null)
+            return null;
+        return intervalQuerySceneFromModel(model);
+    }
+    /**
+     * Shared finish-brush effects (select/zoom/end); pointer callers cancel first.
+     */
+    function applyFinishBrush(finish, source) {
+        switch (finish.type) {
+            case "keep-second-corner":
+                ports.setBrushRect(finish.corners);
+                context.announce(BRUSH_SECOND_CORNER_ANNOUNCEMENT);
+                break;
+            case "select-end": {
+                ports.setBrushRect(null);
+                const eventValue = selectionEvent("end", finish.rect, source);
+                // Interval owns commit + emit; surface only routes FinishBrushAction.
+                ports.interval().finishBrushSelect(eventValue, source);
+                reducerOf().dispatch({ type: "cancel-area" });
+                break;
+            }
+            case "zoom-end":
+                ports.setBrushRect(null);
+                ports.zoom().applyBrushZoom(finish.rect, source);
+                reducerOf().dispatch({ type: "cancel-area" });
+                break;
+            case "end-area":
+                // Commit with non-area tool (e.g. tool changed mid-drag): clear only.
+                ports.setBrushRect(null);
+                reducerOf().dispatch({ type: "cancel-area" });
+                break;
+        }
+    }
+    function onPointerLeave() {
+        // Evaluate leave clear **inside** the microtask so brushing/tooltip
+        // reflect post-flush state (not leave-time snapshots).
+        queueMicrotask(() => {
+            if (!shouldClearInspectionOnPointerLeave({
+                brushing: ports.brushing(),
+                tooltipHovered: context.tooltipHovered(),
+            }))
+                return;
+            ports.inspection().cancelPointerInspect({ pendingPinned: "discard" });
+            reducerOf().cancelScheduledPointer();
+            ports.inspection().setInspection(null, "pointer");
+        });
+    }
+    function onPointerDown(event) {
+        // Always cancel queued inspection before pure routing (host cleanup).
+        // Preserve pinned stash; full schedule cancel (inspect + move-area).
+        ports.inspection().cancelPointerInspect({ pendingPinned: "preserve" });
+        reducerOf().cancelScheduledPointer();
+        // point always computed (pure begin-area needs it; touch/none ignore).
+        const p = plotPoint(event);
+        const action = resolvePointerDownAction({
+            pointerType: event.pointerType,
+            button: event.button,
+            activeTool: ports.activeTool(),
+            areaAwaitingSecond: ports.areaAwaitingSecond(),
+            brushCorners: ports.getBrushRect(),
+            point: p,
+        });
+        switch (action.type) {
+            case "touch-inspect-start":
+                touchInspectStart = p;
+                touchInspectMoved = false;
+                break;
+            case "none":
+                break;
+            case "begin-area": {
+                // R3: the brush is panel-scoped — extending stays on the origin
+                // panel from the reducer; a fresh brush anchors to the hit panel.
+                const area = reducerOf().state.area;
+                const extending = ports.areaAwaitingSecond() && ports.getBrushRect() !== null;
+                const model = context.model();
+                const originPanel = extending
+                    ? area.kind === "idle" || area.panelId === null
+                        ? null
+                        : (model?.viewport.panel(area.panelId) ?? null)
+                    : panelAtPoint(p);
+                if (originPanel === null)
+                    break;
+                // Pure table owns fresh vs extend corner policy.
+                ports.setBrushRect(action.corners);
+                ports.inspection().setInspection(null, action.source);
+                reducerOf().dispatch({
+                    type: "begin-area",
+                    point: p,
+                    panelId: originPanel.id,
+                });
+                if (action.emitSelectStart) {
+                    const startEvent = selectionEvent("start", normalizedRect(action.corners), action.source);
+                    ports.emitSelection(startEvent);
+                }
+                try {
+                    event.currentTarget.setPointerCapture(event.pointerId);
+                }
+                catch {
+                    // Synthetic events may not register a pointer id; reducer owns cancel.
+                }
+                break;
+            }
+        }
+    }
+    function selectionEvent(phase, rect, source) {
+        const area = reducerOf().state.area;
+        const originPanelId = area.kind === "idle" ? ports.interval().committedInterval?.panelId : area.panelId;
+        return buildIntervalSelectionFromScene({
+            phase,
+            mode: context.selectConfig()?.mode ?? "xy",
+            source,
+            pixels: rect,
+            scene: intervalQueryScene(),
+            ...(originPanelId !== undefined && { panelId: originPanelId }),
+            keyForRow: (rowIndex) => context.semanticKey(context.model()?.row(rowIndex) ?? null, rowIndex),
+        });
+    }
+    function onPointerUp(event) {
+        // endPoint always computed (pure finish-brush needs it; touch paths ignore).
+        const endPoint = plotPoint(event);
+        const action = resolvePointerUpAction({
+            pointerType: event.pointerType,
+            activeTool: ports.activeTool(),
+            inspect: context.inspectConfig(),
+            hasTouchInspectStart: touchInspectStart !== null,
+            touchInspectMoved,
+            brushing: ports.brushing(),
+            brushCorners: ports.getBrushRect(),
+            endPoint,
+        });
+        switch (action.type) {
+            case "touch-inspect-drag-ignore":
+                // Always clear touch-inspect start state (host cleanup).
+                clearTouchInspect();
+                break;
+            case "touch-inspect-tap": {
+                clearTouchInspect();
+                // mode/maxDistance/state from pure inspect snapshot — no re-gate.
+                // Resolved target owns panel-scoped nearest + tap distance policy (#1080 / #787).
+                const model = context.model();
+                const target = model === null
+                    ? null
+                    : resolveTarget({
+                        model,
+                        point: endPoint,
+                        intent: "tap",
+                        inspect: { mode: action.mode, maxDistance: action.maxDistance },
+                    });
+                if (target !== null) {
+                    ports.inspection().setInspection(target.match, "touch", action.state, target.mode);
+                    suppressClickUntil = performance.now() + TOUCH_INSPECT_CLICK_SUPPRESS_MS;
+                }
+                break;
+            }
+            case "none":
+                break;
+            case "finish-brush": {
+                // Pure table owns evaluate + select/zoom/end; host cancels then applies.
+                reducerOf().cancelScheduledPointer();
+                applyFinishBrush(action.finish, action.source);
+                break;
+            }
+        }
+    }
+    function onSurfaceBlur(event) {
+        const blurAction = resolveSurfaceBlurAction({
+            relatedTargetInsideRoot: context.root()?.contains(event.relatedTarget) === true,
+            inspectionState: ports.inspection().inspection?.state ?? "none",
+        });
+        if (blurAction.type === "ignore")
+            return;
+        // Shared for keep-pinned and clear-inspection (ordering is load-bearing).
+        ports.inspection().resetTraversalIndex();
+        ports.inspection().cancelPointerInspect({ pendingPinned: "preserve" });
+        if (blurAction.type === "blur-clear-inspection")
+            ports.inspection().setInspection(null, "keyboard");
+    }
+    function onSurfaceKeyDown(event) {
+        // Decision table is pure (surface/keyboard); this switch owns side
+        // effects only. brushCorners is the draft source of truth (not reducer
+        // brushing); nudge/complete-area carry pure payloads so host only applies.
+        const inspection = ports.inspection();
+        const { action, preventDefault } = resolveSurfaceKeyAction({
+            key: event.key,
+            shiftKey: event.shiftKey,
+            activeTool: ports.activeTool(),
+            brushCorners: ports.getBrushRect(),
+            hasInspection: inspection.inspection !== null,
+            pinEnabled: context.inspectConfig()?.pin === true,
+            focusKey: inspection.inspection?.focus.key ?? null,
+            sourceKeys: inspection.inspection?.focus.sourceKeys ?? [],
+            inspectionAnchor: inspection.inspection?.focus.anchor ?? null,
+            inspectionPanel: inspection.inspectionPanel,
+            // Viewport is the sole panel authority — not scene.panels[0] (#1038).
+            firstPanel: (() => {
+                const panel = context.model()?.viewport.panels[0];
+                return panel === undefined ? undefined : panelBoundsFrom(panel.bounds);
+            })(),
+        });
+        if (preventDefault)
+            event.preventDefault();
+        switch (action.type) {
+            case "nudge-brush": {
+                // Pure table owns clamp panel policy and free-corner nudge.
+                ports.setBrushRect(action.corners);
+                reducerOf().dispatch({
+                    type: "move-area",
+                    point: { x: action.corners.x1, y: action.corners.y1 },
+                });
+                return;
+            }
+            case "begin-area": {
+                // Pure table owns inspection-anchor vs panel-center policy.
+                // R3: the brush is panel-scoped — anchor to the panel under it.
+                const originPanel = panelAtPoint(action.anchor);
+                if (originPanel === null)
+                    return;
+                ports.setBrushRect(brushAtPoint(action.anchor));
+                reducerOf().dispatch({
+                    type: "begin-area",
+                    point: action.anchor,
+                    panelId: originPanel.id,
+                });
+                context.announce(BRUSH_SECOND_CORNER_ANNOUNCEMENT);
+                return;
+            }
+            case "complete-area": {
+                // finish payload is pure-owned (normalize + select/zoom/end routing).
+                applyFinishBrush(action.finish, "keyboard");
+                return;
+            }
+            case "cycle-coincident":
+                inspection.cycleCoincident(action.delta);
+                return;
+            case "navigate-direction":
+                inspection.navigateDirection(action.dx, action.dy);
+                return;
+            case "toggle-point-keys":
+                ports.togglePointKeys(action.keys, "keyboard");
+                return;
+            case "toggle-pin":
+                inspection.toggleInspectionPin("keyboard");
+                return;
+            case "escape": {
+                const plan = inspection.dismissInspection("escape", "keyboard", {
+                    returnToInspect: action.returnToInspect,
+                });
+                applyInspectionDismissSideEffects(plan, {
+                    clearBrush: () => {
+                        ports.setBrushRect(null);
+                    },
+                    chooseTool: ports.chooseTool,
+                });
+                break;
+            }
+            case "none":
+                break;
+        }
+    }
+    function onCaptureClick(event) {
+        const inspection = ports.inspection();
+        const action = resolveCaptureClickAction({
+            suppressClick: performance.now() < suppressClickUntil,
+            activeTool: ports.activeTool(),
+            pointSelectEnabled: ports.pointSelectEnabled(),
+            inspectEnabled: context.inspectConfig() !== null,
+            pinEnabled: context.inspectConfig()?.pin === true,
+            hasInspection: inspection.inspection !== null,
+        });
+        switch (action.type) {
+            case "suppress":
+                suppressClickUntil = 0;
+                break;
+            case "toggle-point": {
+                const point = plotPoint(event);
+                // Resolved target owns panel-scoped nearest + point-select radius (#1080 / #787).
+                const model = context.model();
+                const target = model === null
+                    ? null
+                    : resolveTarget({
+                        model,
+                        point,
+                        intent: "point-select",
+                        inspect: null,
+                    });
+                if (target === null)
+                    break;
+                ports.togglePointKeys(context.candidateSemanticKeys(target.match), "pointer");
+                break;
+            }
+            case "toggle-pin":
+                inspection.toggleInspectionPin("pointer");
+                break;
+            case "none":
+                break;
+        }
+    }
+    /** Pointer-cancel always drops draft/queue/touch-inspect and cancels area. */
+    function onPointerCancel() {
+        // Preserve pinned stash (leave discards; cancel preserves).
+        ports.inspection().cancelPointerInspect({ pendingPinned: "preserve" });
+        clearTouchInspect();
+        reducerOf().cancelScheduledPointer();
+        ports.setBrushRect(null);
+        reducerOf().dispatch({ type: "cancel-area" });
+    }
+    /**
+     * Lost capture: pure table owns keep vs clear draft; host mutates brushRect.
+     */
+    function onLostPointerCapture() {
+        const lost = resolveLostPointerCaptureAction(reducerOf().state.area.kind);
+        switch (lost.type) {
+            case "ignore":
+                break;
+            case "cancel-keep-draft":
+                reducerOf().dispatch({ type: "cancel-area" });
+                break;
+            case "cancel-clear-draft":
+                ports.setBrushRect(null);
+                reducerOf().dispatch({ type: "cancel-area" });
+                break;
+        }
+    }
+    return {
+        applyAreaMove,
+        clearTouchInspect,
+        onPointerMove,
+        onPointerDown,
+        onPointerUp,
+        onPointerLeave,
+        onPointerCancel,
+        onLostPointerCapture,
+        onCaptureClick,
+        onSurfaceKeyDown,
+        onSurfaceBlur,
+    };
+}

package/dist/surface/surface-state.svelte.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Surface controller extracted from GGPlot for S7.
+ *
+ * Owns the interaction reducer (+ revision), tool/brush state,
+ * construction-time deriveds (activeTool, surfaceDescription, brushing,
+ * areaAwaitingSecond), tool selection, and both surface effects
+ * (window-teardown then tool-sync). The DOM/event handler implementation
+ * lives in surface-handlers.svelte.ts and receives live accessors/actions
+ * from this factory (reducer thunk, derived reads, brush-draft get/set,
+ * sibling controller ports).
+ *
+ * Construction topology (assembly): surface is constructed BEFORE inspection
+ * so the shared reducer exists as a concrete instance; inspection receives it
+ * via options. Construction-time deriveds read ONLY module-internal state +
+ * context.inspectConfig. Sibling controller ports, sinks, and chrome getters
+ * are handler/effect-only (armed for the construction guard).
+ *
+ * Window-teardown + tool-sync effects register inside this factory (#627).
+ * Tool-scoped pure decision tables stay in pointer.ts, keyboard.ts, and
+ * area-brush.ts — those seams narrow traffic; this module is the single owner.
+ */
+import type { InspectionState } from "../inspection/inspection-state.svelte.js";
+import type { InteractionContext } from "../interaction/interaction-context.svelte.js";
+import type { IntervalState } from "../interval/interval-state.svelte.js";
+import type { InteractionSource, InteractionTool, PlotSelection, ResolvedInteractionConfig } from "../interaction/interaction.js";
+import { createInteractionReducer } from "../interaction/reducer.js";
+import type { PlotZoomState } from "../zoom/zoom-state.svelte.js";
+/** Component-held reducer shape — factory creates it inside the module. */
+export type InteractionReducer = ReturnType<typeof createInteractionReducer>;
+export type BrushRect = {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+/**
+ * Surface-specific ports beyond the shared InteractionContext. Sibling
+ * controllers are wired by the assembly (interaction-states.svelte.ts) as
+ * handler-only getters over the bundle under construction.
+ */
+export type SurfaceStateOptions = {
+    /** Controlled-tool prop + resolved config/chrome (host-held). */
+    readonly toolProp: () => InteractionTool | undefined;
+    readonly initialTool: () => ResolvedInteractionConfig["initialTool"];
+    readonly availableTools: () => readonly InteractionTool[];
+    /**
+     * Host point-select enablement (`select?.type === "point"`). Host-derived
+     * before this factory so surface does not close over later chromeState
+     * (#1082). Same formula as chrome `canPublishPointSelection`.
+     */
+    readonly pointSelectEnabled: () => boolean;
+    /**
+     * Required by the window-teardown effect — NOT derivable from filtered
+     * availableTools (codex P1-4).
+     */
+    readonly surfaceInteractive: () => boolean;
+    /** Sibling controller ports (handler-only reads). */
+    readonly inspection: () => Pick<InspectionState, "inspection" | "inspectionPanel" | "schedulePointerInspect" | "cancelPointerInspect" | "onInspectPointerFrame" | "setInspection" | "closeInspection" | "dismissInspection" | "toggleInspectionPin" | "navigateDirection" | "cycleCoincident" | "resetTraversalIndex">;
+    readonly interval: () => Pick<IntervalState, "finishBrushSelect" | "committedInterval">;
+    readonly zoom: () => Pick<PlotZoomState, "applyBrushZoom">;
+    /** Selection controller write paths. */
+    readonly emitSelection: (event: PlotSelection) => void;
+    readonly togglePointKeys: (keys: readonly PropertyKey[], source: InteractionSource) => void;
+};
+export type SurfaceState = {
+    readonly reducer: InteractionReducer;
+    readonly activeTool: InteractionTool;
+    readonly surfaceDescription: string;
+    readonly brushRect: BrushRect | null;
+    readonly areaAwaitingSecond: boolean;
+    clearBrush(): void;
+    chooseTool(next: InteractionTool): void;
+    onPointerMove(event: PointerEvent): void;
+    onPointerDown(event: PointerEvent): void;
+    onPointerUp(event: PointerEvent): void;
+    onPointerLeave(): void;
+    onPointerCancel(): void;
+    onLostPointerCapture(): void;
+    onCaptureClick(event: MouseEvent): void;
+    onSurfaceKeyDown(event: KeyboardEvent): void;
+    onSurfaceBlur(event: FocusEvent): void;
+};
+/**
+ * Create the surface controller. Construction registers deriveds and
+ * window-teardown + tool-sync effects.
+ *
+ * Construction-order note: deps must not be invoked during construction —
+ * construction-read discipline enforced by the armed-getter suite.
+ */
+export declare function createSurfaceState(context: InteractionContext, options: SurfaceStateOptions): SurfaceState;