@atscript/db 0.1.152 → 0.1.153

package/dist/agg.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_aggregate_fns = require("./aggregate-fns-C-UJRobm.cjs");
+const require_aggregate_fns = require("./aggregate-fns-DFtKAv7Q.cjs");
 let _uniqu_core = require("@uniqu/core");
 //#region src/agg.ts
 /**

package/dist/agg.d.cts

@@ -1,3 +1,3 @@
-import { r as TResolvedBucket } from "./buckets-tzd8iIM2.cjs";
+import { r as TResolvedBucket } from "./buckets-jy8BfswO.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-42CSpGDR.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,3 +1,3 @@
-import { r as TResolvedBucket } from "./buckets-Cb0zmhDc.mjs";
+import { r as TResolvedBucket } from "./buckets-CBKL_ZWE.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-Wo-smrYV.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,4 +1,4 @@
-import { s as assertAggregateFn } from "./aggregate-fns-CyaZyb9I.mjs";
+import { s as assertAggregateFn } from "./aggregate-fns-B_sgl4mB.mjs";
 import { isAggregateExpr, isBucketExpr, resolveAlias } from "@uniqu/core";
 //#region src/agg.ts
 /**

package/dist/{aggregate-fns-CyaZyb9I.mjs → aggregate-fns-B_sgl4mB.mjs}

@@ -1,4 +1,4 @@
-import { r as DbError } from "./db-error-Az85UhTX.mjs";
+import { r as DbError } from "./db-error-eSsQX7rt.mjs";
 import { ROW_ORDER_FNS, isAggregateExpr } from "@uniqu/core";
 //#region src/query/aggregate-fns.ts
 /**

package/dist/{aggregate-fns-C-UJRobm.cjs → aggregate-fns-DFtKAv7Q.cjs}

@@ -1,4 +1,4 @@
-const require_db_error = require("./db-error-DRQH4sLY.cjs");
+const require_db_error = require("./db-error-JcfJqqpk.cjs");
 let _uniqu_core = require("@uniqu/core");
 //#region src/query/aggregate-fns.ts
 /**

package/dist/{buckets-Cb0zmhDc.d.mts → buckets-CBKL_ZWE.d.mts}

@@ -1,6 +1,6 @@
 import { f as TFieldOps } from "./ops-AqhV7s9o.mjs";
 import { AtscriptExprNode, AtscriptExprNode as AtscriptExprNode$1, AtscriptOrderItem, AtscriptQueryComparison, AtscriptQueryFieldRef, AtscriptQueryFieldRef as AtscriptQueryFieldRef$1, AtscriptQueryNode, AtscriptQueryNode as AtscriptQueryNode$1, AtscriptRef, 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";
-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, RelationOp, ResolvedBucket, ResolvedRowOrderKey, ResolvedSelectExpr, 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, NullsPlacement, NullsPlacement as NullsPlacement$1, RelationOp, ResolvedBucket, ResolvedRowOrderKey, ResolvedSelectExpr, TypedWithRelation, Uniquery, Uniquery as Uniquery$1, UniqueryControls, UniqueryControls as UniqueryControls$1, UniqueryInsights, WithRelation, WithRelation as WithRelation$1 } from "@uniqu/core";
 
 //#region src/query/uniqu-select.d.ts
 /** A row-level expression aggregate: `fn(<expr>)` over each row (physical field leaves). */
@@ -28,6 +28,13 @@ interface TFirstLast {
 interface TRowOrderKey {
   column: string;
   desc: boolean;
+  /**
+   * Requested NULL placement (`$nulls`, or the field's `@db.sort.nulls`);
+   * absent: the uniform "NULL is the smallest value" order. Only set on
+   * adapters whose `supportsNullsPlacement()` is `true`.
+   * @since 0.1.153
+   */
+  nulls?: NullsPlacement;
 }
 /** The arithmetic and representative-row parts of an aggregate `$select`, as the field mapper resolves them. */
 interface TUniquComputed {
@@ -212,8 +219,6 @@ declare abstract class FieldMappingStrategy {
    * `first(raisedAt):raisedAt`, is the alias, exactly as in `$sort`).
    */
   private translateHaving;
-  /** Output aliases of the computed `$select` entries (aggregates, expressions and calendar buckets). */
-  private computedAliasSet;
   /**
    * The arithmetic and `$rowOrder` parts of a grouped query with PHYSICAL
    * names: a row-level operand is a column; a group-level operand stays an
@@ -232,6 +237,13 @@ declare abstract class FieldMappingStrategy {
   protected physicalSelect(select: NonNullable<UniqueryControls["$select"]>, meta: TableMetadata): NonNullable<UniqueryControls["$select"]>;
   /** `$sort` with physical keys; computed `aliases` (grouped queries) pass through. */
   protected physicalSort(sort: NonNullable<DbControls["$sort"]>, meta: TableMetadata, aliases?: ReadonlySet<string>): DbControls["$sort"];
+  /**
+   * `$nulls` with physical keys, like {@link physicalSort}. The core hands
+   * over only the resolved entries (since 0.1.153).
+   */
+  protected physicalNulls(nulls: NonNullable<DbControls["$nulls"]>, meta: TableMetadata, aliases?: ReadonlySet<string>): DbControls["$nulls"];
+  /** `map` with its field-path keys made physical; computed `aliases` pass through. */
+  private physicalKeys;
   /**
    * Translates a logical filter for the adapter: relational predicates are
    * resolved first (`resolveRelationFilterTree`), then every key and value
@@ -703,7 +715,8 @@ declare class AtscriptDbReadable<T extends TAtscriptAnnotatedType = TAtscriptAnn
   get primaryKeys(): readonly string[];
   /**
    * Physical column lists that must be unique: the primary key (when declared)
-   * followed by every unique index and every adapter-contributed unique field. Used by conflict-ignoring inserts.
+   * followed by every unique index and every adapter-contributed unique field / key. Used by
+   * conflict-ignoring inserts and view read pruning.
    * @since 0.1.148
    */
   get uniqueKeySets(): string[][];
@@ -841,6 +854,41 @@ declare class AtscriptDbReadable<T extends TAtscriptAnnotatedType = TAtscriptAnn
    * by default), loads their `$with` relations and strips widened keys.
    */
   private _finishRead;
+  /**
+   * `query` with {@link _withPkTieBreak} applied and its `$nulls` resolved
+   * ({@link NullsSource.resolveSort}) — a copy when either changes.
+   */
+  private _withStableSort;
+  private _nullsCache?;
+  /** NULL-placement resolution for this table (`$nulls`, `@db.sort.nulls`; since 0.1.153). */
+  private get _nulls();
+  /**
+   * `$sort` with the primary-key tie-breaker appended (since 0.1.153), or
+   * `undefined` when the read keeps its `$sort` as written. Rows that tie on
+   * every `$sort` key otherwise come back in an engine-chosen order that can
+   * differ between two reads, so offset pages overlap or skip rows. The
+   * primary-key fields the `$sort` leaves out are appended in declaration
+   * order, in the direction of the LAST `$sort` key (a backward index scan
+   * serves `amount DESC, id DESC`).
+   *
+   * Unchanged when there is no `$sort` (no order is imposed), when the
+   * `$sort` already names every field of the primary key or of a unique key
+   * over non-nullable fields ({@link _totalOrderKeys}), when the table has no
+   * primary key (a view without `@meta.id`), and on grouped / aggregate /
+   * `$count` reads. Search, vector and geo relevance is never touched: the
+   * key is appended only to an explicit `$sort`. Every read path applies it
+   * ({@link _translateRead}, and {@link _translateForAdapter} for a native
+   * `$with` loader), so nested relation rows get it too.
+   */
+  private _withPkTieBreak;
+  private _totalOrderKeysCache?;
+  /**
+   * Physical column sets that order rows totally: the primary key, then
+   * every unique index (and adapter-contributed unique field) whose fields
+   * are all non-nullable — a unique key over a nullable column admits
+   * several NULLs, so it does not.
+   */
+  private _totalOrderKeys;
   /** `$select` plus the join keys of `withRelations` it leaves out — `undefined` when none is missing. */
   private _widenSelectForWith;
   private _joinKeysCache?;
@@ -955,6 +1003,12 @@ declare class AtscriptDbReadable<T extends TAtscriptAnnotatedType = TAtscriptAnn
    * then reverse-maps and applies fromStorage formatters on results.
    */
   aggregate(query: AggregateQuery): Promise<Array<Record<string, unknown>>>;
+  /**
+   * A grouped read's `$nulls` resolved for its `$sort` keys (computed aliases
+   * take a request entry only) and its `$rowOrder` keys — see
+   * {@link NullsSource}.
+   */
+  private _aggregateNulls;
   /**
    * The computed aliases of one source field that is a boolean or a decimal —
    * `min` / `max` / `first` / `last` — with that field's descriptor: the
@@ -971,6 +1025,12 @@ declare class AtscriptDbReadable<T extends TAtscriptAnnotatedType = TAtscriptAnn
   supportsAggregateExpressions(): boolean;
   /** Aggregate functions the adapter renders (proxies adapter capability). @since 0.1.136 */
   aggregateFns(): ReadonlySet<AggregateFn>;
+  /**
+   * Whether the adapter honours a requested NULL placement (`$nulls`,
+   * `@db.sort.nulls`) — proxies adapter capability.
+   * @since 0.1.153
+   */
+  supportsNullsPlacement(): boolean;
   /** Whether the adapter can sort by a given field (proxies adapter capability). */
   canSortField(fd: TDbFieldMeta): boolean;
   /** Returns available search indexes from the adapter. */
@@ -1661,6 +1721,25 @@ interface TViewSource {
  */
 declare function aliasTargetOf(type: TAtscriptAnnotatedType | undefined): TAtscriptAnnotatedType | undefined;
 //#endregion
+//#region src/table/view-read-plan.d.ts
+/**
+ * One read variant of a managed view with the left joins its query does not
+ * need removed — see `AtscriptDbView.readPlan`.
+ * @since 0.1.153
+ */
+interface TViewReadPlan {
+  /** The view plan without the dropped joins (entry table and view filter unchanged). */
+  readonly plan: TViewPlan;
+  /** The column mappings that remain readable — every mapping none of whose sources was dropped. */
+  readonly columns: TViewColumnMapping[];
+  /** Scopes of the dropped joins, in declaration order. */
+  readonly dropped: readonly string[];
+  /** Physical view columns the variant no longer exposes. */
+  readonly droppedColumns: readonly string[];
+  /** Identifies the variant within its view (the dropped scopes) — a cache key. */
+  readonly key: string;
+}
+//#endregion
 //#region src/table/db-view.d.ts
 interface TViewColumnMapping {
   /**
@@ -1739,6 +1818,7 @@ declare function isViewType(type: TAtscriptAnnotatedType): boolean;
 declare class AtscriptDbView<T extends TAtscriptAnnotatedType = TAtscriptAnnotatedType, DataType = TAtscriptDataType<T>, FlatType = NullableOptional<FlatOf<T>>, A extends BaseDbAdapter = BaseDbAdapter, IdType = PrimaryKeyOf<T>, OwnProps = NullableOptional<OwnPropsOf<T>>, NavType extends Record<string, unknown> = NavPropsOf<T>> extends AtscriptDbReadable<T, DataType, FlatType, A, IdType, OwnProps, NavType> {
   private _viewPlan?;
   private _columnMappings?;
+  private _readPlanner?;
   get isView(): boolean;
   /**
    * Builds the view's metadata — first stamping its fields with their
@@ -1811,6 +1891,28 @@ declare class AtscriptDbView<T extends TAtscriptAnnotatedType = TAtscriptAnnotat
    *   aggregate other than `count` over `'*'`.
    */
   getViewColumnMappings(): TViewColumnMapping[];
+  /**
+   * The read variant of this managed view for a query that reads only the
+   * `needed` PHYSICAL view columns (`undefined`: every column) — the view
+   * plan with every LEFT join removed that (a) matches at most one row per
+   * input row and (b) feeds no needed column, no other kept join's ON clause
+   * and no `@db.view.filter`. Dropping such a join leaves every row of the
+   * view in place, so a query over the variant returns exactly what it
+   * returns over the view. `undefined` when nothing can be dropped.
+   *
+   * At most one match is proven from the model: a first-row join, or an ON
+   * clause whose `=` conjuncts pin every column of one of the target's unique
+   * keys (primary key included) — see the views guide. Inner joins, joins to
+   * a view, grouped (`@db.agg.*`), materialized and external views are never
+   * pruned. A variant's {@link TViewReadPlan.columns} omit the columns of the
+   * dropped joins, so a column reference the caller failed to declare fails
+   * loudly instead of reading wrong data.
+   *
+   * Memoised per dropped-join set. Adapters use it to read through an
+   * inline, pruned definition instead of the stored view.
+   * @since 0.1.153
+   */
+  readPlan(needed: Iterable<string> | undefined): TViewReadPlan | undefined;
   /**
    * Why the bound adapter cannot render this managed view: one message per
    * computed column / first-row join whose feature its `viewCapabilities()`
@@ -2245,6 +2347,22 @@ declare abstract class BaseDbAdapter {
    * @since 0.1.148
    */
   supportsAggregateExpressions(): boolean;
+  /**
+   * Whether this adapter honours a requested NULL placement: `controls.$nulls`
+   * (PHYSICAL `$sort` keys → `'first'` / `'last'`, or computed aliases on a
+   * grouped read) and `TRowOrderKey.nulls` on the `first` / `last` row
+   * order. NULL (and, on document stores, a missing value) goes before or
+   * after every non-null value whatever the sort direction. The core only
+   * forwards entries for keys that can be NULL; a key without an entry keeps
+   * the adapter's native order (`$sort`) or "NULL is the smallest value"
+   * (grouped / row order). Default `false` (fail-closed): the core refuses a
+   * request naming a placement with `INVALID_QUERY` and drops
+   * `@db.sort.nulls` defaults. moost-db advertises it as
+   * `/meta.nullsPlacement`.
+   *
+   * @since 0.1.153
+   */
+  supportsNullsPlacement(): boolean;
   /**
    * Revision of how this adapter renders a managed view (its SQL / pipeline)
    * from an unchanged view definition. Stored in each managed view's sync
@@ -2266,6 +2384,18 @@ declare abstract class BaseDbAdapter {
    * @since 0.1.147
    */
   viewCapabilities(): ReadonlySet<TViewCapability>;
+  /**
+   * Whether reads of a managed view drop the LEFT joins the query does not
+   * need (`AtscriptDbView.readPlan`) — reading through an inline, pruned
+   * definition instead of the stored view. Only adapters that implement it
+   * honour it; each sets its own default from its constructor options (the
+   * bundled MySQL, SQLite and MongoDB adapters: on; PostgreSQL removes such
+   * joins itself). Set it to `false` on one view's adapter
+   * (`space.getAdapter(View)`) to read that view by name again.
+   *
+   * @since 0.1.153
+   */
+  viewJoinPruning: boolean;
   /**
    * Whether this adapter enforces foreign key constraints natively.
    * When `true`, the generic layer skips application-level cascade/setNull
@@ -2618,10 +2748,13 @@ declare abstract class BaseDbAdapter {
    * and every other error must throw — and a skipped row must never abort the
    * surrounding transaction. Fail-closed by default: throws
    * `DbError("ON_CONFLICT_NOT_SUPPORTED")`; also override
-   * {@link supportsInsertIgnore}.
+   * {@link supportsInsertIgnore}. `opts` (since 0.1.153) tells whether the
+   * call joins a caller's transaction and whether to lock the stored rows the
+   * batch collides with — see {@link TDbInsertIgnoreOptions}; an adapter
+   * without row locks ignores it.
    * @since 0.1.148
    */
-  insertManyIgnore(_data: Array<Record<string, unknown>>): Promise<TDbInsertIgnoreSlot[]>;
+  insertManyIgnore(_data: Array<Record<string, unknown>>, _opts?: TDbInsertIgnoreOptions): Promise<TDbInsertIgnoreSlot[]>;
   /** Whether {@link insertManyIgnore} is implemented (drives `crud.insert: ["onConflict"]` in `/meta`). @since 0.1.148 */
   supportsInsertIgnore(): boolean;
   abstract replaceOne(filter: FilterExpr, data: Record<string, unknown>, expectedVersion?: number): Promise<TDbUpdateResult>;
@@ -2922,6 +3055,8 @@ declare class TableMetadata {
   navFields: Set<string>;
   ignoredFields: Set<string>;
   uniqueProps: Set<string>;
+  /** Adapter-contributed multi-field unique keys (logical paths) — see `TMetadataOverrides.addUniqueKeys`. */
+  uniqueKeys: string[][];
   defaults: Map<string, TDbDefaultValue>;
   /** Logical path → `@db.column` override (top-level keys only on document storage). */
   columnMap: Map<string, string>;
@@ -3044,6 +3179,17 @@ declare class TableMetadata {
    * 10. Build allPhysicalFields list
    */
   build(type: TAtscriptAnnotatedType<TAtscriptTypeObject>, adapter: BaseDbAdapter, logger: TGenericLogger): void;
+  /**
+   * `flattenAnnotatedType` merges the metadata of every union / tuple member
+   * into the synthetic flat entry of the prop's path, so a member's
+   * annotations would reach the column (DDL type, size, default). Since
+   * atscript 0.1.103 a built-in primitive member carries its built-in
+   * annotations (`number.timestamp.created | null` → `@db.default.now`,
+   * `string.char` → `@expect.maxLength 1`). Rebuild such an entry from the
+   * prop's own annotations plus the non-`db.*` annotations of named members
+   * (aliases, interfaces), so the column is described as before 0.1.103.
+   */
+  private _dropMemberMetadata;
   /**
    * Applies adapter-provided metadata overrides atomically.
    * Processing order: injectFields → removePrimaryKeys → addPrimaryKeys → addUniqueFields.
@@ -3138,6 +3284,8 @@ declare class TableMetadata {
    *   overrides (`addUniqueFields`); these aren't reflected in
    *   `this.indexes` but still legitimate addressing identifications.
    *   Deduped against any single-field unique index already captured.
+   * - `this.uniqueKeys` — multi-field uniques contributed by adapter
+   *   overrides (`addUniqueKeys`).
    */
   private _buildIdentifications;
   /** Legitimate row-identifier shapes — primary key first, then each unique index. */
@@ -3329,6 +3477,15 @@ interface TMetaResponse {
    * @since 0.1.148
    */
   aggregateExpressions?: boolean;
+  /**
+   * Present (true) when the adapter honours a requested NULL placement in
+   * sorts: the `$nulls` control (URL suffix `$sort=-amount:last`) and the
+   * fields' `@db.sort.nulls` defaults (serialized in {@link type} as the
+   * `db.sort.nulls` annotation) — see `BaseDbAdapter.supportsNullsPlacement()`.
+   *
+   * @since 0.1.153
+   */
+  nullsPlacement?: true;
 }
 /** Where the action applies on the UI. */
 type TDbActionLevel = "table" | "row" | "rows";
@@ -3535,6 +3692,26 @@ interface TDbInsertManyIgnoreResult extends TDbInsertManyResult {
 type TDbInsertIgnoreSlot = {
   insertedId: unknown;
 } | null;
+/**
+ * Options the table hands to `BaseDbAdapter.insertManyIgnore`.
+ * @since 0.1.153
+ */
+interface TDbInsertIgnoreOptions {
+  /**
+   * `true` when the call joins a transaction its CALLER opened (more
+   * statements may follow in it), `false` when the transaction (if any) is the
+   * call's own. Adapters whose failed duplicate INSERT leaves a lock behind
+   * (MySQL / InnoDB: a shared lock held to commit) look up the stored keys
+   * first in that case, so no lock outlives the call. Omitted (a direct
+   * adapter call): the adapter decides from `isInTransaction()`.
+   */
+  inCallerTransaction?: boolean;
+  /**
+   * Lock the stored rows the batch collides with until the transaction ends
+   * (`TInsertOptions.lockConflicts`). Only sent inside a caller transaction.
+   */
+  lockConflicts?: boolean;
+}
 interface TDbUpdateResult {
   matchedCount: number;
   modifiedCount: number;
@@ -3929,6 +4106,13 @@ interface TMetadataOverrides {
   removePrimaryKeys?: string[];
   /** Fields to register as having a unique constraint. */
   addUniqueFields?: string[];
+  /**
+   * Multi-field unique keys (logical paths) the adapter enforces with an index
+   * of its own — no field of one is unique alone (MongoDB: a composite
+   * `@meta.id` beside an explicit `_id`, indexed as one `__pk` key).
+   * @since 0.1.153
+   */
+  addUniqueKeys?: string[][];
   /** Synthetic fields to inject into flatMap (e.g. MongoDB's `_id`). */
   injectFields?: Array<{
     path: string;
@@ -4198,6 +4382,20 @@ interface TInsertOptions<Row = Record<string, unknown>> extends TWriteOptions<Ro
    * parent (`@db.rel.to` nested object) is rejected in this mode.
    */
   onConflict?: "error" | "ignore";
+  /**
+   * With `onConflict: 'ignore'` inside a caller's transaction: lock the STORED
+   * rows the batch collides with until that transaction ends, so the caller
+   * can update them next without racing — or deadlocking — a concurrent
+   * transaction doing the same. MySQL and PostgreSQL take exclusive row locks
+   * (`SELECT … FOR UPDATE`) on those rows only, in key order, before
+   * inserting the rest (on MySQL a row that a concurrent writer commits while
+   * the call runs keeps the shared lock of its failed INSERT instead); SQLite (database-level write lock), MongoDB and the
+   * in-memory adapter need no row locks and ignore it. Outside a caller
+   * transaction it is a no-op (the call's own transaction ends on return).
+   * Throws `INVALID_QUERY` without `onConflict: 'ignore'`.
+   * @since 0.1.153
+   */
+  lockConflicts?: boolean;
 }
 /**
  * Context handed to a write {@link TWriteOptions.check} (since 0.1.143) — and
@@ -4375,4 +4573,4 @@ declare function isJsonValueField(fd: TDbFieldMeta): boolean;
  */
 declare function jsonValueAncestor(path: string, jsonValueParents: ReadonlySet<string>): string | undefined;
 //#endregion
-export { TDbReferentialAction as $, TDbSpaceOptions as $t, TCrudOp as A, andFilters as An, TRowResolveOptions as At, TDbDefaultValue as B, TReadControls as Bn, TypedWithRelation as Bt, NavPropsOf$1 as C, REL_FILTER_MAX_DEPTH as Cn, TIdentification as Ct, TCascadeResolver as D, TRelationFilterJunction as Dn, TPrimaryKeyChange as Dt, PrimaryKeyOf$1 as E, TRelGuardState as En, TMetadataOverrides as Et, TDbActionProcessor as F, relationStaticFilter as Fn, TTouchManyOptions as Ft, TDbIndexField as G, TRowOrderKey as Gn, isGeoIndexableType as Gt, TDbFieldMeta as H, TGenericLogger as Hn, UniqueryControls$1 as Ht, TDbActionTargetSummary as I, DbEncryption as In, TValueFormatterPair as It, TDbInsertIgnoreSlot as J, ALL_VIEW_CAPABILITIES as Jt, TDbIndexType as K, UniquSelect as Kn, isGeoPointType as Kt, TDbAvailableActions as L, TDbEncryptionOptions as Ln, TViewJsonType as Lt, TDbActionInfo as M, forEachResolvedRelation as Mn, TSyncColumnResult as Mt, TDbActionIntent as N, hasRelationOp as Nn, TTableOptionDiff as Nt, TCascadeTarget as O, TRelationFilterTable as On, TReferencingForeignKey as Ot, TDbActionLevel as P, isResolvedRelationFilter as Pn, TTableResolver as Pt, TDbObjectKind as Q, TAdapterFactory as Qt, TDbCollation as R, DocumentFieldMapper as Rn, TWriteOptions as Rt, FlatOf$1 as S, resolveDesignType as Sn, TIdResolveOptions as St, OwnPropsOf$1 as T, ResolvedRelationFilter as Tn, TMetaResponse as Tt, TDbForeignKey as U, TExprAggregate as Un, WithRelation$1 as Ut, TDbDeleteResult as V, NoopLogger as Vn, Uniquery$1 as Vt, TDbIndex as W, TFirstLast as Wn, TableMetadata as Wt, TDbInsertManyResult as X, TViewCapability as Xt, TDbInsertManyIgnoreResult as Y, BaseDbAdapter as Yt, TDbInsertResult as Z, DbSpace as Zt, DbPatch as _, IntegrityStrategy as _n, TExistingTableOption as _t, isJsonValueField as a, AtscriptExprNode$1 as an, TDbUpdateResult as at, FieldOpsFor as b, AtscriptDbReadable as bn, TFkLookupTarget as bt, resolveCalendarBuckets as c, AtscriptQueryFieldRef$1 as cn, TDbWriteCheckContext as ct, AggregateFn$1 as d, TViewJoin as dn, TDeleteOptions as dt, AtscriptDbView as en, TDbRelation as et, AggregateQuery$1 as f, TViewPlan as fn, TDerivedChangeReason as ft, DbControls as g, AtscriptDbTable as gn, TExistingForeignKey as gt, AtscriptDbWritable as h, translateQueryTree as hn, TExistingColumn as ht, isBucketableField as i, aliasTargetOf as in, TDbUpdateOptions as it, TCrudPermissions as j, containsRelationFilter as jn, TSearchIndexInfo as jt, TColumnDiff as k, TRelationStaticFilter as kn, TRelationInfo as kt, AggregateControls as l, AtscriptQueryNode$1 as ln, TDbWriteGuard as lt, AtscriptDbTableLike as m, isFieldRef as mn, TEnsureTableOptions as mt, TComputedSelect as n, isAtscriptDbView as nn, TDbRemoveGuardContext as nt, jsonValueAncestor as o, AtscriptOrderItem as on, TDbWriteAction as ot, AggregateResult as p, evaluateExpr as pn, TDerivedColumn as pt, TDbInsertIgnoreResult as q, ALL_BUCKET_UNITS as qt, TResolvedBucket as r, isViewType as rn, TDbStorageType as rt, normalizeComputedSelect as s, AtscriptQueryComparison as sn, TDbWriteCheck as st, TBucketFieldSource as t, TViewColumnMapping as tn, TDbRemoveGuard as tt, AggregateExpr$1 as u, AtscriptRef as un, TDbWriteGuardContext as ut, DbQuery as v, NativeIntegrity as vn, TFieldMeta as vt, NullableOptional as w, REL_FILTER_MAX_NODES as wn, TInsertOptions as wt, FilterExpr$1 as x, DbResponse as xn, TIdDescriptor as xt, DbRow as y, TCascadePin as yn, TFkLookupResolver as yt, TDbDefaultFn as z, FieldMappingStrategy as zn, TWriteTableResolver as zt };
+export { TDbInsertResult as $, DbSpace as $t, TColumnDiff as A, TRelationFilterJunction as An, TReferencingForeignKey as At, TDbDefaultFn as B, TDbEncryptionOptions as Bn, TWriteOptions as Bt, NavPropsOf$1 as C, AtscriptDbReadable as Cn, TIdDescriptor as Ct, PrimaryKeyOf$1 as D, REL_FILTER_MAX_NODES as Dn, TMetaResponse as Dt, OwnPropsOf$1 as E, REL_FILTER_MAX_DEPTH as En, TInsertOptions as Et, TDbActionLevel as F, forEachResolvedRelation as Fn, TTableOptionDiff as Ft, TDbIndex as G, TGenericLogger as Gn, WithRelation$1 as Gt, TDbDeleteResult as H, FieldMappingStrategy as Hn, TypedWithRelation as Ht, TDbActionProcessor as I, hasRelationOp as In, TTableResolver as It, TDbInsertIgnoreOptions as J, TRowOrderKey as Jn, isGeoPointType as Jt, TDbIndexField as K, TExprAggregate as Kn, TableMetadata as Kt, TDbActionTargetSummary as L, isResolvedRelationFilter as Ln, TTouchManyOptions as Lt, TCrudPermissions as M, TRelationStaticFilter as Mn, TRowResolveOptions as Mt, TDbActionInfo as N, andFilters as Nn, TSearchIndexInfo as Nt, TCascadeResolver as O, ResolvedRelationFilter as On, TMetadataOverrides as Ot, TDbActionIntent as P, containsRelationFilter as Pn, TSyncColumnResult as Pt, TDbInsertManyResult as Q, TViewCapability as Qt, TDbAvailableActions as R, relationStaticFilter as Rn, TValueFormatterPair as Rt, FlatOf$1 as S, TCascadePin as Sn, TFkLookupTarget as St, NullsPlacement$1 as T, resolveDesignType as Tn, TIdentification as Tt, TDbFieldMeta as U, TReadControls as Un, Uniquery$1 as Ut, TDbDefaultValue as V, DocumentFieldMapper as Vn, TWriteTableResolver as Vt, TDbForeignKey as W, NoopLogger as Wn, UniqueryControls$1 as Wt, TDbInsertIgnoreSlot as X, ALL_VIEW_CAPABILITIES as Xt, TDbInsertIgnoreResult as Y, UniquSelect as Yn, ALL_BUCKET_UNITS as Yt, TDbInsertManyIgnoreResult as Z, BaseDbAdapter as Zt, DbPatch as _, isFieldRef as _n, TExistingColumn as _t, isJsonValueField as a, isViewType as an, TDbStorageType as at, FieldOpsFor as b, IntegrityStrategy as bn, TFieldMeta as bt, resolveCalendarBuckets as c, AtscriptExprNode$1 as cn, TDbWriteAction as ct, AggregateFn$1 as d, AtscriptQueryFieldRef$1 as dn, TDbWriteGuard as dt, TAdapterFactory as en, TDbObjectKind as et, AggregateQuery$1 as f, AtscriptQueryNode$1 as fn, TDbWriteGuardContext as ft, DbControls as g, evaluateExpr as gn, TEnsureTableOptions as gt, AtscriptDbWritable as h, TViewPlan as hn, TDerivedColumn as ht, isBucketableField as i, isAtscriptDbView as in, TDbRemoveGuardContext as it, TCrudOp as j, TRelationFilterTable as jn, TRelationInfo as jt, TCascadeTarget as k, TRelGuardState as kn, TPrimaryKeyChange as kt, AggregateControls as l, AtscriptOrderItem as ln, TDbWriteCheck as lt, AtscriptDbTableLike as m, TViewJoin as mn, TDerivedChangeReason as mt, TComputedSelect as n, AtscriptDbView as nn, TDbRelation as nt, jsonValueAncestor as o, TViewReadPlan as on, TDbUpdateOptions as ot, AggregateResult as p, AtscriptRef as pn, TDeleteOptions as pt, TDbIndexType as q, TFirstLast as qn, isGeoIndexableType as qt, TResolvedBucket as r, TViewColumnMapping as rn, TDbRemoveGuard as rt, normalizeComputedSelect as s, aliasTargetOf as sn, TDbUpdateResult as st, TBucketFieldSource as t, TDbSpaceOptions as tn, TDbReferentialAction as tt, AggregateExpr$1 as u, AtscriptQueryComparison as un, TDbWriteCheckContext as ut, DbQuery as v, translateQueryTree as vn, TExistingForeignKey as vt, NullableOptional as w, DbResponse as wn, TIdResolveOptions as wt, FilterExpr$1 as x, NativeIntegrity as xn, TFkLookupResolver as xt, DbRow as y, AtscriptDbTable as yn, TExistingTableOption as yt, TDbCollation as z, DbEncryption as zn, TViewJsonType as zt };