@atscript/db 0.1.133 → 0.1.135

package/dist/agg-BtlGeRfj.d.mts

@@ -0,0 +1,43 @@
+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 adapters implement — uniqu's set minus `countDistinct`. */
+type TDbAggregateFn = Exclude<AggregateFn, "countDistinct">;
+/**
+ * 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 { assertAggregateFn as _, AggregateResult as a, CalendarBucketLabel as c, WeekStart as d, isAggregateExpr$1 as f, TDbAggregateFn 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 };

package/dist/agg-CvXDGnKi.mjs

@@ -0,0 +1,61 @@
+import { r as DbError } from "./db-error-D5uilS_A.mjs";
+import { isAggregateExpr as isAggregateExpr$1, isBucketExpr as isBucketExpr$1, resolveAlias } from "@uniqu/core";
+//#region src/query/aggregate-fns.ts
+/**
+* The only `$fn` names a `$select` aggregate may use (since 0.1.135). 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.
+*/
+const SUPPORTED_AGGREGATE_FNS = [
+	"sum",
+	"count",
+	"avg",
+	"min",
+	"max"
+];
+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
+//#region src/agg.ts
+/**
+* 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.
+*/
+function resolveAggregateSearch(controls) {
+	const raw = controls?.$search;
+	if (typeof raw !== "string") return;
+	const text = raw.trim();
+	if (!text) return;
+	const index = controls?.$index;
+	return {
+		text,
+		indexName: typeof index === "string" && index ? index : void 0
+	};
+}
+//#endregion
+export { SUPPORTED_AGGREGATE_FNS as a, resolveAlias as i, isBucketExpr$1 as n, assertAggregateFn as o, resolveAggregateSearch as r, isAggregateExpr$1 as t };

package/dist/agg-DKuf_v2L.d.cts

@@ -0,0 +1,43 @@
+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 adapters implement — uniqu's set minus `countDistinct`. */
+type TDbAggregateFn = Exclude<AggregateFn, "countDistinct">;
+/**
+ * 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 { assertAggregateFn as _, AggregateResult as a, CalendarBucketLabel as c, WeekStart as d, isAggregateExpr as f, TDbAggregateFn 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 };

package/dist/agg-EcIbAFnJ.cjs

@@ -0,0 +1,78 @@
+const require_db_error = require("./db-error-DTkkeu5b.cjs");
+require("@uniqu/core");
+//#region src/query/aggregate-fns.ts
+/**
+* The only `$fn` names a `$select` aggregate may use (since 0.1.135). 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.
+*/
+const SUPPORTED_AGGREGATE_FNS = [
+	"sum",
+	"count",
+	"avg",
+	"min",
+	"max"
+];
+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
+//#region src/agg.ts
+/**
+* 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.
+*/
+function resolveAggregateSearch(controls) {
+	const raw = controls?.$search;
+	if (typeof raw !== "string") return;
+	const text = raw.trim();
+	if (!text) return;
+	const index = controls?.$index;
+	return {
+		text,
+		indexName: typeof index === "string" && index ? index : void 0
+	};
+}
+//#endregion
+Object.defineProperty(exports, "SUPPORTED_AGGREGATE_FNS", {
+	enumerable: true,
+	get: function() {
+		return SUPPORTED_AGGREGATE_FNS;
+	}
+});
+Object.defineProperty(exports, "assertAggregateFn", {
+	enumerable: true,
+	get: function() {
+		return assertAggregateFn;
+	}
+});
+Object.defineProperty(exports, "resolveAggregateSearch", {
+	enumerable: true,
+	get: function() {
+		return resolveAggregateSearch;
+	}
+});

package/dist/agg.cjs

@@ -1,37 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_agg = require("./agg-EcIbAFnJ.cjs");
 let _uniqu_core = require("@uniqu/core");
-//#region src/agg.ts
-/**
-* 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.
-*/
-function resolveAggregateSearch(controls) {
-	const raw = controls?.$search;
-	if (typeof raw !== "string") return;
-	const text = raw.trim();
-	if (!text) return;
-	const index = controls?.$index;
-	return {
-		text,
-		indexName: typeof index === "string" && index ? index : void 0
-	};
-}
-//#endregion
+exports.assertAggregateFn = require_agg.assertAggregateFn;
 Object.defineProperty(exports, "isAggregateExpr", {
 	enumerable: true,
 	get: function() {
@@ -44,7 +14,7 @@ Object.defineProperty(exports, "isBucketExpr", {
 		return _uniqu_core.isBucketExpr;
 	}
 });
-exports.resolveAggregateSearch = resolveAggregateSearch;
+exports.resolveAggregateSearch = require_agg.resolveAggregateSearch;
 Object.defineProperty(exports, "resolveAlias", {
 	enumerable: true,
 	get: function() {

package/dist/agg.d.cts

@@ -1,35 +1,3 @@
-import { n as TResolvedBucket } from "./buckets-CTWy7Y1k.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-D6PBXKRJ.cjs";
+import { _ as assertAggregateFn, a as AggregateResult, c as CalendarBucketLabel, d as WeekStart, f as isAggregateExpr, g as TDbAggregateFn, 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 } from "./agg-DKuf_v2L.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-BENuu_tK.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-GruoVxH5.mjs";
+import { _ as assertAggregateFn, a as AggregateResult, c as CalendarBucketLabel, d as WeekStart, f as isAggregateExpr, g as TDbAggregateFn, 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 } from "./agg-BtlGeRfj.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,34 +1,2 @@
-import { isAggregateExpr, isBucketExpr, resolveAlias } from "@uniqu/core";
-//#region src/agg.ts
-/**
-* 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.
-*/
-function resolveAggregateSearch(controls) {
-	const raw = controls?.$search;
-	if (typeof raw !== "string") return;
-	const text = raw.trim();
-	if (!text) return;
-	const index = controls?.$index;
-	return {
-		text,
-		indexName: typeof index === "string" && index ? index : void 0
-	};
-}
-//#endregion
-export { isAggregateExpr, isBucketExpr, resolveAggregateSearch, resolveAlias };
+import { i as resolveAlias, n as isBucketExpr, o as assertAggregateFn, r as resolveAggregateSearch, t as isAggregateExpr } from "./agg-CvXDGnKi.mjs";
+export { assertAggregateFn, isAggregateExpr, isBucketExpr, resolveAggregateSearch, resolveAlias };

package/dist/{buckets-CTWy7Y1k.d.cts → buckets-D6PBXKRJ.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 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
@@ -361,6 +361,14 @@ declare class AtscriptDbReadable<T extends TAtscriptAnnotatedType = TAtscriptAnn
   get preferredId(): readonly string[];
   /** Legitimate row-identifier shapes (primary key + every unique index). */
   get identifications(): readonly TIdentification[];
+  /**
+   * The {@link identifications} an id may resolve through when fields are
+   * hidden per request (since 0.1.134): a unique index with a field that
+   * fails `isFieldVisible` is dropped, as if it did not exist. Primary-key,
+   * `preferredId` and `@meta.id` fields always count as visible. Without a
+   * predicate, every identification.
+   */
+  identificationsVisibleTo(isFieldVisible?: TIdResolveOptions["isFieldVisible"]): readonly TIdentification[];
   /**
    * Physical column name of the single `@meta.id` field, or `null` when the
    * schema has zero or multiple `@meta.id` fields. Used by adapters to return
@@ -414,6 +422,19 @@ declare class AtscriptDbReadable<T extends TAtscriptAnnotatedType = TAtscriptAnn
    * Pre-computed field metadata for adapter use.
    */
   get fieldDescriptors(): readonly TDbFieldMeta[];
+  /**
+   * The target table of the navigation relation `navField` (since 0.1.134),
+   * resolved through the table resolver this readable was built with (the
+   * `DbSpace`'s). `undefined` when `navField` is not a relation of this table
+   * or no resolver is available (a table constructed without a `DbSpace`).
+   * Top-level relation names only — no dotted paths.
+   *
+   * ```typescript
+   * const users = posts.relatedTable('author')
+   * users?.primaryKeys // ['id']
+   * ```
+   */
+  relatedTable(navField: string): ReturnType<TTableResolver>;
   /**
    * Resolves whether `path` references a real field — directly via `flatMap`
    * or transitively through a nav relation by recursing into the target
@@ -567,17 +588,20 @@ declare class AtscriptDbReadable<T extends TAtscriptAnnotatedType = TAtscriptAnn
    * same identification resolution as {@link findById}. Public so callers can
    * AND-combine the id-filter with a row-level read overlay before issuing
    * `findOne` (avoiding the existence leak that `findById` would cause).
+   * `opts.isFieldVisible` (since 0.1.134) drops unique indexes over hidden
+   * fields — see {@link identificationsVisibleTo}.
    */
-  resolveIdFilter(id: unknown): FilterExpr | null;
+  resolveIdFilter(id: unknown, opts?: TIdResolveOptions): FilterExpr | null;
   /**
    * Resolve an id value into a filter expression.
    *
    * When `preferredId` differs from the PK, scalar ids resolve only against
    * the preferred field (deterministic addressing). Otherwise scalars try PK
    * + every single-field unique index; objects try PK + compound unique
-   * indexes.
+   * indexes. With `opts.isFieldVisible`, only the identifications
+   * {@link identificationsVisibleTo} keeps are tried.
    */
-  protected _resolveIdFilter(id: unknown): FilterExpr | null;
+  protected _resolveIdFilter(id: unknown, opts?: TIdResolveOptions): FilterExpr | null;
   /** Build a single-key filter from `idObj` over `fields`, or null if any field is missing/incompatible. */
   private _tryCompoundFilter;
   /**
@@ -1391,6 +1415,7 @@ declare class TableMetadata {
   physicalNames: ReadonlySet<string>;
   private _built;
   private _identifications?;
+  private _alwaysAddressable?;
   private _collateMap;
   private _columnFromMap;
   constructor(nestedObjects: boolean);
@@ -1487,6 +1512,12 @@ declare class TableMetadata {
   private _buildIdentifications;
   /** Legitimate row-identifier shapes — primary key first, then each unique index. */
   getIdentifications(): readonly TIdentification[];
+  /**
+   * Fields that always count as visible for row identification (since
+   * 0.1.134): primary key, `preferredId` and `@meta.id` fields — see
+   * `AtscriptDbReadable.identificationsVisibleTo`.
+   */
+  getAlwaysAddressable(): ReadonlySet<string>;
   private _resolvePreferredId;
 }
 //#endregion
@@ -2114,8 +2145,13 @@ interface TTouchManyOptions {
    */
   require?: "all" | "any";
 }
-/** Options of `insertOne/Many`, `replaceOne` / `bulkReplace`, `updateOne` / `bulkUpdate`. */
-interface TWriteOptions<Row = Record<string, unknown>> {
+/**
+ * Options of `insertOne/Many`, `replaceOne` / `bulkReplace`, `updateOne` / `bulkUpdate`.
+ * `isFieldVisible` (since 0.1.134, see {@link TIdResolveOptions}) applies to the
+ * top-level rows only — a payload without its primary key identifies through
+ * a unique index; nested-relation writes ignore it.
+ */
+interface TWriteOptions<Row = Record<string, unknown>> extends TIdResolveOptions {
   /** Nested-relation write recursion limit (default 3). */
   maxDepth?: number;
   /**
@@ -2128,8 +2164,8 @@ interface TWriteOptions<Row = Record<string, unknown>> {
    */
   guard?: TDbWriteGuard<Row>;
 }
-/** Options of `deleteOne`. */
-interface TDeleteOptions<Row = Record<string, unknown>> {
+/** Options of `deleteOne`. `isFieldVisible` since 0.1.134 — see {@link TIdResolveOptions}. */
+interface TDeleteOptions<Row = Record<string, unknown>> extends TIdResolveOptions {
   /**
    * Validated-stage guard (since 0.1.128): invoked inside the table's
    * transaction after the id resolved to a filter and before cascade /
@@ -2137,6 +2173,17 @@ interface TDeleteOptions<Row = Record<string, unknown>> {
    */
   guard?: TDbRemoveGuard<Row>;
 }
+/** Options of `resolveIdFilter` / `identificationsVisibleTo` (since 0.1.134). */
+interface TIdResolveOptions {
+  /**
+   * Field-visibility predicate (e.g. a per-request read scope). A unique-index
+   * identification with a field that fails it is ignored — the id resolves
+   * exactly as if that index did not exist, so a hidden unique key can never
+   * answer "a row with this value exists". Primary-key, `preferredId` and
+   * `@meta.id` fields always count as visible.
+   */
+  isFieldVisible?: (path: string) => boolean;
+}
 /**
  * Adds `null` to every optional property of `O`. Optional columns store SQL
  * NULL / Mongo null, and the runtime validator accepts `null` for optional
@@ -2176,7 +2223,8 @@ interface TBucketFieldSource {
  * 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).
  *
  * Which layer validates what:
  * - **Shapes** (this normalizer) run FIRST at every entry point — the core's
@@ -2227,4 +2275,4 @@ declare function isJsonValueField(fd: TDbFieldMeta): boolean;
  */
 declare function jsonValueAncestor(path: string, jsonValueParents: ReadonlySet<string>): string | undefined;
 //#endregion
-export { TDbWriteGuardContext as $, TDbActionIntent as A, isGeoPointType as At, TDbIndexField as B, NoopLogger as Bt, PrimaryKeyOf$1 as C, TypedWithRelation as Ct, TCrudOp as D, TableMetadata as Dt, TColumnDiff as E, WithRelation$1 as Et, TDbDefaultValue as F, resolveDesignType as Ft, TDbReferentialAction as G, TDbInsertManyResult as H, UniquSelect as Ht, TDbDeleteResult as I, DbEncryption as It, TDbRemoveGuardContext as J, TDbRelation as K, TDbFieldMeta as L, TDbEncryptionOptions as Lt, TDbActionProcessor as M, BaseDbAdapter as Mt, TDbCollation as N, AtscriptDbReadable as Nt, TCrudPermissions as O, findAncestorInSet as Ot, TDbDefaultFn as P, DbResponse as Pt, TDbWriteGuard as Q, TDbForeignKey as R, DocumentFieldMapper as Rt, OwnPropsOf$1 as S, TWriteTableResolver as St, TCascadeTarget as T, UniqueryControls$1 as Tt, TDbInsertResult as U, TDbIndexType as V, TGenericLogger as Vt, TDbObjectKind as W, TDbUpdateResult as X, TDbStorageType as Y, TDbWriteAction as Z, FieldOpsFor as _, TTableOptionDiff as _t, jsonValueAncestor as a, TFieldMeta as at, NavPropsOf$1 as b, TValueFormatterPair as bt, AggregateExpr$1 as c, TIdDescriptor as ct, AggregateResult as d, TMetadataOverrides as dt, TDeleteOptions as et, AtscriptDbWritable as f, TPrimaryKeyChange as ft, DbRow as g, TSyncColumnResult as gt, DbQuery as h, TSearchIndexInfo as ht, isJsonValueField as i, TExistingTableOption as it, TDbActionLevel as j, ALL_BUCKET_UNITS as jt, TDbActionInfo as k, isGeoIndexableType as kt, AggregateFn as l, TIdentification as lt, DbPatch as m, TRelationInfo as mt, TResolvedBucket as n, TExistingColumn as nt, resolveCalendarBuckets as o, TFkLookupResolver as ot, DbControls as p, TReferencingForeignKey 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, TMetaResponse as ut, FilterExpr$1 as v, TTableResolver as vt, TCascadeResolver as w, Uniquery$1 as wt, NullableOptional as x, TWriteOptions as xt, FlatOf$1 as y, TTouchManyOptions as yt, TDbIndex as z, FieldMappingStrategy as zt };
+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$1 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 };