react-semaphor 0.1.514 → 0.1.516

package/dist/types/lib/matrix-table/matrix-layout-read.d.ts

@@ -0,0 +1,68 @@
+import { MatrixLayoutReadResult } from '../../shared/dashboard-authoring/matrix-delivery.js';
+import { buildMatrixDeliveryPayload } from './matrix-delivery.js';
+import { DocumentTableRowFacts } from '../document/document-pagination.js';
+import { FastPathTableStructure } from '../../shared/format-utils/table-structure.js';
+import { ReportRuntimeContext } from '../../shared/report-runtime-context/index.js';
+/** Matrix sections on one page read at most this many full results at once (tech spec G6). */
+export declare const MATRIX_LAYOUT_READ_CONCURRENCY = 2;
+/**
+ * The full Matrix result a Document section prints, from the delivery-authorized
+ * layout route (tech spec D-M1). Always resolves to the typed result; an abort
+ * rejects, so it is never kept as a result.
+ */
+export declare function readMatrixLayout(input: {
+    apiServiceUrl: string;
+    token: string;
+    payload: ReturnType<typeof buildMatrixDeliveryPayload>;
+    signal: AbortSignal;
+}): Promise<MatrixLayoutReadResult>;
+/** How a printed row reads: its role and where it sits in the hierarchy. */
+export type MatrixPrintRowKind = 'member'
+/** A parent row in outline layout, heading its children. */
+ | 'group'
+/** The subtotal of the innermost group level. */
+ | 'subtotal_inner'
+/** The subtotal of an outer group level. */
+ | 'subtotal_outer' | 'grand_total';
+export type MatrixPrintRow = {
+    kind: MatrixPrintRowKind;
+    /**
+     * Group labels this row hides because the row above shows them, by column
+     * index. A page that starts at this row repeats them, marked "(cont.)".
+     */
+    continuation?: Readonly<Record<number, string>>;
+    /**
+     * Indented layout: the parent header rows a page that starts at this row
+     * repeats, outermost first, already indented and marked "(cont.)".
+     */
+    continuationHeaders?: readonly string[];
+};
+/** A read as the page draws it: the formatted table and each row's print facts. */
+export type DocumentMatrixRead = {
+    status: 'ok';
+    table: FastPathTableStructure;
+    rows: readonly MatrixPrintRow[];
+    /** Indented layout: the column that carries the row labels. */
+    hierarchyColumn?: number;
+    /**
+     * Column groups for bands (Plan 2, 2c): per column, the index of its
+     * group in `groups`, or `null` for a row-label column. A group is one
+     * column member (or total) with all its measures.
+     */
+    columnGroups: readonly (number | null)[];
+    /** Each group's label, as the header prints it ("Houston", "Grand Total"). */
+    groupLabels: readonly string[];
+    /** What bands name their groups by: the innermost column level, or "Measures". */
+    groupLevelLabel: string;
+    /** How the paginator may split these rows (Plan 2, L1 and L5). */
+    pageBreaks: DocumentTableRowFacts;
+} | Extract<MatrixLayoutReadResult, {
+    status: 'failed';
+}>;
+/**
+ * Formats a read once, with the definition that ran. The Document section
+ * does this in its query, so every page slice shares one formatted table.
+ * The table is the one every Matrix PDF prints (`buildMatrixPrintTable`);
+ * this adds what only a Document uses, such as "(cont.)" labels.
+ */
+export declare function formatMatrixLayoutRead(result: MatrixLayoutReadResult, report: ReportRuntimeContext): DocumentMatrixRead;

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

@@ -6,6 +6,7 @@ import { BuildCardQueryContextParams, CompiledCardQueryContext } from './build-c
 import { CompiledDashboardCardFilters } from './compile-dashboard-card-filters.js';
 import { DashboardInputResolveMode } from '../dashboard-inputs/resolve-dashboard-input-context.js';
 import { prepareMatrixCard, MatrixCardCatalog } from '../matrix-table/matrix-card-adapter.js';
+import { DocumentSectionCardRuntime } from './document-section-card-query.js';
 export type DashboardExecutionSnapshot = {
     selectedSheetId: string | null;
     filterValues: TFilterValue[];
@@ -36,6 +37,12 @@ export type BuildDashboardCardExecutionSnapshotParams = Omit<BuildCardQueryConte
     /** Editor drafts replace their persisted card only for this computation. */
     cardOverride?: TCard;
     sheetId?: string | null;
+    /**
+     * Runs the target card as a Document section (tech spec G3), with the same
+     * rules as every section card's frame query. Other cards keep the dashboard
+     * runtime.
+     */
+    documentSection?: DocumentSectionCardRuntime;
 };
 export type DashboardCardExecutionSnapshot = {
     status: 'ready';
@@ -52,5 +59,5 @@ export type DashboardCardExecutionSnapshotResult = DashboardCardExecutionSnapsho
     message?: string;
 } | null;
 export declare function requireReadyDashboardCardExecutionSnapshot(result: DashboardCardExecutionSnapshotResult): DashboardCardExecutionSnapshot | null;
-export declare function buildDashboardCardExecutionSnapshot({ dashboard, cardId, transientContexts, cardViewStates, 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, documentSection, }: BuildDashboardCardExecutionSnapshotParams): DashboardCardExecutionSnapshotResult;
 export {};

package/dist/types/lib/query-context/build-dashboard-frame-base-query-contexts.d.ts

@@ -3,6 +3,7 @@ import { TFilter, TFilterValue } from '../../components/surfboard/filter/types.j
 import { ControlDefinition, DashboardInputValues, TCard, TDashboard, TFrame } from '../types/common-types.js';
 import { TransientInputContext } from '../dashboard-inputs/transient-input-context.js';
 import { CardQueryContext } from './build-card-query-context.js';
+import { CardExecution } from './card-execution.js';
 export type DashboardFrameDocumentQueryState = {
     isExplicitDocumentSectionRuntime: boolean;
     isDocumentSectionEditing: boolean;
@@ -41,7 +42,8 @@ export type BuildDashboardFrameBaseQueryContextsParams = {
     cardViewStates: CardViewStateMap | undefined;
     filteringCards?: TCard[];
     selectedSheetId?: string | null;
-    isVisualEditing: boolean;
+    /** How this call's queries run (tech spec M7). */
+    execution: CardExecution;
     getCardFrame: (cardId: string) => TFrame | undefined;
     lastRequestPayloadMap?: Map<string, Record<string, unknown>>;
     documentState: DashboardFrameDocumentQueryState;
@@ -55,4 +57,4 @@ export type DashboardFrameBaseQueryContext = CardQueryContext & {
     missingRequiredInputLabels: string[];
     dashboardInputMissingRequiredLabels: string[];
 };
-export declare function buildDashboardFrameBaseQueryContexts({ cards, dashboard, filters, dashboardControls, filterValues, controlValues, dashboardInputValues, dashboardInlineFilterValuesMap, editorInlineFilterValuesMap, dashboardCardControlValuesMap, transientContexts, cardViewStates, filteringCards, selectedSheetId, isVisualEditing, getCardFrame, lastRequestPayloadMap, documentState, }: BuildDashboardFrameBaseQueryContextsParams): DashboardFrameBaseQueryContext[];
+export declare function buildDashboardFrameBaseQueryContexts({ cards, dashboard, filters, dashboardControls, filterValues, controlValues, dashboardInputValues, dashboardInlineFilterValuesMap, editorInlineFilterValuesMap, dashboardCardControlValuesMap, transientContexts, cardViewStates, filteringCards, selectedSheetId, execution, getCardFrame, lastRequestPayloadMap, documentState, }: BuildDashboardFrameBaseQueryContextsParams): DashboardFrameBaseQueryContext[];

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

@@ -0,0 +1,30 @@
+import { SemanticExecutionPayloadAuthority } from './use-semantic-execution-payload-for-cards.js';
+/**
+ * How one card's query runs, decided once per card (tech spec M7). Every gate
+ * in `useDashboardFrameQuery` and the base query-context builder reads this
+ * instead of the global `isVisualEditing` flag.
+ */
+export type CardExecution = {
+    /** The editor shows a failed query inline; a dashboard or report throws to its boundary. */
+    errorMode: 'throw' | 'inline';
+    refetchOnInterval: boolean;
+    /**
+     * `editor`: config cards run unless the editor is in dev mode, and dev mode
+     * uses the card's own connection. `runtime`: any card with a connection and
+     * SQL or a valid config runs.
+     */
+    gating: 'editor' | 'runtime';
+    /** `editor` waits for fresh semantic metadata before querying. */
+    metadataAuthority: SemanticExecutionPayloadAuthority;
+    /** `editorSnapshot`: the editor's inline filter values and the document inputs captured when it opened. */
+    inputSource: 'host' | 'editorSnapshot';
+};
+/**
+ * - `isEditorPreview`: the card renders inside `<Editor>`.
+ * - `requestedAuthority`: the caller's explicit choice. Inside the editor some
+ *   components query with runtime metadata, so it is kept as is.
+ */
+export declare function resolveCardExecution({ isEditorPreview, requestedAuthority, }: {
+    isEditorPreview: boolean;
+    requestedAuthority?: SemanticExecutionPayloadAuthority;
+}): CardExecution;

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

@@ -0,0 +1,37 @@
+import { TFilterValue } from '../../components/surfboard/filter/types.js';
+import { DashboardInputRuntimeValues } from '../dashboard-inputs/resolve-dashboard-input-context.js';
+import { ControlDefinition, DashboardInputValues, TCard, TDashboard } from '../types/common-types.js';
+import { BuildCardQueryContextParams } from './build-card-query-context.js';
+/** What a Document sheet resolved for one section, as one card's query sees it. */
+export type DocumentSectionCardRuntime = {
+    sheetId: string | undefined;
+    sectionId: string | undefined;
+    documentFilterValues: TFilterValue[];
+    documentControlDefinitions: ControlDefinition[];
+    documentControlValues: Record<string, unknown>;
+    /** The page's own input values; the editor's query uses the dashboard's. */
+    documentDashboardInputValues?: DashboardInputValues;
+    /** The editor's card filters, for the editor's query of the card it edits. */
+    editorFilterValues?: TFilterValue[];
+    /** `editor` for the editor's query of the card it edits, else `print`. */
+    mode: 'print' | 'editor';
+};
+/**
+ * The `buildCardQueryContext` inputs for a card that runs as a Document
+ * section. A section is its own runtime:
+ * - nothing is carried in (no transient contexts, no drill state);
+ * - the dashboard's toolbar filters and controls do not apply;
+ * - the section's scoped dashboard inputs apply when the dashboard has any,
+ *   otherwise the document's filter and control values do.
+ *
+ * The one owner of these rules, for frame queries and the Matrix execution
+ * snapshot alike.
+ */
+export declare function buildDocumentSectionCardQueryParams({ card, dashboard, runtime, dashboardRuntimeValues, timezone, }: {
+    card: TCard;
+    dashboard: TDashboard;
+    runtime: DocumentSectionCardRuntime;
+    /** The dashboard's runtime values, which scoped input resolution reads. */
+    dashboardRuntimeValues: Omit<DashboardInputRuntimeValues, 'cardViewState'>;
+    timezone?: string;
+}): Omit<BuildCardQueryContextParams, 'selectedSheetId' | 'includeAuthoredFilters'>;

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

@@ -6,6 +6,8 @@ import { DashboardAIContext } from '../types/assistant-types.js';
 import { FilterGroup, Field } from '../types/explorer-types.js';
 import { DashboardControlsModelOptions } from '../controls/control-authoring-types.js';
 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 { DocumentFilterMode } from '../document/document-input-runtime.js';
 import { DashboardInputRuntimeTarget } from '../dashboard-inputs/dashboard-input-values.js';
 import { DashboardFilterMappingAuthoringIssue, DashboardFilterInputAcceptanceResult, DashboardFilterMappingAcceptanceResult, DashboardFilterMappingAuthoringRequest, DashboardFilterMappingDisableResult } from '../dashboard-inputs/dashboard-filter-mapping-authoring.js';
@@ -61,8 +63,8 @@ export type DashboardStore = {
     selectedFrameId?: string | null;
     selectedCardId?: string | null;
     selectedCard?: TCard | null;
-    selectedDocumentSectionIdsBySheetId: Record<string, string | null>;
-    documentInspectorTabsBySheetId: Record<string, DocumentInspectorTab>;
+    /** What each Document sheet's side panel shows; also its section selection. */
+    documentPanelTargetBySheetId: Record<string, DocumentPanelTarget>;
     documentInputRuntimeBySheetId: Record<string, DocumentInputRuntimeState>;
     /**
      * Pending sheet-wide frame rewrites produced while visual editing. These stay
@@ -139,7 +141,6 @@ export type DashboardStore = {
     onRemoveCard?: (card: TCard, sheetId: string) => void;
     actions: Actions;
 };
-export type DocumentInspectorTab = 'section' | 'page' | 'header' | 'footer' | 'inputs';
 export type DocumentInputRuntimeState = {
     filterValuesByInputId: Record<string, TFilterValue | undefined>;
     filterModesByInputId: Record<string, DocumentFilterMode>;
@@ -227,11 +228,14 @@ type Actions = {
     deleteSheet: (sheetId: string) => void;
     setSheetTitle: (sheetId: string, title: string) => void;
     updateSheetDocument: (sheetId: string, updater: (document: DocumentDefinition) => DocumentDefinition) => void;
-    updateDocumentSectionCard: (sheetId: string, sectionId: string, card: TCard, options?: {
-        calculatedFields?: Field[];
-    }) => void;
-    setSelectedDocumentSectionId: (sheetId: string, sectionId: string | null) => void;
-    setDocumentInspectorTab: (sheetId: string, tab: DocumentInspectorTab) => void;
+    /**
+     * The one write for a Document's sections (see `applyDocumentEdit`).
+     * Persists the edited document, any sheet calculated fields a copy brought,
+     * and card reference cleanup. Throws `DocumentEditError` for a refused edit
+     * without changing state.
+     */
+    editDocument: (sheetId: string, edit: DocumentEdit) => DocumentEditResult;
+    setDocumentPanelTarget: (sheetId: string, target: DocumentPanelTarget) => void;
     setDocumentInputFilterValues: (sheetId: string, valuesByInputId: Record<string, TFilterValue | undefined>) => void;
     setDocumentInputFilterValue: (sheetId: string, inputId: string, filterValue: TFilterValue) => void;
     removeDocumentInputFilterValue: (sheetId: string, inputId: string) => void;

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

@@ -28,6 +28,8 @@ export type EditorContext = {
     sheetId: string;
     sectionId: string;
     cardId: string;
+    /** The card type at open. The section's kind cannot change in the editor. */
+    lockedKind: TChartType;
     documentFilterValues?: TFilterValue[];
     documentControlDefinitions?: ControlDefinition[];
     documentControlValues?: Record<string, unknown>;

package/dist/types/lib/table-formatting/table-presentation-fields.d.ts

@@ -10,6 +10,7 @@ export type TableFieldLookup = {
     fieldRole?: QueryColumnKeyRole;
     columnKeyMap?: QueryColumnKeyMap;
 };
+/** True when the field authors a format for numeric values (numeric or duration). */
 export declare function hasNumericFieldFormat(field: Pick<PresentationField, 'format'> | undefined): boolean;
 /** Resolve identity before presentation. A supplied map is authoritative; names
  * and labels are only a unique-match adapter for results without bindings. */

package/dist/types/lib/text-variables/text-variable-types.d.ts

@@ -0,0 +1,39 @@
+/** What kind of value a variable holds; picks the chip's icon. */
+export type TextVariableKind = 'filter' | 'date' | 'control' | 'report';
+/** How one variable reference reads as a chip. */
+export type TextVariableChipFace = {
+    /** The input's name ("State"), or "Missing input". */
+    name: string;
+    kind: TextVariableKind;
+    /** Shown after the name when the chip shows a part other than the default. */
+    partLabel?: string;
+    /** The reference points at an input that no longer exists. */
+    missing?: boolean;
+};
+/** One part of an input a chip can show, with what it holds now. */
+export type TextVariablePart = {
+    key: string;
+    label: string;
+    preview?: string;
+};
+/** One input (or report value) the picker offers. */
+export type TextVariableOption = {
+    id: string;
+    name: string;
+    kind: TextVariableKind;
+    parts: TextVariablePart[];
+    defaultPart: string;
+};
+/** What a chip shows: an option and one of its parts. */
+export type TextVariableSelection = {
+    optionId: string;
+    part: string;
+};
+export declare const TEXT_VARIABLE_PART_LABELS: Record<string, string>;
+/** The picker's groups, in order. */
+export declare function textVariableGroup(kind: TextVariableKind): "Filters" | "Controls" | "Report";
+/**
+ * Options whose name matches `query`, in the picker's order: filters, then
+ * controls, then report values.
+ */
+export declare function filterTextVariableOptions(options: readonly TextVariableOption[], query: string): TextVariableOption[];

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

@@ -1435,7 +1435,7 @@ export type DocumentTextStyle = {
     color?: string;
     align?: 'left' | 'center' | 'right';
 };
-export type DocumentSection = DocumentTextSection | DocumentTableSection | DocumentChartSection | DocumentSpacerSection | DocumentPageBreakSection;
+export type DocumentSection = DocumentTextSection | DocumentTableSection | DocumentKpiSection | DocumentChartSection | DocumentSpacerSection | DocumentPageBreakSection;
 export type DocumentTextSection = {
     id: string;
     type: 'text';
@@ -1452,6 +1452,39 @@ export type DocumentTableSection = {
         columnFormatting?: Record<string, unknown>;
         repeatHeaderOnPageBreak?: boolean;
         rowHeightPx?: number;
+        /** Print nothing, and take no space, while the result is empty (Plan 2). */
+        hideWhenEmpty?: boolean;
+        /** Matrix sections only: how the Document prints the Matrix (Plan 2). */
+        matrix?: {
+            /** `tabular`: one column per row level. `outline`: one indented column. */
+            rowLabels?: 'tabular' | 'outline';
+            /** Where each group's subtotal prints. */
+            subtotals?: 'after' | 'before';
+            /**
+             * A Matrix too wide for the page prints in column bands. `across`: each
+             * slice of rows prints in every band before the next slice. `down`:
+             * each band runs through every row before the next band.
+             */
+            bandOrder?: 'across' | 'down';
+        };
+    };
+};
+/**
+ * Headline numbers. Each card is an ordinary `kpi` card with its own query.
+ * Read and rewrite its cards through `getDocumentSectionCards` and
+ * `mapDocumentSectionCards` (`react-semaphor/dashboard-authoring`).
+ */
+export type DocumentKpiSection = {
+    id: string;
+    type: 'kpi';
+    title?: string;
+    /** 1 to 8 cards, each `card.type === 'kpi'`, with unique ids. Order is display order. */
+    cards: TCard[];
+    kpi: {
+        /** `tiles` holds at most 6 cards; a section with more uses `lines`. */
+        layout: 'tiles' | 'lines';
+        /** Used by `lines`, default 2. Kept but ignored on `tiles`. */
+        columns?: 1 | 2;
     };
 };
 export type DocumentChartSection = {

package/dist/types/lib/utils/card-definition.d.ts

@@ -43,6 +43,7 @@ export declare function getCardDefinition(card: DefinitionCard, catalog?: Matrix
                         position: "before" | "after";
                         label?: string | undefined;
                     }>>;
+                    skipRedundant?: boolean | undefined;
                 };
                 rows: {
                     grand: {
@@ -55,6 +56,7 @@ export declare function getCardDefinition(card: DefinitionCard, catalog?: Matrix
                         position: "before" | "after";
                         label?: string | undefined;
                     }>>;
+                    skipRedundant?: boolean | undefined;
                 };
             };
             layout: {

package/dist/types/lib/utils/card-utils.d.ts

@@ -2,19 +2,20 @@ import { TDashboard, TCard, TSheet } from '../types/common-types.js';
 export type DashboardCardEntry = {
     card: TCard;
     sheet: TSheet;
-};
-export declare function getDashboardCardEntries(dashboard: Pick<TDashboard, 'sheets'>): DashboardCardEntry[];
-export type DashboardCardLocation = DashboardCardEntry & {
-    /** Set when the card is the visual of a document section. */
+    /** Set when the card sits in a frame. */
+    frameId?: string;
+    /** Set when the card belongs to a document section (a section may own several cards). */
     sectionId?: string;
 };
+/** Dashboard cards: sheet cards and frame cards. Document section cards are not included. */
+export declare function getDashboardCardEntries(dashboard: Pick<TDashboard, 'sheets'>): DashboardCardEntry[];
 /**
  * Every card a dashboard hosts, with where it sits: sheet cards, frame cards,
- * and the table or chart of a document section. Use this, not
+ * and every card of a document section. Use this, not
  * `getDashboardCardEntries`, when a card may be reached by a scope that names
  * document sections.
  */
-export declare function getDashboardCardLocations(dashboard: Pick<TDashboard, 'sheets'>): DashboardCardLocation[];
+export declare function getDashboardCardLocations(dashboard: Pick<TDashboard, 'sheets'>): DashboardCardEntry[];
 export declare function getDashboardCards(dashboard: Pick<TDashboard, 'sheets'>): TCard[];
 /**
  * Check if a card ID is unique across the entire dashboard
@@ -53,6 +54,12 @@ export declare function getAllCardIds(dashboard: TDashboard): string[];
  * @returns The card if found, undefined otherwise
  */
 export declare function findCardById(dashboard: TDashboard, cardId: string): TCard | undefined;
+/**
+ * A dashboard card (sheet or frame) by id. Document section cards are not
+ * included: they need their section for input resolution, so they are found
+ * through section-aware lookups (for example the dashboard input snapshot's
+ * section targets). Phase 1.2 routes KPI card execution through those.
+ */
 export declare function findCardLocationById(dashboard: TDashboard, cardId: string): {
     card: TCard;
     sheet: TSheet;

package/dist/types/lib/utils/date-timezone-utils.d.ts

@@ -8,9 +8,13 @@ import { CalendarContext, WeekStart } from '../types/token-types.js';
  * @returns A Date object representing midnight in the specified timezone
  *
  * @example
- * // User in PST selects Nov 18, 2025
- * startOfDayInTimezone(new Date('2025-11-18'), 'America/Los_Angeles')
+ * // Nov 18, 2025 14:30 PST
+ * startOfDayInTimezone(new Date('2025-11-18T22:30:00Z'), 'America/Los_Angeles')
  * // Returns a Date that serializes to: 2025-11-18T08:00:00.000Z (Nov 18 00:00 PST)
+ *
+ * Do not pass `new Date('YYYY-MM-DD')`: that is UTC midnight, which is the
+ * previous day in zones west of UTC. Use `parseFilterDateValue` for
+ * date-only strings.
  */
 export declare const startOfDayInTimezone: (date: Date, timezone: string) => Date;
 /**
@@ -22,11 +26,29 @@ export declare const startOfDayInTimezone: (date: Date, timezone: string) => Dat
  * @returns A Date object representing 23:59:59.999 in the specified timezone
  *
  * @example
- * // User in PST selects Nov 20, 2025
- * endOfDayInTimezone(new Date('2025-11-20'), 'America/Los_Angeles')
+ * // Nov 20, 2025 14:30 PST
+ * endOfDayInTimezone(new Date('2025-11-20T22:30:00Z'), 'America/Los_Angeles')
  * // Returns a Date that serializes to: 2025-11-21T07:59:59.999Z (Nov 20 23:59:59 PST)
  */
 export declare const endOfDayInTimezone: (date: Date, timezone: string) => Date;
+/**
+ * Parses a stored date filter value into the instant the date pickers would
+ * have written for it.
+ *
+ * Filter values are usually instants, but date-only strings (`YYYY-MM-DD`)
+ * also arrive from SDK/embed defaults, generated dashboards and inputs. A
+ * date-only string names a calendar day, not an instant: it maps to the start
+ * (or, for an upper bound, the end) of that day in `timezone`, exactly as
+ * `startOfDayInTimezone` / `endOfDayInTimezone` produce for a picked day.
+ * `new Date('YYYY-MM-DD')` would instead give UTC midnight, which displays as
+ * the previous day in zones west of UTC.
+ *
+ * Everything else parses as an instant. Returns undefined for empty or
+ * unparseable values, including `YYYY-MM-DD` strings that name no calendar
+ * day (which `new Date` would silently roll into the next month). A missing timezone falls back to the browser zone, as
+ * `getEffectiveTimezone` does.
+ */
+export declare const parseFilterDateValue: (value: unknown, timezone: string | null | undefined, bound?: "start" | "end") => Date | undefined;
 /**
  * Gets the start of week (midnight) for a date in the specified timezone.
  *

package/dist/types/pdf-table-layout.d.ts

@@ -0,0 +1,2 @@
+export * from './shared/format-utils/pdf-table-layout/index.js'
+export {}

package/dist/types/shared/analytics-protocol/index.d.ts

@@ -26,7 +26,7 @@ export * from './matrix-window-contract.js';
 export * from './matrix-member-presentation.js';
 export { matrixFormattingRoleSchema, type MatrixFormattingRole } from './matrix-path-contract.js';
 export { getMatrixAnalyticalDefinition } from './matrix-analytical-definition.js';
-export { matrixAxisSchema, matrixAggregateSchema, matrixFieldSchema, matrixLevelSchema, matrixMeasureSchema, matrixMemberSchema, matrixPathSchema, matrixCoordinateSchema, matrixSortTargetSchema, matrixSortSchema, matrixRankingSchema, matrixPathKey, matrixSortKey, matrixSpecSchema, matrixTotalPresentationSchema, matrixPresentationSchema, matrixExpansionSchema, matrixDefaultViewSchema, matrixViewStateSchema, matrixDefinitionInputSchema, matrixConfigSchema, matrixExportRequestSchema, } from './matrix-definition-contract.js';
+export { matrixAxisSchema, matrixAggregateSchema, matrixFieldSchema, matrixLevelSchema, matrixMeasureSchema, matrixMemberSchema, matrixPathSchema, matrixCoordinateSchema, matrixSortTargetSchema, matrixSortSchema, matrixRankingSchema, matrixPathKey, matrixSortKey, matrixSpecSchema, matrixTotalPresentationSchema, MATRIX_TOTAL_MEMBER_PLACEHOLDER, matrixPresentationSchema, matrixExpansionSchema, matrixDefaultViewSchema, matrixViewStateSchema, matrixDefinitionInputSchema, matrixConfigSchema, matrixExportRequestSchema, } from './matrix-definition-contract.js';
 export type { MatrixLevelId, MatrixMeasureId, MatrixAxis, MatrixAggregate, MatrixField, MatrixLevel, MatrixMeasure, MatrixMember, MatrixPath, MatrixCoordinate, MatrixSortTarget, MatrixSort, MatrixRanking, MatrixSpec, MatrixTotalPresentation, MatrixPresentation, MatrixExpansion, MatrixViewState, MatrixConfig, MatrixDefinitionInput, MatrixExportRequest, } from './matrix-definition-contract.js';
 export * from './matrix-operation-contract.js';
 export { configSourceRefSchema } from './execution-input-schemas.js';