@lossless.org/client 1.11.0 → 1.12.0

package/dist_ts/nosqldb/classes.operationbudget.d.ts

@@ -8,6 +8,8 @@ export declare class SmartdataOperationBudget {
     private readonly timer;
     constructor(timeoutMsArg: unknown, signalArg?: unknown);
     check(): void;
+    /** Whether the deadline itself has passed; a caller's signal does not count. */
+    expired(): boolean;
     remainingMs(): number;
     operationOptions(): {
         timeoutMS: number;

package/dist_ts/nosqldb/classes.operationbudget.js

@@ -38,6 +38,12 @@ export class SmartdataOperationBudget {
             throw new SmartdataPersistenceError('unsupported_operation', 'SmartData operation was cancelled or exceeded its deadline.');
         }
     }
+    /** Whether the deadline itself has passed; a caller's signal does not count. */
+    expired() {
+        if (performance.now() >= this.expiresAt)
+            this.controller.abort();
+        return this.controller.signal.aborted;
+    }
     remainingMs() {
         this.check();
         return this.cleanupOptions().timeoutMS;
@@ -62,4 +68,4 @@ export class SmartdataOperationBudget {
     }
     close() { clearTimeout(this.timer); }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/nosqldb/classes.session.d.ts

@@ -57,6 +57,12 @@ export declare class SmartdataSession {
      * Any operation on the session that its deadline or a signal interrupts
      * fails the attempt: the call rolls it back and rejects with that
      * operation's error even when the callback caught it.
+     *
+     * When the session ends while the call runs — the database's `close()`
+     * ends every session — the call never reports a commit. It rejects with
+     * `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`.
      */
     withTransaction<TResult>(callbackArg: (sessionArg: SmartdataSession) => Promise<TResult>, optionsArg?: ISmartdataTransactionOptions): Promise<TResult | undefined>;
     close(): Promise<void>;
@@ -108,6 +114,10 @@ export declare const settleSmartdataOperationError: (sessionArg: TSmartdataOrdin
  * of an expired driver deadline to the `timeout` persistence error.
  */
 export declare const runWithOrdinarySmartdataSession: <TResult>(sessionArg: TSmartdataOrdinarySession | undefined, ownerArg: SmartdataDb, optionsArg: IOrdinarySessionOperationOptions, operationArg: (rawSessionArg: plugins.mongodb.ClientSession | undefined, deadlineArg: SmartdataOperationDeadline) => Promise<TResult>) => Promise<TResult>;
-export declare const invalidateSmartdataSessions: (ownerArg: SmartdataDb) => Promise<void>;
+/**
+ * Ends every session of the owner. `endOptionsArg.timeoutMS` is the driver's
+ * deadline for aborting a transaction a session still holds.
+ */
+export declare const invalidateSmartdataSessions: (ownerArg: SmartdataDb, endOptionsArg?: Pick<plugins.mongodb.EndSessionOptions, "timeoutMS">) => Promise<void>;
 export declare const unwrapSmartdataSessionInvalidationErrors: (errorArg: unknown) => readonly unknown[] | undefined;
 export {};

package/dist_ts/nosqldb/classes.session.js

@@ -2,6 +2,14 @@ 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';
+/**
+ * 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
+ * committing, so the call must reject instead.
+ */
+const createTransactionSessionEndedError = (endArg, causeArg) => new SmartdataPersistenceError('unsupported_operation', endArg === 'during_commit'
+    ? 'SmartData transaction session ended during commit; the commit outcome is unknown.'
+    : 'SmartData transaction session ended before commit; nothing was committed.', causeArg === undefined ? undefined : { cause: causeArg });
 const bindings = new WeakMap();
 const bindingsByOwner = new WeakMap();
 const smartdataSessionInvalidationAggregateBrand = Symbol('smartdataSessionInvalidationAggregate');
@@ -64,6 +72,12 @@ export class SmartdataSession {
      * Any operation on the session that its deadline or a signal interrupts
      * fails the attempt: the call rolls it back and rejects with that
      * operation's error even when the callback caught it.
+     *
+     * When the session ends while the call runs — the database's `close()`
+     * ends every session — the call never reports a commit. It rejects with
+     * `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`.
      */
     async withTransaction(callbackArg, optionsArg) {
         if (typeof callbackArg !== 'function') {
@@ -78,25 +92,34 @@ export class SmartdataSession {
         binding.transactionActive = true;
         binding.transactionTimeoutMS = timeoutMS;
         binding.transactionSignal = signal;
+        binding.transactionEnded = undefined;
         let callbackError;
-        let commitReached = false;
+        /** The signal or deadline interruption that failed the last attempt. */
+        let attemptInterruption;
+        let sessionEndedError;
         const runAttempt = async () => {
             const attempt = Symbol('smartdataTransactionAttempt');
             binding.transactionAttempt = attempt;
             binding.transactionCallbackOpen = true;
             binding.transactionUsesOrdinaryWrite = false;
             binding.transactionFailure = undefined;
+            binding.transactionCommitReached = false;
             callbackError = undefined;
-            commitReached = false;
+            attemptInterruption = undefined;
             try {
                 let result;
                 let callbackReturned = false;
+                let callbackThrown;
                 try {
                     // A retry the driver starts after an abort ends before the callback.
                     signal?.throwIfAborted();
                     result = await transactionContext.run({ contextToken: binding.contextToken, attempt }, async () => callbackArg(this));
                     callbackReturned = true;
                 }
+                catch (errorArg) {
+                    callbackThrown = { error: errorArg };
+                    throw errorArg;
+                }
                 finally {
                     const activeOperation = binding.operationActive
                         ? binding.operationSettled
@@ -108,34 +131,62 @@ export class SmartdataSession {
                     if (activeOperation) {
                         await activeOperation;
                     }
+                    attemptInterruption = binding.transactionFailure;
                     assertTransactionSucceeded(binding);
+                    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;
+                    }
                     if (callbackReturned && activeOperation) {
                         throw new SmartdataPersistenceError('unsupported_operation', 'A SmartData transaction callback returned with an operation still active.');
                     }
                 }
                 // An abort that arrived while the callback ran rolls the attempt back.
                 signal?.throwIfAborted();
-                // The driver commits next; a deadline that expires from here on
-                // leaves the commit outcome unknown.
-                commitReached = true;
+                // The driver commits next; a deadline that expires or a session that
+                // ends from here on leaves the commit outcome unknown.
+                binding.transactionCommitReached = true;
                 return result;
             }
             catch (errorArg) {
                 callbackError = errorArg;
+                if (signal?.aborted && errorArg === signal.reason) {
+                    attemptInterruption ??= { error: errorArg };
+                }
                 throw errorArg;
             }
         };
+        let result;
+        let transactionEnded;
         try {
-            return timeoutMS === undefined
+            result = timeoutMS === undefined
                 ? await binding.rawSession.withTransaction(runAttempt)
                 : await binding.rawSession.withTransaction(runAttempt, { timeoutMS });
+            transactionEnded = binding.transactionEnded;
         }
         catch (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);
+            }
+            if (sessionEndedError) {
+                throw sessionEndedError;
+            }
+            if (binding.transactionEnded
+                && errorArg !== signal?.reason
+                && !isMongoDeadlineError(errorArg)
+                && !(errorArg instanceof SmartdataPersistenceError && errorArg.code === 'timeout')) {
+                throw createTransactionSessionEndedError(binding.transactionEnded, errorArg);
+            }
             if (errorArg === callbackError) {
                 throw normalizeDeadlineError(errorArg);
             }
             if (isMongoDeadlineError(errorArg)) {
-                throw createSmartdataTimeoutError(commitReached
+                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);
             }
@@ -150,7 +201,13 @@ export class SmartdataSession {
             binding.transactionSignal = undefined;
             binding.transactionUsesOrdinaryWrite = false;
             binding.transactionFailure = undefined;
+            binding.transactionCommitReached = false;
+            binding.transactionEnded = undefined;
         }
+        if (transactionEnded) {
+            throw createTransactionSessionEndedError(transactionEnded);
+        }
+        return result;
     }
     async close() {
         const binding = bindings.get(this);
@@ -178,6 +235,7 @@ export const createSmartdataSession = (ownerArg) => {
         transactionActive: false,
         transactionCallbackOpen: false,
         transactionUsesOrdinaryWrite: false,
+        transactionCommitReached: false,
         invalidated: false,
     };
     bindings.set(session, binding);
@@ -356,16 +414,20 @@ export const runWithOrdinarySmartdataSession = async (sessionArg, ownerArg, opti
         lease.release();
     }
 };
-export const invalidateSmartdataSessions = async (ownerArg) => {
+/**
+ * Ends every session of the owner. `endOptionsArg.timeoutMS` is the driver's
+ * deadline for aborting a transaction a session still holds.
+ */
+export const invalidateSmartdataSessions = async (ownerArg, endOptionsArg) => {
     const ownerBindings = bindingsByOwner.get(ownerArg);
     if (!ownerBindings) {
         return;
     }
     const sessions = [...ownerBindings];
     for (const bindingArg of sessions) {
-        bindingArg.invalidated = true;
+        invalidateSessionBinding(bindingArg);
     }
-    const results = await Promise.allSettled(sessions.map((bindingArg) => closeSessionBinding(bindingArg)));
+    const results = await Promise.allSettled(sessions.map((bindingArg) => closeSessionBinding(bindingArg, endOptionsArg)));
     const errors = results.flatMap((resultArg) => resultArg.status === 'rejected' ? [resultArg.reason] : []);
     if (errors.length === 1) {
         throw errors[0];
@@ -374,13 +436,25 @@ export const invalidateSmartdataSessions = async (ownerArg) => {
         throw new SmartdataSessionInvalidationAggregateError(errors, 'Multiple SmartData sessions failed to close.');
     }
 };
+/**
+ * Refuses every later operation on the session. A transaction still running on
+ * it records how far it had got, so it rejects instead of reporting a commit.
+ */
+const invalidateSessionBinding = (bindingArg) => {
+    bindingArg.invalidated = true;
+    if (bindingArg.transactionActive) {
+        bindingArg.transactionEnded ??= bindingArg.transactionCommitReached
+            ? 'during_commit'
+            : 'before_commit';
+    }
+};
 /** Failed cleanup remains owned and invalidated until an explicit retry succeeds. */
-const closeSessionBinding = async (bindingArg) => {
+const closeSessionBinding = async (bindingArg, endOptionsArg) => {
     if (bindingArg.closing)
         return bindingArg.closing;
-    bindingArg.invalidated = true;
+    invalidateSessionBinding(bindingArg);
     const closing = Promise.resolve().then(async () => {
-        await bindingArg.rawSession.endSession();
+        await bindingArg.rawSession.endSession(endOptionsArg);
         bindingsByOwner.get(bindingArg.owner)?.delete(bindingArg);
         bindings.delete(bindingArg.session);
     });
@@ -395,4 +469,4 @@ const closeSessionBinding = async (bindingArg) => {
 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lossless.org/client",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "private": false,
   "description": "One typed client for NoSQLDB, MongoDB, SQLDB, MariaDB, ClickHouse and S3 object storage.",
   "exports": {
@@ -85,7 +85,7 @@
     "@git.zone/tsrun": "3.0.0",
     "@git.zone/tstest": "6.3.0",
     "@lossless.org/nosqldb": "8.0.2",
-    "@lossless.org/nosqldb-qualified": "npm:@lossless.org/nosqldb@10.7.0",
+    "@lossless.org/nosqldb-qualified": "npm:@lossless.org/nosqldb@10.7.1",
     "@lossless.org/objectstorage": "10.3.1",
     "@lossless.org/sqldb": "0.2.3",
     "@push.rocks/qenv": "^6.1.3",

package/readme.md

@@ -104,6 +104,8 @@ Family imports preserve the established SmartData and SmartBucket names and cons
 | Key-value store readiness | `EasyStore.ensureInitialized()` — installs the store's declared index at startup, outside any transaction window, so a first `readKey()`/`writeKey()` needs no index DDL |
 | Key-value store copies | `EasyStore` `readKey()`/`readAll()` return copies and `writeKey()`/`writeAll()`/`replace()` store copies, in the persisted BSON form, so a read result is a stable snapshot and a caller-side mutation never reaches the store |
 | 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 |
 | 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 |
 | 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 |
 
@@ -120,7 +122,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.0 (see [Verification](#verification)); the two releases part on the grouped-totals and guarded-`$expr` rows below — 10.7.0 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, and on when a transaction learns of a write conflict.
+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.
 
 `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.
 
@@ -130,12 +132,13 @@ 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.0; `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 creates the collection, lists the options exactly as given and enforces 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.0 (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 |
+| 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 |
+| 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 |
 | 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 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` and write-conflict 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.0. The same boundary pins the rest of the engine's `$group` stage: a non-document accumulator is refused with `TypeMismatch` (14) on 10.7.0 while 8.0.2 answers it, and a `$cond` inside a composite key is evaluated per document on 10.7.0 while 8.0.2 answers its single literal row. It also pins whether a migration can create a partial index — 10.7.0 creates it and lists the filter, 8.0.2 refuses with 72 — and a collection validator — 10.7.0 creates and enforces it against model inserts and updates, 8.0.2 refuses with 72 — and which writer a conflict sends back: on 10.7.0 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. 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.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.
 
 ## Relational SQL
 
@@ -215,14 +218,14 @@ Qualified engines:
 
 | Component | Qualified versions |
 | --- | --- |
-| NoSQLDB engine | **8.0.2 and 10.7.0** — 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.0 |
+| 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 |
 | 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.0 groups composite keys exactly and answers two-field grouped totals, evaluates guarded `$expr` filters, creates migration-owned partial indexes and collection validators and reports a transaction write conflict at the statement, 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.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.
 
 ## License and Legal Information
 

package/ts/00_commitinfo_data.ts

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

package/ts/nosqldb/classes.db.ts

@@ -2,7 +2,11 @@ import * as plugins from './plugins.js';
 
 import { SmartdataCollection } from './classes.collection.js';
 import { EasyStore } from './classes.easystore.js';
-import { SmartdataPersistenceError } from './classes.persistence.js';
+import {
+  createSmartdataTimeoutError,
+  isMongoDeadlineError,
+  SmartdataPersistenceError,
+} from './classes.persistence.js';
 import { SmartdataMongoAdministration } from './classes.mongoadministration.js';
 import {
   createSmartdataSession,
@@ -78,7 +82,14 @@ export interface ISmartdataInitOptions {
 }
 
 export interface ISmartdataCloseOptions {
-  /** Total deadline for removal, including preceding session cleanup (1..120000 ms). */
+  /**
+   * Deadline for the whole close (1..120000 ms): session cleanup, the optional
+   * database removal and the driver client's close. When it expires the call
+   * rejects with `SmartdataPersistenceError` code `timeout` and the database is
+   * `close_failed`. Cleanup still running at that point is not abandoned: it
+   * stays owned by this `SmartdataDb`, and the next `close()` joins it.
+   * Without `timeoutMs`, close waits for every cleanup to settle.
+   */
   timeoutMs?: number;
   dropDatabase?: {
     expectedDatabaseName: string;
@@ -120,6 +131,9 @@ type TSmartdataDbLifecycleState =
 
 type TSmartdataDbLifecycleOperation = 'init' | 'close';
 
+/** How the driver's close of an owned client ended, kept until a close() has observed it. */
+type TSmartdataClientCloseOutcome = { failed: false } | { failed: true; error: unknown };
+
 const readinessDefaultTimeoutMs = 2_000;
 const readinessMaximumTimeoutMs = 30_000;
 
@@ -177,6 +191,8 @@ export class SmartdataDb {
   private lifecycleEpoch = 0;
   private activeLifecycleOperation: TSmartdataDbLifecycleOperation | null = null;
   private pendingClient?: plugins.mongodb.MongoClient;
+  /** The driver's close of the owned client until a close() has observed its outcome. */
+  private clientClosing?: Promise<TSmartdataClientCloseOutcome>;
   private engineIdentityState: ISmartdataEngineIdentity = unidentifiedSmartdataEngine;
   private capabilitiesState: ICapabilities | undefined;
 
@@ -327,7 +343,8 @@ export class SmartdataDb {
   }
 
   /**
-   * closes the connection to the databse
+   * Closes the connection to the database. `timeoutMs` bounds the whole call;
+   * see `ISmartdataCloseOptions`.
    */
   public async close(optionsArg: ISmartdataCloseOptions = {}): Promise<void> {
     this.assertLifecycleOperationCanBegin('close');
@@ -341,7 +358,14 @@ export class SmartdataDb {
     try {
       const closeErrors: unknown[] = [];
       try {
-        await invalidateSmartdataSessions(this);
+        const invalidation = invalidateSmartdataSessions(this, budget?.cleanupOptions());
+        // A session whose cleanup outlives the deadline stays owned and invalidated
+        // until the next close() ends it. Its abort already carries the same
+        // deadline, so a late failure can only be that deadline, which this close
+        // reports as `timeout`.
+        invalidation.catch(() => {});
+        if (budget) await budget.waitFor(invalidation);
+        await invalidation;
       } catch (errorArg) {
         closeErrors.push(
           ...(unwrapSmartdataSessionInvalidationErrors(errorArg) ?? [errorArg]),
@@ -360,16 +384,28 @@ export class SmartdataDb {
           closeErrors.push(errorArg);
         }
       }
-      try {
-        await mongoDbClient?.close();
-        this.pendingClient = undefined;
-      } catch (errorArg) {
-        closeErrors.push(errorArg);
+      if (mongoDbClient) {
+        const clientClosing = this.closeOwnedClient(mongoDbClient);
+        try {
+          if (budget) await budget.waitFor(clientClosing);
+          // Settled in time: this close observes the outcome, and a later one starts afresh.
+          const outcome = await clientClosing;
+          this.clientClosing = undefined;
+          if (outcome.failed) throw outcome.error;
+          this.pendingClient = undefined;
+        } catch (errorArg) {
+          closeErrors.push(errorArg);
+        }
       }
       if (closeErrors.length > 0) {
         this.transitionLifecycle('close_failed');
-        if (budget) throw new SmartdataPersistenceError('unsupported_operation',
-          'SmartData database cleanup failed; close must be retried.');
+        if (budget) {
+          throw budget.expired() || closeErrors.some(isMongoDeadlineError)
+            ? createSmartdataTimeoutError(
+              'SmartData database close exceeded its deadline; close must be retried.')
+            : new SmartdataPersistenceError('unsupported_operation',
+              'SmartData database cleanup failed; close must be retried.');
+        }
         if (closeErrors.length === 1) {
           throw closeErrors[0];
         }
@@ -653,6 +689,22 @@ export class SmartdataDb {
     return this.mongoDb;
   }
 
+  /**
+   * Starts the driver's close of an owned client, or joins the one a previous
+   * close() started. The driver offers no deadline for it, so a close that
+   * outlived its caller keeps running, and its outcome — a rejection included —
+   * waits here for the next close() instead of being lost.
+   */
+  private closeOwnedClient(
+    clientArg: plugins.mongodb.MongoClient,
+  ): Promise<TSmartdataClientCloseOutcome> {
+    this.clientClosing ??= clientArg.close().then(
+      (): TSmartdataClientCloseOutcome => ({ failed: false }),
+      (errorArg: unknown): TSmartdataClientCloseOutcome => ({ failed: true, error: errorArg }),
+    );
+    return this.clientClosing;
+  }
+
   private endLifecycleOperation(operationArg: TSmartdataDbLifecycleOperation): void {
     if (this.activeLifecycleOperation === operationArg) {
       this.activeLifecycleOperation = null;