@bitcobblers/wod-wiki-wql 0.51.2196 → 0.53.2203

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import { LRParser } from '@lezer/lr';
 import { LanguageSupport, HighlightStyle, LRLanguage } from '@codemirror/language';
 import { Completion, CompletionContext, CompletionResult } from '@codemirror/autocomplete';
 import { Extension } from '@codemirror/state';
-import { SummaryCoverage, BlockIndexRow, Note, EventRecord, PageNote, Page, NotePlacement, AnalyticsDataPoint, FeedId, NotebookId, NotebookOrigin, ResultOrigin, StoredOutputStatement, NoteBlockChange } from '@bitcobblers/wod-wiki-core';
+import { SummaryCoverage, BlockIndexRow, Note, EventRecord, FeedSourceCatalogRow, FeedNotebookCatalogRow, PageNote, Page, NotePlacement, AnalyticsDataPoint, FeedId, NotebookId, NotebookOrigin, ResultOrigin, StoredOutputStatement, NoteBlockChange } from '@bitcobblers/wod-wiki-core';
 export { DEFAULT_NOTEBOOK_SLUGS, DefaultNotebookSlug, FeedId, LinkWidget, NotebookId, NotebookOrigin, ParsedFrontmatter, SYSTEM_DEFAULT_OUTPUT_UNIT, TypedTagItem, UnitConversionError, convertViaCatalog, dimensionKeyOf, extractFrontmatterTags, extractTypedFrontmatterTags, getList, getScalar, isNoteEditable, lookupUnit, notebookSlugFromId, parseFlatProperties, parseFrontmatter, parseFrontmatterBody, parseFrontmatterCategories, parseFrontmatterProps, serializeFrontmatter, stripFrontmatter, systemDefaultUnit, toNotebookId } from '@bitcobblers/wod-wiki-core';
 import { IEffort } from '@bitcobblers/wod-wiki-lang';
 export { IEffort } from '@bitcobblers/wod-wiki-lang';
@@ -76,7 +76,7 @@ type WqlGrain = (typeof WQL_GRAINS)[number];
  *  planes (ticket 08) are first-class targets: `:notebook{}` lists the
  *  notes across every notebook, `:page{}` the page placements, `:tag{}` the tags,
  *  `:equipment{}` the equipment notes — the latter two resolve to notes. */
-declare const WQL_FIND_TARGETS: readonly ["note", "block", "effort", "session", "segment", "event", "notebook", "page", "tag", "equipment"];
+declare const WQL_FIND_TARGETS: readonly ["note", "block", "effort", "session", "segment", "event", "notebook", "page", "tag", "equipment", "feed"];
 type WqlFindTarget = (typeof WQL_FIND_TARGETS)[number];
 /** Canonical source filter values: the allowed storage locations. Corpus-
  *  delivered notes carry `notebook:<slug>` source ids, so `notebooks` spans
@@ -91,7 +91,7 @@ type WqlSourceValue = (typeof WQL_SOURCE_VALUES)[number];
  *  container planes (targets of their own name). `:notebook{}` stays a NOTE
  *  plane (ticket 05): it returns every notebook's notes, delegating to the
  *  note executor. */
-declare const WQL_SOURCE_HEADS: readonly ["note", "notes", "block", "effort", "session", "segment", "event", "journal", "notebook", "notebooks", "playground", "page", "tag", "equipment", "dashboard"];
+declare const WQL_SOURCE_HEADS: readonly ["note", "notes", "block", "effort", "session", "segment", "event", "journal", "notebook", "notebooks", "playground", "page", "tag", "equipment", "feed", "feeds", "dashboard"];
 type WqlSourceHead = (typeof WQL_SOURCE_HEADS)[number];
 /** Storage scope a source-scoped note head binds (undefined = plain target). */
 declare const WQL_SOURCE_HEAD_SCOPES: Readonly<Record<string, WqlSourceValue>>;
@@ -112,11 +112,11 @@ declare const WQL_NOTE_DEFAULT_SOURCES: readonly WqlSourceValue[];
 declare const WQL_FUNCTION_HEADS: readonly ["sum", "avg", "min", "max", "count", "last", "delta"];
 type WqlFunctionHead = WqlAggregator;
 /** Colon chart heads — terminal pipeline sinks (`:timeseries`, `:bar`, …). */
-declare const WQL_CHART_HEADS: readonly ["timeseries", "bar", "table", "donut", "toplist", "value"];
+declare const WQL_CHART_HEADS: readonly ["timeseries", "bar", "stacked-bar", "table", "list", "donut", "toplist", "value", "goal-rings", "zone-distribution"];
 type WqlChartHead = (typeof WQL_CHART_HEADS)[number];
 /** Standard datasets the host registers per page/run before children
  *  evaluate (`@session` active session, `@today` civil-day telemetry+notes). */
-declare const WQL_STANDARD_DATASETS: readonly ["@session", "@today"];
+declare const WQL_STANDARD_DATASETS: readonly ["@session", "@today", "@note"];
 type WqlStandardDataset = (typeof WQL_STANDARD_DATASETS)[number];
 /** Result planes — `rows:<plane>` narrows raw output-statement rows by the
  *  unified store's promoted `outputType` column. The STORE vocabulary is
@@ -141,7 +141,7 @@ type WqlContentFilterKey = (typeof WQL_CONTENT_FILTER_KEYS)[number];
  * deliberately absent — it needs new grammar/engine semantics and is
  * deferred to its own ticket.
  */
-declare const WQL_SOURCES: readonly ["note", "block", "effort", "session", "segment", "event", "notebook", "page", "tag", "equipment"];
+declare const WQL_SOURCES: readonly ["note", "block", "effort", "session", "segment", "event", "notebook", "page", "tag", "equipment", "feed"];
 type WqlSource = WqlFindTarget;
 /** Rollup periods the aggregate grammar accepts (wql.ts: N > 1, unit d|w). */
 declare const WQL_ROLLUP_PERIODS: readonly ["2w", "4w"];
@@ -181,28 +181,31 @@ declare const Head = 4;
 declare const Word = 5;
 declare const Aggregator$1 = 6;
 declare const Metric = 7;
-declare const Filters = 8;
-declare const Filter = 9;
-declare const Negate = 10;
-declare const TagKey = 11;
-declare const TagValue$1 = 12;
-declare const Value = 13;
-declare const Star = 14;
-declare const Quoted = 15;
-declare const DatasetReference = 16;
-declare const At = 17;
-declare const Single = 18;
-declare const GroupBy = 19;
-declare const By = 20;
-declare const Dimension = 21;
-declare const Rollup = 22;
-declare const RollupDot = 23;
-declare const Int = 24;
+declare const ParamRef = 8;
+declare const Dollar = 9;
+declare const Filters = 10;
+declare const Filter = 11;
+declare const Negate = 12;
+declare const TagKey = 13;
+declare const TagValue$1 = 14;
+declare const Value = 15;
+declare const Star = 16;
+declare const Quoted = 17;
+declare const DatasetReference = 18;
+declare const At = 19;
+declare const Single = 20;
+declare const GroupBy = 21;
+declare const By = 22;
+declare const Dimension = 23;
+declare const Rollup = 24;
+declare const RollupDot = 25;
+declare const Int = 26;
 
 declare const wql_parser_terms_At: typeof At;
 declare const wql_parser_terms_By: typeof By;
 declare const wql_parser_terms_DatasetReference: typeof DatasetReference;
 declare const wql_parser_terms_Dimension: typeof Dimension;
+declare const wql_parser_terms_Dollar: typeof Dollar;
 declare const wql_parser_terms_Filter: typeof Filter;
 declare const wql_parser_terms_Filters: typeof Filters;
 declare const wql_parser_terms_GroupBy: typeof GroupBy;
@@ -210,6 +213,7 @@ declare const wql_parser_terms_Head: typeof Head;
 declare const wql_parser_terms_Int: typeof Int;
 declare const wql_parser_terms_Metric: typeof Metric;
 declare const wql_parser_terms_Negate: typeof Negate;
+declare const wql_parser_terms_ParamRef: typeof ParamRef;
 declare const wql_parser_terms_Pipeline: typeof Pipeline;
 declare const wql_parser_terms_Query: typeof Query;
 declare const wql_parser_terms_Quoted: typeof Quoted;
@@ -222,7 +226,7 @@ declare const wql_parser_terms_TagKey: typeof TagKey;
 declare const wql_parser_terms_Value: typeof Value;
 declare const wql_parser_terms_Word: typeof Word;
 declare namespace wql_parser_terms {
-  export { Aggregator$1 as Aggregator, wql_parser_terms_At as At, wql_parser_terms_By as By, wql_parser_terms_DatasetReference as DatasetReference, wql_parser_terms_Dimension as Dimension, wql_parser_terms_Filter as Filter, wql_parser_terms_Filters as Filters, wql_parser_terms_GroupBy as GroupBy, wql_parser_terms_Head as Head, wql_parser_terms_Int as Int, wql_parser_terms_Metric as Metric, wql_parser_terms_Negate as Negate, wql_parser_terms_Pipeline as Pipeline, wql_parser_terms_Query as Query, wql_parser_terms_Quoted as Quoted, wql_parser_terms_Rollup as Rollup, wql_parser_terms_RollupDot as RollupDot, wql_parser_terms_Single as Single, wql_parser_terms_Stage as Stage, wql_parser_terms_Star as Star, wql_parser_terms_TagKey as TagKey, TagValue$1 as TagValue, wql_parser_terms_Value as Value, wql_parser_terms_Word as Word };
+  export { Aggregator$1 as Aggregator, wql_parser_terms_At as At, wql_parser_terms_By as By, wql_parser_terms_DatasetReference as DatasetReference, wql_parser_terms_Dimension as Dimension, wql_parser_terms_Dollar as Dollar, wql_parser_terms_Filter as Filter, wql_parser_terms_Filters as Filters, wql_parser_terms_GroupBy as GroupBy, wql_parser_terms_Head as Head, wql_parser_terms_Int as Int, wql_parser_terms_Metric as Metric, wql_parser_terms_Negate as Negate, wql_parser_terms_ParamRef as ParamRef, wql_parser_terms_Pipeline as Pipeline, wql_parser_terms_Query as Query, wql_parser_terms_Quoted as Quoted, wql_parser_terms_Rollup as Rollup, wql_parser_terms_RollupDot as RollupDot, wql_parser_terms_Single as Single, wql_parser_terms_Stage as Stage, wql_parser_terms_Star as Star, wql_parser_terms_TagKey as TagKey, TagValue$1 as TagValue, wql_parser_terms_Value as Value, wql_parser_terms_Word as Word };
 }
 
 /**
@@ -242,9 +246,10 @@ interface ParsedWqlRollupSuffix {
     unit: string;
     raw: string;
 }
-/** A window clause (C1): relative (`last 8w`) or civil-date range
- *  (`from 2026-01-01 [to 2026-03-31]`). One window per query — `last` and
- *  `from` are mutually exclusive (validated as a C3-style conflict). */
+/** A window clause (C1): relative (`last 8w`), civil-date range
+ *  (`from 2026-01-01 [to 2026-03-31]`), or a `$param` reference (`last $range`
+ *  or `last $weeks w`). One window per query — `last` and `from` are mutually
+ *  exclusive (validated as a C3-style conflict). */
 type ParsedWqlWindowSuffix = {
     kind: 'relative';
     size: number;
@@ -255,6 +260,11 @@ type ParsedWqlWindowSuffix = {
     start: string;
     end?: string;
     raw: string;
+} | {
+    kind: 'param';
+    param: string;
+    unit?: 'd' | 'w';
+    raw: string;
 };
 interface ParsedWqlSuffixes {
     /** Outer cross-store join clause text (`where ...`). */
@@ -312,8 +322,14 @@ type Aggregator = WqlAggregator;
 interface TagValue {
     value: string;
     wildcard: boolean;
+    /** Parameter name (without `$`) when authored as a `$param` atom. */
+    param?: string;
 }
 interface TagFilter {
+    /** `'spreadParam'` when authored as a bare `$param` filter (`{$scope}`); `'kv'` (default) otherwise. */
+    kind?: 'kv' | 'spreadParam';
+    /** Parameter name (without `$`) when `kind === 'spreadParam'`. */
+    param?: string;
     key: string;
     negate: boolean;
     values: TagValue[];
@@ -355,8 +371,10 @@ interface ParsedAggregateQuery {
     family: 'aggregate';
     raw: string;
     agg: Aggregator;
-    /** Canonical Metric Key (fact row `metricKey`). */
+    /** Canonical Metric Key (fact row `metricKey`), or `$param` when parameterized. */
     metric: string;
+    /** Parameter name (without `$`) when `metric` was authored as `$param`. */
+    metricParam?: string;
     filters: TagFilter[];
     /** Tag keys, or virtual dims: day | week | session | round. */
     groupBy: string[];
@@ -436,6 +454,10 @@ type QueryWindow = {
     kind: 'range';
     start: string;
     end?: string;
+} | {
+    kind: 'param';
+    param: string;
+    unit?: 'd' | 'w';
 };
 type AnyParsedQuery = ParsedAggregateQuery | ParsedFindQuery | ParsedPipelineQuery;
 /** Type guard: true for content-discovery queries. */
@@ -594,6 +616,178 @@ declare function findTargetAdvisories(query: ParsedFindQuery): string[];
 /** Serialize any parsed query to canonical WQL text. Total: never throws. */
 declare function serialize(parsed: AnyParsedQuery): string;
 
+/**
+ * First-class WQL `$param` (`ParamRef`) inspection and AST-level binding.
+ *
+ * Queries containing `$scope`, `effort:$effort`, `sum:$metric{}`, or
+ * `last $range` parse directly into typed AST nodes without pre-parse regex
+ * text substitution. At execution time, `bindQueryParams` binds active
+ * parameter values onto the AST — cleanly dropping empty optional filters
+ * (`$scope = ""`) instead of producing trailing-comma syntax errors, and
+ * routing content-only scope filters (`notebook:…`, `source:…`) on aggregate
+ * queries into a `where :note{…}` join.
+ */
+
+/**
+ * Collect all `$param` names referenced anywhere in a parsed WQL AST, in
+ * deterministic appearance order.
+ */
+declare function collectQueryParams(parsed: AnyParsedQuery): string[];
+/** Parse a filter fragment (`effort:snatch, discipline:weightlifting` or `:note{tags:pr}`) into `TagFilter[]`. */
+declare function parseFilterFragment(fragment: string): {
+    filters: TagFilter[];
+    error?: string;
+};
+/**
+ * Bind `$param` AST nodes (`ParamRef`) on a parsed query using `params`.
+ *
+ * If any referenced `$param` is absent from `params` (`params[name] === undefined`),
+ * returns `{ parsed, missing }` without mutating `parsed` so callers can surface
+ * `unknownTokensMessage(missing)`. Empty string values (`""`) are treated as
+ * "unfiltered / unset" for filter and window parameters.
+ */
+declare function bindQueryParams(parsed: AnyParsedQuery, params: Record<string, string>): {
+    parsed: AnyParsedQuery;
+    missing: string[];
+};
+
+/**
+ * Shared widget type vocabulary and legacy ```query:<type>[-<N>|-full] fence
+ * suffix parser. Kept free of `queryBlockCodec` / `dashboard/model` imports so
+ * both modules can depend on it without a cycle.
+ */
+declare const DASHBOARD_WIDGET_TYPES: readonly ["table", "list", "value", "timeseries", "bar", "donut", "toplist", "stacked-bar", "goal-rings", "zone-distribution"];
+type DashboardWidgetType = (typeof DASHBOARD_WIDGET_TYPES)[number];
+declare function isDashboardWidgetType(type: string): type is DashboardWidgetType;
+declare const DASHBOARD_GRID_MAX_COLS = 4;
+interface QueryWidgetSuffix {
+    /** Raw widget type from the tag, lowercased; '' for a bare ```query fence. */
+    type: string;
+    /** Grid column span 1..4 (`-N`). */
+    spanCols?: number;
+    /** Full-row flag (`-full`). Mutually exclusive with spanCols. */
+    spanFull?: boolean;
+    /** Presentation attributes: `key=value` tokens after the type/span
+     *  (decision 22 — positional params ride the fence tag, not the body). */
+    attributes: Record<string, string>;
+    /** Attribute order for stable re-serialization. */
+    attributeOrder: string[];
+    /** Set when the suffix is malformed (the type is still reported raw). */
+    error?: string;
+}
+/**
+ * Parse the suffix after `query:` in a fence tag — `<type>`, `<type>-<N>` or
+ * `<type>-full`. Unknown types parse fine (renderers badge them); structural
+ * problems (empty type, bad span, `-N-full` combo) set `error`.
+ */
+declare function parseQueryWidgetSuffix(suffix: string): QueryWidgetSuffix;
+
+/**
+ * queryBlockCodec — Canonical `QueryBlockObject` model and lossless YAML /
+ * 1-line shorthand codec for ```query fences.
+ *
+ * Design boundary:
+ *   - **YAML** inside ```query owns layout, presentation, titles, multi-series
+ *     composition, formulas, goals, table columns, and sorting.
+ *   - **WQL** inside `query:` / `series[].query:` (and bare 1-line shorthand
+ *     fences like `:session{result:<id>}`) owns search and data selection.
+ *
+ * Zero external runtime dependencies — safe in Web Workers, CLI, and browser.
+ */
+
+type QueryViewKind = 'table' | 'list' | 'value' | 'timeseries' | 'bar' | 'donut' | 'toplist' | 'stacked-bar' | 'goal-rings' | 'zone-distribution';
+interface QuerySeriesSpec {
+    id: string;
+    label?: string;
+    /** Standard WQL query expression (when this layer is a data query). */
+    query?: string;
+    /** Arithmetic / correlation formula referencing sibling series ids. */
+    formula?: string;
+    normalize?: string;
+    unit?: string;
+    /** When false, computed as an intermediate dependency (e.g. for a formula) without plotting. */
+    visible?: boolean;
+}
+type ScalarOrParam = number | {
+    param: string;
+};
+interface QuerySortSpec {
+    col: string;
+    dir: 'asc' | 'desc';
+}
+interface QueryBlockObject {
+    title?: string;
+    description?: string;
+    /** Active view kind (defaults to `'table'`). Unknown legacy types ride `rawViewType`. */
+    view: QueryViewKind;
+    /** Preserved raw view string when a legacy fence named an unknown widget type. */
+    rawViewType?: string;
+    span?: 1 | 2 | 3 | 4 | 'full';
+    unit?: string;
+    window?: QueryWindow;
+    groupBy?: string[];
+    /** Shorthand single WQL query when there is 1 data layer and no formula. */
+    query?: string;
+    /** Multi-layer series & formula definitions. */
+    series?: QuerySeriesSpec[];
+    /** Table presentation options. */
+    columns?: string[];
+    sort?: QuerySortSpec[];
+    limit?: number;
+    /** Chart / threshold options. */
+    goal?: ScalarOrParam;
+    targets?: ScalarOrParam[];
+    comparePr?: boolean;
+    /** Preserved extra legacy attributes. */
+    attributes?: Record<string, string>;
+    /** Malformed fence/YAML syntax error, if any. */
+    error?: string;
+}
+interface ParseQueryBlockOptions {
+    /** Optional fence tag (`query`, `query:timeseries-2 goal=$x`, or suffix `timeseries-2`). */
+    fenceTag?: string;
+    /** Legacy fallback title from an adjacent `## Heading` above the fence. */
+    adjacentTitle?: string;
+    /** Legacy fallback description/question from an adjacent paragraph above the fence. */
+    adjacentDescription?: string;
+}
+/** True when `rawBody` is authored in YAML `key: value` form (not bare WQL or legacy QueryDocument). */
+declare function isYamlQueryBlockBody(rawBody: string): boolean;
+/**
+ * Parse any ```query fence body (canonical YAML, 1-line WQL shorthand, or
+ * legacy QueryDocument + fence-tag suffix) into a canonical `QueryBlockObject`.
+ */
+declare function parseQueryBlock(rawBody: string, options?: ParseQueryBlockOptions): QueryBlockObject;
+/**
+ * True when `obj` can serialize as a zero-boilerplate 1-line WQL shorthand
+ * inside ```query (e.g. `:session{result:<id>}`) without losing any layout metadata.
+ */
+declare function isDefaultShorthandQueryBlock(obj: QueryBlockObject): boolean;
+/**
+ * Serialize a `QueryBlockObject` into the inner content of a ```query fence:
+ *   - Emits 1-line WQL shorthand when `isDefaultShorthandQueryBlock(obj)` holds;
+ *   - Otherwise emits clean, deterministic 2-space YAML.
+ */
+declare function serializeQueryBlock(obj: QueryBlockObject, opts?: {
+    forceYaml?: boolean;
+}): string;
+/** Serialize a full fenced ```query markdown block (opening fence + body + closing fence). */
+declare function serializeQueryBlockFence(obj: QueryBlockObject, opts?: {
+    forceYaml?: boolean;
+}): string;
+/**
+ * Compile a `QueryBlockObject` into an executable WQL / `QueryDocument` text
+ * consumed by `SharedQueryDocumentRunner` and `QueryService`.
+ */
+declare function queryBlockToDocumentText(obj: QueryBlockObject): string;
+/** Derive widget `attributes` map (`goal`, `targets`, `comparePr`, `label.<id>`) from `QueryBlockObject`. */
+declare function queryBlockAttributes(obj: QueryBlockObject): {
+    attributes: Record<string, string>;
+    attributeOrder: string[];
+};
+/** Collect all `$param` names referenced anywhere in a `QueryBlockObject` (queries, window, goal, targets). */
+declare function collectQueryBlockParams(obj: QueryBlockObject): string[];
+
 /**
  * Canonical discipline vocabulary — the single source of truth for effort
  * disciplines across the resolver, the TIS factor table, fact-row tags, the
@@ -703,6 +897,23 @@ interface WqlCompletionOptions {
      */
     catalog?: IFieldCatalog;
 }
+type WqlCursorStageRole = 'source' | 'reduce' | 'sink' | 'binding' | 'defaults';
+interface WqlCursorStageInfo {
+    role: WqlCursorStageRole;
+    /** 0-indexed pipeline stage index within the active line (0 = source, 1+ = reduce/sink). */
+    stageIndex: number;
+    /** 0-indexed transform index (0 for first reducer stage, 1 for second, etc.). */
+    reduceIndex?: number;
+    head?: string;
+    from: number;
+    to: number;
+}
+/**
+ * Resolve the active pipeline stage role and character range at `pos` inside
+ * a single-line or multi-line WQL document — powers WqlComposer visual stage
+ * feedback (`source` → `reduce` → `sink`).
+ */
+declare function resolveWqlCursorStage(doc: string, pos: number): WqlCursorStageInfo;
 declare function wqlCompletionSource(options_?: WqlCompletionOptions): (context: CompletionContext) => CompletionResult | Promise<CompletionResult | null> | null;
 declare function wqlCompletion(options?: WqlCompletionOptions): Extension;
 /**
@@ -843,6 +1054,10 @@ declare function resolveWindowRange(w: {
     kind: 'range';
     start: string;
     end?: string;
+} | {
+    kind: 'param';
+    param: string;
+    unit?: 'd' | 'w';
 } | undefined, ctx: ExecutionContext): ResolvedRange | undefined;
 /** Half-open membership predicate: start included, exclusive end excluded
  *  (a metric exactly at Monday midnight belongs only to the new week).
@@ -887,6 +1102,11 @@ interface DocumentAssignment {
     /** For kind 'query' — the parsed query of any family (defaults merged at run). */
     queryText?: string;
     parsed?: AnyParsedQuery;
+    /** When a pipeline starts from a previously bound assignment (`kb = bench | :sum{…}`). */
+    sourceRef?: string;
+    /** The pipe stages after `<sourceRef> |` (`:sum{…} | :bar{…}`). */
+    pipeTail?: string;
+    transformsText?: string;
     formula?: DocumentFormula;
     raw: string;
 }
@@ -894,6 +1114,8 @@ interface QueryDocument {
     defaults?: DocumentDefaults;
     assignments: DocumentAssignment[];
     show: string[];
+    /** Optional terminal chart sink on the `show` line (`show a, b | :stacked-bar{…}`). */
+    showChart?: PipelineSink;
     /** True when the body carried no document constructs (legacy single query). */
     degenerate: boolean;
 }
@@ -1121,6 +1343,11 @@ interface NoteRelationBundle {
     /** Resolved junction pages by page id. */
     pages: Page[];
 }
+interface FeedCatalogQueryStore {
+    getAllFeeds(): Promise<FeedSourceCatalogRow[]>;
+    getAllNotebooks(): Promise<FeedNotebookCatalogRow[]>;
+    getRemoteNotebookNotes?(slug: string, feedId?: string): Promise<Note[]>;
+}
 interface QueryServiceStores {
     eventStore?: EventStore;
     noteStore?: NoteQueryStore;
@@ -1132,6 +1359,10 @@ interface QueryServiceStores {
     blockEffortsStore?: {
         getAllFromIndex(index: string, key: string): Promise<any[]>;
     };
+    /** Serves equipment containment rows (`block_equipment` store). */
+    blockEquipmentStore?: {
+        getAllFromIndex(index: string, key: string): Promise<any[]>;
+    };
     /** Serves tag records (`tags` store). `getAll` backs the `:tag{}` plane;
      *  absent → the plane resolves to no rows. */
     tagsStore?: {
@@ -1170,6 +1401,8 @@ interface QueryServiceStores {
     };
     /** Optional notebook subscription checker for feed-owned notes/notebooks. */
     isNotebookSubscribed?: (feedId: string, chunkId: string) => boolean;
+    /** Distributed feed & notebook catalog seam for `:feed{}`, `:notebook{type:notebook}`, and zero-import remote previews. */
+    feedCatalogStore?: FeedCatalogQueryStore;
 }
 
 /**
@@ -1225,7 +1458,7 @@ declare function feedOfItem(item: {
  * (`seedNoteSourceId`/`chunkIdFor`) derives the sourceId from the same path
  * the importer stamps as `sourcePath`.
  */
-declare function notebookOfItem(item: {
+interface NotebookResolvableItem {
     id?: string;
     noteId?: string;
     sourceId?: string;
@@ -1236,8 +1469,16 @@ declare function notebookOfItem(item: {
     feedSourceId?: string;
     sourcePath?: string;
     notebookId?: string;
+    notebookIds?: readonly string[];
     tags?: readonly string[];
-}): NotebookId | undefined;
+}
+/**
+ * Resolve ALL notebooks an item belongs to (many-to-many).
+ * User-owned notes retain their base container (`notebook/journal` or `notebook/playground`)
+ * alongside every promoted user notebook (`notebookIds`, `notebookId`, `notebook:` tags).
+ */
+declare function notebooksOfItem(item: NotebookResolvableItem): NotebookId[];
+declare function notebookOfItem(item: NotebookResolvableItem): NotebookId | undefined;
 /**
  * Who owns the notebook a row resolves to — the editability key (ticket 05).
  * Pure over the row's own fields, and exact for every reachable state:
@@ -1251,7 +1492,7 @@ declare function notebookOfItem(item: {
  * A user-owned copy (clone) keeps its provenance stamps but resolves through
  * tier 1, so it is editable while its origin stays visible.
  */
-declare function notebookOriginOfItem(item: Parameters<typeof notebookOfItem>[0]): NotebookOrigin | undefined;
+declare function notebookOriginOfItem(item: NotebookResolvableItem): NotebookOrigin | undefined;
 declare function feedIdOfItem(item: {
     feedSourceId?: string;
     seedChunkId?: string;
@@ -1397,6 +1638,8 @@ interface QueryOptions {
     /** Captured execution context (ticket 12) — one `{instant, timeZone}`
      *  capture per document run; defaults to a fresh system capture. */
     context?: ExecutionContext;
+    /** Active `$param` bindings applied to `ParamRef` AST nodes at execution time. */
+    params?: Record<string, string>;
 }
 /** Options for `runFind` / `runFindBlock` — overrides for the parsed WQL. */
 interface FindOptions {
@@ -1409,6 +1652,12 @@ interface FindOptions {
     /** Captured execution context (ticket 12). */
     context?: ExecutionContext;
     isNotebookSubscribed?: (feedId: string, chunkId: string) => boolean;
+    /** When true (e.g. pipeline source feeding a numeric reducer), skip container/placement hydration. */
+    skipContainers?: boolean;
+    /** Active `$param` bindings applied to `ParamRef` AST nodes at execution time. */
+    params?: Record<string, string>;
+    /** When 'containers' (e.g. `/notebooks` library plane), `:notebook{…}` returns Notebook container rows instead of member Notes. */
+    notebookPlane?: 'notes' | 'containers';
 }
 interface QueryResult {
     parsed: ParsedAggregateQuery;
@@ -1484,7 +1733,9 @@ declare class QueryService {
     private readonly relationStore?;
     private readonly datasetStore?;
     private readonly isNotebookSubscribed?;
+    private readonly feedCatalogStore?;
     private blockEffortsStore;
+    private blockEquipmentStore;
     private tagsStore;
     private noteTagsStore;
     constructor(storesOrEventStore?: QueryServiceStores | EventStore, noteStore?: NoteQueryStore, blockStore?: BlockQueryStore, effortStore?: EffortQueryStore);
@@ -1553,6 +1804,19 @@ declare class QueryService {
      *  stages look up `pageSources` (then an injected datasetStore)
      *  synchronously; no database roundtrip. */
     runPipelineParsed(parsed: AnyParsedQuery, options?: PipelineOptions): Promise<PipelineResult>;
+    /**
+     * Evaluate pipeline tail stages (`:sum{…} | :bar{…}`) over an already-fetched
+     * `FindQueryResult` (or `FamilyRunPayload`). Resolves and caches `content.events`
+     * on the first call so multiple downstream named branches (`kb = bench | :sum{…}`,
+     * `bb = bench | :sum{…}`) share the exact `EventRecord[]` slice in memory.
+     */
+    runPipelineFromFind(content: {
+        notes?: Note[];
+        blocks?: BlockIndexRow[];
+        events?: EventRecord[];
+        runs?: RowsRun[];
+        table?: TabularResult;
+    }, pipeTail: string, options?: PipelineOptions): Promise<PipelineResult>;
     /** Events behind a content source — resolved ONLY when a transform needs
      *  them: session/table sources already carry their rows; note sources read
      *  the per-note index; block sources read the content index. */
@@ -1589,10 +1853,12 @@ declare class QueryService {
     private noteContentMap;
     /** Collect wod blockContentIds owned by a find query's content matches. */
     private contentIdsFromFindResult;
-    /** Load note tag labels only when the query touches 'tags'. Batched when
-     *  a relationStore is injected — one bundle read per run instead of a
-     *  junction read per row's note. */
-    private loadNoteTags;
+    /**
+     * Load 3-tier fact dimensions (`noteTags`, `typedNoteTags`, `effortsBySlug`)
+     * in at most one batched `relationStore.getBatches` call and one
+     * `effortStore.getAllEfforts` call per query run.
+     */
+    private loadFactDimensions;
     /** Resolve matching note IDs for an exercise slug via the block_efforts containment index. */
     private getNoteIdsForEffort;
     /** Resolve matching note IDs for a canonical typed tag (e.g. equipment:kettlebell). */
@@ -1609,6 +1875,17 @@ declare class QueryService {
      * management surface) is the app's NotebookService model, not WQL rows.
      */
     runFindNotebook(parsed: ParsedFindQuery, options?: FindOptions): Promise<FindQueryResult>;
+    /**
+     * Execute `:feed{}` — the distributed Feed sources plane.
+     * Returns one synthetic Note-shaped row per registered Feed source
+     * (including "My Published Feed" when local public content or server snapshot exists).
+     */
+    runFindFeed(parsed: ParsedFindQuery, _options?: FindOptions): Promise<FindQueryResult>;
+    /**
+     * Execute `:notebook{type:notebook, ...}` — the Notebook container listing
+     * across user-owned local notebooks and manifest-discovered remote Feed notebooks.
+     */
+    private runFindNotebookContainers;
     /**
      * Execute a :page query (ticket 08) — the placement plane. Results are
      * the placed notes; `placements` carries every page each note sits on
@@ -1720,6 +1997,7 @@ interface DocumentOutput {
 interface DocumentResult {
     outputs: DocumentOutput[];
     diagnostics: string[];
+    showChart?: PipelineSink;
 }
 /** Payload surfaces the ticket-19 family dispatch may hand back. */
 interface FamilyRunPayload {
@@ -1728,6 +2006,7 @@ interface FamilyRunPayload {
     notes?: Note[];
     blocks?: BlockIndexRow[];
     efforts?: unknown[];
+    events?: EventRecord[];
     containers?: Record<string, NoteContainer>;
     placements?: Record<string, NotePlacement[]>;
     runs?: RowsRun[];
@@ -1746,6 +2025,9 @@ interface QueryDocumentRunnerOptions {
     /** Pipeline queries (`:source | :fn | :chart`, `@dataset | …`) surface
      *  the pipeline result — the host's QueryService.runPipeline. */
     runPipeline?: (queryText: string) => Promise<FamilyRunPayload>;
+    /** Evaluate pipeline tail stages (`:sum{…} | :bar{…}`) over an already-evaluated find payload (shared source DAG). */
+    runPipelineFromFind?: (sourceFind: FamilyRunPayload, pipeTail: string) => Promise<FamilyRunPayload>;
+    runAggregateEvents?: (queryText: string, events: readonly EventRecord[], sourceFind?: FamilyRunPayload) => Promise<FamilyRunPayload>;
 }
 declare class QueryDocumentRunner$1 {
     private readonly runAggregate;
@@ -1825,11 +2107,14 @@ interface QueryDocumentRunnerHost {
         runs?: RowsRun[];
         table?: TabularResult;
         unit?: string;
+        events?: EventRecord[];
         error?: string;
     }>;
     /** Pipeline execution (`:source | :fn | :chart`, `@dataset | …`) — the
      *  host's QueryService.runPipeline. */
     runPipeline?(queryText: string, context?: ExecutionContext): Promise<FamilyRunPayload>;
+    /** Evaluate pipeline tail stages over an already-evaluated find payload (shared source DAG). */
+    runPipelineFromFind?(sourceFind: FamilyRunPayload, pipeTail: string, context?: ExecutionContext): Promise<FamilyRunPayload>;
     /** Injected formula evaluator override (engine/app composition adapts
      *  lang's calc evaluator); the built-in pointwise evaluator otherwise. */
     formulaEvaluator?: FormulaEvaluator;
@@ -1924,16 +2209,6 @@ interface SummaryFactSourceOutput {
 declare function normalizeSummaryFacts(logs: readonly SummaryFactSourceOutput[], identity: SummaryFactIdentity): AnalyticsDataPoint[];
 /** Identity for unified event-row emission — same fields as the fact identity. */
 type EventRowIdentity = SummaryFactIdentity;
-/**
- * Logs → event rows, 1:1 per statement (ticket 002). Deterministic ids
- * `${resultId}:${seq}`; query-critical scalars promoted top-level.
- *
- * Ticket 12 temporal anchoring: the row timestamp is the statement's OWN
- * timeSpan start when it has one — the workout-start timestamp never
- * relocates a metric observation whose own instant differs. Statements with
- * a timeSpan carry per-metric temporal anchors ('instant') so projection
- * groups each observation under its own date.
- */
 declare function toEventRows(logs: readonly StoredOutputStatement[], identity: SummaryFactIdentity): EventRecord[];
 /**
  * Tier-2 analytics outputs → deterministic summary event rows (tickets
@@ -1949,7 +2224,12 @@ declare function toSummaryEventRows(logs: readonly StoredOutputStatement[], iden
  * from the row's label metric as fallback. Deterministic fact ids:
  * `${record.id}:${factOrdinal}`.
  */
+interface ProjectEventToFactsFilter {
+    metricKey?: string;
+}
+declare function matchesFactMetricKey(metricKey: string | undefined, queryMetric: string | undefined): boolean;
 declare function projectEventToFacts(record: EventRecord): AnalyticsDataPoint[];
+declare function projectEventToFacts(record: EventRecord, filter?: ProjectEventToFactsFilter): AnalyticsDataPoint[];
 /**
  * Inverse of {@link toEventRows}/{@link toSummaryEventRows}: rebuild the
  * statement stream a session's event rows represent. Event rows keep their
@@ -2005,9 +2285,7 @@ declare function hasLegacyIdentity(row: Record<string, unknown>): boolean;
  * This module is pure — no React, no editor, no query service — so the editor
  * extensions, the inline block renderer, and the dashboard route all share it.
  */
-declare const DASHBOARD_WIDGET_TYPES: readonly ["table", "list", "value", "timeseries", "bar", "donut", "toplist", "stacked-bar", "goal-rings", "zone-distribution"];
-type DashboardWidgetType = (typeof DASHBOARD_WIDGET_TYPES)[number];
-declare function isDashboardWidgetType(type: string): type is DashboardWidgetType;
+
 /** The widget type a block renders as: a bare ```query fence defaults to `table`. */
 declare function resolveWidgetType(type: string | undefined): string;
 /** Shared badge messages — the editor, inline renderer, and route all word these identically. */
@@ -2021,28 +2299,6 @@ declare const PLANNED_WIDGET_TYPES: readonly string[];
  * placeholder badge (#901).
  */
 declare function isProposedMetric(metricKey: string | undefined): boolean;
-declare const DASHBOARD_GRID_MAX_COLS = 4;
-interface QueryWidgetSuffix {
-    /** Raw widget type from the tag, lowercased; '' for a bare ```query fence. */
-    type: string;
-    /** Grid column span 1..4 (`-N`). */
-    spanCols?: number;
-    /** Full-row flag (`-full`). Mutually exclusive with spanCols. */
-    spanFull?: boolean;
-    /** Presentation attributes: `key=value` tokens after the type/span
-     *  (decision 22 — positional params ride the fence tag, not the body). */
-    attributes: Record<string, string>;
-    /** Attribute order for stable re-serialization. */
-    attributeOrder: string[];
-    /** Set when the suffix is malformed (the type is still reported raw). */
-    error?: string;
-}
-/**
- * Parse the suffix after `query:` in a fence tag — `<type>`, `<type>-<N>` or
- * `<type>-full`. Unknown types parse fine (renderers badge them); structural
- * problems (empty type, bad span, `-N-full` combo) set `error`.
- */
-declare function parseQueryWidgetSuffix(suffix: string): QueryWidgetSuffix;
 /** Frontmatter meta shape. */
 type DashboardMeta = Record<string, string | number | string[]>;
 interface DashboardToken {
@@ -2085,6 +2341,8 @@ interface DashboardSectionInput {
     subtype?: string;
     /** Raw inner content of the section. */
     content: string;
+    /** Raw fence tag (`query` or `query:bar-2`) when parsed from markdown. */
+    fenceTag?: string;
     /** Widget type suffix parsed from the fence tag (query sections). */
     widgetType?: string;
     /** Grid column span parsed from the fence tag (query sections). */
@@ -2104,18 +2362,20 @@ interface DashboardWidget {
     type: string;
     spanCols?: number;
     spanFull?: boolean;
-    /** Full fenced body — a Query Document (decision 22), comment lines
-     *  stripped, surrounding whitespace trimmed, line structure preserved. */
+    /** Executable Query Document / WQL string consumed by runners and validators. */
     body: string;
-    /** Malformed fence-suffix reason — renderers badge instead of executing. */
+    /** Raw fenced text before YAML → QueryDocument compilation. */
+    rawBody?: string;
+    /** Canonical structured QueryBlockObject parsed from YAML, 1-line shorthand, or legacy fences. */
+    queryObject?: QueryBlockObject;
+    /** Malformed fence-suffix or YAML reason — renderers badge instead of executing. */
     widgetError?: string;
-    /** Fence-tag presentation attributes (decision 22) — positional params
-     *  ride the tag, never the body. */
+    /** Presentation attributes (`goal`, `targets`, `comparePr`, `label.<id>`, or legacy tag attrs). */
     attributes: Record<string, string>;
     attributeOrder: string[];
-    /** Title from the markdown heading directly above (or above the question). */
+    /** Title from inline YAML `title:` (preferred) or markdown heading directly above. */
     title?: string;
-    /** Coaching question from the paragraph directly above the block. */
+    /** Coaching question / description from inline YAML `description:` or paragraph directly above. */
     question?: string;
 }
 interface DashboardDocument {
@@ -2179,18 +2439,19 @@ declare function buildDashboardScaffold(title?: string): string;
  */
 
 interface WidgetSpec {
-    /** Card title — renders as a `## ` heading above the block. */
+    /** Card title — persisted as `title:` inside the YAML ```query fence. */
     title?: string;
-    /** Coaching question — the paragraph between the heading and the block. */
+    /** Coaching question / description — persisted as `description:` inside YAML. */
     question?: string;
-    /** Raw widget type from the fence suffix ('' → the `table` default). */
+    /** Raw widget type (`''` → the `table` default). */
     type: string;
     spanCols?: number;
     spanFull?: boolean;
-    /** The composed Query Document text — stored verbatim as the block body
-     *  (single-line or multi-line; decision 22). */
+    /** The composed WQL / Query Document text. */
     wql: string;
-    /** Fence-tag presentation attributes (goal targets, …). */
+    /** Optional pre-built structured `QueryBlockObject` (preferred by `<QueryObjectBuilder />`). */
+    queryObject?: QueryBlockObject;
+    /** Presentation attributes (goal targets, …). */
     attributes?: Record<string, string>;
     /** Attribute emission order (defaults to Object key order). */
     attributeOrder?: string[];
@@ -2201,7 +2462,9 @@ type WidgetSpan = Pick<WidgetSpec, 'spanCols' | 'spanFull'>;
 declare function widgetFenceTag(spec: Pick<WidgetSpec, 'type' | 'spanCols' | 'spanFull' | 'attributes' | 'attributeOrder'>): string;
 /** Block body: the Query Document text verbatim (trimmed). */
 declare function widgetBodyLine(spec: Pick<WidgetSpec, 'wql'>): string;
-/** The markdown lines of a whole widget group (heading? / question? / fence block). */
+/** Convert a `WidgetSpec` into its canonical `QueryBlockObject`. */
+declare function widgetSpecToQueryObject(spec: WidgetSpec): QueryBlockObject;
+/** The markdown lines of a widget — canonical self-contained ```query block (YAML or 1-line shorthand). */
 declare function renderWidgetGroup(spec: WidgetSpec): string[];
 /**
  * Append a new widget group at the end of the note body. Frontmatter and all
@@ -2325,6 +2588,28 @@ declare function extractNoteWqlOverride(rawContent?: string): string | undefined
  * `EntityScopeDescriptor`.
  */
 declare function resolveEntityScope(input: ResolveEntityScopeInput): EntityScopeDescriptor;
+interface ResolveQueryExecutionScopeInput {
+    noteId?: string;
+    rawContent?: string;
+    tokenValues?: Record<string, string>;
+    pageSources?: PageSourceRegistry | ReadonlyMap<string, PageSourceEntry>;
+    noteEvents?: EventRecord[];
+    note?: Note;
+}
+interface QueryExecutionScope {
+    tokens: Record<string, string>;
+    pageSources: PageSourceRegistry;
+}
+/**
+ * Resolve the unified execution scope (tokens + page dataset registry) for
+ * a ```query block or Dashboard Widget.
+ *
+ * Merge precedence:
+ *   1. Entity scope defaults (`note`, `thisnote`, `scope`, `metric`) when `noteId` is given
+ *   2. Frontmatter `dashboard.*` token defaults when `rawContent` is given
+ *   3. Caller `tokenValues` overrides
+ */
+declare function resolveQueryExecutionScope(input?: ResolveQueryExecutionScopeInput): QueryExecutionScope;
 /**
  * Infer default Dashboard Widget specs for turning any WQL query or
  * `EntityScopeDescriptor` into a multi-widget Dashboard Note.
@@ -2343,17 +2628,98 @@ interface BuildScopedDashboardOptions {
  */
 declare function buildDashboardFromScope(options: BuildScopedDashboardOptions): string;
 
+/**
+ * INTEGRATION STATUS (wayfinder): intentionally unwired — no production
+ * consumer yet. Wiring is the open item of wayfinder ticket 20 (runner/store wiring); do not
+ * delete these exports (they are the tested deliverable awaiting cutover).
+ * Query cache, scan coalescing, and invalidation (wayfinder
+ * datadog-analytics ticket 20, per the invalidation and performance
+ * contract).
+ *
+ * - Cache keys are STRUCTURAL: normalized AST, resolved range instants,
+ *   effective timezone, captured instant, store generation, and active
+ *   unit defaults. Changing any dimension invalidates by key.
+ * - Scan coalescing: widgets sharing one resolved range share one in-flight
+ *   store fetch — coalescing never merges semantically different queries
+ *   beyond the shared raw fetch.
+ * - Invalidation: commits to results/notes/efforts/catalog bump an
+ *   in-memory generation and post ANALYTICS_MUTATION on BroadcastChannel
+ *   'wodwiki.analytics'; a received receipt advances the local epoch so
+ *   generation comparisons stay correct across reloads.
+ *
+ * Pure module: the channel factory is injected (tests pass a fake; the app
+ * passes `new BroadcastChannel('wodwiki.analytics')`).
+ */
+
+/** Cross-tab invalidation bus. Every tab owns one bus over one channel. */
+declare class AnalyticsInvalidationBus {
+    private readonly makeChannel;
+    private channel?;
+    private generation;
+    private readonly listeners;
+    constructor(makeChannel: () => BroadcastChannel | undefined);
+    get generationId(): number;
+    /** Commit hook: bump local generation and broadcast the receipt. */
+    publishMutation(): Promise<void>;
+    /** Listen for receipts from OTHER tabs (and this one). */
+    subscribe(): void;
+    onChange(listener: () => void): () => void;
+    private notify;
+}
+/** Structural cache: entries carry the generation they were computed under;
+ *  a read against a different generation is a miss (and drops the entry).
+ *
+ *  Bounded LRU: the cache holds at most `maxEntries` (default 64) entries.
+ *  A read refreshes recency; a write evicts the least-recently-used entry
+ *  when the cache is full. The bound keeps browser memory flat — an
+ *  unbounded cache over a long-lived dashboard session grows with every
+ *  distinct query the user ever ran. */
+declare class QueryCache {
+    private readonly entries;
+    private readonly maxEntries;
+    constructor(bus: AnalyticsInvalidationBus, options?: {
+        maxEntries?: number;
+    });
+    get(key: string, generation: number): unknown;
+    set(key: string, value: unknown, generation: number): void;
+    clear(): void;
+    /** Current entry count — the LRU bound's observable state. */
+    get size(): number;
+}
+interface CacheKeyContext {
+    rangeStart?: number;
+    rangeEnd?: number;
+    timeZone?: string;
+    instant?: number;
+    generation: number;
+    /** Active system default output units (dimension → unit). */
+    unitDefaults?: Record<string, string | undefined>;
+}
+/** Structural cache key: canonical AST + every context dimension. */
+declare function computeCacheKey(parsed: AnyParsedQuery, context: CacheKeyContext): string;
+/**
+ * Wrap a UnifiedEventStore's range fetch with in-flight coalescing: calls
+ * sharing an identical resolved range join one fetch; different ranges scan
+ * separately. A mutation through the returned `invalidate()` clears the
+ * in-flight map (entries are short-lived by construction).
+ */
+declare function coalescingEventStore<S extends {
+    getEventsByTimeRange(start: number, end: number): Promise<unknown>;
+}>(inner: S): S & {
+    invalidateInFlight(): void;
+};
+
 /**
  * Auto-generated build version metadata.
  * Do not edit directly; updated by scripts/stamp-version.ts
  */
-declare const VERSION = "0.51.2196";
-declare const GIT_SHA = "817bc28";
-declare const BUILD_TIME = "2026-11-05T23:36:56.914Z";
+declare const VERSION = "0.53.2203";
+declare const GIT_SHA = "522974d";
+declare const BUILD_TIME = "2026-11-11T22:34:03.328Z";
 declare const SEMVER: {
-    readonly version: "0.51.2196";
-    readonly gitSha: "817bc28";
-    readonly buildTime: "2026-11-05T23:36:56.914Z";
+    readonly version: "0.53.2203";
+    readonly gitSha: "522974d";
+    readonly buildTime: "2026-11-11T22:34:03.328Z";
 };
 
-export { type Aggregator, type AnyParsedQuery, BUILD_TIME, type BlockQueryStore, type BuildScopedDashboardOptions, CONTENT_GROUPING_DIMENSIONS, type CatalogFieldSuggestion, type CatalogValueSuggestion, type ComparisonOp, DASHBOARD_GRID_MAX_COLS, DASHBOARD_WIDGET_TYPES, DEFAULT_DASHBOARD_TITLE, DISCIPLINE_FACTORS, type DashboardDocument, type DashboardMeta, type DashboardParsedSection, type DashboardSectionInput, type DashboardToken, type DashboardWidget, type DashboardWidgetType, type DocumentAssignment, type DocumentDefaults, type DocumentFormula, type DocumentOutput, type DocumentResult, EFFORT_DISCIPLINES, type EffortDiscipline, type EffortQueryStore, type EntityScopeDescriptor, type EntityScopeKind, type EventRowIdentity, type EventStore, type ExecutionContext, type FamilyRunPayload, type FindOptions, type FindPredicate, type FindQueryResult, type FormulaEvaluation, type FormulaEvaluator, GIT_SHA, type IFieldCatalog, type MetricPredicate, type NoteContainer, type NoteQueryStore, type NoteRelationBundle, type OperandValue, type OutputUnitResolution, PLANNED_WIDGET_TYPES, type PageSourceEntry, PageSourceRegistry, type ParsedAggregateQuery, type ParsedDocument, type ParsedFindQuery, type ParsedPipelineQuery, type ParsedRowsQuery, type ParsedWqlRollupSuffix, type ParsedWqlSuffixes, type ParsedWqlWindowSuffix, type PipelineOptions, type PipelineResult, type PipelineSink, type PipelineSource, type PointwiseInputs, type QueryDocument, QueryDocumentRunner$1 as QueryDocumentRunner, type QueryDocumentRunnerHost, type QueryDocumentRunnerOptions, type QueryOptions, type QueryResult, QueryService, type QueryServiceStores, type QueryWidgetSuffix, type QueryWindow, type ResolveEntityScopeInput, type ResolvedRange, type RowsPipes, type RowsQueryResult, type RowsRun, SEMVER, SOURCE_ID_SHAPES, type Series, type SeriesPoint, QueryDocumentRunner as SharedQueryDocumentRunner, type SharedRunnerOptions, type SummaryFactIdentity, type SummaryFactSourceOutput, type TabularColumn, type TabularGroup, type TabularResult, type TagFilter, type TagValue, UNASSIGNED, type UnitBearingFact, type UnitFamily, VERSION, WQL_AGGREGATORS, WQL_CALC_TARGETS, WQL_CHART_HEADS, WQL_COMPARISON_OPS, WQL_CONTENT_FILTER_KEYS, WQL_CONTENT_ONLY_KEYS, WQL_DISPLAY_UNITS, WQL_EFFORT_FILTER_KEYS, WQL_FIND_TARGETS, WQL_FUNCTION_HEADS, WQL_GRAINS, WQL_INTENSITY_TIERS, WQL_KEYWORDS, WQL_METRIC_AGGREGATES, WQL_METRIC_FAMILIES, WQL_NOTE_DEFAULT_SOURCES, WQL_NOTE_HEAD_ALIASES, WQL_RESULT_PLANES, WQL_ROLLUP_PERIODS, WQL_SOURCES, WQL_SOURCE_HEADS, WQL_SOURCE_HEAD_SCOPES, WQL_SOURCE_VALUES, WQL_STANDARD_DATASETS, WQL_TAG_KEYS, WQL_TYPED_TAG_KEYS, WQL_TYPE_HEADS, WQL_VIRTUAL_DIMS, type WidgetOpResult, type WidgetSpan, type WidgetSpec, type WqlAggregator, type WqlCalcTarget, type WqlChartHead, type WqlComparisonOp, type WqlCompletionOptions, type WqlContentFilterKey, type WqlDisplayUnit, type WqlDomainOrder, type WqlDomainPredicate, type WqlDomainReadResult, type WqlFindTarget, type WqlFunctionHead, type WqlGrain, type WqlIntensityTier, type WqlKeyword, type WqlMetricAggregate, type WqlMetricFamily, type WqlResultPlane, type WqlRollupPeriod, type WqlSource, type WqlSourceHead, type WqlSourceValue, type WqlStandardDataset, type WqlTagKey, type WqlTypedTagKey, type WqlVirtualDim, allowedFilterTypesForTarget, appendSuffixes, appendWidget, buildDashboardDocument, buildDashboardFromScope, buildDashboardScaffold, buildDrillDownQuery, buildWidgetsForWqlScope, captureContext, chunkIdOfItem, civilDateAdd, civilDateDiff, civilDateOf, civilDatesCoveredByRange, civilMonday, consumesRollupFacts, convertDisplay, createBuiltinFormulaEvaluator, dashboardSlug, defaultTokenValues, disciplineFactorFor, duplicateWidget, eventsToStoredLogs, extractDashboardTokens, extractNoteWqlOverride, feedIdOfItem, feedOfItem, findTargetAdvisories, getUnitFamily, hasLegacyIdentity, inRange, isAggregateQuery, isDashboardMeta, isDashboardWidgetType, isEffortDiscipline, isFindQuery, isItemSubscribed, isPipelineQuery, isProposedMetric, migrateLegacyChunkId, migrateLegacyDashboardBodies, migrateLegacyRouteId, migrateLegacyRow, migrateLegacySourceId, migrateLegacySourcePath, moveWidget, normalizeSummaryFacts, normalizeWql, notebookOfItem, notebookOriginOfItem, notebookSlugOfSourceId, parseDashboardNote, parseDocument, parseQuery, parseQueryWidgetSuffix, parseWqlSuffixes, projectEventToFacts, referencedTokens, removeWidget, renderWidgetGroup, resizeWidget, resolveCanonicalMetricKey, resolveEntityScope, resolveOutputUnit, resolveWidgetType, resolveWindowRange, rowsParseError, serialize, serializeDocument, setDashboardTokenValue, sourceMatches, sourceShape, splitAtWhere, substituteTokens, substituteTokens$1 as substituteTokensRaw, supportsWqlFilterKey, systemTimeZone, toEventRows, toSummaryEventRows, unknownTokensMessage, unknownWidgetTypeMessage, updateWidget, widgetBodyLine, widgetFenceTag, wql, wqlCompletion, wqlCompletionSource, wqlFilterKeys, wqlGroupingDimensions, wqlHighlightStyle, wqlLanguage, parser as wqlParser, wql_parser_terms as wqlTerms, zonedNoon, zonedStartOfDay };
+export { type Aggregator, AnalyticsInvalidationBus, type AnyParsedQuery, BUILD_TIME, type BlockQueryStore, type BuildScopedDashboardOptions, CONTENT_GROUPING_DIMENSIONS, type CacheKeyContext, type CatalogFieldSuggestion, type CatalogValueSuggestion, type ComparisonOp, DASHBOARD_GRID_MAX_COLS, DASHBOARD_WIDGET_TYPES, DEFAULT_DASHBOARD_TITLE, DISCIPLINE_FACTORS, type DashboardDocument, type DashboardMeta, type DashboardParsedSection, type DashboardSectionInput, type DashboardToken, type DashboardWidget, type DashboardWidgetType, type DocumentAssignment, type DocumentDefaults, type DocumentFormula, type DocumentOutput, type DocumentResult, EFFORT_DISCIPLINES, type EffortDiscipline, type EffortQueryStore, type EntityScopeDescriptor, type EntityScopeKind, type EventRowIdentity, type EventStore, type ExecutionContext, type FamilyRunPayload, type FeedCatalogQueryStore, type FindOptions, type FindPredicate, type FindQueryResult, type FormulaEvaluation, type FormulaEvaluator, GIT_SHA, type IFieldCatalog, type MetricPredicate, type NoteContainer, type NoteQueryStore, type NoteRelationBundle, type NotebookResolvableItem, type OperandValue, type OutputUnitResolution, PLANNED_WIDGET_TYPES, type PageSourceEntry, PageSourceRegistry, type ParseQueryBlockOptions, type ParsedAggregateQuery, type ParsedDocument, type ParsedFindQuery, type ParsedPipelineQuery, type ParsedRowsQuery, type ParsedWqlRollupSuffix, type ParsedWqlSuffixes, type ParsedWqlWindowSuffix, type PipelineOptions, type PipelineResult, type PipelineSink, type PipelineSource, type PointwiseInputs, type ProjectEventToFactsFilter, type QueryBlockObject, QueryCache, type QueryDocument, QueryDocumentRunner$1 as QueryDocumentRunner, type QueryDocumentRunnerHost, type QueryDocumentRunnerOptions, type QueryExecutionScope, type QueryOptions, type QueryResult, type QuerySeriesSpec, QueryService, type QueryServiceStores, type QuerySortSpec, type QueryViewKind, type QueryWidgetSuffix, type QueryWindow, type ResolveEntityScopeInput, type ResolveQueryExecutionScopeInput, type ResolvedRange, type RowsPipes, type RowsQueryResult, type RowsRun, SEMVER, SOURCE_ID_SHAPES, type ScalarOrParam, type Series, type SeriesPoint, QueryDocumentRunner as SharedQueryDocumentRunner, type SharedRunnerOptions, type SummaryFactIdentity, type SummaryFactSourceOutput, type TabularColumn, type TabularGroup, type TabularResult, type TagFilter, type TagValue, UNASSIGNED, type UnitBearingFact, type UnitFamily, VERSION, WQL_AGGREGATORS, WQL_CALC_TARGETS, WQL_CHART_HEADS, WQL_COMPARISON_OPS, WQL_CONTENT_FILTER_KEYS, WQL_CONTENT_ONLY_KEYS, WQL_DISPLAY_UNITS, WQL_EFFORT_FILTER_KEYS, WQL_FIND_TARGETS, WQL_FUNCTION_HEADS, WQL_GRAINS, WQL_INTENSITY_TIERS, WQL_KEYWORDS, WQL_METRIC_AGGREGATES, WQL_METRIC_FAMILIES, WQL_NOTE_DEFAULT_SOURCES, WQL_NOTE_HEAD_ALIASES, WQL_RESULT_PLANES, WQL_ROLLUP_PERIODS, WQL_SOURCES, WQL_SOURCE_HEADS, WQL_SOURCE_HEAD_SCOPES, WQL_SOURCE_VALUES, WQL_STANDARD_DATASETS, WQL_TAG_KEYS, WQL_TYPED_TAG_KEYS, WQL_TYPE_HEADS, WQL_VIRTUAL_DIMS, type WidgetOpResult, type WidgetSpan, type WidgetSpec, type WqlAggregator, type WqlCalcTarget, type WqlChartHead, type WqlComparisonOp, type WqlCompletionOptions, type WqlContentFilterKey, type WqlCursorStageInfo, type WqlCursorStageRole, type WqlDisplayUnit, type WqlDomainOrder, type WqlDomainPredicate, type WqlDomainReadResult, type WqlFindTarget, type WqlFunctionHead, type WqlGrain, type WqlIntensityTier, type WqlKeyword, type WqlMetricAggregate, type WqlMetricFamily, type WqlResultPlane, type WqlRollupPeriod, type WqlSource, type WqlSourceHead, type WqlSourceValue, type WqlStandardDataset, type WqlTagKey, type WqlTypedTagKey, type WqlVirtualDim, allowedFilterTypesForTarget, appendSuffixes, appendWidget, bindQueryParams, buildDashboardDocument, buildDashboardFromScope, buildDashboardScaffold, buildDrillDownQuery, buildWidgetsForWqlScope, captureContext, chunkIdOfItem, civilDateAdd, civilDateDiff, civilDateOf, civilDatesCoveredByRange, civilMonday, coalescingEventStore, collectQueryBlockParams, collectQueryParams, computeCacheKey, consumesRollupFacts, convertDisplay, createBuiltinFormulaEvaluator, dashboardSlug, defaultTokenValues, disciplineFactorFor, duplicateWidget, eventsToStoredLogs, extractDashboardTokens, extractNoteWqlOverride, feedIdOfItem, feedOfItem, findTargetAdvisories, getUnitFamily, hasLegacyIdentity, inRange, isAggregateQuery, isDashboardMeta, isDashboardWidgetType, isDefaultShorthandQueryBlock, isEffortDiscipline, isFindQuery, isItemSubscribed, isPipelineQuery, isProposedMetric, isYamlQueryBlockBody, matchesFactMetricKey, migrateLegacyChunkId, migrateLegacyDashboardBodies, migrateLegacyRouteId, migrateLegacyRow, migrateLegacySourceId, migrateLegacySourcePath, moveWidget, normalizeSummaryFacts, normalizeWql, notebookOfItem, notebookOriginOfItem, notebookSlugOfSourceId, notebooksOfItem, parseDashboardNote, parseDocument, parseFilterFragment, parseQuery, parseQueryBlock, parseQueryWidgetSuffix, parseWqlSuffixes, projectEventToFacts, queryBlockAttributes, queryBlockToDocumentText, referencedTokens, removeWidget, renderWidgetGroup, resizeWidget, resolveCanonicalMetricKey, resolveEntityScope, resolveOutputUnit, resolveQueryExecutionScope, resolveWidgetType, resolveWindowRange, resolveWqlCursorStage, rowsParseError, serialize, serializeDocument, serializeQueryBlock, serializeQueryBlockFence, setDashboardTokenValue, sourceMatches, sourceShape, splitAtWhere, substituteTokens, substituteTokens$1 as substituteTokensRaw, supportsWqlFilterKey, systemTimeZone, toEventRows, toSummaryEventRows, unknownTokensMessage, unknownWidgetTypeMessage, updateWidget, widgetBodyLine, widgetFenceTag, widgetSpecToQueryObject, wql, wqlCompletion, wqlCompletionSource, wqlFilterKeys, wqlGroupingDimensions, wqlHighlightStyle, wqlLanguage, parser as wqlParser, wql_parser_terms as wqlTerms, zonedNoon, zonedStartOfDay };