@atscript/db 0.1.134 → 0.1.136

package/dist/agg-CV7y8nC6.d.cts

@@ -0,0 +1,53 @@
+import { AggregateControls, AggregateExpr as AggregateExpr$1, AggregateFn, AggregateFn as AggregateFn$1, AggregateQuery as AggregateQuery$1, AggregateResult, BucketExpr, BucketUnit as BucketUnit$1, CalendarBucketLabel, ComputedExpr, ResolvedBucket as ResolvedBucket$1, WeekStart, isAggregateExpr, isBucketExpr, resolveAlias } from "@uniqu/core";
+
+//#region src/query/aggregate-fns.d.ts
+/**
+ * The aggregate functions atscript-db knows — uniqu's full `AggregateFn` set.
+ * Which of them an adapter renders is its `aggregateFns()` capability.
+ */
+type TDbAggregateFn = AggregateFn;
+/**
+ * Every aggregate function — what an adapter that renders them all returns
+ * from `aggregateFns()`.
+ *
+ * @since 0.1.136
+ */
+declare const ALL_AGGREGATE_FNS: ReadonlySet<TDbAggregateFn>;
+/**
+ * Throws `DbError` `INVALID_QUERY` (uniqu's wording) unless `fn` is in
+ * `SUPPORTED_AGGREGATE_FNS` — for adapters to re-assert before rendering.
+ */
+declare function assertAggregateFn(fn: unknown, path?: string): asserts fn is TDbAggregateFn;
+//#endregion
+//#region src/agg.d.ts
+/** The text-search request a grouped query carries, once normalised. */
+interface TAggregateSearch {
+  /** Non-empty, trimmed search term. */
+  text: string;
+  /** Named search index to target, when the caller picked one. */
+  indexName?: string;
+}
+/**
+ * Reads the `$search` / `$index` controls of an aggregate query.
+ *
+ * Search and grouping are orthogonal: `$search` narrows the ROWS, `$groupBy`
+ * shapes what is left. Every adapter must therefore apply the search predicate
+ * BEFORE grouping, so the groups — and `$count`, which counts them — only ever
+ * describe rows that matched. An adapter that silently ignored the term would
+ * report totals for rows the same search excludes from the leaf list.
+ *
+ * Two rules the leaf search path applies and the grouped path must NOT:
+ * - **No implicit relevance ordering.** Relevance is a property of a row, not
+ *   of a group; after `$group` there is no per-row score left to sort on.
+ *   Grouped results order by `$sort` or not at all.
+ * - **No implicit row cap.** The leaf runners cap an unbounded search at 1000
+ *   rows; applying that before `$group` would silently truncate group counts.
+ *
+ * Returns `undefined` when there is nothing to search for, so callers fall
+ * straight through to the plain grouped path.
+ */
+declare function resolveAggregateSearch(controls: {
+  [key: `$${string}`]: unknown;
+} | undefined): TAggregateSearch | undefined;
+//#endregion
+export { TDbAggregateFn as _, AggregateResult as a, CalendarBucketLabel as c, WeekStart as d, isAggregateExpr as f, ALL_AGGREGATE_FNS as g, resolveAlias as h, AggregateQuery$1 as i, ComputedExpr as l, resolveAggregateSearch as m, AggregateExpr$1 as n, BucketExpr as o, isBucketExpr as p, AggregateFn$1 as r, BucketUnit$1 as s, AggregateControls as t, ResolvedBucket$1 as u, assertAggregateFn as v };

package/dist/agg-D5DHsAby.d.mts

@@ -0,0 +1,53 @@
+import { AggregateControls, AggregateExpr as AggregateExpr$1, AggregateFn, AggregateFn as AggregateFn$1, AggregateQuery as AggregateQuery$1, AggregateResult, BucketExpr, BucketUnit as BucketUnit$1, CalendarBucketLabel, ComputedExpr, ResolvedBucket as ResolvedBucket$1, WeekStart, isAggregateExpr as isAggregateExpr$1, isBucketExpr as isBucketExpr$1, resolveAlias } from "@uniqu/core";
+
+//#region src/query/aggregate-fns.d.ts
+/**
+ * The aggregate functions atscript-db knows — uniqu's full `AggregateFn` set.
+ * Which of them an adapter renders is its `aggregateFns()` capability.
+ */
+type TDbAggregateFn = AggregateFn;
+/**
+ * Every aggregate function — what an adapter that renders them all returns
+ * from `aggregateFns()`.
+ *
+ * @since 0.1.136
+ */
+declare const ALL_AGGREGATE_FNS: ReadonlySet<TDbAggregateFn>;
+/**
+ * Throws `DbError` `INVALID_QUERY` (uniqu's wording) unless `fn` is in
+ * `SUPPORTED_AGGREGATE_FNS` — for adapters to re-assert before rendering.
+ */
+declare function assertAggregateFn(fn: unknown, path?: string): asserts fn is TDbAggregateFn;
+//#endregion
+//#region src/agg.d.ts
+/** The text-search request a grouped query carries, once normalised. */
+interface TAggregateSearch {
+  /** Non-empty, trimmed search term. */
+  text: string;
+  /** Named search index to target, when the caller picked one. */
+  indexName?: string;
+}
+/**
+ * Reads the `$search` / `$index` controls of an aggregate query.
+ *
+ * Search and grouping are orthogonal: `$search` narrows the ROWS, `$groupBy`
+ * shapes what is left. Every adapter must therefore apply the search predicate
+ * BEFORE grouping, so the groups — and `$count`, which counts them — only ever
+ * describe rows that matched. An adapter that silently ignored the term would
+ * report totals for rows the same search excludes from the leaf list.
+ *
+ * Two rules the leaf search path applies and the grouped path must NOT:
+ * - **No implicit relevance ordering.** Relevance is a property of a row, not
+ *   of a group; after `$group` there is no per-row score left to sort on.
+ *   Grouped results order by `$sort` or not at all.
+ * - **No implicit row cap.** The leaf runners cap an unbounded search at 1000
+ *   rows; applying that before `$group` would silently truncate group counts.
+ *
+ * Returns `undefined` when there is nothing to search for, so callers fall
+ * straight through to the plain grouped path.
+ */
+declare function resolveAggregateSearch(controls: {
+  [key: `$${string}`]: unknown;
+} | undefined): TAggregateSearch | undefined;
+//#endregion
+export { TDbAggregateFn as _, AggregateResult as a, CalendarBucketLabel as c, WeekStart as d, isAggregateExpr$1 as f, ALL_AGGREGATE_FNS as g, resolveAlias as h, AggregateQuery$1 as i, ComputedExpr as l, resolveAggregateSearch as m, AggregateExpr$1 as n, BucketExpr as o, isBucketExpr$1 as p, AggregateFn$1 as r, BucketUnit$1 as s, AggregateControls as t, ResolvedBucket$1 as u, assertAggregateFn as v };

package/dist/agg.cjs

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_aggregate_fns = require("./aggregate-fns-CGBv3E8S.cjs");
 let _uniqu_core = require("@uniqu/core");
 //#region src/agg.ts
 /**
@@ -32,6 +33,7 @@ function resolveAggregateSearch(controls) {
 	};
 }
 //#endregion
+exports.assertAggregateFn = require_aggregate_fns.assertAggregateFn;
 Object.defineProperty(exports, "isAggregateExpr", {
 	enumerable: true,
 	get: function() {

package/dist/agg.d.cts

@@ -1,35 +1,3 @@
-import { n as TResolvedBucket } from "./buckets-Bo2IcPZ_.cjs";
-import { AggregateControls, AggregateExpr, AggregateFn, AggregateQuery, AggregateResult, BucketExpr, BucketUnit, CalendarBucketLabel, ComputedExpr, ResolvedBucket, WeekStart, isAggregateExpr, isBucketExpr, resolveAlias } from "@uniqu/core";
-
-//#region src/agg.d.ts
-/** The text-search request a grouped query carries, once normalised. */
-interface TAggregateSearch {
-  /** Non-empty, trimmed search term. */
-  text: string;
-  /** Named search index to target, when the caller picked one. */
-  indexName?: string;
-}
-/**
- * Reads the `$search` / `$index` controls of an aggregate query.
- *
- * Search and grouping are orthogonal: `$search` narrows the ROWS, `$groupBy`
- * shapes what is left. Every adapter must therefore apply the search predicate
- * BEFORE grouping, so the groups — and `$count`, which counts them — only ever
- * describe rows that matched. An adapter that silently ignored the term would
- * report totals for rows the same search excludes from the leaf list.
- *
- * Two rules the leaf search path applies and the grouped path must NOT:
- * - **No implicit relevance ordering.** Relevance is a property of a row, not
- *   of a group; after `$group` there is no per-row score left to sort on.
- *   Grouped results order by `$sort` or not at all.
- * - **No implicit row cap.** The leaf runners cap an unbounded search at 1000
- *   rows; applying that before `$group` would silently truncate group counts.
- *
- * Returns `undefined` when there is nothing to search for, so callers fall
- * straight through to the plain grouped path.
- */
-declare function resolveAggregateSearch(controls: {
-  [key: `$${string}`]: unknown;
-} | undefined): TAggregateSearch | undefined;
-//#endregion
-export { type AggregateControls, type AggregateExpr, type AggregateFn, type AggregateQuery, type AggregateResult, type BucketExpr, type BucketUnit, type CalendarBucketLabel, type ComputedExpr, type ResolvedBucket, type TResolvedBucket, type WeekStart, isAggregateExpr, isBucketExpr, resolveAggregateSearch, resolveAlias };
+import { n as TResolvedBucket } from "./buckets-kKY0RKYN.cjs";
+import { _ as TDbAggregateFn, a as AggregateResult, c as CalendarBucketLabel, d as WeekStart, f as isAggregateExpr, h as resolveAlias, i as AggregateQuery, l as ComputedExpr, m as resolveAggregateSearch, n as AggregateExpr, o as BucketExpr, p as isBucketExpr, r as AggregateFn, s as BucketUnit, t as AggregateControls, u as ResolvedBucket, v as assertAggregateFn } from "./agg-CV7y8nC6.cjs";
+export { type AggregateControls, type AggregateExpr, type AggregateFn, type AggregateQuery, type AggregateResult, type BucketExpr, type BucketUnit, type CalendarBucketLabel, type ComputedExpr, type ResolvedBucket, type TDbAggregateFn, type TResolvedBucket, type WeekStart, assertAggregateFn, isAggregateExpr, isBucketExpr, resolveAggregateSearch, resolveAlias };

package/dist/agg.d.mts

@@ -1,35 +1,3 @@
-import { n as TResolvedBucket } from "./buckets-Bys2QXyk.mjs";
-import { AggregateControls, AggregateExpr, AggregateFn, AggregateQuery, AggregateResult, BucketExpr, BucketUnit, CalendarBucketLabel, ComputedExpr, ResolvedBucket, WeekStart, isAggregateExpr, isBucketExpr, resolveAlias } from "@uniqu/core";
-
-//#region src/agg.d.ts
-/** The text-search request a grouped query carries, once normalised. */
-interface TAggregateSearch {
-  /** Non-empty, trimmed search term. */
-  text: string;
-  /** Named search index to target, when the caller picked one. */
-  indexName?: string;
-}
-/**
- * Reads the `$search` / `$index` controls of an aggregate query.
- *
- * Search and grouping are orthogonal: `$search` narrows the ROWS, `$groupBy`
- * shapes what is left. Every adapter must therefore apply the search predicate
- * BEFORE grouping, so the groups — and `$count`, which counts them — only ever
- * describe rows that matched. An adapter that silently ignored the term would
- * report totals for rows the same search excludes from the leaf list.
- *
- * Two rules the leaf search path applies and the grouped path must NOT:
- * - **No implicit relevance ordering.** Relevance is a property of a row, not
- *   of a group; after `$group` there is no per-row score left to sort on.
- *   Grouped results order by `$sort` or not at all.
- * - **No implicit row cap.** The leaf runners cap an unbounded search at 1000
- *   rows; applying that before `$group` would silently truncate group counts.
- *
- * Returns `undefined` when there is nothing to search for, so callers fall
- * straight through to the plain grouped path.
- */
-declare function resolveAggregateSearch(controls: {
-  [key: `$${string}`]: unknown;
-} | undefined): TAggregateSearch | undefined;
-//#endregion
-export { type AggregateControls, type AggregateExpr, type AggregateFn, type AggregateQuery, type AggregateResult, type BucketExpr, type BucketUnit, type CalendarBucketLabel, type ComputedExpr, type ResolvedBucket, type TResolvedBucket, type WeekStart, isAggregateExpr, isBucketExpr, resolveAggregateSearch, resolveAlias };
+import { n as TResolvedBucket } from "./buckets-y4EzoX7D.mjs";
+import { _ as TDbAggregateFn, a as AggregateResult, c as CalendarBucketLabel, d as WeekStart, f as isAggregateExpr, h as resolveAlias, i as AggregateQuery, l as ComputedExpr, m as resolveAggregateSearch, n as AggregateExpr, o as BucketExpr, p as isBucketExpr, r as AggregateFn, s as BucketUnit, t as AggregateControls, u as ResolvedBucket, v as assertAggregateFn } from "./agg-D5DHsAby.mjs";
+export { type AggregateControls, type AggregateExpr, type AggregateFn, type AggregateQuery, type AggregateResult, type BucketExpr, type BucketUnit, type CalendarBucketLabel, type ComputedExpr, type ResolvedBucket, type TDbAggregateFn, type TResolvedBucket, type WeekStart, assertAggregateFn, isAggregateExpr, isBucketExpr, resolveAggregateSearch, resolveAlias };

package/dist/agg.mjs

@@ -1,3 +1,4 @@
+import { a as assertAggregateFn } from "./aggregate-fns-CfsveE1w.mjs";
 import { isAggregateExpr, isBucketExpr, resolveAlias } from "@uniqu/core";
 //#region src/agg.ts
 /**
@@ -31,4 +32,4 @@ function resolveAggregateSearch(controls) {
 	};
 }
 //#endregion
-export { isAggregateExpr, isBucketExpr, resolveAggregateSearch, resolveAlias };
+export { assertAggregateFn, isAggregateExpr, isBucketExpr, resolveAggregateSearch, resolveAlias };

package/dist/aggregate-fns-CGBv3E8S.cjs

@@ -0,0 +1,87 @@
+const require_db_error = require("./db-error-DTkkeu5b.cjs");
+//#region src/query/aggregate-fns.ts
+/**
+* The only `$fn` names a `$select` aggregate may use. Any other name is rejected with
+* `INVALID_QUERY` (HTTP 400 through moost-db) before a query reaches an
+* adapter, so no adapter ever renders an unchecked function name into SQL or
+* a pipeline. A known name missing from the adapter's `aggregateFns()` is
+* `AGG_FN_NOT_SUPPORTED`.
+*/
+const SUPPORTED_AGGREGATE_FNS = [
+	"sum",
+	"count",
+	"avg",
+	"min",
+	"max",
+	"countDistinct"
+];
+/**
+* The aggregates that are NULL over no (non-null) value — every function but
+* the counts, which are 0. So a view field reading a left-joined table must be
+* optional unless it counts, and a CONDITIONAL one must be optional when no
+* row may match — except `sum`, whose conditional form is rendered as
+* `COALESCE(…, 0)`.
+*/
+const NULL_WHEN_EMPTY_AGGREGATE_FNS = new Set([
+	"sum",
+	"avg",
+	"min",
+	"max"
+]);
+/** `BaseDbAdapter.aggregateFns()` by default: every function except `countDistinct`. */
+const BASE_AGGREGATE_FNS = new Set([
+	"sum",
+	"count",
+	"avg",
+	"min",
+	"max"
+]);
+/**
+* Every aggregate function — what an adapter that renders them all returns
+* from `aggregateFns()`.
+*
+* @since 0.1.136
+*/
+const ALL_AGGREGATE_FNS = new Set(SUPPORTED_AGGREGATE_FNS);
+const SUPPORTED_LIST = `${SUPPORTED_AGGREGATE_FNS.slice(0, -1).join(", ")} or ${SUPPORTED_AGGREGATE_FNS.at(-1)}`;
+/**
+* Throws `DbError` `INVALID_QUERY` (uniqu's wording) unless `fn` is in
+* `SUPPORTED_AGGREGATE_FNS` — for adapters to re-assert before rendering.
+*/
+function assertAggregateFn(fn, path = "$select") {
+	if (!SUPPORTED_AGGREGATE_FNS.includes(fn)) throw new require_db_error.DbError("INVALID_QUERY", [{
+		path,
+		message: `Unknown aggregate function "${String(fn)}" — use ${SUPPORTED_LIST}`
+	}]);
+}
+//#endregion
+Object.defineProperty(exports, "ALL_AGGREGATE_FNS", {
+	enumerable: true,
+	get: function() {
+		return ALL_AGGREGATE_FNS;
+	}
+});
+Object.defineProperty(exports, "BASE_AGGREGATE_FNS", {
+	enumerable: true,
+	get: function() {
+		return BASE_AGGREGATE_FNS;
+	}
+});
+Object.defineProperty(exports, "NULL_WHEN_EMPTY_AGGREGATE_FNS", {
+	enumerable: true,
+	get: function() {
+		return NULL_WHEN_EMPTY_AGGREGATE_FNS;
+	}
+});
+Object.defineProperty(exports, "SUPPORTED_AGGREGATE_FNS", {
+	enumerable: true,
+	get: function() {
+		return SUPPORTED_AGGREGATE_FNS;
+	}
+});
+Object.defineProperty(exports, "assertAggregateFn", {
+	enumerable: true,
+	get: function() {
+		return assertAggregateFn;
+	}
+});

package/dist/aggregate-fns-CfsveE1w.mjs

@@ -0,0 +1,58 @@
+import { r as DbError } from "./db-error-D5uilS_A.mjs";
+//#region src/query/aggregate-fns.ts
+/**
+* The only `$fn` names a `$select` aggregate may use. Any other name is rejected with
+* `INVALID_QUERY` (HTTP 400 through moost-db) before a query reaches an
+* adapter, so no adapter ever renders an unchecked function name into SQL or
+* a pipeline. A known name missing from the adapter's `aggregateFns()` is
+* `AGG_FN_NOT_SUPPORTED`.
+*/
+const SUPPORTED_AGGREGATE_FNS = [
+	"sum",
+	"count",
+	"avg",
+	"min",
+	"max",
+	"countDistinct"
+];
+/**
+* The aggregates that are NULL over no (non-null) value — every function but
+* the counts, which are 0. So a view field reading a left-joined table must be
+* optional unless it counts, and a CONDITIONAL one must be optional when no
+* row may match — except `sum`, whose conditional form is rendered as
+* `COALESCE(…, 0)`.
+*/
+const NULL_WHEN_EMPTY_AGGREGATE_FNS = new Set([
+	"sum",
+	"avg",
+	"min",
+	"max"
+]);
+/** `BaseDbAdapter.aggregateFns()` by default: every function except `countDistinct`. */
+const BASE_AGGREGATE_FNS = new Set([
+	"sum",
+	"count",
+	"avg",
+	"min",
+	"max"
+]);
+/**
+* Every aggregate function — what an adapter that renders them all returns
+* from `aggregateFns()`.
+*
+* @since 0.1.136
+*/
+const ALL_AGGREGATE_FNS = new Set(SUPPORTED_AGGREGATE_FNS);
+const SUPPORTED_LIST = `${SUPPORTED_AGGREGATE_FNS.slice(0, -1).join(", ")} or ${SUPPORTED_AGGREGATE_FNS.at(-1)}`;
+/**
+* Throws `DbError` `INVALID_QUERY` (uniqu's wording) unless `fn` is in
+* `SUPPORTED_AGGREGATE_FNS` — for adapters to re-assert before rendering.
+*/
+function assertAggregateFn(fn, path = "$select") {
+	if (!SUPPORTED_AGGREGATE_FNS.includes(fn)) throw new DbError("INVALID_QUERY", [{
+		path,
+		message: `Unknown aggregate function "${String(fn)}" — use ${SUPPORTED_LIST}`
+	}]);
+}
+//#endregion
+export { assertAggregateFn as a, SUPPORTED_AGGREGATE_FNS as i, BASE_AGGREGATE_FNS as n, NULL_WHEN_EMPTY_AGGREGATE_FNS as r, ALL_AGGREGATE_FNS as t };

package/dist/{buckets-Bo2IcPZ_.d.cts → buckets-kKY0RKYN.d.cts}

@@ -1,5 +1,5 @@
 import { f as TFieldOps } from "./ops-AqhV7s9o.cjs";
-import { AggregateControls, AggregateExpr, AggregateExpr as AggregateExpr$1, AggregateFn, AggregateQuery, AggregateQuery as AggregateQuery$1, AggregateResult, BucketUnit, FieldOpsFor, FilterExpr, FilterExpr as FilterExpr$1, ResolvedBucket, TypedWithRelation, Uniquery, Uniquery as Uniquery$1, UniqueryControls, UniqueryControls as UniqueryControls$1, UniqueryInsights, WithRelation, WithRelation as WithRelation$1 } from "@uniqu/core";
+import { AggregateControls, AggregateExpr, AggregateExpr as AggregateExpr$1, AggregateFn, AggregateFn as AggregateFn$1, AggregateQuery, AggregateQuery as AggregateQuery$1, AggregateResult, BucketUnit, FieldOpsFor, FilterExpr, FilterExpr as FilterExpr$1, ResolvedBucket, TypedWithRelation, Uniquery, Uniquery as Uniquery$1, UniqueryControls, UniqueryControls as UniqueryControls$1, UniqueryInsights, WithRelation, WithRelation as WithRelation$1 } from "@uniqu/core";
 import { FlatOf, FlatOf as FlatOf$1, NavPropsOf, NavPropsOf as NavPropsOf$1, OwnPropsOf, OwnPropsOf as OwnPropsOf$1, PrimaryKeyOf, PrimaryKeyOf as PrimaryKeyOf$1, TAtscriptAnnotatedType, TAtscriptDataType, TAtscriptTypeObject, TMetadataMap, TSerializedAnnotatedType, TValidatorOptions, TValidatorPlugin, Validator } from "@atscript/typescript/utils";
 
 //#region src/query/uniqu-select.d.ts
@@ -15,7 +15,7 @@ import { FlatOf, FlatOf as FlatOf$1, NavPropsOf, NavPropsOf as NavPropsOf$1, Own
  * An array `$select` holds plain field names and computed entries —
  * aggregates (`{ $fn, $field }`, {@link aggregates}) and calendar buckets
  * (`{ $bucket, $field }`, {@link buckets}). Entries arrive normalized
- * (`resolveCalendarBuckets` rejects any other shape before translation).
+ * (`normalizeComputedSelect` rejects any other shape before translation).
  */
 declare class UniquSelect {
   private static readonly UNRESOLVED;
@@ -101,7 +101,7 @@ declare abstract class FieldMappingStrategy {
    * equals a field name).
    *
    * `buckets` are the query's calendar buckets as the core's normalizer
-   * resolved them (`resolveCalendarBuckets` — `AtscriptDbReadable.aggregate`
+   * resolved them (`normalizeComputedSelect` — `AtscriptDbReadable.aggregate`
    * runs it before the guards); they reach adapters with `field` made
    * physical and the source descriptor as `fd`.
    */
@@ -111,7 +111,10 @@ declare abstract class FieldMappingStrategy {
   /**
    * `$select` with its field paths made physical: array-form names and
    * computed `$field`s (`'*'` kept), or the keys of the object
-   * (inclusion / exclusion) form.
+   * (inclusion / exclusion) form. An aggregate's output alias is fixed
+   * (`$as`) from its LOGICAL field first, so a default alias never leaks a
+   * physical name (`sum(amount)` over `@db.column 'amount_cents'` stays
+   * `sum_amount`); a bucket's alias is already resolved.
    */
   protected physicalSelect(select: NonNullable<UniqueryControls["$select"]>, meta: TableMetadata): NonNullable<UniqueryControls["$select"]>;
   /** `$sort` with physical keys; computed `aliases` (grouped queries) pass through. */
@@ -478,13 +481,15 @@ declare class AtscriptDbReadable<T extends TAtscriptAnnotatedType = TAtscriptAnn
    *
    * Validates:
    * - `$select` computed entries and calendar buckets (the shared normalizer,
-   *   `resolveCalendarBuckets`: shapes, unit, zone, alias, grouping)
+   *   `normalizeComputedSelect`: shapes, unit, zone, alias, grouping)
    * - Plain fields in $select are a subset of $groupBy
    * - When dimensions/measures are defined (strict mode): $groupBy fields
-   *   must be dimensions, aggregate $field values must be measures (or '*')
+   *   must be dimensions, aggregate $field values must be measures (or '*';
+   *   a `countDistinct` field may also be a dimension)
    * - the path guard (a bucket source must pass `bucketSourceVerdict` —
    *   timestamp type, no JSON ancestor, a dimension in strict mode, an
-   *   adapter with calendar buckets) and the adapter's calendar-bucket units
+   *   adapter with calendar buckets), the adapter's aggregate functions
+   *   (`AGG_FN_NOT_SUPPORTED`) and calendar-bucket units
    *   (`BUCKET_NOT_SUPPORTED`)
    *
    * Translates field names, delegates to adapter.aggregate(),
@@ -497,6 +502,8 @@ declare class AtscriptDbReadable<T extends TAtscriptAnnotatedType = TAtscriptAnn
   canFilterField(fd: TDbFieldMeta): boolean;
   /** Calendar-bucket units the adapter can group by (proxies adapter capability; empty = none). */
   calendarBucketUnits(): ReadonlySet<BucketUnit>;
+  /** Aggregate functions the adapter renders (proxies adapter capability). @since 0.1.136 */
+  aggregateFns(): ReadonlySet<AggregateFn>;
   /** Whether the adapter can sort by a given field (proxies adapter capability). */
   canSortField(fd: TDbFieldMeta): boolean;
   /** Returns available search indexes from the adapter. */
@@ -799,6 +806,18 @@ declare abstract class BaseDbAdapter {
    * out-of-range source, uniqu's `bucketLabel` semantics). Since 0.1.132.
    */
   calendarBucketUnits(): ReadonlySet<BucketUnit>;
+  /**
+   * Aggregate functions (`{ $fn, $field }` in an aggregate `$select`) this
+   * adapter renders. The default is `sum`, `count`, `avg`, `min` and `max`;
+   * an adapter that also implements `countDistinct` (distinct non-null
+   * values) returns `ALL_AGGREGATE_FNS`. The core rejects a known function
+   * missing from this set with `AGG_FN_NOT_SUPPORTED` before dispatch, so
+   * `aggregate()` only ever receives functions listed here; moost-db's
+   * `/meta` advertises the set as `aggregateFns`.
+   *
+   * @since 0.1.136
+   */
+  aggregateFns(): ReadonlySet<AggregateFn>;
   /**
    * Whether this adapter enforces foreign key constraints natively.
    * When `true`, the generic layer skips application-level cascade/setNull
@@ -1468,8 +1487,6 @@ declare class TableMetadata {
    * Builds the bidirectional pathToPhysical / physicalToPath maps.
    */
   private _classifyFields;
-  /** Returns the `__`-separated parent prefix for a dot-separated path, or empty string for top-level paths. */
-  private _flattenedPrefix;
   /** Nearest `@db.encrypted` ancestor of `path` (exclusive), or `undefined`. */
   /**
    * Indexes non-ignored descriptors by logical path and retains the JSON-parent
@@ -1619,6 +1636,14 @@ interface TMetaResponse {
    * none. Since 0.1.132.
    */
   bucketUnits?: BucketUnit[];
+  /**
+   * Aggregate functions the adapter renders (`{ $fn }` in an aggregate
+   * `$select`, URL `sum(field)` / `countDistinct(field)` …) — see
+   * `BaseDbAdapter.aggregateFns()`.
+   *
+   * @since 0.1.136
+   */
+  aggregateFns?: AggregateFn[];
 }
 /** Where the action applies on the UI. */
 type TDbActionLevel = "table" | "row" | "rows";
@@ -1684,12 +1709,24 @@ interface TDbActionInfo {
   disabled?: string;
   /**
    * Name of the `.as` interface the action's `@InputForm()` parameter expects
-   * (the compiled class's `.name`). Present only when the handler declares an
-   * `@InputForm(FormType)` parameter. Clients fetch the serialized schema via
-   * `GET /meta/form/:name` on the same controller and render a form to
-   * collect the `input` field of the action's request envelope.
+   * (the compiled class's `.name`). Present for an `@InputForm(FormType)`
+   * parameter or a class-level `inputForm` entry. Clients fetch the
+   * serialized schema via `GET /meta/form/:name` on the same controller and
+   * render a form to collect the `input` field of the action's request
+   * envelope. A class-level entry may name a form served elsewhere — then
+   * {@link formUrl} is present and clients fetch it instead of `meta/form/:name`.
    */
   inputForm?: string;
+  /**
+   * Server-absolute path of the serialized form schema —
+   * same convention as `value` for `'backend'` actions: clients prefix
+   * their base URL. Present only together with {@link inputForm}, when the
+   * form is served by another endpoint than this controller's
+   * `meta/form/:name`; clients fetch it instead of the relative route.
+   *
+   * @since 0.1.136
+   */
+  formUrl?: string;
 }
 interface TDbInsertResult {
   insertedId: unknown;
@@ -2217,13 +2254,15 @@ interface TBucketFieldSource {
   navFields: ReadonlySet<string>;
 }
 /**
- * The one normalizer of `$select` computed entries (since 0.1.132) — uniqu's
+ * The one normalizer of `$select` computed entries — uniqu's
  * `resolveBuckets` (entry shapes, unit, time zone canonicalization, week
  * start, alias syntax and uniqueness, "grouped queries only", "must also
  * appear in $groupBy", string `$groupBy` entries) with the table's names as
  * the collision set: a bucket alias may not equal a logical path, a physical
  * column or a navigation field, so a label is never reverse-mapped as a
- * column.
+ * column. Aggregate entries are checked against `SUPPORTED_AGGREGATE_FNS`
+ * (and `'*'` is `count`'s only); whether the adapter renders a function is
+ * `guardAggregate`'s (`aggregateFns()` → `AGG_FN_NOT_SUPPORTED`).
  *
  * Which layer validates what:
  * - **Shapes** (this normalizer) run FIRST at every entry point — the core's
@@ -2245,10 +2284,15 @@ interface TBucketFieldSource {
  *
  * @throws DbError `INVALID_QUERY` carrying every issue (`path` `$select` / `$groupBy`).
  */
-declare function resolveCalendarBuckets(controls: {
+declare function normalizeComputedSelect(controls: {
   $select?: unknown;
   $groupBy?: unknown;
 } | undefined, fields: TBucketFieldSource, aggregate?: boolean): ResolvedBucket[];
+/**
+ * @deprecated since 0.1.136 — renamed {@link normalizeComputedSelect} (it
+ * normalizes every computed `$select` entry, aggregates included).
+ */
+declare const resolveCalendarBuckets: typeof normalizeComputedSelect;
 /**
  * Whether a field's TYPE allows it to be the source of a calendar bucket: a
  * `number` / `integer` leaf carrying the `timestamp` tag
@@ -2274,4 +2318,4 @@ declare function isJsonValueField(fd: TDbFieldMeta): boolean;
  */
 declare function jsonValueAncestor(path: string, jsonValueParents: ReadonlySet<string>): string | undefined;
 //#endregion
-export { TDbWriteGuardContext as $, TDbActionIntent as A, isGeoIndexableType as At, TDbIndexField as B, FieldMappingStrategy as Bt, PrimaryKeyOf$1 as C, TWriteTableResolver as Ct, TCrudOp as D, WithRelation$1 as Dt, TColumnDiff as E, UniqueryControls$1 as Et, TDbDefaultValue as F, DbResponse as Ft, TDbReferentialAction as G, TDbInsertManyResult as H, TGenericLogger as Ht, TDbDeleteResult as I, resolveDesignType as It, TDbRemoveGuardContext as J, TDbRelation as K, TDbFieldMeta as L, DbEncryption as Lt, TDbActionProcessor as M, ALL_BUCKET_UNITS as Mt, TDbCollation as N, BaseDbAdapter as Nt, TCrudPermissions as O, TableMetadata as Ot, TDbDefaultFn as P, AtscriptDbReadable as Pt, TDbWriteGuard as Q, TDbForeignKey as R, TDbEncryptionOptions as Rt, OwnPropsOf$1 as S, TWriteOptions as St, TCascadeTarget as T, Uniquery$1 as Tt, TDbInsertResult as U, UniquSelect as Ut, TDbIndexType as V, NoopLogger as Vt, TDbObjectKind as W, TDbUpdateResult as X, TDbStorageType as Y, TDbWriteAction as Z, FieldOpsFor as _, TSyncColumnResult as _t, jsonValueAncestor as a, TFieldMeta as at, NavPropsOf$1 as b, TTouchManyOptions as bt, AggregateExpr$1 as c, TIdDescriptor as ct, AggregateResult as d, TMetaResponse as dt, TDeleteOptions as et, AtscriptDbWritable as f, TMetadataOverrides as ft, DbRow as g, TSearchIndexInfo as gt, DbQuery as h, TRelationInfo as ht, isJsonValueField as i, TExistingTableOption as it, TDbActionLevel as j, isGeoPointType as jt, TDbActionInfo as k, findAncestorInSet as kt, AggregateFn as l, TIdResolveOptions as lt, DbPatch as m, TReferencingForeignKey as mt, TResolvedBucket as n, TExistingColumn as nt, resolveCalendarBuckets as o, TFkLookupResolver as ot, DbControls as p, TPrimaryKeyChange as pt, TDbRemoveGuard as q, isBucketableField as r, TExistingForeignKey as rt, AggregateControls as s, TFkLookupTarget as st, TBucketFieldSource as t, TEnsureTableOptions as tt, AggregateQuery$1 as u, TIdentification as ut, FilterExpr$1 as v, TTableOptionDiff as vt, TCascadeResolver as w, TypedWithRelation as wt, NullableOptional as x, TValueFormatterPair as xt, FlatOf$1 as y, TTableResolver as yt, TDbIndex as z, DocumentFieldMapper as zt };
+export { TDbWriteGuard as $, TDbActionInfo as A, findAncestorInSet as At, TDbIndex as B, DocumentFieldMapper as Bt, OwnPropsOf$1 as C, TWriteOptions as Ct, TColumnDiff as D, UniqueryControls$1 as Dt, TCascadeTarget as E, Uniquery$1 as Et, TDbDefaultFn as F, AtscriptDbReadable as Ft, TDbObjectKind as G, TDbIndexType as H, NoopLogger as Ht, TDbDefaultValue as I, DbResponse as It, TDbRemoveGuard as J, TDbReferentialAction as K, TDbDeleteResult as L, resolveDesignType as Lt, TDbActionLevel as M, isGeoPointType as Mt, TDbActionProcessor as N, ALL_BUCKET_UNITS as Nt, TCrudOp as O, WithRelation$1 as Ot, TDbCollation as P, BaseDbAdapter as Pt, TDbWriteAction as Q, TDbFieldMeta as R, DbEncryption as Rt, NullableOptional as S, TValueFormatterPair as St, TCascadeResolver as T, TypedWithRelation as Tt, TDbInsertManyResult as U, TGenericLogger as Ut, TDbIndexField as V, FieldMappingStrategy as Vt, TDbInsertResult as W, UniquSelect as Wt, TDbStorageType as X, TDbRemoveGuardContext as Y, TDbUpdateResult as Z, DbRow as _, TSearchIndexInfo as _t, jsonValueAncestor as a, TExistingTableOption as at, FlatOf$1 as b, TTableResolver as bt, AggregateControls as c, TFkLookupTarget as ct, AggregateQuery$1 as d, TIdentification as dt, TDbWriteGuardContext as et, AggregateResult as f, TMetaResponse as ft, DbQuery as g, TRelationInfo as gt, DbPatch as h, TReferencingForeignKey as ht, isJsonValueField as i, TExistingForeignKey as it, TDbActionIntent as j, isGeoIndexableType as jt, TCrudPermissions as k, TableMetadata as kt, AggregateExpr$1 as l, TIdDescriptor as lt, DbControls as m, TPrimaryKeyChange as mt, TResolvedBucket as n, TEnsureTableOptions as nt, normalizeComputedSelect as o, TFieldMeta as ot, AtscriptDbWritable as p, TMetadataOverrides as pt, TDbRelation as q, isBucketableField as r, TExistingColumn as rt, resolveCalendarBuckets as s, TFkLookupResolver as st, TBucketFieldSource as t, TDeleteOptions as tt, AggregateFn$1 as u, TIdResolveOptions as ut, FieldOpsFor as v, TSyncColumnResult as vt, PrimaryKeyOf$1 as w, TWriteTableResolver as wt, NavPropsOf$1 as x, TTouchManyOptions as xt, FilterExpr$1 as y, TTableOptionDiff as yt, TDbForeignKey as z, TDbEncryptionOptions as zt };