@atscript/db 0.1.154 → 0.1.156

package/dist/{column-diff-DAIAq6XR.mjs → column-diff-DR1glykD.mjs}

@@ -1,12 +1,12 @@
 import { a as aggregateExpressionsNotSupported, n as CasMismatchError, r as DbError, u as spaceClosedError } from "./db-error-eSsQX7rt.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-B_sgl4mB.mjs";
 import { A as hasRelationOp, D as containsRelationFilter, F as resolveRelationFilterTree, H as tableNameOf, I as compositeKey, J as viewExprNullable, K as isFieldRef, L as findFKEntryForRelation, M as noteRelationFilter, N as relGuardState, O as createRelationFilterHost, R as findFKForRelation, S as uniqueKeyTuple, U as computeOf, V as slicePerGroup, W as computedOperands, Y as walkViewExpr, _ as remapDeleteFkViolation, a as batchPatchNestedFrom, b as rowMatchesKey, c as batchReplaceNestedFrom, d as checkDepthOverflow, f as planNestedFromVia, g as enrichFkViolation, h as validateBatch, i as batchInsertNestedVia, l as batchReplaceNestedTo, m as preValidateNestedFrom, n as batchInsertNestedFrom, p as planPatchNestedTo, r as batchInsertNestedTo, s as batchPatchNestedVia, t as applyPatchNestedTo, u as batchReplaceNestedVia, v as findRowsByKeys, x as sameKey, y as pkTupleKey, z as findRemoteFK } from "./nested-writer-BOj_c_lI.mjs";
-import { a as DERIVED_INCOMPATIBLE, n as searchMemberKind, r as numericTypeProblem, s as isJsonLeafType } from "./search-fields-DBIZKwyb.mjs";
+import { a as forceNavNonOptional, c as getKeyProps, d as soleUnionMember, f as unionValueMembers, i as dbPlugin, l as columnUnionBase, n as buildPatchPartial, t as buildDbValidator, u as pathPresence } from "./validator-B3fPJjS1.mjs";
+import { a as DERIVED_INCOMPATIBLE, n as searchMemberKind, r as numericTypeProblem, s as isJsonLeafType } from "./search-fields-CE8cmj9X.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 NOT_DIMENSION_REASON } from "./aggregate-rules-jdPrxqWa.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-BACewoRj.mjs";
 import { flattenAnnotatedType, isAnnotatedType } from "@atscript/typescript/utils";
 import { ARITH_MAX_NODES, BUCKET_UNITS, isAggregateExpr, isAggregateOfExpr, isBucketExpr, isNullsPlacement, isPrimitive, isRelationOp, isSelectArithExpr, resolveAlias, resolveBuckets } from "@uniqu/core";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -215,7 +215,7 @@ function sourceIndex(type) {
 			if (metadata.has("db.ignore") || navFields.has(path)) idx.unstored.add(path);
 			if (metadata.has("db.column.derived") && fieldType.ref?.field) idx.derived.set(path, fieldType.ref.field);
 			if (metadata.has("db.encrypted")) storage.push([path, false]);
-			else if (metadata.has("db.json") || resolveDesignType(fieldType) === "array") storage.push([path, true]);
+			else if (metadata.has("db.json") || resolveDesignType(fieldType) === "array" || isStructuredMixedUnion(fieldType)) storage.push([path, true]);
 		}
 		storage.sort(([a], [b]) => a.split(".").length - b.split(".").length);
 		for (const [path, json] of storage) if (findAncestorInSet(path, idx.jsonRoots) === void 0 && findAncestorInSet(path, idx.encrypted) === void 0) (json ? idx.jsonRoots : idx.encrypted).add(path);
@@ -264,8 +264,8 @@ function sourceFieldMetadata(sourceType, logicalPath) {
 * aggregate's field, a predicate operand) to where it is physically stored.
 * Internal — `AtscriptDbView.resolveRefSource` is the public entry.
 *
-* Relational rules (`TableMetadata`'s): the outermost `@db.json` or array
-* node with segments remaining is the column and the rest becomes
+* Relational rules (`TableMetadata`'s): the outermost `@db.json`, array or
+* structured mixed union (`isStructuredMixedUnion`) node with segments remaining is the column and the rest becomes
 * {@link TViewSource.jsonPath}; a flattened leaf is its parent segments
 * joined with `__` plus its `@db.column` (or segment); a top-level field is
 * its `@db.column` or name. Nested-object adapters use the document path
@@ -297,7 +297,8 @@ function resolveViewSource(sourceType, logicalPath, nestedObjects) {
 		};
 	}
 	const jsonRoot = selfOrAncestor(logicalPath, idx.jsonRoots);
-	const optional = selfOrAncestor(logicalPath, idx.optional) !== void 0 || jsonRoot !== void 0 && jsonRoot !== logicalPath;
+	const presence = pathPresence(sourceType, logicalPath);
+	const optional = (presence === void 0 ? selfOrAncestor(logicalPath, idx.optional) !== void 0 : presence !== "required") || jsonRoot !== void 0 && jsonRoot !== logicalPath;
 	if (!node) return {
 		column: logicalPath,
 		designType: "unknown",
@@ -385,6 +386,38 @@ function relationalColumnName(path, override, flattened) {
 function isNavRelation(metadata) {
 	return metadata.has("db.rel.to") || metadata.has("db.rel.from") || metadata.has("db.rel.via");
 }
+/**
+* A union whose value members disagree on their design type and include a
+* structure — `Addr | string`, or the leaf `a` of `{ a: Addr } | { a: string }`.
+* It has no column layout of its own: relational storage keeps it as one
+* JSON column, like `@db.json` (since 0.1.155).
+*/
+function isStructuredMixedUnion(type) {
+	if (type.type.kind !== "union" || resolveDesignType(type) !== "union") return false;
+	return unionValueMembers(type).members.some((member) => {
+		const kind = member.type.kind;
+		return kind === "object" || kind === "array" || kind === "tuple" || kind === "intersection";
+	});
+}
+/**
+* The type a column of `type` is described by: the value member of a
+* nullable union (`number.int | null` → `number.int`, so type mappers see
+* its tags) carrying the field's own annotations and optionality, else
+* `type` itself.
+*/
+function columnType(type) {
+	const member = soleUnionMember(type);
+	if (!member) return type;
+	return {
+		__is_atscript_annotated_type: true,
+		type: member.type,
+		metadata: type.metadata,
+		optional: type.optional,
+		id: member.id,
+		ref: member.ref,
+		validator: (...args) => type.validator(...args)
+	};
+}
 /** Returns true if the annotated type IS the `db.geoPoint` primitive (tag-based). */
 function isGeoPointType(fieldType) {
 	return fieldType.type.tags?.has("geoPoint") === true;
@@ -470,6 +503,12 @@ var TableMetadata = class {
 	/** Adapter-contributed multi-field unique keys (logical paths) — see `TMetadataOverrides.addUniqueKeys`. */
 	uniqueKeys = [];
 	defaults = /* @__PURE__ */ new Map();
+	/**
+	* Logical paths annotated with `@db.onUpdate.now` (`number.timestamp.updated`
+	* applies it): set to the current time by every update and replace.
+	* @since 0.1.156
+	*/
+	onUpdateNow = /* @__PURE__ */ new Set();
 	/** Logical path → `@db.column` override (top-level keys only on document storage). */
 	columnMap = /* @__PURE__ */ new Map();
 	dimensions = [];
@@ -554,6 +593,9 @@ var TableMetadata = class {
 	_alwaysAddressable;
 	_collateMap = /* @__PURE__ */ new Map();
 	_columnFromMap = /* @__PURE__ */ new Map();
+	/** The annotated type `build()` ran on — the root of {@link presence}. */
+	_rootType;
+	_presence = /* @__PURE__ */ new Map();
 	constructor(nestedObjects) {
 		this.nestedObjects = nestedObjects;
 	}
@@ -561,6 +603,72 @@ var TableMetadata = class {
 		return this._built;
 	}
 	/**
+	* Whether the value of the LOGICAL field `path` is always there, may be
+	* NULL / missing, or is declared by only some members of a union of
+	* objects on the way ({@link TPathPresence}); `undefined` inside an array.
+	* @since 0.1.155
+	*/
+	presence(path) {
+		if (this._presence.has(path)) return this._presence.get(path);
+		const root = this._rootType;
+		const answer = root ? pathPresence(root, path) : void 0;
+		this._presence.set(path, answer);
+		return answer;
+	}
+	/**
+	* Whether the LOGICAL field `path` can hold NULL (or be missing): it or a
+	* parent object is optional or a `| null` union, or only some members of
+	* a union of objects declare it. Inside an array: the field or a parent
+	* is optional.
+	* @since 0.1.155
+	*/
+	isNullable(path) {
+		const presence = this.presence(path);
+		if (presence !== void 0) return presence !== "required";
+		for (let p = path;;) {
+			if (this.flatMap.get(p)?.optional === true) return true;
+			const dot = p.lastIndexOf(".");
+			if (dot === -1) return false;
+			p = p.slice(0, dot);
+		}
+	}
+	_objectLeaves;
+	/**
+	* The stored fields under the object field `path` that a null test on the
+	* object reads (`rewriteObjectNullTests`, since 0.1.155): its leaf columns
+	* on relational storage, its scalar / array / JSON fields on document
+	* storage (not inside an array or a JSON value). `undefined` when `path`
+	* is no stored object (a leaf, a `@db.json` / encrypted / ignored field,
+	* a navigation relation, inside a JSON value, unknown).
+	*/
+	objectLeaves(path) {
+		this._objectLeaves ??= /* @__PURE__ */ new Map();
+		if (this._objectLeaves.has(path)) return this._objectLeaves.get(path);
+		let leaves;
+		const fd = this.descriptorByPath.get(path);
+		if (findAncestorInSet(path, this.jsonValueParents) === void 0 && (this.nestedObjects ? fd !== void 0 && fd.designType === "object" && fd.storage !== "json" : this.flattenedParents.has(path) && !this.ignoredFields.has(path))) {
+			const prefix = `${path}.`;
+			leaves = [];
+			for (const [leaf, leafFd] of this.descriptorByPath) {
+				if (!leaf.startsWith(prefix) || leafFd.designType === "object") continue;
+				if (findAncestorInSet(leaf, this.jsonValueParents) !== void 0) continue;
+				if (this.presence(leaf) === void 0) continue;
+				leaves.push(leaf);
+			}
+		}
+		this._objectLeaves.set(path, leaves);
+		return leaves;
+	}
+	/**
+	* Whether the column of `path` is nullable: {@link isNullable}, except
+	* inside an array (document storage only), where the field's own
+	* optionality counts.
+	*/
+	_columnNullable(path, type) {
+		const presence = this.presence(path);
+		return presence === void 0 ? type.optional === true : presence !== "required";
+	}
+	/**
 	* {@link documentPath} over this table's `columnMap`. A `@db.column.derived`
 	* field has no stored path of its own: it maps to its source leaf.
 	*/
@@ -604,6 +712,7 @@ var TableMetadata = class {
 	build(type, adapter, logger) {
 		if (this._built) return;
 		adapter.onBeforeFlatten?.(type);
+		this._rootType = type;
 		const collected = [];
 		this.flatMap = flattenAnnotatedType(type, {
 			topLevelArrayTag: adapter.getTopLevelArrayTag?.() ?? "db.__topLevelArray",
@@ -662,10 +771,13 @@ var TableMetadata = class {
 	* 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.
+	* annotations (`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. Exception: the one non-`null` member of `T | null` is the
+	* column's type, so its `db.*` annotations apply too — `createdAt:
+	* number.timestamp.created | null` gets `@db.default.now` like
+	* `createdAt: number.timestamp.created`.
 	*/
 	_dropMemberMetadata(collected) {
 		const byPath = /* @__PURE__ */ new Map();
@@ -678,12 +790,16 @@ var TableMetadata = class {
 			if (!entries.some((e) => e.member)) continue;
 			const flat = this.flatMap.get(path);
 			if (!flat?.__flat_union) continue;
+			const prop = entries.find((e) => !e.member);
+			const base = prop && columnUnionBase(prop.type);
 			const target = flat.metadata;
 			target.clear();
 			for (const entry of entries) {
-				if (entry.member && isInlinePrimitive(entry.type)) continue;
-				for (const [key, value] of entry.metadata) if (!entry.member || !key.startsWith("db.")) target.set(key, value);
+				const inline = entry.member && isInlinePrimitive(entry.type);
+				const isBase = entry.member && entry.type === base;
+				for (const [key, value] of entry.metadata) if (!entry.member || (key.startsWith("db.") ? isBase : !inline)) target.set(key, value);
 			}
+			if (base && prop) prop.metadata = target;
 		}
 	}
 	/**
@@ -706,7 +822,7 @@ var TableMetadata = class {
 	* Scans `@db.*` and `@meta.id` annotations on a field during flattening.
 	*/
 	_scanGenericAnnotations(fieldName, fieldType, metadata, logger) {
-		if (metadata.has("meta.id")) {
+		if (metadata.has("meta.id") && !fieldName.includes(".")) {
 			this.primaryKeys.push(fieldName);
 			this.originalMetaIdFields.push(fieldName);
 		}
@@ -717,6 +833,7 @@ var TableMetadata = class {
 		if (columnFrom && renamable) this._columnFromMap.set(fieldName, columnFrom);
 		const resolvedDefault = resolveDefaultFromMetadata(metadata);
 		if (resolvedDefault) this.defaults.set(fieldName, resolvedDefault);
+		if (metadata.has("db.onUpdate.now")) this.onUpdateNow.add(fieldName);
 		if (metadata.has("db.ignore")) this.ignoredFields.add(fieldName);
 		if (isNavRelation(metadata)) {
 			this.navFields.add(fieldName);
@@ -886,6 +1003,7 @@ var TableMetadata = class {
 		if (metadata.has("db.search.vector") || metadata.has("db.search.filter")) reject("@db.search.*", "search over ciphertext is impossible");
 		if (metadata.has("db.mongo.search.text") || metadata.has("db.mongo.search.autocomplete")) reject("@db.mongo.search.*", "Atlas Search over ciphertext is impossible");
 		if (metadata.has("db.column.version")) reject("@db.column.version", "the OCC filter needs cleartext equality");
+		if (metadata.has("db.onUpdate.now")) reject("@db.onUpdate.now", "the update time is set after the encryption transform");
 		if (metadata.has("db.default.increment") || metadata.has("db.default.now")) reject("@db.default.increment / @db.default.now", "engine-side defaults bypass the encryption transform");
 		if (metadata.get("db.patch.strategy") === "merge") reject("@db.patch.strategy \"merge\"", "ciphertext is opaque — partial merges would silently drop omitted keys");
 	}
@@ -969,7 +1087,7 @@ var TableMetadata = class {
 			const isJson = this.jsonFields.has(path);
 			const isArray = designType === "array";
 			const isObject = designType === "object";
-			if (isArray) this.jsonFields.add(path);
+			if (isArray || isStructuredMixedUnion(type)) this.jsonFields.add(path);
 			else if (isObject && isJson) {} else if (isObject && !isJson) this.flattenedParents.add(path);
 		}
 		for (const ignoredField of this.ignoredFields) if (this.flattenedParents.has(ignoredField)) {
@@ -1071,6 +1189,7 @@ var TableMetadata = class {
 			const isJson = this.jsonFields.has(path);
 			const isFlattened = !skipFlattening && findAncestorInSet(path, this.flattenedParents) !== void 0;
 			const designType = isEncrypted ? "string" : isJson ? "json" : resolveDesignType(type);
+			const colType = columnType(type);
 			let storage;
 			if (skipFlattening) storage = "column";
 			else if (isEncrypted) storage = isFlattened ? "flattened" : "column";
@@ -1089,10 +1208,10 @@ var TableMetadata = class {
 			if (quantityRef) this.quantityRefByField.set(path, quantityRef);
 			descriptors.push({
 				path,
-				type,
+				type: colType,
 				physicalName,
 				designType,
-				optional: type.optional === true,
+				optional: skipFlattening ? type.optional === true : this._columnNullable(path, type),
 				isPrimaryKey: this.primaryKeys.includes(path),
 				ignored: this.ignoredFields.has(path),
 				defaultValue: this.defaults.get(path),
@@ -1106,7 +1225,7 @@ var TableMetadata = class {
 				unitCode,
 				unitRefField,
 				encrypted: isEncrypted || underEncrypted || void 0,
-				isGeoPoint: isGeoPointType(type) || void 0,
+				isGeoPoint: isGeoPointType(colType) || void 0,
 				derived: this.derivedFields.get(path),
 				computed: computedMeta(rootType, path)
 			});
@@ -1234,7 +1353,7 @@ var TableMetadata = class {
 		for (const index of this.indexes.values()) for (const field of index.fields) {
 			const ftype = this.flatMap.get(field.name);
 			if (ftype) {
-				field.optional = ftype.optional === true;
+				field.optional = this._columnNullable(field.name, ftype);
 				field.designType = ftype.type.tags?.has("objectId") ? "objectId" : resolveDesignType(ftype);
 			}
 			field.name = this.physicalPath(field.name);
@@ -1647,6 +1766,78 @@ function rewriteIntegerRegex(filter, meta) {
 	return out ?? filter;
 }
 //#endregion
+//#region src/query/object-null.ts
+/**
+* Whether a filter entry's value only asks if the value is there: `null`,
+* `{ $eq: null }`, `{ $ne: null }`, `{ $exists: true | false }` (and
+* combinations of them).
+*/
+function isNullTest(value) {
+	if (value === null) return true;
+	if (!isPlainObject(value)) return false;
+	const ops = Object.entries(value);
+	return ops.length > 0 && ops.every(([op, operand]) => op === "$exists" ? typeof operand === "boolean" : (op === "$eq" || op === "$ne") && operand === null);
+}
+/**
+* The leaf form of one null test on an object (see
+* {@link rewriteObjectNullTests}) as `$and` members: absent — `$exists: false`
+* on every leaf; present — one `$or` of `$exists: true` per leaf.
+*/
+function objectTest(value, leaves) {
+	const ops = value === null ? { $eq: null } : value;
+	const out = [];
+	for (const [op, operand] of Object.entries(ops)) {
+		const present = op === "$exists" ? operand : op === "$ne";
+		const tests = leaves.map((leaf) => ({ [leaf]: { $exists: present } }));
+		if (present) out.push({ $or: tests });
+		else out.push(...tests);
+	}
+	return out;
+}
+/**
+* A null test on a stored object (since 0.1.155) — `{ address: null }`,
+* `{ address: { $ne: null } }`, `{ address: { $exists: … } }` — on the
+* object's leaves: the object is null when none of its fields holds a value
+* (`$exists: false` on every leaf), present when one does. Relational
+* storage has no column for the object (an all-NULL row reads back as
+* `null`); document storage answers the same, so an object stored as `{}`
+* or with only null fields counts as null everywhere. LOGICAL filter;
+* copy-on-write (the same object comes back when nothing changed).
+*/
+function rewriteObjectNullTests(filter, meta) {
+	if (!isPlainObject(filter)) return filter;
+	let out;
+	const extra = [];
+	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) => rewriteObjectNullTests(f, meta));
+				if (mapped.some((m, i) => m !== value[i])) next = mapped;
+			}
+		} else if (key === "$not") next = rewriteObjectNullTests(value, meta);
+		else if (!key.startsWith("$") && isNullTest(value)) {
+			const leaves = meta.objectLeaves(key);
+			if (leaves && leaves.length > 0) {
+				extra.push(...objectTest(value, leaves));
+				out ??= { ...filter };
+				delete out[key];
+				continue;
+			}
+		}
+		if (next !== value) {
+			out ??= { ...filter };
+			out[key] = next;
+		}
+	}
+	if (!out) return filter;
+	if (extra.length > 0) {
+		const and = out.$and;
+		out.$and = [...Array.isArray(and) ? and : [], ...extra];
+	}
+	return out;
+}
+//#endregion
 //#region src/query/aggregate-expr.ts
 /**
 * Output aliases of the computed `$select` entries of a grouped query —
@@ -2298,7 +2489,7 @@ var FieldMappingStrategy = class {
 	* translate predicate operands at deeper levels).
 	*/
 	translateFilter(filter, meta, depth = 0) {
-		filter = rewriteIntegerRegex(filter, meta);
+		filter = rewriteObjectNullTests(rewriteIntegerRegex(filter, meta), meta);
 		const has = containsRelationFilter(filter);
 		const resolved = has ? resolveRelationFilterTree(filter, meta, depth) : filter;
 		return this.noteTranslated(filter, this.translateResolvedFilter(resolved, meta), has);
@@ -2640,13 +2831,13 @@ var RelationalFieldMapper = class extends FieldMappingStrategy {
 					current = created;
 				} else current = next;
 			}
-			current[col.last] = value;
+			if (!col.partial || value !== null && value !== void 0) current[col.last] = value;
 		}
 		for (const parent of plan.parents) collapseNullParent(result, parent);
 		return result;
 	}
 	translateQuery(query, meta) {
-		const logical = rewriteIntegerRegex(query.filter, meta);
+		const logical = rewriteObjectNullTests(rewriteIntegerRegex(query.filter, meta), meta);
 		const has = containsRelationFilter(logical);
 		const filter = has ? resolveRelationFilterTree(logical, meta, 0) : logical;
 		if (!meta.requiresMappings) {
@@ -2701,7 +2892,11 @@ var RelationalFieldMapper = class extends FieldMappingStrategy {
 		return result;
 	}
 	prepareForWrite(payload, meta, adapter) {
-		if (meta.requiresMappings && !meta.onlyColumnRenames) return this.formatWriteValues(this.flattenWritePayload(payload, meta, adapter), meta);
+		if (meta.requiresMappings && !meta.onlyColumnRenames) {
+			const flat = this.flattenWritePayload(payload, meta, adapter);
+			nullAbsentNested(payload, flat, meta);
+			return this.formatWriteValues(flat, meta);
+		}
 		const data = { ...payload };
 		this.prepareCommon(data, meta, adapter);
 		if (meta.onlyColumnRenames) {
@@ -2728,7 +2923,7 @@ var RelationalFieldMapper = class extends FieldMappingStrategy {
 			const suffix = operatorMatch ? operatorMatch[2] : "";
 			const fd = meta.leafByLogical.get(basePath);
 			const finalKey = (fd?.physicalName ?? basePath) + suffix;
-			if (fd?.storage === "json" && typeof value === "object" && value !== null && !suffix) result[finalKey] = JSON.stringify(value);
+			if (fd?.storage === "json" && value !== null && value !== void 0 && !suffix) result[finalKey] = JSON.stringify(value);
 			else result[finalKey] = value;
 		}
 		return this.formatWriteValues(result, meta);
@@ -2808,6 +3003,49 @@ var RelationalFieldMapper = class extends FieldMappingStrategy {
 		return result;
 	}
 };
+const nestedColumns = /* @__PURE__ */ new WeakMap();
+function nestedColumnsFor(meta) {
+	let list = nestedColumns.get(meta);
+	if (list === void 0) {
+		list = [];
+		for (const [physical, fd] of meta.leafByPhysical) {
+			if (fd.derived || fd.isPrimaryKey || fd.storage === "column" || !fd.path.includes(".")) continue;
+			const segs = fd.path.split(".");
+			list.push({
+				physical,
+				parents: segs.slice(0, -1),
+				partial: meta.presence(fd.path) === "partial"
+			});
+		}
+		nestedColumns.set(meta, list);
+	}
+	return list;
+}
+/**
+* Every write through `prepareForWrite` stores a whole row (insert, replace).
+* A column the flattened row leaves out would take its column `DEFAULT` —
+* a `now` default below an absent optional object would make the object
+* reappear on read, and one of another union member's leaves would add a
+* field to the stored member. So a column below an absent / `null` parent
+* object, or one only some union members declare that the written member
+* leaves out, is written as `NULL` (since 0.1.155), as the document adapters
+* store such a row.
+*/
+function nullAbsentNested(payload, flat, meta) {
+	for (const col of nestedColumnsFor(meta)) {
+		if (col.physical in flat) continue;
+		let absent = false;
+		let current = payload;
+		for (const seg of col.parents) {
+			current = current[seg];
+			if (current === null || current === void 0 || typeof current !== "object") {
+				absent = true;
+				break;
+			}
+		}
+		if (absent || col.partial) flat[col.physical] = null;
+	}
+}
 /**
 * Per-table read plan of {@link RelationalFieldMapper.reconstructFromRead}:
 * the per-column decisions (coercion, JSON, nesting — the dot-path pre-split)
@@ -2827,12 +3065,14 @@ function compileReadPlan(meta) {
 	const fromFmts = meta.fromStorageFormatters;
 	const columns = /* @__PURE__ */ new Map();
 	for (const [physical, fd] of meta.leafByPhysical) {
-		const segs = (fd.storage === "json" || fd.storage === "flattened") && fd.path.includes(".") ? fd.path.split(".") : void 0;
+		const nested = (fd.storage === "json" || fd.storage === "flattened") && fd.path.includes(".");
+		const segs = nested ? fd.path.split(".") : void 0;
 		columns.set(physical, {
 			path: fd.path,
 			parents: segs?.slice(0, -1),
 			last: segs ? segs[segs.length - 1] : fd.path,
 			json: fd.storage === "json",
+			partial: nested && meta.presence(fd.path) === "partial",
 			coerce: fd.designType === "boolean" ? toBool : fd.designType === "decimal" ? toDecimalString : void 0,
 			fromFmt: fromFmts?.get(physical)
 		});
@@ -2843,15 +3083,16 @@ function compileReadPlan(meta) {
 		parents.push({
 			ancestors: segs.slice(0, -1),
 			last: segs[segs.length - 1],
-			optional: !!meta.flatMap?.get(parentPath)?.optional
+			presence: meta.presence(parentPath) ?? "required"
 		});
 	}
+	parents.sort((a, b) => b.ancestors.length - a.ancestors.length);
 	return {
 		columns,
 		parents
 	};
 }
-/** If every child of a flattened parent is null / undefined, collapse it (`null` when optional, else `{}`). */
+/** If every child of a flattened parent is null / undefined, collapse it (see {@link TReadParent}). */
 function collapseNullParent(obj, parent) {
 	let current = obj;
 	const ancestors = parent.ancestors;
@@ -2866,7 +3107,8 @@ function collapseNullParent(obj, parent) {
 		const v = parentObj[k];
 		if (v !== null && v !== void 0) return;
 	}
-	current[parent.last] = parent.optional ? null : {};
+	if (parent.presence === "partial") delete current[parent.last];
+	else current[parent.last] = parent.presence === "nullable" ? null : {};
 }
 /**
 * Per-table write plan of the relational flatten: each logical path's
@@ -3308,6 +3550,10 @@ function collectQueryPaths(query, aggregate) {
 			path,
 			predicate,
 			relation: relationOpsOf(value)
+		} : isNullTest(value) ? {
+			path,
+			predicate,
+			nullTest: true
 		} : {
 			path,
 			predicate
@@ -3407,10 +3653,11 @@ function pathSourceOf(meta) {
 * `FieldCapabilityIndex`, with `$with` hints and leaf lists) is what clients
 * see and is authoritative — the HTTP gate always answers first.
 */
-function guardPath(meta, adapter, path, op, predicate = "compare") {
+function guardPath(meta, adapter, path, op, predicate = "compare", nullTest = false) {
 	const verb = OP_VERB[op];
 	const { kind, parent } = classifyQueryPath(pathSourceOf(meta), path);
 	if (predicate === "relation" && kind !== "nav" && kind !== "unknown") throw pathError(path, `"$some" / "$none" are only valid on a navigation relation — "${path}" is not one`);
+	if (op === "filter" && nullTest && meta.objectLeaves(path)?.length) return;
 	switch (kind) {
 		case "nav":
 			if (op === "filter" && predicate === "relation" && parent === void 0) return;
@@ -3495,7 +3742,7 @@ function guardPaths(meta, adapter, query, aggregate = false, state) {
 	if (refs.unsupportedOperator !== void 0) throw pathError(refs.unsupportedOperator, unsupportedOperatorMessage(refs.unsupportedOperator));
 	let relState = state;
 	for (const ref of refs.filter) {
-		guardPath(meta, adapter, ref.path, "filter", ref.predicate);
+		guardPath(meta, adapter, ref.path, "filter", ref.predicate, ref.nullTest);
 		if (ref.predicate === "relation") guardRelationRef(meta, adapter, ref, relState ??= relGuardState());
 	}
 	for (const path of refs.sort) guardPath(meta, adapter, path, "sort");
@@ -3637,10 +3884,12 @@ var NullsSource = class {
 	}
 	/**
 	* Whether ordering by the LOGICAL field `path` can meet NULL (or a missing
-	* value): the field or one of its parent objects is optional, the field is
-	* a derived column, it is not a known field, or the source is a view. A
-	* `$nulls` entry on any other field changes nothing and is dropped, so the
-	* plain `ORDER BY` keeps using the index.
+	* value): the field can hold NULL (`TableMetadata.isNullable` — it or a
+	* parent object is optional or a `| null` union, or only some members of a
+	* union of objects declare it), the field is a derived column, it is not a
+	* known field, or the source is a view. A `$nulls` entry on any other
+	* field changes nothing and is dropped, so the plain `ORDER BY` keeps
+	* using the index.
 	*/
 	nullable(path) {
 		let answer = this._nullable.get(path);
@@ -3654,12 +3903,7 @@ var NullsSource = class {
 		const { meta } = this._init;
 		const fd = meta.descriptorByPath.get(path);
 		if (!fd || fd.derived) return true;
-		for (let p = path;;) {
-			if (meta.flatMap.get(p)?.optional === true) return true;
-			const dot = p.lastIndexOf(".");
-			if (dot === -1) return false;
-			p = p.slice(0, dot);
-		}
+		return meta.isNullable(path);
 	}
 	/**
 	* The effective `$nulls` of the `$sort` keys of one read: the request's
@@ -3774,7 +4018,9 @@ function geoIndexNotFoundMessage(tableName, indexName) {
 * otherwise trips up every adapter author.
 *
 * For union types (e.g., from flattened `{...} | {...}` objects):
-* - If all members resolve to the same type → returns that type (strong type)
+* - `null` / `undefined` members are left out (since 0.1.155): `T | null`
+*   resolves to the design type of `T`
+* - If all other members resolve to the same type → returns that type (strong type)
 * - If members disagree → returns `'union'` (out of scope for type management)
 */
 function resolveDesignType(fieldType) {
@@ -3782,9 +4028,9 @@ function resolveDesignType(fieldType) {
 	if (fieldType.type.kind === "object") return "object";
 	if (fieldType.type.kind === "array") return "array";
 	if (fieldType.type.kind === "union") {
-		const items = fieldType.type.items;
-		if (items.length > 0) {
-			const resolved = items.map((item) => resolveDesignType(item));
+		const { members } = unionValueMembers(fieldType);
+		if (members.length > 0) {
+			const resolved = members.map((item) => resolveDesignType(item));
 			if (resolved.every((type) => type === resolved[0])) return resolved[0];
 		}
 		return "union";
@@ -4440,21 +4686,13 @@ var AtscriptDbReadable = class {
 	_totalOrderKeys() {
 		if (this._totalOrderKeysCache) return this._totalOrderKeysCache;
 		const meta = this._meta;
-		const nullable = (logical) => {
-			for (let path = logical;;) {
-				if (meta.flatMap.get(path)?.optional === true) return true;
-				const dot = path.lastIndexOf(".");
-				if (dot === -1) return false;
-				path = path.slice(0, dot);
-			}
-		};
 		const sets = [];
 		if (meta.primaryKeys.length > 0) sets.push(meta.primaryKeys.map((f) => meta.physicalPath(f)));
 		for (const index of meta.indexes.values()) {
 			if (index.type !== "unique") continue;
-			if (index.fields.every((f) => f.optional !== true && !nullable(meta.physicalToPath.get(f.name) ?? f.name))) sets.push(index.fields.map((f) => f.name));
+			if (index.fields.every((f) => f.optional !== true && !meta.isNullable(meta.physicalToPath.get(f.name) ?? f.name))) sets.push(index.fields.map((f) => f.name));
 		}
-		for (const prop of meta.uniqueProps) if (!nullable(prop)) sets.push([meta.physicalPath(prop)]);
+		for (const prop of meta.uniqueProps) if (!meta.isNullable(prop)) sets.push([meta.physicalPath(prop)]);
 		this._totalOrderKeysCache = sets;
 		return sets;
 	}
@@ -6075,7 +6313,7 @@ var BaseDbAdapter = class {
 	}
 	/**
 	* Whether the table has at least one row. Schema sync uses it in the
-	* pre-flight phase to refuse a primary-key change on a populated table.
+	* pre-flight phase to check a primary-key change on a populated table.
 	* Override with an EXISTS/LIMIT 1 probe — this default is `count() > 0`,
 	* a full scan on some engines, and it can only answer for the adapter's
 	* OWN table: for another `tableName` (or on an administrative adapter
@@ -6495,6 +6733,10 @@ function flattenPatchPayload(payload, prefix, update, meta, table) {
 		const key = prefix ? `${prefix}.${_key}` : _key;
 		if (primaryKeys.includes(key)) continue;
 		if (!(typeof value === "object" && value !== null && !Array.isArray(value))) {
+			if (value === null && meta.flattenedParents.has(key)) {
+				for (const lp of meta.optionalLeavesByLogicalParent.get(key) ?? []) update[lp] = null;
+				continue;
+			}
 			update[key] = value;
 			continue;
 		}
@@ -6575,10 +6817,11 @@ function assertNoVersionWrites(data, versionColumn) {
 * 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.
+* (keep the two side by side): PK keys and `@db.onUpdate.now` fields 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
 */
@@ -6587,11 +6830,12 @@ function isVersionExemptPatch(data, table) {
 	if (meta.versionExemptPaths.size === 0) return false;
 	const primaryKeys = meta.primaryKeys;
 	const flatMap = meta.flatMap;
+	const stamps = meta.onUpdateNow;
 	const walk = (obj, prefix) => {
 		let result = "none";
 		for (const [k, value] of Object.entries(obj)) {
 			const key = prefix ? `${prefix}.${k}` : k;
-			if (primaryKeys.includes(key)) continue;
+			if (primaryKeys.includes(key) || stamps.has(key)) continue;
 			if (meta.isVersionExemptPath(key)) {
 				result = "exempt";
 				continue;
@@ -6904,7 +7148,8 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 		const singleStatement = !ignore && this._isSingleStatementWrite(payloads, depth, guard, check);
 		return enrichFkViolation(this._meta, () => this._inWriteTransaction(singleStatement, async () => {
 			const clone = depth === 0 ? _cloneWritePayload : _shallowPrunedClone;
-			let items = payloads.map((p) => this._applyDefaults(clone(p)));
+			const now = Date.now();
+			let items = payloads.map((p) => this._applyDefaults(clone(p), now));
 			if (ignore) this._linkToByKeyInIgnoreMode(items);
 			let originals = canNest ? items.map((item) => ({ ...item })) : [];
 			const validator = this.getValidator("insert");
@@ -6980,10 +7225,12 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 			const versionColumn = this.versionColumn;
 			const expectedVersions = Array.from({ length: payloads.length });
 			const clone = depth === 0 ? _cloneWritePayload : _shallowPrunedClone;
+			const now = Date.now();
 			const items = payloads.map((p, i) => {
 				const c = clone(p);
 				expectedVersions[i] = separateCas(c, versionColumn);
-				return this._applyDefaults(c);
+				this._stampOnUpdate(c, now, true);
+				return this._applyDefaults(c, now);
 			});
 			const originals = canNest ? items.map((item) => ({ ...item })) : [];
 			const validator = this.getValidator("bulkReplace");
@@ -7067,9 +7314,11 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 			const versionColumn = this.versionColumn;
 			const expectedVersions = Array.from({ length: payloads.length });
 			const clone = depth === 0 ? _cloneWritePayload : _shallowPrunedClone;
+			const now = Date.now();
 			const cloned = payloads.map((p, i) => {
 				const c = clone(p);
 				expectedVersions[i] = separateCas(c, versionColumn);
+				this._stampOnUpdate(c, now, false);
 				return c;
 			});
 			const validator = this.getValidator("bulkUpdate");
@@ -7116,6 +7365,7 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 					continue;
 				}
 				const updateOpts = expectedVersion === void 0 && versionColumn !== void 0 && isVersionExemptPatch(data, this) ? [KEEP_VERSION] : [];
+				this._stampTopLevel(data, now);
 				let result;
 				if (this.adapter.supportsNativePatch()) {
 					const ops = separateFieldOps(data);
@@ -7275,6 +7525,8 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 		await this._integrity.validateForeignKeys([data], this._meta, this._fkLookupResolver, this._writeTableResolver, true);
 		const dataCopy = _cloneWritePayload(data);
 		this._meta.stripDerived(dataCopy);
+		const now = Date.now();
+		this._stampOnUpdate(dataCopy, now, false);
 		const versionColumn = this.versionColumn;
 		if ("$cas" in dataCopy) throw new DbError("INVALID_QUERY", [{
 			path: "$cas",
@@ -7282,6 +7534,7 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 		}]);
 		if (versionColumn !== void 0) assertNoVersionWrites(dataCopy, versionColumn);
 		const updateOpts = versionColumn !== void 0 && isVersionExemptPatch(dataCopy, this) ? [KEEP_VERSION] : [];
+		this._stampTopLevel(dataCopy, now);
 		await this._encryptItems([dataCopy], "patch");
 		const update = decomposePatch(dataCopy, this);
 		const ops = separateFieldOps(update);
@@ -7302,6 +7555,7 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 		this._guardMutationFilter(filter);
 		await this._integrity.validateForeignKeys([data], this._meta, this._fkLookupResolver, this._writeTableResolver);
 		const dataCopy = _cloneWritePayload(data);
+		this._stampOnUpdate(dataCopy, Date.now(), true);
 		await this._encryptItems([dataCopy], "write");
 		return enrichFkViolation(this._meta, () => this.adapter.replaceMany(this._fieldMapper.translateFilter(filter, this._meta), this._fieldMapper.prepareForWrite(dataCopy, this._meta, this.adapter)));
 	}
@@ -7672,27 +7926,79 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 	* full row). Function defaults (`now` / `uuid` / `increment` / custom) the
 	* adapter handles natively are NOT filled — the field stays absent so the
 	* engine's own default applies. The version column is never touched.
-	*/
-	_applyDefaults(data) {
+	* A nested field (`audit.createdAt`) is filled inside its object, only when
+	* that object is present (an absent or `null` embedded object stays so), and
+	* in every object of an array on the way; a field inside a JSON value or an
+	* array has no column default, so the SDK fills its function default too.
+	* Every `now` default the SDK fills gets the one time `now` (one per write
+	* call, so `createdAt` / `updatedAt` of a new row are equal).
+	*/
+	_applyDefaults(data, now = Date.now()) {
 		const nativeFns = this.adapter.nativeDefaultFns();
 		const versionField = this._meta.versionField;
 		for (const [field, def] of this._meta.defaults.entries()) {
 			if (field === versionField) continue;
-			if (data[field] === void 0) {
-				if (def.kind === "value") data[field] = this._valueDefault(field, def.value);
-				else if (def.kind === "fn" && !nativeFns.has(def.fn)) switch (def.fn) {
-					case "now":
-						data[field] = Date.now();
-						break;
-					case "uuid":
-						data[field] = crypto.randomUUID();
-						break;
-				}
+			let make;
+			if (def.kind === "value") make = () => this._valueDefault(field, def.value);
+			else if (def.kind === "fn" && (!nativeFns.has(def.fn) || findAncestorInSet(field, this._meta.jsonParents) !== void 0)) {
+				if (def.fn === "now") make = () => now;
+				else if (def.fn === "uuid") make = () => crypto.randomUUID();
 			}
+			if (!make) continue;
+			if (!field.includes(".")) {
+				if (data[field] === void 0) data[field] = make();
+			} else if (this._nestedDefaultFillable(field)) fillNested(data, field.split("."), 0, make);
 		}
 		return data;
 	}
 	/**
+	* `@db.onUpdate.now` (since 0.1.156): sets each such field of a replace /
+	* patch payload to `now`, overriding the caller's value. A nested field
+	* (`audit.updatedAt`) is set inside its object only when the payload
+	* carries that object — in every item of an array on the way and of the
+	* items an array patch operator adds or updates — like
+	* {@link _applyDefaults}. `topLevel: false` (a patch) instead drops the
+	* caller's values of the table's own columns: {@link _stampTopLevel} sets
+	* them once the patch is known to write something.
+	*/
+	_stampOnUpdate(data, now, topLevel) {
+		for (const field of this._meta.onUpdateNow) if (!field.includes(".")) if (topLevel) data[field] = now;
+		else delete data[field];
+		else if (this._nestedDefaultFillable(field)) stampNested(data, field.split("."), 0, now);
+	}
+	/** Sets the top-level `@db.onUpdate.now` columns of a non-empty patch to `now`. */
+	_stampTopLevel(data, now) {
+		if (isEmptyObject(data)) return;
+		for (const field of this._meta.onUpdateNow) if (!field.includes(".")) data[field] = now;
+	}
+	/** {@link _nestedDefaultFillable} per nested default path. */
+	_fillableDefaults;
+	/**
+	* Whether every parent of the nested default `field` is one object type —
+	* an object, `T | null` of one, or an array of one. Below a tuple or a
+	* union of several types the default cannot be placed (the item it belongs
+	* to is unknown), so it is not filled.
+	*/
+	_nestedDefaultFillable(field) {
+		const cache = this._fillableDefaults ??= /* @__PURE__ */ new Map();
+		let fillable = cache.get(field);
+		if (fillable === void 0) {
+			fillable = true;
+			for (let dot = field.indexOf("."); dot !== -1; dot = field.indexOf(".", dot + 1)) {
+				let type = this.flatMap.get(field.slice(0, dot));
+				if (type?.type.kind === "union") type = soleUnionMember(type);
+				if (type?.type.kind === "array") type = type.type.of;
+				if (type?.type.kind === "union") type = soleUnionMember(type);
+				if (type?.type.kind !== "object") {
+					fillable = false;
+					break;
+				}
+			}
+			cache.set(field, fillable);
+		}
+		return fillable;
+	}
+	/**
 	* Parsed `@db.default 'literal'` values that are primitives — reused for
 	* every row (an object / array default is parsed per row: each row gets
 	* its own instance).
@@ -7857,6 +8163,42 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 		return this.createValidator({ plugins: adapterPlugins });
 	}
 };
+/**
+* Sets `segs` below `value` to `now` (see `_stampOnUpdate`), through
+* arrays and the item lists of array patch operators (`$insert`, `$upsert`,
+* `$replace`, `$update` — not `$remove`).
+*/
+function stampNested(value, segs, i, now) {
+	if (Array.isArray(value)) {
+		for (const item of value) stampNested(item, segs, i, now);
+		return;
+	}
+	if (!isPlainObject(value)) return;
+	const key = segs[i];
+	if (i === segs.length - 1) {
+		value[key] = now;
+		return;
+	}
+	const next = value[key];
+	if (isPlainObject(next) && Object.keys(next).some((k) => k.startsWith("$"))) {
+		for (const [op, items] of Object.entries(next)) if (op !== "$remove") stampNested(items, segs, i + 1, now);
+	} else stampNested(next, segs, i + 1, now);
+}
+/**
+* Sets `segs[i..]` to `make()` where it is `undefined`, inside present plain
+* objects only — fanned out over the objects of every array on the way.
+*/
+function fillNested(value, segs, i, make) {
+	if (Array.isArray(value)) {
+		for (const item of value) fillNested(item, segs, i, make);
+		return;
+	}
+	if (!isPlainObject(value)) return;
+	const key = segs[i];
+	if (i === segs.length - 1) {
+		if (value[key] === void 0) value[key] = make();
+	} else fillNested(value[key], segs, i + 1, make);
+}
 //#endregion
 //#region src/table/view-read-plan.ts
 /** Design types whose `=` compares one scalar to one scalar on every engine. */
@@ -8969,7 +9311,9 @@ function computeColumnDiff(desired, existing, typeMapper, opts) {
 					});
 				}
 				const desiredDefault = serializeDefaultValue(field.defaultValue);
-				if (existingCol.dflt_value !== void 0 && existingCol.dflt_value !== desiredDefault) defaultChanged.push({
+				const fn = field.defaultValue?.kind === "fn" ? field.defaultValue.fn : void 0;
+				const missingNative = fn !== void 0 && fn !== "increment" && opts?.nativeDefaultFns?.has(fn) === true;
+				if ((existingCol.dflt_value !== void 0 || missingNative) && existingCol.dflt_value !== desiredDefault) defaultChanged.push({
 					field,
 					oldDefault: existingCol.dflt_value,
 					newDefault: desiredDefault
@@ -9006,4 +9350,4 @@ function computeColumnDiff(desired, existing, typeMapper, opts) {
 	return diff;
 }
 //#endregion
-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 };
+export { RelationalFieldMapper as $, AtscriptDbReadable as A, canFilterLeaf as B, ApplicationIntegrity as C, createFailureCollector as D, BaseDbAdapter as E, ADAPTER_FILTER_REASON as F, guardAggregate as G, classifyQueryPath as H, ENCRYPTED_REASON as I, guardPaths as J, guardFilter as K, acceptedOperatorsHint as L, geoIndexNotFoundMessage as M, searchIndexNotFoundMessage as N, IntegrityStrategy as O, vectorIndexNotFoundMessage as P, unsupportedOperatorMessage as Q, assertGeoPoint as R, decomposePatch as S, ALL_VIEW_CAPABILITIES as T, collectQueryPaths as U, checkHavingKeys as V, groupSourceVerdict as W, narrowerFilterOps as X, guardQuery as Y, sortFieldNames as Z, isAtscriptDbView as _, normalizeComputedSelect as _t, computeTableHash as a, defaultFulltextIndex as at, isVersionExemptPatch as b, serializeDefaultValue as c, splitFulltextFields as ct, viewSnapshotSources as d, isGeoPointType as dt, DocumentFieldMapper as et, computeForeignKeyDiff as f, relationalColumnName as ft, AtscriptDbView as g, jsonValueAncestor as gt, hasForeignKeyChanges as h, isJsonValueField as ht, computeSchemaHash as i, INTEGER_REGEX_OP as it, resolveDesignType as j, NativeIntegrity as k, snapshotToExistingColumns as l, TableMetadata as lt, fkKey as m, isBucketableField as mt, isColumnTypeChanged as n, UniquSelect as nt, computeTableSnapshot as o, describeFulltext as ot, fkColumns as p, aliasTargetOf as pt, guardPath as q, canonicalizeQueryNode as r, numericOperandProblem as rt, computeViewSnapshot as s, searchTermInteger as st, computeColumnDiff as t, FieldMappingStrategy as tt, snapshotToExistingTableOptions as u, isGeoIndexableType as ut, isViewType as v, resolveCalendarBuckets as vt, ALL_BUCKET_UNITS as w, assertNoVersionWrites as x, AtscriptDbTable as y, NoopLogger as yt, bucketSourceVerdict as z };