@bitcobblers/wod-wiki-wql 0.11.43 → 0.35.2116

package/dist/index.d.cts

@@ -1,8 +1,9 @@
 import { LRParser } from '@lezer/lr';
 import { LanguageSupport, HighlightStyle, LRLanguage } from '@codemirror/language';
-import { CompletionContext, CompletionResult } from '@codemirror/autocomplete';
+import { Completion, CompletionContext, CompletionResult } from '@codemirror/autocomplete';
 import { Extension } from '@codemirror/state';
-import { ResultOrigin, AnalyticsDataPoint, UnifiedEventRecord, StoredOutputStatement, BlockIndexRow, Note } from '@bitcobblers/wod-wiki-core';
+import { SummaryCoverage, BlockIndexRow, Note, EventRecord, PageNote, Page, AnalyticsDataPoint, ResultOrigin, StoredOutputStatement } from '@bitcobblers/wod-wiki-core';
+export { SYSTEM_DEFAULT_OUTPUT_UNIT, UnitConversionError, convertViaCatalog, dimensionKeyOf, lookupUnit, systemDefaultUnit } from '@bitcobblers/wod-wiki-core';
 
 /**
  * WQL vocabulary — the single owner of the WQL dictionary: aggregators,
@@ -28,9 +29,20 @@ type WqlAggregator = (typeof WQL_AGGREGATORS)[number];
 /** Comparison operators for cross-store `where` joins (#800). */
 declare const WQL_COMPARISON_OPS: readonly [">", ">=", "<", "<=", "==", "!="];
 type WqlComparisonOp = (typeof WQL_COMPARISON_OPS)[number];
+/** Frontmatter typed-tag keys (CONTEXT.md § Tags) — values are dynamic,
+ *  backed by the host's tags store (`by-type` index), not a static enum. */
+declare const WQL_TYPED_TAG_KEYS: readonly ["domain", "format", "equipment", "quality", "intent"];
+type WqlTypedTagKey = (typeof WQL_TYPED_TAG_KEYS)[number];
 /** Tag keys the Query Service reads off a fact row (QueryService.factTagValue). */
-declare const WQL_TAG_KEYS: readonly ["effort", "discipline", "intensity", "note", "page", "origin", "grain", "metric", "block", "result", "tags"];
+declare const WQL_TAG_KEYS: readonly ["domain", "format", "equipment", "quality", "intent", "effort", "discipline", "intensity", "grade", "note", "page", "origin", "grain", "metric", "block", "result", "tags"];
 type WqlTagKey = (typeof WQL_TAG_KEYS)[number];
+/** Content-plane keys — meaningful only on find:/rows:. On an aggregate
+ *  they are a category error (a fact row has no note text or source);
+ *  every other non-structural key is a candidate custom dimension. */
+declare const WQL_CONTENT_ONLY_KEYS: readonly ["type", "text", "has", "source", "catalog"];
+/** Filter keys the effort registry can resolve (runFindEffort) — anything
+ *  else on find:effort is ignored and reported as an advisory. */
+declare const WQL_EFFORT_FILTER_KEYS: readonly ["effort", "discipline", "intensity", "origin", "text"];
 /** Virtual dimensions — time buckets and stream positions, not fact fields. */
 declare const WQL_VIRTUAL_DIMS: readonly ["day", "week", "session", "round"];
 type WqlVirtualDim = (typeof WQL_VIRTUAL_DIMS)[number];
@@ -56,11 +68,42 @@ type WqlIntensityTier = (typeof WQL_INTENSITY_TIERS)[number];
 declare const WQL_GRAINS: readonly ["summary", "event"];
 type WqlGrain = (typeof WQL_GRAINS)[number];
 /** Content-discovery query targets (find:<target>). */
-declare const WQL_FIND_TARGETS: readonly ["note", "block", "effort"];
+declare const WQL_FIND_TARGETS: readonly ["note", "block", "effort", "session", "segment", "event"];
 type WqlFindTarget = (typeof WQL_FIND_TARGETS)[number];
-/** Canonical source filter values (C2): scope folded into the source: filter key. */
-declare const WQL_SOURCE_VALUES: readonly ["journal", "collections", "feeds", "all"];
+/** Canonical source filter values: the allowed storage locations (the
+ *  former `collections` spelling is retired — renamed to feeds; storage
+ *  identities keep their `collection:` prefixes). Seed corpus locations
+ *  joined the note plane: prebuilt dashboards and the effort library. */
+declare const WQL_SOURCE_VALUES: readonly ["journal", "feeds", "guides", "playground", "dashboards", "efforts"];
 type WqlSourceValue = (typeof WQL_SOURCE_VALUES)[number];
+/** Colon source heads — the unprefixed `:<head>` names. Find targets map
+ *  1:1 to the content planes; journal/feed(s)/catalog(s)/playground are
+ *  source-scoped note heads (they parse to target 'note' plus an injected
+ *  `source:` filter). */
+declare const WQL_SOURCE_HEADS: readonly ["note", "block", "effort", "session", "segment", "event", "journal", "feed", "feeds", "catalog", "catalogs", "playground", "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>>;
+/** Type-alias note heads — `:<head>` parses to target 'note' plus an injected
+ *  `type:` filter (no storage scope, so the head never narrows by source).
+ *  `:dashboard` is the canonical member: dashboards are notes typed
+ *  'dashboard', findable with ordinary note tags/text/frontmatter filters. */
+declare const WQL_TYPE_HEADS: Readonly<Record<string, string>>;
+/** Former generic `:note` default scope — now EMPTY: the generic note head
+ *  is the inclusive note plane (every row). Kept exported (empty) so the
+ *  serializer and host surfaces keep a single name for "the default scope",
+ *  which no longer narrows anything. */
+declare const WQL_NOTE_DEFAULT_SOURCES: readonly WqlSourceValue[];
+/** Colon function heads — the unprefixed `:<fn>{metric:…}` aggregate stage. */
+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"];
+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"];
+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
  *  open (core KNOWN_OUTPUT_TYPES, ticket 002: unknowns are stored and
@@ -69,17 +112,8 @@ type WqlSourceValue = (typeof WQL_SOURCE_VALUES)[number];
  *  stay addressable programmatically via hand-built ASTs. */
 declare const WQL_RESULT_PLANES: readonly ["segment", "system", "load", "event", "compiler", "completion", "analytics", "wellness"];
 type WqlResultPlane = (typeof WQL_RESULT_PLANES)[number];
-/** All `rows:` targets — content planes plus result planes (rows model
- *  §1.0: every query selects rows from a target) plus `all`, the explicit
- *  no-narrowing pseudo-target (spec v2 decision 1: the bare `rows:{…}`
- *  alias retires). Content-plane targets scope by content, not outputType
- *  (C4). */
-declare const WQL_ROWS_TARGETS: readonly ["note", "block", "effort", "segment", "system", "load", "event", "compiler", "completion", "analytics", "wellness", "all"];
-type WqlRowsTarget = (typeof WQL_ROWS_TARGETS)[number];
-/** Rows scope filter keys (C4): the exact-match keys a rows query filters by. */
-declare const WQL_ROWS_SCOPE_KEYS: readonly ["result", "block", "note"];
 /** Content-specific filter keys (beyond the analytics tag keys). */
-declare const WQL_CONTENT_FILTER_KEYS: readonly ["type", "text", "has", "source", "catalog", "effort", "discipline", "intensity", "note", "page", "origin", "grain", "metric", "block", "result", "tags"];
+declare const WQL_CONTENT_FILTER_KEYS: readonly ["type", "text", "has", "source", "catalog", "domain", "format", "equipment", "quality", "intent", "effort", "discipline", "intensity", "grade", "note", "page", "origin", "grain", "metric", "block", "result", "tags"];
 type WqlContentFilterKey = (typeof WQL_CONTENT_FILTER_KEYS)[number];
 /**
  * Composer source planes (issue #838, decision #836): the single `source`
@@ -90,10 +124,10 @@ 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 ["journal", "collections", "feeds", "notes", "blocks", "efforts", "metrics"];
+declare const WQL_SOURCES: readonly ["note", "block", "effort", "session", "segment", "event"];
 type WqlSource = (typeof WQL_SOURCES)[number];
-/** Rollup periods the aggregate grammar accepts (wql.ts: unit d|w only). */
-declare const WQL_ROLLUP_PERIODS: readonly ["1d", "1w"];
+/** Rollup periods the aggregate grammar accepts (wql.ts: N > 1, unit d|w). */
+declare const WQL_ROLLUP_PERIODS: readonly ["2w", "4w"];
 type WqlRollupPeriod = (typeof WQL_ROLLUP_PERIODS)[number];
 /** Display units the app can render (analytics unit preference, kg/lb). The
  *  `in <unit>` directive accepts any word; these are the canonical options. */
@@ -103,29 +137,54 @@ type WqlDisplayUnit = (typeof WQL_DISPLAY_UNITS)[number];
 declare const WQL_KEYWORDS: readonly ["find", "rows", "where", "group", "by", "order", "limit", "sum", "avg", "min", "max", "count", "last", "delta"];
 type WqlKeyword = (typeof WQL_KEYWORDS)[number];
 
+/**
+ * Grouping dimensions the content consumer (stream entryGrouping) applies on
+ * top of find results: the note/block/effort/session executors return flat
+ * results and the view groups them, ordered and multi-dim. The find tables
+ * (segment/event) group inside the executor over selected columns instead.
+ */
+declare const CONTENT_GROUPING_DIMENSIONS: readonly ["date", "day", "week", "month", "year", "discipline", "origin", "source", "kind", "type", "tag"];
+/** Guided clause types, including structural clauses honored by their consumers. */
+declare function allowedFilterTypesForTarget(target: string, family: 'find' | 'aggregate'): ReadonlySet<string>;
+/** Suggested filter keys. Fact-backed queries also accept custom dimension keys. */
+declare function wqlFilterKeys(target: string, family: 'find' | 'aggregate'): readonly string[];
+/** Content grouping is applied by the stream consumer; table grouping reads
+ *  selected columns. Effort/session have no executor grouping but their views
+ *  group content (the effort view profile groups by discipline). */
+declare function wqlGroupingDimensions(target: string, family: 'find' | 'aggregate'): readonly string[];
+/** Fact dimensions are open, but content-only fields and plane have no fact meaning. */
+declare function supportsWqlFilterKey(target: string, family: 'find' | 'aggregate', rawKey: string): boolean;
+
 declare const parser: LRParser;
 
 declare const Query = 1;
-declare const Head = 2;
-declare const Aggregator$1 = 3;
-declare const Word = 4;
-declare const Metric = 5;
-declare const Filters = 6;
-declare const Filter = 7;
-declare const Negate = 8;
-declare const TagKey = 9;
-declare const TagValue$1 = 10;
-declare const Value = 11;
-declare const Star = 12;
-declare const Quoted = 13;
-declare const GroupBy = 14;
-declare const By = 15;
-declare const Dimension = 16;
-declare const Rollup = 17;
-declare const RollupDot = 18;
-declare const Int = 19;
+declare const Pipeline = 2;
+declare const Stage = 3;
+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 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_Filter: typeof Filter;
 declare const wql_parser_terms_Filters: typeof Filters;
@@ -134,16 +193,19 @@ 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_Pipeline: typeof Pipeline;
 declare const wql_parser_terms_Query: typeof Query;
 declare const wql_parser_terms_Quoted: typeof Quoted;
 declare const wql_parser_terms_Rollup: typeof Rollup;
 declare const wql_parser_terms_RollupDot: typeof RollupDot;
+declare const wql_parser_terms_Single: typeof Single;
+declare const wql_parser_terms_Stage: typeof Stage;
 declare const wql_parser_terms_Star: typeof Star;
 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_By as By, 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_Query as Query, wql_parser_terms_Quoted as Quoted, wql_parser_terms_Rollup as Rollup, wql_parser_terms_RollupDot as RollupDot, 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_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 };
 }
 
 /**
@@ -180,9 +242,13 @@ type ParsedWqlWindowSuffix = {
 interface ParsedWqlSuffixes {
     /** Outer cross-store join clause text (`where ...`). */
     where?: string;
+    /** Stored source binding target (`=> @sourceName`). */
+    storedAs?: string;
+    /** Source dataset reference for downstream query (`@source | ...` or `in @source`). */
+    sourceRef?: string;
     /** Display unit directive (`in kg`). */
     displayUnit?: string;
-    /** Rollup period (`.rollup(1w)`). */
+    /** Rollup period (`.rollup(2w)` — 1-unit forms are rejected in parseQuery). */
     rollup?: ParsedWqlRollupSuffix;
     /** Group-by dimensions (`by {week, effort}`). */
     groupBy?: string[];
@@ -205,7 +271,7 @@ declare function splitAtWhere(text: string): {
 };
 /**
  * Extract suffixes from a raw WQL query string.
- * Strips outer join (`where`), display unit (`in kg`), rollup (`.rollup(1w)`),
+ * Strips outer join (`where`), display unit (`in kg`), rollup (`.rollup(Nw)`),
  * group-by (`by {week}`), time window (`last 8w` / `from … [to …]`), and
  * legacy scope (`in journal`).
  */
@@ -216,7 +282,7 @@ declare function parseWqlSuffixes(raw: string): ParsedWqlSuffixes;
  *
  *   <aggregator>:<metric.namespace>{<tag filters>} by {<dimensions>} .rollup(<period>)
  *
- *   sum:totalVolume{discipline:strength} by {week}.rollup(1w)
+ *   sum:totalVolume{discipline:strength} by {week}
  *   avg:tis{effort:thruster,!discipline:recovery} by {session}
  *
  * This module holds the AST contract the Query Service executes and the
@@ -252,7 +318,7 @@ interface MetricPredicate {
 }
 /**
  * Content half of a cross-store join — the find predicate attached to an
- * analytics query via `where`. Example: `find:note{tags:competition} in journal`.
+ * analytics query via `where`. Example: `find:note{tags:competition,source:journal}`.
  * Restricts the metric computation to the blockContentIds owned by matching
  * content; the metric is recomputed from raw logs for those blocks only.
  */
@@ -291,17 +357,50 @@ interface ParsedAggregateQuery {
     advisories?: string[];
     error?: string;
 }
-/** Result of parsing a content-discovery query (`find:target{filters} in scope`). */
+/**
+ * Ticket 18 — drill-down: construct a cross-workout `rows:segment` query
+ * inheriting an aggregate point's tag/metadata filters, the clicked bucket's
+ * EXACT half-open civil boundaries (structural, not display timestamps), and
+ * the clicked group tuple as exact filters.
+ */
+declare function buildDrillDownQuery(options: {
+    filters?: Array<{
+        key: string;
+        values: readonly string[];
+    }>;
+    /** Half-open bucket bounds (ms epoch) from the clicked point's bucket. */
+    start?: number;
+    end?: number;
+    /** Civil dates (YYYY-MM-DD) — used when the point is a calendar bucket. */
+    startIso?: string;
+    endIso?: string;
+    timeZone?: string;
+    limit?: number;
+}): string;
+/** Result of parsing a content-discovery query — the colon source heads
+ *  (`:note{…}`, `:journal{…}`); the legacy `find:` spelling is retired and
+ *  survives only inside `where` join halves. */
 interface ParsedFindQuery {
     family: 'find';
     raw: string;
     /** Content target — a WQL_FIND_TARGETS value (C7 closed enum). */
     target: string;
     filters: TagFilter[];
+    /** Implicit default source scope for the generic `:note` head —
+     *  journal | feeds | playground. NOT a filter: authored filters stay
+     *  untouched (composer pills never see it); the executor ANDs it in only
+     *  when no explicit `source:` filter was written. */
+    sourceScope?: string[];
     /** Time-selection window (C1): `last 8w` or `from … [to …]`. */
     window?: QueryWindow;
     /** Cross-store metric join (`where sum:totalVolume{} > 5000`). */
     join?: MetricPredicate;
+    /** Presentation pipes (`| select … | order by … | limit …`). */
+    pipes?: RowsPipes;
+    /** Group-by dimensions (`by {effort}`). */
+    groupBy?: string[];
+    /** Optional display unit directive (`in kg` / `in lb`). */
+    displayUnit?: string;
     /** Deprecation advisories (C2 normalizer). */
     advisories?: string[];
     error?: string;
@@ -321,16 +420,53 @@ type QueryWindow = {
     start: string;
     end?: string;
 };
-type AnyParsedQuery = ParsedAggregateQuery | ParsedFindQuery | ParsedRowsQuery;
+type AnyParsedQuery = ParsedAggregateQuery | ParsedFindQuery | ParsedPipelineQuery;
 /** Type guard: true for content-discovery queries. */
 declare function isFindQuery(parsed: AnyParsedQuery): parsed is ParsedFindQuery;
-/** Type guard: true for rows queries. */
-declare function isRowsQuery(parsed: AnyParsedQuery): parsed is ParsedRowsQuery;
 /** Type guard: true for analytics (aggregate) queries. */
 declare function isAggregateQuery(parsed: AnyParsedQuery): parsed is ParsedAggregateQuery;
+/** Type guard: true for left-to-right value pipelines (`:src | :fn | :chart`). */
+declare function isPipelineQuery(parsed: AnyParsedQuery): parsed is ParsedPipelineQuery;
+/** A pipeline's input: a full single query, or a named dataset
+ *  (`@session` / `@today` / a host-registered page source — name keeps `@`). */
+type PipelineSource = {
+    kind: 'query';
+    query: ParsedFindQuery | ParsedAggregateQuery;
+} | {
+    kind: 'dataset';
+    name: string;
+};
+/** Terminal chart stage of a pipeline: the chart head plus its authored
+ *  parameter filters (`:bar{type:session}` → `{head:'bar', filters:[…]}`). */
+interface PipelineSink {
+    head: WqlChartHead;
+    filters: TagFilter[];
+}
+/**
+ * Left-to-right value pipeline (`:journal{…} last 8w | :sum{metric:tis} | :timeseries{}`).
+ * Transforms apply in order to the previous stage's output — the executor
+ * reduces in memory, it never rescans stores. A dataset alone (`@today`) is
+ * a pipeline with no transforms; a lone chart head starts from an implicit
+ * `:segment` source.
+ */
+interface ParsedPipelineQuery {
+    family: 'pipeline';
+    raw: string;
+    source: PipelineSource;
+    /** Ordered aggregate stages, each applied to the previous stage's rows. */
+    transforms: ParsedAggregateQuery[];
+    sink?: PipelineSink;
+    /** Parse-time disclosures (ignored chart suffixes, …). */
+    advisories?: string[];
+    error?: string;
+}
 interface SeriesPoint {
     ts: number;
     value: number;
+    /** True for a structurally present bucket with no recorded observations
+     *  (ticket 12 calendar domain generation) — display zero-fill, never an
+     *  observation. */
+    missing?: boolean;
 }
 /**
  * Result of parsing a rows query (`rows:{filters}` / `rows:segment{filters}`) —
@@ -338,12 +474,31 @@ interface SeriesPoint {
  * output-statement rows re-derived from WorkoutResult logs, scoped by
  * `result:` / `block:` / `note:`. Never aggregates — no by/rollup/where.
  */
+/** Ticket 18 — pipe clauses: presentation only, never alter the match. */
+interface RowsPipes {
+    error?: string;
+    select?: Array<{
+        col: string;
+        unit?: string;
+    }>;
+    order?: Array<{
+        col: string;
+        dir: 'asc' | 'desc';
+    }>;
+    limit?: number;
+    offset?: number;
+}
 interface ParsedRowsQuery {
+    /** Ticket 18 — pipe clauses (| select / | order by / | limit). */
+    pipes?: RowsPipes;
     raw: string;
     /** Family discriminator shared by all three query ASTs (C5). */
     family: 'rows';
     /** Output-statement type narrowing from the optional target (`rows:segment{…}`); undefined = all types. */
     outputType?: string;
+    /** The rows target itself — 'all' | 'segment' | content plane (ticket 18:
+     *  segment without scope = cross-workout form). */
+    target?: string;
     filters: TagFilter[];
     /** Time-selection window (C1): `last 4w` or `from … [to …]` over the
      *  workout end time. */
@@ -352,11 +507,14 @@ interface ParsedRowsQuery {
     advisories?: string[];
     error?: string;
 }
+/** One aggregated series. `error` carries the diagnostic when this series'
+ *  calculation failed (ticket 13) — an errored series has no valid values. */
 interface Series {
     key: string;
     label: string;
     points: SeriesPoint[];
     unit?: string;
+    error?: string;
 }
 /**
  * Parse a WQL query string into one of the three query families —
@@ -364,10 +522,17 @@ interface Series {
  * (C5). Dispatch is textual: a leading `find:` routes to the content path,
  * `rows` to the rows path, everything else to analytics.
  */
+declare function rowsParseError(raw: string): string;
+/**
+ * Parse a WQL query string into one of the query families — analytics
+ * aggregate, content find, or pipeline — discriminated by `family` (C5).
+ * Dispatch: `rows` is a retired-error; `find:` is retired; a pipe-separated
+ * stage list (or a lone `@dataset`/chart head) is a pipeline; a colon
+ * source/function head or legacy `agg:metric` head parses as a single query.
+ */
 declare function parseQuery(raw: string): AnyParsedQuery;
 /**
  * C2 Compatibility normalizer: rewrites legacy query syntax into modern WQL.
- *   - Bare `rows:{…}` heads rewrite to `rows:all{…}`
  *   - Legacy trailing `in <scope>` rewrites into `{source:<scope>}`
  * Returns the normalized query string and any deprecation advisories.
  */
@@ -375,6 +540,14 @@ declare function normalizeWql(raw: string): {
     query: string;
     advisories: string[];
 };
+/**
+ * Target-capability advisories for a find AST: every clause the executor will
+ * silently drop, apply differently than written, or group outside the
+ * executor. A pure function of the parsed shape — `parseFindQuery` attaches
+ * these at parse time and `QueryService.runFind` re-derives them, so
+ * hand-built ASTs get the same loud disclosure without re-serializing text.
+ */
+declare function findTargetAdvisories(query: ParsedFindQuery): string[];
 
 /**
  * WQL serializer (C6 — one structured interface for code).
@@ -393,7 +566,10 @@ declare function normalizeWql(raw: string): {
  * to parse has no well-defined structure to re-emit, and echoing the input
  * keeps the function total.
  *
- * Round-trip equality holds for text-surface-representable ASTs. Three value
+ * Round-trip equality holds for text-surface-representable ASTs. Single
+ * aggregate queries serialize in the retained legacy `sum:metric{…}` form;
+ * find queries serialize with colon source heads (find: is retired) and
+ * pipelines as `source | :fn{…} | :chart{…}`. Three value
  * shapes the grammar cannot express (or parses away) sit outside that
  * contract — documented here rather than silently corrupted:
  *   - a `"` inside a filter value: the quoted token has no escape form;
@@ -425,6 +601,53 @@ declare const DISCIPLINE_FACTORS: Record<EffortDiscipline, number>;
 /** Factor for an arbitrary discipline string; 1.0 when absent or unknown. */
 declare function disciplineFactorFor(discipline: string | undefined): number;
 
+/**
+ * IFieldCatalog — the consumer interface for field discovery (wayfinder
+ * datadog-analytics ticket 15, per the field discovery contract: typeahead
+ * reads catalog indexes with bounded result counts and NEVER scans event or
+ * result history; the query package performs no browser-storage access — the
+ * app injects an implementation over the V17 stores).
+ */
+/** One typed field variant as surfaced to authoring surfaces. */
+interface CatalogFieldSuggestion {
+    /** Typed field identity (collision-free key). */
+    id: string;
+    /** Normalized full path. */
+    path: string;
+    kind: string;
+    /** Physical/named dimension of a numeric variant, when known. */
+    dimension?: string;
+    /** Observed effective units (original spellings as context). */
+    units: readonly string[];
+    /** Observed original spellings (provenance context). */
+    spellings: readonly string[];
+}
+/** One observed categorical value of a field (original spelling kept). */
+interface CatalogValueSuggestion {
+    fieldId: string;
+    value: string;
+}
+interface IFieldCatalog {
+    /**
+     * Bounded normalized-path prefix listing for field typeahead. Implementations
+     * MUST serve it from the catalog index — never from event/result scans — and
+     * MUST cap results at `limit` (narrower prefixes reveal further suggestions
+     * rather than silently claiming the page is the whole vocabulary).
+     */
+    listByPrefix(prefix: string, limit?: number): Promise<CatalogFieldSuggestion[]>;
+    /** Typed-variant lookup by exact normalized path — all variants of the path
+     *  (e.g. numeric and text `score`), for `field(...)` alternatives. */
+    lookup(path: string): Promise<CatalogFieldSuggestion[]>;
+    /** Bounded categorical-value prefix lookup scoped to one field path. */
+    listValues(path: string, valuePrefix: string, limit?: number): Promise<CatalogValueSuggestion[]>;
+    /**
+     * Change notification — catalog commits signal interested consumers so new
+     * fields appear without reload (invalidation wiring lands with ticket 20).
+     * Returns an unsubscribe function.
+     */
+    onChange?(listener: () => void): () => void;
+}
+
 /**
  * WQL language support — CodeMirror highlighting + autocomplete over the
  * Lezer grammar (grammar/wql.grammar).
@@ -447,8 +670,28 @@ interface WqlCompletionOptions {
      * `() => resolver.list().map(e => e.slug)`.
      */
     effortNames?: () => readonly string[];
+    /**
+     * Dynamic values for the frontmatter typed-tag filters (`{domain:…}`,
+     * `{format:…}`, `{equipment:…}`, `{quality:…}`, `{intent:…}`) — fed from
+     * the tags store's `by-type` index:
+     * `async key => (await storage.getAllFromIndex('tags', 'by-type', key)).map(t => t.label)`.
+     * Absent or empty results fall through to catalog discovery.
+     */
+    tagTypeValues?: (key: string) => Promise<readonly string[]> | readonly string[];
+    /**
+     * Host-supplied values for a filter key (e.g. the composer's suggestion
+     * feeds). Non-empty results win over the static vocabularies below.
+     */
+    values?: (key: string) => Promise<readonly Completion[]>;
+    /**
+     * Injected field catalog (ticket 15): discovered typed variants join the
+     * static metric vocabulary, and categorical values back filter-value
+     * suggestions for discovered fields. Bounded prefix lookups only — the
+     * catalog never scans event/result history.
+     */
+    catalog?: IFieldCatalog;
 }
-declare function wqlCompletionSource(options_?: WqlCompletionOptions): (context: CompletionContext) => CompletionResult | null;
+declare function wqlCompletionSource(options_?: WqlCompletionOptions): (context: CompletionContext) => CompletionResult | Promise<CompletionResult | null> | null;
 declare function wqlCompletion(options?: WqlCompletionOptions): Extension;
 /**
  * Query-field colors, mapped onto the app's theme tokens so
@@ -460,141 +703,244 @@ declare const wqlHighlightStyle: HighlightStyle;
 declare function wql(completionOptions?: WqlCompletionOptions): LanguageSupport;
 
 /**
- * Analytics unit conversion seam — narrow, fake-free, pure.
+ * WQL unit policy (wayfinder ticket 13, home per decision ticket 21).
  *
- * Supports exactly the unit families analytics currently needs:
- *   - mass: kg ↔ lb (exact 0.45359237 kg per lb)
- *   - distance: m ↔ km
+ * Recognition and conversion evidence live in the core catalog — this module
+ * adds the wql application policy: strict conversion before arithmetic, the
+ * system-default output table applied when the query has no `in <unit>`
+ * directive, and errors (never pass-through) for unknown units and
+ * dimension-incompatible conversions.
  *
- * Any unknown or incompatible units pass through unchanged.
+ * Cutover notes (ticket 13): the old first-record-unit fallback and the
+ * unknown/incompatible pass-through in `resolveDisplayUnit` are gone. The
+ * host `kg | lb` widget preference is no longer a tier in the default chain —
+ * `useAnalyticsUnitPreference` callers migrate to the system defaults under
+ * ticket 19; no new callers allowed.
  */
-declare const KG_PER_LB = 0.45359237;
+
+/** Legacy 2-family vocabulary kept only as a type alias for existing
+ *  callers of the display seam; arithmetic dimensions come from the catalog. */
 type UnitFamily = 'mass' | 'distance';
-interface UnitFamilyDef {
-    /** Base unit for the family (used for documentation, not conversion). */
-    base: string;
-    /** Factor to convert FROM this unit TO the base unit. */
-    units: Record<string, number>;
-}
-declare const UNIT_FAMILIES: Record<UnitFamily, UnitFamilyDef>;
-declare function getUnitFamily(unit: string | undefined): UnitFamily | undefined;
-/**
- * Convert a value between known units.
- *
- * Returns the input unchanged when:
- *   - from === to
- *   - either unit is unknown
- *   - the units belong to different families
- */
-declare function convert(value: number, from: string | undefined, to: string | undefined): number;
-/**
- * Determine the target display unit for a set of matched facts and query
- * options. Returns the unit to render and whether values should be converted.
- */
-declare function resolveDisplayUnit(facts: ReadonlyArray<{
+/** The fact-unit shape resolveOutputUnit reads. */
+interface UnitBearingFact {
     unit?: string;
     metricUnit?: string;
-}>, { directive, preferred, }: {
-    directive?: string;
-    preferred?: string;
-}): {
+}
+/** Display conversion for UI surfaces (RawPointsTable etc.): converts
+ *  within a shared dimension through the catalog, passes unknown or
+ *  cross-dimension values through unchanged instead of throwing. Arithmetic
+ *  must use {@link convertViaCatalog}. Ticket 19 migrates the remaining
+ *  display callers onto renderer formatting. */
+declare function convertDisplay(value: number, from: string | undefined, to: string | undefined): number;
+/** Dimension compatibility probe for display surfaces. */
+declare function getUnitFamily(unit: string | undefined): string | undefined;
+interface OutputUnitResolution {
+    /** The resolved output unit — undefined means unitless / no conversion. */
     unit?: string;
+    /** Whether fact values must be converted into `unit` before aggregation. */
     convert: boolean;
-};
-
+    /** Diagnostic when the directive is unusable for this result (unknown
+     *  unit, or dimension-incompatible with the selected observations). */
+    error?: string;
+}
 /**
- * Workout derivation helpers for WQL QueryService and cross-store joins.
+ * Resolve the output unit for an aggregate result (arithmetic contract §5):
+ *
+ * 1. an explicit `in <unit>` directive wins when it is a known unit and
+ *    dimensionally compatible with the observations; incompatible → error
+ *    for the affected calculation;
+ * 2. otherwise the system default for the observations' dimension
+ *    (mass `kg`, distance `m`, duration `s`, …; ratio unitless);
+ * 3. observations with no unit at all stay unitless — no first-record
+ *    fallback, no reinterpretation of stored measurements.
  */
+declare function resolveOutputUnit(facts: ReadonlyArray<UnitBearingFact>, { directive, preferred, }: {
+    directive?: string;
+    preferred?: string;
+}): OutputUnitResolution;
 
 /**
- * Map a summary projection name to its Canonical Metric Key — the one key two
- * workouts must share for an aggregate to be compared across them. Same key
- * in fact rows and display. 'Total Volume' → 'totalVolume', 'TIS' → 'tis'.
- */
-declare function resolveCanonicalMetricKey(projectionName: string): string;
-/**
- * Identity of the block a result belongs to, stamped on every fact row.
+ * Calendar — system-local civil calendar arithmetic over captured execution
+ * contexts (wayfinder datadog-analytics ticket 12, per the time alignment
+ * contract §§ Evaluation context, Calendar and duration windows).
+ *
+ * Calendar days run from local midnight to the next local midnight in the
+ * context's timezone; weeks start on Monday. All arithmetic is component
+ * math via the timezone's civil date — never multiplication by 86 400 000
+ * ms, which mislabels DST-shifted days. Range endpoints are half-open:
+ * start included, exclusive end; an inclusive `to` civil date is implemented
+ * as an exclusive bound at the following local midnight.
  */
-interface SummaryFactIdentity {
-    noteId: string;
-    resultId: string;
-    /** FK to NoteSegment.id (positional section id of the block run). */
-    segmentId?: string;
-    /** NoteSegment.version at record time. */
-    segmentVersion?: number;
-    /** Content-stable cross-note join key. */
-    blockContentId?: string;
-    /** Which surface produced the result; trend queries exclude 'playground' by default. */
-    origin?: ResultOrigin;
-    /** FK to the `page` store (copied from the parent note). */
-    pageId?: string;
-    /**
-     * Canonical workout time — WorkoutResult.createdAt (true workout end).
-     * Every fact row carries it as `timestamp` so time-range queries mean
-     * "when the workout happened", never "when the metric was derived".
-     */
-    workoutTimestamp?: number;
+/** One captured execution context: every relative window, bucket, and
+ *  boundary decision in a document run resolves against this one capture. */
+interface ExecutionContext {
+    /** Captured current instant (ms epoch). */
+    readonly instant: number;
+    /** IANA timezone name of the effective system timezone. */
+    readonly timeZone: string;
 }
-/** Logs shape read by normalizeSummaryFacts (StoredOutputStatement-compatible). */
-interface SummaryFactSourceOutput {
-    outputType?: string;
-    metrics: readonly {
-        type?: string;
-        value?: unknown;
-        image?: string;
-        unit?: string;
-        /** Summary-processor payload (effortSlug / effortDiscipline / effortIntensityTier / …). */
-        metadata?: Record<string, unknown>;
-    }[];
-    timeSpan?: {
-        started?: number;
-        ended?: number;
-    };
+/** Capture the execution context — once per document run (ticket 19's
+ *  runner captures; QueryService consumes). */
+declare function captureContext(instant?: number, timeZone?: string): ExecutionContext;
+/** The system's IANA timezone. */
+declare function systemTimeZone(): string;
+/** Civil YYYY-MM-DD of `instant` interpreted in `timeZone` — the calendar
+ *  the athlete lives in, not UTC. */
+declare function civilDateOf(instant: number, timeZone: string): string;
+/** Add `days` (may be negative) to a civil date — pure date math across
+ *  month/year boundaries and leap days; no timezone involved. */
+declare function civilDateAdd(iso: string, days: number): string;
+/** Days between two civil dates (second minus first). */
+declare function civilDateDiff(a: string, b: string): number;
+/** The Monday-starting civil week of a civil date. */
+declare function civilMonday(iso: string): string;
+/** The instant of local midnight (00:00) starting civil date `iso` in
+ *  `timeZone` — component math that survives DST boundaries (a 23h or 25h
+ *  day still starts at its own local 00:00). */
+declare function zonedStartOfDay(iso: string, timeZone: string): number;
+/** Local noon of civil date `iso` in `timeZone` — the presentation-only
+ *  representative instant for calendar buckets (never a join key). */
+declare function zonedNoon(iso: string, timeZone: string): number;
+/** A resolved range: [start, end). `endExclusive` marks the half-open
+ *  convention; `end === Number.MAX_SAFE_INTEGER` with `endExclusive ===
+ *  false` is the unbounded side. */
+interface ResolvedRange {
+    readonly start: number;
+    readonly end: number;
+    /** True when `end` is an exclusive half-open bound (calendar windows and
+     *  captured-instant relative cutoffs). */
+    readonly endExclusive: boolean;
 }
-/**
- * Convert Tier-2 summary outputs (outputType 'analytics') in a result's logs
- * into persisted fact rows — one row per result × Canonical Metric Key.
- */
-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}`; canonical workout time wins over the statement's own
- * timeSpan; query-critical scalars promoted top-level.
- */
-declare function toEventRows(logs: readonly StoredOutputStatement[], identity: SummaryFactIdentity): UnifiedEventRecord[];
-/**
- * Tier-2 analytics outputs → deterministic summary event rows (tickets
- * 002/004): id `${resultId}:summary:${rowKey}` — no timestamp salt, so
- * re-finalize overwrites cleanly. Fold identity lives in metrics[0].metadata
- * (canonicalKey, effort metadata, groupTags) — shape-uniform with events.
+/** Resolve a parsed query window against the captured context — the single
+ *  window→range mapping every execution path shares (time contract):
+ *
+ *  - `last Nd`: N local dates including today — midnight N−1 dates back
+ *    through the captured current instant (inclusive cutoff, exclusive
+ *    encoding `instant + 1`). Never N×86 400 000 ms.
+ *  - `last Nw`: current Monday-start week plus N−1 preceding complete
+ *    weeks, through the captured instant. Never a rolling 7N-date window.
+ *  - explicit `from`/`to`: both named dates included in full — implemented
+ *    as an exclusive bound at the following local midnight. An open `to`
+ *    stays unbounded. Future ranges are preserved, never replaced.
  */
-declare function toSummaryEventRows(logs: readonly StoredOutputStatement[], identity: SummaryFactIdentity): UnifiedEventRecord[];
+declare function resolveWindowRange(w: {
+    kind: 'relative';
+    size: number;
+    unit: 'd' | 'w';
+} | {
+    kind: 'range';
+    start: string;
+    end?: string;
+} | 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).
+ *  Unbounded ends admit everything. */
+declare function inRange(instant: number, range: ResolvedRange | undefined): boolean;
+
 /**
- * Event row → flat fact currency for the four-stage plan (ticket 003):
- * one AnalyticsDataPoint per numeric metric. Canonical key resolution
- * mirrors the summary fold — metadata.canonicalKey first, name-derived
- * from the row's label metric as fallback. Deterministic fact ids:
- * `${record.id}:${factOrdinal}`.
+ * Query documents (wayfinder datadog-analytics ticket 17, per the query
+ * documents contract).
+ *
+ * A query block is a self-contained document:
+ *
+ *   defaults [by {dim, …}] [window]
+ *   <ident> = <query | expression> [(normalize <bucket>)] [-> <unit>]
+ *   show <ident>, …
+ *
+ * A body that carries no document constructs parses as a DEGENERATE document
+ * wrapping the single query — zero behavior change for legacy bodies
+ * (decision ticket 22: every widget body is a document; single-line bodies
+ * are degenerate documents).
+ *
+ * Evaluation order follows the reference graph; forward references are
+ * allowed; cycles are a document-level diagnostic.
  */
-declare function projectEventToFacts(record: UnifiedEventRecord): AnalyticsDataPoint[];
 
+interface DocumentDefaults {
+    groupBy?: string[];
+    window?: QueryWindow;
+}
+interface DocumentFormula {
+    expression: string;
+    /** Referenced assignment names, in appearance order. */
+    references: string[];
+    /** Persisted normalization intent (user-selected target bucket). */
+    normalize?: string;
+    /** Explicit output unit directive. */
+    unit?: string;
+}
+interface DocumentAssignment {
+    name: string;
+    kind: 'query' | 'formula';
+    /** For kind 'query' — the parsed query of any family (defaults merged at run). */
+    queryText?: string;
+    parsed?: AnyParsedQuery;
+    formula?: DocumentFormula;
+    raw: string;
+}
+interface QueryDocument {
+    defaults?: DocumentDefaults;
+    assignments: DocumentAssignment[];
+    show: string[];
+    /** True when the body carried no document constructs (legacy single query). */
+    degenerate: boolean;
+}
+interface ParsedDocument {
+    doc: QueryDocument;
+    diagnostics: string[];
+}
 /**
- * Pure projection of a block_index into static Notes — one Note per distinct
- * noteId, with a `catalog` field set to `noteId.split('/')[0]`. The catalog is
- * the directory the file lives under (e.g. `crossfit-girls` for collections,
- * `crossfit-programming` for feeds) and is what the Library's panel uses to
- * target the `+ Filter → Catalog` menu.
+ * Parse a query-document body. Never throws: syntax problems surface as
+ * diagnostics so one broken block never takes down a surface.
  */
-declare function staticNotesFromBlocks(blocks: BlockIndexRow[]): Note[];
+declare function parseDocument(text: string): ParsedDocument;
+/** Lossless serialization: round-trips parse(serialize(parse(text))) to the
+ *  same document (used by dashboards and note rendering to persist intent). */
+declare function serializeDocument(doc: QueryDocument): string;
+
 /**
- * Tag → noteIds index over a block index's frontmatter rows. Static-corpus
- * notes declare tags only in frontmatter `tags:`; this recovers the mapping
- * the note store needs to answer `tags:` clauses (issue #853 — the store
- * previously returned an empty set for every tag).
+ * Contribution selection — grain integrity and coverage (wayfinder
+ * datadog-analytics ticket 16, per the automatic grain contract).
+ *
+ * Coverage is chosen within each workout/result and typed metric — never by
+ * an `any attributed record exists` check over the whole query:
+ *
+ * - Detail observations and substitute summaries of the same population are
+ *   duplicate representations: only one is aggregated (detail wins).
+ * - A summary with a coverage partition (effort / group tags) disjoint from
+ *   the present detail substitutes exactly for its uncovered partition —
+ *   provided its retained statistics answer the requested operation.
+ * - A retained population represented only by an insufficient summary
+ *   reports insufficient evidence — never an invented observation.
+ * - Explicit grain filters are hard source constraints and report
+ *   limitations rather than silently switching representation.
  */
-declare function staticTagIndexFromBlocks(blocks: BlockIndexRow[]): Map<string, Set<string>>;
+
+/** Compact coverage references carried on aggregate results (ticket 16
+ *  explainability; ticket 18's drill-down consumes the on-demand detail). */
+interface CoverageReport {
+    /** (resultId, metric) populations selected as detail observations. */
+    detailPopulations: number;
+    /** Substitute summaries that answered the requested operation. */
+    selectedSummaries: Array<{
+        resultId: string;
+        metricKey: string;
+        coverage?: SummaryCoverage;
+    }>;
+    /** Duplicate representations dropped because detail covered them. */
+    ignoredDuplicates: Array<{
+        resultId: string;
+        metricKey: string;
+        id: string;
+    }>;
+    /** Populations that could not answer the operation — reported, never
+     *  silently omitted and never fabricated. */
+    insufficientScopes: Array<{
+        resultId: string;
+        metricKey: string;
+        reason: string;
+    }>;
+}
 
 /**
  * Injected store interfaces for WQL QueryService.
@@ -610,37 +956,125 @@ declare function staticTagIndexFromBlocks(blocks: BlockIndexRow[]): Map<string,
  * Query Service needs, plus the write contract owned by the write-path
  * lifecycle (ticket 005).
  */
-interface UnifiedEventStore {
+interface EventStore {
+    /** Ticket 12/14 complete-fetch seam: candidates whose METRIC date
+     *  (civil, multiEntry index) falls in the requested dates — rows whose
+     *  own date differs from their fetch-hint timestamp are reachable. */
+    getEventsByMetricDates?(dates: readonly string[]): Promise<EventRecord[]>;
     /** Windowed fetch — the one proven culling index (ticket 001). */
-    getEventsByTimeRange(start: number, end: number): Promise<UnifiedEventRecord[]>;
+    getEventsByTimeRange(start: number, end: number): Promise<EventRecord[]>;
     /** Per-result fetch (rows:{result:…}, re-finalize, orphan inspection). */
-    getEventsByResult(resultId: string): Promise<UnifiedEventRecord[]>;
+    getEventsByResult(resultId: string): Promise<EventRecord[]>;
     /** Note-scoped fetch (rows:{note:…}). */
-    getEventsForNote(noteId: string): Promise<UnifiedEventRecord[]>;
+    getEventsForNote(noteId: string): Promise<EventRecord[]>;
     /** Content-scoped fetch — the cross-store join hot path (indexed). */
-    getEventsByContent(blockContentId: string): Promise<UnifiedEventRecord[]>;
+    getEventsByContent(blockContentId: string): Promise<EventRecord[]>;
     /** Full scan — all-time SELECT leg (ticket 001: scan beats non-selective indexes). */
-    scanAll(): Promise<UnifiedEventRecord[]>;
+    scanAll(): Promise<EventRecord[]>;
     /** Append event rows (per-statement flush; same-tick coalescing allowed). */
-    appendEvents(rows: UnifiedEventRecord[]): Promise<void>;
+    appendEvents(rows: EventRecord[]): Promise<void>;
     /** Atomic finalize: clear the result's engine-authored summaries, write finals. */
-    finalizeSummaries(resultId: string, rows: UnifiedEventRecord[]): Promise<void>;
+    finalizeSummaries(resultId: string, rows: EventRecord[]): Promise<void>;
     /** Reconcile deletes (wellness note-save) + GC sweeps. */
     deleteEvents(ids: string[]): Promise<void>;
 }
-/** Store surface for content queries (`find:note`). */
+/** Store surface for content queries (`:note`). */
 interface NoteQueryStore {
     getAllNotes(): Promise<Note[]>;
     getNoteIdsForTag(label: string): Promise<Set<string>>;
     /** Note-tags label set of one note (moved here from FactQueryStore — it
      *  reads note tags, not facts). */
     getNoteTagLabels(noteId: string): Promise<string[]>;
+    /** Indexed/domain candidate read for :note — `selection` carries only
+     *  exact-semantics predicates, so rows are a SUPERSET of the matches and
+     *  QueryService re-applies every residual filter in JS. `undefined` =
+     *  capability unavailable (no domain projection / scoped transaction) →
+     *  the caller falls back to getAllNotes(). Server order/offset/limit ride
+     *  only when no residual filter, window, or join precedes the slice. */
+    queryDomain?(request: {
+        plan: 'notes';
+        selection?: WqlDomainPredicate[];
+        filters?: WqlDomainPredicate[];
+        order?: WqlDomainOrder[];
+        offset?: number;
+        limit?: number;
+    }): Promise<WqlDomainReadResult | undefined>;
 }
-/** Store surface for block-index queries (`find:block`). */
+/**
+ * Candidate/domain read wire — a structural mirror of packages/storage/src/
+ * domain.ts (root-owned). WQL stays DB-independent: no storage-package
+ * dependency; the app adapter bridges these shapes 1:1 to
+ * IStorage.queryDomain. Keep field-by-field compatible with that file.
+ *
+ * Clause algebra (identical to the wire): clauses AND; a clause's value list
+ * ORs; `negate` excludes any row matching any value.
+ */
+type WqlDomainPredicate = {
+    field: 'id' | 'noteId' | 'type' | 'catalog' | 'source' | 'tags' | 'effort';
+    values: string[];
+    negate?: boolean;
+} | {
+    field: 'text';
+    value: string;
+} | {
+    field: 'date';
+    start: number;
+    end: number;
+    endExclusive?: boolean;
+} | {
+    field: 'page';
+    value: boolean;
+}
+/** The :note default page-exclusion stage (notes plan only). `feeds`
+ *  = an authored feed source clause rides along: true drops literal
+ *  type 'page' rows; false drops isPage rows (page-like kinds or page:/
+ *  guides: source prefixes on non-note kinds). */
+ | {
+    field: 'defaultNotes';
+    feeds: boolean;
+} | {
+    field: 'sourceFence';
+};
+/** Server order clause — structural mirror of the storage wire's
+ *  DomainOrder. Only exact-parity orderings are ever sent (natural id order
+ *  matches the historical whole-store iteration order). */
+type WqlDomainOrder = {
+    field: 'id' | 'createdAt' | 'date' | 'title' | 'noteTitle' | 'dataType' | 'position';
+    direction: 'asc' | 'desc';
+};
+/** Candidate read result for the plans WQL consumes. `rows` are original
+ *  entity payloads; the counts follow the wire contract (selected before
+ *  filters, matched before limit) — selectedCount baselines the historical
+ *  pre-filter `stages.selected`, matchedCount is informational (WQL
+ *  recounts after its own residual pipeline and slice). */
+type WqlDomainReadResult = {
+    plan: 'notes';
+    projectionVersion: number;
+    selectedCount: number;
+    matchedCount: number;
+    rows: Note[];
+} | {
+    plan: 'blocks';
+    projectionVersion: number;
+    selectedCount: number;
+    matchedCount: number;
+    rows: BlockIndexRow[];
+};
+/** Store surface for block-index queries (`:block`). */
 interface BlockQueryStore {
     getAllBlocks(): Promise<BlockIndexRow[]>;
+    /** Indexed/domain candidate read for :block — same superset contract as
+     *  the note seam; `undefined` falls back to getAllBlocks(). */
+    queryDomain?(request: {
+        plan: 'blocks';
+        selection?: WqlDomainPredicate[];
+        filters?: WqlDomainPredicate[];
+        order?: WqlDomainOrder[];
+        offset?: number;
+        limit?: number;
+    }): Promise<WqlDomainReadResult | undefined>;
 }
-/** Pure effort model interface for `find:effort` queries. */
+/** Pure effort model interface for `:effort` queries. */
 interface IEffort {
     id: string;
     slug: string;
@@ -655,18 +1089,69 @@ interface IEffort {
     registrySource?: 'bundled' | 'user' | string;
     [key: string]: unknown;
 }
-/** Store surface for effort queries (`find:effort`). */
 interface EffortQueryStore {
     getAllEfforts(): Promise<IEffort[]>;
 }
 /** Optional bundle of stores for QueryService initialization. */
+/** One note's hydration relations — structurally the storage entries
+ *  bundle's relation slice, so a host can bridge its entry batch reads
+ *  (local: one transaction; remote: entries plan with ids chunked at the
+ *  domain parser's 64-value limit) straight through without mapping. WQL
+ *  reads only `label` off each tag record and never imports storage. */
+interface NoteRelationBundle {
+    /** The note's junction tag records (label plane). */
+    tags: ReadonlyArray<{
+        label: string;
+    }>;
+    /** page_notes junction rows for the note; first by position is the
+     *  parent page. */
+    links: PageNote[];
+    /** Resolved junction pages by page id. */
+    pages: Page[];
+}
 interface QueryServiceStores {
-    eventStore?: UnifiedEventStore;
+    eventStore?: EventStore;
     noteStore?: NoteQueryStore;
+    /** Serves every block row — user journal and seeded corpus alike (the
+     *  seed importer materializes corpus rows into the same store). */
     blockStore?: BlockQueryStore;
     effortStore?: EffortQueryStore;
+    /** Derived corpus-note projections (catalog/tag planes). */
     staticNoteStore?: NoteQueryStore;
-    staticBlockStore?: BlockQueryStore;
+    /** Serves exercise containment rows (`block_efforts` store). */
+    blockEffortsStore?: {
+        getAllFromIndex(index: string, key: string): Promise<any[]>;
+    };
+    /** Serves tag records (`tags` store). */
+    tagsStore?: {
+        getAllFromIndex(index: string, key: string): Promise<any[]>;
+    };
+    /** Serves note-tag junction rows (`note_tags` store). */
+    noteTagsStore?: {
+        getAllFromIndex(index: string, key: string): Promise<any[]>;
+    };
+    /** Canonical page_notes junction reads for container resolution — a
+     *  note's parent Page wins over a standalone Note container. */
+    pageStore?: {
+        getNotePages(noteId: string): Promise<PageNote[]>;
+        getPage(pageId: string): Promise<Page | undefined>;
+    };
+    /** Batched relation reads for the hydration paths (containers, run
+     *  tags) — one bundle per distinct note id instead of a page/tag read
+     *  per matched result. Optional: absent → the per-note pageStore /
+     *  noteStore seams above serve each request. */
+    relationStore?: {
+        getBatches(noteIds: readonly string[]): Promise<Map<string, NoteRelationBundle>>;
+    };
+    /** Synchronous named datasets (`@session`, `@today`, user-stored sources)
+     *  populated by the host before queries run — pipeline dataset stages
+     *  never touch the database. */
+    datasetStore?: {
+        getDataset(name: string): {
+            events: EventRecord[];
+            notes: Note[];
+        } | undefined;
+    };
 }
 
 /**
@@ -690,37 +1175,124 @@ interface QueryServiceStores {
  * Fully inverted dependencies: zero IndexedDB/storage module-level imports.
  */
 
+/** Extract the catalog directory id from a Note or BlockIndexRow.
+ *  Uses explicit `catalog` when present; falls back to parsing `sourceId`
+ *  (stripping `collection:`/`feed:` prefixes and `feeds/` path components) or `noteId`.
+ *  Exported so host mappers (Entry derivation) carry the exact field the
+ *  `catalog:` filter matches — presentation catalogs must not diverge. */
+declare function catalogOfItem(item: {
+    id?: string;
+    noteId?: string;
+    sourceId?: string;
+    catalog?: string;
+}): string | undefined;
+/** Match a single row against one source filter value. The `journal` kind matches
+ *  rows with no sourceId, the literal 'journal', or UUID / journal/date lineage
+ *  pointing to the original note. Lineage also passes corpus exclusions below.
+ *  The feed / guide kinds match
+ *  rows whose sourceId starts with the kind (storage identities keep their
+ *  `collection:`/`page:collection:` prefixes — only the query vocabulary
+ *  was renamed). A `kind:id` literal matches the
+ *  exact id. `playground` matches the playground intake's sourceId convention
+ *  and, on the note plane, legacy rows typed 'playground' (playground pages
+ *  saved before the sourceId convention existed — their sourceId is absent).
+ *  `all` spans exactly the WQL source domain plus sourceless rows — identical
+ *  to the source fence. `journal` rejects the rest of the seed corpus: rows
+ *  with seed provenance (importer stamps, or surviving seedChunkId /
+ *  markdown/ sourcePath / catalog on legacy user-edited rows whose
+ *  seedOrigin flipped to 'user') and typed dashboards never journal — a user
+ *  journal note carries none of those markers. Exported so host mappers
+ *  classify result rows with the exact predicate the `source:` filter
+ *  applies. */
+declare function sourceMatches(item: {
+    id?: string;
+    noteId?: string;
+    sourceId?: string;
+    type?: string;
+    seedOrigin?: string;
+    seedChunkId?: string;
+    sourcePath?: string;
+    catalog?: string;
+}, kind: string): boolean;
 interface FindQueryResult {
     parsed: ParsedFindQuery;
     notes: Note[];
     blocks: BlockIndexRow[];
-    /** Registry rows for find:effort queries. */
+    /** Registry rows for :effort queries. */
     efforts?: IEffort[];
+    /** Session run cards for :session queries (#1041). */
+    runs?: RowsRun[];
+    /** Tabular output for :segment and :event queries (#1042). */
+    table?: TabularResult;
+    /** Raw event rows behind the result — session run statements and table
+     *  observations. Pipeline stages aggregate these in memory (no re-read). */
+    events?: EventRecord[];
+    /** Highest container per note id: the parent Page when the canonical
+     *  page_notes junction links one, else the standalone Note. Present only
+     *  when a pageStore is injected and notes were matched. */
+    containers?: Record<string, NoteContainer>;
     stages: {
         selected: number;
         matched: number;
     };
 }
+/** Highest-container link for a matched note (parent Page wins). `slug` and
+ *  `date` route app URLs (/p/:slug, /journal/:date). Core Page has no type —
+ *  the parent is never classified by the note's kind. */
+type NoteContainer = {
+    kind: 'page';
+    id: string;
+    slug?: string;
+    date?: string;
+} | {
+    kind: 'note';
+    id: string;
+};
+/** Options for runPipeline: query options plus host-populated datasets.
+ *  `pageSources` wins over an injected `datasetStore`; both are synchronous
+ *  in-memory lookups — dataset stages never roundtrip the database. */
+interface PipelineOptions extends QueryOptions {
+    /** Host-populated datasets keyed by name (names include `@`). */
+    pageSources?: ReadonlyMap<string, {
+        events: EventRecord[];
+        notes: Note[];
+    }>;
+}
+/** Result of one pipeline run: the final stage's data under its existing
+ *  result type, plus the chart sink marker for the renderer. */
+interface PipelineResult {
+    parsed: ParsedPipelineQuery;
+    series?: Series[];
+    table?: TabularResult;
+    notes?: Note[];
+    blocks?: BlockIndexRow[];
+    efforts?: IEffort[];
+    runs?: RowsRun[];
+    /** Highest container per note id (see FindQueryResult.containers). */
+    containers?: Record<string, NoteContainer>;
+    unit?: string;
+    chart?: PipelineSink;
+    error?: string;
+}
 interface QueryOptions {
     rangeStart?: number;
     rangeEnd?: number;
     /** App-level unit preference ('kg' | 'lb'). Used when query has no `in <unit>` directive. */
     preferredUnit?: string;
+    /** Captured execution context (ticket 12) — one `{instant, timeZone}`
+     *  capture per document run; defaults to a fresh system capture. */
+    context?: ExecutionContext;
 }
 /** Options for `runFind` / `runFindBlock` — overrides for the parsed WQL. */
 interface FindOptions {
-    /** Explicit timestamp range; overrides parsed WQL's `last` clause when set. */
-    range?: {
-        start: number;
-        end: number;
-    };
-    /** Time-window anchoring mode. 'wall-clock' anchors to Date.now();
-     *  'latest-activity' anchors to the newest row in the scope selection
-     *  (#857). Defaults to 'wall-clock'. */
-    anchor?: 'wall-clock' | 'latest-activity';
-    /** Explicit reference time for the window (useful for tests/replay).
-     *  Overrides `anchor`. */
+    /** Host-supplied timestamp range (half-open [start, end)) — the DEFAULT
+     *  when the parsed WQL has no window; an explicit query window wins. */
+    range?: ResolvedRange;
+    /** Explicit reference time for the window (tests/replay). Superseded by
+     *  `context` when both are given. */
     anchorNow?: number;
+    /** Captured execution context (ticket 12). */
+    context?: ExecutionContext;
 }
 interface QueryResult {
     parsed: ParsedAggregateQuery;
@@ -736,6 +1308,10 @@ interface QueryResult {
     scalar?: number;
     /** Result display unit, if determined by directive, preference, or fact metadata. */
     unit?: string;
+    /** First diagnostic across series (ticket 13) — per-widget badges in 19. */
+    error?: string;
+    /** Compact coverage references (ticket 16 explainability). */
+    coverage?: CoverageReport;
 }
 /** One run in a rows result: the canonical result identity plus the event
  *  rows that survived the optional output-type narrowing (`rows:segment{…}`). */
@@ -744,48 +1320,125 @@ interface RowsRun {
     noteId: string;
     /** Canonical workout time (result.createdAt under the unified model). */
     timestamp: number;
-    events: UnifiedEventRecord[];
+    events: EventRecord[];
 }
 interface RowsQueryResult {
     parsed: ParsedRowsQuery;
     runs: RowsRun[];
     error?: string;
+    /** Ticket 18 — cross-workout tabular result (cross-workout rows only). */
+    table?: TabularResult;
+}
+interface TabularColumn {
+    name: string;
+    type: 'date' | 'string' | 'number';
+    unit?: string;
+}
+/** Civil dates (YYYY-MM-DD, `timeZone`-local) whose [local midnight,
+ * next local midnight) windows intersect `[start, end)` — the by-metric-date
+ * candidate set for the complete fetch (ticket 12/14). Callers pass bounded
+ * ranges only: an unbounded side uses the all-store scan as the complete
+ * fetch instead of enumerating an open horizon. */
+declare function civilDatesCoveredByRange(start: number, end: number, timeZone: string): string[];
+/** The stable tabular shape consumed by table widgets (ticket 19 wires
+ *  widgets): bounded page + full match count. Missing column values are
+ *  ABSENT (undefined) — strictly distinct from a recorded 0. */
+interface TabularGroup {
+    key: string;
+    label: string;
+    rows: Array<Record<string, unknown>>;
+}
+interface TabularResult {
+    columns: TabularColumn[];
+    rows: Array<Record<string, unknown>>;
+    groups?: TabularGroup[];
+    totalCount: number;
+    limit?: number;
+    offset?: number;
 }
+/** Structural missing-group sentinel — distinct from any literal text
+ *  (group identity is the JSON tuple, so it cannot collide). */
+declare const UNASSIGNED = "\0unassigned";
 declare class QueryService {
     private readonly store;
     private readonly noteStore;
     private readonly blockStore;
     private readonly effortStore;
     private readonly staticNoteStore?;
-    private readonly staticBlockStore?;
-    constructor(storesOrEventStore?: QueryServiceStores | UnifiedEventStore, noteStore?: NoteQueryStore, blockStore?: BlockQueryStore, effortStore?: EffortQueryStore, staticNoteStore?: NoteQueryStore, staticBlockStore?: BlockQueryStore);
+    private readonly pageStore?;
+    private readonly relationStore?;
+    private readonly datasetStore?;
+    private blockEffortsStore;
+    private tagsStore;
+    private noteTagsStore;
+    constructor(storesOrEventStore?: QueryServiceStores | EventStore, noteStore?: NoteQueryStore, blockStore?: BlockQueryStore, effortStore?: EffortQueryStore, staticNoteStore?: NoteQueryStore);
     /** Windowed flat-fact fetch — the projected view over the event store. */
     getFactsByTimeRange(start: number, end: number): Promise<AnalyticsDataPoint[]>;
     runQuery(raw: string, options?: QueryOptions): Promise<QueryResult>;
     /**
-     * Execute a rows query (rows:<target>{…}, #949/C4) — the session results
-     * table plane. Filter rules are validated at parse; this executes only.
-     * Reads event rows directly over the unified store: outputType narrowing
-     * hits the promoted column; content-plane targets scope by content.
+     * Legacy rows-family executor kept for hand-built ASTs (RowsTable, CLI).
+     * Text `rows:…` no longer parses (#1044); this delegates to the find paths
+     * so a programmatic ParsedRowsQuery still resolves.
      */
     runRows(parsed: ParsedRowsQuery, options?: {
         anchorNow?: number;
+        context?: ExecutionContext;
     }): Promise<RowsQueryResult>;
     /**
-     * Execute a content-discovery query (find:note). Naive in-memory filtering
+     * Execute a :session query (#1041/#1042) — grouped run cards per completed session.
+     */
+    runFindSession(parsed: ParsedFindQuery, options?: FindOptions): Promise<FindQueryResult>;
+    /**
+     * Execute a :segment or :event query (#1042/#1048) — flat cross-workout table.
+     */
+    runFindTable(parsed: ParsedFindQuery, options?: FindOptions): Promise<FindQueryResult>;
+    /**
+     * Execute a content-discovery query (:note). Naive in-memory filtering
      * per the tracer-bullet scope (#797): load all notes, then apply tag/text/
      * time filters.
      */
     runFind(parsed: ParsedFindQuery, options?: FindOptions): Promise<FindQueryResult>;
+    /** Highest container per note id: the parent Page from the canonical
+     *  page_notes junction (first link by position) wins; a note with no page
+     *  link stays a standalone Note container. Batched when a relationStore
+     *  is injected — one bundle read per run instead of a link/page read per
+     *  matched note. */
+    private containersForNotes;
     /**
-     * Execute a find:block query against the derived block_index store.
+     * Execute a :block query against the derived block_index store.
      */
     runFindBlock(parsed: ParsedFindQuery, options?: FindOptions): Promise<FindQueryResult>;
     /**
-     * Execute a find:effort query against the effort registry.
+     * Execute a :effort query against the effort registry.
      */
     runFindEffort(parsed: ParsedFindQuery): Promise<FindQueryResult>;
-    run(parsed: ParsedAggregateQuery, options?: QueryOptions): Promise<QueryResult>;
+    run(parsed: AnyParsedQuery, options?: QueryOptions): Promise<QueryResult>;
+    /**
+     * In-memory aggregation over ALREADY-FETCHED event rows — the pipeline
+     * dataset/transform path. Identical metric projection, selection,
+     * bucketing, unit, and aggregation stages as `run`; no store reads (a
+     * content join on carried data is REJECTED by runAggregateEvents — it
+     * would abandon the carried population).
+     */
+    runAggregateEvents(query: ParsedAggregateQuery, events: readonly EventRecord[], options?: QueryOptions): Promise<QueryResult>;
+    /** Public pipeline executor — parse the text, then run. */
+    runPipeline(queryText: string, options?: PipelineOptions): Promise<PipelineResult>;
+    /** Execute an already-parsed pipeline: resolve the source once, then flow
+     *  the carried value left to right through the transforms — each function
+     *  reduces the PRECEDING stage, never an independent re-query. Dataset
+     *  stages look up `pageSources` (then an injected datasetStore)
+     *  synchronously; no database roundtrip. */
+    runPipelineParsed(parsed: AnyParsedQuery, 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. */
+    private sourceEventsFromFind;
+    /** QueryExecutor adapter: a pipeline run's final stage rendered as the
+     *  aggregate QueryResult shape chart consumers already read. */
+    private pipelineResultToQueryResult;
+    /** Stages 2–4 over raw event rows: project → metric filter → range filter
+     *  → tag filters → coverage selection → BUCKET/GROUP/AGGREGATE. */
+    private aggregateEventRows;
     /**
      * Stages 2–4 — BUCKET → GROUP → AGGREGATE over an already-selected +
      * filtered `matched` set.
@@ -795,30 +1448,388 @@ declare class QueryService {
      *  blockContentIds owned by the find predicate's content matches. */
     private runJoined;
     /** Direction 1 — keep only content owning a wod block whose raw-log metric
-     *  aggregate satisfies the predicate. `notes` for find:note, `blocks` for
-     *  find:block. */
+     *  aggregate satisfies the predicate. `notes` for :note, `blocks` for
+     *  :block. */
     private applyMetricJoin;
     /** Re-derive the metric from raw logs for each content id, aggregate per id,
      *  and return the ids whose aggregate satisfies the join predicate. */
     private contentIdsSatisfying;
-    /** Filter per-effort vs un-attributed overall summary rows to avoid
-     *  double-counting. */
-    private applyEffortScope;
     /** Summary facts for one Canonical Metric Key across the given content ids —
      *  the cross-store join source. Reads finalize-written summary rows straight
      *  off the content index (ticket 003: the store is authoritative; the old
      *  freshness re-derivation is moot). One fact row per result × rowKey. */
     private deriveMetricFacts;
-    /** All content blocks across the journal + static corpus. */
+    /** All content blocks — journal and seeded corpus in one store. */
     private allContentBlocks;
     /** Map each note id to the wod blockContentIds it owns. */
     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'. */
+    /** 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;
+    /** 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). */
+    private getNoteIdsForTypedTag;
+    /**
+     * Find catalogs: identifies catalogs whose member notes (or catalog landing
+     * notes) match the authored criteria (effort, tags, text, typed tags, etc.).
+     */
+    private runFindCatalog;
+}
+
+/**
+ * Document runner + formula evaluation (wayfinder datadog-analytics
+ * ticket 17).
+ *
+ * - `FormulaEvaluator` is an INJECTED capability: the engine/app composition
+ *   adapts lang's calc Pratt evaluator behind it. `wql` ships a small
+ *   built-in pointwise arithmetic evaluator so documents evaluate without
+ *   the injection (add/sub/mul/div, corr) — never a dependency on lang.
+ * - Post-aggregate formulas evaluate pointwise over the ALIGNMENT DOMAIN:
+ *   the intersection of input requested ranges and the union of observed
+ *   group tuples. Missing operands substitute zero, flagged as
+ *   missing-derived; missing-derived zeros are excluded from downstream
+ *   ordinary averages; division by zero propagates an error.
+ * - `corr(a, b)` is paired-only over in-range positions; the pair count is
+ *   reported.
+ */
+
+/** Presence provenance of one operand value at one aligned position. */
+interface OperandValue {
+    value: number;
+    /** True when the value was substituted for a missing input. */
+    missingDerived: boolean;
+}
+type PointwiseInputs = Record<string, (position: number) => OperandValue | undefined>;
+interface FormulaEvaluation {
+    value: number;
+    missingDerived: boolean;
+    error?: string;
+}
+interface FormulaEvaluator {
+    /**
+     * Evaluate `expression` at one aligned position. `inputs` maps referenced
+     * assignment names to position accessors; a missing operand is `undefined`
+     * (the evaluator substitutes zero and flags the result).
+     */
+    evaluate(expression: string, inputs: PointwiseInputs, position: number): FormulaEvaluation;
+}
+/** Built-in pointwise arithmetic evaluator (+ - * /, unary minus, corr-free). */
+declare function createBuiltinFormulaEvaluator(): FormulaEvaluator;
+/** Append document-default window/groupBy as textual suffixes before family
+ *  dispatch — defaults apply to find and pipeline documents too (a bare
+ *  `last 4w` block default must bound a `:journal{…}` content run). */
+declare function appendSuffixes(queryText: string, window: QueryWindow, groupBy?: string[]): string;
+/** One ordered `show` output — widget-independent (ticket 19 consumes). */
+interface DocumentOutput {
+    name: string;
+    kind: 'aggregate' | 'formula' | 'find' | 'pipeline';
+    /** Ticket 19 — TabularResult for cross-workout rows outputs. */
+    table?: TabularResult;
+    unit?: string;
+    groupBy?: string[];
+    window?: QueryWindow;
+    /** Series for aggregate and formula outputs. */
+    series?: Array<{
+        key: string;
+        label: string;
+        points: Array<{
+            ts: number;
+            value: number;
+            missing?: boolean;
+            missingDerived?: boolean;
+        }>;
+        unit?: string;
+    }>;
+    /** Formula provenance: pair counts for corr, coverage notes. */
+    pairs?: number;
+    /** Content-plane payloads (find / find-source pipeline outputs). */
+    notes?: Note[];
+    blocks?: BlockIndexRow[];
+    efforts?: unknown[];
+    /** Highest-container page/note links keyed by note id. */
+    containers?: Record<string, NoteContainer>;
+    /** Session run cards (find:session / session-source pipelines). */
+    runs?: RowsRun[];
+    /** Terminal chart sink of a pipeline output (renderer dispatch). */
+    chart?: PipelineSink;
+    error?: string;
+}
+interface DocumentResult {
+    outputs: DocumentOutput[];
+    diagnostics: string[];
+}
+/** Payload surfaces the ticket-19 family dispatch may hand back. */
+interface FamilyRunPayload {
+    series?: DocumentOutput['series'];
+    table?: TabularResult;
+    notes?: Note[];
+    blocks?: BlockIndexRow[];
+    efforts?: unknown[];
+    containers?: Record<string, NoteContainer>;
+    runs?: RowsRun[];
+    unit?: string;
+    chart?: PipelineSink;
+    error?: string;
+}
+interface QueryDocumentRunnerOptions {
+    /** Injected formula evaluator (lang's calc evaluator via the engine). */
+    formulaEvaluator?: FormulaEvaluator;
+    /** Host default window — used only when the document has none. */
+    rangeStart?: number;
+    rangeEnd?: number;
+    /** Ticket 19 family dispatch: find queries surface FindQueryResult. */
+    runFind?: (queryText: string) => Promise<FamilyRunPayload>;
+    /** Pipeline queries (`:source | :fn | :chart`, `@dataset | …`) surface
+     *  the pipeline result — the host's QueryService.runPipeline. */
+    runPipeline?: (queryText: string) => Promise<FamilyRunPayload>;
+}
+declare class QueryDocumentRunner$1 {
+    private readonly runAggregate;
+    private readonly evaluator;
+    constructor(runAggregate: (queryText: string, overrides: {
+        groupBy?: string[];
+        window?: QueryWindow;
+    }) => Promise<{
+        series?: DocumentOutput['series'];
+        unit?: string;
+        error?: string;
+        window?: QueryWindow;
+    }>, options?: QueryDocumentRunnerOptions);
+    private readonly options;
+    /** Parse → validate → evaluate in reference order → ordered outputs. */
+    run(text: string): Promise<DocumentResult>;
+    /** Defaults precedence (ticket 17): explicit per-query range/grouping >
+     *  block defaults > host. Explicit per-query by{} fully replaces block
+     *  grouping — never merges. */
+    private mergeDefaults;
 }
 
+/**
+ * QueryDocumentRunner — the ONE execution path for query documents
+ * (wayfinder datadog-analytics ticket 19, per the shared query execution
+ * contract). Dashboard surfaces and embedded note query documents evaluate
+ * through this runner via a host adapter; no surface runs queries itself.
+ *
+ * Per document run:
+ *   1. token substitution (`$name` → active parameter values, raw text);
+ *   2. parse as a QueryDocument (degenerate single query = legacy body);
+ *   3. AST rollup inspection — `calc.*`-class targets (including pipeline
+ *      transform stages) trigger the host's rollup-ensure ONCE per run
+ *      (never string matching over query text);
+ *   4. one captured execution context threads every window resolution;
+ *   5. family dispatch: aggregate → aggregate run, find → runFind,
+ *      rows → runRows, pipeline → runPipeline.
+ *
+ * Zero browser dependencies — stores, catalog, and evaluator are injected.
+ * Hosts that lack a family capability surface a diagnostic on the output —
+ * never a silent empty result.
+ */
+
+/** Host-populated page source dataset: named standard sources (`@session`,
+ *  `@today`, user names include `@`) resolved in memory before queries run. */
+interface PageSourceEntry {
+    events: EventRecord[];
+    notes: Note[];
+}
+/**
+ * PageSourceRegistry — the host's named page-source store (ticket 5).
+ * Constructed/populated ONCE per page load / run context, BEFORE child
+ * queries evaluate. Dataset pipeline stages (`@today | :sum{…}`) read it
+ * synchronously through `QueryServiceStores.datasetStore` — no database
+ * roundtrip downstream.
+ */
+declare class PageSourceRegistry extends Map<string, PageSourceEntry> {
+    /** QueryService datasetStore seam alias — names include the `@`. */
+    getDataset(name: string): PageSourceEntry | undefined;
+}
+interface QueryDocumentRunnerHost {
+    runAggregate(queryText: string, overrides: {
+        groupBy?: string[];
+        window?: QueryWindow;
+        context?: ExecutionContext;
+    }): Promise<{
+        series?: DocumentOutput['series'];
+        unit?: string;
+        error?: string;
+    }>;
+    runFind?(queryText: string, context?: ExecutionContext): Promise<{
+        kind: 'find';
+        notes?: Note[];
+        blocks?: BlockIndexRow[];
+        efforts?: unknown[];
+        containers?: Record<string, NoteContainer>;
+        runs?: RowsRun[];
+        table?: TabularResult;
+        unit?: string;
+        error?: string;
+    }>;
+    /** Pipeline execution (`:source | :fn | :chart`, `@dataset | …`) — the
+     *  host's QueryService.runPipeline. */
+    runPipeline?(queryText: 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;
+    /** Host rollup driver: recompute-on-open for `calc.*` facts. Must skip
+     *  already-up-to-date prerequisites (no ensure→refresh loop). */
+    rollupEnsure?: () => Promise<void>;
+}
+interface SharedRunnerOptions {
+    formulaEvaluator?: FormulaEvaluator;
+    /** One captured execution context per document run (ticket 12). */
+    context?: ExecutionContext;
+    /** Host default range — applies only when the document has no window. */
+    rangeStart?: number;
+    rangeEnd?: number;
+    /** Active token values (frontmatter controls, dashboard controls). */
+    tokens?: Record<string, string>;
+}
+declare class QueryDocumentRunner {
+    private readonly host;
+    private readonly initialOptions;
+    constructor(host: QueryDocumentRunnerHost, options?: SharedRunnerOptions);
+    /**
+     * Run one document. `runOptions` override construction-time captures
+     * (tokens, context) — one capture per run. Each run gets its OWN
+     * evaluation snapshot: overlapping runs (one awaiting rollupEnsure while
+     * another executes) can never borrow each other's context.
+     */
+    run(text: string, runOptions?: SharedRunnerOptions): Promise<DocumentResult>;
+}
+/** Substitute `$name` tokens with active parameter values (raw text). */
+declare function substituteTokens$1(text: string, tokens: Record<string, string>): string;
+/**
+ * AST rollup inspection (replaces `.includes('calc.')` string sniffing):
+ * true when the parsed head's metric — a pipeline's source aggregate metric
+ * or any transform stage's — is a calc target whose derivation depends on
+ * workload rollup facts.
+ */
+declare function consumesRollupFacts(parsed: AnyParsedQuery | undefined): boolean;
+
+/**
+ * Workout derivation helpers for WQL QueryService and cross-store joins.
+ */
+
+/**
+ * Map a summary projection name to its Canonical Metric Key — the one key two
+ * workouts must share for an aggregate to be compared across them. Same key
+ * in fact rows and display. 'Total Volume' → 'totalVolume', 'TIS' → 'tis'.
+ */
+declare function resolveCanonicalMetricKey(projectionName: string): string;
+/**
+ * Identity of the block a result belongs to, stamped on every fact row.
+ */
+interface SummaryFactIdentity {
+    noteId: string;
+    resultId: string;
+    /** FK to NoteSegment.id (positional section id of the block run). */
+    segmentId?: string;
+    /** NoteSegment.version at record time. */
+    segmentVersion?: number;
+    /** Content-stable cross-note join key. */
+    blockContentId?: string;
+    /** Which surface produced the result; trend queries exclude 'playground' by default. */
+    origin?: ResultOrigin;
+    /** FK to the `page` store (copied from the parent note). */
+    pageId?: string;
+    /**
+     * Canonical workout time — WorkoutResult.createdAt (true workout end).
+     * Every fact row carries it as `timestamp` so time-range queries mean
+     * "when the workout happened", never "when the metric was derived".
+     */
+    workoutTimestamp?: number;
+}
+/** Logs shape read by normalizeSummaryFacts (StoredOutputStatement-compatible). */
+interface SummaryFactSourceOutput {
+    outputType?: string;
+    metrics: readonly {
+        type?: string;
+        value?: unknown;
+        image?: string;
+        unit?: string;
+        /** Summary-processor payload (effortSlug / effortDiscipline / effortIntensityTier / …). */
+        metadata?: Record<string, unknown>;
+    }[];
+    timeSpan?: {
+        started?: number;
+        ended?: number;
+    };
+}
+/**
+ * Convert Tier-2 summary outputs (outputType 'analytics') in a result's logs
+ * into persisted fact rows — one row per result × Canonical Metric Key.
+ */
+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
+ * 002/004): id `${resultId}:summary:${rowKey}` — no timestamp salt, so
+ * re-finalize overwrites cleanly. Fold identity lives in metrics[0].metadata
+ * (canonicalKey, effort metadata, groupTags) — shape-uniform with events.
+ */
+declare function toSummaryEventRows(logs: readonly StoredOutputStatement[], identity: SummaryFactIdentity): EventRecord[];
+/**
+ * Event row → flat fact currency for the four-stage plan (ticket 003):
+ * one AnalyticsDataPoint per numeric metric. Canonical key resolution
+ * mirrors the summary fold — metadata.canonicalKey first, name-derived
+ * from the row's label metric as fallback. Deterministic fact ids:
+ * `${record.id}:${factOrdinal}`.
+ */
+declare function projectEventToFacts(record: EventRecord): AnalyticsDataPoint[];
+/**
+ * Inverse of {@link toEventRows}/{@link toSummaryEventRows}: rebuild the
+ * statement stream a session's event rows represent. Event rows keep their
+ * recorded order (id `${resultId}:${seq}`); summary rows follow in fold
+ * order. Consumers that need the statement shape (replay, review display)
+ * read events and call this — the store keeps only event rows.
+ */
+declare function eventsToStoredLogs(events: readonly EventRecord[]): StoredOutputStatement[];
+
+/**
+ * Landing/catalog projection for a block row, derived from its sourceId route
+ * (`collection:<catalog>/<item>`, `page:collection:<catalog>`,
+ * `feed:feeds/<catalog>/…`) — never from `noteId`, which is a UUID for
+ * imported notes. Legacy path-keyed rows keep deriving from the noteId stem
+ * through `catalogOfItem` (undefined for UUID or no path); a bare
+ * `collection:<catalog>` route is the legacy landing and gets its canonical
+ * `page:collection:` sourceId.
+ */
+declare function staticCatalogRoute(block: Pick<BlockIndexRow, 'noteId' | 'sourceId'>): {
+    landing: boolean;
+    catalog?: string;
+    sourceId?: string;
+};
+/**
+ * Pure projection of a block_index into static Notes — one Note per distinct
+ * noteId. `id` stays the canonical storage identity (UUID for imported rows);
+ * `catalog` and feed-landing status come from the sourceId route, not
+ * the noteId path. The catalog (e.g. `crossfit-girls`) is what the Library's
+ * panel uses to target the `+ Filter → Catalog` menu.
+ */
+declare function staticNotesFromBlocks(blocks: BlockIndexRow[]): Note[];
+/**
+ * Tag → noteIds index over a block index's frontmatter rows. Static-corpus
+ * notes declare tags only in frontmatter `tags:`; this recovers the mapping
+ * the note store needs to answer `tags:` clauses (issue #853 — the store
+ * previously returned an empty set for every tag).
+ */
+declare function staticTagIndexFromBlocks(blocks: BlockIndexRow[]): Map<string, Set<string>>;
+
 /**
  * Dashboard Note model (#898 map, format locked in #899).
  *
@@ -827,12 +1838,13 @@ declare class QueryService {
  * ```query[:<type>][-<N>|-full] blocks whose title/question associate from the
  * markdown heading/paragraph directly above each block. Queries reference
  * tokens as `$name`, substituted as raw text at execution time. A block body
- * is one line: WQL query + optional `/`-separated positional params.
+ * body is a Query Document (decision 22); presentation params ride the
+ * fence tag as `key=value` attributes.
  *
  * 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", "value", "timeseries", "bar", "toplist", "stacked-bar", "goal-rings", "zone-distribution"];
+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`. */
@@ -856,6 +1868,11 @@ interface QueryWidgetSuffix {
     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;
 }
@@ -899,16 +1916,6 @@ declare function substituteTokens(query: string, values: Record<string, string>)
 };
 /** Token names a query references, in order of first appearance. */
 declare function referencedTokens(query: string): string[];
-/**
- * Split a block body into the WQL query and its trailing `/`-separated
- * positional parameters (decision #899-7). Splits at the FIRST ` / ` so
- * params stay trailing; a literal ` / ` inside a tag value is pathological
- * and unsupported. Params are whitespace-split literals or `$token` refs.
- */
-declare function splitWidgetBody(body: string): {
-    query: string;
-    params: string[];
-};
 /** Structural input for the builder — satisfied by EditorSection + doc text. */
 interface DashboardSectionInput {
     /** Section type ('query', 'markdown', 'frontmatter', …). */
@@ -925,6 +1932,9 @@ interface DashboardSectionInput {
     spanFull?: boolean;
     /** Malformed fence-suffix reason — carried so route mode badges it too. */
     widgetError?: string;
+    /** Fence-tag presentation attributes (decision 22). */
+    attributes?: Record<string, string>;
+    attributeOrder?: string[];
 }
 interface DashboardWidget {
     /** Stable key within the document (section index). */
@@ -933,14 +1943,15 @@ interface DashboardWidget {
     type: string;
     spanCols?: number;
     spanFull?: boolean;
-    /** Raw block body (query + params). */
+    /** Full fenced body — a Query Document (decision 22), comment lines
+     *  stripped, surrounding whitespace trimmed, line structure preserved. */
     body: string;
     /** Malformed fence-suffix reason — renderers badge instead of executing. */
     widgetError?: string;
-    /** WQL query after parameter split. */
-    query: string;
-    /** Positional parameters (literals or `$token` refs). */
-    params: string[];
+    /** Fence-tag presentation attributes (decision 22) — positional params
+     *  ride the tag, never the body. */
+    attributes: Record<string, string>;
+    attributeOrder: string[];
     /** Title from the markdown heading directly above (or above the question). */
     title?: string;
     /** Coaching question from the paragraph directly above the block. */
@@ -1035,17 +2046,109 @@ declare function parseFlatProperties(innerContent: string): Record<string, strin
  */
 declare function parseFrontmatterProps(lines: string[]): Record<string, string>;
 
+/**
+ * Dashboard note operations — pure markdown↔markdown transforms over the
+ * locked dashboard-note format (#899). Every operation:
+ *
+ *  - takes the note's raw content and returns the NEW raw content (the caller
+ *    persists through journalNotes, the only write path);
+ *  - is identity-guarded: the target widget is located by its positional key
+ *    (`w${index}`, matching buildDashboardDocument) AND its expected body
+ *    content. A guard mismatch returns null and writes NOTHING — a concurrent
+ *    edit or reorder between read and write can never retarget the splice to
+ *    the wrong widget.
+ *
+ * A widget's editable unit is its "group": the title heading / coaching
+ * question paragraph the document builder associates with the block (strict
+ * adjacency, same rule as buildDashboardDocument) plus the ```query fence
+ * itself. Move/duplicate/remove operate on the whole group so the rendered
+ * card — title, question, chart — travels together.
+ */
+interface WidgetSpec {
+    /** Card title — renders as a `## ` heading above the block. */
+    title?: string;
+    /** Coaching question — the paragraph between the heading and the block. */
+    question?: string;
+    /** Raw widget type from the fence suffix ('' → 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). */
+    wql: string;
+    /** Fence-tag presentation attributes (goal targets, …). */
+    attributes?: Record<string, string>;
+    /** Attribute emission order (defaults to Object key order). */
+    attributeOrder?: string[];
+}
+type WidgetSpan = Pick<WidgetSpec, 'spanCols' | 'spanFull'>;
+/** Opening fence line for a widget spec — type/span plus `key=value`
+ *  attributes (decision 22: presentation params ride the fence tag). */
+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). */
+declare function renderWidgetGroup(spec: WidgetSpec): string[];
+/**
+ * Append a new widget group at the end of the note body. Frontmatter and all
+ * existing content are preserved verbatim.
+ */
+declare function appendWidget(raw: string, spec: WidgetSpec): string;
+/** Structured operation result (decision 22): a missing widget is distinct
+ *  from a concurrent edit, and neither silently no-ops. */
+type WidgetOpResult = {
+    ok: true;
+    note: string;
+} | {
+    ok: false;
+    reason: 'not-found' | 'stale-body';
+};
+/**
+ * Replace a widget's whole group (title/question/type/body) in place.
+ * Identity-guarded against the widget's exact full body text.
+ */
+declare function updateWidget(raw: string, key: string, expectedBody: string, spec: WidgetSpec): WidgetOpResult;
+/** Duplicate a widget's group directly below itself. Identity-guarded. */
+declare function duplicateWidget(raw: string, key: string, expectedBody: string): WidgetOpResult;
+/**
+ * Remove a widget's group (title/question/fence). Identity-guarded. Collapses
+ * the blank-line gap the removal leaves behind.
+ */
+declare function removeWidget(raw: string, key: string, expectedBody: string): WidgetOpResult;
+/**
+ * Reorder a widget among the query blocks — the whole group (title, question,
+ * block) moves past its neighbor. `delta` is -1 (up) or +1 (down); out-of-range
+ * moves are no-ops that return the content unchanged. Identity-guarded.
+ */
+declare function moveWidget(raw: string, key: string, expectedBody: string, delta: -1 | 1): WidgetOpResult;
+/**
+ * Resize (or re-span) a widget: rewrites only the opening fence line, leaving
+ * the body, params, and surrounding markdown untouched. `spanFull` wins over
+ * `spanCols`. Identity-guarded.
+ */
+declare function resizeWidget(raw: string, key: string, expectedBody: string, span: WidgetSpan): WidgetOpResult;
+/**
+ * Rewrite one dashboard note's legacy widget bodies to Query Documents
+ * (decision 22, answer 1): the first-` / ` positional split is retired.
+ * For each query fence whose body carries ` / ` positional params, the
+ * query text stays the body and the params move onto the fence tag as
+ * numbered attributes (`param1=…`) — values preserved verbatim, losslessly
+ * editable. A body already document-shaped is untouched; the note that
+ * cannot be rewritten safely returns unchanged (the caller badges it).
+ */
+declare function migrateLegacyDashboardBodies(raw: string): string;
+
 /**
  * Auto-generated build version metadata.
  * Do not edit directly; updated by scripts/stamp-version.ts
  */
-declare const VERSION = "0.11.43";
-declare const GIT_SHA = "ed28149";
-declare const BUILD_TIME = "2026-08-26T16:34:15.927Z";
+declare const VERSION = "0.35.2116";
+declare const GIT_SHA = "a4d411f";
+declare const BUILD_TIME = "2026-10-12T00:14:24.795Z";
 declare const SEMVER: {
-    readonly version: "0.11.43";
-    readonly gitSha: "ed28149";
-    readonly buildTime: "2026-08-26T16:34:15.927Z";
+    readonly version: "0.35.2116";
+    readonly gitSha: "a4d411f";
+    readonly buildTime: "2026-10-12T00:14:24.795Z";
 };
 
-export { type Aggregator, type AnyParsedQuery, BUILD_TIME, type BlockQueryStore, 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, EFFORT_DISCIPLINES, type EffortDiscipline, type EffortQueryStore, type EventRowIdentity, type FindOptions, type FindPredicate, type FindQueryResult, GIT_SHA, type IEffort, KG_PER_LB, type LinkWidget, type MetricPredicate, type NoteQueryStore, PLANNED_WIDGET_TYPES, type ParsedAggregateQuery, type ParsedFindQuery, type ParsedFrontmatter, type ParsedRowsQuery, type ParsedWqlRollupSuffix, type ParsedWqlSuffixes, type ParsedWqlWindowSuffix, type QueryOptions, type QueryResult, QueryService, type QueryServiceStores, type QueryWidgetSuffix, type QueryWindow, type RowsQueryResult, type RowsRun, SEMVER, type Series, type SeriesPoint, type SummaryFactIdentity, type SummaryFactSourceOutput, type TagFilter, type TagValue, UNIT_FAMILIES, type UnifiedEventStore, type UnitFamily, type UnitFamilyDef, VERSION, WQL_AGGREGATORS, WQL_CALC_TARGETS, WQL_COMPARISON_OPS, WQL_CONTENT_FILTER_KEYS, WQL_DISPLAY_UNITS, WQL_FIND_TARGETS, WQL_GRAINS, WQL_INTENSITY_TIERS, WQL_KEYWORDS, WQL_METRIC_AGGREGATES, WQL_METRIC_FAMILIES, WQL_RESULT_PLANES, WQL_ROLLUP_PERIODS, WQL_ROWS_SCOPE_KEYS, WQL_ROWS_TARGETS, WQL_SOURCES, WQL_SOURCE_VALUES, WQL_TAG_KEYS, WQL_VIRTUAL_DIMS, type WqlAggregator, type WqlCalcTarget, type WqlComparisonOp, type WqlCompletionOptions, type WqlContentFilterKey, type WqlDisplayUnit, type WqlFindTarget, type WqlGrain, type WqlIntensityTier, type WqlKeyword, type WqlMetricAggregate, type WqlMetricFamily, type WqlResultPlane, type WqlRollupPeriod, type WqlRowsTarget, type WqlSource, type WqlSourceValue, type WqlTagKey, type WqlVirtualDim, buildDashboardDocument, buildDashboardScaffold, convert, dashboardSlug, defaultTokenValues, disciplineFactorFor, extractDashboardTokens, extractFrontmatterTags, getList, getScalar, getUnitFamily, isAggregateQuery, isDashboardMeta, isDashboardWidgetType, isEffortDiscipline, isFindQuery, isProposedMetric, isRowsQuery, normalizeSummaryFacts, normalizeWql, parseDashboardNote, parseFlatProperties, parseFrontmatter, parseFrontmatterBody, parseFrontmatterCategories, parseFrontmatterProps, parseQuery, parseQueryWidgetSuffix, parseWqlSuffixes, projectEventToFacts, referencedTokens, resolveCanonicalMetricKey, resolveDisplayUnit, resolveWidgetType, serialize, serializeFrontmatter, setDashboardTokenValue, splitAtWhere, splitWidgetBody, staticNotesFromBlocks, staticTagIndexFromBlocks, stripFrontmatter, substituteTokens, toEventRows, toSummaryEventRows, unknownTokensMessage, unknownWidgetTypeMessage, wql, wqlCompletion, wqlCompletionSource, wqlHighlightStyle, wqlLanguage, parser as wqlParser, wql_parser_terms as wqlTerms };
+export { type Aggregator, type AnyParsedQuery, BUILD_TIME, type BlockQueryStore, 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 EventRowIdentity, type EventStore, type ExecutionContext, type FamilyRunPayload, type FindOptions, type FindPredicate, type FindQueryResult, type FormulaEvaluation, type FormulaEvaluator, GIT_SHA, type IEffort, type IFieldCatalog, type LinkWidget, 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 ParsedFrontmatter, 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 ResolvedRange, type RowsPipes, type RowsQueryResult, type RowsRun, SEMVER, 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_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, buildDashboardScaffold, buildDrillDownQuery, captureContext, catalogOfItem, civilDateAdd, civilDateDiff, civilDateOf, civilDatesCoveredByRange, civilMonday, consumesRollupFacts, convertDisplay, createBuiltinFormulaEvaluator, dashboardSlug, defaultTokenValues, disciplineFactorFor, duplicateWidget, eventsToStoredLogs, extractDashboardTokens, extractFrontmatterTags, findTargetAdvisories, getList, getScalar, getUnitFamily, inRange, isAggregateQuery, isDashboardMeta, isDashboardWidgetType, isEffortDiscipline, isFindQuery, isPipelineQuery, isProposedMetric, migrateLegacyDashboardBodies, moveWidget, normalizeSummaryFacts, normalizeWql, parseDashboardNote, parseDocument, parseFlatProperties, parseFrontmatter, parseFrontmatterBody, parseFrontmatterCategories, parseFrontmatterProps, parseQuery, parseQueryWidgetSuffix, parseWqlSuffixes, projectEventToFacts, referencedTokens, removeWidget, renderWidgetGroup, resizeWidget, resolveCanonicalMetricKey, resolveOutputUnit, resolveWidgetType, resolveWindowRange, rowsParseError, serialize, serializeDocument, serializeFrontmatter, setDashboardTokenValue, sourceMatches, splitAtWhere, staticCatalogRoute, staticNotesFromBlocks, staticTagIndexFromBlocks, stripFrontmatter, 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 };