@atscript/db-client 0.1.163 → 0.1.165

package/dist/index.mjs

@@ -1,149 +1,7 @@
+import { a as ClientError, c as VersionMismatchError, i as ActionUnsupportedError, n as ActionNotFoundError, o as ClientValidationError, r as ActionTargetError, s as TransportError, t as ActionDisabledError } from "./client-error-Dn4WeNft.mjs";
 import { buildUrl } from "@uniqu/url/builder";
 import { deserializeAnnotatedType } from "@atscript/typescript/utils";
 import { bucketSeries, bucketStartInstant, nextBucketLabel } from "@uniqu/core";
-//#region src/client-error.ts
-/**
-* Error thrown by `Client` when the server responds with a non-2xx status code.
-* Captures the HTTP status and the structured error body from moost-db.
-*/
-var ClientError = class extends Error {
-	status;
-	body;
-	name = "ClientError";
-	constructor(status, body) {
-		super(body.message || `HTTP ${status}`);
-		this.status = status;
-		this.body = body;
-	}
-	/** Shortcut to structured validation/DB errors from the server. */
-	get errors() {
-		return this.body.errors ?? [];
-	}
-};
-/**
-* Typed marker thrown by `Client._send` when the server response body's
-* `name === 'ActionDisabledError'`. The transport / status / base body are
-* identical to a generic `ClientError`; this subclass adds typed accessors
-* so consumers can write `catch (e) { if (e instanceof ActionDisabledError) … }`
-* to access `action` / `id` / `ids` / `reason` / `reasons` without indexing
-* into `body`.
-*/
-var ActionDisabledError = class extends ClientError {
-	name = "ActionDisabledError";
-	/** The `@DbAction` name that rejected the request. */
-	get action() {
-		return this.body.action;
-	}
-	/** Present only for `'row'`-level rejections. */
-	get id() {
-		return this.body.id;
-	}
-	/** Present only for `'rows'`-level rejections (full list of failing IDs). */
-	get ids() {
-		return this.body.ids;
-	}
-	/**
-	* Human-readable reason shared by every rejected row — present only when
-	* the server's `disabled` predicate returned one. `message` already
-	* carries it.
-	*
-	* @since 0.1.141
-	*/
-	get reason() {
-		return this.body.reason;
-	}
-	/**
-	* `'rows'`-level only: per-row reasons index-aligned with {@link ids}
-	* (`null` where that row has none). Present only when at least one
-	* rejected row carries a reason.
-	*
-	* @since 0.1.141
-	*/
-	get reasons() {
-		return this.body.reasons;
-	}
-};
-/**
-* Typed marker thrown by `Client` when a query-targeted action request is
-* refused (body `name === 'ActionTargetError'`): `TARGET_INVALID` (400),
-* `TARGET_TOO_LARGE` (400, `cap`) or `TARGET_CHANGED` (409, `matched` — the
-* rows the query matches now; re-confirm and retry with that count).
-*
-* @since 0.1.147
-*/
-var ActionTargetError = class extends ClientError {
-	name = "ActionTargetError";
-	get code() {
-		return this.body.code;
-	}
-	get action() {
-		return this.body.action;
-	}
-	get matched() {
-		return this.body.matched;
-	}
-	get cap() {
-		return this.body.cap;
-	}
-};
-/**
-* Typed marker thrown by `Client._send` when the server response body's
-* `kind === 'version_mismatch'`. The transport / status / base body are
-* identical to a generic `ClientError`; this subclass adds a typed
-* `currentVersion` accessor so consumers can write
-* `catch (e) { if (e instanceof VersionMismatchError) … }` without casting.
-*/
-var VersionMismatchError = class extends ClientError {
-	name = "VersionMismatchError";
-	/** Row's current server-side version — clients refresh + retry against it. */
-	get currentVersion() {
-		return this.body.currentVersion;
-	}
-};
-/**
-* Thrown by `Client` when NO server verdict was obtained: `fetch` itself
-* rejected (network down, DNS, CORS, `AbortError`, …) or a 2xx response
-* carried a body that is not JSON. Unlike {@link ClientError} — where the
-* server answered and rejected — the request's outcome is unknown: a write
-* may have committed. Reload before retrying a non-idempotent write.
-* The underlying error is the standard `cause`.
-*/
-var TransportError = class extends Error {
-	method;
-	url;
-	name = "TransportError";
-	constructor(method, url, detail, cause) {
-		super(`${method} ${url}: ${detail}`, { cause });
-		this.method = method;
-		this.url = url;
-	}
-};
-/** Thrown by `Client.action()` when the action name is not present in `/meta`. */
-var ActionNotFoundError = class extends Error {
-	action;
-	name = "ActionNotFoundError";
-	constructor(action) {
-		super(`Action "${action}" is not declared on this controller`);
-		this.action = action;
-	}
-};
-/**
-* Thrown by `Client.action()` for actions that cannot be invoked through
-* the client — currently `processor: 'custom'` (UI-dispatched events,
-* which the application is responsible for handling) and `processor: 'navigate'`
-* when no browser environment and no `navigate` option are configured.
-*/
-var ActionUnsupportedError = class extends Error {
-	action;
-	processor;
-	name = "ActionUnsupportedError";
-	constructor(action, processor, message) {
-		super(message);
-		this.action = action;
-		this.processor = processor;
-	}
-};
-//#endregion
 //#region src/meta-store.ts
 /** ETags remembered per store key (most recent first). */
 const CANDIDATES_PER_KEY = 4;
@@ -335,17 +193,17 @@ var Client = class {
 	* The response type narrows by the literal `$with` array in `query` —
 	* relations not listed in `$with` are stripped from the row type.
 	*/
-	async query(query) {
-		return this._get("query", query);
+	async query(query, opts) {
+		return this._get("query", query, opts?.signal);
 	}
 	/**
 	* `GET /query` with `$count: true` — returns record count.
 	*/
-	async count(query) {
+	async count(query, opts) {
 		return this._get("query", {
 			...query,
 			controls: { $count: true }
-		});
+		}, opts?.signal);
 	}
 	/**
 	* `GET /query` with `$groupBy` — aggregate query with typed dimension/measure fields.
@@ -364,8 +222,8 @@ var Client = class {
 	* read a representative row ordered by `$rowOrder`. The URL forms are `expr(a/b):x`,
 	* `sum(a*b):x`, `first(f):x` and `$rowOrder=f,-id`.
 	*/
-	async aggregate(query) {
-		return this._get("query", query);
+	async aggregate(query, opts) {
+		return this._get("query", query, opts?.signal);
 	}
 	/**
 	* `GET /pages` — paginated query with typed filter and relations.
@@ -373,7 +231,7 @@ var Client = class {
 	* Response rows narrow by the literal `$with` array — same algebra as
 	* {@link query}.
 	*/
-	async pages(query, page = 1, size = 10) {
+	async pages(query, page = 1, size = 10, opts) {
 		return this._get("pages", {
 			...query,
 			controls: {
@@ -381,7 +239,7 @@ var Client = class {
 				$page: page,
 				$size: size
 			}
-		});
+		}, opts?.signal);
 	}
 	/**
 	* `GET /geo` — distance-ranked geospatial search (tables with `@db.index.geo`).
@@ -392,19 +250,19 @@ var Client = class {
 	* in `query.controls`; filter / `$select` / `$with` / `$skip` / `$limit`
 	* compose as usual.
 	*/
-	async geoSearch(point, query) {
+	async geoSearch(point, query, opts) {
 		return this._get("geo", {
 			...query,
 			controls: {
 				...query?.controls,
 				$center: point.join(",")
 			}
-		});
+		}, opts?.signal);
 	}
 	/**
 	* `GET /geo` with `$page` / `$size` — paginated distance-ranked search.
 	*/
-	async geoPages(point, query, page = 1, size = 10) {
+	async geoPages(point, query, page = 1, size = 10, opts) {
 		return this._get("geo", {
 			...query,
 			controls: {
@@ -413,7 +271,7 @@ var Client = class {
 				$page: page,
 				$size: size
 			}
-		});
+		}, opts?.signal);
 	}
 	/**
 	* `GET /one/:id` or `GET /one?k1=v1&k2=v2` — single record by primary key.
@@ -421,13 +279,13 @@ var Client = class {
 	* Returns `null` on 404. Response narrows by the literal `$with` array in
 	* `query.controls` — same algebra as {@link query}.
 	*/
-	async one(id, query) {
+	async one(id, query, opts) {
 		const controlStr = query?.controls ? buildUrl({ controls: query.controls }) : "";
-		return this._getOrNull(this._idUrl("one", id, controlStr));
+		return this._getOrNull(this._idUrl("one", id, controlStr), opts?.signal);
 	}
 	async insert(data, opts) {
 		const query = opts?.onConflict === "ignore" ? "?$onConflict=ignore" : "";
-		return this._request("POST", query, await this._prepareWrite(data, "insert"));
+		return this._request("POST", query, await this._prepareWrite(data, "insert"), opts);
 	}
 	/**
 	* `PATCH /` — partial update one or many records by primary key.
@@ -438,21 +296,21 @@ var Client = class {
 	* {@link VersionMismatchError}; a PK-only body with a version is a real
 	* write (the server bumps the version).
 	*/
-	async update(data) {
-		return this._request("PATCH", "", await this._prepareWrite(data, "patch"));
+	async update(data, opts) {
+		return this._request("PATCH", "", await this._prepareWrite(data, "patch"), opts);
 	}
 	/**
 	* `PUT /` — full replace one or many records by primary key. Same OCC
 	* shapes as {@link update}; the version column itself is optional.
 	*/
-	async replace(data) {
-		return this._request("PUT", "", await this._prepareWrite(data, "replace"));
+	async replace(data, opts) {
+		return this._request("PUT", "", await this._prepareWrite(data, "replace"), opts);
 	}
 	/**
 	* `DELETE /:id` or `DELETE /?k1=v1&k2=v2` — remove a record by primary key.
 	*/
-	async remove(id) {
-		return this._request("DELETE", this._idUrl("", id));
+	async remove(id, opts) {
+		return this._request("DELETE", this._idUrl("", id), void 0, opts);
 	}
 	/**
 	* `GET /meta` — table/view metadata (cached after first call).
@@ -626,7 +484,7 @@ var Client = class {
 	}
 	_postQueryTarget(action, body) {
 		const path = action.queryTarget?.url ?? action.value;
-		return this._requestUrl("POST", `${this._baseUrl}${path}`, body, true);
+		return this._requestUrl("POST", `${this._baseUrl}${path}`, body, { allowEmpty: true });
 	}
 	/**
 	* `GET /meta/actions/:id` or `GET /meta/actions?k1=v1&k2=v2` — the
@@ -732,7 +590,7 @@ var Client = class {
 		throw new ActionUnsupportedError(action.name, "navigate", `Action "${action.name}" is processor: 'navigate' but no browser is available and no \`navigate\` option was provided to Client.`);
 	}
 	_postAction(action, body) {
-		return this._requestUrl("POST", `${this._baseUrl}${action.value}`, body, true);
+		return this._requestUrl("POST", `${this._baseUrl}${action.value}`, body, { allowEmpty: true });
 	}
 	_idToParams(id) {
 		const params = new URLSearchParams();
@@ -754,17 +612,17 @@ var Client = class {
 		const path = `${base ? `${base}/` : ""}${encodeURIComponent(String(id))}`;
 		return query ? `${path}?${query}` : path;
 	}
-	async _getOrNull(endpoint) {
+	async _getOrNull(endpoint, signal) {
 		try {
-			return await this._request("GET", endpoint);
+			return await this._request("GET", endpoint, void 0, { signal });
 		} catch (e) {
 			if (e instanceof ClientError && e.status === 404) return null;
 			throw e;
 		}
 	}
-	async _get(endpoint, query) {
+	async _get(endpoint, query, signal) {
 		const qs = query ? buildUrl(query) : "";
-		return this._request("GET", `${endpoint}${qs ? `?${qs}` : ""}`);
+		return this._request("GET", `${endpoint}${qs ? `?${qs}` : ""}`, void 0, { signal });
 	}
 	async _resolveHeaders() {
 		if (!this._headers) return {};
@@ -848,8 +706,8 @@ var Client = class {
 			etag
 		};
 	}
-	_request(method, endpoint, body) {
-		return this._requestUrl(method, this._endpointUrl(endpoint), body);
+	_request(method, endpoint, body, opts) {
+		return this._requestUrl(method, this._endpointUrl(endpoint), body, opts);
 	}
 	/** `baseUrl + path` joined with an endpoint relative to this controller (`""`, `meta`, `?q`…). */
 	_endpointUrl(endpoint) {
@@ -857,17 +715,18 @@ var Client = class {
 		return `${this._baseUrl}${this._path}${sep}${endpoint}`;
 	}
 	/** Sends one request to an absolute URL with the client's headers and a JSON body. */
-	async _requestUrl(method, url, body, allowEmpty = false) {
+	async _requestUrl(method, url, body, opts) {
 		const headers = { ...await this._resolveHeaders() };
 		const init = {
 			method,
 			headers
 		};
+		if (opts?.signal) init.signal = opts.signal;
 		if (body !== void 0) {
 			headers["Content-Type"] = "application/json";
 			init.body = JSON.stringify(body);
 		}
-		return this._send(url, init, allowEmpty);
+		return this._send(url, init, opts?.allowEmpty === true);
 	}
 	async _send(url, init, allowEmpty) {
 		const res = await this._fetchUrl(url, init);
@@ -1013,4 +872,4 @@ function describeShape(value) {
 	return typeof value;
 }
 //#endregion
-export { ActionDisabledError, ActionNotFoundError, ActionTargetError, ActionUnsupportedError, Client, ClientError, MetaStore, TransportError, VersionMismatchError, actionIdentifier, bucketSeries, bucketStartInstant, clearMetaStore, defaultMetaStore, encodeNavigateId, formatIdentifier, formatIdentifierField, nextBucketLabel };
+export { ActionDisabledError, ActionNotFoundError, ActionTargetError, ActionUnsupportedError, Client, ClientError, ClientValidationError, MetaStore, TransportError, VersionMismatchError, actionIdentifier, bucketSeries, bucketStartInstant, clearMetaStore, defaultMetaStore, encodeNavigateId, formatIdentifier, formatIdentifierField, nextBucketLabel };

package/dist/{validator-CI8qxCps.d.cts → validator-DrJYT-pz.d.cts}

@@ -172,15 +172,38 @@ interface PageResult<T> {
   pages: number;
   count: number;
 }
-/** Server error response shape (matches moost-db error transform). */
+/**
+ * Per-call options of the `Client` read / write methods (since 0.1.165).
+ */
+interface TClientCallOptions {
+  /**
+   * Cancels the request. An aborted request rejects with a `TransportError`
+   * whose `aborted` is `true` (the `AbortError` is its `cause`).
+   */
+  signal?: AbortSignal;
+}
+/** One entry of a server error's `errors` list. */
+interface ServerErrorEntry {
+  path: string;
+  message: string;
+  /** Machine-readable reason (`UNIQUE`, `FK_MISSING`, `FK_RESTRICT`, …). @since 0.1.165 */
+  code?: string;
+  /** Values the message names, for translating it. @since 0.1.165 */
+  params?: Record<string, unknown>;
+  details?: unknown[];
+}
+/**
+ * Server error response shape (matches moost-db error transform). Open to
+ * extra fields (since 0.1.165): a handler's own error body (`quota`, `tier`,
+ * …) reads without a cast — type it with `ClientError<B>`.
+ */
 interface ServerError {
   message: string;
   statusCode: number;
-  errors?: Array<{
-    path: string;
-    message: string;
-    details?: unknown[];
-  }>;
+  /** The `DbError` code (`CONFLICT`, `FK_VIOLATION`, …) or a handler's own. @since 0.1.165 */
+  code?: string;
+  errors?: ServerErrorEntry[];
+  [key: string]: unknown;
 }
 /**
  * Minimal brand shape every `Client<T>` generic must satisfy. All fields are
@@ -203,6 +226,16 @@ type DataOf<T> = T extends {
     __dataType?: infer D;
   };
 } ? unknown extends D ? T extends (new (...a: any[]) => infer I) ? I : Record<string, unknown> : D & Record<string, unknown> : Record<string, unknown>;
+/**
+ * The row type a read answers with: {@link DataOf} without its
+ * `Record<string, unknown>` widening, which would make `DbResponse`'s
+ * `Omit` collapse every field to `unknown` (since 0.1.165).
+ */
+type ResponseDataOf<T> = T extends {
+  type: {
+    __dataType?: infer D;
+  };
+} ? unknown extends D ? T extends (new (...a: any[]) => infer I) ? I : Record<string, unknown> : D : Record<string, unknown>;
 /**
  * `$select` controls of a read over `T` whose controller declares the display-only
  * fields `D` (`@DbDecorations`): `$select` also accepts `keyof D`; filter, sort
@@ -235,7 +268,7 @@ type IdOf<T> = T extends {
  * short-circuits to the data type. `$actions` / `$disabledReasons` are always
  * optional — the server emits them only when the request set `?$actions=true`.
  */
-type ClientResponse<T, Q> = DbResponse<DataOf<T>, NavOf<T>, Q> & {
+type ClientResponse<T, Q> = DbResponse<ResponseDataOf<T>, NavOf<T>, Q> & {
   /**
    * Server-evaluated per-row availability for `'row'` and `'rows'`-level
    * actions. Each entry is the `name` of an action that is NOT disabled for
@@ -274,6 +307,200 @@ interface TDbQueryTarget<T = AtscriptClientShape> {
   maxRows?: number;
 }
 //#endregion
+//#region src/client-error.d.ts
+/**
+ * Error thrown by `Client` when the server responds with a non-2xx status code.
+ * Captures the HTTP status and the structured error body from moost-db.
+ */
+declare class ClientError<B extends ServerError = ServerError> extends Error {
+  /** HTTP status code (e.g. 400, 404, 409, 500). */
+  readonly status: number;
+  /**
+   * Structured error response from the server. `B` (since 0.1.165) types a
+   * body that carries fields of its own: `new ClientError<QuotaBody>(…)`,
+   * `(e as ClientError<QuotaBody>).body.quota`.
+   */
+  readonly body: B;
+  name: string;
+  constructor(/** HTTP status code (e.g. 400, 404, 409, 500). */
+
+  status: number,
+  /**
+   * Structured error response from the server. `B` (since 0.1.165) types a
+   * body that carries fields of its own: `new ClientError<QuotaBody>(…)`,
+   * `(e as ClientError<QuotaBody>).body.quota`.
+   */
+
+  body: B);
+  /** Shortcut to structured validation/DB errors from the server. */
+  get errors(): ServerErrorEntry[];
+}
+/**
+ * Thrown before the request is sent when the client-side preflight
+ * (`validator` option, `ClientValidator`) rejects a write. A
+ * {@link ClientError} since 0.1.165 — status `400`, `body` shaped like the
+ * server's validation envelope (`{ message, statusCode: 400, errors }`) — so
+ * one `instanceof ClientError` branch handles a preflight failure and the
+ * server's 400 alike; `preflight` (`true`) tells them apart. The same class
+ * is exported from `@atscript/db-client` and `@atscript/db-client/validator`.
+ */
+declare class ClientValidationError extends ClientError {
+  name: string;
+  /** `true`: the request never left the client. */
+  readonly preflight: true;
+  constructor(errors: Array<{
+    path: string;
+    message: string;
+  }>);
+}
+/**
+ * Wire-body shape for `ActionDisabledError` responses (HTTP 409). Extends
+ * the base `ServerError` envelope with a `name` discriminator, the action
+ * name, and the offending identifier(s). The bridge between `@atscript/moost-db`'s
+ * server-side error and this typed client-side subclass is the wire JSON
+ * body — neither package depends on the other.
+ */
+interface ActionDisabledErrorBody extends ServerError {
+  name: "ActionDisabledError";
+  action: string;
+  id?: Record<string, unknown>;
+  ids?: Record<string, unknown>[];
+  /** Reason shared by every rejected row, when the server's predicate gave one. @since 0.1.141 */
+  reason?: string;
+  /** `'rows'` level: index-aligned with `ids`, `null` = no reason for that row. @since 0.1.141 */
+  reasons?: (string | null)[];
+}
+/**
+ * Typed marker thrown by `Client._send` when the server response body's
+ * `name === 'ActionDisabledError'`. The transport / status / base body are
+ * identical to a generic `ClientError`; this subclass adds typed accessors
+ * so consumers can write `catch (e) { if (e instanceof ActionDisabledError) … }`
+ * to access `action` / `id` / `ids` / `reason` / `reasons` without indexing
+ * into `body`.
+ */
+declare class ActionDisabledError extends ClientError {
+  name: string;
+  /** The `@DbAction` name that rejected the request. */
+  get action(): string;
+  /** Present only for `'row'`-level rejections. */
+  get id(): Record<string, unknown> | undefined;
+  /** Present only for `'rows'`-level rejections (full list of failing IDs). */
+  get ids(): Record<string, unknown>[] | undefined;
+  /**
+   * Human-readable reason shared by every rejected row — present only when
+   * the server's `disabled` predicate returned one. `message` already
+   * carries it.
+   *
+   * @since 0.1.141
+   */
+  get reason(): string | undefined;
+  /**
+   * `'rows'`-level only: per-row reasons index-aligned with {@link ids}
+   * (`null` where that row has none). Present only when at least one
+   * rejected row carries a reason.
+   *
+   * @since 0.1.141
+   */
+  get reasons(): (string | null)[] | undefined;
+}
+/**
+ * Wire-body shape for `ActionTargetError` responses (since 0.1.147): a
+ * query target the server refused — `code` says why.
+ */
+interface ActionTargetErrorBody extends ServerError {
+  name: "ActionTargetError";
+  code: "TARGET_INVALID" | "TARGET_TOO_LARGE" | "TARGET_CHANGED";
+  action: string;
+  /** `TARGET_CHANGED`: the current match count. */
+  matched?: number;
+  /** `TARGET_TOO_LARGE`: the most rows one request may target. */
+  cap?: number;
+}
+/**
+ * Typed marker thrown by `Client` when a query-targeted action request is
+ * refused (body `name === 'ActionTargetError'`): `TARGET_INVALID` (400),
+ * `TARGET_TOO_LARGE` (400, `cap`) or `TARGET_CHANGED` (409, `matched` — the
+ * rows the query matches now; re-confirm and retry with that count).
+ *
+ * @since 0.1.147
+ */
+declare class ActionTargetError extends ClientError {
+  name: string;
+  get code(): ActionTargetErrorBody["code"];
+  get action(): string;
+  get matched(): number | undefined;
+  get cap(): number | undefined;
+}
+/**
+ * Wire-body shape for 409 OCC `version_mismatch` responses. Extends the base
+ * `ServerError` envelope with a `kind` discriminator and the row's current
+ * server-side version. The bridge between `@atscript/moost-db`'s server-side
+ * `_disambiguateMismatch` and this typed client-side subclass is the wire
+ * JSON body — neither package depends on the other.
+ */
+interface VersionMismatchErrorBody extends ServerError {
+  kind: "version_mismatch";
+  currentVersion: number;
+}
+/**
+ * Typed marker thrown by `Client._send` when the server response body's
+ * `kind === 'version_mismatch'`. The transport / status / base body are
+ * identical to a generic `ClientError`; this subclass adds a typed
+ * `currentVersion` accessor so consumers can write
+ * `catch (e) { if (e instanceof VersionMismatchError) … }` without casting.
+ */
+declare class VersionMismatchError extends ClientError {
+  name: string;
+  /** Row's current server-side version — clients refresh + retry against it. */
+  get currentVersion(): number;
+}
+/**
+ * Thrown by `Client` when NO server verdict was obtained: `fetch` itself
+ * rejected (network down, DNS, CORS, `AbortError`, …) or a 2xx response
+ * carried a body that is not JSON. Unlike {@link ClientError} — where the
+ * server answered and rejected — the request's outcome is unknown: a write
+ * may have committed. Reload before retrying a non-idempotent write.
+ * The underlying error is the standard `cause`.
+ */
+declare class TransportError extends Error {
+  /** HTTP method of the failed request. */
+  readonly method: string;
+  /** Full request URL. */
+  readonly url: string;
+  name: string;
+  constructor(/** HTTP method of the failed request. */
+
+  method: string, /** Full request URL. */
+
+  url: string, /** What went wrong; the message is `<method> <url>: <detail>`. */
+
+  detail: string, cause?: unknown);
+  /**
+   * `true` when the request was cancelled — its `cause` is an `AbortError`
+   * (an aborted `signal`) or a `TimeoutError` (`AbortSignal.timeout`) —
+   * rather than a network failure. @since 0.1.165
+   */
+  get aborted(): boolean;
+}
+/** Thrown by `Client.action()` when the action name is not present in `/meta`. */
+declare class ActionNotFoundError extends Error {
+  readonly action: string;
+  name: string;
+  constructor(action: string);
+}
+/**
+ * Thrown by `Client.action()` for actions that cannot be invoked through
+ * the client — currently `processor: 'custom'` (UI-dispatched events,
+ * which the application is responsible for handling) and `processor: 'navigate'`
+ * when no browser environment and no `navigate` option are configured.
+ */
+declare class ActionUnsupportedError extends Error {
+  readonly action: string;
+  readonly processor: string;
+  name: string;
+  constructor(action: string, processor: string, message: string);
+}
+//#endregion
 //#region src/validator.d.ts
 /** Options for {@link ClientValidator} / {@link createClientValidator}. */
 interface ClientValidatorOptions {
@@ -329,20 +556,6 @@ declare class ClientValidator {
   validate(data: unknown, mode: ValidatorMode): void;
   private _getValidator;
 }
-/**
- * Structured validation error thrown before HTTP requests when client-side
- * validation fails.
- */
-declare class ClientValidationError extends Error {
-  readonly errors: Array<{
-    path: string;
-    message: string;
-  }>;
-  constructor(errors: Array<{
-    path: string;
-    message: string;
-  }>);
-}
 /**
  * Create a {@link ClientValidator} from a meta response (or promise).
  *
@@ -355,4 +568,4 @@ declare class ClientValidationError extends Error {
  */
 declare function createClientValidator(meta: MetaResponse, opts?: ClientValidatorOptions): ClientValidator;
 //#endregion
-export { SearchIndexInfo as A, Uniquery$1 as B, MetaResponse as C, PatchOf as D, PageResult as E, TDbInsertManyResult$1 as F, MetaStoreOptions as G, ValidGroupBy$1 as H, TDbInsertResult$1 as I, clearMetaStore as K, TDbQueryTarget as L, TDbDeleteResult$1 as M, TDbInsertIgnoreResult$1 as N, RelationInfo as O, TDbInsertManyIgnoreResult$1 as P, TDbUpdateResult$1 as R, IdOf as S, OwnOf as T, WeekStart as U, UniqueryControls as V, MetaStore as W, DbRow as _, ValidatorMode$1 as a, FieldMeta as b, AggregateResult$1 as c, BucketUnit as d, CalendarBucketLabel as f, DbPatch as g, DataOf as h, DbValidationContext as i, ServerError as j, RowOf as k, AtscriptClientShape as l, ClientResponse as m, ClientValidator as n, createClientValidator as o, ClientOptions as p, defaultMetaStore as q, ClientValidatorOptions as r, AggregateQuery$1 as s, ClientValidationError as t, BucketExpr$1 as u, DecoratedControls as v, NavOf as w, FilterExpr as x, DecoratedQuery as y, TypedWithRelation as z };
+export { UniqueryControls as $, FieldMeta as A, RowOf as B, ClientOptions as C, DbRow as D, DbPatch as E, OwnOf as F, TDbInsertIgnoreResult$1 as G, ServerError as H, PageResult as I, TDbInsertResult$1 as J, TDbInsertManyIgnoreResult$1 as K, PatchOf as L, IdOf as M, MetaResponse as N, DecoratedControls as O, NavOf as P, Uniquery$1 as Q, RelationInfo as R, CalendarBucketLabel as S, DataOf as T, TClientCallOptions as U, SearchIndexInfo as V, TDbDeleteResult$1 as W, TDbUpdateResult$1 as X, TDbQueryTarget as Y, TypedWithRelation as Z, AggregateQuery$1 as _, createClientValidator as a, defaultMetaStore as at, BucketExpr$1 as b, ActionNotFoundError as c, ActionUnsupportedError as d, ValidGroupBy$1 as et, ClientError as f, VersionMismatchErrorBody as g, VersionMismatchError as h, ValidatorMode$1 as i, clearMetaStore as it, FilterExpr as j, DecoratedQuery as k, ActionTargetError as l, TransportError as m, ClientValidatorOptions as n, MetaStore as nt, ActionDisabledError as o, ClientValidationError as p, TDbInsertManyResult$1 as q, DbValidationContext as r, MetaStoreOptions as rt, ActionDisabledErrorBody as s, ClientValidator as t, WeekStart as tt, ActionTargetErrorBody as u, AggregateResult$1 as v, ClientResponse as w, BucketUnit as x, AtscriptClientShape as y, ResponseDataOf as z };