@atscript/db 0.1.150 → 0.1.152

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

@@ -1,6 +1,6 @@
 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 { A as hasRelationOp, D as containsRelationFilter, F as resolveRelationFilterTree, H as tableNameOf, I as compositeKey, J as viewExprNullable, 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-cvbVAkNo.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";
@@ -2520,23 +2520,37 @@ var RelationalFieldMapper = class extends FieldMappingStrategy {
 			this.reverseColumnRenames(row, meta);
 			return row;
 		}
+		const plan = readPlanFor(meta);
+		const cols = plan.columns;
 		const result = {};
-		const fromFmts = meta.fromStorageFormatters;
 		for (const physical of Object.keys(row)) {
-			const fd = meta.leafByPhysical.get(physical);
-			if (!fd) {
+			const col = cols.get(physical);
+			if (col === void 0) {
 				result[physical] = row[physical];
 				continue;
 			}
-			let raw = row[physical];
-			const fromFmt = fromFmts?.get(physical);
-			if (fromFmt && raw !== null && raw !== void 0) raw = fromFmt(raw);
-			const value = fd.designType === "boolean" ? toBool(raw) : fd.designType === "decimal" ? toDecimalString(raw) : raw;
-			if (fd.storage === "json") this.setNestedValue(result, fd.path, typeof value === "string" ? JSON.parse(value) : value);
-			else if (fd.storage === "flattened") this.setNestedValue(result, fd.path, value);
-			else result[fd.path] = value;
-		}
-		for (const parentPath of meta.flattenedParents) this.reconstructNullParent(result, parentPath, meta);
+			let value = row[physical];
+			if (col.fromFmt !== void 0 && value !== null && value !== void 0) value = col.fromFmt(value);
+			if (col.coerce !== void 0) value = col.coerce(value);
+			if (col.json && typeof value === "string") value = JSON.parse(value);
+			const parents = col.parents;
+			if (parents === void 0) {
+				result[col.path] = value;
+				continue;
+			}
+			let current = result;
+			for (let i = 0; i < parents.length; i++) {
+				const part = parents[i];
+				const next = current[part];
+				if (next === void 0 || next === null) {
+					const created = {};
+					current[part] = created;
+					current = created;
+				} else current = next;
+			}
+			current[col.last] = value;
+		}
+		for (const parent of plan.parents) collapseNullParent(result, parent);
 		return result;
 	}
 	translateQuery(query, meta) {
@@ -2595,17 +2609,16 @@ 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);
 		const data = { ...payload };
 		this.prepareCommon(data, meta, adapter);
-		if (!meta.requiresMappings) return this.formatWriteValues(data, meta);
 		if (meta.onlyColumnRenames) {
 			for (const [logical, physical] of meta.columnMap.entries()) if (logical in data) {
 				data[physical] = data[logical];
 				delete data[logical];
 			}
-			return this.formatWriteValues(data, meta);
 		}
-		return this.formatWriteValues(this.flattenPayload(data, meta), meta);
+		return this.formatWriteValues(data, meta);
 	}
 	translatePatchKeys(update, meta) {
 		if (!meta.requiresMappings && !meta.toStorageFormatters) return update;
@@ -2680,41 +2693,160 @@ var RelationalFieldMapper = class extends FieldMappingStrategy {
 		return result;
 	}
 	/**
-	* Flattens nested object fields into __-separated keys and
-	* JSON-stringifies @db.json / array fields.
+	* Flattens nested objects into __-separated keys and JSON-stringifies
+	* @db.json / array fields — with `prepareCommon` folded in: primary-key
+	* values prepared (`adapter.prepareId`), top-level ignored fields (skipped
+	* by {@link writeFlattenedField}) and derived fields left out. `payload`
+	* itself is not modified.
 	*/
-	flattenPayload(data, meta) {
+	flattenWritePayload(payload, meta, adapter) {
 		const result = {};
-		for (const key of Object.keys(data)) this.writeFlattenedField(key, data[key], result, meta);
+		const primaryKeys = meta.primaryKeys;
+		const root = writePlanFor(meta);
+		for (const key of Object.keys(payload)) {
+			if (meta.derivedFields.has(key)) continue;
+			let value = payload[key];
+			if (value !== void 0 && primaryKeys.includes(key)) {
+				const fieldType = meta.flatMap?.get(key);
+				if (fieldType) value = adapter.prepareId(value, fieldType);
+			}
+			writeFlattenedField(root, "", key, value, result, meta);
+		}
 		return result;
 	}
-	/**
-	* Classifies and writes a single field to the result object.
-	* Recurses into nested objects that should be flattened.
-	*/
-	writeFlattenedField(path, value, result, meta) {
-		if (meta.ignoredFields.has(path)) return;
-		if (meta.flattenedParents.has(path)) {
-			if (value === null || value === void 0) this.setFlattenedChildrenNull(path, result, meta);
+};
+/**
+* Per-table read plan of {@link RelationalFieldMapper.reconstructFromRead}:
+* the per-column decisions (coercion, JSON, nesting — the dot-path pre-split)
+* and the parent-collapse list, compiled once per built metadata instead of
+* per row. Metadata is immutable after `build()`, which precedes any read.
+*/
+const readPlans = /* @__PURE__ */ new WeakMap();
+function readPlanFor(meta) {
+	let plan = readPlans.get(meta);
+	if (plan === void 0) {
+		plan = compileReadPlan(meta);
+		readPlans.set(meta, plan);
+	}
+	return plan;
+}
+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;
+		columns.set(physical, {
+			path: fd.path,
+			parents: segs?.slice(0, -1),
+			last: segs ? segs[segs.length - 1] : fd.path,
+			json: fd.storage === "json",
+			coerce: fd.designType === "boolean" ? toBool : fd.designType === "decimal" ? toDecimalString : void 0,
+			fromFmt: fromFmts?.get(physical)
+		});
+	}
+	const parents = [];
+	for (const parentPath of meta.flattenedParents) {
+		const segs = parentPath.split(".");
+		parents.push({
+			ancestors: segs.slice(0, -1),
+			last: segs[segs.length - 1],
+			optional: !!meta.flatMap?.get(parentPath)?.optional
+		});
+	}
+	return {
+		columns,
+		parents
+	};
+}
+/** If every child of a flattened parent is null / undefined, collapse it (`null` when optional, else `{}`). */
+function collapseNullParent(obj, parent) {
+	let current = obj;
+	const ancestors = parent.ancestors;
+	for (let i = 0; i < ancestors.length; i++) {
+		const next = current[ancestors[i]];
+		if (next === void 0 || next === null) return;
+		current = next;
+	}
+	const parentObj = current[parent.last];
+	if (typeof parentObj !== "object" || parentObj === null) return;
+	for (const k of Object.keys(parentObj)) {
+		const v = parentObj[k];
+		if (v !== null && v !== void 0) return;
+	}
+	current[parent.last] = parent.optional ? null : {};
+}
+/**
+* Per-table write plan of the relational flatten: each logical path's
+* classification (ignored / flattened parent / json / plain column) and
+* physical column, resolved once per path instead of per row (no per-key
+* path concatenation and map lookups). Only schema paths are memoised — a
+* key the metadata does not know is resolved per call, so arbitrary payload
+* keys cannot grow the plan.
+*/
+const writePlans = /* @__PURE__ */ new WeakMap();
+function writePlanFor(meta) {
+	let root = writePlans.get(meta);
+	if (root === void 0) {
+		root = /* @__PURE__ */ new Map();
+		writePlans.set(meta, root);
+	}
+	return root;
+}
+function resolveWriteNode(path, meta) {
+	if (meta.ignoredFields.has(path)) return {
+		node: {
+			kind: "ignored",
+			path,
+			physical: ""
+		},
+		known: true
+	};
+	if (meta.flattenedParents.has(path)) return {
+		node: {
+			kind: "parent",
+			path,
+			physical: "",
+			children: /* @__PURE__ */ new Map(),
+			nullChildren: meta.childrenByParent.get(path) ?? []
+		},
+		known: true
+	};
+	const fd = meta.leafByLogical.get(path);
+	return {
+		node: {
+			kind: fd?.storage === "json" ? "json" : "leaf",
+			path,
+			physical: fd?.physicalName ?? path.replace(/\./g, "__")
+		},
+		known: fd !== void 0
+	};
+}
+/**
+* Classifies and writes a single field to the result object — recursing into
+* nested objects that are flattened; JSON-stringifies @db.json / array fields.
+*/
+function writeFlattenedField(level, prefix, key, value, result, meta) {
+	let node = level.get(key);
+	if (node === void 0) {
+		const resolved = resolveWriteNode(prefix ? `${prefix}.${key}` : key, meta);
+		node = resolved.node;
+		if (resolved.known) level.set(key, node);
+	}
+	switch (node.kind) {
+		case "ignored": return;
+		case "parent":
+			if (value === null || value === void 0) for (const physical of node.nullChildren) result[physical] = null;
 			else if (typeof value === "object" && !Array.isArray(value)) {
 				const obj = value;
-				for (const key of Object.keys(obj)) this.writeFlattenedField(`${path}.${key}`, obj[key], result, meta);
+				for (const childKey of Object.keys(obj)) writeFlattenedField(node.children, node.path, childKey, obj[childKey], result, meta);
 			}
-		} else {
-			const fd = meta.leafByLogical.get(path);
-			const physical = fd?.physicalName ?? path.replace(/\./g, "__");
-			if (fd?.storage === "json") result[physical] = value !== void 0 && value !== null ? JSON.stringify(value) : value;
-			else result[physical] = value;
-		}
-	}
-	/**
-	* When a parent object is null/undefined, set all its flattened children to null.
-	*/
-	setFlattenedChildrenNull(parentPath, result, meta) {
-		const children = meta.childrenByParent.get(parentPath);
-		if (children) for (const physical of children) result[physical] = null;
+			return;
+		case "json":
+			result[node.physical] = value !== void 0 && value !== null ? JSON.stringify(value) : value;
+			return;
+		default: result[node.physical] = value;
 	}
-};
+}
 //#endregion
 //#region src/query/query-guards.ts
 /**
@@ -3712,6 +3844,11 @@ var AtscriptDbReadable = class {
 	*/
 	get uniqueKeySets() {
 		this._ensureBuilt();
+		this._uniqueKeySets ??= this._computeUniqueKeySets();
+		return this._uniqueKeySets;
+	}
+	_uniqueKeySets;
+	_computeUniqueKeySets() {
 		const sets = [];
 		if (this._meta.primaryKeys.length > 0) sets.push(this._meta.primaryKeys.map((f) => this._meta.physicalPath(f)));
 		for (const index of this._meta.indexes.values()) if (index.type === "unique") sets.push(index.fields.map((f) => f.name));
@@ -3719,7 +3856,8 @@ var AtscriptDbReadable = class {
 			const column = this._meta.physicalPath(prop);
 			if (!sets.some((s) => s.length === 1 && s[0] === column)) sets.push([column]);
 		}
-		return sets;
+		for (const set of sets) Object.freeze(set);
+		return Object.freeze(sets);
 	}
 	/** Preferred row identifier field names. Defaults to primary keys. */
 	get preferredId() {
@@ -4693,7 +4831,7 @@ var AtscriptDbReadable = class {
 	* Public entry point for relation loading. Used by adapters for nested $with delegation.
 	*/
 	async loadRelations(rows, withRelations) {
-		const { loadRelationsImpl } = await import("./relation-loader-ByY1Byrl.mjs").then((n) => n.n);
+		const { loadRelationsImpl } = await import("./relation-loader-DYab07lw.mjs").then((n) => n.n);
 		return loadRelationsImpl(rows, withRelations, this);
 	}
 	/**
@@ -5721,8 +5859,14 @@ var ApplicationIntegrity = class extends IntegrityStrategy {
 		}
 		return pin;
 	}
-	needsCascade(cascadeResolver) {
-		return !!cascadeResolver;
+	/**
+	* A resolver is set and — when `tableName` is given (since 0.1.151) — some
+	* table references `tableName` with an `onDelete` action: a delete from a
+	* table nothing references needs no cascade pass (nor its transaction).
+	*/
+	needsCascade(cascadeResolver, tableName) {
+		if (!cascadeResolver) return false;
+		return tableName === void 0 || cascadeResolver(tableName).length > 0;
 	}
 	recordKey(tableName, pkFields, record) {
 		let key = tableName;
@@ -5918,10 +6062,6 @@ function matchByKeys(a, b, keys) {
 	for (const key of keys) if (a[key] !== b[key]) return false;
 	return true;
 }
-//#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.
@@ -5940,21 +6080,25 @@ const TOP_LEVEL_ARRAY_TAG = "db.__topLevelArray";
 */
 function decomposePatch(payload, table) {
 	const update = {};
-	flattenPatchPayload(payload, "", update, table, TOP_LEVEL_ARRAY_TAG);
+	flattenPatchPayload(payload, "", update, table.getMetadata(), table);
 	return update;
 }
-function flattenPatchPayload(payload, prefix, update, table, topLevelArrayTag) {
-	const meta = table.getMetadata();
-	for (const [_key, value] of Object.entries(payload)) {
+function flattenPatchPayload(payload, prefix, update, meta, table) {
+	const primaryKeys = meta.primaryKeys;
+	const flatMap = meta.flatMap;
+	for (const _key of Object.keys(payload)) {
+		const value = payload[_key];
 		const key = prefix ? `${prefix}.${_key}` : _key;
-		if (table.primaryKeys.includes(key)) continue;
-		const flatType = table.flatMap.get(key);
-		const isTopLevelArray = flatType?.metadata?.get(topLevelArrayTag);
-		const isObjectValue = typeof value === "object" && value !== null && !Array.isArray(value);
-		if (isObjectValue && isTopLevelArray && !flatType?.metadata?.has("db.json")) decomposeArrayPatch(key, value, flatType, update, table);
-		else if (isObjectValue && flatType?.metadata?.get("db.patch.strategy") === "merge") flattenPatchPayload(value, key, update, table, topLevelArrayTag);
-		else if (isObjectValue && meta.flattenedParents.has(key)) {
-			flattenPatchPayload(value, key, update, table, topLevelArrayTag);
+		if (primaryKeys.includes(key)) continue;
+		if (!(typeof value === "object" && value !== null && !Array.isArray(value))) {
+			update[key] = value;
+			continue;
+		}
+		const flatType = flatMap.get(key);
+		if (flatType?.metadata?.get("db.__topLevelArray") && !flatType?.metadata?.has("db.json")) decomposeArrayPatch(key, value, flatType, update, table);
+		else if (flatType?.metadata?.get("db.patch.strategy") === "merge") flattenPatchPayload(value, key, update, meta, table);
+		else if (meta.flattenedParents.has(key)) {
+			flattenPatchPayload(value, key, update, meta, table);
 			const optLeaves = meta.optionalLeavesByLogicalParent.get(key);
 			if (optLeaves) {
 				for (const lp of optLeaves) if (!(lp in update)) update[lp] = null;
@@ -6037,16 +6181,18 @@ function assertNoVersionWrites(data, versionColumn) {
 function isVersionExemptPatch(data, table) {
 	const meta = table.getMetadata();
 	if (meta.versionExemptPaths.size === 0) return false;
+	const primaryKeys = meta.primaryKeys;
+	const flatMap = meta.flatMap;
 	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 (primaryKeys.includes(key)) continue;
 			if (meta.isVersionExemptPath(key)) {
 				result = "exempt";
 				continue;
 			}
-			const flatType = table.flatMap.get(key);
+			const flatType = 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";
@@ -6211,8 +6357,7 @@ var WriteGuardContext = class {
 			controls: {}
 		});
 		const used = /* @__PURE__ */ new Set();
-		const out = filters.map((filter) => {
-			const row = rows.find((r) => rowMatchesKey(r, filter));
+		const out = findRowsByKeys(rows, filters).map((row) => {
 			if (row) used.add(row);
 			return row ?? null;
 		});
@@ -6346,7 +6491,8 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 		const depth = _depth ?? 0;
 		const canNest = depth < maxDepth && this._writeTableResolver && this._meta.navFields.size > 0;
 		if (!canNest && this._meta.navFields.size > 0) checkDepthOverflow(payloads, maxDepth, this._meta);
-		return enrichFkViolation(this._meta, () => this.adapter.withTransaction(async () => {
+		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)));
 			if (ignore) this._linkToByKeyInIgnoreMode(items);
@@ -6419,7 +6565,8 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 		const depth = _depth ?? 0;
 		const canNest = depth < maxDepth && this._writeTableResolver && this._meta.navFields.size > 0;
 		if (!canNest && this._meta.navFields.size > 0) checkDepthOverflow(payloads, maxDepth, this._meta);
-		return enrichFkViolation(this._meta, () => this.adapter.withTransaction(async () => {
+		const singleStatement = this._isSingleStatementWrite(payloads, depth, guard, check);
+		return enrichFkViolation(this._meta, () => this._inWriteTransaction(singleStatement, async () => {
 			const versionColumn = this.versionColumn;
 			const expectedVersions = Array.from({ length: payloads.length });
 			const clone = depth === 0 ? _cloneWritePayload : _shallowPrunedClone;
@@ -6505,7 +6652,8 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 		const depth = _depth ?? 0;
 		const canNest = depth < maxDepth && this._writeTableResolver && this._meta.navFields.size > 0;
 		if (!canNest && this._meta.navFields.size > 0) checkDepthOverflow(payloads, maxDepth, this._meta);
-		return enrichFkViolation(this._meta, () => this.adapter.withTransaction(async () => {
+		const singleStatement = this._isSingleStatementWrite(payloads, depth, guard, check);
+		return enrichFkViolation(this._meta, () => this._inWriteTransaction(singleStatement, async () => {
 			const versionColumn = this.versionColumn;
 			const expectedVersions = Array.from({ length: payloads.length });
 			const clone = depth === 0 ? _cloneWritePayload : _shallowPrunedClone;
@@ -6569,13 +6717,14 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 					const ops = separateFieldOps(update);
 					const translatedOps = ops ? this._fieldMapper.translateOpsKeys(ops, this._meta) : void 0;
 					const translatedUpdate = this._fieldMapper.translatePatchKeys(update, this._meta);
-					if (getArrayOpsFields(translatedUpdate).size > 0) {
+					if (getArrayOpsFields(translatedUpdate).size > 0) result = await this.adapter.withTransaction(async () => {
 						const resolved = resolveArrayOps(translatedUpdate, await this.adapter.findOne({
 							filter: translatedFilter,
 							controls: {}
 						}), this);
-						result = await this.adapter.updateOne(translatedFilter, resolved, translatedOps, expectedVersion, ...updateOpts);
-					} else result = await this.adapter.updateOne(translatedFilter, translatedUpdate, translatedOps, expectedVersion, ...updateOpts);
+						return 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;
@@ -6696,7 +6845,7 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 		const candidates = this._idCandidates(id, opts);
 		if (candidates.length === 0) return { deletedCount: 0 };
 		const guard = opts?.guard;
-		const needsCascade = this._integrity.needsCascade(this._cascadeResolver);
+		const needsCascade = this._integrity.needsCascade(this._cascadeResolver, this.tableName);
 		const run = async () => {
 			const pinned = await this._pinIdCandidates(candidates, opts?.scope);
 			const filter = this._andScope(pinned, opts?.scope);
@@ -6749,7 +6898,7 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 	async deleteMany(filter) {
 		this._ensureBuilt();
 		this._guardMutationFilter(filter);
-		if (this._integrity.needsCascade(this._cascadeResolver)) return remapDeleteFkViolation(this.tableName, () => this.adapter.withTransaction(async () => {
+		if (this._integrity.needsCascade(this._cascadeResolver, this.tableName)) return remapDeleteFkViolation(this.tableName, () => this.adapter.withTransaction(async () => {
 			const pin = await this._integrity.cascadeBeforeDelete(filter, this.tableName, this._meta, this._cascadeResolver, (f) => this._fieldMapper.translateFilter(f, this._meta), this.adapter);
 			if (pin) {
 				let deletedCount = 0;
@@ -6837,6 +6986,33 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 			};
 		});
 	}
+	/**
+	* Whether a `*One` / `bulk*` write of `payloads` is a single statement that
+	* needs no wrapping transaction (since 0.1.151): one root-level row, no
+	* `guard` / `check` (their reads and the write must share one snapshot),
+	* no nested navigation data (multi-table phases), and FK integrity enforced
+	* by the database (application-level FK checks read before writing). The
+	* write then calls the adapter outside any transaction of its own — one
+	* `insertMany([row])` / `replaceOne` / `updateOne` / `nativePatch`, or a
+	* read-only `count` for an empty patch; the array-operator read-modify-write
+	* still opens a transaction for its pair. Adapters may rely on it: a
+	* single-row `insertMany` reached this way runs outside a transaction.
+	*/
+	_isSingleStatementWrite(payloads, depth, guard, check) {
+		if (payloads.length !== 1 || depth !== 0 || guard || check) return false;
+		if (this._meta.foreignKeys.size > 0 && !this.adapter.supportsNativeForeignKeys()) return false;
+		const payload = payloads[0];
+		if (!payload || typeof payload !== "object") return false;
+		for (const navField of this._meta.navFields) {
+			const value = payload[navField];
+			if (value !== void 0 && value !== null) return false;
+		}
+		return true;
+	}
+	/** Runs a write body inside the adapter transaction — or directly for a single-statement write. */
+	_inWriteTransaction(singleStatement, fn) {
+		return singleStatement ? fn() : this.adapter.withTransaction(fn);
+	}
 	/** Whether `filter` names every primary-key field (so it IS the row's exact key). */
 	_isPkFilter(filter) {
 		const pkFields = this.primaryKeys;
@@ -6898,11 +7074,12 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 			controls
 		});
 		const used = /* @__PURE__ */ new Set();
-		for (const i of pending) {
-			const row = rows.find((r) => rowMatchesKey(r, rowFilters[i]));
+		const found = findRowsByKeys(rows, filters);
+		pending.forEach((i, k) => {
+			const row = found[k];
 			targets[i] = row ?? null;
 			if (row) used.add(row);
-		}
+		});
 		if (used.size < rows.length) {
 			for (const i of pending) if (targets[i] === null) targets[i] = await this.findOne({
 				filter: rowFilters[i],
@@ -7092,7 +7269,7 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 		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._parseValueDefault(field, def.value);
+				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();
@@ -7106,6 +7283,19 @@ var AtscriptDbTable = class extends AtscriptDbReadable {
 		return data;
 	}
 	/**
+	* 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).
+	*/
+	_primitiveDefaults;
+	_valueDefault(field, literal) {
+		const cache = this._primitiveDefaults ??= /* @__PURE__ */ new Map();
+		if (cache.has(field)) return cache.get(field);
+		const value = this._parseValueDefault(field, literal);
+		if (value === null || typeof value !== "object") cache.set(field, value);
+		return value;
+	}
+	/**
 	* The JS value for a `@db.default 'literal'`: strings (including unions of
 	* string literals) are used as-is, every other design type is parsed as
 	* JSON — the same value the SQL adapters put into the DDL `DEFAULT` clause.
@@ -7789,6 +7979,7 @@ function extractFieldSnapshots(readable, typeMapper) {
 			jsonPath: [...f.derived.jsonPath],
 			type: f.derived.type
 		};
+		if (f.collate && f.collate !== "binary") snap.collate = f.collate;
 		return snap;
 	}).toSorted((a, b) => a.physicalName.localeCompare(b.physicalName));
 }

package/dist/{fk-diff-CCLiJ9sJ.d.cts → fk-diff-Bw26lwSc.d.cts}

@@ -1,4 +1,4 @@
-import { B as TDbDefaultValue, H as TDbFieldMeta, U as TDbForeignKey, _t as TExistingTableOption, bn as AtscriptDbReadable, cn as AtscriptQueryFieldRef, en as AtscriptDbView, ht as TExistingColumn, k as TColumnDiff, ln as AtscriptQueryNode, pt as TDerivedColumn, rt as TDbStorageType } from "./buckets-24Ac4sIS.cjs";
+import { B as TDbDefaultValue, H as TDbFieldMeta, R as TDbCollation, U as TDbForeignKey, _t as TExistingTableOption, bn as AtscriptDbReadable, cn as AtscriptQueryFieldRef, en as AtscriptDbView, ht as TExistingColumn, k as TColumnDiff, ln as AtscriptQueryNode, pt as TDerivedColumn, rt as TDbStorageType } from "./buckets-tzd8iIM2.cjs";
 
 //#region src/schema/schema-hash.d.ts
 interface TFieldSnapshot {
@@ -21,6 +21,13 @@ interface TFieldSnapshot {
    * @since 0.1.141
    */
   derived?: Omit<TDerivedColumn, "sourcePath">;
+  /**
+   * A non-binary `@db.column.collate` — changing it changes the snapshot hash
+   * on every adapter (MongoDB builds the field's indexes with its collation).
+   * Absent for byte-wise fields, so a table without one hashes as before.
+   * @since 0.1.151
+   */
+  collate?: TDbCollation;
 }
 interface TIndexSnapshot {
   key: string;

package/dist/{fk-diff-R8eU7gq-.d.mts → fk-diff-lcAnwvm9.d.mts}

@@ -1,4 +1,4 @@
-import { B as TDbDefaultValue, H as TDbFieldMeta, U as TDbForeignKey, _t as TExistingTableOption, bn as AtscriptDbReadable, cn as AtscriptQueryFieldRef, en as AtscriptDbView, ht as TExistingColumn, k as TColumnDiff, ln as AtscriptQueryNode, pt as TDerivedColumn, rt as TDbStorageType } from "./buckets-XOz0Bw5x.mjs";
+import { B as TDbDefaultValue, H as TDbFieldMeta, R as TDbCollation, U as TDbForeignKey, _t as TExistingTableOption, bn as AtscriptDbReadable, cn as AtscriptQueryFieldRef, en as AtscriptDbView, ht as TExistingColumn, k as TColumnDiff, ln as AtscriptQueryNode, pt as TDerivedColumn, rt as TDbStorageType } from "./buckets-Cb0zmhDc.mjs";
 
 //#region src/schema/schema-hash.d.ts
 interface TFieldSnapshot {
@@ -21,6 +21,13 @@ interface TFieldSnapshot {
    * @since 0.1.141
    */
   derived?: Omit<TDerivedColumn, "sourcePath">;
+  /**
+   * A non-binary `@db.column.collate` — changing it changes the snapshot hash
+   * on every adapter (MongoDB builds the field's indexes with its collation).
+   * Absent for byte-wise fields, so a table without one hashes as before.
+   * @since 0.1.151
+   */
+  collate?: TDbCollation;
 }
 interface TIndexSnapshot {
   key: string;

package/dist/index.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_db_error = require("./db-error-DRQH4sLY.cjs");
-const require_column_diff = require("./column-diff-CKKBVDvx.cjs");
+const require_column_diff = require("./column-diff-CU7KHj9-.cjs");
 const require_aggregate_fns = require("./aggregate-fns-C-UJRobm.cjs");
-const require_nested_writer = require("./nested-writer-BUQvk6QT.cjs");
+const require_nested_writer = require("./nested-writer-BzbOPSUp.cjs");
 const require_search_fields = require("./search-fields-DwrsJUC1.cjs");
 const require_object = require("./object-Djg28csK.cjs");
 const require_consts = require("./consts-BzRfCcH2.cjs");
@@ -236,6 +236,12 @@ var DbSpace = class {
 	_readables = /* @__PURE__ */ new WeakMap();
 	/** All tables created in this space — used for reverse FK lookup during cascade. */
 	_allTables = /* @__PURE__ */ new Set();
+	/**
+	* Per-table-name memo of {@link _getCascadeTargets} / {@link _getFkLookupTarget}
+	* (since 0.1.151) — both scan every table; cleared whenever a table is added.
+	*/
+	_cascadeTargets = /* @__PURE__ */ new Map();
+	_fkLookupTargets = /* @__PURE__ */ new Map();
 	/** Every table / view handle the space created — flagged closed on {@link close}. */
 	_handles = /* @__PURE__ */ new Set();
 	/** Lazily created adapter for administrative ops (drop table/view) that don't need a registered readable. */
@@ -285,6 +291,8 @@ var DbSpace = class {
 				return resolved instanceof require_column_diff.AtscriptDbTable ? resolved : void 0;
 			});
 			this._allTables.add(readable);
+			this._cascadeTargets.clear();
+			this._fkLookupTargets.clear();
 			readable.setCascadeResolver((tableName) => this._getCascadeTargets(tableName));
 			readable.setFkLookupResolver((tableName) => this._getFkLookupTarget(tableName));
 			readable.setEncryption(this._encryption);
@@ -413,6 +421,14 @@ var DbSpace = class {
 	* Accesses `table.foreignKeys` which triggers `_flatten()` if needed.
 	*/
 	_getCascadeTargets(tableName) {
+		let targets = this._cascadeTargets.get(tableName);
+		if (targets === void 0) {
+			targets = this._scanCascadeTargets(tableName);
+			this._cascadeTargets.set(tableName, targets);
+		}
+		return targets;
+	}
+	_scanCascadeTargets(tableName) {
 		const targets = [];
 		for (const table of this._allTables) for (const fk of table.foreignKeys.values()) if (fk.targetTable === tableName && fk.onDelete) targets.push({
 			fk,
@@ -428,6 +444,12 @@ var DbSpace = class {
 	* Searches all registered tables for one with the matching table name.
 	*/
 	_getFkLookupTarget(tableName) {
+		if (this._fkLookupTargets.has(tableName)) return this._fkLookupTargets.get(tableName);
+		const target = this._scanFkLookupTarget(tableName);
+		this._fkLookupTargets.set(tableName, target);
+		return target;
+	}
+	_scanFkLookupTarget(tableName) {
 		for (const table of this._allTables) if (table.tableName === tableName) return { count: (filter) => table.count({ filter }) };
 	}
 };