@atscript/db 0.1.148 → 0.1.150

package/dist/{column-diff-Cp6ZoyRE.mjs → column-diff-CKLDWBbo.mjs}

@@ -1,12 +1,11 @@
 import { a as aggregateExpressionsNotSupported, l as spaceClosedError, n as CasMismatchError, r as DbError } from "./db-error-Az85UhTX.mjs";
 import { a as SOURCE_VALUE_FNS, c as isFirstLast, o as SUPPORTED_AGGREGATE_FNS, r as BASE_AGGREGATE_FNS, t as AGG_ANNOTATIONS } from "./aggregate-fns-CyaZyb9I.mjs";
 import { B as slicePerGroup, D as createRelationFilterHost, E as containsRelationFilter, F as compositeKey, H as computeOf, I as findFKEntryForRelation, J as walkViewExpr, L as findFKForRelation, M as relGuardState, P as resolveRelationFilterTree, R as findRemoteFK, U as computedOperands, V as tableNameOf, _ as remapDeleteFkViolation, a as batchPatchNestedFrom, b as sameKey, c as batchReplaceNestedFrom, d as checkDepthOverflow, f as planNestedFromVia, g as enrichFkViolation, h as validateBatch, i as batchInsertNestedVia, j as noteRelationFilter, k as hasRelationOp, l as batchReplaceNestedTo, m as preValidateNestedFrom, n as batchInsertNestedFrom, p as planPatchNestedTo, q as viewExprNullable, r as batchInsertNestedTo, s as batchPatchNestedVia, t as applyPatchNestedTo, u as batchReplaceNestedVia, v as pkTupleKey, x as uniqueKeyTuple, y as rowMatchesKey } from "./nested-writer-CUBoq1ZO.mjs";
-import { i as isJsonLeafType, n as DERIVED_INCOMPATIBLE } from "./derived-rules-0sKn4f5C.mjs";
+import { a as DERIVED_INCOMPATIBLE, n as searchMemberKind, r as numericTypeProblem, s as isJsonLeafType } from "./search-fields-DBIZKwyb.mjs";
 import { a as isPlainObject, i as isEmptyObject, n as findAncestorInSet, o as selfOrAncestor, r as getPath, t as deletePath } from "./object-TkiJQ-Dp.mjs";
 import { resolveAlias as resolveAlias$1 } from "./agg.mjs";
-import { t as numericTypeProblem } from "./numeric-operand-B1jKH7x5.mjs";
 import { t as NOT_DIMENSION_REASON } from "./aggregate-rules-jdPrxqWa.mjs";
-import { separateCas, separateFieldOps } from "./ops.mjs";
+import { isDbFieldOp, separateCas, separateFieldOps } from "./ops.mjs";
 import { a as forceNavNonOptional, c as getKeyProps, i as dbPlugin, n as buildPatchPartial, t as buildDbValidator } from "./validator-BTiIOTKP.mjs";
 import { flattenAnnotatedType, isAnnotatedType } from "@atscript/typescript/utils";
 import { ARITH_MAX_NODES, BUCKET_UNITS, isAggregateExpr, isAggregateOfExpr, isBucketExpr, isPrimitive, isRelationOp, isSelectArithExpr, resolveAlias, resolveBuckets } from "@uniqu/core";
@@ -396,6 +395,10 @@ function isGeoIndexableType(fieldType) {
 	}
 	return false;
 }
+/** Runtime mirror of the `@db.column.version.exempt` placement errors. */
+function rejectVersionExempt(path, why) {
+	throw new Error(`@db.column.version.exempt on "${path}": ${why}`);
+}
 /**
 * Computed metadata for a database table or view.
 *
@@ -443,6 +446,15 @@ var TableMetadata = class {
 	measures = [];
 	/** Logical field name annotated with `@db.column.version`, if any. */
 	versionField;
+	/** Paths annotated with `@db.column.version.exempt`, as declared (since 0.1.150). */
+	_versionExemptDeclared = /* @__PURE__ */ new Set();
+	/**
+	* Version-exempt paths (since 0.1.150): the declared ones plus every object
+	* whose direct children are all exempt (upward closure). A path is exempt
+	* when it, or an ancestor, is in this set — see {@link isVersionExemptPath}.
+	* Empty when the table declares no `@db.column.version`.
+	*/
+	versionExemptPaths = /* @__PURE__ */ new Set();
 	/** path → sibling-ref path for `@db.amount.currency.ref` / `@db.unit.ref`. */
 	quantityRefByField = /* @__PURE__ */ new Map();
 	/** Logical paths annotated with `@db.encrypted` — stored as one opaque ciphertext column. */
@@ -599,6 +611,7 @@ var TableMetadata = class {
 			...this.originalMetaIdFields
 		]);
 		this._finalizeIndexes();
+		this._finalizeVersionExempt();
 		this._collateMap.clear();
 		this._columnFromMap.clear();
 		this.jsonFields.clear();
@@ -700,6 +713,15 @@ var TableMetadata = class {
 			const name = index === true ? fieldName : typeof index === "string" ? index : index?.name || fieldName;
 			this._addIndexField("unique", name, fieldName);
 		}
+		if (metadata.has("db.writeOnly") && (metadata.has("db.index.fulltext") || metadata.has("db.column.searchable"))) {
+			const which = metadata.has("db.index.fulltext") ? "@db.index.fulltext" : "@db.column.searchable";
+			throw new Error(`@db.writeOnly cannot coexist with ${which} on "${fieldName}" — search results would reveal the sealed value`);
+		}
+		const searchKind = searchMemberKind(fieldType);
+		if (typeof searchKind === "object") {
+			if (metadata.has("db.index.fulltext")) throw new Error(`@db.index.fulltext on "${fieldName}" ${searchKind.problem} — a fulltext member must be a string or an integer`);
+			if (metadata.has("db.column.searchable")) throw new Error(`@db.column.searchable on "${fieldName}" ${searchKind.problem} — a searchable column must be a string or an integer`);
+		}
 		for (const index of metadata.get("db.index.fulltext") || []) {
 			const name = index === true ? fieldName : typeof index === "string" ? index : index?.name || fieldName;
 			const weight = index !== true && typeof index === "object" ? index?.weight : void 0;
@@ -727,6 +749,7 @@ var TableMetadata = class {
 			if (!hasExplicitIndex) this._addIndexField("plain", fieldName, fieldName);
 		}
 		if (metadata.has("db.column.measure")) this.measures.push(fieldName);
+		if (metadata.has("db.column.version.exempt")) this._versionExemptDeclared.add(fieldName);
 		if (metadata.has("db.column.version")) if (this.versionField !== void 0) logger.warn(`@db.column.version declared on multiple fields ("${this.versionField}" and "${fieldName}") — only one is allowed; using "${this.versionField}"`);
 		else {
 			this.versionField = fieldName;
@@ -737,6 +760,55 @@ var TableMetadata = class {
 		}
 	}
 	/**
+	* Validates the `@db.column.version.exempt` placements (E1–E5, the runtime
+	* mirror of the compile-time check, so pre-compiled models fail fast) and
+	* computes {@link versionExemptPaths} with its upward closure. Runs after
+	* `_applyOverrides` (the primary keys are final) and before `jsonFields` is
+	* released. A table without a version column ignores the annotation.
+	*/
+	_finalizeVersionExempt() {
+		if (this._versionExemptDeclared.size === 0) return;
+		for (const path of this._versionExemptDeclared) {
+			if (path === this.versionField) rejectVersionExempt(path, "cannot mark the version column itself");
+			if (this.primaryKeys.includes(path)) rejectVersionExempt(path, "a primary key identifies the row and is never patched");
+			if (this.navFields.has(path)) rejectVersionExempt(path, "a navigation field has no column here");
+			let pos = path.length;
+			while ((pos = path.lastIndexOf(".", pos - 1)) !== -1) {
+				const ancestor = path.slice(0, pos);
+				const node = this.flatMap.get(ancestor);
+				if (node?.metadata.has("db.json")) rejectVersionExempt(path, `mark the @db.json field "${ancestor}" itself — a JSON column is written as one value`);
+				if (node?.type.kind === "array") rejectVersionExempt(path, `mark the array field "${ancestor}" itself — array elements are not separate columns`);
+			}
+		}
+		if (this.versionField === void 0) return;
+		const exempt = new Set(this._versionExemptDeclared);
+		const objects = [...this.flatMap.keys()].filter((p) => {
+			const node = this.flatMap.get(p);
+			return node.type.kind === "object" && !node.metadata.has("db.json");
+		}).toSorted((a, b) => b.split(".").length - a.split(".").length);
+		for (const obj of objects) {
+			if (exempt.has(obj)) continue;
+			const prefix = `${obj}.`;
+			let children = 0;
+			let all = true;
+			for (const key of this.flatMap.keys()) {
+				if (!key.startsWith(prefix) || key.indexOf(".", prefix.length) !== -1) continue;
+				if (this.navFields.has(key) || this.ignoredFields.has(key)) continue;
+				children++;
+				if (!exempt.has(key)) {
+					all = false;
+					break;
+				}
+			}
+			if (children > 0 && all) exempt.add(obj);
+		}
+		this.versionExemptPaths = exempt;
+	}
+	/** Whether `path` — or an ancestor of it — is version-exempt (since 0.1.150). */
+	isVersionExemptPath(path) {
+		return selfOrAncestor(path, this.versionExemptPaths) !== void 0;
+	}
+	/**
 	* Build-time diagnostics for `@db.encrypted` (§6 of the field-encryption
 	* spec). Mirrors the compile-time AnnotationSpec validation so models built
 	* from pre-compiled types still fail fast.
@@ -1070,8 +1142,28 @@ var TableMetadata = class {
 			};
 		}
 	}
+	/**
+	* Flags the integer members of fulltext indexes (matched by exact number,
+	* never part of the physical text index) and enforces that each is
+	* index-backed — the equality branch must not scan. Runs while index field
+	* names are still logical.
+	*/
+	_resolveIntegerFulltextMembers() {
+		for (const index of this.indexes.values()) {
+			if (index.type !== "fulltext") continue;
+			for (const field of index.fields) {
+				const ftype = this.flatMap.get(field.name);
+				if (!ftype || searchMemberKind(ftype) !== "integer") continue;
+				const where = `@db.index.fulltext on the integer field "${field.name}"`;
+				if (findAncestorInSet(field.name, this.jsonFields) !== void 0) throw new Error(`${where} inside a JSON value is not supported`);
+				if (!(field.name === "_id" || this.originalMetaIdFields[0] === field.name || this.uniqueProps.has(field.name) || [...this.indexes.values()].some((other) => (other.type === "plain" || other.type === "unique") && other.fields[0]?.name === field.name))) throw new Error(`${where} needs an index for its exact-number match — make it the primary key (first @meta.id) or the first field of a @db.index.plain / @db.index.unique`);
+				field.integer = true;
+			}
+		}
+	}
 	_finalizeIndexes() {
 		for (const index of this.indexes.values()) if (index.type === "unique" && index.fields.length === 1) this.uniqueProps.add(index.fields[0].name);
+		this._resolveIntegerFulltextMembers();
 		for (const index of this.indexes.values()) for (const field of index.fields) {
 			const ftype = this.flatMap.get(field.name);
 			if (ftype) {
@@ -1143,15 +1235,343 @@ var TableMetadata = class {
 		const selected = this.getIdentifications().find((id) => id.source !== "primaryKey" && (requestedName === void 0 || id.source === requestedName));
 		this.preferredId = selected ? [...selected.fields] : [...this.primaryKeys];
 	}
-};
-/** `TDbFieldMeta.computed` of a top-level `@db.compute` view field (since 0.1.147). */
-function computedMeta(rootType, path) {
-	if (path.includes(".")) return void 0;
-	const computed = computedOperands(rootType, path);
-	return computed ? {
-		operands: Object.freeze(computed.operands),
-		via: Object.freeze(computed.via)
-	} : void 0;
+};
+/** `TDbFieldMeta.computed` of a top-level `@db.compute` view field (since 0.1.147). */
+function computedMeta(rootType, path) {
+	if (path.includes(".")) return void 0;
+	const computed = computedOperands(rootType, path);
+	return computed ? {
+		operands: Object.freeze(computed.operands),
+		via: Object.freeze(computed.via)
+	} : void 0;
+}
+//#endregion
+//#region src/shared/search-term.ts
+/**
+* Internal filter operator (since 0.1.150): a regular expression over the
+* DECIMAL TEXT of an integer column. The core rewrites a caller's `$regex`
+* (or bare `RegExp`) on an integer field into it at translation time;
+* callers can never send it (the filter value guard refuses it).
+*/
+const INTEGER_REGEX_OP = "$integerRegex";
+const INTEGER_TERM_RE = /^-?(?:0|[1-9][0-9]*)$/;
+/**
+* The whole number a `$search` term denotes, or `undefined` (since 0.1.150).
+* The trimmed term must be a plain integer literal — ASCII digits with an
+* optional leading `-`, no `+`, no leading zeros (except `0` itself), no
+* `-0`, no separators / decimals / exponent — within the safe-integer range.
+* Only the whole term counts (`"invoice 2946"` has no number).
+*/
+function searchTermInteger(term) {
+	const t = term.trim();
+	if (!INTEGER_TERM_RE.test(t) || t === "-0") return void 0;
+	const n = Number(t);
+	return Number.isSafeInteger(n) ? n : void 0;
+}
+/**
+* Splits a fulltext index into the members that belong to the physical text
+* index and the integer members matched by exact number (since 0.1.150).
+*/
+function splitFulltextFields(index) {
+	const text = [];
+	const integer = [];
+	for (const f of index.fields) (f.integer ? integer : text).push(f);
+	return {
+		text,
+		integer
+	};
+}
+/**
+* `/meta` description of a fulltext index: the adapter's text-index label over
+* the text members, then the exact-number members (since 0.1.150).
+*/
+function describeFulltext(index, textLabel) {
+	const { text, integer } = splitFulltextFields(index);
+	return [text.length > 0 ? textLabel(text.map((f) => f.name).join(", ")) : "", integer.map((f) => `exact number on ${f.name}`).join(" + ")].filter(Boolean).join(" + ");
+}
+/**
+* The fulltext index that answers a search naming none (since 0.1.150): the
+* first one with at least one TEXT member, else the first one (an index of
+* integer members only answers exact-number terms).
+*/
+function defaultFulltextIndex(indexes) {
+	return indexes.find((i) => splitFulltextFields(i).text.length > 0) ?? indexes[0];
+}
+//#endregion
+//#region src/query/filter-values.ts
+const OPAQUE = {
+	kinds: new Set(["any"]),
+	timestamp: false
+};
+const NUMBER = {
+	kinds: new Set(["number"]),
+	timestamp: false
+};
+const INTEGER = {
+	kinds: new Set(["integer"]),
+	timestamp: false
+};
+const STRING = {
+	kinds: new Set(["string"]),
+	timestamp: false
+};
+function collectKinds(type, kinds, out, depth = 0) {
+	const def = type?.type;
+	const metadata = type?.metadata;
+	if (!def || depth > 8) {
+		kinds.add("any");
+		return;
+	}
+	switch (def.kind) {
+		case "": switch (def.designType) {
+			case "string":
+				kinds.add("string");
+				return;
+			case "number": {
+				const timestamp = def.tags?.has("timestamp") === true;
+				if (timestamp) out.timestamp = true;
+				const integer = timestamp || def.tags?.has("int") === true || metadata?.has?.("expect.int") === true;
+				kinds.add(integer ? "integer" : "number");
+				return;
+			}
+			case "decimal":
+				kinds.add("decimal");
+				return;
+			case "boolean":
+				kinds.add("boolean");
+				return;
+			case "null":
+			case "undefined":
+			case "never": return;
+			default:
+				kinds.add("any");
+				return;
+		}
+		case "union":
+			for (const item of def.items ?? []) collectKinds(item, kinds, out, depth + 1);
+			return;
+		case "array":
+			collectKinds(def.of, kinds, out, depth + 1);
+			return;
+		default: kinds.add("any");
+	}
+}
+const typeCache = /* @__PURE__ */ new WeakMap();
+/**
+* The value kinds a filter on `fd` accepts (cached per descriptor). A leaf
+* inside a JSON value (a `@db.json` object or an array, addressable on
+* nested-object adapters) is opaque: its contents are not schema-enforced.
+*/
+function valueTypeOf(meta, fd) {
+	let vt = typeCache.get(fd);
+	if (vt) return vt;
+	if (jsonValueAncestor(fd.path, meta.jsonValueParents) !== void 0 || fd.encrypted || fd.isGeoPoint || fd.designType === "json" || fd.designType === "object" || !fd.type) vt = OPAQUE;
+	else {
+		const kinds = /* @__PURE__ */ new Set();
+		const out = { timestamp: false };
+		collectKinds(fd.type, kinds, out);
+		const metadata = fd.type.metadata;
+		if ((fd.defaultValue?.kind === "fn" && fd.defaultValue.fn !== "uuid" || metadata?.has?.("db.agg.count") === true || metadata?.has?.("db.agg.countDistinct") === true) && kinds.delete("number")) kinds.add("integer");
+		vt = kinds.size === 0 ? OPAQUE : {
+			kinds,
+			timestamp: out.timestamp,
+			integerText: searchMemberKind(fd.type) === "integer"
+		};
+	}
+	typeCache.set(fd, vt);
+	return vt;
+}
+/** Whether `$regex` on `fd` matches the decimal text of an integer (since 0.1.150). */
+function isIntegerTextField(meta, fd) {
+	return valueTypeOf(meta, fd).integerText === true;
+}
+/** A decimal literal (`5`, `-1.5`, `.5`, `1e3`), surrounding blanks allowed — no hex, no `Infinity`. */
+const NUMERIC_RE = /^\s*[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?\s*$/i;
+/** An integer literal (`5`, `-12`), surrounding blanks allowed. */
+const INTEGER_RE = /^\s*[+-]?\d+\s*$/;
+function acceptsScalar(kind, value) {
+	switch (kind) {
+		case "any": return true;
+		case "string": return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint";
+		case "number":
+		case "decimal": return typeof value === "number" && Number.isFinite(value) || typeof value === "bigint" || typeof value === "string" && NUMERIC_RE.test(value);
+		case "integer": return typeof value === "number" && Number.isInteger(value) || typeof value === "bigint" || typeof value === "string" && INTEGER_RE.test(value);
+		default: return typeof value === "boolean" || value === 0 || value === 1;
+	}
+}
+/** The first element of `value` (itself when not an array) `vt` rejects, or `undefined`. */
+function rejectedValue(vt, value) {
+	if (vt.kinds.has("any") || value === null || value === void 0) return void 0;
+	if (Array.isArray(value)) {
+		for (const item of value) {
+			const bad = rejectedValue(vt, item);
+			if (bad) return bad;
+		}
+		return;
+	}
+	if (typeof value === "object" && !isPlainObject(value)) return void 0;
+	for (const kind of vt.kinds) if (acceptsScalar(kind, value)) return void 0;
+	return { value };
+}
+const KIND_LABEL = {
+	string: "a string",
+	number: "a number",
+	integer: "an integer",
+	decimal: "a decimal (number or numeric string)",
+	boolean: "a boolean"
+};
+function expectedOf(vt) {
+	const labels = [];
+	for (const kind of vt.kinds) {
+		if (kind === "any") continue;
+		labels.push(kind === "integer" && vt.timestamp ? "an integer (epoch milliseconds)" : KIND_LABEL[kind]);
+	}
+	return labels.join(" or ");
+}
+function describeValue(value) {
+	if (typeof value === "string") return JSON.stringify(value.length > 40 ? `${value.slice(0, 40)}…` : value);
+	if (isPlainObject(value)) return "an object";
+	return String(value);
+}
+function valueError(path, op, message) {
+	return new DbError("INVALID_QUERY", [{
+		path,
+		message: `Invalid filter value for "${path}"${op ? ` (${op})` : ""}: ${message}`
+	}]);
+}
+function holdsStrings(vt) {
+	return vt.kinds.has("string") || vt.kinds.has("any") || vt.integerText === true;
+}
+function checkRegex(path, vt, op, pattern) {
+	if (!holdsStrings(vt)) throw valueError(path, op, `a pattern match needs a string or integer field, "${path}" holds ${expectedOf(vt)}`);
+	if (typeof pattern !== "string" && !(pattern instanceof RegExp)) throw valueError(path, op, `expected a regular expression, got ${describeValue(pattern)}`);
+}
+function checkValue(path, vt, op, value) {
+	if (value instanceof RegExp) {
+		checkRegex(path, vt, op ?? "RegExp", value);
+		return;
+	}
+	const bad = rejectedValue(vt, value);
+	if (bad) throw valueError(path, op, `expected ${expectedOf(vt)}, got ${describeValue(bad.value)}`);
+}
+/** Operators whose operand is compared with the field's values. */
+const COMPARE_OPS = new Set([
+	"$eq",
+	"$ne",
+	"$gt",
+	"$gte",
+	"$lt",
+	"$lte",
+	"$in",
+	"$nin"
+]);
+/** Checks one filter entry's value (a bare value or an operator map) against `vt`. */
+function checkEntry(path, vt, value) {
+	if (vt.kinds.has("any")) return;
+	if (!isPlainObject(value)) {
+		checkValue(path, vt, void 0, value);
+		return;
+	}
+	for (const [op, operand] of Object.entries(value)) if (op === "$regex") checkRegex(path, vt, op, operand);
+	else if (COMPARE_OPS.has(op)) checkValue(path, vt, op, operand);
+}
+/**
+* Walks `filter` (through `$and` / `$or` / `$not`; relational predicates are
+* the related table's) and checks every entry whose key `typeOf` knows.
+*/
+function walkFilterValues(filter, typeOf) {
+	if (!isPlainObject(filter)) return;
+	for (const [key, value] of Object.entries(filter)) {
+		if (key === "$and" || key === "$or") {
+			if (Array.isArray(value)) for (const child of value) walkFilterValues(child, typeOf);
+			continue;
+		}
+		if (key === "$not") {
+			walkFilterValues(value, typeOf);
+			continue;
+		}
+		if (key.startsWith("$") || hasRelationOp(value)) continue;
+		if (isPlainObject(value) && "$integerRegex" in value) throw valueError(key, INTEGER_REGEX_OP, "is internal — use $regex");
+		const vt = typeOf(key);
+		if (vt) checkEntry(key, vt, value);
+	}
+}
+/**
+* Rejects (`INVALID_QUERY`, `path` = the field) a filter value that cannot
+* denote its field's declared type — see the module notes for the accepted
+* forms. Unknown paths are skipped (the path guard owns them).
+*/
+function guardFilterValues(meta, filter) {
+	if (!filter) return;
+	walkFilterValues(filter, (key) => {
+		const fd = meta.descriptorByPath.get(key);
+		return fd ? valueTypeOf(meta, fd) : void 0;
+	});
+}
+/**
+* `$having` values: an aggregate alias is a number (`count`,
+* `countDistinct`, `sum`, `avg`, an expression) or its source field's type
+* (`min` / `max`, `first` / `last`),
+* a calendar-bucket alias a string label, any other key a `$groupBy`
+* field's own type.
+*/
+function guardHavingValues(meta, controls) {
+	if (!controls?.$having) return;
+	const aliases = /* @__PURE__ */ new Map();
+	if (Array.isArray(controls.$select)) {
+		for (const item of controls.$select) if (isAggregateOfExpr(item) || isSelectArithExpr(item)) aliases.set(item.$as, NUMBER);
+		else if (isAggregateExpr(item)) {
+			const fd = SOURCE_VALUE_FNS.has(item.$fn) ? meta.descriptorByPath.get(item.$field) : void 0;
+			const counts = item.$fn === "count" || item.$fn === "countDistinct";
+			aliases.set(resolveAlias$1(item), fd ? valueTypeOf(meta, fd) : counts ? INTEGER : NUMBER);
+		} else if (isBucketExpr(item)) aliases.set(resolveAlias$1(item), STRING);
+	}
+	walkFilterValues(controls.$having, (key) => {
+		const alias = aliases.get(key);
+		if (alias) return alias;
+		const fd = meta.descriptorByPath.get(key);
+		return fd ? valueTypeOf(meta, fd) : void 0;
+	});
+}
+//#endregion
+//#region src/query/integer-regex.ts
+/** Rewrites one field entry; returns the same value when it has no pattern match. */
+function rewriteEntry(value) {
+	if (value instanceof RegExp) return { [INTEGER_REGEX_OP]: value };
+	if (isPlainObject(value) && "$regex" in value) {
+		const out = {};
+		for (const [op, operand] of Object.entries(value)) out[op === "$regex" ? INTEGER_REGEX_OP : op] = operand;
+		return out;
+	}
+	return value;
+}
+/**
+* `$regex` (and a bare `RegExp`) on integer search members →
+* {@link INTEGER_REGEX_OP}, on the LOGICAL filter. Copy-on-write: the very
+* same object comes back when nothing changed. Relational predicates are
+* rewritten by the related table when it translates them.
+*/
+function rewriteIntegerRegex(filter, meta) {
+	if (!isPlainObject(filter)) return filter;
+	let out;
+	for (const [key, value] of Object.entries(filter)) {
+		let next = value;
+		if (key === "$and" || key === "$or") {
+			if (Array.isArray(value)) {
+				const mapped = value.map((f) => rewriteIntegerRegex(f, meta));
+				if (mapped.some((m, i) => m !== value[i])) next = mapped;
+			}
+		} else if (key === "$not") next = rewriteIntegerRegex(value, meta);
+		else if (!key.startsWith("$") && !meta.navFields.has(key)) {
+			const fd = meta.descriptorByPath.get(key);
+			if (fd && isIntegerTextField(meta, fd)) next = rewriteEntry(value);
+		}
+		if (next !== value) {
+			out ??= { ...filter };
+			out[key] = next;
+		}
+	}
+	return out ?? filter;
 }
 //#endregion
 //#region src/query/aggregate-expr.ts
@@ -1787,6 +2207,7 @@ var FieldMappingStrategy = class {
 	* translate predicate operands at deeper levels).
 	*/
 	translateFilter(filter, meta, depth = 0) {
+		filter = rewriteIntegerRegex(filter, meta);
 		const has = containsRelationFilter(filter);
 		const resolved = has ? resolveRelationFilterTree(filter, meta, depth) : filter;
 		return this.noteTranslated(filter, this.translateResolvedFilter(resolved, meta), has);
@@ -1921,7 +2342,8 @@ var FieldMappingStrategy = class {
 		if (!isPlainObject(value)) return fmt(value);
 		const ops = value;
 		const formatted = {};
-		for (const [op, opVal] of Object.entries(ops)) if ((op === "$in" || op === "$nin") && Array.isArray(opVal)) formatted[op] = opVal.map((v) => v === null || v === void 0 ? v : fmt(v));
+		for (const [op, opVal] of Object.entries(ops)) if (op === "$integerRegex") formatted[op] = opVal;
+		else if ((op === "$in" || op === "$nin") && Array.isArray(opVal)) formatted[op] = opVal.map((v) => v === null || v === void 0 ? v : fmt(v));
 		else if (op.startsWith("$") && opVal !== null && opVal !== void 0) formatted[op] = fmt(opVal);
 		else formatted[op] = opVal;
 		return formatted;
@@ -2118,7 +2540,7 @@ var RelationalFieldMapper = class extends FieldMappingStrategy {
 		return result;
 	}
 	translateQuery(query, meta) {
-		const logical = query.filter;
+		const logical = rewriteIntegerRegex(query.filter, meta);
 		const has = containsRelationFilter(logical);
 		const filter = has ? resolveRelationFilterTree(logical, meta, 0) : logical;
 		if (!meta.requiresMappings) {
@@ -2294,236 +2716,6 @@ var RelationalFieldMapper = class extends FieldMappingStrategy {
 	}
 };
 //#endregion
-//#region src/query/filter-values.ts
-const OPAQUE = {
-	kinds: new Set(["any"]),
-	timestamp: false
-};
-const NUMBER = {
-	kinds: new Set(["number"]),
-	timestamp: false
-};
-const INTEGER = {
-	kinds: new Set(["integer"]),
-	timestamp: false
-};
-const STRING = {
-	kinds: new Set(["string"]),
-	timestamp: false
-};
-function collectKinds(type, kinds, out, depth = 0) {
-	const def = type?.type;
-	const metadata = type?.metadata;
-	if (!def || depth > 8) {
-		kinds.add("any");
-		return;
-	}
-	switch (def.kind) {
-		case "": switch (def.designType) {
-			case "string":
-				kinds.add("string");
-				return;
-			case "number": {
-				const timestamp = def.tags?.has("timestamp") === true;
-				if (timestamp) out.timestamp = true;
-				const integer = timestamp || def.tags?.has("int") === true || metadata?.has?.("expect.int") === true;
-				kinds.add(integer ? "integer" : "number");
-				return;
-			}
-			case "decimal":
-				kinds.add("decimal");
-				return;
-			case "boolean":
-				kinds.add("boolean");
-				return;
-			case "null":
-			case "undefined":
-			case "never": return;
-			default:
-				kinds.add("any");
-				return;
-		}
-		case "union":
-			for (const item of def.items ?? []) collectKinds(item, kinds, out, depth + 1);
-			return;
-		case "array":
-			collectKinds(def.of, kinds, out, depth + 1);
-			return;
-		default: kinds.add("any");
-	}
-}
-const typeCache = /* @__PURE__ */ new WeakMap();
-/**
-* The value kinds a filter on `fd` accepts (cached per descriptor). A leaf
-* inside a JSON value (a `@db.json` object or an array, addressable on
-* nested-object adapters) is opaque: its contents are not schema-enforced.
-*/
-function valueTypeOf(meta, fd) {
-	let vt = typeCache.get(fd);
-	if (vt) return vt;
-	if (jsonValueAncestor(fd.path, meta.jsonValueParents) !== void 0 || fd.encrypted || fd.isGeoPoint || fd.designType === "json" || fd.designType === "object" || !fd.type) vt = OPAQUE;
-	else {
-		const kinds = /* @__PURE__ */ new Set();
-		const out = { timestamp: false };
-		collectKinds(fd.type, kinds, out);
-		const metadata = fd.type.metadata;
-		if ((fd.defaultValue?.kind === "fn" && fd.defaultValue.fn !== "uuid" || metadata?.has?.("db.agg.count") === true || metadata?.has?.("db.agg.countDistinct") === true) && kinds.delete("number")) kinds.add("integer");
-		vt = kinds.size === 0 ? OPAQUE : {
-			kinds,
-			timestamp: out.timestamp
-		};
-	}
-	typeCache.set(fd, vt);
-	return vt;
-}
-/** A decimal literal (`5`, `-1.5`, `.5`, `1e3`), surrounding blanks allowed — no hex, no `Infinity`. */
-const NUMERIC_RE = /^\s*[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?\s*$/i;
-/** An integer literal (`5`, `-12`), surrounding blanks allowed. */
-const INTEGER_RE = /^\s*[+-]?\d+\s*$/;
-function acceptsScalar(kind, value) {
-	switch (kind) {
-		case "any": return true;
-		case "string": return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint";
-		case "number":
-		case "decimal": return typeof value === "number" && Number.isFinite(value) || typeof value === "bigint" || typeof value === "string" && NUMERIC_RE.test(value);
-		case "integer": return typeof value === "number" && Number.isInteger(value) || typeof value === "bigint" || typeof value === "string" && INTEGER_RE.test(value);
-		default: return typeof value === "boolean" || value === 0 || value === 1;
-	}
-}
-/** The first element of `value` (itself when not an array) `vt` rejects, or `undefined`. */
-function rejectedValue(vt, value) {
-	if (vt.kinds.has("any") || value === null || value === void 0) return void 0;
-	if (Array.isArray(value)) {
-		for (const item of value) {
-			const bad = rejectedValue(vt, item);
-			if (bad) return bad;
-		}
-		return;
-	}
-	if (typeof value === "object" && !isPlainObject(value)) return void 0;
-	for (const kind of vt.kinds) if (acceptsScalar(kind, value)) return void 0;
-	return { value };
-}
-const KIND_LABEL = {
-	string: "a string",
-	number: "a number",
-	integer: "an integer",
-	decimal: "a decimal (number or numeric string)",
-	boolean: "a boolean"
-};
-function expectedOf(vt) {
-	const labels = [];
-	for (const kind of vt.kinds) {
-		if (kind === "any") continue;
-		labels.push(kind === "integer" && vt.timestamp ? "an integer (epoch milliseconds)" : KIND_LABEL[kind]);
-	}
-	return labels.join(" or ");
-}
-function describeValue(value) {
-	if (typeof value === "string") return JSON.stringify(value.length > 40 ? `${value.slice(0, 40)}…` : value);
-	if (isPlainObject(value)) return "an object";
-	return String(value);
-}
-function valueError(path, op, message) {
-	return new DbError("INVALID_QUERY", [{
-		path,
-		message: `Invalid filter value for "${path}"${op ? ` (${op})` : ""}: ${message}`
-	}]);
-}
-function holdsStrings(vt) {
-	return vt.kinds.has("string") || vt.kinds.has("any");
-}
-function checkRegex(path, vt, op, pattern) {
-	if (!holdsStrings(vt)) throw valueError(path, op, `a pattern match needs a string field, "${path}" holds ${expectedOf(vt)}`);
-	if (typeof pattern !== "string" && !(pattern instanceof RegExp)) throw valueError(path, op, `expected a regular expression, got ${describeValue(pattern)}`);
-}
-function checkValue(path, vt, op, value) {
-	if (value instanceof RegExp) {
-		checkRegex(path, vt, op ?? "RegExp", value);
-		return;
-	}
-	const bad = rejectedValue(vt, value);
-	if (bad) throw valueError(path, op, `expected ${expectedOf(vt)}, got ${describeValue(bad.value)}`);
-}
-/** Operators whose operand is compared with the field's values. */
-const COMPARE_OPS = new Set([
-	"$eq",
-	"$ne",
-	"$gt",
-	"$gte",
-	"$lt",
-	"$lte",
-	"$in",
-	"$nin"
-]);
-/** Checks one filter entry's value (a bare value or an operator map) against `vt`. */
-function checkEntry(path, vt, value) {
-	if (vt.kinds.has("any")) return;
-	if (!isPlainObject(value)) {
-		checkValue(path, vt, void 0, value);
-		return;
-	}
-	for (const [op, operand] of Object.entries(value)) if (op === "$regex") checkRegex(path, vt, op, operand);
-	else if (COMPARE_OPS.has(op)) checkValue(path, vt, op, operand);
-}
-/**
-* Walks `filter` (through `$and` / `$or` / `$not`; relational predicates are
-* the related table's) and checks every entry whose key `typeOf` knows.
-*/
-function walkFilterValues(filter, typeOf) {
-	if (!isPlainObject(filter)) return;
-	for (const [key, value] of Object.entries(filter)) {
-		if (key === "$and" || key === "$or") {
-			if (Array.isArray(value)) for (const child of value) walkFilterValues(child, typeOf);
-			continue;
-		}
-		if (key === "$not") {
-			walkFilterValues(value, typeOf);
-			continue;
-		}
-		if (key.startsWith("$") || hasRelationOp(value)) continue;
-		const vt = typeOf(key);
-		if (vt) checkEntry(key, vt, value);
-	}
-}
-/**
-* Rejects (`INVALID_QUERY`, `path` = the field) a filter value that cannot
-* denote its field's declared type — see the module notes for the accepted
-* forms. Unknown paths are skipped (the path guard owns them).
-*/
-function guardFilterValues(meta, filter) {
-	if (!filter) return;
-	walkFilterValues(filter, (key) => {
-		const fd = meta.descriptorByPath.get(key);
-		return fd ? valueTypeOf(meta, fd) : void 0;
-	});
-}
-/**
-* `$having` values: an aggregate alias is a number (`count`,
-* `countDistinct`, `sum`, `avg`, an expression) or its source field's type
-* (`min` / `max`, `first` / `last`),
-* a calendar-bucket alias a string label, any other key a `$groupBy`
-* field's own type.
-*/
-function guardHavingValues(meta, controls) {
-	if (!controls?.$having) return;
-	const aliases = /* @__PURE__ */ new Map();
-	if (Array.isArray(controls.$select)) {
-		for (const item of controls.$select) if (isAggregateOfExpr(item) || isSelectArithExpr(item)) aliases.set(item.$as, NUMBER);
-		else if (isAggregateExpr(item)) {
-			const fd = SOURCE_VALUE_FNS.has(item.$fn) ? meta.descriptorByPath.get(item.$field) : void 0;
-			const counts = item.$fn === "count" || item.$fn === "countDistinct";
-			aliases.set(resolveAlias$1(item), fd ? valueTypeOf(meta, fd) : counts ? INTEGER : NUMBER);
-		} else if (isBucketExpr(item)) aliases.set(resolveAlias$1(item), STRING);
-	}
-	walkFilterValues(controls.$having, (key) => {
-		const alias = aliases.get(key);
-		if (alias) return alias;
-		const fd = meta.descriptorByPath.get(key);
-		return fd ? valueTypeOf(meta, fd) : void 0;
-	});
-}
-//#endregion
 //#region src/query/query-guards.ts
 /**
 * Engine-agnostic query-time guards, applied in the core layer BEFORE filter
@@ -3595,6 +3787,17 @@ var AtscriptDbReadable = class {
 		if (field === void 0) return void 0;
 		return this._meta.columnMap.get(field) ?? field;
 	}
+	/**
+	* Logical paths of the `@db.column.version.exempt` fields, including objects
+	* whose direct children are all exempt. A patch that writes only these (and
+	* no `$cas`) does not bump the version column. Empty when the table has no
+	* `@db.column.version`.
+	* @since 0.1.150
+	*/
+	get versionExemptFields() {
+		this._ensureBuilt();
+		return this._meta.versionExemptPaths;
+	}
 	/** Dimension fields from `@db.column.dimension`. */
 	get dimensions() {
 		this._ensureBuilt();
@@ -4661,6 +4864,16 @@ var BaseDbAdapter = class {
 		this._verbose = enabled;
 	}
 	/**
+	* Physical version column an UPDATE must bump, or `undefined` when it must
+	* not: no `@db.column.version`, or a version-exempt patch
+	* (`opts.keepVersion`, since 0.1.150 — the core never combines it with
+	* `expectedVersion`; a violation throws).
+	*/
+	_versionColumnFor(opts, expectedVersion) {
+		if (!opts?.keepVersion) return this._table.versionColumnPhysical;
+		if (expectedVersion !== void 0) throw new Error("keepVersion cannot combine with expectedVersion");
+	}
+	/**
 	* Logs a debug message if verbose mode is enabled.
 	* Adapters call this to log DB operations with zero overhead when disabled.
 	*/
@@ -5000,9 +5213,10 @@ var BaseDbAdapter = class {
 	*
 	* @param filter - Filter identifying the record to patch.
 	* @param patch - The patch payload with array operations.
+	* @param opts - `keepVersion`: skip the version bump (see {@link TDbUpdateOptions}).
 	* @returns Update result.
 	*/
-	async nativePatch(_filter, _patch, _ops, _expectedVersion) {
+	async nativePatch(_filter, _patch, _ops, _expectedVersion, _opts) {
 		throw new Error("Native patch not supported by this adapter");
 	}
 	/**
@@ -5047,6 +5261,7 @@ var BaseDbAdapter = class {
 				continue;
 			}
 			if (opts.shouldSkipType?.(index.type)) continue;
+			if (index.type === "fulltext" && !index.fields.some((f) => !f.integer)) continue;
 			desiredNames.add(index.key);
 			if (!existingNames.has(index.key)) {
 				await attempt(`create index "${index.key}"`, () => opts.createIndex(index));
@@ -5067,6 +5282,13 @@ var BaseDbAdapter = class {
 	/**
 	* Returns available search indexes for this adapter.
 	* UI uses this to show index picker. Override in adapters that support search.
+	*
+	* A fulltext index may carry integer members ({@link TDbIndexField.integer},
+	* since 0.1.150): list them in `fields`, keep them out of the physical text
+	* index, and OR `member = n` into the search predicate when
+	* `searchTermInteger(text)` is defined. An index of integer members only
+	* is still listed (it makes the table natively searchable); a term that is
+	* not a whole number then matches nothing.
 	*/
 	getSearchIndexes() {
 		return [];
@@ -5112,7 +5334,9 @@ var BaseDbAdapter = class {
 		return false;
 	}
 	/**
-	* Full-text search. Override in adapters that support search.
+	* Full-text search. Override in adapters that support search. The text
+	* match is OR'd with exact-number equality on the index's integer members
+	* when the whole term is a whole number (see `searchTermInteger`).
 	*
 	* @param text - Search text.
 	* @param query - Filter, sort, limit, etc.
@@ -5696,6 +5920,8 @@ function matchByKeys(a, b, keys) {
 }
 //#endregion
 //#region src/patch/patch-decomposer.ts
+/** Metadata tag the flattener puts on top-level array fields (shared with `isVersionExemptPatch`). */
+const TOP_LEVEL_ARRAY_TAG = "db.__topLevelArray";
 /**
 * Decomposes a patch payload into a flat update object for adapters
 * that don't support native patch operations.
@@ -5714,7 +5940,7 @@ function matchByKeys(a, b, keys) {
 */
 function decomposePatch(payload, table) {
 	const update = {};
-	flattenPatchPayload(payload, "", update, table, "db.__topLevelArray");
+	flattenPatchPayload(payload, "", update, table, TOP_LEVEL_ARRAY_TAG);
 	return update;
 }
 function flattenPatchPayload(payload, prefix, update, table, topLevelArrayTag) {
@@ -5796,6 +6022,44 @@ function assertNoVersionWrites(data, versionColumn) {
 	}]);
 }
 //#endregion
+//#region src/patch/version-exempt.ts
+/**
+* Whether a logical (pre-decomposition) patch writes ONLY version-exempt
+* fields (`@db.column.version.exempt`). `data` has nav fields, filter keys and
+* derived fields removed and `$cas` separated. Mirrors `flattenPatchPayload`
+* (keep the two side by side): PK keys are skipped; an exempt path (or one
+* under an exempt ancestor) is covered whatever its value (scalar, field op,
+* array ops, object); a non-exempt merge-strategy object recurses (only the
+* supplied children are written); anything else is a non-exempt write.
+* True iff at least one key is covered and none is not.
+* @since 0.1.150
+*/
+function isVersionExemptPatch(data, table) {
+	const meta = table.getMetadata();
+	if (meta.versionExemptPaths.size === 0) return false;
+	const walk = (obj, prefix) => {
+		let result = "none";
+		for (const [k, value] of Object.entries(obj)) {
+			const key = prefix ? `${prefix}.${k}` : k;
+			if (table.primaryKeys.includes(key)) continue;
+			if (meta.isVersionExemptPath(key)) {
+				result = "exempt";
+				continue;
+			}
+			const flatType = table.flatMap.get(key);
+			if (typeof value === "object" && value !== null && !Array.isArray(value) && !isDbFieldOp(value) && !flatType?.metadata?.get("db.__topLevelArray") && !flatType?.metadata?.has("db.json") && flatType?.metadata?.get("db.patch.strategy") === "merge") {
+				const inner = walk(value, key);
+				if (inner === "versioned") return "versioned";
+				if (inner === "exempt") result = "exempt";
+				continue;
+			}
+			return "versioned";
+		}
+		return result;
+	};
+	return walk(data, "") === "exempt";
+}
+//#endregion
 //#region src/table/db-table.ts
 /** Returns true when `value` is a plain object carrying any `$`-prefixed key (an operator object). */
 function _hasOperatorKeys(value) {
@@ -6003,6 +6267,8 @@ function concurrentChange() {
 		message: "The record changed during the write — nothing was written, retry"
 	}]);
 }
+/** Hand-off for a version-exempt patch (since 0.1.150) — shared, never mutated. */
+const KEEP_VERSION = Object.freeze({ keepVersion: true });
 /** Upper bound of keys per `touchMany` UPDATE statement (parameter-count safety). */
 const TOUCH_MANY_CHUNK = 500;
 /** `touchMany` input rejection — always `INVALID_QUERY`, path names the key. */
@@ -6291,12 +6557,13 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 					if (!matched[i] && _ownedBy?.strict?.[i]) throw concurrentChange();
 					continue;
 				}
+				const updateOpts = expectedVersion === void 0 && versionColumn !== void 0 && isVersionExemptPatch(data, this) ? [KEEP_VERSION] : [];
 				let result;
 				if (this.adapter.supportsNativePatch()) {
 					const ops = separateFieldOps(data);
 					const translatedOps = ops ? this._fieldMapper.translateOpsKeys(ops, this._meta) : void 0;
 					const translatedData = this._fieldMapper.translatePatchKeys(data, this._meta);
-					result = await this.adapter.nativePatch(translatedFilter, translatedData, translatedOps, expectedVersion);
+					result = await this.adapter.nativePatch(translatedFilter, translatedData, translatedOps, expectedVersion, ...updateOpts);
 				} else {
 					const update = decomposePatch(data, this);
 					const ops = separateFieldOps(update);
@@ -6307,8 +6574,8 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 							filter: translatedFilter,
 							controls: {}
 						}), this);
-						result = await this.adapter.updateOne(translatedFilter, resolved, translatedOps, expectedVersion);
-					} else result = await this.adapter.updateOne(translatedFilter, translatedUpdate, translatedOps, expectedVersion);
+						result = await this.adapter.updateOne(translatedFilter, resolved, translatedOps, expectedVersion, ...updateOpts);
+					} else result = await this.adapter.updateOne(translatedFilter, translatedUpdate, translatedOps, expectedVersion, ...updateOpts);
 				}
 				modifiedCount += result.modifiedCount;
 				matched[i] = result.matchedCount > 0;
@@ -6455,6 +6722,7 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 			message: "$cas is not supported on updateMany — use bulkUpdate with per-row $cas for version-locked batch updates"
 		}]);
 		if (versionColumn !== void 0) assertNoVersionWrites(dataCopy, versionColumn);
+		const updateOpts = versionColumn !== void 0 && isVersionExemptPatch(dataCopy, this) ? [KEEP_VERSION] : [];
 		await this._encryptItems([dataCopy], "patch");
 		const update = decomposePatch(dataCopy, this);
 		const ops = separateFieldOps(update);
@@ -6468,7 +6736,7 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 			}),
 			modifiedCount: 0
 		};
-		return enrichFkViolation(this._meta, () => this.adapter.updateMany(translatedFilter, translatedUpdate, translatedOps));
+		return enrichFkViolation(this._meta, () => this.adapter.updateMany(translatedFilter, translatedUpdate, translatedOps, ...updateOpts));
 	}
 	async replaceMany(filter, data) {
 		this._ensureBuilt();
@@ -7540,7 +7808,8 @@ function computeTableSnapshot(readable, typeMapper, tableOptions) {
 		type: idx.type,
 		fields: idx.fields.map((f) => ({
 			name: f.name,
-			sort: f.sort
+			sort: f.sort,
+			...f.integer ? { integer: true } : {}
 		}))
 	})).toSorted((a, b) => a.key.localeCompare(b.key));
 	const foreignKeys = [...readable.foreignKeys.values()].map((fk) => ({
@@ -7847,4 +8116,4 @@ function computeColumnDiff(desired, existing, typeMapper, opts) {
 	return diff;
 }
 //#endregion
-export { FieldMappingStrategy as $, geoIndexNotFoundMessage as A, classifyQueryPath as B, ALL_VIEW_CAPABILITIES as C, NativeIntegrity as D, IntegrityStrategy as E, acceptedOperatorsHint as F, guardPath as G, groupSourceVerdict as H, assertGeoPoint as I, narrowerFilterOps as J, guardPaths as K, bucketSourceVerdict as L, vectorIndexNotFoundMessage as M, ADAPTER_FILTER_REASON as N, AtscriptDbReadable as O, ENCRYPTED_REASON as P, DocumentFieldMapper as Q, canFilterLeaf as R, ALL_BUCKET_UNITS as S, createFailureCollector as T, guardAggregate as U, collectQueryPaths as V, guardFilter as W, unsupportedOperatorMessage as X, sortFieldNames as Y, RelationalFieldMapper as Z, isViewType as _, computeTableHash as a, aliasTargetOf as at, decomposePatch as b, snapshotToExistingColumns as c, jsonValueAncestor as ct, computeForeignKeyDiff as d, NoopLogger as dt, UniquSelect as et, fkColumns as f, isAtscriptDbView as g, AtscriptDbView as h, computeSchemaHash as i, isGeoPointType as it, searchIndexNotFoundMessage as j, resolveDesignType as k, snapshotToExistingTableOptions as l, normalizeComputedSelect as lt, hasForeignKeyChanges as m, isColumnTypeChanged as n, TableMetadata as nt, computeTableSnapshot as o, isBucketableField as ot, fkKey as p, guardQuery as q, canonicalizeQueryNode as r, isGeoIndexableType as rt, computeViewSnapshot as s, isJsonValueField as st, computeColumnDiff as t, numericOperandProblem as tt, viewSnapshotSources as u, resolveCalendarBuckets as ut, AtscriptDbTable as v, BaseDbAdapter as w, ApplicationIntegrity as x, assertNoVersionWrites as y, checkHavingKeys as z };
+export { DocumentFieldMapper as $, resolveDesignType as A, checkHavingKeys as B, ALL_BUCKET_UNITS as C, IntegrityStrategy as D, createFailureCollector as E, ENCRYPTED_REASON as F, guardFilter as G, collectQueryPaths as H, acceptedOperatorsHint as I, guardQuery as J, guardPath as K, assertGeoPoint as L, searchIndexNotFoundMessage as M, vectorIndexNotFoundMessage as N, NativeIntegrity as O, ADAPTER_FILTER_REASON as P, RelationalFieldMapper as Q, bucketSourceVerdict as R, ApplicationIntegrity as S, BaseDbAdapter as T, groupSourceVerdict as U, classifyQueryPath as V, guardAggregate as W, sortFieldNames as X, narrowerFilterOps as Y, unsupportedOperatorMessage as Z, isViewType as _, NoopLogger as _t, computeTableHash as a, describeFulltext as at, assertNoVersionWrites as b, snapshotToExistingColumns as c, TableMetadata as ct, computeForeignKeyDiff as d, aliasTargetOf as dt, FieldMappingStrategy as et, fkColumns as f, isBucketableField as ft, isAtscriptDbView as g, resolveCalendarBuckets as gt, AtscriptDbView as h, normalizeComputedSelect as ht, computeSchemaHash as i, defaultFulltextIndex as it, geoIndexNotFoundMessage as j, AtscriptDbReadable as k, snapshotToExistingTableOptions as l, isGeoIndexableType as lt, hasForeignKeyChanges as m, jsonValueAncestor as mt, isColumnTypeChanged as n, numericOperandProblem as nt, computeTableSnapshot as o, searchTermInteger as ot, fkKey as p, isJsonValueField as pt, guardPaths as q, canonicalizeQueryNode as r, INTEGER_REGEX_OP as rt, computeViewSnapshot as s, splitFulltextFields as st, computeColumnDiff as t, UniquSelect as tt, viewSnapshotSources as u, isGeoPointType as ut, AtscriptDbTable as v, ALL_VIEW_CAPABILITIES as w, decomposePatch as x, isVersionExemptPatch as y, canFilterLeaf as z };