react-semaphor 0.1.544 → 0.1.545

package/dist/types/lib/stores/dashboard-store.d.ts

@@ -4,7 +4,7 @@ import { TableColumnEditResult } from '../dashboard-viewer/table-view-edit.js';
 import { Bookmark } from '../../shared/dashboard-viewer/index.js';
 import { DashboardViewerState } from '../dashboard-viewer/viewer-store-state.js';
 import { ViewerStateClient } from '../dashboard-viewer/viewer-state-client.js';
-import { AuthToken, TBaseQuery, Breakpoint, ControlDefinition, CustomCard, StyleProps, TCard, TDashboard, TEvent, TFrame, TSheet, TStyle, CacheConfig, FilterLayoutSettings, DocumentDefinition, DashboardInput, DashboardInputSlot, DashboardInputValues, DashboardLifecycleEvent } from '../types/common-types.js';
+import { AuthToken, TBaseQuery, Breakpoint, ControlDefinition, CustomCard, StyleProps, TCard, TDashboard, TEvent, TFrame, TSheet, TStyle, CacheConfig, FilterLayoutSettings, DocumentDefinition, DashboardInput, DashboardInputScope, DashboardInputSlot, DashboardInputValues, DashboardLifecycleEvent } from '../types/common-types.js';
 import { TFilter, TFilterValue } from '../../components/surfboard/filter/types.js';
 import { TransientInputContext } from '../dashboard-inputs/transient-input-context.js';
 import { MissingPrintInputs } from '../print/print-inputs.js';
@@ -15,10 +15,9 @@ import { DashboardControlsModelOptions } from '../controls/control-authoring-typ
 import { SemanticExecutionPayload } from '../types/semantic-runtime-types.js';
 import { DocumentPanelTarget } from '../document/document-panel-target.js';
 import { DocumentEdit, DocumentEditResult } from '../document/document-edits.js';
+import { FilterSettingsChange, FilterSettingsSaveResult } from '../dashboard-inputs/filter-settings.js';
+import { FilterRef } from '../../shared/dashboard-authoring/filter-model/index.js';
 import { DashboardInputRuntimeTarget } from '../dashboard-inputs/dashboard-input-values.js';
-import { DashboardFilterMappingAuthoringIssue, DashboardFilterInputAcceptanceResult, DashboardFilterMappingAcceptanceResult, DashboardFilterMappingAuthoringRequest, DashboardFilterMappingDisableResult } from '../dashboard-inputs/dashboard-filter-mapping-authoring.js';
-import { DashboardFilterOptionSource } from '../../shared/dashboard-authoring/index.js';
-import { DashboardFilterAuthoringSettingsUpdate } from '../dashboard-inputs/dashboard-filter-mapping-storage-transition.js';
 import { GlobalDateComparisonSelection } from '../../shared/analytics-protocol/index.js';
 import { CalendarPreferencesResponse, ReportRuntimeContext, ResolvedCalendarPreferenceSources } from '../../shared/report-runtime-context/index.js';
 import { ResolvedValueFormatPreferenceSources, ResolvedValueFormatPreferences } from '../../shared/value-format-preferences/index.js';
@@ -31,26 +30,6 @@ type AddFrameOptions = {
     placement?: DashboardFramePlacement;
     semanticExecutionPayload?: SemanticExecutionPayload;
 };
-export type FilterDashboardInputDefinitionUpdateMetadata = {
-    variableName?: string;
-    label?: string;
-    forceSelection?: boolean;
-    exports?: DashboardInput['exports'];
-    /**
-     * Option source, dependency and population edits for an embedded Input,
-     * persisted through the same contract validation as mapped dashboard
-     * filters. Presentations that bind an embedded Input (the document input
-     * bar) carry these; dashboard-filter references persist through
-     * `acceptDashboardFilterInput` and `acceptDashboardFilterMapping` instead.
-     */
-    optionSettings?: DashboardFilterAuthoringSettingsUpdate;
-};
-export type FilterDashboardInputDefinitionUpdateResult = {
-    ok: true;
-} | {
-    ok: false;
-    issues: DashboardFilterMappingAuthoringIssue[];
-};
 export type DashboardStore = {
     isDownloadingPdf?: boolean;
     isSessionExpired: boolean;
@@ -73,11 +52,6 @@ export type DashboardStore = {
      * draft-only until the editor Save path applies the current frame.
      */
     visualEditPendingFrameRewrites: Record<string, TFrame[]>;
-    /**
-     * Pending dashboard-filter metadata rewrites produced while visual editing.
-     * These stay draft-only until the editor Save path applies the current frame.
-     */
-    visualEditPendingFilterRewrites: Record<string, TFilter[]>;
     /**
      * Pending dashboard-scoped calculated-field rewrites produced while visual
      * editing. These stay draft-only until the editor Save path applies the
@@ -99,7 +73,12 @@ export type DashboardStore = {
     isVisualEditing: boolean;
     showDashboardJSON: boolean;
     showFilters: boolean;
-    filterValues?: TFilterValue[];
+    /**
+     * Runtime-only values no filter defines: chart clicks on SQL charts and
+     * summary chips (one filter model SPEC 5.8). Never saved. Authored filter
+     * values are `dashboardInputValues` slots.
+     */
+    adHocFilterValues: TFilterValue[];
     /** Runtime-only inline filter values, keyed by cardId. Not persisted with dashboard. */
     inlineFilterValuesMap: Record<string, TFilterValue[]>;
     /** Runtime-only dashboard control values keyed by globally unique controlId. */
@@ -179,20 +158,25 @@ type Actions = {
     setGlobalStyle: (style: TStyle) => void;
     setDashboardInputs: (inputs: DashboardInput[]) => void;
     upsertDashboardInput: (input: DashboardInput) => void;
-    updateFilterDashboardInputDefinition: (inputId: string, filter: TFilter, metadata?: FilterDashboardInputDefinitionUpdateMetadata) => FilterDashboardInputDefinitionUpdateResult;
-    acceptDashboardFilterInput: (updatedFilter: TFilter, optionSource: DashboardFilterOptionSource | undefined, settings?: DashboardFilterAuthoringSettingsUpdate, inputMetadata?: {
-        variableName?: string;
-    }) => DashboardFilterInputAcceptanceResult;
     /**
-     * Saves filter settings for a dashboard filter no Input owns: the
-     * definition, and through the default-storage owner its live value and
-     * saved overlay entry when the default changed (FM-D9). A comparison
-     * default keeps its own action (`setDefaultDashboardInputComparisonSelection`).
+     * Every settings write of a filter (one filter model M4, SPEC 4.5): the
+     * definition, label, variable name, keep selection, required, scope, option
+     * settings, mapping and value effects, in one write. Nothing is written
+     * when the change is refused.
      */
-    acceptOrdinaryDashboardFilter: (updatedFilter: TFilter, settings?: Pick<DashboardFilterAuthoringSettingsUpdate, 'defaultValueChanged' | 'selectionIdentityChanged' | 'target'>) => void;
-    acceptDashboardFilterMapping: (request: DashboardFilterMappingAuthoringRequest, updatedFilter?: TFilter, settings?: DashboardFilterAuthoringSettingsUpdate) => DashboardFilterMappingAcceptanceResult;
-    disableDashboardFilterMapping: (filterId: string, updatedFilter?: TFilter, settings?: DashboardFilterAuthoringSettingsUpdate) => DashboardFilterMappingDisableResult;
+    saveFilterSettings: (ref: FilterRef, change: FilterSettingsChange) => FilterSettingsSaveResult;
     removeDashboardInput: (inputId: string) => void;
+    /**
+     * Adds a new filter as an input holding this definition, reaching `scope`
+     * (one filter model Phase 5: every filter is an input). One Global Date per
+     * dashboard: a second is refused. Returns the new input's id.
+     */
+    addFilterInput: (filter: TFilter, scope: DashboardInputScope) => string | undefined;
+    /**
+     * Removes a filter, whichever input holds it, with its saved and runtime
+     * values (one filter model SP-9; from Phase 5 every filter is an input).
+     */
+    removeFilterInput: (ref: FilterRef) => void;
     reorderDashboardInputs: (orderedInputIds: string[]) => void;
     setDefaultDashboardInputValues: (values: DashboardInputValues | undefined) => void;
     setDefaultDashboardInputComparisonSelection: (input: Pick<DashboardInput, 'id' | 'runtimeScope'>, target: DashboardInputRuntimeTarget, selection: GlobalDateComparisonSelection | undefined) => void;
@@ -228,7 +212,14 @@ type Actions = {
         dashboardInputGeneratedAt?: string;
         reportContext?: ReportRuntimeContext;
     }) => void;
+    /**
+     * Loads a dashboard. `filterValues` is a host overlay (one filter model M5):
+     * each filter's value becomes its input's slot, under any slots in
+     * `options.dashboardInputValues`; a value no filter defines is ad-hoc.
+     */
     setDashboardWithFilterValues: (dashboard: TDashboard, filterValues: TFilterValue[], runtimeOverrides?: Record<string, unknown>, options?: {
+        /** Ad-hoc values to load (SPEC 5.8). */
+        adHocFilterValues?: TFilterValue[];
         selectedSheetId?: string | null;
         semanticExecutionPayload?: SemanticExecutionPayload;
         dashboardInputValues?: DashboardInputValues;
@@ -317,9 +308,7 @@ type Actions = {
     updateSheetCalculatedFields: (sheetId: string, calculatedFields: Field[]) => void;
     updateDashboardCalculatedFields: (calculatedFields: Field[]) => void;
     setVisualEditPendingFrameRewrites: (sheetId: string, frames: TFrame[]) => void;
-    setVisualEditPendingFilterRewrites: (sheetId: string, filters: TFilter[]) => void;
     clearVisualEditPendingFrameRewrites: (sheetId?: string) => void;
-    clearVisualEditPendingFilterRewrites: (sheetId?: string) => void;
     updateCard: (sheetId: string, card: TCard) => void;
     updateFrameCard?: (sheetId: string, frameId: string, card: TCard) => void;
     updateCurrentDashboardCard: (card: TCard) => void;
@@ -330,17 +319,13 @@ type Actions = {
     setIsVisualEditing: (editing: boolean) => void;
     setShowFilters: (show: boolean) => void;
     setFilterLayout: (settings: Partial<FilterLayoutSettings>) => void;
-    addFilter: (filter: TFilter) => void;
-    removeFilter: (filterId: string) => void;
-    reorderFilters: (orderedFilterIds: string[]) => void;
-    updateFilter: (filter: TFilter) => void;
-    updateFilterId: (filterId: string, newId: string) => void;
-    setFilterDefaultValues: (filterId: string, defaultValues: (string | number)[] | undefined) => void;
-    setFilterValues: (filterValues: TFilterValue[] | undefined) => void;
-    addOrUpdateFilterValue: (filterValue: TFilterValue) => void;
-    addOrUpdateFilterValues: (filterValues: TFilterValue[]) => void;
-    removeFilterValues: (filterId: string) => void;
-    replaceFilterValue: (filterValue: TFilterValue) => void;
+    /** Adds or replaces ad-hoc values by `filterId`; a value with no values removes its entry. */
+    addOrUpdateAdHocFilterValues: (filterValues: TFilterValue[]) => void;
+    /** Removes every ad-hoc value whose id starts with the prefix: everything one chart added (SPEC 5.8). */
+    removeAdHocFilterValues: (idPrefix: string) => void;
+    clearAdHocFilterValues: () => void;
+    /** Clears every filter's value on every target, and every ad-hoc value (a card popover's Clear all). */
+    clearAllFilterValues: () => void;
     setStyle: (style: TStyle) => void;
     getStyle: () => TStyle | undefined;
     setOnSaveFunction: (onSaveFunction: (dashboard: TDashboard) => void) => void;
@@ -358,7 +343,6 @@ type Actions = {
     getCardSheet: (cardId: string) => TSheet | undefined;
     getSelectedSheetLayout: () => ReactGridLayout.Layout[] | undefined;
     getSelectedSheetLayouts: () => ReactGridLayout.Layouts | undefined;
-    handleDataPointClickAction: (card: TCard, dataPoint: any) => void;
     addBaseQuery: (baseQuery: TBaseQuery) => void;
     removeBaseQuery: (baseQueryId: string) => void;
     setBaseQueries: (baseQueries: TBaseQuery[]) => void;

package/dist/types/lib/stores/editor-store.d.ts

@@ -33,7 +33,6 @@ export type EditorContext = {
     documentFilterValues?: TFilterValue[];
     documentControlDefinitions?: ControlDefinition[];
     documentControlValues?: Record<string, unknown>;
-    missingRequiredInputLabels?: string[];
 };
 /**
  * Factory function to create empty KPI card configuration
@@ -71,7 +70,6 @@ export type EditorStore = {
     activeTabCardId?: string | null;
     showFilters: boolean;
     applyFilters: boolean;
-    filterValues?: TFilterValue[];
     inlineFilterValuesMap: Record<string, TFilterValue[]>;
     queryResultColumns: string[];
     queryResultColumnKeyMap?: QueryColumnKeyMap;
@@ -183,7 +181,6 @@ type Actions = TableActions & ExplorerActions & {
     setCardConfig: (config: CardConfig | undefined) => void;
     setShowFilters: (showFilters: boolean) => void;
     setApplyFilters: (applyFilters: boolean) => void;
-    setFilterValues: (filterValues: TFilterValue[]) => void;
     setInlineFilterValuesMap: (map: Record<string, TFilterValue[]>) => void;
     setCardInlineFilterValue: (cardId: string, filterValue: TFilterValue) => void;
     removeCardInlineFilterValue: (cardId: string, filterId: string) => void;

package/dist/types/lib/types/common-types.d.ts

@@ -138,6 +138,14 @@ export type VisualDisplayPreferences = {
      * exactly as today (report attachment delivery RA-D11).
      */
     delivery?: 'strict';
+    /**
+     * An emailed card image (PNG exports PN-D13): the card is drawn at the size
+     * its saved layout has on a dashboard this many CSS pixels wide, by the
+     * dashboard grid's own geometry. Read by `Visual` only.
+     */
+    imageLayout?: {
+        dashboardWidth: number;
+    };
     /**
      * Override specific UI elements visibility
      * These overrides take precedence over the mode presets
@@ -161,12 +169,6 @@ export type VisualDisplayPreferences = {
  * Filter layout settings for controlling how dashboard filters are displayed
  */
 export type FilterLayoutSettings = {
-    /**
-     * Display mode for filters
-     * - 'canvas': Filters displayed as draggable/resizable cards on the dashboard canvas (default)
-     * - 'toolbar': Filters displayed in a compact horizontal toolbar below dashboard controls
-     */
-    displayMode?: 'canvas' | 'toolbar';
     /**
      * Whether the toolbar should wrap filters to multiple lines
      * - false: Horizontal scroll when filters overflow (default)
@@ -931,14 +933,27 @@ export type ControlBinding = {
     mapping: Record<string, string>;
 } | CurrencyPresentationBinding;
 export type DashboardInput = FilterDashboardInput | ControlDashboardInput;
+/**
+ * Which tabs and cards an input reaches. The one owner of reach; read it only
+ * through the scope rule (`doesDashboardInputApplyToTarget`,
+ * `isDashboardInputOnTab` in react-semaphor `dashboard-authoring`).
+ */
 export type DashboardInputScope = {
     kind: 'allSheets';
+    /** Omitted = tabs of both kinds. */
     sheetKinds?: Array<'dashboard' | 'document'>;
+    /** Every allowed tab except these. A tab added later is included. */
+    exceptSheetIds?: string[];
+    /** Every card on the reached tabs except these. A card added later is included. */
+    exceptCardIds?: string[];
 } | {
     kind: 'sheets';
+    /** May be empty: the input reaches nothing. */
     sheetIds: string[];
+    exceptCardIds?: string[];
 } | {
     kind: 'cards';
+    /** May be empty: the input reaches nothing. */
     cardIds: string[];
 } | {
     kind: 'documentSections';

package/dist/types/shared/assistant-context/saved-dashboard-context.d.ts

@@ -1,10 +1,9 @@
-import { DashboardInputExecutionSnapshot, TCard, TDashboard } from '../../lib/types/common-types.js';
-import { TFilterValue } from '../../components/surfboard/filter/types.js';
+import { TCard, TDashboard } from '../../lib/types/common-types.js';
 import { CardViewStateMap } from '../../lib/dashboard-view-state/index.js';
 import { ControlContractOverrides } from '../../lib/dashboard-inputs/control-contract-overrides.js';
 import { SemanticExecutionPayload } from '../../lib/types/semantic-runtime-types.js';
 import { CalendarContext } from '../report-runtime-context/index.js';
-import { ViewerStoreInputValues } from '../../lib/dashboard-viewer/compatibility-input-storage.js';
+import { CardRuntimeValues, StoredCaptureValues } from '../../lib/dashboard-viewer/captured-runtime-values.js';
 import { DashboardCardExecutionSnapshotResult } from '../../lib/query-context/build-dashboard-execution-snapshot.js';
 import { TransientInputContext } from '../../lib/dashboard-inputs/transient-input-context.js';
 import { DashboardCardLocation } from '../dashboard-authoring/document-section-cards.js';
@@ -26,10 +25,6 @@ export type SavedDashboardPlace = {
     /** Drill paths by card. */
     cardViewState?: CardViewStateMap;
 };
-/** The store's input values plus drill paths: what a card's snapshot is built from. */
-export type CardRuntimeValues = ViewerStoreInputValues & {
-    cardViewState: CardViewStateMap;
-};
 export declare function projectSavedDashboardContext(input: {
     dashboard: TDashboard;
     place: SavedDashboardPlace;
@@ -115,11 +110,9 @@ export declare function cardReplayOf(input: {
  * contract, and a saved input snapshot. Every field is optional; none at all
  * is a fresh viewer (saved defaults).
  */
-export type SavedCardHost = {
-    filterValues?: readonly TFilterValue[];
-    controlValues?: Readonly<Record<string, unknown>>;
+/** A scheduled card attachment's saved values, with the host's control contract. */
+export type SavedCardHost = StoredCaptureValues & {
     controlContract?: ControlContractOverrides;
-    dashboardInputExecutionSnapshot?: DashboardInputExecutionSnapshot;
 };
 /**
  * A saved card's request as a host opens it: by default a fresh viewer

package/dist/types/shared/dashboard-authoring/control-execution-contract.d.ts

@@ -193,10 +193,10 @@ export declare const controlDefinitionExecutionSchema: z.ZodEffects<z.ZodObject<
     defaultValue?: unknown;
     showLabel?: boolean | undefined;
     toolbarWidth?: number | undefined;
-    placement?: "toolbar" | "card_header" | "advanced" | undefined;
     hidden?: boolean | undefined;
     locked?: boolean | undefined;
     helpText?: string | undefined;
+    placement?: "toolbar" | "card_header" | "advanced" | undefined;
 }, {
     type: "number" | "boolean" | "date" | "text" | "enum" | "multi_enum" | "field_selector" | "metric_selector" | "aggregation_selector" | "grain_selector";
     id: string;
@@ -236,10 +236,10 @@ export declare const controlDefinitionExecutionSchema: z.ZodEffects<z.ZodObject<
     defaultValue?: unknown;
     showLabel?: boolean | undefined;
     toolbarWidth?: number | undefined;
-    placement?: "toolbar" | "card_header" | "advanced" | undefined;
     hidden?: boolean | undefined;
     locked?: boolean | undefined;
     helpText?: string | undefined;
+    placement?: "toolbar" | "card_header" | "advanced" | undefined;
 }>, {
     type: "number" | "boolean" | "date" | "text" | "enum" | "multi_enum" | "field_selector" | "metric_selector" | "aggregation_selector" | "grain_selector";
     id: string;
@@ -279,10 +279,10 @@ export declare const controlDefinitionExecutionSchema: z.ZodEffects<z.ZodObject<
     defaultValue?: unknown;
     showLabel?: boolean | undefined;
     toolbarWidth?: number | undefined;
-    placement?: "toolbar" | "card_header" | "advanced" | undefined;
     hidden?: boolean | undefined;
     locked?: boolean | undefined;
     helpText?: string | undefined;
+    placement?: "toolbar" | "card_header" | "advanced" | undefined;
 }, {
     type: "number" | "boolean" | "date" | "text" | "enum" | "multi_enum" | "field_selector" | "metric_selector" | "aggregation_selector" | "grain_selector";
     id: string;
@@ -322,10 +322,10 @@ export declare const controlDefinitionExecutionSchema: z.ZodEffects<z.ZodObject<
     defaultValue?: unknown;
     showLabel?: boolean | undefined;
     toolbarWidth?: number | undefined;
-    placement?: "toolbar" | "card_header" | "advanced" | undefined;
     hidden?: boolean | undefined;
     locked?: boolean | undefined;
     helpText?: string | undefined;
+    placement?: "toolbar" | "card_header" | "advanced" | undefined;
 }>;
 export declare const controlBindingExecutionSchema: z.ZodDiscriminatedUnion<"target", [z.ZodObject<{
     controlId: z.ZodString;
@@ -858,7 +858,6 @@ export declare const controlBindingExecutionSchema: z.ZodDiscriminatedUnion<"tar
     }>>;
 }, "strict", z.ZodTypeAny, {
     target: "config_metric_selector";
-    controlId: string;
     mapping: Record<string, z.objectOutputType<{
         id: z.ZodString;
         name: z.ZodString;
@@ -934,10 +933,10 @@ export declare const controlBindingExecutionSchema: z.ZodDiscriminatedUnion<"tar
         id: string;
         kind: "matrix_instance";
     }>;
+    controlId: string;
     matrixTargetId?: string | undefined;
 }, {
     target: "config_metric_selector";
-    controlId: string;
     mapping: Record<string, z.objectInputType<{
         id: z.ZodString;
         name: z.ZodString;
@@ -1013,6 +1012,7 @@ export declare const controlBindingExecutionSchema: z.ZodDiscriminatedUnion<"tar
         id: string;
         kind: "matrix_instance";
     }>;
+    controlId: string;
     matrixTargetId?: string | undefined;
 }>, z.ZodObject<{
     controlId: z.ZodString;
@@ -1526,7 +1526,6 @@ export declare const controlBindingExecutionSchema: z.ZodDiscriminatedUnion<"tar
     }>>;
 }, "strict", z.ZodTypeAny, {
     target: "config_field_selector";
-    controlId: string;
     mapping: Record<string, z.objectOutputType<{
         id: z.ZodString;
         name: z.ZodString;
@@ -1601,10 +1600,10 @@ export declare const controlBindingExecutionSchema: z.ZodDiscriminatedUnion<"tar
         id: string;
         kind: "matrix_instance";
     }>;
+    controlId: string;
     matrixTargetId?: string | undefined;
 }, {
     target: "config_field_selector";
-    controlId: string;
     mapping: Record<string, z.objectInputType<{
         id: z.ZodString;
         name: z.ZodString;
@@ -1679,6 +1678,7 @@ export declare const controlBindingExecutionSchema: z.ZodDiscriminatedUnion<"tar
         id: string;
         kind: "matrix_instance";
     }>;
+    controlId: string;
     matrixTargetId?: string | undefined;
 }>, z.ZodObject<{
     controlId: z.ZodString;
@@ -1687,13 +1687,13 @@ export declare const controlBindingExecutionSchema: z.ZodDiscriminatedUnion<"tar
     mapping: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodString>, Record<string, string>, Record<string, string>>;
 }, "strict", z.ZodTypeAny, {
     target: "config_aggregation";
-    controlId: string;
     mapping: Record<string, string>;
+    controlId: string;
     matrixTargetId?: string | undefined;
 }, {
     target: "config_aggregation";
-    controlId: string;
     mapping: Record<string, string>;
+    controlId: string;
     matrixTargetId?: string | undefined;
 }>, z.ZodObject<{
     controlId: z.ZodString;
@@ -1702,13 +1702,13 @@ export declare const controlBindingExecutionSchema: z.ZodDiscriminatedUnion<"tar
     mapping: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodString>, Record<string, string>, Record<string, string>>;
 }, "strict", z.ZodTypeAny, {
     target: "config_grain";
-    controlId: string;
     mapping: Record<string, string>;
+    controlId: string;
     matrixTargetId?: string | undefined;
 }, {
     target: "config_grain";
-    controlId: string;
     mapping: Record<string, string>;
+    controlId: string;
     matrixTargetId?: string | undefined;
 }>, z.ZodObject<{
     controlId: z.ZodString;

package/dist/types/shared/dashboard-authoring/dashboard-filter-mapping-contract.d.ts

@@ -21,6 +21,13 @@ export type NormalizeDashboardInputsResult = {
     inputs: NormalizedDashboardInput[];
     issues: DashboardFilterMappingContractIssue[];
 };
+/**
+ * The one table of allowed scope and runtime-scope combinations (one filter
+ * model SPEC 4.2). A per-tab value lives on every tab the input is shown on
+ * (`isDashboardInputOnTab`), so a `cards` scope may keep per-tab values.
+ */
+export declare const DASHBOARD_INPUT_RUNTIME_SCOPE_KINDS: Readonly<Record<DashboardInput['runtimeScope'], ReadonlyArray<DashboardInput['scope']['kind']>>>;
+export declare function isAllowedDashboardInputScopeCombination(runtimeScope: DashboardInput['runtimeScope'], scopeKind: DashboardInput['scope']['kind']): boolean;
 export declare function normalizeDashboardInputs({ inputs, dashboardFilters, cards, validateCardTargets, }: {
     inputs: DashboardInput[] | unknown;
     dashboardFilters: TFilter[] | undefined;

package/dist/types/shared/dashboard-authoring/dashboard-input-scope.d.ts

@@ -0,0 +1,92 @@
+import { DashboardInputBase, DashboardInputScope, NormalizedDashboardInput, TDashboard } from '../../lib/types/common-types.js';
+import { DashboardInputRuntimeTarget } from '../../lib/dashboard-inputs/dashboard-input-values.js';
+/**
+ * The scope rule (one filter model M2): the one interpreter of
+ * `DashboardInputScope`. Filters, controls, click-to-filter targets and
+ * carried contexts all decide "does this reach that card" here, on the client
+ * and on the server.
+ */
+export type ScopedDashboardInputTarget = DashboardInputRuntimeTarget & {
+    sheetKind?: 'dashboard' | 'document';
+};
+/** One tab, for "is this input shown in this tab's filter bar". */
+export type DashboardTabTarget = {
+    sheetId: string;
+    sheetKind: 'dashboard' | 'document';
+    /** Every card on the tab: sheet cards, frame cards, section cards. */
+    cardIds: ReadonlySet<string>;
+};
+/** Does the input apply to this card, section or tab? */
+export declare function doesDashboardInputApplyToTarget(input: Pick<DashboardInputBase, 'scope' | 'compatibility'>, target: ScopedDashboardInputTarget): boolean;
+/**
+ * Is the input shown in this tab's filter bar? True when it applies to the
+ * tab itself, or to any card on it (a `cards` scope), or, for a
+ * `documentSections` scope, when the tab is that Document tab. "The tabs of
+ * a per-tab input" always means the tabs where this holds.
+ */
+export declare function isDashboardInputOnTab(input: Pick<DashboardInputBase, 'scope' | 'compatibility'>, tab: DashboardTabTarget): boolean;
+/** The tab targets of a dashboard, by sheet id, memoized per dashboard object. */
+export declare function listDashboardTabTargets(dashboard: Pick<TDashboard, 'sheets'>): ReadonlyMap<string, DashboardTabTarget>;
+/**
+ * Every tab, card and Document section an input reaches, as keys
+ * (`sheet:<id>`, `card:<id>`, `section:<id>`). A section card is evaluated
+ * with its section, as the runtime resolves it. Two inputs overlap when their
+ * keys intersect: the one reach behind the overlap rules of filter settings
+ * and of the app's save validation (aliases, backing control ids).
+ */
+export declare function listDashboardInputReachKeys(dashboard: Pick<TDashboard, 'sheets'>, input: Pick<DashboardInputBase, 'scope' | 'compatibility'>): Set<string>;
+/**
+ * Whether a filter input still applies when a carried context turns the
+ * dashboard's own filters off (`resolveContextAwareFilterPolicy`): a filter
+ * scoped to specific cards does, a toolbar filter included, and so do the
+ * cards' inline filters, which are scoped to their card (SP-12). A mapping
+ * never changes the scope, so attaching one never changes survival. The one
+ * rule for the compiler, the mapping resolver, the required check and any
+ * reader that says which filters a view applies.
+ */
+export declare function doesDashboardInputSurviveCarriedContext(input: Pick<NormalizedDashboardInput, 'kind' | 'scope'>): boolean;
+export type DashboardInputScopeIdChange = {
+    removedSheetIds?: ReadonlySet<string>;
+    removedCardIds?: ReadonlySet<string>;
+    /**
+     * Ids given new ids: a card renamed in place, a library visual's ids on its
+     * dashboard instance, an authoring plan's ids on the cards it produced. An
+     * id the map does not list stays.
+     */
+    renamedSheetIds?: ReadonlyMap<string, string>;
+    renamedCardIds?: ReadonlyMap<string, string>;
+    renamedSectionIds?: ReadonlyMap<string, string>;
+    /**
+     * `renamedCardIds` lists every card that is kept: a card id it does not
+     * list is removed (an authoring plan compiled into cards, some skipped).
+     */
+    keepOnlyRenamedCardIds?: boolean;
+    copiedTab?: {
+        /**
+         * 'replace': a filter copied with the tab; every listed id of the copied
+         * tab and its cards becomes its copy's id. 'extend': a filter shared with
+         * the copy; every listed id stays and its copy's id is added next to it.
+         */
+        mode: 'replace' | 'extend';
+        sheetIds: ReadonlyMap<string, string>;
+        cardIds: ReadonlyMap<string, string>;
+        sectionIds: ReadonlyMap<string, string>;
+    };
+};
+/**
+ * Rewrites the ids a scope names, in the positive lists and both except
+ * lists: after tabs or cards are removed, ids are renamed, or a tab is
+ * duplicated. The one rewrite of a scope's ids, for inputs and for click to
+ * filter targets alike. Lists may become empty; whether an input with an
+ * empty scope is kept is the caller's existing rule. Returns the same scope
+ * object when nothing changed.
+ */
+export declare function rewriteDashboardInputScopeIds(scope: DashboardInputScope, change: DashboardInputScopeIdChange): DashboardInputScope;
+/**
+ * Whether a tab owns an input, so deleting the tab deletes it: its scope
+ * names only that tab, only cards on it, or its Document sections. Scope
+ * owns an input's lifetime; runtimeScope only owns its value slots.
+ */
+export declare function isDashboardInputOwnedBySheet(scope: DashboardInputScope, sheetId: string, cardIds: ReadonlySet<string>): boolean;
+/** Whether a scope reaches nothing: an empty tab or card list (after ids are removed). */
+export declare function isDashboardInputScopeEmpty(scope: DashboardInputScope): boolean;

package/dist/types/shared/dashboard-authoring/filter-model/ad-hoc-filter-values.d.ts

@@ -0,0 +1,10 @@
+import { TFilterValue } from '../../../components/surfboard/filter/types.js';
+/**
+ * Whether an ad-hoc value belongs to a tab: its id ends with the tab id. With
+ * no current tab, no ad-hoc value applies. The one owner of this rule (one
+ * filter model SPEC 5.8, P4a-02): the compile, the filter option lists, the
+ * summary request and the filter value list call it.
+ */
+export declare function isAdHocFilterValueOnTab(filterId: string, sheetId: string | null | undefined): boolean;
+/** The ad-hoc values of one tab, in list order. */
+export declare function listAdHocFilterValuesOnTab(adHocFilterValues: readonly TFilterValue[] | undefined, sheetId: string | null | undefined): TFilterValue[];

package/dist/types/shared/dashboard-authoring/filter-model/filter-definitions.d.ts

@@ -0,0 +1,29 @@
+import { TFilter } from '../../../components/surfboard/filter/types.js';
+import { NormalizedFilterDashboardInput, TDashboard } from '../../../lib/types/common-types.js';
+import { FilterInputEntry } from './read-dashboard-filter-model.js';
+/** One definition per filter input, in model order. The same array for the same dashboard object. */
+export declare function listDashboardFilterDefinitions(dashboard: TDashboard): readonly TFilter[];
+/** The dashboard's Global Date filter, whichever input holds it. */
+export declare function getDashboardGlobalDateFilter(dashboard: TDashboard): TFilter | undefined;
+/**
+ * The filter inputs the tab-presence rule places on a tab (M2), in model
+ * order: what the tab's filter bar shows. `sheetKind` overrides the tab's
+ * own kind. None for an unknown tab.
+ */
+export declare function listDashboardFilterInputsOnTab(dashboard: TDashboard, sheetId: string | null | undefined, sheetKind?: 'dashboard' | 'document'): readonly FilterInputEntry[];
+/**
+ * A filter hidden from the toolbar and not attached to a visual: a toolbar
+ * filter's `hide`, or an input placed `hidden` (OF-D14). The edit-mode strip
+ * of hidden filters lists these.
+ */
+export declare function isHiddenFilterInput(input: NormalizedFilterDashboardInput): boolean;
+/**
+ * Every filter definition the stored template holds, as stored: toolbar
+ * filters, stored inputs' filters and prototype Document inputs' filters,
+ * rejected inputs included (the model leaves those out). The objects
+ * themselves, so a writer of the stored shape (a migration's remap, a demo
+ * copy) rewrites them in place on its own copy, and a reader that must see
+ * every stored definition (the connections a migration maps) sees what the
+ * remap writes (one filter model P4b-02 (f)).
+ */
+export declare function listStoredFilterDefinitions(dashboard: TDashboard): TFilter[];

package/dist/types/shared/dashboard-authoring/filter-model/filter-values.d.ts

@@ -0,0 +1,58 @@
+import { TFilter, TFilterValue } from '../../../components/surfboard/filter/types.js';
+import { DashboardInputValues, NormalizedFilterDashboardInput, TDashboard } from '../../../lib/types/common-types.js';
+import { CalendarContext } from '../../report-runtime-context/index.js';
+import { DashboardInputRuntimeTarget } from '../../../lib/dashboard-inputs/dashboard-input-values.js';
+import { DashboardInputRuntimeValues } from '../../../lib/dashboard-inputs/resolve-dashboard-input-context.js';
+/**
+ * M5, the filter value adapters (one filter model SPEC 4.7): they move values
+ * between the old filter value list, keyed by `filterId`, and input slots.
+ * They decide no precedence.
+ */
+/** A host filter default: a full filter value, or the short `{ filterId, values }` embed form. */
+export type HostFilterValue = TFilterValue | {
+    readonly filterId: string;
+    readonly values: string[] | number[];
+};
+/**
+ * A host value as a filter value of this definition (today's hydration rule).
+ * The short embed form names no operation: it takes the filter's own, so the
+ * slot passes the input's validation (ledger P4a-03).
+ */
+export declare function hostFilterValueFor(filter: TFilter, hostValue: HostFilterValue, calendar: CalendarContext | null | undefined): TFilterValue;
+/**
+ * Host overlay in: each value goes to the input owning its `filterId`, as a
+ * runtime slot over saved defaults. A `shared` input gets one slot; a
+ * `perSheet` input gets one on every tab the input is on (a host default is
+ * dashboard-wide, as today). A value whose `filterId` owns no input, or
+ * whose input holds one value per card or section, is dropped and listed.
+ * The values that own no input are also returned as they were listed: the
+ * caller decides whether they are ad-hoc values (SPEC 5.8, 5.9).
+ */
+export declare function hostFilterValuesToSlots(dashboard: TDashboard, values: readonly HostFilterValue[] | undefined, options: {
+    calendar: CalendarContext | null | undefined;
+}): {
+    slots: DashboardInputValues;
+    adHocFilterValues: TFilterValue[];
+    droppedFilterIds: string[];
+};
+/**
+ * List out, tab-wide: each filter shown on this tab with its effective value
+ * (the inputs the tab-presence rule places on it, in model order, each
+ * through the hydration owner), followed by the tab's ad-hoc values. Inputs
+ * with no value, or cleared, are left out. Used by `onFilterValuesChange`,
+ * captures and every reader that reports a tab's filters.
+ */
+export declare function readFilterValueList(params: {
+    dashboard: TDashboard;
+    runtimeValues: Pick<DashboardInputRuntimeValues, 'dashboardInputValues'>;
+    adHocFilterValues: readonly TFilterValue[] | undefined;
+    sheetId: string | null | undefined;
+    sheetKind: 'dashboard' | 'document';
+    calendar: CalendarContext | null;
+}): TFilterValue[];
+/**
+ * Every runtime target a filter input holds a value at: one for a `shared`
+ * input, each tab it is on for `perSheet`, each card it reaches for
+ * `perCard`, each section it reaches for `perDocumentSection`.
+ */
+export declare function listFilterInputValueTargets(dashboard: TDashboard, input: NormalizedFilterDashboardInput): DashboardInputRuntimeTarget[];

package/dist/types/shared/dashboard-authoring/filter-model/index.d.ts

@@ -0,0 +1,7 @@
+export * from './read-dashboard-filter-model.js';
+export * from './toolbar-filter-reach.js';
+export { foldPrototypeDocumentInputs } from './prototype-document-inputs.js';
+export * from './filter-values.js';
+export * from './filter-definitions.js';
+export * from './ad-hoc-filter-values.js';
+export { upgradeToStoredDashboard } from './stored-dashboard.js';