@lossless.org/client 1.12.0 → 1.14.0

package/dist_ts/nosqldb/classes.session.js

@@ -1,7 +1,23 @@
 import * as plugins from './plugins.js';
 import { SmartdataOperationDeadline, requireOperationSignal, requireOperationTimeoutMS, } from './classes.operationdeadline.js';
 import { assertDataOptions } from './classes.operationbudget.js';
-import { SmartdataPersistenceError, createSmartdataTimeoutError, isMongoDeadlineError, normalizeDeadlineError, normalizeOrdinaryPersistenceError, } from './classes.persistence.js';
+import { SmartdataPersistenceError, createSmartdataTimeoutError, isMongoDeadlineError, isMongoTransientTransactionError, normalizeDeadlineError, normalizeOrdinaryPersistenceError, } from './classes.persistence.js';
+/** The commit outcome of every value a `withTransaction()` call rejected with. */
+const transactionCommitOutcomes = new WeakMap();
+/**
+ * Records what `errorArg`, the rejection of a `withTransaction()` call, means
+ * for the commit, and returns it for the throw. A value several transactions
+ * rejected with keeps `unknown` once any of them may have committed. A
+ * primitive cannot be recorded.
+ */
+const rejectTransaction = (errorArg, outcomeArg) => {
+    if (((typeof errorArg === 'object' && errorArg !== null) || typeof errorArg === 'function')
+        && transactionCommitOutcomes.get(errorArg) !== 'unknown') {
+        transactionCommitOutcomes.set(errorArg, outcomeArg);
+    }
+    return errorArg;
+};
+const commitOutcomeOfTransactionEnd = (endArg) => endArg === 'during_commit' ? 'unknown' : 'not_committed';
 /**
  * The session of a transaction ended while it ran, for example through the
  * database's `close()`. The driver then returns the callback's result without
@@ -41,12 +57,43 @@ const normalizeTransactionOptions = (optionsArg) => {
         signal: requireOperationSignal(signal, 'SmartData transaction signal'),
     };
 };
+/** Everything `withTransaction()` refuses before a transaction starts. */
+const admitTransaction = (sessionArg, callbackArg, optionsArg) => {
+    if (typeof callbackArg !== 'function') {
+        throw new SmartdataPersistenceError('invalid_argument', 'SmartData transaction callback must be a function.');
+    }
+    const { timeoutMS, signal } = normalizeTransactionOptions(optionsArg);
+    const binding = resolveBinding(sessionArg);
+    if (binding.operationActive || binding.transactionActive) {
+        throw new SmartdataPersistenceError('unsupported_operation', 'Parallel or nested SmartData session operations are not supported.');
+    }
+    signal?.throwIfAborted();
+    return { binding, timeoutMS, signal };
+};
 const assertTransactionSucceeded = (bindingArg) => {
     if (bindingArg.transactionFailure) {
         throw bindingArg.transactionFailure.error;
     }
 };
 export class SmartdataSession {
+    /**
+     * Whether the transaction whose `withTransaction()` call rejected with
+     * `errorArg` could have committed: `not_committed` when nothing of it was
+     * committed, `unknown` when a commit was sent and never confirmed, so it may
+     * have applied. Every rejection of `withTransaction()` carries one, whatever
+     * it is: the client's own errors, the callback's error, the abort reason or
+     * a driver error, which all keep their identity. A value several calls
+     * rejected with reads `unknown` once any of them may have committed.
+     *
+     * Returns `undefined` for any other value, and for a primitive rejection —
+     * a callback that throws a string, or a string abort reason — which cannot
+     * carry the outcome; treat `undefined` as `unknown`.
+     */
+    static getCommitOutcome(errorArg) {
+        return (typeof errorArg === 'object' && errorArg !== null) || typeof errorArg === 'function'
+            ? transactionCommitOutcomes.get(errorArg)
+            : undefined;
+    }
     /**
      * Runs `callbackArg` in a transaction, retrying it as the driver decides.
      *
@@ -78,17 +125,20 @@ export class SmartdataSession {
      * `unsupported_operation`: before the callback returned nothing was
      * committed, afterwards the commit outcome is unknown. The callback's
      * error, if it threw, is the `cause`.
+     *
+     * Every rejection states whether the transaction could have committed:
+     * `SmartdataSession.getCommitOutcome(error)` returns `not_committed` or
+     * `unknown` for the value the call rejected with.
      */
     async withTransaction(callbackArg, optionsArg) {
-        if (typeof callbackArg !== 'function') {
-            throw new SmartdataPersistenceError('invalid_argument', 'SmartData transaction callback must be a function.');
+        let admitted;
+        try {
+            admitted = admitTransaction(this, callbackArg, optionsArg);
         }
-        const { timeoutMS, signal } = normalizeTransactionOptions(optionsArg);
-        const binding = resolveBinding(this);
-        if (binding.operationActive || binding.transactionActive) {
-            throw new SmartdataPersistenceError('unsupported_operation', 'Parallel or nested SmartData session operations are not supported.');
+        catch (errorArg) {
+            throw rejectTransaction(errorArg, 'not_committed');
         }
-        signal?.throwIfAborted();
+        const { binding, timeoutMS, signal } = admitted;
         binding.transactionActive = true;
         binding.transactionTimeoutMS = timeoutMS;
         binding.transactionSignal = signal;
@@ -96,7 +146,8 @@ export class SmartdataSession {
         let callbackError;
         /** The signal or deadline interruption that failed the last attempt. */
         let attemptInterruption;
-        let sessionEndedError;
+        /** The session-ended rejection the last attempt failed with, and how far that transaction had got. */
+        let sessionEnded;
         const runAttempt = async () => {
             const attempt = Symbol('smartdataTransactionAttempt');
             binding.transactionAttempt = attempt;
@@ -136,8 +187,11 @@ export class SmartdataSession {
                     if (binding.transactionEnded) {
                         // The driver would commit or return the result on a session that is
                         // being ended; the attempt fails instead, keeping the callback's error.
-                        sessionEndedError = createTransactionSessionEndedError(binding.transactionEnded, callbackThrown?.error);
-                        throw sessionEndedError;
+                        sessionEnded = {
+                            error: createTransactionSessionEndedError(binding.transactionEnded, callbackThrown?.error),
+                            end: binding.transactionEnded,
+                        };
+                        throw sessionEnded.error;
                     }
                     if (callbackReturned && activeOperation) {
                         throw new SmartdataPersistenceError('unsupported_operation', 'A SmartData transaction callback returned with an operation still active.');
@@ -158,42 +212,70 @@ export class SmartdataSession {
                 throw errorArg;
             }
         };
-        let result;
-        let transactionEnded;
-        try {
-            result = timeoutMS === undefined
-                ? await binding.rawSession.withTransaction(runAttempt)
-                : await binding.rawSession.withTransaction(runAttempt, { timeoutMS });
-            transactionEnded = binding.transactionEnded;
-        }
-        catch (errorArg) {
+        /**
+         * What the call rejects with when the driver's `withTransaction()` rejected
+         * with `errorArg`, and whether the transaction could have committed. Once
+         * the last attempt's callback returned, the driver was committing: every
+         * error from there on leaves the commit outcome unknown, unless it states
+         * that the transaction was aborted. The driver starts another attempt only
+         * after such an error, so an earlier attempt never committed.
+         */
+        const settleTransactionRejection = (errorArg) => {
             // The driver's closing abort replaces the attempt's error when it finds
             // the transaction already aborted, as a session that close() ended leaves
             // it; the interruption that failed the attempt keeps its rejection.
             if (attemptInterruption) {
-                throw normalizeDeadlineError(attemptInterruption.error);
+                return { error: normalizeDeadlineError(attemptInterruption.error), outcome: 'not_committed' };
             }
-            if (sessionEndedError) {
-                throw sessionEndedError;
+            if (sessionEnded) {
+                return { error: sessionEnded.error, outcome: commitOutcomeOfTransactionEnd(sessionEnded.end) };
             }
             if (binding.transactionEnded
                 && errorArg !== signal?.reason
                 && !isMongoDeadlineError(errorArg)
                 && !(errorArg instanceof SmartdataPersistenceError && errorArg.code === 'timeout')) {
-                throw createTransactionSessionEndedError(binding.transactionEnded, errorArg);
+                return {
+                    error: createTransactionSessionEndedError(binding.transactionEnded, errorArg),
+                    outcome: commitOutcomeOfTransactionEnd(binding.transactionEnded),
+                };
             }
             if (errorArg === callbackError) {
-                throw normalizeDeadlineError(errorArg);
+                return { error: normalizeDeadlineError(errorArg), outcome: 'not_committed' };
             }
+            const outcome = binding.transactionCommitReached && !isMongoTransientTransactionError(errorArg)
+                ? 'unknown'
+                : 'not_committed';
             if (isMongoDeadlineError(errorArg)) {
-                throw createSmartdataTimeoutError(binding.transactionCommitReached
-                    ? 'SmartData transaction exceeded its client deadline during commit; the commit outcome is unknown.'
-                    : 'SmartData transaction exceeded its client deadline before commit; nothing was committed.', errorArg);
+                return {
+                    error: createSmartdataTimeoutError(outcome === 'unknown'
+                        ? 'SmartData transaction exceeded its client deadline during commit; the commit outcome is unknown.'
+                        : binding.transactionCommitReached
+                            ? 'SmartData transaction exceeded its client deadline after the database aborted its commit; nothing was committed.'
+                            : 'SmartData transaction exceeded its client deadline before commit; nothing was committed.', errorArg),
+                    outcome,
+                };
             }
             if (binding.transactionUsesOrdinaryWrite) {
-                return normalizeOrdinaryPersistenceError(errorArg, 'SmartData transaction conflicts with a unique index.');
+                try {
+                    normalizeOrdinaryPersistenceError(errorArg, 'SmartData transaction conflicts with a unique index.');
+                }
+                catch (normalizedArg) {
+                    return { error: normalizedArg, outcome };
+                }
             }
-            throw errorArg;
+            return { error: errorArg, outcome };
+        };
+        let result;
+        let transactionEnded;
+        try {
+            result = timeoutMS === undefined
+                ? await binding.rawSession.withTransaction(runAttempt)
+                : await binding.rawSession.withTransaction(runAttempt, { timeoutMS });
+            transactionEnded = binding.transactionEnded;
+        }
+        catch (errorArg) {
+            const { error, outcome } = settleTransactionRejection(errorArg);
+            throw rejectTransaction(error, outcome);
         }
         finally {
             binding.transactionActive = false;
@@ -205,7 +287,7 @@ export class SmartdataSession {
             binding.transactionEnded = undefined;
         }
         if (transactionEnded) {
-            throw createTransactionSessionEndedError(transactionEnded);
+            throw rejectTransaction(createTransactionSessionEndedError(transactionEnded), commitOutcomeOfTransactionEnd(transactionEnded));
         }
         return result;
     }
@@ -469,4 +551,4 @@ const closeSessionBinding = async (bindingArg, endOptionsArg) => {
 export const unwrapSmartdataSessionInvalidationErrors = (errorArg) => errorArg instanceof SmartdataSessionInvalidationAggregateError
     ? errorArg.errors
     : undefined;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.session.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.session.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.session.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.session.ts"],"names":[],"mappings":"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"}

package/dist_ts/nosqldb/index.d.ts

@@ -16,6 +16,7 @@ export * from './classes.doc.js';
 export { ordinaryPersistence } from './classes.ordinarypersistence.js';
 export type { IOrdinaryPersistenceOptions } from './classes.ordinarypersistence.js';
 export type { ISmartdataStoredInspectionOptions, ISmartdataStoredInspection, ISmartdataStoredDocumentEvidence, ISmartdataStoredEvidenceInspection, TSmartdataOrdinaryDocumentEvidence, } from './classes.storedinspection.js';
+export type { ISmartdataQueryPlanOptions, ISmartdataQueryPlan, ISmartdataQueryPlanStage, } from './classes.queryplaninspection.js';
 export { SmartdataPersistenceError } from './classes.persistence.js';
 export type { TSmartdataPersistenceErrorCode } from './classes.persistence.js';
 export * from './classes.exactpersistence.js';

package/dist_ts/nosqldb/index.js

@@ -16,4 +16,4 @@ export * from './classes.distributedcoordinator.js';
 export * from './classes.cached-document.js';
 import * as convenience from './classes.convenience.js';
 export { convenience };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9ub3NxbGRiL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDhFQUE4RTtBQUM5RSxPQUFPLFdBQVcsQ0FBQztBQUVuQixPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFhMUQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUc5QyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsa0NBQWtDLENBQUM7QUFPakQsY0FBYyx5QkFBeUIsQ0FBQztBQVl4QyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBT3ZFLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRXJFLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLDhCQUE4QixDQUFDO0FBRTdDLE9BQU8sS0FBSyxXQUFXLE1BQU0sMEJBQTBCLENBQUM7QUFFeEQsT0FBTyxFQUFFLFdBQVcsRUFBRSxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9ub3NxbGRiL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDhFQUE4RTtBQUM5RSxPQUFPLFdBQVcsQ0FBQztBQUVuQixPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFhMUQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUc5QyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsa0NBQWtDLENBQUM7QUFPakQsY0FBYyx5QkFBeUIsQ0FBQztBQVl4QyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBVXZFLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRXJFLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLDhCQUE4QixDQUFDO0FBRTdDLE9BQU8sS0FBSyxXQUFXLE1BQU0sMEJBQTBCLENBQUM7QUFFeEQsT0FBTyxFQUFFLFdBQVcsRUFBRSxDQUFDIn0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lossless.org/client",
-  "version": "1.12.0",
+  "version": "1.14.0",
   "private": false,
   "description": "One typed client for NoSQLDB, MongoDB, SQLDB, MariaDB, ClickHouse and S3 object storage.",
   "exports": {
@@ -82,10 +82,10 @@
     "@aws-sdk/client-s3": "^3.1039.0",
     "@clickhouse/client": "1.23.1",
     "@git.zone/tsbuild": "5.0.0",
-    "@git.zone/tsrun": "3.0.0",
-    "@git.zone/tstest": "6.3.0",
+    "@git.zone/tsrun": "3.0.1",
+    "@git.zone/tstest": "6.3.2",
     "@lossless.org/nosqldb": "8.0.2",
-    "@lossless.org/nosqldb-qualified": "npm:@lossless.org/nosqldb@10.7.1",
+    "@lossless.org/nosqldb-qualified": "npm:@lossless.org/nosqldb@10.7.2",
     "@lossless.org/objectstorage": "10.3.1",
     "@lossless.org/sqldb": "0.2.3",
     "@push.rocks/qenv": "^6.1.3",

package/readme.md

@@ -106,7 +106,9 @@ Family imports preserve the established SmartData and SmartBucket names and cons
 | Client deadlines | `timeoutMS` (1..120000) on every ordinary model read and write, instance `save()`/`saveIf()`/`delete()` included, on every exact call, and `session.withTransaction(callback, { timeoutMS })` for a whole transaction, retries and commit included; expiry rejects with `SmartdataPersistenceError` code `timeout`, and an exact write interrupted in flight with `ambiguous_write` |
 | Bounded database close | `db.close({ timeoutMs })` bounds the whole close — session cleanup, the optional database removal and the driver client's close — and rejects at its deadline with `SmartdataPersistenceError` code `timeout`, leaving the database `close_failed`; the driver's close keeps running until it settles on its own, and the next `close()` joins it |
 | Transactions ended by close | a `session.withTransaction()` whose session `db.close()` ends while it runs rejects with `SmartdataPersistenceError` code `unsupported_operation` — "nothing was committed" before the commit, "the commit outcome is unknown" during it — instead of resolving with the callback's result |
+| Transaction commit outcome | `SmartdataSession.getCommitOutcome(error)` states for every value a `session.withTransaction()` rejected with whether the transaction could have committed: `not_committed` (nothing was committed) or `unknown` (a commit was sent and never confirmed); the rejection itself keeps its identity |
 | Cancellation | `signal` on every exact call, `atomicDeleteMany()` and `session.withTransaction(callback, { signal })`, which interrupts the session's operation in flight, rolls the attempt back and never commits after an abort |
+| Query-plan inspection | `Model.inspectQueryPlan(db, { filter, sort?, projection?, limit?, timeoutMS?, signal? })` — the winning plan's stages (`stage`, `depth`, `indexName`, `direction`) and `nReturned`/`totalKeysExamined`/`totalDocsExamined`, read-only and bounded, so a consumer proves a model query uses its intended index without raw driver access |
 | Disposable test databases on a unix socket | `SmartdataTestDatabase.create({ connection: { socketPath } })` from `@lossless.org/client/testsupport` reaches an engine that listens only on a unix-domain socket, fault helpers included; the loopback `host`/`port` form is unchanged |
 
 `docs/source/smartdata/readme.md` documents each one with its refusals.
@@ -122,7 +124,7 @@ A bucket lookup sends one HeadBucket for the named bucket, never ListBuckets, so
 
 ### Document APIs that need a MongoDB backend
 
-The document model runs on both NoSQLDB and MongoDB, but several APIs do not mean the same thing on both. The NoSQLDB engine is qualified at 8.0.2 and 10.7.1 (see [Verification](#verification)); the two releases part on the grouped-totals and guarded-`$expr` rows below — 10.7.1 groups composite keys exactly and evaluates the guard, 8.0.2 does neither — on whether a migration can create a partial index or a collection validator at all, on when a transaction learns of a write conflict, and on whether `$elemMatch` applies query operators to scalar array elements.
+The document model runs on both NoSQLDB and MongoDB, but several APIs do not mean the same thing on both. The NoSQLDB engine is qualified at 8.0.2 and 10.7.2 (see [Verification](#verification)); the two releases part on the grouped-totals and guarded-`$expr` rows below — 10.7.2 groups composite keys exactly and evaluates the guard, 8.0.2 does neither — on whether a migration can create a partial index or a collection validator at all, on when a transaction learns of a write conflict, and on whether `$elemMatch` applies query operators to scalar array elements.
 
 `init()` asks the connected engine what it is with one `buildInfo` command and records the answer on the database as `engineIdentity` (`{ product, version }`). NoSQLDB answers with its own `nosqldb` identity document from 10.3.0 onward; a MongoDB server answers `buildInfo` without one; an engine that refuses the command — NoSQLDB 8.0.2 answers `CommandNotFound` — stays `{ product: 'unknown', version: null }`. The identity is what states `capabilities` on a plain `SmartdataDb`, and an unidentified engine states none at all, so every capability-gated call refuses. `NoSqlConnection` keeps stating the capabilities of its declared backend from construction on.
 
@@ -132,13 +134,14 @@ The document model runs on both NoSQLDB and MongoDB, but several APIs do not mea
 | the same with **two** `groupBy` fields | exact, `sums` included, on an engine that identifies itself as NoSQLDB 10.5.0 or newer: that release evaluates the composite group key per document. Below it the call is refused with `unsupported_operation` naming both fields and the single-field form, because the engine leaves the composite group key unresolved and answers with a single row whose group values are the literal field paths (`'$owner'`) and whose count is the whole filtered collection; the refusal is the guard against that wrong number, not a fix for it | exact |
 | guarded `$expr` atomic filters (`$add`, `$lte`, `$ifNull`) | exact on 10.6.0 and newer: the engine evaluates the client's fail-closed compilation (`$cond`, `$let`, `$isNumber`, `$type`), so the guard admits within the limit, refuses beyond it and never matches a stored value that is not a finite number. 8.0.2 rejects the compilation with `invalid argument: $cond` and leaves the document untouched | exact |
 | `watch()` change streams | unsupported. `NoSqlConnection` refuses with `unsupported_capability`, and so does a plain `SmartdataDb` whose engine identified itself; against an engine that answers no identity the refusal instead arrives from the engine as `CommandNotFound` once the change stream is read | supported on replica sets |
-| model-declared partial indexes (`partialFilterExpression`) | not expressible: the index-option type rejects it and the runtime refuses it with `invalid_configuration`. A client decision, not an engine limit on every release — 10.6.0 and newer create partial indexes, 8.0.2 refuses the option with `InvalidOptions` (72) — because one model declaration has to hold on every qualified backend. A migration may create one on 10.7.1; `toleratedIndexNames` accepts it and inspection reports its filter | not expressible, but a migration may own one; inspection reports its filter |
+| model-declared partial indexes (`partialFilterExpression`) | not expressible: the index-option type rejects it and the runtime refuses it with `invalid_configuration`. A client decision, not an engine limit on every release — 10.6.0 and newer create partial indexes, 8.0.2 refuses the option with `InvalidOptions` (72) — because one model declaration has to hold on every qualified backend. A migration may create one on 10.7.2; `toleratedIndexNames` accepts it and inspection reports its filter | not expressible, but a migration may own one; inspection reports its filter |
 | collection validators (`validator`, `validationLevel`, `validationAction`) | no client API; a migration owns a validator through the driver. 10.7.0 and newer create the collection, list the options exactly as given and enforce them on every model write: a violating `insert()` or `atomicUpdate()` rejects with the engine's `DocumentValidationFailure` (121) and its `errInfo`, which the client passes through unchanged rather than mapping to a `SmartdataPersistenceError` code, and stores nothing. Models initialize on a validated collection like on any other. 8.0.2 refuses the option with `InvalidOptions` (72) and creates no collection, so a validator is never silently dropped | enforced; not exercised by the client's MongoDB suite |
-| write conflicts between transactions, and writes outside a transaction to a document a transaction holds | 10.7.1 (since 10.6.1) detects a conflict at the statement, as MongoDB does: the first writer wins, and the later transaction's statement rejects with the engine's `WriteConflict` (112) labelled `TransientTransactionError`, which the client passes through so `session.withTransaction()` re-runs that callback. A write outside a transaction waits until the transaction holding its document ends, then applies on top; the wait is bounded by the write's own `timeoutMS` and by the engine's fixed 60-second transaction lifetime, after which a waiting writer aborts the holder. Awaiting such a write inside the holding transaction's callback therefore stalls that transaction until one of the two expires. 8.0.2 detects the conflict at commit: the first transaction to commit wins, a write outside a transaction applies at once, and the transaction that wrote first re-runs. Both writes land on either engine; a callback must be safe to re-run and must not swallow the statement error | first writer wins at the statement and outside writes wait, MongoDB's documented rule; not exercised by the client's MongoDB suite |
-| value-form `$elemMatch` in read filters (`{ scores: { $elemMatch: { $gte: 80, $lt: 90 } } }`, `{ labels: { $not: { $elemMatch: { $nin: runnerLabels } } } }`) | exact on 10.7.1: the operators apply to each array element as a whole, so the range matches only a document with one score inside it and the claim selects a job only when every one of its labels is a runner label. 8.0.2 parses every operand as a query over embedded documents and refuses the value form with `TypeMismatch` (14). A non-document operand is refused on both, with MongoDB's `BadValue` (2) on 10.7.1 and 14 on 8.0.2. The client passes the operand through unchanged; the filter type admits the value form over scalar elements and the document form over embedded documents. Atomic filters (`atomicUpdate()` and the other atomic writes) accept no `$elemMatch` on any backend: the client refuses it with `invalid_argument` before any backend is contacted | exact |
+| write conflicts between transactions, and writes outside a transaction to a document a transaction holds | 10.7.2 (since 10.6.1) detects a conflict at the statement, as MongoDB does: the first writer wins, and the later transaction's statement rejects with the engine's `WriteConflict` (112) labelled `TransientTransactionError`, which the client passes through so `session.withTransaction()` re-runs that callback. A write outside a transaction waits until the transaction holding its document ends, then applies on top; the wait is bounded by the write's own `timeoutMS` and by the engine's fixed 60-second transaction lifetime, after which a waiting writer aborts the holder. Awaiting such a write inside the holding transaction's callback therefore stalls that transaction until one of the two expires. 8.0.2 detects the conflict at commit: the first transaction to commit wins, a write outside a transaction applies at once, and the transaction that wrote first re-runs. Both writes land on either engine; a callback must be safe to re-run and must not swallow the statement error | first writer wins at the statement and outside writes wait, MongoDB's documented rule; not exercised by the client's MongoDB suite |
+| value-form `$elemMatch` in read filters (`{ scores: { $elemMatch: { $gte: 80, $lt: 90 } } }`, `{ labels: { $not: { $elemMatch: { $nin: runnerLabels } } } }`) | exact on 10.7.1 and newer: the operators apply to each array element as a whole, so the range matches only a document with one score inside it and the claim selects a job only when every one of its labels is a runner label. 8.0.2 parses every operand as a query over embedded documents and refuses the value form with `TypeMismatch` (14). A non-document operand is refused on both, with MongoDB's `BadValue` (2) on 10.7.1 and newer and 14 on 8.0.2. The client passes the operand through unchanged; the filter type admits the value form over scalar elements and the document form over embedded documents. Atomic filters (`atomicUpdate()` and the other atomic writes) accept no `$elemMatch` on any backend: the client refuses it with `invalid_argument` before any backend is contacted | exact |
+| `Model.inspectQueryPlan()` | explains on 10.7.2: the summary names the winning plan's stages and its execution totals. 8.0.2 answers `explain` with `CommandNotFound` (59), and the call rejects with `unsupported_operation` ("The connected engine does not explain queries.") rather than returning a plan it cannot know. Stage shapes are the engine's own: on 10.7.2 a limited sort on an unindexed field is `LIMIT` over `SORT` over `COLLSCAN`, an equality on a unique single-field index is `FETCH` over `IXSCAN`, and an `$or` whose branches each have an index is a `COLLSCAN` | explains: the same limited sort is `SORT` over `COLLSCAN`, the limit folded into the sort; the equality is `EXPRESS_IXSCAN` on the unique index; the `$or` is `SUBPLAN` over `FETCH` over `OR` over one `IXSCAN` per branch |
 | aggregation-pipeline (array) updates | refused by the client with `invalid_argument` before any backend is contacted. A client-owned refusal, not an engine limit: both qualified engines apply a pipeline update themselves | same client refusal |
 
-`test/nosqldb/smartdb/test.engine-capability-boundary.node.ts` asserts the identity, grouped-totals, guarded-`$expr`, partial-index, collection-validator, write-conflict, `$elemMatch` and pipeline-update rows against both qualified engines, so a boundary that moves shows up as a failing suite rather than as a changed number in a consumer. The two halves of the grouped-totals, guarded-`$expr`, write-conflict and `$elemMatch` rows are separate tests, each bound to the engine that answers it, and the engine's own composite-key answer stays under assertion through the raw `aggregateGroupedTotals()` boundary — one literal row on 8.0.2, the two exact pairs on 10.7.1. The same boundary pins the rest of the engine's `$group` stage: a non-document accumulator is refused with `TypeMismatch` (14) on 10.7.1 while 8.0.2 answers it, and a `$cond` inside a composite key is evaluated per document on 10.7.1 while 8.0.2 answers its single literal row. It also pins whether a migration can create a partial index — 10.7.1 creates it and lists the filter, 8.0.2 refuses with 72 — and a collection validator — 10.7.1 creates and enforces it against model inserts and updates, 8.0.2 refuses with 72 — which writer a conflict sends back: on 10.7.1 the later transaction fails at its statement and re-runs while a write outside a transaction waits for the holder's commit, on 8.0.2 the later transaction commits first and the holder re-runs — and what `$elemMatch` answers through `getInstances()`: 10.7.1 matches the documented range and the `$not`/`$elemMatch`/`$nin` claim exactly as the MongoDB filter suite asserts them, 8.0.2 refuses both with 14, and a non-document operand is refused with 2 on 10.7.1 and 14 on 8.0.2. The `watch()` row is the contract refusal `ts/nosqldb/classes.collection.ts` states; the engine suite opens no change stream.
+`test/nosqldb/smartdb/test.engine-capability-boundary.node.ts` asserts the identity, grouped-totals, guarded-`$expr`, partial-index, collection-validator, write-conflict, `$elemMatch` and pipeline-update rows against both qualified engines, so a boundary that moves shows up as a failing suite rather than as a changed number in a consumer. The two halves of the grouped-totals, guarded-`$expr`, write-conflict and `$elemMatch` rows are separate tests, each bound to the engine that answers it, and the engine's own composite-key answer stays under assertion through the raw `aggregateGroupedTotals()` boundary — one literal row on 8.0.2, the two exact pairs on 10.7.2. The same boundary pins the rest of the engine's `$group` stage: a non-document accumulator is refused with `TypeMismatch` (14) on 10.7.2 while 8.0.2 answers it, and a `$cond` inside a composite key is evaluated per document on 10.7.2 while 8.0.2 answers its single literal row. It also pins whether a migration can create a partial index — 10.7.2 creates it and lists the filter, 8.0.2 refuses with 72 — and a collection validator — 10.7.2 creates and enforces it against model inserts and updates, 8.0.2 refuses with 72 — which writer a conflict sends back: on 10.7.2 the later transaction fails at its statement and re-runs while a write outside a transaction waits for the holder's commit, on 8.0.2 the later transaction commits first and the holder re-runs — and what `$elemMatch` answers through `getInstances()`: 10.7.2 matches the documented range and the `$not`/`$elemMatch`/`$nin` claim exactly as the MongoDB filter suite asserts them, 8.0.2 refuses both with 14, and a non-document operand is refused with 2 on 10.7.2 and 14 on 8.0.2. The `watch()` row is the contract refusal `ts/nosqldb/classes.collection.ts` states; the engine suite opens no change stream.
 
 ## Relational SQL
 
@@ -218,14 +221,14 @@ Qualified engines:
 
 | Component | Qualified versions |
 | --- | --- |
-| NoSQLDB engine | **8.0.2 and 10.7.1** — the same `test/nosqldb/smartdb/` suite runs against both, through the single engine seam in `test/nosqldb/helpers/smartdb.ts`; `NOSQLDB_ENGINE=qualified` selects 10.7.1 |
+| NoSQLDB engine | **8.0.2 and 10.7.2** — the same `test/nosqldb/smartdb/` suite runs against both, through the single engine seam in `test/nosqldb/helpers/smartdb.ts`; `NOSQLDB_ENGINE=qualified` selects 10.7.2 |
 | MongoDB | 8.0.26 replica sets |
 | ObjectStorage | 10.3.1 |
 | SQLDB | 0.2.3 |
 | MariaDB | 11.8 |
 | ClickHouse | 25.8 |
 
-Both engine versions run the whole document suite. They part on asserted boundaries — 10.7.1 groups composite keys exactly and answers two-field grouped totals, evaluates guarded `$expr` filters, creates migration-owned partial indexes and collection validators, reports a transaction write conflict at the statement and matches value-form `$elemMatch`, 8.0.2 does none of these, reports the conflict at commit, and the client refuses the two-field form there — which [Document APIs that need a MongoDB backend](#document-apis-that-need-a-mongodb-backend) states row by row. Text search, the Lucene adapter and the broad read-filter surface are exercised against MongoDB only. `pnpm run test:minio` uses a digest-pinned MinIO image: `sha256:14cea493d9a34af32f524e538b8346cf79f3321eff8e708c1e2960462bd8936e`. That MinIO version enforces the tested conditional uploads but does not enforce conditional deletion; its exact-purge capability is correctly unavailable. ObjectStorage passes both live probes. AWS S3 has not been qualified against a live account in this migration; no universal S3 exact-operation guarantee is inferred from the SDK.
+Both engine versions run the whole document suite. They part on asserted boundaries — 10.7.2 groups composite keys exactly and answers two-field grouped totals, evaluates guarded `$expr` filters, creates migration-owned partial indexes and collection validators, reports a transaction write conflict at the statement and matches value-form `$elemMatch`, 8.0.2 does none of these, reports the conflict at commit, and the client refuses the two-field form there — which [Document APIs that need a MongoDB backend](#document-apis-that-need-a-mongodb-backend) states row by row. Text search, the Lucene adapter and the broad read-filter surface are exercised against MongoDB only. `pnpm run test:minio` uses a digest-pinned MinIO image: `sha256:14cea493d9a34af32f524e538b8346cf79f3321eff8e708c1e2960462bd8936e`. That MinIO version enforces the tested conditional uploads but does not enforce conditional deletion; its exact-purge capability is correctly unavailable. ObjectStorage passes both live probes. AWS S3 has not been qualified against a live account in this migration; no universal S3 exact-operation guarantee is inferred from the SDK.
 
 ## License and Legal Information
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@lossless.org/client',
-  version: '1.12.0',
+  version: '1.14.0',
   description: 'One typed client for NoSQLDB, MongoDB, SQLDB, MariaDB, ClickHouse and S3 object storage.'
 }

package/ts/nosqldb/classes.db.ts

@@ -22,7 +22,11 @@ import {
 } from './classes.namespaceinspection.js';
 
 export { SmartdataSession } from './classes.session.js';
-export type { ISmartdataTransactionOptions, TSmartdataOrdinarySession } from './classes.session.js';
+export type {
+  ISmartdataTransactionOptions,
+  TSmartdataOrdinarySession,
+  TSmartdataTransactionCommitOutcome,
+} from './classes.session.js';
 
 import { logger } from './logging.js';
 import { assertDataOptions, SmartdataOperationBudget } from './classes.operationbudget.js';

package/ts/nosqldb/classes.doc.ts

@@ -16,6 +16,10 @@ import {
   type ISmartdataStoredInspectionOptions, type ISmartdataStoredInspection,
   type ISmartdataStoredEvidenceInspection,
 } from './classes.storedinspection.js';
+import {
+  inspectQueryPlan, requireQueryPlanOptions,
+  type ISmartdataQueryPlan, type ISmartdataQueryPlanOptions,
+} from './classes.queryplaninspection.js';
 import {
   getIdentityDocumentIdField,
   type IManager,
@@ -3727,6 +3731,32 @@ export class SmartDataDbDoc<T extends TImplements, TImplements, TManager extends
     return inspectStoredDocumentEvidence(this, dbArg, optionsArg);
   }
 
+  /**
+   * Explains one model query with `executionStats` on `dbArg` and returns the
+   * winning plan's stages and execution totals, so a consumer can prove which
+   * index serves the query. Read-only: nothing is created, bound or hydrated.
+   */
+  public static async inspectQueryPlan<T>(
+    this: plugins.tsclass.typeFest.Class<T>,
+    dbArg: SmartdataDb,
+    optionsArg: ISmartdataQueryPlanOptions<T>,
+  ): Promise<ISmartdataQueryPlan> {
+    const model = this as unknown as typeof SmartDataDbDoc;
+    const options = requireQueryPlanOptions(optionsArg);
+    model.assertHydratedProjection(options.projection);
+    const declaredRoots = model.getDeclaredPersistedRoots();
+    const declaredQueryPaths = model.getDeclaredQueryPaths();
+    return inspectQueryPlan(dbArg, {
+      collectionName: getExpectedCollectionTopologyForModel(model).collectionName,
+      filter: model.normalizeReadFilter(options.filter),
+      sort: normalizeSort(options.sort, declaredRoots, declaredQueryPaths),
+      projection: normalizeProjection(options.projection, declaredRoots, declaredQueryPaths),
+      limit: options.limit,
+      timeoutMS: options.timeoutMS,
+      signal: options.signal,
+    });
+  }
+
   public static createInstanceFromMongoDbNativeDoc<T>(
     this: plugins.tsclass.typeFest.Class<T>,
     mongoDbNativeDocArg: any,

package/ts/nosqldb/classes.persistence.ts

@@ -69,6 +69,15 @@ export const isMongoTransactionRetryError = (errorArg: unknown): boolean =>
     errorArg.hasErrorLabel('UnknownTransactionCommitResult')
   );
 
+/**
+ * The server or the driver stated that the transaction was aborted and may be
+ * run again from its start, so nothing of it was committed. A timeout the
+ * driver raises in place of such an error copies its labels.
+ */
+export const isMongoTransientTransactionError = (errorArg: unknown): boolean =>
+  errorArg instanceof plugins.mongodb.MongoError
+  && errorArg.hasErrorLabel(plugins.mongodb.MongoErrorLabel.TransientTransactionError);
+
 export const isMongoDuplicateKeyError = (
   errorArg: unknown,
 ): errorArg is plugins.mongodb.MongoServerError => {