bazis 0.98.16 → 0.98.18

package/core/infra/connectors/codex/CodexAppServerClient.ts

@@ -232,7 +232,7 @@ export class CodexAppServerClient implements CodexClient {
         if (method === "account/updated") this.modelCache = undefined;
       }, () => { this.clearLogin(); this.modelCache = undefined; });
       const initialized = await client.request("initialize", {
-        clientInfo: { name: "bazis", title: "Bazis", version: "0.98.16" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.98.18" }, capabilities: { experimentalApi: true },
       }, 15_000, signal);
       if (resolve(text(initialized.codexHome, 4096)) !== this.paths.home) throw new CodexError("PROTOCOL_ERROR");
       client.notify("initialized");

package/library/orm/Providers/PostgresProvider.ts

@@ -828,6 +828,7 @@ export class PostgresProvider implements DatabaseProvider {
     let result!: T;
     let failure: unknown;
     try {
+      this.traceSql("BEGIN", []);
       await this.ownerCommand(owner, "BEGIN");
       await this.configureSession(owner);
       result = await this.transactionCallbacks.run(callbacks, () => this.ambient.run({ executor, session: owner.session, owner }, async () => {
@@ -837,6 +838,7 @@ export class PostgresProvider implements DatabaseProvider {
       }));
       operation.signal.throwIfAborted();
       committing = true;
+      this.traceSql("COMMIT", []);
       await this.ownerCommand(owner, "COMMIT");
       committed = true;
     } catch (error) {
@@ -850,6 +852,7 @@ export class PostgresProvider implements DatabaseProvider {
           if (operation.signal.aborted || owner.quarantinePromise) await this.quarantineOwner(owner);
           else {
             const cleanup = new OperationDeadline(this.cancellationTimeoutMs);
+            this.traceSql("ROLLBACK", []);
             try { await cleanup.wait(this.native(() => owner.session.unsafe("ROLLBACK"))); }
             catch { await this.quarantineOwner(owner); }
             finally { cleanup.dispose(); }
@@ -1265,6 +1268,7 @@ export class PostgresProvider implements DatabaseProvider {
     const rollback = async () => {
       // No further owner dispatch can pass the synchronous quarantine fence.
       await deadline.wait(Promise.allSettled([...(owner.pending ?? [])]));
+      this.traceSql("ROLLBACK", []);
       await deadline.wait(this.native(() => { deadline.signal.throwIfAborted(); return owner.session.unsafe("ROLLBACK"); }, true));
       const current = await this.readBackendIdentity(owner.session, deadline);
       if (Object.entries(identity).some(([key, value]) => current[key as keyof BackendIdentity] !== value)) throw new OrmTransactionScopeError("PostgreSQL rollback backend identity changed.");

package/library/orm/Providers/operationDeadline.ts

@@ -11,11 +11,12 @@ export class OperationDeadline {
   readonly controller = new AbortController();
   readonly signal = this.controller.signal;
   private readonly timer: ReturnType<typeof setTimeout>;
-  private readonly onAbort = () => this.controller.abort(new OrmTransactionScopeError("ORM operation was aborted."));
+  // A parent deadline's reason (for example a scope timeout) survives nesting.
+  private readonly onAbort = () => this.controller.abort(this.parent?.reason instanceof OrmTransactionScopeError ? this.parent.reason : new OrmTransactionScopeError(`${this.label} was aborted.`));
 
-  constructor(timeoutMs: number, private readonly parent?: AbortSignal) {
+  constructor(timeoutMs: number, private readonly parent?: AbortSignal, private readonly label = "ORM operation") {
     if (parent !== undefined && !(parent instanceof AbortSignal)) throw new TypeError("signal must be an AbortSignal.");
-    this.timer = setTimeout(() => this.controller.abort(new OrmTransactionScopeError("ORM operation deadline exceeded.")), timeoutMs);
+    this.timer = setTimeout(() => this.controller.abort(new OrmTransactionScopeError(`${label} timed out after ${timeoutMs} ms.`)), timeoutMs);
     if (parent?.aborted) this.onAbort();
     else parent?.addEventListener("abort", this.onAbort, { once: true });
   }

package/library/orm/Query/EntityQuery.ts

@@ -207,6 +207,8 @@ export class EntityQuery<T extends object, TResult = T> {
 }
 
 function assertSkipLocked(model: EntityModel, runtime: DbContextRuntime, plan: QueryPlan, terminal: "toList" | "count"): void {
+  // Outside a transaction PostgreSQL releases the lock right after the SELECT.
+  if (plan.rowLock && !plan.skipLocked && runtime.provider.isTransactionActive?.() !== true) throw new Error("forUpdate() locks rows only until the surrounding transaction ends; outside a transaction the lock is released right after the SELECT. Run the read and the following saveChanges() inside db.transactionScope(async () => { ... }).");
   if (!plan.skipLocked) return;
   if (terminal !== "toList" || runtime.provider.isTransactionActive?.() !== true || plan.conditions.length === 0 || plan.invalidRequestedLimit !== undefined || !Number.isSafeInteger(plan.limit) || plan.limit! <= 0 || plan.requestedLimit !== undefined && plan.requestedLimit !== plan.limit || plan.offset !== undefined || plan.projections.length !== 0 || plan.includes.length !== 0) throw new Error("FOR UPDATE SKIP LOCKED requires an active transaction, where, positive take, and terminal materialization.");
   const ordered = new Set(plan.orders.map((order) => order.property));

package/library/orm/Saving/SaveExecutor.ts

@@ -7,7 +7,8 @@ import type { DatabaseProvider, DbExecutor } from "../Providers/types";
 import { isUnknownTransactionOutcome, registerTransactionUncertainty, TransactionOutcomeUnknownError } from "../Providers/transactionOutcome";
 import { registerPostCommitFinalizer } from "../Providers/transactionCallbacks";
 import { EntityState } from "../Tracking/EntityState";
-import { assertUniqueTrackedKeys, holdDeletedIdentity, type ChangeTracker, type TrackedEntry } from "../Tracking/ChangeTracker";
+import { assertUniqueTrackedKeys, holdDeletedIdentity, trackedEntriesOf, type ChangeTracker, type TrackedEntry } from "../Tracking/ChangeTracker";
+import { NavigationFixup } from "./navigationFixup";
 import { CommandBuilder } from "./CommandBuilder";
 import { applyConventions } from "./applyConventions";
 import { ExecutionStrategy, type ExecutionStrategyOptions } from "./ExecutionStrategy";
@@ -78,6 +79,10 @@ export class SaveExecutor {
 
   private async saveCore(): Promise<number> {
     if (uncertainTrackers.has(this.tracker)) throw new TransactionOutcomeUnknownError();
+    // Foreign keys from navigations first, so a changed navigation on an
+    // Unchanged entity is detected as a Modified foreign key.
+    const fixup = new NavigationFixup(trackedEntriesOf(this.tracker));
+    fixup.applyAll();
     this.tracker.detectChanges();
     const pending = this.tracker.entriesToProcess();
     if (pending.length === 0) {
@@ -127,9 +132,14 @@ export class SaveExecutor {
               group.push(ordered[i]!);
               i += 1;
             }
+            // Parents are inserted first: their generated keys are known now.
+            for (const added of group) fixup.apply(added);
             await this.insertBatch(tx, entry.model, group);
             continue;
           }
+          if (entry.state === EntityState.Modified) {
+            for (const name of fixup.apply(entry)) entry.modifiedProperties.add(name);
+          }
           await this.execute(tx, entry);
           i += 1;
         }

package/library/orm/Saving/navigationFixup.ts

@@ -0,0 +1,80 @@
+import { EntityState } from "../Tracking/EntityState";
+import type { TrackedEntry } from "../Tracking/ChangeTracker";
+
+type Values = Record<string, unknown>;
+
+/**
+ * Foreign keys from navigations, as EF Core's relationship fix-up does:
+ * `article.author = bob` (a `@ManyToOne`) or `bob.articles.push(article)`
+ * (a `@OneToMany`) set `article.authorId` from `bob`'s key. Only navigations to
+ * entities tracked by the same context are followed; the navigation wins over
+ * a different value in the foreign key property.
+ */
+export class NavigationFixup {
+  /** child entity -> the parents whose collection holds it. */
+  private readonly parents = new Map<object, { readonly parent: TrackedEntry; readonly foreignKey: readonly string[] }[]>();
+
+  constructor(private readonly entries: ReadonlyMap<object, TrackedEntry>) {
+    for (const entry of entries.values()) {
+      for (const relation of entry.model.relations) {
+        if (relation.kind !== "collection") continue;
+        const children = (entry.entity as Values)[relation.navigationName];
+        if (!Array.isArray(children)) continue;
+        for (const child of children) {
+          if (child === null || typeof child !== "object" || !entries.has(child)) continue;
+          const list = this.parents.get(child) ?? [];
+          list.push({ parent: entry, foreignKey: toArray(relation.foreignKey) });
+          this.parents.set(child, list);
+        }
+      }
+    }
+  }
+
+  /** Applies the fix-up to every tracked entry (before change detection). */
+  applyAll(): void {
+    for (const entry of this.entries.values()) {
+      if (entry.state !== EntityState.Deleted) this.apply(entry);
+    }
+  }
+
+  /**
+   * Applies the fix-up to one entry and returns the foreign key properties it
+   * changed. Called again right before the entry's SQL, when the keys the
+   * database generated for its parents are known.
+   */
+  apply(entry: TrackedEntry): readonly string[] {
+    const changed: string[] = [];
+    const entity = entry.entity as Values;
+    for (const relation of entry.model.relations) {
+      if (relation.kind !== "reference") continue;
+      const target = entity[relation.navigationName];
+      if (target === null || typeof target !== "object") continue;
+      const targetEntry = this.entries.get(target);
+      if (targetEntry === undefined) continue;
+      this.copyKey(entity, toArray(relation.foreignKey), targetEntry, changed);
+    }
+    for (const { parent, foreignKey } of this.parents.get(entry.entity) ?? []) {
+      if (parent.state === EntityState.Deleted) continue;
+      this.copyKey(entity, foreignKey, parent, changed);
+    }
+    return changed;
+  }
+
+  private copyKey(entity: Values, foreignKey: readonly string[], target: TrackedEntry, changed: string[]): void {
+    const key = target.model.key;
+    if (key.length !== foreignKey.length) return;
+    const source = target.entity as Values;
+    key.forEach((property, index) => {
+      const name = foreignKey[index]!;
+      const value = source[property.propertyName];
+      if (entity[name] !== value) {
+        entity[name] = value;
+        changed.push(name);
+      }
+    });
+  }
+}
+
+function toArray(value: string | readonly string[]): readonly string[] {
+  return typeof value === "string" ? [value] : value;
+}

package/library/orm/Tracking/ChangeTracker.ts

@@ -342,6 +342,11 @@ export class ChangeTracker {
   }
 }
 
+/** Non-barrel access to every tracked entry, for the save-time navigation fix-up. */
+export function trackedEntriesOf(tracker: ChangeTracker): ReadonlyMap<object, TrackedEntry> {
+  return trackerEntries.get(tracker) ?? new Map();
+}
+
 /** Non-barrel helper used only by immediate DML admission. */
 export function hasTrackedEntriesForModel(tracker: ChangeTracker, model: EntityModel): boolean {
   return [...(trackerEntries.get(tracker)?.values() ?? [])].some((entry) => entry.model === model);

package/library/orm/Transactions/TransactionScopeCoordinator.ts

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import type { DbContext } from "../DbContext";
-import { ConcurrentTransactionScopeError, OrmDatabaseTimeError, OrmProviderIdentityMismatchError, OrmTransactionScopeError } from "../errors";
+import { ConcurrentTransactionScopeError, differentProviderMessage, OrmDatabaseTimeError, OrmProviderIdentityMismatchError, OrmTransactionScopeError } from "../errors";
 import { baseProvider, withPostgresScopeOptions, createObservedProvider, postgresTransactionCapability, rootAuthority, withProviderDispatchObserver, withoutProviderDispatchObserver, type CancellableProviderDispatch } from "../Providers/ormTransactionRuntime";
 import type { DatabaseProvider } from "../Providers/types";
 import { OrmTransaction, type OrmDatabaseTimeV1, type OrmTransactionScopeOptions } from "./OrmTransaction";
@@ -47,6 +47,27 @@ const uncertainContexts = new WeakSet<object>();
 const contextTokens = new WeakMap<object, object>();
 const contextProviders = new WeakMap<object, DatabaseProvider>();
 
+const contextName = (context: object): string => (context.constructor as { readonly name?: string } | undefined)?.name || "This DbContext";
+const scopeClosed = () => new OrmTransactionScopeError("ORM transaction scope has already finished or is closing; await every ORM call inside the scope callback.");
+const nestedScopeRunning = () => new OrmTransactionScopeError("A nested transaction scope is still running; await it before using the outer scope.");
+const notEnrolled = (context: object) => new OrmTransactionScopeError(`${contextName(context)} is not part of the surrounding transaction scope. Run it through tx.use(context, work) to share the transaction, or use it after the scope.`);
+
+/** Explains why `context` cannot run ORM work in the current scope view. */
+function scopeRejection(context: object, view: View): OrmTransactionScopeError {
+  const provider = contextProviders.get(context);
+  if (provider && rootAuthority(provider) !== view.frame.authority) return new OrmTransactionScopeError(differentProviderMessage(contextName(context)));
+  if (!view.enrolled.has(contextToken(context))) return notEnrolled(context);
+  if (view.frame.state !== "active") return scopeClosed();
+  return view.frame.activeChild !== undefined ? nestedScopeRunning() : new OrmTransactionScopeError();
+}
+
+/** A failed operation dooms its scope; a callback that caught the error still learns why. */
+function operationFailed(error: unknown): OrmTransactionScopeError {
+  if (error instanceof OrmTransactionScopeError) return error;
+  const reason = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+  return new OrmTransactionScopeError(`ORM transaction scope was rolled back because an operation inside it failed: ${reason}. A failed operation marks the whole scope for rollback even when its error is caught; to continue after an expected failure, run that operation in a nested transactionScope().`, { cause: error });
+}
+
 /** Private, non-barrel signal: SaveExecutor uses it to suppress retries only
  * in a coordinator-owned ORM scope, never in arbitrary provider transactions. */
 export function isNewOrmTransactionScopeActive(): boolean {
@@ -69,7 +90,7 @@ export function observedProvider(context: object, provider: DatabaseProvider): D
     if (!view) return guarded();
     const frame = view.frame;
     if (frame.authority !== authority || !view.enrolled.has(token) || frame.state !== "active" || frame.activeChild !== undefined) {
-      return Promise.reject(new OrmTransactionScopeError());
+      return Promise.reject(scopeRejection(context, view));
     }
     return trackTask(frame, guarded);
   };
@@ -87,7 +108,7 @@ export function monitorWholeOperation<T>(context: object, operation: () => Promi
   if (uncertainContexts.has(contextToken(context))) return Promise.reject(new TransactionOutcomeUnknownError());
   const view = views.getStore();
   if (!view) return operation();
-  if (!view.enrolled.has(contextToken(context)) || view.frame.state !== "active" || view.frame.activeChild !== undefined) return Promise.reject(new OrmTransactionScopeError());
+  if (!view.enrolled.has(contextToken(context)) || view.frame.state !== "active" || view.frame.activeChild !== undefined) return Promise.reject(scopeRejection(context, view));
   // Save work must not inherit a forever `use` callback task: only its
   // post-validation unwind is framework-owned during physical quarantine.
   return trackTask(view.frame, operation, "save", true);
@@ -99,11 +120,11 @@ export function monitorImmediateOperation<T>(context: object, operation: () => T
   const view = views.getStore();
   const token = contextToken(context);
   const run = () => Promise.resolve().then(() => {
-    if (view && (!view.enrolled.has(token) || view.frame.state !== "active" || view.frame.activeChild !== undefined)) throw new OrmTransactionScopeError();
+    if (view && (!view.enrolled.has(token) || view.frame.state !== "active" || view.frame.activeChild !== undefined)) throw scopeRejection(context, view);
     return operation();
   });
   if (!view) return run();
-  if (!view.enrolled.has(token) || view.frame.state !== "active" || view.frame.activeChild !== undefined) return Promise.reject(new OrmTransactionScopeError());
+  if (!view.enrolled.has(token) || view.frame.state !== "active" || view.frame.activeChild !== undefined) return Promise.reject(scopeRejection(context, view));
   return trackTask(view.frame, run, "immediate", true);
 }
 
@@ -123,9 +144,9 @@ export function markCurrentSaveRequiresUnwind(): void {
 function trackTask<T>(frame: Frame, operation: () => Promise<T>, kind: PendingTask["kind"] = "user", distinct = false): Promise<T> {
   const parent = currentTasks.getStore();
   if (!distinct && parent?.frame === frame && frame.pending.has(parent)) {
-    const promise = Promise.resolve().then(() => { if (frame.state !== "active") throw new OrmTransactionScopeError(); return operation(); });
+    const promise = Promise.resolve().then(() => { if (frame.state !== "active") throw scopeClosed(); return operation(); });
     parent.attached.add(promise);
-    void promise.catch(() => { frame.rollbackOnly ??= new OrmTransactionScopeError(); });
+    void promise.catch((error) => { frame.rollbackOnly ??= operationFailed(error); });
     promise.finally(() => { parent.attached.delete(promise); releaseTask(parent); }).catch(() => {});
     return Promise.race([promise, frame.abortPromise]);
   }
@@ -134,12 +155,12 @@ function trackTask<T>(frame: Frame, operation: () => Promise<T>, kind: PendingTa
   const task: PendingTask = { frame, kind, dispatches: new Set(), attached: new Set(), promise: Promise.resolve(), underlying: Promise.resolve(), abort, settled: false };
   frame.pending.add(task);
   const underlying = Promise.resolve().then(() => {
-    if (frame.state !== "active") throw new OrmTransactionScopeError();
+    if (frame.state !== "active") throw scopeClosed();
     return currentTasks.run(task, operation);
   });
   task.promise = underlying;
   (task as { underlying: Promise<unknown> }).underlying = underlying;
-  void underlying.catch(() => { frame.rollbackOnly ??= new OrmTransactionScopeError(); });
+  void underlying.catch((error) => { frame.rollbackOnly ??= operationFailed(error); });
   underlying.finally(() => { task.settled = true; releaseTask(task); }).catch(() => {});
   // Permanent rejection sink makes detached hostile user tails safe.
   void abortProjection.catch(() => {});
@@ -154,14 +175,17 @@ export async function transactionScope<TResult>(context: DbContext, provider: Da
   let signal = options?.signal;
   if (options?.timeoutMs !== undefined) positiveTimeout(options.timeoutMs, 30_000, "timeoutMs");
   if (signal !== undefined && !(signal instanceof AbortSignal)) throw new TypeError("ORM transaction signal must be an AbortSignal.");
-  const assertNotAborted = () => { if (signal?.aborted) throw new OrmTransactionScopeError("ORM transaction scope was aborted."); };
+  const abortReason = () => signal?.reason instanceof OrmTransactionScopeError ? signal.reason : new OrmTransactionScopeError("ORM transaction scope was aborted.");
+  const assertNotAborted = () => { if (signal?.aborted) throw abortReason(); };
   assertNotAborted();
   const token = contextToken(context);
   if (uncertainContexts.has(token)) throw new TransactionOutcomeUnknownError();
   const authority = rootAuthority(provider);
   const current = views.getStore();
   if (current) {
-    if (current.frame.authority !== authority || !current.enrolled.has(token) || current.frame.state !== "active") throw new OrmProviderIdentityMismatchError();
+    if (current.frame.authority !== authority) throw new OrmProviderIdentityMismatchError(contextName(context));
+    if (!current.enrolled.has(token)) throw notEnrolled(context);
+    if (current.frame.state !== "active") throw scopeClosed();
     if (current.frame.activeChild !== undefined) throw new ConcurrentTransactionScopeError();
   }
   const base = baseProvider(provider);
@@ -171,7 +195,7 @@ export async function transactionScope<TResult>(context: DbContext, provider: Da
   const uncertain = (error: unknown) => postgres.isOutcomeUncertain ? postgres.isOutcomeUncertain(error) : isUnknownTransactionOutcome(error);
   const inheritedSignal = postgres.operationSignal?.();
   const timeoutMs = positiveTimeout(options?.timeoutMs, postgres.operationTimeoutMs ?? 30_000, "timeoutMs");
-  const deadline = new OperationDeadline(timeoutMs, signal && inheritedSignal ? AbortSignal.any([signal, inheritedSignal]) : signal ?? inheritedSignal);
+  const deadline = new OperationDeadline(timeoutMs, signal && inheritedSignal ? AbortSignal.any([signal, inheritedSignal]) : signal ?? inheritedSignal, "ORM transaction scope");
   signal = deadline.signal;
   const parent = current?.frame;
   const ownership = Symbol("orm transaction child");
@@ -210,7 +234,7 @@ export async function transactionScope<TResult>(context: DbContext, provider: Da
       return withProviderDispatchObserver((dispatch) => registerDispatch(frame, dispatch), () => views.run(view, async () => {
         const transaction = new ScopedOrmTransaction(frame);
         const onAbort = () => {
-          const error = new OrmTransactionScopeError("ORM transaction scope was aborted.");
+          const error = abortReason();
           // Fence synchronously: a callback catching its aborted operation
           // cannot enqueue another query before asynchronous close starts.
           for (let target: Frame | undefined = frame; target; target = target.activeChildFrame) {
@@ -286,13 +310,13 @@ function registerDispatch(frame: Frame, dispatch: CancellableProviderDispatch):
   const settled = Promise.resolve(dispatch.settled);
   // Keep a rejection sink for detached driver promises while preserving the
   // original caller-facing rejection returned by query/execute.
-  void settled.catch(() => { frame.rollbackOnly ??= new OrmTransactionScopeError(); });
+  void settled.catch((error) => { frame.rollbackOnly ??= operationFailed(error); });
   settled.finally(() => { task.dispatches.delete(dispatch); releaseTask(task); }).catch(() => {});
 }
 
 async function settleFrame(frame: Frame): Promise<void> {
   if (frame.pending.size === 0) return;
-  frame.rollbackOnly ??= new OrmTransactionScopeError("ORM transaction scope has unresolved operations.");
+  frame.rollbackOnly ??= new OrmTransactionScopeError("ORM transaction scope callback returned while ORM operations were still running, so the scope was rolled back; await every ORM call inside the scope callback.");
   const capability = postgresTransactionCapability(frame.provider);
   const hasDispatch = [...frame.pending].some((task) => task.dispatches.size > 0);
   let quarantine = frame.cancellationRequested || (capability?.quarantineOnPendingDispatch && hasDispatch);
@@ -335,6 +359,7 @@ async function settleFrame(frame: Frame): Promise<void> {
   }
 }
 
+const foreignTransaction = () => new OrmTransactionScopeError("This transaction object belongs to another transaction scope; use the object passed to the innermost transactionScope() callback.");
 const transactionFrames = new WeakMap<ScopedOrmTransaction, Frame>();
 class ScopedOrmTransaction extends OrmTransaction {
   constructor(frame: Frame) { super(); transactionFrames.set(this, frame); }
@@ -343,9 +368,9 @@ class ScopedOrmTransaction extends OrmTransaction {
     const frame = this.#requireCurrentFrame();
     const token = contextToken(context);
     const provider = contextProviders.get(context);
-    if (!provider || rootAuthority(provider) !== frame.authority) throw new OrmProviderIdentityMismatchError();
+    if (!provider || rootAuthority(provider) !== frame.authority) throw new OrmProviderIdentityMismatchError(contextName(context));
     const parent = views.getStore();
-    if (!parent || parent.frame !== frame) throw new OrmTransactionScopeError();
+    if (!parent || parent.frame !== frame) throw foreignTransaction();
     if (uncertainContexts.has(token)) throw new TransactionOutcomeUnknownError();
     for (let target: Frame | undefined = frame; target; target = target.parent) target.allEnrolled.add(token);
     const enrolled = new Set(parent.enrolled); enrolled.add(token);
@@ -371,7 +396,9 @@ class ScopedOrmTransaction extends OrmTransaction {
   #requireCurrentFrame(): Frame {
     const frame = transactionFrames.get(this);
     const view = views.getStore();
-    if (!frame || frame.state !== "active" || frame.activeChild !== undefined || !view || view.frame !== frame) throw new OrmTransactionScopeError();
+    if (!frame || frame.state !== "active") throw new OrmTransactionScopeError("ORM transaction scope has already finished or is closing; use the transaction object only inside its transactionScope() callback.");
+    if (frame.activeChild !== undefined) throw nestedScopeRunning();
+    if (!view || view.frame !== frame) throw foreignTransaction();
     return frame;
   }
 }

package/library/orm/errors.ts

@@ -119,12 +119,16 @@ export class ConcurrentTransactionScopeError extends OrmError {
 
 /** Safe failure for a stale, closing, or unenrolled ORM transaction capability. */
 export class OrmTransactionScopeError extends OrmError {
-  constructor(message = "ORM transaction scope is not active for this operation.") { super(message); }
+  constructor(message = "ORM transaction scope is not active for this operation.", options?: ErrorOptions) { super(message, options); }
 }
 
 /** Contexts may share transaction work only when their configured provider is the same object. */
 export class OrmProviderIdentityMismatchError extends OrmError {
-  constructor() { super("ORM transaction context belongs to a different provider identity."); }
+  constructor(contextName = "This DbContext") { super(differentProviderMessage(contextName)); }
+}
+
+export function differentProviderMessage(contextName: string): string {
+  return `${contextName} uses a different database provider than the surrounding transaction scope. Contexts share one transaction only when they are created with the same provider object.`;
 }
 
 /** The provider did not return an exact safe millisecond database timestamp. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bazis",
-  "version": "0.98.16",
+  "version": "0.98.18",
   "description": "Modular backend framework for Bun in TypeScript: DI wired by codegen, HTTP, a PostgreSQL ORM, JWT, WebSocket, agents and a CLI.",
   "license": "MIT",
   "author": "Alexander Alenin",