@fjader/svelte 0.2.0 → 0.2.2

package/dist/interactors/Interval1D.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-	import { getContext, onMount } from 'svelte';
+	import { getContext, onMount, untrack } from 'svelte';
 	import { isBetween } from '@uwdata/mosaic-sql';
 	import { BrushState1D } from './brush-state.svelte';
 	import BrushOverlay from './BrushOverlay.svelte';
@@ -9,6 +9,7 @@
 		isDragging,
 		scaleBrushExtent1D,
 		createPanModeHandlers,
+		brushHandleAt,
 		WHEEL_SENSITIVITY
 	} from './brush-utils';
 	import type { ChartContext, FieldRef, Point, D3Scale } from '../types';
@@ -103,7 +104,7 @@
 	let current = 0;
 	let isCapturing = false;
 	let hasDragged = false;
-	let isPanModeActive = $state(false);
+	let isPanModeActive = false;
 
 	// Reusable point object to reduce GC pressure
 	const point = { x: 0, y: 0 };
@@ -113,9 +114,12 @@
 	let lastEmittedMax: number | null = null;
 
 	// Keyboard handlers for Space key pan mode
-	const { handleKeyDown, handleKeyUp } = createPanModeHandlers((active) => {
-		isPanModeActive = active;
-	});
+	const { handleKeyDown, handleKeyUp, handleBlur } = createPanModeHandlers(
+		(active) => {
+			isPanModeActive = active;
+		},
+		() => chart.reroutePress()
+	);
 
 	// Scale validation
 	// Always validate as 'linear': Fjader time scales use float offsets, not Dates,
@@ -128,19 +132,26 @@
 	});
 
 	// Watch for external selection changes (from detail chart pan/zoom)
-	// to keep brush visual in sync and update Mosaic filter
+	// to keep brush visual in sync and update Mosaic filter.
+	// Tracks only the selection extent and its source. The rest runs untracked:
+	// emitting the clause reads state it then writes (the filter group's
+	// selection, the scales' active values), which made this effect re-run
+	// itself without end while a detail chart was panned.
 	$effect(() => {
 		if (!(scaleState instanceof LinearScaleState)) return;
 		const extent = scaleState.selectionExtent;
-		if (extent && scaleState.selectionSource === 'external') {
-			brush.setExtent(extent[0], extent[1]);
-			lastEmittedMin = extent[0];
-			lastEmittedMax = extent[1];
-			emitFilterClause(extent[0], extent[1]);
-		} else if (!extent && brush.active) {
-			// Selection was cleared externally (e.g. detail chart reset) — clear brush
-			clearBrush();
-		}
+		const source = scaleState.selectionSource;
+		untrack(() => {
+			if (extent && source === 'external') {
+				brush.setExtent(extent[0], extent[1]);
+				lastEmittedMin = extent[0];
+				lastEmittedMax = extent[1];
+				emitFilterClause(extent[0], extent[1]);
+			} else if (!extent && brush.active) {
+				// Selection was cleared externally (e.g. detail chart reset) — clear brush
+				clearBrush();
+			}
+		});
 	});
 
 	// Derived screen coordinates — read chart.xScale/yScale directly so the
@@ -223,16 +234,25 @@
 
 	// --- Pointer Event Handlers (registered as chart context callbacks) ---
 
-	function handlePointerDown(event: PointerEvent, innerPoint: Point) {
+	/** A press: move or resize on the brush's handles, else draw; decline in pan mode. */
+	function handlePointerDown(target: Element, pointerId: number, innerPoint: Point) {
 		if (brush.phase !== 'idle') return false;
 		if (isPanModeActive) return false;
 
-		(event.target as Element).setPointerCapture(event.pointerId);
+		target.setPointerCapture(pointerId);
 		isCapturing = true;
 		hasDragged = false;
 
 		anchor = innerCoord(innerPoint);
 		current = anchor;
+
+		const hit = brushHandleAt(target);
+		if (hit?.handle === 'move') {
+			brush.phase = 'moving';
+		} else if (hit) {
+			brush.phase = 'resizing';
+			brush.resizeEdge = hit.handle === edgeStart ? 'start' : 'end';
+		}
 		return true;
 	}
 
@@ -280,44 +300,30 @@
 		(event.target as Element).releasePointerCapture(event.pointerId);
 		isCapturing = false;
 
+		// A press that never moved is a click, which clears the brush.
 		if (!hasDragged && brush.active && (brush.phase === 'idle' || brush.phase === 'moving')) {
 			clearBrush();
 			return true;
 		}
 
+		endDrag();
+		return true;
+	}
+
+	/** Keep what the drag did and go idle. */
+	function endDrag() {
 		if (brush.phase !== 'idle') {
 			emitUpdate();
 			brush.phase = 'idle';
 		}
-
 		hasDragged = false;
-		return true;
 	}
 
-	function handleMoveStart(event: PointerEvent) {
-		event.stopPropagation();
-		(event.target as Element).setPointerCapture(event.pointerId);
-		isCapturing = true;
-		hasDragged = false;
-
-		point.x = event.offsetX;
-		point.y = event.offsetY;
-		const innerCoords = chart.toInnerCoordinates(point);
-		anchor = innerCoord(innerCoords);
-		brush.phase = 'moving';
-	}
-
-	function handleResizeStart(edge: string, event: PointerEvent) {
-		event.stopPropagation();
-		(event.target as Element).setPointerCapture(event.pointerId);
-		isCapturing = true;
-
-		point.x = event.offsetX;
-		point.y = event.offsetY;
-		const innerCoords = chart.toInnerCoordinates(point);
-		anchor = innerCoord(innerCoords);
-		brush.phase = 'resizing';
-		brush.resizeEdge = edge === edgeStart ? 'start' : 'end';
+	/** The chart re-routes the press: end the drag as it stands, never as a click. */
+	function handleDragEnd() {
+		if (!isCapturing) return;
+		isCapturing = false;
+		endDrag();
 	}
 
 	// Register pointer callbacks; the keys are on <svelte:window> below.
@@ -325,19 +331,21 @@
 		chart.onInteractorPointerDown = handlePointerDown;
 		chart.onInteractorPointerMove = handlePointerMove;
 		chart.onInteractorPointerUp = handlePointerUp;
+		chart.onInteractorDragEnd = handleDragEnd;
 		chart.activators.add(brushHandle.activate);
 
 		return () => {
 			chart.onInteractorPointerDown = null;
 			chart.onInteractorPointerMove = null;
 			chart.onInteractorPointerUp = null;
+			chart.onInteractorDragEnd = null;
 			chart.activators.delete(brushHandle.activate);
 			brushHandle.destroy();
 		};
 	});
 </script>
 
-<svelte:window onkeydown={handleKeyDown} onkeyup={handleKeyUp} />
+<svelte:window onkeydown={handleKeyDown} onkeyup={handleKeyUp} onblur={handleBlur} />
 
 {#if brush.active && brushScreen}
 	<BrushOverlay
@@ -346,8 +354,6 @@
 		width={isX ? brushScreen.size : chart.innerWidth}
 		height={isX ? chart.innerHeight : brushScreen.size}
 		orientation={axis}
-		onMoveStart={handleMoveStart}
-		onResizeStart={handleResizeStart}
 		onWheel={handleWheel}
 	/>
 {/if}

package/dist/interactors/Interval2D.svelte

@@ -8,6 +8,8 @@
 		closeTo,
 		isDragging,
 		scaleBrushExtent2D,
+		createPanModeHandlers,
+		brushHandleAt,
 		WHEEL_SENSITIVITY
 	} from './brush-utils';
 	import type { ChartContext, FieldRef, Point } from '../types';
@@ -104,6 +106,15 @@
 	let currentY = 0;
 	let isCapturing = false;
 	let hasDragged = false;
+	let isPanModeActive = false;
+
+	// Space held: presses pan the chart instead of brushing
+	const { handleKeyDown, handleKeyUp, handleBlur } = createPanModeHandlers(
+		(active) => {
+			isPanModeActive = active;
+		},
+		() => chart.reroutePress()
+	);
 
 	// Reusable point object to reduce GC pressure
 	const point = { x: 0, y: 0 };
@@ -218,10 +229,12 @@
 
 	// --- Pointer Event Handlers (registered as chart context callbacks) ---
 
-	function handlePointerDown(event: PointerEvent, innerPoint: Point) {
+	/** A press: move or resize on the brush's handles, else draw; decline in pan mode. */
+	function handlePointerDown(target: Element, pointerId: number, innerPoint: Point) {
 		if (brush.phase !== 'idle') return false;
+		if (isPanModeActive) return false;
 
-		(event.target as Element).setPointerCapture(event.pointerId);
+		target.setPointerCapture(pointerId);
 		isCapturing = true;
 		hasDragged = false;
 
@@ -229,6 +242,23 @@
 		anchorY = innerPoint.y;
 		currentX = innerPoint.x;
 		currentY = innerPoint.y;
+
+		const hit = brushHandleAt(target);
+		if (hit?.handle === 'move') {
+			brush.phase = 'moving';
+		} else if (hit) {
+			brush.phase = 'resizing';
+			const edge = hit.handle;
+			if (edge === 'nw' || edge === 'ne' || edge === 'sw' || edge === 'se') {
+				brush.resizeCorner = edge;
+				brush.x.resizeEdge = null;
+				brush.y.resizeEdge = null;
+			} else {
+				brush.resizeCorner = null;
+				brush.x.resizeEdge = edge === 'left' || edge === 'right' ? edge : null;
+				brush.y.resizeEdge = edge === 'top' || edge === 'bottom' ? edge : null;
+			}
+		}
 		return true;
 	}
 
@@ -302,11 +332,18 @@
 		(event.target as Element).releasePointerCapture(event.pointerId);
 		isCapturing = false;
 
+		// A press that never moved is a click, which clears the brush.
 		if (!hasDragged && brush.active && (brush.phase === 'idle' || brush.phase === 'moving')) {
 			clearBrush();
 			return true;
 		}
 
+		endDrag();
+		return true;
+	}
+
+	/** Keep what the drag did and go idle. */
+	function endDrag() {
 		if (brush.phase !== 'idle') {
 			emitClause();
 			brush.phase = 'idle';
@@ -314,58 +351,14 @@
 			brush.x.resizeEdge = null;
 			brush.y.resizeEdge = null;
 		}
-
 		hasDragged = false;
-		return true;
-	}
-
-	function handleMoveStart(event: PointerEvent) {
-		event.stopPropagation();
-		(event.target as Element).setPointerCapture(event.pointerId);
-		isCapturing = true;
-		hasDragged = false;
-
-		point.x = event.offsetX;
-		point.y = event.offsetY;
-		const innerCoords = chart.toInnerCoordinates(point);
-		anchorX = innerCoords.x;
-		anchorY = innerCoords.y;
-		currentX = innerCoords.x;
-		currentY = innerCoords.y;
-		brush.phase = 'moving';
 	}
 
-	function handleResizeStart(
-		edge: 'left' | 'right' | 'top' | 'bottom' | 'nw' | 'ne' | 'sw' | 'se',
-		event: PointerEvent
-	) {
-		event.stopPropagation();
-		(event.target as HTMLElement).setPointerCapture(event.pointerId);
-		isCapturing = true;
-
-		point.x = event.offsetX;
-		point.y = event.offsetY;
-		const innerCoords = chart.toInnerCoordinates(point);
-		anchorX = innerCoords.x;
-		anchorY = innerCoords.y;
-		currentX = innerCoords.x;
-		currentY = innerCoords.y;
-		brush.phase = 'resizing';
-
-		if (edge === 'nw' || edge === 'ne' || edge === 'sw' || edge === 'se') {
-			brush.resizeCorner = edge;
-			brush.x.resizeEdge = null;
-			brush.y.resizeEdge = null;
-		} else {
-			brush.resizeCorner = null;
-			if (edge === 'left' || edge === 'right') {
-				brush.x.resizeEdge = edge;
-				brush.y.resizeEdge = null;
-			} else {
-				brush.x.resizeEdge = null;
-				brush.y.resizeEdge = edge;
-			}
-		}
+	/** The chart re-routes the press: end the drag as it stands, never as a click. */
+	function handleDragEnd() {
+		if (!isCapturing) return;
+		isCapturing = false;
+		endDrag();
 	}
 
 	// Register callbacks
@@ -373,18 +366,22 @@
 		chart.onInteractorPointerDown = handlePointerDown;
 		chart.onInteractorPointerMove = handlePointerMove;
 		chart.onInteractorPointerUp = handlePointerUp;
+		chart.onInteractorDragEnd = handleDragEnd;
 		chart.activators.add(brushHandle.activate);
 
 		return () => {
 			chart.onInteractorPointerDown = null;
 			chart.onInteractorPointerMove = null;
 			chart.onInteractorPointerUp = null;
+			chart.onInteractorDragEnd = null;
 			chart.activators.delete(brushHandle.activate);
 			brushHandle.destroy();
 		};
 	});
 </script>
 
+<svelte:window onkeydown={handleKeyDown} onkeyup={handleKeyUp} onblur={handleBlur} />
+
 {#if brush.active && brushScreen}
 	<BrushOverlay
 		x={brushScreen.x}
@@ -392,8 +389,6 @@
 		width={brushScreen.width}
 		height={brushScreen.height}
 		orientation="2d"
-		onMoveStart={handleMoveStart}
-		onResizeStart={handleResizeStart}
 		onWheel={handleWheel}
 	/>
 {/if}

package/dist/interactors/ParallelBrushes.svelte

@@ -4,7 +4,7 @@
 	import { SvelteMap } from 'svelte/reactivity';
 	import BrushOverlay from './BrushOverlay.svelte';
 	import ParallelAxisSource, { type ParallelAxis } from './ParallelAxisSource.svelte';
-	import { closeTo, isDragging, createPanModeHandlers } from './brush-utils';
+	import { closeTo, isDragging, createPanModeHandlers, brushHandleAt } from './brush-utils';
 	import { LinearScaleState } from '../scales/LinearScaleState.svelte';
 	import type { ChartContext, Point } from '../types';
 	import type { FilterGroupRegistry } from '../query-engine/FilterGroupRegistry.svelte';
@@ -62,10 +62,13 @@
 	}
 
 	// Pan mode (Space key) — when active, pointer events fall through to ChartCell for pan
-	let isPanModeActive = $state(false);
-	const { handleKeyDown, handleKeyUp } = createPanModeHandlers((active) => {
-		isPanModeActive = active;
-	});
+	let isPanModeActive = false;
+	const { handleKeyDown, handleKeyUp, handleBlur } = createPanModeHandlers(
+		(active) => {
+			isPanModeActive = active;
+		},
+		() => chart.reroutePress()
+	);
 
 	// The axis the user is dragging on, by column
 	let activeAxis: string | null = null;
@@ -166,19 +169,35 @@
 
 	// --- Pointer handlers ---
 
-	function handlePointerDown(event: PointerEvent, innerPoint: Point) {
+	/**
+	 * A press: move or resize on an axis's brush handles (that axis, from the
+	 * overlay's owner), else draw on the nearest axis; decline in pan mode.
+	 */
+	function handlePointerDown(target: Element, pointerId: number, innerPoint: Point) {
 		if (!ps) return false;
 		if (isPanModeActive) return false; // Fall through to ChartCell for parallel axis pan
 
-		const col = nearestAxis(innerPoint.x);
+		const hit = brushHandleAt(target);
+		const col = hit?.owner ?? nearestAxis(innerPoint.x);
 		if (col == null || !axes.has(col)) return false;
+		// A drag that starts on a brush overlay hovers its axis, even without a
+		// pointer move over the axis first.
+		if (hit) hoverAxis(col);
 
-		(event.target as Element).setPointerCapture(event.pointerId);
+		target.setPointerCapture(pointerId);
 		activeAxis = col;
 		isCapturing = true;
 		hasDragged = false;
 		anchor = innerPoint.y;
 		current = anchor;
+
+		const brush = axes.get(col)!.brush;
+		if (hit?.handle === 'move') {
+			brush.phase = 'moving';
+		} else if (hit) {
+			brush.phase = 'resizing';
+			brush.resizeEdge = hit.handle === 'top' ? 'start' : 'end';
+		}
 		return true;
 	}
 
@@ -240,59 +259,39 @@
 		const col = activeAxis;
 		activeAxis = null;
 		const brush = axes.get(col)?.brush;
-		if (!brush) {
-			hasDragged = false;
-			return true;
-		}
 
-		if (!hasDragged && brush.active && (brush.phase === 'idle' || brush.phase === 'moving')) {
+		// A press that never moved is a click, which clears the brush.
+		if (
+			brush &&
+			!hasDragged &&
+			brush.active &&
+			(brush.phase === 'idle' || brush.phase === 'moving')
+		) {
 			clearBrush(col);
 			return true;
 		}
 
-		if (brush.phase !== 'idle') {
-			emitUpdate(col);
-			brush.phase = 'idle';
-		}
-
-		hasDragged = false;
+		endDrag(col);
 		return true;
 	}
 
-	function handleMoveStart(col: string, event: PointerEvent) {
+	/** Keep what the drag on an axis did and go idle. */
+	function endDrag(col: string) {
 		const brush = axes.get(col)?.brush;
-		if (!brush) return;
-		event.stopPropagation();
-		// A drag that starts on a brush overlay hovers its axis, even without a
-		// pointer move over the axis first.
-		hoverAxis(col);
-		(event.target as Element).setPointerCapture(event.pointerId);
-		activeAxis = col;
-		isCapturing = true;
+		if (brush && brush.phase !== 'idle') {
+			emitUpdate(col);
+			brush.phase = 'idle';
+		}
 		hasDragged = false;
-
-		point.x = event.offsetX;
-		point.y = event.offsetY;
-		const innerCoords = chart.toInnerCoordinates(point);
-		anchor = innerCoords.y;
-		brush.phase = 'moving';
 	}
 
-	function handleResizeStart(col: string, edge: string, event: PointerEvent) {
-		const brush = axes.get(col)?.brush;
-		if (!brush) return;
-		event.stopPropagation();
-		hoverAxis(col);
-		(event.target as Element).setPointerCapture(event.pointerId);
-		activeAxis = col;
-		isCapturing = true;
-
-		point.x = event.offsetX;
-		point.y = event.offsetY;
-		const innerCoords = chart.toInnerCoordinates(point);
-		anchor = innerCoords.y;
-		brush.phase = 'resizing';
-		brush.resizeEdge = edge === 'top' ? 'start' : 'end';
+	/** The chart re-routes the press: end the drag as it stands, never as a click. */
+	function handleDragEnd() {
+		if (!isCapturing || activeAxis == null) return;
+		isCapturing = false;
+		const col = activeAxis;
+		activeAxis = null;
+		endDrag(col);
 	}
 
 	// Brush screen extents, one per active brush, at its axis's x-position —
@@ -324,18 +323,20 @@
 		chart.onInteractorPointerDown = handlePointerDown;
 		chart.onInteractorPointerMove = handlePointerMove;
 		chart.onInteractorPointerUp = handlePointerUp;
+		chart.onInteractorDragEnd = handleDragEnd;
 		chart.activators.add(activateHoveredAxis);
 
 		return () => {
 			chart.onInteractorPointerDown = null;
 			chart.onInteractorPointerMove = null;
 			chart.onInteractorPointerUp = null;
+			chart.onInteractorDragEnd = null;
 			chart.activators.delete(activateHoveredAxis);
 		};
 	});
 </script>
 
-<svelte:window onkeydown={handleKeyDown} onkeyup={handleKeyUp} />
+<svelte:window onkeydown={handleKeyDown} onkeyup={handleKeyUp} onblur={handleBlur} />
 
 {#if ps}
 	{#each ps.columns as col (col)}
@@ -356,8 +357,7 @@
 			width={brushHalfWidth * 2}
 			height={screen.size}
 			orientation="y"
-			onMoveStart={(e) => handleMoveStart(screen.col, e)}
-			onResizeStart={(edge, e) => handleResizeStart(screen.col, edge, e)}
+			owner={screen.col}
 			onWheel={() => {}}
 		/>
 	{/each}

package/dist/interactors/brush-utils.d.ts

@@ -4,10 +4,30 @@ export declare const EPS_ABSOLUTE = 1e-12;
 export declare const DRAG_THRESHOLD = 3;
 export declare const WHEEL_SENSITIVITY = 0.001;
 export declare function closeTo(a: number | null | undefined, b: number | null | undefined): boolean;
-export declare function createPanModeHandlers(setActive: (active: boolean) => void): {
+/**
+ * Space-held pan mode for brushes, wired to <svelte:window> keydown, keyup and
+ * blur. Each change calls `reroutePress` (the chart's), so a press already
+ * under way switches between panning and brushing where the pointer is now:
+ * with three-finger drag on a trackpad, one press can last seconds after the
+ * fingers lift. Key repeats while Space is held change nothing. Blur ends pan
+ * mode: a Space released while the window is unfocused sends no keyup.
+ */
+export declare function createPanModeHandlers(setActive: (active: boolean) => void, reroutePress: () => void): {
     handleKeyDown: (event: KeyboardEvent) => void;
     handleKeyUp: (event: KeyboardEvent) => void;
+    handleBlur: () => void;
 };
+/** The parts of a brush overlay a press can land on, from its `data-brush-handle`. */
+export type BrushHandle = 'move' | 'left' | 'right' | 'top' | 'bottom' | 'nw' | 'ne' | 'sw' | 'se';
+/**
+ * The brush handle under a press, read from the overlay's DOM: its element's
+ * `data-brush-handle`, and the `data-brush-owner` of its overlay (a parallel
+ * axis's column), or null when the press is not on a brush.
+ */
+export declare function brushHandleAt(target: Element | null): {
+    handle: BrushHandle;
+    owner: string | null;
+} | null;
 export declare function scaleBrushExtent1D(min: number, max: number, scaleFactor: number): [number, number];
 export declare function scaleBrushExtent2D(xMin: number, xMax: number, yMin: number, yMax: number, scaleFactor: number): {
     x: [number, number];

package/dist/interactors/brush-utils.js

@@ -15,18 +15,46 @@ export function closeTo(a, b) {
     }
     return diff < EPS_ABSOLUTE;
 }
-export function createPanModeHandlers(setActive) {
+/**
+ * Space-held pan mode for brushes, wired to <svelte:window> keydown, keyup and
+ * blur. Each change calls `reroutePress` (the chart's), so a press already
+ * under way switches between panning and brushing where the pointer is now:
+ * with three-finger drag on a trackpad, one press can last seconds after the
+ * fingers lift. Key repeats while Space is held change nothing. Blur ends pan
+ * mode: a Space released while the window is unfocused sends no keyup.
+ */
+export function createPanModeHandlers(setActive, reroutePress) {
+    let active = false;
+    const set = (next) => {
+        if (next === active)
+            return;
+        active = next;
+        setActive(next);
+        reroutePress();
+    };
     const handleKeyDown = (event) => {
-        if (event.code === 'Space') {
-            setActive(true);
-        }
+        if (event.code === 'Space')
+            set(true);
     };
     const handleKeyUp = (event) => {
-        if (event.code === 'Space') {
-            setActive(false);
-        }
+        if (event.code === 'Space')
+            set(false);
+    };
+    return { handleKeyDown, handleKeyUp, handleBlur: () => set(false) };
+}
+/**
+ * The brush handle under a press, read from the overlay's DOM: its element's
+ * `data-brush-handle`, and the `data-brush-owner` of its overlay (a parallel
+ * axis's column), or null when the press is not on a brush.
+ */
+export function brushHandleAt(target) {
+    const el = target?.closest?.('[data-brush-handle]');
+    if (!el)
+        return null;
+    return {
+        handle: el.getAttribute('data-brush-handle'),
+        owner: el.closest('[data-brush-owner]')?.getAttribute('data-brush-owner') ?? null
     };
-    return { handleKeyDown, handleKeyUp };
 }
 export function scaleBrushExtent1D(min, max, scaleFactor) {
     const center = (min + max) / 2;

package/dist/query-engine/index.d.ts

@@ -5,13 +5,23 @@
  *   import { setQueryContext } from './';
  *   setQueryContext(wasm.getConnection());  // Promise OK — resolves lazily
  *
- * Usage in spec renderer:
- *   context.set('query-engine', new QueryEngine(connection));
- *   context.set('filter-groups', new FilterGroupRegistry());
+ * Usage outside a component (the spec renderer), passing contexts to mount():
+ *   const { filterGroups } = createQueryServices(queryEngine);
+ *   context.set('query-engine', queryEngine);
+ *   context.set('filter-groups', filterGroups);
  */
 import { QueryEngine } from './QueryEngine';
 import type { DuckDBConnection } from './QueryEngine';
 import { FilterGroupRegistry } from './FilterGroupRegistry.svelte';
+/**
+ * Create the FilterGroupRegistry for an engine and wire both to the schema
+ * service. Brushes and toggles reach the engine only through this wiring:
+ * a FilterGroup without an engine updates its selection but never re-queries.
+ */
+export declare function createQueryServices(queryEngine: QueryEngine): {
+    queryEngine: QueryEngine;
+    filterGroups: FilterGroupRegistry;
+};
 /**
  * Create QueryEngine + FilterGroupRegistry and set Svelte contexts.
  * Call this synchronously in a component's <script> block.