@ahoo-wang/wow-view-engine 9.2.0-rc.0

package/dist/analysis/compile.d.ts

@@ -0,0 +1,55 @@
+import { AggregationQuery } from '@ahoo-wang/wow-client';
+import { AnalysisViewConfig, DataViewDefinition, RuntimeLimits } from '../model/index.js';
+import { FieldKindRegistry, FilterCompileContext } from '../filter/index.js';
+/**
+ * Compilation is a mapping, not a translation: the configuration is
+ * isomorphic to the Wow aggregation protocol and differs only in storing enum
+ * values as literals and filters as trees. Admission happened in
+ * `validateAnalysis`, so anything invalid here is a programming error.
+ */
+export declare function compileAnalysis(definition: DataViewDefinition, config: AnalysisViewConfig, kinds: FieldKindRegistry, context: FilterCompileContext, limits?: Pick<RuntimeLimits, 'maxAnalysisRows'>): AggregationQuery;
+/**
+ * The row count the grouped query asks for: one more than the configured
+ * limit (D20 Ⅷ).
+ *
+ * An aggregation answers at most `limit` rows and says nothing about what it
+ * left out, so a table that came back exactly full used to be reported as
+ * "may have been cut short" — a grouping of exactly that size and a larger
+ * one cut down to it look the same. Asking for one row more turns the guess
+ * into an answer: the probe row either comes back, and there are more groups,
+ * or it does not, and there are not. `projectAnalysis` drops it again, so the
+ * reader still sees the `limit` rows they asked for.
+ *
+ * The extra row never passes a ceiling — the capability's own `maxLimit`,
+ * the runtime's `maxAnalysisRows` (what the server admits, D42) and Wow's
+ * `AGGREGATION_LIMITS.MAX_LIMIT`, the least of which `limitBounds` reads —
+ * because a query beyond any is refused rather than answered, and trading the whole result for a probe is
+ * not a trade worth making. A configured limit already sitting on that
+ * ceiling therefore gets no probe at all: there is no row left to ask for,
+ * and that one case keeps the old "may have been cut short".
+ *
+ * An analysis with no grouping asks one question and gets one row, so there
+ * is nothing a ceiling could cut and nothing to probe for.
+ */
+export declare function analysisProbeLimit(definition: DataViewDefinition, config: AnalysisViewConfig, limits?: Pick<RuntimeLimits, 'maxAnalysisRows'>): number;
+/**
+ * Whether a config asks for its whole — the ungrouped answer — beside its
+ * groups: when its table draws a totals row, or when its chart is a metric
+ * card over a trend read as the whole (`MetricTrend.headline: 'whole'`).
+ * Read as its last period — the default — the card's headline is one of
+ * the buckets, and the whole is not asked.
+ *
+ * Without it that card added up its buckets, and those are only the groups
+ * that fit the limit: a card over the first twenty days of a month said the
+ * month was smaller than it was (the 2026-09-23 audit; the user chose a
+ * second query over a sum labelled as partial). It is asked only when
+ * something draws it, so a bar chart or a plain table costs one query as
+ * before, and a dashboard of them no more than it did.
+ */
+export declare function asksForWhole(config: AnalysisViewConfig): boolean;
+/**
+ * Totals run their own ungrouped query. Deriving them from the grouped rows
+ * would be wrong for AVG, DISTINCT_COUNT and percentile.
+ */
+export declare function compileAnalysisTotals(definition: DataViewDefinition, config: AnalysisViewConfig, kinds: FieldKindRegistry, context: FilterCompileContext): AggregationQuery | null;
+//# sourceMappingURL=compile.d.ts.map

package/dist/analysis/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/analysis/compile.ts"],"names":[],"mappings":"AAaA,OAAO,EAcL,KAAK,gBAAgB,EAOtB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAMV,kBAAkB,EAClB,kBAAkB,EAElB,aAAa,EACd,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EAC1B,MAAM,oBAAoB,CAAC;AAc5B;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,iBAAiB,EACxB,OAAO,EAAE,oBAAoB,EAC7B,MAAM,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,iBAAiB,CAAC,GAC9C,gBAAgB,CAiBlB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,kBAAkB,EAC1B,MAAM,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,iBAAiB,CAAC,GAC9C,MAAM,CASR;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAShE;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,iBAAiB,EACxB,OAAO,EAAE,oBAAoB,GAC5B,gBAAgB,GAAG,IAAI,CASzB"}

package/dist/analysis/currency.d.ts

@@ -0,0 +1,68 @@
+import { AnalysisMetric, AnalysisViewConfig, CurrencyReading, DataViewDefinition, Issue, RecordData } from '../model/index.js';
+/**
+ * The two metrics asked beside a metric of money whose currency each record
+ * holds, so its answer can say whose money it is (capabilities.md 21):
+ * how many currencies the records behind each row hold (`count`, a
+ * `DISTINCT_COUNT` of the currency field) and one of them (`code`, an
+ * `ANY`). One currency is that currency; more than one means the row's sum
+ * adds unlike amounts, and it is not shown as a number at all.
+ *
+ * They carry the metric's own condition, so a conditioned metric is told
+ * about the records it counted, not the whole group.
+ */
+export interface CurrencyCompanion {
+    /** The metric it tells about. */
+    metric: string;
+    /** The currency field, as the config spells a field. */
+    field: string;
+    /** Alias of the `ANY` of the currency field. */
+    code: string;
+    /** Alias of the `DISTINCT_COUNT` of the currency field. */
+    count: string;
+}
+/**
+ * The metrics of a config that are money in a currency each record holds,
+ * with what tells their currency. A metric is one when its value is in the
+ * field's unit — a sum, an average, a smallest or largest, a percentile, a
+ * value of one record — of a field whose `numeric` is row-currency money and
+ * whose author declared no format of their own. A count, a distinct count
+ * or a formula is in no one's currency.
+ *
+ * A companion is asked only where the source can answer it: the currency
+ * field takes both a distinct count and an `ANY` in this scope, and the
+ * metrics fit the capability's `maxMetrics` with them. Where it cannot, the
+ * metric is listed in `unchecked`: its currency cannot be told, and a
+ * reader is told so rather than shown a sum that may add yen to dollars.
+ */
+export declare function currencyCompanions(definition: DataViewDefinition, config: Pick<AnalysisViewConfig, 'metrics' | 'elements'>): {
+    companions: CurrencyCompanion[];
+    unchecked: string[];
+};
+/** The companions of a config, as metrics the query asks beside its own. */
+export declare function companionMetrics(config: Pick<AnalysisViewConfig, 'metrics'>, companions: readonly CurrencyCompanion[]): AnalysisMetric[];
+/**
+ * The metrics a derived metric is computed from, by alias, all the way
+ * down: GMV ÷ orders reads GMV's currency, and a ratio of a ratio reads
+ * the operands of both.
+ */
+export declare function derivedOperands(metric: AnalysisMetric, byAlias: ReadonlyMap<string, AnalysisMetric>, seen?: Set<string>): string[];
+/** Readings of several companions, joined: see `joinCurrencies`. */
+export declare function companionsReading(row: RecordData | undefined, companions: readonly Pick<CurrencyCompanion, 'code' | 'count'>[]): CurrencyReading | undefined;
+/**
+ * The codes a result says about its money beside the rows
+ * (`currencyIssues`): drawn beside the result they are about, with the offer
+ * to group by the currency field.
+ */
+export declare const CURRENCY_ISSUE_CODES: readonly string[];
+/**
+ * What a result says about its money: each metric some of whose rows are
+ * in several currencies — blank there, and why (`analysis.result.mixed-currency`)
+ * — and each whose currency the source could not be asked for
+ * (`analysis.metric.currency-unchecked`), whose sums may add unlike
+ * amounts unseen. Both name the currency field (`field`, and the raw
+ * `currencyField` a screen offers to group by), because grouping by it is
+ * what separates the amounts. A result already grouped by it is in one
+ * currency per row and says nothing: its companions tell each row's.
+ */
+export declare function currencyIssues(definition: DataViewDefinition, config: Pick<AnalysisViewConfig, 'metrics' | 'elements' | 'groups'>, rows: readonly RecordData[]): Issue[];
+//# sourceMappingURL=currency.d.ts.map

package/dist/analysis/currency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"currency.d.ts","sourceRoot":"","sources":["../../src/analysis/currency.ts"],"names":[],"mappings":"AAaA,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,KAAK,EACV,KAAK,UAAU,EAChB,MAAM,mBAAmB,CAAC;AAM3B;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAiB;IAChC,iCAAiC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,2DAA2D;IAC3D,KAAK,EAAE,MAAM,CAAC;CACf;AAUD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,SAAS,GAAG,UAAU,CAAC,GACvD;IAAE,UAAU,EAAE,iBAAiB,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,CAiC1D;AAcD,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,SAAS,CAAC,EAC3C,UAAU,EAAE,SAAS,iBAAiB,EAAE,GACvC,cAAc,EAAE,CAsBlB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,EAC5C,IAAI,GAAE,GAAG,CAAC,MAAM,CAAa,GAC5B,MAAM,EAAE,CAiBV;AAED,oEAAoE;AACpE,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,UAAU,GAAG,SAAS,EAC3B,UAAU,EAAE,SAAS,IAAI,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,GAC/D,eAAe,GAAG,SAAS,CAI7B;AAED;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,EAAE,SAAS,MAAM,EAGjD,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,kBAAkB,EAC9B,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,SAAS,GAAG,UAAU,GAAG,QAAQ,CAAC,EACnE,IAAI,EAAE,SAAS,UAAU,EAAE,GAC1B,KAAK,EAAE,CA+CT"}

package/dist/analysis/dangling.d.ts

@@ -0,0 +1,52 @@
+import { AnalysisHavingExpression, AnalysisMetric, AnalysisViewConfig } from '../model/index.js';
+/** What a metric may be read by, beyond its being there. */
+export interface DanglingFacts {
+    /** The metrics that are moments (`momentMetrics`): no operand, no having. */
+    moments?: ReadonlySet<string>;
+    /** The metric types 「只保留」 may compare (`havingMetrics`); all when absent. */
+    havingMetrics?: readonly string[];
+}
+export interface WithoutDangling {
+    metrics: AnalysisViewConfig['metrics'];
+    /** The same object when nothing in it moved; `undefined` when none is left. */
+    having: AnalysisHavingExpression | undefined;
+    /** The aliases of the derived metrics that left with what they read. */
+    removed: string[];
+}
+type Shape = Pick<AnalysisViewConfig, 'groups' | 'metrics' | 'having'>;
+/** The config an edit started from, and what its metrics were read by. */
+export interface DanglingBefore {
+    shape: Pick<AnalysisViewConfig, 'groups' | 'metrics'>;
+    facts?: DanglingFacts;
+}
+/**
+ * The metrics and the having an edit to what is grouped or measured leaves
+ * reading something: the one rule every such edit follows, the way the
+ * chart, the sort and the table columns follow the aliases.
+ *
+ * - **A derived metric leaves with an operand it can no longer read**: one
+ *   gone, turned into a sample value or a moment, or declared after it —
+ *   the rules `analysis.derived.unknown-metric` and `…moment-operand` hold
+ *   it to. Walked in order, so a derived metric reading one that just left
+ *   leaves too.
+ * - **A having rule on a metric it can no longer compare no longer
+ *   constrains**: it leaves an `AND`, and an `OR` it sits in leaves with it
+ *   (one side holding for every group keeps every group). No rule left, no
+ *   having; no dimension left, no having either — Wow has no groups to
+ *   keep (`analysis.having.requires-group`).
+ *
+ * Only what the edit broke goes (`before`, the config it started from): a
+ * derived metric or a rule that already read nothing stays, for admission
+ * to point at, rather than vanishing under an edit about something else,
+ * and so does a metric the edit itself changed (not the object `before`
+ * held) — the card being typed into is not fallout.
+ * Without `before`, everything that reads nothing goes. The metrics may
+ * come out empty: the caller says what an empty question becomes.
+ */
+export declare function withoutDangling(shape: Shape, facts?: DanglingFacts, before?: DanglingBefore): WithoutDangling;
+/** The aliases a derived expression reads. */
+export declare function derivedRefs(expression: Extract<AnalysisMetric, {
+    type: 'DERIVED';
+}>['expression']): string[];
+export {};
+//# sourceMappingURL=dangling.d.ts.map

package/dist/analysis/dangling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dangling.d.ts","sourceRoot":"","sources":["../../src/analysis/dangling.ts"],"names":[],"mappings":"AAaA,OAAO,EAEL,KAAK,wBAAwB,EAC7B,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACxB,MAAM,mBAAmB,CAAC;AAE3B,4DAA4D;AAC5D,MAAM,WAAW,aAAa;IAC5B,6EAA6E;IAC7E,OAAO,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC9B,6EAA6E;IAC7E,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;IACvC,+EAA+E;IAC/E,MAAM,EAAE,wBAAwB,GAAG,SAAS,CAAC;IAC7C,wEAAwE;IACxE,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,KAAK,KAAK,GAAG,IAAI,CAAC,kBAAkB,EAAE,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC,CAAC;AAEvE,0EAA0E;AAC1E,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,IAAI,CAAC,kBAAkB,EAAE,QAAQ,GAAG,SAAS,CAAC,CAAC;IACtD,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,KAAK,EACZ,KAAK,GAAE,aAAkB,EACzB,MAAM,CAAC,EAAE,cAAc,GACtB,eAAe,CAiCjB;AAqED,8CAA8C;AAC9C,wBAAgB,WAAW,CACzB,UAAU,EAAE,OAAO,CAAC,cAAc,EAAE;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC,CAAC,YAAY,CAAC,GACrE,MAAM,EAAE,CAYV"}

package/dist/analysis/defaults.d.ts

@@ -0,0 +1,168 @@
+import { AggregationFieldCapability, AnalysisDatePart, AnalysisDateUnit, AnalysisFunction, AnalysisGroup, AnalysisGroupType, AnalysisMetric, AnalysisCapability, AnalysisViewConfig, DataViewDefinition, DatePartOffer, FieldDefinition, FieldMetricType, RuntimeLimits } from '../model/index.js';
+/**
+ * The range 「前 N 组」 may take, and the N it stands for when nobody said one.
+ *
+ * `max` is the lowest of three ceilings — the capability's `maxLimit`, the
+ * runtime's `maxAnalysisRows` and Wow's own `AGGREGATION_LIMITS.MAX_LIMIT` —
+ * because a declaration may only lower what the layers under it allow; the
+ * least is 1, since Wow refuses a limit under it. It is also the most rows
+ * any query the engine compiles asks for — the probe row
+ * (`analysisProbeLimit`) and the split's whole (`splitWholeConfig`)
+ * included — since `maxAnalysisRows` is what the server admits: a Wow
+ * server's HTTP guard refuses more than 1,000 by default (D42).
+ *
+ * `fallback` is where a new view starts, and what an emptied 「前 N 组」
+ * field means: the model has no "no limit" (Wow answers at most `MAX_LIMIT`
+ * rows whatever is asked), so the honest reading of a blank is the number a
+ * view would have started at.
+ *
+ * One function for the three readers — the default config, the admission
+ * rule and the tray's field — so the bounds a field says out loud are the
+ * ones Apply is refused by, never a second copy of them.
+ */
+export interface AnalysisLimitBounds {
+    max: number;
+    fallback: number;
+}
+export declare function limitBounds(capability: Pick<AnalysisCapability, 'limits'> | undefined, limits?: Pick<RuntimeLimits, 'maxAnalysisRows'>): AnalysisLimitBounds;
+/** The percentile a new percentile metric asks for. */
+export declare const DEFAULT_PERCENTILE = 95;
+/** Alias derived from a field path, kept to the single segment Wow allows. */
+export declare function aliasOf(field: string, suffix: string): string;
+/**
+ * The bucket key records with no value of the dimension land in.
+ *
+ * Without one, Wow drops those records from the whole result rather than
+ * leaving them ungrouped: a count of orders by warehouse would silently omit
+ * every order that has no warehouse, and nothing on screen would say so. It
+ * is a stored key and not a label — it travels to the server and comes back
+ * as the bucket's own key — so it is one fixed string in every language, and
+ * the wording a reader sees for that bucket is the interface's to decide.
+ */
+export declare const DEFAULT_MISSING_KEY = "(empty)";
+/**
+ * What building a dimension needs to know of its field, and nothing more —
+ * so a declared field read with its capability (a fresh config, a split) and
+ * the editor's `AnalysisFieldOption` (a field picked on the tray) are the
+ * same input to the one builder.
+ */
+export interface GroupFacts {
+    /** The field, named as a config names it. */
+    field: string;
+    /**
+     * Whether one record holds at most one string there
+     * (`isSingleStringField`): only then may the records missing it keep a
+     * bucket of their own, which is Wow's rule and `validateGroups`'s.
+     */
+    missingKey: boolean;
+    /** The date units the capability offers; a time dimension starts at the first. */
+    dateUnits: readonly AnalysisDateUnit[];
+    /**
+     * The calendar parts the capability offers (`datePartsOf`); a part
+     * dimension starts at the first. Left out, every one.
+     */
+    dateParts?: readonly AnalysisDatePart[];
+}
+/**
+ * The facts of a declared field. Nothing in a kernel holds a registry, so a
+ * field of a kind an application registered itself is read by the built-in
+ * rule unless the caller hands its kind in; admission, which does hold one,
+ * is the authority.
+ */
+export declare function groupFacts(field: FieldDefinition, dateUnits?: readonly AnalysisDateUnit[], kind?: {
+    singleString?: boolean;
+}, offered?: {
+    missingKey?: boolean;
+} & Partial<DatePartOffer>): GroupFacts;
+/**
+ * The one builder of a dimension: `type` on a field, whole rather than as a
+ * patch. A fresh config, a split from the follow-up menu, a field picked on
+ * the tray and a card switched to another type all build through this, so
+ * each default is said once:
+ *
+ * - by value, the sentinel bucket wherever the field can carry one — without
+ *   it Wow drops every record missing the value, and a dimension never drops
+ *   records without saying so;
+ * - by date, at `unit` when the caller recommends one (K4), else the first
+ *   unit the capability offers, else a day;
+ * - by band, one unit wide;
+ * - by calendar part, at the first part the capability offers — the weekday.
+ */
+export declare function groupOfType(facts: GroupFacts, type: AnalysisGroupType, alias: string, unit?: AnalysisDateUnit): AnalysisGroup;
+/**
+ * The fields a dimension may still be added on: the groupable ones `groups`
+ * does not already cut by. Cutting by one field twice is a question nobody
+ * asks — the second cut makes exactly the groups the first one did — so the
+ * tray's "add dimension" (over the draft) and the follow-up menu's split
+ * (over the config that ran) both read this list.
+ */
+export declare function groupableFields<F extends {
+    field: string;
+    groups: readonly unknown[];
+}>(fields: readonly F[], groups: readonly Pick<AnalysisGroup, 'field'>[]): F[];
+/**
+ * How a metric summarises its field, as one choice: a function for a
+ * numeric metric, the metric's own type for the other types that measure a
+ * field (`FIELD_METRIC_TYPES`). This is what a tray card's "summary" select
+ * shows and takes, so the six ways Wow can measure a field read as one list
+ * (D20 汇总方式).
+ */
+export type SummaryChoice = AnalysisFunction | Exclude<FieldMetricType, 'NUMERIC'>;
+/** What a field offers to be measured by: its capability, or the editor's option of it. */
+export interface MetricFacts {
+    field: string;
+    functions: readonly AnalysisFunction[];
+    distinctCount?: boolean;
+    percentile?: boolean;
+    any?: boolean;
+    firstLast?: boolean;
+}
+/** The choices a field offers, in the order `FIELD_METRIC_TYPES` lists them. */
+export declare function summaryChoices(facts: MetricFacts): SummaryChoice[];
+/** The choice a metric was built from, or `null` for one that measures no field. */
+export declare function summaryOf(metric: AnalysisMetric): SummaryChoice | null;
+/**
+ * The one builder of a metric over a field: `choice` on it, whole — a card
+ * that changes the summary replaces the metric rather than patching it, and
+ * a fresh config's first metric is built the same way.
+ */
+export declare function metricOfSummary(facts: Pick<MetricFacts, 'field'>, choice: SummaryChoice, alias: string): AnalysisMetric;
+/**
+ * The first metric a set of aggregation capabilities can express, in a
+ * fixed order: the count, then the first field that can be summed, counted
+ * distinctly, taken a percentile of, or sampled. The same rule seeds a
+ * fresh definition and an analysis whose expansion left nothing to measure
+ * (`withElements`), over whichever fields that unit holds.
+ *
+ * `validateDefinition` only accepts a capability that can produce one of
+ * these, so a definition that was admitted always has a usable default.
+ */
+export declare function firstMetric(count: boolean, fields: readonly AggregationFieldCapability[]): AnalysisMetric;
+/**
+ * A complete starting config. Grouping is optional, because Wow accepts an
+ * ungrouped aggregation and some definitions declare no groupable field.
+ *
+ * An ungrouped aggregation is one row, so there is nothing to sort: Wow
+ * refuses a `sort` without a `groupBy`, and the default must not carry one.
+ */
+export declare function defaultAnalysisConfig(definition: DataViewDefinition, limits?: RuntimeLimits): AnalysisViewConfig;
+/**
+ * A name no group or metric is using: `base`'s stem plus the first free
+ * number. Numbering by the row count collided as soon as a row was removed,
+ * so the first free number it is, however rows were added and removed.
+ * Aliases are single-segment in Wow, so a field path becomes one token, and
+ * a copy of `amount_2` is `amount_<next>` rather than `amount_2_1`.
+ */
+export declare function freeAlias(base: string, taken: readonly string[]): string;
+/**
+ * A second card of the same metric, for a condition of its own (D20 屏 H
+ * 「复制并加条件」): a free alias, no display name — two cards called the
+ * same thing is the ambiguity a name exists to resolve — the summary kept,
+ * and no condition yet. The card opens its conditions for one; an empty
+ * group written here would be a draft that refuses itself before the
+ * analyst has done anything (2026-09-23 audit), so the condition is written
+ * with its first entry. A derived metric carries no condition and is not
+ * copied.
+ */
+export declare function metricWithCondition(source: AnalysisMetric, taken: readonly string[]): AnalysisMetric | undefined;
+//# sourceMappingURL=defaults.d.ts.map

package/dist/analysis/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/analysis/defaults.ts"],"names":[],"mappings":"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"}

package/dist/analysis/derived.d.ts

@@ -0,0 +1,81 @@
+import { AnalysisViewConfig, DerivedKind, DerivedSeries } from '../model/index.js';
+import { CartesianData } from './cartesian.js';
+/**
+ * Why a derived series cannot be computed over this result (D33 Q53). Wow's
+ * aggregation has no window functions, so a trend, a moving average and a
+ * running total are computed here over the rows that came back — and over
+ * rows that are not the whole time axis they are silently wrong. A wrong
+ * running total is worse than none, so the kernel draws none and says why:
+ *
+ * - `split`: a split draws a series per value, and a computed line over one
+ *   of them in the foreground's dashes could not say which it follows.
+ * - `not-time`: the x is no time dimension; a category has no before — for
+ *   a trend and a moving average.
+ * - `not-sorted`: a running total or share along categories is a Pareto
+ *   only in the order of the metric it follows (D38): the result must be
+ *   sorted by that metric first; in any other order it is a sum in an order
+ *   nobody chose.
+ * - `shares`: the chart is stacked to 100%, its axis a scale of shares; a
+ *   running total of shares is nothing.
+ * - `narrowed`: 「只保留」 dropped groups by their numbers.
+ * - `cut-short`: the rows are the first N groups of more.
+ * - `holes`: the axis has a gap nobody can put a number on — a bucket the
+ *   rows lack that is not known to be empty, or buckets the zone could not
+ *   step (`CartesianData.timeline` absent).
+ * - `not-additive`: a running total of an average is no total of anything.
+ * - `too-few`: fewer measured points than the line needs (two for a trend,
+ *   the window for a moving average).
+ */
+export type DerivedGap = 'split' | 'not-time' | 'not-sorted' | 'shares' | 'narrowed' | 'cut-short' | 'holes' | 'not-additive' | 'too-few';
+/** One computed line, as the drawing takes it: a value per point or none. */
+export interface DerivedLine {
+    /** Unique among the chart's series keys and derived keys. */
+    key: string;
+    kind: DerivedKind;
+    /** The metric alias of the series it is computed from. */
+    metric: string;
+    /** A moving average's window, as used. */
+    window?: number;
+    values: (number | null)[];
+}
+/** The window a moving average over this config's x runs over. */
+export declare function movingWindow(config: AnalysisViewConfig, derived: Pick<DerivedSeries, 'window'>): number;
+/**
+ * Why `derived` cannot be drawn over `data`, or `undefined` when it can.
+ * `cutShort` is whether the rows are the first groups of more
+ * (`AnalysisProjection.truncated` or `atLimit`). The reasons are checked in the
+ * order a reader fixes them: the chart's shape first, then the question,
+ * then what came back.
+ */
+export declare function derivedGap(config: AnalysisViewConfig, data: CartesianData, derived: Pick<DerivedSeries, 'kind' | 'metric' | 'window'>, cutShort: boolean): DerivedGap | undefined;
+/** Whether a derived kind runs along the axis, adding up as it goes. */
+export declare function isRunning(kind: DerivedKind): boolean;
+/**
+ * The derived line's values over a whole series — `derivedGap` said there
+ * is no hole, so every value is a number. A moving average has none before
+ * its window fills: a mean of fewer points is another statistic, and
+ * drawing it would bend the line's start toward whatever came first.
+ */
+export declare function derivedValues(values: readonly number[], kind: DerivedKind, window: number): (number | null)[];
+/** Each asked-for line computed, or the reason it is not (`shapeCartesian`). */
+export declare function deriveLines(config: AnalysisViewConfig, data: CartesianData, cutShort: boolean): {
+    lines: DerivedLine[];
+    gaps: CartesianGap[];
+};
+/**
+ * Something the spec asked the chart to draw that the kernel left out, and
+ * why: a derived line (`DerivedGap`), or a statistic reference line over a
+ * split or over no measured value.
+ */
+export type CartesianGap = {
+    kind: DerivedKind;
+    metric: string;
+    gap: DerivedGap;
+    /** The groups the result was cut at, for `cut-short`. */
+    limit?: number;
+} | {
+    kind: 'average' | 'median';
+    metric: string;
+    gap: 'split' | 'shares' | 'none-measured';
+};
+//# sourceMappingURL=derived.d.ts.map

package/dist/analysis/derived.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derived.d.ts","sourceRoot":"","sources":["../../src/analysis/derived.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAEV,kBAAkB,EAClB,WAAW,EACX,aAAa,EACd,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAKpD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,MAAM,UAAU,GAClB,OAAO,GACP,UAAU,GACV,YAAY,GACZ,QAAQ,GACR,UAAU,GACV,WAAW,GACX,OAAO,GACP,cAAc,GACd,SAAS,CAAC;AAEd,6EAA6E;AAC7E,MAAM,WAAW,WAAW;IAC1B,6DAA6D;IAC7D,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,WAAW,CAAC;IAClB,0DAA0D;IAC1D,MAAM,EAAE,MAAM,CAAC;IACf,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;CAC3B;AAeD,kEAAkE;AAClE,wBAAgB,YAAY,CAC1B,MAAM,EAAE,kBAAkB,EAC1B,OAAO,EAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAC,GACrC,MAAM,CAKR;AAUD;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAC,EAC1D,QAAQ,EAAE,OAAO,GAChB,UAAU,GAAG,SAAS,CA+BxB;AAED,wEAAwE;AACxE,wBAAgB,SAAS,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAEpD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,MAAM,GACb,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CA0BnB;AAqBD,gFAAgF;AAChF,wBAAgB,WAAW,CACzB,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,aAAa,EACnB,QAAQ,EAAE,OAAO,GAChB;IAAE,KAAK,EAAE,WAAW,EAAE,CAAC;IAAC,IAAI,EAAE,YAAY,EAAE,CAAA;CAAE,CAgChD;AAED;;;;GAIG;AACH,MAAM,MAAM,YAAY,GACpB;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,UAAU,CAAC;IAChB,yDAAyD;IACzD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GACD;IACE,IAAI,EAAE,SAAS,GAAG,QAAQ,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,OAAO,GAAG,QAAQ,GAAG,eAAe,CAAC;CAC3C,CAAC"}

package/dist/analysis/drill.d.ts

@@ -0,0 +1,142 @@
+import { AnalysisDateUnit, AnalysisGroup, AnalysisGroupType, AnalysisViewConfig, FieldDefinition, FilterLeaf, FilterNode, RecordData } from '../model/index.js';
+import { FieldKind, FieldKindRegistry } from '../filter/index.js';
+/**
+ * One group of an aggregation result, turned back into the conditions that
+ * select the records it was computed from.
+ *
+ * This is the inverse of bucketing (K1): a `TERMS` group is one value, a
+ * `HISTOGRAM` group is the half-open interval `[key, key + interval)`, and a
+ * `DATE_HISTOGRAM` group is the bucket `[start, next start)` cut in the zone
+ * the histogram was cut in. A `DATE_PART` group — every Monday — has no
+ * inverse a condition can hold, so a row with one leads to no records. The analysis kernel hands out conditions and
+ * nothing else (K6): what view they open, and under which columns, is the
+ * runtime's and the record kernel's to say, because `analysis` and `record`
+ * never import each other.
+ */
+/** The instant a bucket starts, and the instant the next one does. */
+export interface BucketRange {
+    from: number;
+    to: number;
+}
+/**
+ * The bucket a date-histogram key names: `[from, to)` in epoch milliseconds,
+ * where `to` is the next bucket's start in `timeZone`.
+ *
+ * Calendar units advance on the zone's wall clock — a month is the same day
+ * of the next month, a week is seven days later — so a bucket that crosses a
+ * daylight-saving change is as long as the calendar says, not 24 hours.
+ * Clock units advance by their length; Wow cuts hours on the wall clock too,
+ * which agrees except across the one hour a year that repeats or is skipped.
+ */
+export declare function bucketRange(unit: AnalysisDateUnit, start: number, timeZone: string): BucketRange;
+/**
+ * The start of the bucket of `unit` that holds `ms`, cut in `timeZone` the
+ * way Wow cuts a date histogram: a calendar unit on the zone's wall clock —
+ * a week from its Monday — an hour on the wall-clock hour, a minute and a
+ * second by their length. The inverse of `bucketRange`'s question: that
+ * one is given a bucket's start, this one any moment inside it.
+ */
+export declare function bucketStart(unit: AnalysisDateUnit, ms: number, timeZone: string): number;
+/**
+ * What a clock in `timeZone` shows at `ms`, as the instant that wall-clock
+ * time is at UTC — the axis a wall-clock bucket key (`2026-09-18`) is read on.
+ */
+export declare function wallClockAt(ms: number, timeZone: string): number;
+export interface DrillContext {
+    /** The engine's zone: the one a histogram that names none was cut in. */
+    timeZone: string;
+}
+/**
+ * The conditions that select the records behind one row of an analysis
+ * result, or `null` when no condition can say it.
+ *
+ * Over the root, one or two per group. Over one level of expanded elements
+ * (D38) the row is a count of elements, and a record view sees root
+ * documents: the row's conditions are asked of one element of the array —
+ * one element match holding the level's own gate and every group, so a
+ * record is one with an element that is this group, not one whose elements
+ * are this group between them. Over elements of elements there is no such
+ * sentence yet (`drillGap`).
+ */
+export declare function drillConditions(config: AnalysisViewConfig, fields: readonly FieldDefinition[], kinds: FieldKindRegistry, row: RecordData, context: DrillContext): FilterNode[] | null;
+/**
+ * Why a group of this result, which can be named, cannot be followed to the
+ * records behind it (D38): its counting unit is an element of an element,
+ * and a condition over root documents reaches one level of an array only.
+ */
+export type DrillGap = 'nested-elements';
+export declare function drillGap(config: Pick<AnalysisViewConfig, 'elements'>): DrillGap | undefined;
+/**
+ * The conditions a record view opens drilled groups under — the groups of
+ * `drillGroups` or `drillSpan` — as `drillConditions` says them; `null` over
+ * elements of elements, or over an array the definition does not let a
+ * condition match into.
+ */
+export declare function drillRecordConditions(config: AnalysisViewConfig, fields: readonly FieldDefinition[], kinds: FieldKindRegistry, drilled: readonly DrilledGroup[]): FilterNode[] | null;
+/**
+ * The fields a result's groups name, by their config spelling: the root's,
+ * or the innermost expanded element's, each qualified by the chain above it
+ * as `analysisScope` names them — `null` where the chain names an array the
+ * definition does not hold.
+ */
+export declare function drilledFields(config: Pick<AnalysisViewConfig, 'elements'>, fields: readonly FieldDefinition[]): Map<string, FieldDefinition> | null;
+/** One dimension of a pressed row, and the conditions that select it. */
+export interface DrilledGroup {
+    group: AnalysisGroup;
+    /** The row's value under the group's alias: a key, a bucket's start. */
+    value: unknown;
+    conditions: FilterLeaf[];
+}
+/**
+ * The groups of one pressed row, dimension by dimension, in the config's
+ * order: what a menu names the group pressed by, where one dimension may
+ * read better as its value than as its conditions — a month is 「2026年9月」,
+ * not the two instants that bound it. Over expanded elements each names the
+ * innermost element's fields (`drilledFields`), at any depth: the group can
+ * be named even where it cannot be followed to records
+ * (`drillRecordConditions`).
+ */
+export declare function drillGroups(config: AnalysisViewConfig, fields: readonly FieldDefinition[], kinds: FieldKindRegistry, row: RecordData, context: DrillContext): DrilledGroup[] | null;
+/**
+ * The smallest set of conditions that selects the records behind two groups
+ * and every bucket between them along time (D33 Q52: a brushed stretch of a
+ * time axis, or a range of rows picked from the table): a date dimension
+ * becomes one range from the earlier bucket's start to the later bucket's
+ * end — `[first start, last end)`, each end where `bucketRange` puts it, so
+ * a stretch across a daylight-saving change is as long as the calendar
+ * says. A dimension on which the two agree narrows to that value as a press
+ * on one group does; one on which they differ, or that either leaves out
+ * (a brush along the axis names no series), is not narrowed at all.
+ *
+ * Over expanded elements the conditions name the element's fields, as
+ * `drillGroups`'s do. `null` where no condition can say it — a field the
+ * definition lacks, a bound that reads as no instant — and where nothing
+ * spans time: without a date dimension the two are two groups, not a
+ * stretch, and a menu over them would ask a question nobody pressed.
+ */
+export declare function drillSpan(config: AnalysisViewConfig, fields: readonly FieldDefinition[], kinds: FieldKindRegistry, first: RecordData, last: RecordData, context: DrillContext): DrilledGroup[] | null;
+/**
+ * The two follow-up questions that stay analyses (D20 追问): "only this
+ * group" narrows the range to the row, "split by" narrows it and asks the
+ * same question by another dimension. Each is a patch over the config that
+ * ran; the workbench opens the patched config as a view of its own beside
+ * the one pressed, which it leaves as it was.
+ */
+export declare function focusOn(config: AnalysisViewConfig, conditions: readonly FilterNode[]): Pick<AnalysisViewConfig, 'filter' | 'filterMode'>;
+export declare function splitBy(config: AnalysisViewConfig, conditions: readonly FilterNode[], group: AnalysisGroup, 
+/** The metrics that are moments (`momentMetrics`), which no mark measures. */
+moments?: ReadonlySet<string>): Pick<AnalysisViewConfig, 'filter' | 'filterMode' | 'groups' | 'sort' | 'table' | 'chart'>;
+/**
+ * The dimension a field becomes when a group is split by it: the first way
+ * the definition offers to group it, as the tray's 「添加维度」 takes it —
+ * the order a definition lists its group types in is its author saying how
+ * the field is first looked at, and a follow-up has no better reason to
+ * look at it otherwise. Shaped by the one builder, `groupOfType`. The alias is the one a fresh config's dimension
+ * carries (`aliasOf(field, 'group')`), so the split is savable as it stands.
+ */
+export declare function groupFor(field: FieldDefinition, offered: {
+    groups: readonly AnalysisGroupType[];
+    dateUnits: readonly AnalysisDateUnit[];
+    missingKey?: boolean;
+}, kind?: Pick<FieldKind, 'singleString'>): AnalysisGroup;
+//# sourceMappingURL=drill.d.ts.map

package/dist/analysis/drill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drill.d.ts","sourceRoot":"","sources":["../../src/analysis/drill.ts"],"names":[],"mappings":"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"}

package/dist/analysis/drillFilter.d.ts

@@ -0,0 +1,34 @@
+import { FilterNode, FilterTree } from '../model/index.js';
+/**
+ * How a drilled group's conditions join the conditions it was drilled
+ * under (`drillFilter`), and whether a view still narrows to them
+ * (`narrowsTo`).
+ */
+/**
+ * The filter a drilled view opens under: the analysis view's own conditions
+ * with the row's added, flattened into one "all of" group when the analysis
+ * filter was one — so the record view opens in simple mode wherever the
+ * analysis view was in it — and nested under it otherwise.
+ *
+ * A group of a simple tree holds one condition per field
+ * (`filter.field.duplicate-in-group`), and a row's range is on the field the
+ * analysis was often already scoped by — the day of a stretch of days, a
+ * status among the statuses asked about. Both still hold, so neither is
+ * dropped unless the other says all of it: a scope's absolute stretch that
+ * holds the row's whole stretch gives its place to the row's, which then
+ * says the same records in one condition. Otherwise the row's conditions on
+ * that field go into an "all of" of their own beside the scope's — the one
+ * way a tree asks two things of one field — which is exact, and read in the
+ * editor's advanced mode.
+ */
+export declare function drillFilter(applied: FilterTree, conditions: readonly FilterNode[]): FilterTree;
+/**
+ * Whether `filter` still narrows to the group `drillFilter` added: every one
+ * of `conditions` is a conjunct of it — a child of its root "all of", or of
+ * an "all of" inside that, which is where `drillFilter` puts them however
+ * many times it has been over the tree. A condition taken off, edited or
+ * negated since is not, and neither is one that now sits under an "any of":
+ * the view is no longer that group, and the name that said so is stale.
+ */
+export declare function narrowsTo(filter: FilterTree, conditions: readonly FilterNode[]): boolean;
+//# sourceMappingURL=drillFilter.d.ts.map

package/dist/analysis/drillFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drillFilter.d.ts","sourceRoot":"","sources":["../../src/analysis/drillFilter.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAEV,UAAU,EACV,UAAU,EAEX,MAAM,mBAAmB,CAAC;AAU3B;;;;GAIG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,UAAU,EACnB,UAAU,EAAE,SAAS,UAAU,EAAE,GAChC,UAAU,CAgCZ;AA0CD;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,UAAU,EAClB,UAAU,EAAE,SAAS,UAAU,EAAE,GAChC,OAAO,CAYT"}