react-semaphor 0.1.507 → 0.1.509

package/dist/types/lib/hooks/interactions/{use-event-engine.d.ts → use-drill-actions.d.ts}

@@ -1,6 +1,7 @@
+import { DrillStep } from '../../dashboard-view-state/index.js';
 import { ClickContextResult } from '../../interactions/get-click-context-from-chartjs.js';
 import { TCard } from '../../types/index.js';
-import { ClickFilterEvent, Interaction } from '../../types/interaction-types.js';
+import { Interaction, ClickFilterCondition, DrillDownInteraction, DrillToURLInteraction } from '../../types/interaction-types.js';
 /**
  * Find matching V2 interaction based on click context
  *
@@ -34,21 +35,41 @@ export declare function findAllMatchingV2Interactions(interactions: Interaction[
  */
 export declare function findMatchingV2Interaction(interactions: Interaction[], context: ClickContextResult, identity?: InteractionTriggerIdentity): Interaction | null;
 /**
- * Compares two ClickFilterEvents for logical equivalence,
- * ignoring the order of filter groups and filters within them.
+ * Next step of a card's drill hierarchy, or undefined when the hierarchy is
+ * missing or exhausted. Date hierarchies resolve from the chart's current
+ * granularity; static hierarchies from the drill depth.
  */
-export declare function isSameClickFilterEvent(a: ClickFilterEvent, b: ClickFilterEvent): boolean;
+export declare function resolveDrillDownStep(card: TCard, interaction: DrillDownInteraction, breadcrumbs: readonly Pick<DrillStep, 'granularity'>[]): {
+    hierarchy: import('../../types/interaction-types.js').DrillHierarchy;
+    nextStep: import('../../types/interaction-types.js').DrillHierarchyStep;
+} | undefined;
 /**
- * Hook to manage chart interactions as part of the Event Engine
+ * Opens a drill-to-URL target. Must run synchronously inside the click handler
+ * so popup blockers allow it. Returns false when the interpolated URL is invalid.
+ */
+export declare function openDrillToUrl(interaction: DrillToURLInteraction, params: {
+    conditions: ClickFilterCondition[];
+    cardId: string;
+    frameId: string;
+    sheetId: string;
+}): boolean;
+/**
+ * Drill interactions a click matches. Click to filter is not an interaction any
+ * more: it is a card setting whose clicks become a selection input, so a legacy
+ * `clickFilter` entry never executes here.
+ */
+export declare function findMatchingDrillInteractions(interactions: Interaction[], context: ClickContextResult, identity?: InteractionTriggerIdentity): Interaction[];
+/**
+ * Hook to run a card's drill interactions
  *
  * @param card - The card configuration
  * @param onMultipleInteractions - Optional callback when multiple interactions match a click
  */
-export declare function useEventEngine(card: TCard, frameId: string, sheetId: string, onMultipleInteractions?: (matches: Interaction[], context: ClickContextResult, position?: {
+export declare function useDrillActions(card: TCard, frameId: string, sheetId: string, onMultipleInteractions?: (matches: Interaction[], context: ClickContextResult, position?: {
     x: number;
     y: number;
 }) => void): {
-    handlePointerInteraction: ({ context, gesture, position, modifierKeys, }: {
+    handlePointerInteraction: ({ context, gesture, position, }: {
         context: ClickContextResult;
         gesture: "leftClick" | "rightClick" | "longPress" | "hover";
         modifierKeys?: {

package/dist/types/lib/hooks/selection/use-active-selections.d.ts

@@ -0,0 +1,15 @@
+/** Every selection in effect, with how many cards each narrows. For the filter bar. */
+export declare function useActiveSelections(): (import('../../dashboard-inputs/build-selection-dashboard-inputs.js').ActiveSelection & {
+    targetCount: number;
+})[];
+/** What each active selection does on one card. For that card's filter badge. */
+export declare function useSelectionsOnCard(cardId: string | undefined): {
+    resolution: import('../../dashboard-inputs/resolve-selection-input.js').ResolvedCardSelection;
+    input: import('../../types/index.js').SelectionDashboardInput;
+    value: import('../../../shared/analytics-protocol/selection-contract.js').SelectionInputValue;
+    sourceCard: import('../../types/index.js').TCard;
+}[];
+/** How many source cards currently narrow this card. */
+export declare function useCardSelectionFilterCount(cardId: string | undefined): number;
+/** Clears every selection slot, including one whose source card is gone. */
+export declare function clearAllSelections(): void;

package/dist/types/lib/hooks/selection/use-click-to-filter-mapping-draft.d.ts

@@ -0,0 +1,20 @@
+import { NormalizedFilterDashboardInput, TCard } from '../../types/common-types.js';
+import { ClickToFilterSettings } from '../../../shared/dashboard-authoring/index.js';
+import { ClickToFilterDimension } from '../../dashboard-inputs/click-to-filter-emitted-fields.js';
+/**
+ * The review rows for one source card's draft settings. Field metadata and
+ * labels come from the same loader the toolbar filter's Cards tab uses, and
+ * are requested only while the behavior is on and the surface is open.
+ */
+export declare function useClickToFilterMappingDraft(params: {
+    sourceCard: Pick<TCard, 'id'> | null | undefined;
+    settings: ClickToFilterSettings;
+    dimensions: ClickToFilterDimension[];
+    enabled: boolean;
+}): {
+    draft: import('../../dashboard-inputs/click-to-filter-mapping-draft.js').ClickToFilterMappingDraft | undefined;
+    fieldLabels: import('../../dashboard-inputs/dashboard-filter-mapping-candidate-metadata.js').DashboardFilterMappingFieldLabels;
+    filterInputs: NormalizedFilterDashboardInput[];
+    isLoading: boolean;
+    retry: () => void;
+};

package/dist/types/lib/hooks/selection/use-selection-click.d.ts

@@ -0,0 +1,34 @@
+import { ClickContextResult } from '../../interactions/get-click-context-from-chartjs.js';
+import { TCard } from '../../types/common-types.js';
+import { Interaction } from '../../types/interaction-types.js';
+type PointerInteraction = (params: {
+    context: ClickContextResult;
+    gesture: 'leftClick';
+    modifierKeys?: {
+        shift: boolean;
+        ctrl: boolean;
+        meta: boolean;
+    };
+    position?: {
+        x: number;
+        y: number;
+    };
+}) => void;
+/**
+ * One left click on a mark or cell of a visual without row ranges: it selects
+ * for click to filter, runs the card's drill, or, when it does both, opens the
+ * menu with "Filter" beside the drills. Cmd, Ctrl and Shift toggle.
+ */
+export declare function useSelectionClick(card: TCard, params: {
+    handlePointerInteraction: PointerInteraction;
+    onMultipleInteractions?: (matches: Interaction[], context: ClickContextResult, position?: {
+        x: number;
+        y: number;
+    }) => void;
+}): {
+    isEnabled: boolean;
+    handleClick: (event: Pick<React.MouseEvent, "shiftKey" | "metaKey" | "ctrlKey" | "clientX" | "clientY">, context: ClickContextResult, options?: {
+        canDrill: boolean;
+    }) => void;
+};
+export {};

package/dist/types/lib/hooks/selection/use-selection-gestures.d.ts

@@ -0,0 +1,38 @@
+import { SelectionTuple } from '../../../shared/analytics-protocol/selection-contract.js';
+import { SelectionGesture, SelectionReduceResult } from '../../selection/selection-reducer.js';
+import { SelectionTupleResult } from '../../selection/selection-from-click-context.js';
+import { ClickToFilterFieldsRule, ClickToFilterSettings, TCard } from '../../types/common-types.js';
+import { Field } from '../../types/explorer-types.js';
+import { ClickFilterCondition, Interaction } from '../../types/interaction-types.js';
+/**
+ * The "Filter" entry offered beside a card's drills when one click matches
+ * both. Compared by identity; it is never persisted and never executed by the
+ * drill engine.
+ */
+export declare const SELECTION_MENU_INTERACTION: Interaction;
+export type SelectionGestures = {
+    /** Normalized `settings.enabled`. */
+    isEnabled: boolean;
+    settings: ClickToFilterSettings;
+    /** From the card's selection slot. */
+    selection: SelectionTuple[];
+    select: (tuple: SelectionTuple, gesture: SelectionGesture) => SelectionReduceResult;
+    /** Checkbox column: the checked set replaces the selection. */
+    selectMany: (tuples: SelectionTuple[]) => void;
+    clear: () => void;
+    /** Turns a capture builder's conditions into a tuple under this card's fields rule. */
+    tupleFromClick: (conditions: ClickFilterCondition[], clickedField?: Field, 
+    /** Overrides the card's fields rule, for callers that need one specific cell or the whole row. */
+    rule?: ClickToFilterFieldsRule) => SelectionTupleResult;
+    /** Last tuple selected by replace or toggle, read at call time; the start of a Shift range. */
+    getAnchor: () => SelectionTuple | undefined;
+    /** Target cards the current selection narrows. Zero without a selection. */
+    targetCount: number;
+};
+/**
+ * Writes a source card's selection slot. Callable outside React so a store
+ * action or an imperative grid callback shares the one write path.
+ */
+export declare function writeSelection(sourceCardId: string, tuples: SelectionTuple[]): void;
+/** The one place a card reads and changes its own selection. */
+export declare function useSelectionGestures(card: TCard): SelectionGestures;

package/dist/types/lib/hooks/selection/use-table-row-selection.d.ts

@@ -0,0 +1,46 @@
+import { Row, Table } from '@tanstack/react-table';
+import { SelectionTupleResult } from '../../selection/selection-from-click-context.js';
+import { Field } from '../../types/explorer-types.js';
+import { ClickFilterCondition } from '../../types/interaction-types.js';
+import { SelectionGestures } from './use-selection-gestures.js';
+/** Checkboxes are the touch affordance: always, never, or on coarse pointers only. */
+export declare function areSelectionCheckboxesShown(gestures: Pick<SelectionGestures, 'isEnabled' | 'settings'>): boolean;
+export type TableRowClickOutcome = 
+/** Click to filter is off, or the table is not interactive. */
+{
+    status: 'ignored';
+} | {
+    status: 'selected';
+}
+/** The click cannot become a selection. */
+ | {
+    status: 'unavailable';
+    result: Extract<SelectionTupleResult, {
+        status: 'unavailable';
+    }>;
+} | {
+    status: 'limitReached';
+};
+/**
+ * Click to filter for a row-based table. The selection slot is the record:
+ * row highlight and checkbox state are derived from it, and a checkbox change
+ * is applied to it as a difference, so rows selected on another page survive.
+ */
+export declare function useTableRowSelection<TData>(params: {
+    /** The card's one gestures instance, shared with the rest of the table. */
+    gestures: SelectionGestures;
+    table: Table<TData>;
+    /** Visible rows in display order, after sort and filter. */
+    rows: Row<TData>[];
+    isInteractive: boolean;
+    /** Dimension conditions of a row, from the table's capture builder. */
+    conditionsForRow: (row: Row<TData>) => ClickFilterCondition[] | undefined;
+    /** The dimension field a column shows, if any. */
+    fieldForColumnId: (columnId: string) => Field | undefined;
+}): {
+    isEnabled: boolean;
+    checkboxesShown: boolean;
+    hasSelection: boolean;
+    handleRowClick: (event: Pick<React.MouseEvent, "shiftKey" | "metaKey" | "ctrlKey" | "nativeEvent">, row: Row<TData>, columnId: string | undefined) => TableRowClickOutcome;
+    clear: () => void;
+};

package/dist/types/lib/hooks/use-dashboard-card.d.ts

@@ -11,7 +11,6 @@ export declare function useCard(cardId: string): {
     visualKey: number;
     handleDatapointClick: (chart: Chart, datasetIndex: number, clickIndex: number, value: number) => void;
     cfg: any;
-    isRetainingSourceResult: boolean;
     queryKey: string[];
     queryRequestPayload: Record<string, unknown> | undefined;
     pagination: import('../types/index.js').PaginationMetadata | undefined;
@@ -30,7 +29,6 @@ export declare function useDashboardCard(card: TCard): {
     visualKey: number;
     handleDatapointClick: (chart: Chart, datasetIndex: number, clickIndex: number, value: number) => void;
     cfg: any;
-    isRetainingSourceResult: boolean;
     queryKey: string[];
     queryRequestPayload: Record<string, unknown> | undefined;
     pagination: import('../types/index.js').PaginationMetadata | undefined;

package/dist/types/lib/hooks/use-dashboard-filter-mapping-candidates.d.ts

@@ -1,6 +1,24 @@
 import { TFilter } from '../../components/surfboard/filter/types.js';
 import { DashboardInputScope } from '../types/common-types.js';
 import { DashboardFilterOptionSource } from '../../shared/dashboard-authoring/index.js';
+/**
+ * Live column metadata, candidate targets and field labels for every card in
+ * a scope. Independent of what is being mapped, so a toolbar filter's Cards
+ * tab and the click-to-filter review dialog load and label fields identically.
+ */
+export declare function useDashboardMappingCandidateCatalogs(params: {
+    enabled: boolean;
+    outerScope: Extract<DashboardInputScope, {
+        kind: 'allSheets' | 'sheets';
+    }>;
+    /** Click-to-filter can target document cards; toolbar mappings cannot. */
+    includeDocumentSections?: boolean;
+}): {
+    candidatesByCardId: Record<string, import('../dashboard-inputs/index.js').DashboardFilterMappingCandidateCatalog | undefined>;
+    fieldLabels: import('../dashboard-inputs/dashboard-filter-mapping-candidate-metadata.js').DashboardFilterMappingFieldLabels;
+    isLoading: boolean;
+    retry: () => void;
+};
 export declare function useDashboardFilterMappingCandidates(params: {
     filter: TFilter;
     enabled: boolean;

package/dist/types/lib/hooks/use-dashboard-frame-query.d.ts

@@ -25,7 +25,6 @@ type AdditionalState = {
     effectiveCardConfig?: CardConfig;
     resultOwner: TemporalResultOwner;
     isCurrentQueryResult: boolean;
-    isRetainingSourceResult: boolean;
 };
 export type DashboardCardQueryResult = UseQueryResult<any, Error> & AdditionalState;
 export type DashboardCardQueryOptions = {

package/dist/types/lib/hooks/use-dashboard.d.ts

@@ -1,7 +1,6 @@
 import { AuthToken, ControlBinding, ControlDefinition, CustomCard, DashboardLifecycleEvent, DashboardInputExecutionSnapshot, TDashboard, TEvent, TStyle } from '../types/common-types.js';
 import { PresentationExecutionSnapshot } from '../../shared/format-utils/index.js';
 import { TFilterValue } from '../../components/index.js';
-import { InteractionState } from '../types/interaction-types.js';
 type UseDashboardProps = {
     id?: string;
     version?: string;
@@ -17,7 +16,6 @@ type UseDashboardProps = {
         controlBindings?: ControlBinding[];
     };
     dashboardInputExecutionSnapshot?: DashboardInputExecutionSnapshot;
-    interactionExecutionSnapshot?: Record<string, InteractionState>;
     presentationExecutionSnapshot?: PresentationExecutionSnapshot;
     customStyle?: TStyle;
     currentTheme?: 'light' | 'dark' | 'system';
@@ -30,7 +28,7 @@ type UseDashboardProps = {
     type?: 'dashboard' | 'visual';
     cardId?: string;
 };
-export declare function useDashboard({ customStyle, currentTheme, onSave, onEvent, onDashboardLifecycleEvent, defaultFilterValues, defaultControlValues, controlContractOverrides, dashboardInputExecutionSnapshot, interactionExecutionSnapshot, presentationExecutionSnapshot, type, cardId, selectedSheetId, onFilterValuesChange, }: UseDashboardProps): {
+export declare function useDashboard({ customStyle, currentTheme, onSave, onEvent, onDashboardLifecycleEvent, defaultFilterValues, defaultControlValues, controlContractOverrides, dashboardInputExecutionSnapshot, presentationExecutionSnapshot, type, cardId, selectedSheetId, onFilterValuesChange, }: UseDashboardProps): {
     isFetching: boolean;
     isLoading: boolean;
     isError: boolean;

package/dist/types/lib/hooks/use-interactions-popover.d.ts

@@ -2,13 +2,6 @@ export declare function useInteractionsPopover(): {
     open: boolean;
     frameId: string | null;
     cardId: string | null;
-    triggerElement: HTMLElement | null;
-    anchorPosition: {
-        left: number;
-        top: number;
-        width: number;
-        height: number;
-    } | null;
-    openPopover: (frameId: string, cardId: string, triggerElement: HTMLElement) => void;
+    openPopover: (frameId: string, cardId: string) => void;
     closePopover: () => void;
 };

package/dist/types/lib/hooks/use-resolved-card-config.d.ts

@@ -0,0 +1,6 @@
+import { CardConfig, FilterGroup } from '../types/explorer-types.js';
+import { TCard } from '../types/common-types.js';
+/** The card's authored filters narrowed by its drill path. Selections reach a query through its card query context. */
+export declare function useResolvedFilters(card: TCard): FilterGroup | undefined;
+export declare function useResolvedCardConfig(card: TCard): CardConfig;
+export declare function useFinalFilterGroupKey(card: TCard): string | undefined;

package/dist/types/lib/interactions/click-outcome.d.ts

@@ -0,0 +1,25 @@
+import { Interaction } from '../types/interaction-types.js';
+/**
+ * What a viewer gets from one click on a card, given what the author set up.
+ * Mirrors the runtime rule in `use-drill-actions.ts` and `use-selection-click.ts`:
+ * one thing to do runs directly, several open a menu with "Filter" beside the
+ * drills. It assumes a click that every action's trigger matches, so a card
+ * whose actions sit on different fields can show a longer menu here than any
+ * single click opens.
+ */
+export type ClickOutcome = {
+    kind: 'nothing';
+} | {
+    kind: 'filter';
+} | {
+    kind: 'direct';
+    interaction: Interaction;
+} | {
+    kind: 'menu';
+    filter: boolean;
+    interactions: Interaction[];
+};
+export declare function resolveClickOutcome({ filterEnabled, interactions, }: {
+    filterEnabled: boolean;
+    interactions: readonly Interaction[];
+}): ClickOutcome;

package/dist/types/lib/interactions/get-click-context-from-chartjs.d.ts

@@ -1,5 +1,5 @@
 import { TCard } from '../types/index.js';
-import { CardConfig } from '../../components/index.js';
+import { CardConfig, Field } from '../../components/index.js';
 import { QueryColumnKeyMap } from '../types/explorer-types.js';
 import { ClickedMetricValue, ClickFilterCondition } from '../types/interaction-types.js';
 import { Chart } from 'chart.js';
@@ -8,6 +8,8 @@ import { ResolvedTemporalValueFormatPreferences } from '../../shared/value-forma
 export interface ClickContextResult {
     conditions: ClickFilterCondition[];
     metrics?: ClickedMetricValue[];
+    /** The dimension column under the pointer, when the visual has cells. */
+    clickedField?: Field;
 }
 export declare function getClickContextFromChartJs({ resolvedCardConfig, card, records, chart, clickEvent, columnKeyMap, resultColumns, valueFormatPreferences, }: {
     resolvedCardConfig: CardConfig;

package/dist/types/lib/interactions/get-click-context-from-matrix.d.ts

@@ -1,7 +1,7 @@
 import { MatrixField, MatrixPath, MatrixSpec, MatrixWindow } from '../../shared/analytics-protocol/index.js';
 import { Field } from '../types/explorer-types.js';
 import { ClickContextResult } from './get-click-context-from-chartjs.js';
-import { InteractionTriggerIdentity } from '../hooks/interactions/use-event-engine.js';
+import { InteractionTriggerIdentity } from '../hooks/interactions/use-drill-actions.js';
 export type MatrixInteractionEligibility = {
     enabled: true;
 } | {

package/dist/types/lib/interactions/get-click-context-from-table.d.ts

@@ -33,3 +33,10 @@ export interface TableClickContextParams {
  * @returns Click context with dimension conditions and metric values, or undefined if no valid context
  */
 export declare function getClickContextFromTable({ resolvedCardConfig, card, row, columnKeyMap, temporalPresentation, }: TableClickContextParams): ClickContextResult | undefined;
+/**
+ * The dimension field a table column shows, resolved through the same column
+ * key binding the row capture uses. Undefined for metric and utility columns.
+ */
+export declare function getTableDimensionFieldForColumn({ resolvedCardConfig, card, columnId, columnKeyMap, }: Pick<TableClickContextParams, 'resolvedCardConfig' | 'card' | 'columnKeyMap'> & {
+    columnId: string;
+}): import('../types/index.js').Field | undefined;

package/dist/types/lib/interactions/interaction-utils.d.ts

@@ -1,4 +1,4 @@
-import { CardInteractionConfig, Interaction } from '../types/interaction-types.js';
+import { CardInteractionConfig, Interaction, PersistedInteraction } from '../types/interaction-types.js';
 /**
  * Get all interactions from a config.
  *
@@ -14,3 +14,19 @@ export declare function getInteractions(config: CardInteractionConfig | undefine
  * @returns true if interaction has a trigger
  */
 export declare function hasTrigger(interaction: Interaction): boolean;
+type InteractionWithId = PersistedInteraction & {
+    id: string;
+};
+/** Interactions saved before ids existed get a stable, position-derived id. */
+export declare function ensureInteractionIds(interactions?: PersistedInteraction[]): InteractionWithId[];
+export declare function createInteractionWithStableId(): {
+    id: string;
+};
+/**
+ * Rewrites the card ids of legacy cross-filter entries when a card is copied
+ * or linked. Cards not yet re-saved still carry those entries, and the
+ * click-to-filter normalizer reads their targets, so the ids must follow the
+ * copy. Authored settings are remapped by `remapClickToFilterReferences`.
+ */
+export declare function remapClickFilterTargetsToInstance(interactions: PersistedInteraction[], sourceToInstanceCardIds: Map<string, string>): PersistedInteraction[];
+export {};

package/dist/types/lib/matrix-table/build-matrix-drill-to-detail.d.ts

@@ -0,0 +1,15 @@
+import { TCard } from '../types/index.js';
+import { ClickFilterCondition, ClickedMetricValue, DrillToDetailEvent } from '../types/interaction-types.js';
+import { InteractionTriggerIdentity } from '../hooks/interactions/use-drill-actions.js';
+export type MatrixDrillClickContext = {
+    cardId: string;
+    conditions: ClickFilterCondition[];
+    metric?: ClickedMetricValue;
+};
+/** Resolve the authored drill-to-insight action for one Matrix click. */
+export declare function buildMatrixDrillToDetail({ card, context, triggerIdentity, }: {
+    card: TCard;
+    context: MatrixDrillClickContext;
+    /** Authored instances select actions; grounded condition fields remain unchanged. */
+    triggerIdentity?: InteractionTriggerIdentity;
+}): DrillToDetailEvent | undefined;

package/dist/types/lib/matrix-table/matrix-card-interactions.d.ts

@@ -1,5 +1,16 @@
 import { MatrixInteractionHost } from '../../components/visual/matrix-table/matrix-interaction-actions.js';
+import { SelectionGestures } from '../hooks/selection/use-selection-gestures.js';
+import { SelectionTupleResult } from '../selection/selection-from-click-context.js';
 import { TCard } from '../types/common-types.js';
-import { InteractionEvent } from '../types/interaction-types.js';
-/** Existing event pipeline remains the sole filter/drill dispatcher. */
-export declare function createMatrixCardInteractions(card: TCard, host: Pick<MatrixInteractionHost, 'resolveField' | 'capabilities'>, dispatch: (event: InteractionEvent) => void): MatrixInteractionHost;
+import { DrillToDetailEvent } from '../types/interaction-types.js';
+export type MatrixSelectionHost = {
+    gestures: Pick<SelectionGestures, 'isEnabled' | 'settings' | 'tupleFromClick' | 'select' | 'selection'>;
+    onUnavailable?: (result: Extract<SelectionTupleResult, {
+        status: 'unavailable';
+    }>) => void;
+};
+/**
+ * Drill-to-insight requests dispatch directly to the dashboard drill runtime.
+ * A context-menu filter and a direct click both write the card's selection slot.
+ */
+export declare function createMatrixCardInteractions(card: TCard, host: Pick<MatrixInteractionHost, 'resolveField' | 'capabilities'>, dispatch: (event: DrillToDetailEvent) => void, selection?: MatrixSelectionHost): MatrixInteractionHost;

package/dist/types/lib/matrix-table/matrix-runtime-types.d.ts

@@ -111,7 +111,4 @@ export declare const MATRIX_RUNTIME_LIMITS: Readonly<{
     checkpoints: 64;
     overrides: 2000;
     mountedCells: 5000;
-    clipboardCells: 10000;
-    clipboardBytes: number;
-    clipboardTimeoutMs: 30000;
 }>;

package/dist/types/lib/matrix-table/matrix-runtime.d.ts

@@ -28,8 +28,6 @@ export declare class MatrixRuntimeController {
     private view;
     private spec;
     private snapshot;
-    private copyDemand?;
-    private rejectCopy?;
     constructor(input: MatrixRuntimeInput, query: QueryClient, execute: MatrixWindowExecutor, session?: MatrixViewState);
     subscribe: (listener: () => void) => () => boolean;
     getSnapshot: () => MatrixRuntimeSnapshot;
@@ -53,8 +51,6 @@ export declare class MatrixRuntimeController {
     /** Used by explicit refresh/retry integrations; latest-issued response wins. */
     refetchCell: (coordinate: MatrixCoordinate) => void;
     refetchPage: (key: string) => void;
-    /** Clipboard demand shares page-owner tiles, the queue and retention policy. */
-    acquireCells: (coordinates: readonly MatrixCoordinate[], signal?: AbortSignal) => Promise<MatrixCellState[]>;
     private visible;
     private plan;
     private loadPage;

package/dist/types/lib/matrix-table/{use-matrix-selection.d.ts → use-matrix-cell-focus.d.ts}

@@ -1,18 +1,21 @@
 import { KeyboardEvent } from 'react';
-import { MatrixCoordinate, MatrixPresentation, MatrixSpec } from '../../shared/analytics-protocol/index.js';
+import { MatrixCoordinate, MatrixSpec } from '../../shared/analytics-protocol/index.js';
 import { MatrixRuntime } from './use-matrix.js';
-/** Selection is view-local; only explicit copy asks the runtime for missing cells. */
-export declare function useMatrixSelection(input: {
+/**
+ * One view-local active cell for grid navigation and editor field scoping.
+ * Dashboard selection remains owned by the selection input runtime.
+ */
+export declare function useMatrixCellFocus(input: {
     runtime: MatrixRuntime;
     spec: MatrixSpec;
-    absence: MatrixPresentation['absence'];
     reveal: (row: number, valueColumn: number) => void;
-    onSelectionChange?: (coordinate: MatrixCoordinate | undefined) => void;
+    onFocusChange?: (coordinate: MatrixCoordinate | undefined) => void;
+    onActivate?: (coordinate: MatrixCoordinate, event: KeyboardEvent<HTMLDivElement>) => void;
 }): {
     hasFocus: boolean;
     focusedRow: number;
     focusedColumn: number;
-    selectedCoordinate: {
+    coordinate: {
         rowPath: readonly {
             member: {
                 value: string | number | boolean | {
@@ -43,17 +46,10 @@ export declare function useMatrixSelection(input: {
         }[];
         measureId: string;
     } | undefined;
-    /** Inclusive row and value-column bounds of the current selection. */
-    range: {
-        rows: readonly [number, number];
-        columns: readonly [number, number];
-    } | null;
-    copyState: string;
-    copyPending: boolean;
-    copy: () => Promise<void>;
     keyboard: (event: KeyboardEvent<HTMLDivElement>) => void;
-    select: (rowIndex: number, valueColumn: number, extend: boolean) => void;
-    /** Drop the selection; the pill's clear button and Escape share it. */
+    setFocus: (rowIndex: number, valueColumn: number, options?: {
+        toggle?: boolean;
+    }) => void;
     clear: () => void;
-    selected: (r: number, c: number) => boolean;
+    isFocused: (rowIndex: number, valueColumn: number) => boolean;
 };

package/dist/types/lib/matrix-table/use-matrix.d.ts

@@ -25,7 +25,6 @@ export declare function useMatrix(input: MatrixInput): {
         }>;
     };
     readCell: (coordinate: import('./matrix-runtime-types.js').MatrixCellAddress) => import('./matrix-runtime-types.js').MatrixCellState;
-    acquireCells: (coordinates: readonly import('../../shared/analytics-protocol/index.js').MatrixCoordinate[], signal?: AbortSignal) => Promise<import('./matrix-runtime-types.js').MatrixCellState[]>;
     setViewport: (viewport: import('./matrix-runtime-types.js').MatrixViewport) => void;
     retry: (retryKey: string) => void;
     refresh: () => void;

package/dist/types/lib/query-context/build-card-query-context.d.ts

@@ -2,16 +2,28 @@ import { TFilter, TFilterValue } from '../../components/surfboard/filter/types.j
 import { ControlBinding, ControlDefinition, ResolvedDashboardDateComparisonInput, ResolvedDashboardInputContext, TCard, TDashboard } from '../types/common-types.js';
 import { GlobalDateComparisonSelection } from '../../shared/analytics-protocol/index.js';
 import { CardConfig } from '../types/explorer-types.js';
-import { resolveFiltersFromInteractionStates } from '../stores/interaction-store.js';
-import { ClickFilterEvent, InteractionState } from '../types/interaction-types.js';
+import { resolveRuntimeCardFilters } from './resolve-runtime-card-filters.js';
+import { CardViewState } from '../dashboard-view-state/index.js';
+import { TransientInputContext } from '../dashboard-inputs/transient-input-context.js';
 import { DashboardCardFilterCompilationInput } from './compile-dashboard-card-filters.js';
 import { ResolvedCardDateFields } from './resolve-card-primary-date-field.js';
-export type InteractionStateMap = Record<string, InteractionState | undefined>;
 export type BuildCardQueryContextParams = {
     card: TCard;
     dashboard: Pick<TDashboard, 'sheets'>;
-    interactionStates: InteractionStateMap | undefined;
-    currentDashboardId: string | undefined;
+    /**
+     * The carried contexts this card resolves under, the same value its
+     * `dashboardInputContext` was resolved with. Their context mode decides
+     * whether the dashboard's own toolbar filters apply. Required so that every
+     * caller decides; a caller that leaves it out would apply the dashboard's
+     * filters where the viewer drilled in without them.
+     */
+    transientContexts: readonly TransientInputContext[] | undefined;
+    /**
+     * This card's view state: its drill path regroups and narrows the card.
+     * Required so that every caller decides; a caller that leaves it out would
+     * query the card at its top level while the viewer sees it drilled.
+     */
+    cardViewState: CardViewState | undefined;
     filters: TFilter[] | undefined;
     filterValues: TFilterValue[] | undefined;
     selectedSheetId: string | null | undefined;
@@ -30,11 +42,10 @@ export type CardQueryContext = {
     controlDefinitions: ControlDefinition[];
     cardControlDefinitions: ControlDefinition[];
     controlBindings: ControlBinding[];
-    resolvedFilters: ReturnType<typeof resolveFiltersFromInteractionStates>;
+    resolvedFilters: ReturnType<typeof resolveRuntimeCardFilters>;
     finalConfig: CardConfig;
     queryRelevantConfig: CardConfig;
     finalFiltersKey: string;
-    appliedClickFilters: ClickFilterEvent[] | undefined;
 };
 export type CompiledCardQueryContext = Omit<CardQueryContext, 'filterCompilationInput'> & {
     cardFilterValues: TFilterValue[];
@@ -42,4 +53,4 @@ export type CompiledCardQueryContext = Omit<CardQueryContext, 'filterCompilation
     globalDateComparisonSelection?: GlobalDateComparisonSelection;
     dateComparisonInputs?: ResolvedDashboardDateComparisonInput[];
 };
-export declare function buildCardQueryContext({ card, dashboard, interactionStates, currentDashboardId, filters, filterValues, selectedSheetId, inlineFilterValuesMap, dashboardControls, dashboardControlValues, cardControlValuesMap, dashboardInputContext, includeAuthoredFilters, }: BuildCardQueryContextParams): CardQueryContext;
+export declare function buildCardQueryContext({ card, dashboard, transientContexts, cardViewState, filters, filterValues, selectedSheetId, inlineFilterValuesMap, dashboardControls, dashboardControlValues, cardControlValuesMap, dashboardInputContext, includeAuthoredFilters, }: BuildCardQueryContextParams): CardQueryContext;

package/dist/types/lib/query-context/build-dashboard-execution-snapshot.d.ts

@@ -1,3 +1,4 @@
+import { CardViewStateMap } from '../dashboard-view-state/index.js';
 import { TFilterValue } from '../../components/surfboard/filter/types.js';
 import { DashboardInputValues, TCard, TDashboard } from '../types/common-types.js';
 import { SemanticExecutionPayload } from '../types/semantic-runtime-types.js';
@@ -21,10 +22,11 @@ type BuildDashboardExecutionSnapshotParams = {
     timezone?: string;
 };
 export declare function buildDashboardExecutionSnapshot({ dashboard, filterValues, selectedSheetId, sheetSelection, dashboardControlValues, cardControlValuesMap, semanticExecutionPayload, timezone, }: BuildDashboardExecutionSnapshotParams): DashboardExecutionSnapshot;
-export type BuildDashboardCardExecutionSnapshotParams = Omit<BuildCardQueryContextParams, 'card' | 'dashboard' | 'selectedSheetId' | 'currentDashboardId' | 'dashboardInputContext'> & {
+export type BuildDashboardCardExecutionSnapshotParams = Omit<BuildCardQueryContextParams, 'card' | 'dashboard' | 'selectedSheetId' | 'dashboardInputContext' | 'cardViewState'> & {
     dashboard: TDashboard | undefined;
     cardId: string;
-    currentDashboardId?: string;
+    /** Drill paths by card. Required so that every caller decides; see `buildCardQueryContext`. */
+    cardViewStates: CardViewStateMap | undefined;
     dashboardInputValues?: DashboardInputValues;
     dashboardInputMode?: DashboardInputResolveMode;
     semanticExecutionPayload?: SemanticExecutionPayload;
@@ -50,5 +52,5 @@ export type DashboardCardExecutionSnapshotResult = DashboardCardExecutionSnapsho
     message?: string;
 } | null;
 export declare function requireReadyDashboardCardExecutionSnapshot(result: DashboardCardExecutionSnapshotResult): DashboardCardExecutionSnapshot | null;
-export declare function buildDashboardCardExecutionSnapshot({ dashboard, cardId, interactionStates, currentDashboardId, semanticExecutionPayload, filters, filterValues, inlineFilterValuesMap, dashboardControls, dashboardControlValues, cardControlValuesMap, dashboardInputValues, dashboardInputMode, timezone, matrixCatalog, cardOverride, sheetId, }: BuildDashboardCardExecutionSnapshotParams): DashboardCardExecutionSnapshotResult;
+export declare function buildDashboardCardExecutionSnapshot({ dashboard, cardId, transientContexts, cardViewStates, semanticExecutionPayload, filters, filterValues, inlineFilterValuesMap, dashboardControls, dashboardControlValues, cardControlValuesMap, dashboardInputValues, dashboardInputMode, timezone, matrixCatalog, cardOverride, sheetId, }: BuildDashboardCardExecutionSnapshotParams): DashboardCardExecutionSnapshotResult;
 export {};