@lossless.org/client 2.0.0 → 2.2.0

package/dist_ts/objectstorage/internal.multipart.planner.js

@@ -60,4 +60,33 @@ export const planMultipartUpload = (optionsArg) => {
         maximumBufferedBytes: Math.min(optionsArg.objectSize, partSize * concurrency) + Math.min(optionsArg.objectSize, partSize),
     };
 };
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Plans an upload of undeclared length that must not exceed
+ * `maxObjectSize`. The part size grows with the maximum so that the largest
+ * allowed source still fits into the multipart part limit.
+ */
+export const planBoundedMultipartUpload = (optionsArg) => {
+    if (!Number.isSafeInteger(optionsArg.maxObjectSize) || optionsArg.maxObjectSize < 1) {
+        throw new TypeError('maxObjectSize must be a positive safe integer.');
+    }
+    if (optionsArg.maxObjectSize > MULTIPART_MAX_OBJECT_SIZE) {
+        throw new RangeError(`maxObjectSize exceeds the ${MULTIPART_MAX_OBJECT_SIZE} byte multipart limit.`);
+    }
+    const requestedConcurrency = normalizeRequestedConcurrency(optionsArg.requestedConcurrency);
+    const preferredPartSize = normalizeRequestedPartSize(optionsArg.requestedPartSize);
+    const partSize = Math.max(preferredPartSize, Math.ceil(optionsArg.maxObjectSize / MULTIPART_MAX_PART_COUNT));
+    if (partSize > MULTIPART_MAX_PART_SIZE) {
+        throw new RangeError('The maximum cannot be represented by legal multipart parts.');
+    }
+    const maxPartCount = Math.ceil(optionsArg.maxObjectSize / partSize);
+    const concurrency = Math.min(requestedConcurrency, maxPartCount);
+    return {
+        classification: 'bounded',
+        maxObjectSize: optionsArg.maxObjectSize,
+        partSize,
+        maxPartCount,
+        concurrency,
+        maximumBufferedBytes: Math.min(optionsArg.maxObjectSize, partSize * concurrency) + Math.min(optionsArg.maxObjectSize, partSize),
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/objectstorage/internal.multipart.stream.js

@@ -6,6 +6,7 @@ const failureMessages = {
     'source-empty-chunk-limit': 'The multipart source emitted too many consecutive empty chunks.',
     'source-short': 'The multipart source ended before the declared content length.',
     'source-extra': 'The multipart source exceeded the declared content length.',
+    'source-over-maximum': 'The multipart source exceeded the maximum content length.',
     'part-callback': 'A multipart part callback failed.',
 };
 const failureSettlementMaximumTimeoutMs = 30_000;
@@ -33,16 +34,33 @@ export class MultipartStreamConsumptionError extends Error {
     }
 }
 const validatePlan = (planArg) => {
-    if (!Number.isSafeInteger(planArg.objectSize) ||
-        planArg.objectSize < 0 ||
-        planArg.objectSize > MULTIPART_MAX_OBJECT_SIZE) {
-        throw new TypeError('plan.objectSize is invalid.');
-    }
     if (!Number.isSafeInteger(planArg.concurrency) ||
         planArg.concurrency < 1 ||
         planArg.concurrency > MULTIPART_MAX_CONCURRENCY) {
         throw new TypeError('plan.concurrency is invalid.');
     }
+    if (planArg.classification === 'bounded') {
+        if (!Number.isSafeInteger(planArg.maxObjectSize) ||
+            planArg.maxObjectSize < 1 ||
+            planArg.maxObjectSize > MULTIPART_MAX_OBJECT_SIZE ||
+            !Number.isSafeInteger(planArg.partSize) ||
+            planArg.partSize < MULTIPART_MIN_PART_SIZE ||
+            planArg.partSize > MULTIPART_MAX_PART_SIZE ||
+            planArg.maxPartCount !== Math.ceil(planArg.maxObjectSize / planArg.partSize) ||
+            planArg.maxPartCount > MULTIPART_MAX_PART_COUNT ||
+            planArg.concurrency > planArg.maxPartCount ||
+            planArg.maximumBufferedBytes !==
+                Math.min(planArg.maxObjectSize, planArg.partSize * planArg.concurrency) +
+                    Math.min(planArg.maxObjectSize, planArg.partSize)) {
+            throw new TypeError('The bounded multipart plan is inconsistent.');
+        }
+        return;
+    }
+    if (!Number.isSafeInteger(planArg.objectSize) ||
+        planArg.objectSize < 0 ||
+        planArg.objectSize > MULTIPART_MAX_OBJECT_SIZE) {
+        throw new TypeError('plan.objectSize is invalid.');
+    }
     if (planArg.classification === 'zero') {
         if (planArg.objectSize !== 0 ||
             planArg.partSize !== 0 ||
@@ -82,6 +100,14 @@ export const consumeExactMultipartStream = async (optionsArg) => {
         failureSettlementTimeoutMs > failureSettlementMaximumTimeoutMs) {
         throw new TypeError(`failureSettlementTimeoutMs must be a positive safe integer no greater than ${failureSettlementMaximumTimeoutMs}.`);
     }
+    const plan = optionsArg.plan;
+    // A bounded plan reads parts until the source ends and refuses more than
+    // its maximum; an exact plan reads exactly the declared length.
+    const bounded = plan.classification === 'bounded';
+    const sizeLimit = bounded ? plan.maxObjectSize : plan.objectSize;
+    const overLimitKind = bounded
+        ? 'source-over-maximum'
+        : 'source-extra';
     const reader = optionsArg.readableStream.getReader();
     const callbackAbortController = new AbortController();
     const inFlightParts = new Map();
@@ -187,7 +213,7 @@ export const consumeExactMultipartStream = async (optionsArg) => {
             return outcome.result;
         }
     };
-    const dispatchPart = (dataArg, partNumberArg) => {
+    const dispatchPart = (dataArg, partNumberArg, isLastPartArg) => {
         const token = Symbol(`multipart-part-${partNumberArg}`);
         partCallbacksStarted++;
         currentPartBytes = 0;
@@ -196,8 +222,8 @@ export const consumeExactMultipartStream = async (optionsArg) => {
         const outcome = Promise.resolve()
             .then(() => optionsArg.onPart({
             partNumber: partNumberArg,
-            byteOffset: (partNumberArg - 1) * optionsArg.plan.partSize,
-            isLastPart: partNumberArg === optionsArg.plan.partCount,
+            byteOffset: (partNumberArg - 1) * plan.partSize,
+            isLastPart: isLastPartArg,
             data: dataArg,
             signal: callbackAbortController.signal,
         }))
@@ -233,10 +259,14 @@ export const consumeExactMultipartStream = async (optionsArg) => {
     try {
         let pendingChunk;
         let pendingChunkOffset = 0;
-        for (let partNumber = 1; partNumber <= optionsArg.plan.partCount; partNumber++) {
+        for (let partNumber = 1; bounded ? !sourceClosed : partNumber <= plan.partCount; partNumber++) {
             await waitForCapacity();
-            const partByteLength = Math.min(optionsArg.plan.partSize, optionsArg.plan.objectSize -
-                (partNumber - 1) * optionsArg.plan.partSize);
+            const partByteLength = Math.min(plan.partSize, sizeLimit - (partNumber - 1) * plan.partSize);
+            if (partByteLength <= 0) {
+                // A bounded source filled its maximum, which ends at or inside the
+                // previous part; the trailing read below refuses any further byte.
+                break;
+            }
             if (inFlightBytes + partByteLength >
                 optionsArg.plan.maximumBufferedBytes) {
                 throw new Error('The multipart plan cannot honor its buffering bound.');
@@ -262,6 +292,9 @@ export const consumeExactMultipartStream = async (optionsArg) => {
                 const readResult = await readWhileObservingCallbacks();
                 if (readResult.done) {
                     sourceClosed = true;
+                    if (bounded) {
+                        break;
+                    }
                     throw {
                         kind: 'source-short',
                     };
@@ -276,22 +309,36 @@ export const consumeExactMultipartStream = async (optionsArg) => {
                     continue;
                 }
                 observedBytes += readResult.value.byteLength;
-                if (observedBytes > optionsArg.plan.objectSize) {
+                if (observedBytes > sizeLimit) {
                     throw {
-                        kind: 'source-extra',
+                        kind: overLimitKind,
                     };
                 }
-                if (readResult.value.byteLength > optionsArg.plan.partSize) {
+                if (readResult.value.byteLength > plan.partSize) {
                     throw {
                         kind: 'source-buffer-limit',
-                        cause: new RangeError(`Source chunks must not exceed ${optionsArg.plan.partSize} bytes.`),
+                        cause: new RangeError(`Source chunks must not exceed ${plan.partSize} bytes.`),
                     };
                 }
                 pendingChunk = readResult.value;
                 pendingChunkBytes = readResult.value.byteLength;
                 observeBufferedBytes();
             }
-            dispatchPart(partData, partNumber);
+            if (partOffset === 0) {
+                // A bounded source ended at a part boundary.
+                currentPartBytes = 0;
+                break;
+            }
+            if (partOffset < partByteLength) {
+                // Only a bounded source ends inside a part; its last part keeps the
+                // bytes read, as an exact copy.
+                dispatchPart(partData.slice(0, partOffset), partNumber, true);
+            }
+            else {
+                dispatchPart(partData, partNumber, bounded
+                    ? sourceClosed || observedBytes === sizeLimit
+                    : partNumber === plan.partCount);
+            }
         }
         while (!sourceClosed) {
             const readResult = await readWhileObservingCallbacks();
@@ -310,7 +357,7 @@ export const consumeExactMultipartStream = async (optionsArg) => {
             }
             observedBytes += readResult.value.byteLength;
             throw {
-                kind: 'source-extra',
+                kind: overLimitKind,
             };
         }
         while (inFlightParts.size > 0) {
@@ -407,7 +454,9 @@ export const consumeExactMultipartStream = async (optionsArg) => {
             completionAuthorized: false,
             kind: failure.kind,
             cause: failure.cause,
-            expectedBytes: optionsArg.plan.objectSize,
+            ...(bounded
+                ? { maxBytes: plan.maxObjectSize }
+                : { expectedBytes: plan.objectSize }),
             observedBytes,
             partCallbacksStarted,
             completedPartNumbers: [...completedPartNumbers].sort((leftArg, rightArg) => {
@@ -437,4 +486,4 @@ export const consumeExactMultipartStream = async (optionsArg) => {
         }
     }
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"internal.multipart.stream.js","sourceRoot":"","sources":["../../ts/objectstorage/internal.multipart.stream.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"internal.multipart.stream.js","sourceRoot":"","sources":["../../ts/objectstorage/internal.multipart.stream.ts"],"names":[],"mappings":"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"}

package/dist_ts/objectstorage/internal.multipart.types.d.ts

@@ -3,6 +3,11 @@ export interface IMultipartPlanningOptions {
     requestedPartSize?: number;
     requestedConcurrency?: number;
 }
+export interface IMultipartBoundedPlanningOptions {
+    maxObjectSize: number;
+    requestedPartSize?: number;
+    requestedConcurrency?: number;
+}
 interface IMultipartUploadPlanBase {
     objectSize: number;
     concurrency: number;
@@ -20,10 +25,31 @@ export interface IMultipartDataUploadPlan extends IMultipartUploadPlanBase {
     partSize: number;
     partCount: number;
 }
-export type TMultipartUploadPlan = IMultipartZeroUploadPlan | IMultipartDataUploadPlan;
+/**
+ * A plan for a source of undeclared length: full parts are read until the
+ * source ends, and a source longer than `maxObjectSize` fails. The part size
+ * is chosen so that `maxObjectSize` fits into the multipart part limit.
+ */
+export interface IMultipartBoundedUploadPlan {
+    classification: 'bounded';
+    maxObjectSize: number;
+    partSize: number;
+    /** Parts that `maxObjectSize` needs; the source may need fewer. */
+    maxPartCount: number;
+    concurrency: number;
+    maximumBufferedBytes: number;
+}
+/** A plan for a source of declared length. */
+export type TMultipartDeclaredUploadPlan = IMultipartZeroUploadPlan | IMultipartDataUploadPlan;
+export type TMultipartUploadPlan = TMultipartDeclaredUploadPlan | IMultipartBoundedUploadPlan;
 export interface IMultipartStreamPart {
     partNumber: number;
     byteOffset: number;
+    /**
+     * Under a bounded plan a part is only known to be the last when the source
+     * ended inside it or it reached the maximum; a source that ends exactly at
+     * a part boundary leaves its last part marked false.
+     */
     isLastPart: boolean;
     /**
      * An exact, exclusively owned copy. The consumer never mutates or reuses it.
@@ -46,7 +72,7 @@ export interface IMultipartStreamConsumptionResult {
     peakBufferedBytes: number;
     maximumBufferedBytes: number;
 }
-export type TMultipartStreamFailureKind = 'aborted' | 'source-read' | 'source-buffer-limit' | 'source-empty-chunk-limit' | 'source-short' | 'source-extra' | 'part-callback';
+export type TMultipartStreamFailureKind = 'aborted' | 'source-read' | 'source-buffer-limit' | 'source-empty-chunk-limit' | 'source-short' | 'source-extra' | 'source-over-maximum' | 'part-callback';
 export type TMultipartOwnedReaderCleanup = {
     status: 'closed';
 } | {
@@ -72,7 +98,10 @@ export interface IMultipartStreamFailureState {
     completionAuthorized: false;
     kind: TMultipartStreamFailureKind;
     cause?: unknown;
-    expectedBytes: number;
+    /** The declared length; absent under a bounded plan. */
+    expectedBytes?: number;
+    /** The maximum length of a bounded plan. */
+    maxBytes?: number;
     observedBytes: number;
     partCallbacksStarted: number;
     completedPartNumbers: number[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lossless.org/client",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "private": false,
   "publishConfig": {
     "registry": "https://verdaccio.lossless.digital"

package/readme.md

@@ -113,6 +113,7 @@ 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 conflicts | a `session.withTransaction()` whose every attempt the database aborted as transient (a write conflict or another error labelled `TransientTransactionError`) until the driver's 120-second retry window closed rejects with `SmartdataTransactionConflictError` (a `SmartdataPersistenceError` of code `transaction_conflict`) carrying `attempts`, `elapsedMS` and the last attempt's error as `cause`: nothing was committed and the transaction is safe to re-run. With `timeoutMS` it rejects with `timeout` instead. Ordinary model writes that run in their own transaction reject the same way |
 | 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 |
 | Nested array paths | `@svDb({ arrayPaths: [...] })` declares nested arrays below a persisted root; `$push`, `$addToSet` and `$pull` in `atomicUpdate()`, `atomicUpdateMany()`, `atomicFindOneAndUpdate()` and `atomicUpsertMany()` accept them, while undeclared and non-array nested paths stay refused with `invalid_argument` |
@@ -148,7 +149,7 @@ A bucket lookup sends one HeadBucket for the named bucket, never ListBuckets, so
 
 `fastGetIfPresent()` answers "read it, or tell me it is gone" with one GetObject, so an object removed between an existence check and a read can no longer turn into a failed read: a provider answer that the key does not exist — `NoSuchKey`, `NotFound` or any other HTTP 404 — resolves `null`. Every other failure rejects as `fastGet()` does, the provider error unchanged: a missing bucket (`NoSuchBucket`), a denied request, a failure while the body streams, and an abort through `signal` or `SmartBucket.close()`, which rejects with the abort reason even when the provider answers not-found after it. `fastExists()` and the create-only check of `fastPutStream()` classify a missing object the same way.
 
-Every request of the S3 client a `SmartBucket` builds is bounded. An attempt whose socket does not connect within `connectionTimeoutMs` (default 10 s, at most 60 s), or whose response headers do not arrive within `requestTimeoutMs` of its start (default 60 s, at most 1 h; the upload of the request body counts), fails with the SDK's `TimeoutError`; the SDK retries it up to `maxAttempts` attempts in all (default 3, at most 10, standard retry mode, `AWS_MAX_ATTEMPTS` and shared config files ignored). Each value must be a positive safe integer; anything else is refused with a `TypeError` before a client is built. `smartBucket.requestBounds` (and `connection.requestBounds`) reads the frozen bounds, including `requestDeadlineMs = maxAttempts × requestTimeoutMs + (maxAttempts − 1) × 20 000 ms + 1 000 ms` — the attempts, the longest wait the retry strategy takes before a retry (a provider's retry-after hint included), and a second for the client's own work. 221 000 ms with the defaults. A request still unsettled at that deadline, a stalled error body included, rejects with `ObjectStorageRequestDeadlineError`, its attempt in flight is destroyed and no further attempt of it starts, so a consumer can hold the client to an upper bound of its own (`requestDeadlineMs < bound`). The bound does not undo a request: a PutObject the provider received completely before the deadline or an abort may still take effect. It covers requests, not the time a caller takes to read a download it received: a response body streams at the caller's pace until it is consumed, the caller's signal aborts or the SmartBucket closes. While a client assigned through `storageClient` or `replaceStorageClient()` is in use, `requestBounds` is `undefined` and that client's own configuration applies. A single-request upload (`fastPut`, `fastPutStream`) must finish sending its body within `requestTimeoutMs`; for large objects raise it or use `fastPutStreamExact()`, whose parts are separate requests of 5 MiB each.
+Every request of the S3 client a `SmartBucket` builds is bounded. An attempt whose socket does not connect within `connectionTimeoutMs` (default 10 s, at most 60 s), or whose response headers do not arrive within `requestTimeoutMs` of its start (default 60 s, at most 1 h; the upload of the request body counts), fails with the SDK's `TimeoutError`; the SDK retries it up to `maxAttempts` attempts in all (default 3, at most 10, standard retry mode, `AWS_MAX_ATTEMPTS` and shared config files ignored). Each value must be a positive safe integer; anything else is refused with a `TypeError` before a client is built. `smartBucket.requestBounds` (and `connection.requestBounds`) reads the frozen bounds, including `requestDeadlineMs = maxAttempts × requestTimeoutMs + (maxAttempts − 1) × 20 000 ms + 1 000 ms` — the attempts, the longest wait the retry strategy takes before a retry (a provider's retry-after hint included), and a second for the client's own work. 221 000 ms with the defaults. A request still unsettled at that deadline, a stalled error body included, rejects with `ObjectStorageRequestDeadlineError`, its attempt in flight is destroyed and no further attempt of it starts, so a consumer can hold the client to an upper bound of its own (`requestDeadlineMs < bound`). The bound does not undo a request: a PutObject the provider received completely before the deadline or an abort may still take effect. It covers requests, not the time a caller takes to read a download it received: a response body streams at the caller's pace until it is consumed, the caller's signal aborts or the SmartBucket closes. While a client assigned through `storageClient` or `replaceStorageClient()` is in use, `requestBounds` is `undefined` and that client's own configuration applies. A single-request upload (`fastPut`, `fastPutStream`) must finish sending its body within `requestTimeoutMs`; large or slow bodies use `fastPutStreamExact()`, whose parts are separate requests, each bounded on its own (5 MiB unless `requestedPartSize` asks for more or the length needs more than 10,000 parts).
 
 A `signal` aborts the request in flight, stops its retries and rejects with the signal's reason; an already aborted signal sends nothing. A signal of a bucket read, write, copy, move, removal, existence check or listing that is not an `AbortSignal`, a `Proxy` of one included, is refused with a `TypeError` before any request. A per-call time limit is a signal as well, `AbortSignal.timeout(ms)` or an own `AbortController`.
 

package/ts/00_commitinfo_data.ts

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

package/ts/nosqldb/classes.persistence.ts

@@ -7,7 +7,8 @@ export type TSmartdataPersistenceErrorCode =
   | 'unique_conflict'
   | 'ambiguous_write'
   | 'unsupported_operation'
-  | 'timeout';
+  | 'timeout'
+  | 'transaction_conflict';
 
 /**
  * Stable errors for ordinary SmartData model configuration and persistence.
@@ -28,6 +29,34 @@ export class SmartdataPersistenceError extends Error {
   }
 }
 
+/**
+ * `session.withTransaction()` gave up because every attempt of the transaction
+ * was aborted as transient: a write conflict or another error the database
+ * labelled `TransientTransactionError`, through the driver's whole retry
+ * window. Nothing was committed, so the transaction is safe to re-run. The
+ * last attempt's error is the `cause` and tells which error it was; like every
+ * driver error it can contain statement data. A transaction with `timeoutMS`
+ * rejects with code `timeout` instead once its deadline expires.
+ */
+export class SmartdataTransactionConflictError extends SmartdataPersistenceError {
+  /** How many times the callback ran. */
+  public readonly attempts: number;
+  /** Milliseconds from the start of `withTransaction()` until it gave up. */
+  public readonly elapsedMS: number;
+
+  constructor(optionsArg: { attempts: number; elapsedMS: number; cause: unknown }) {
+    super(
+      'transaction_conflict',
+      `SmartData transaction gave up after ${optionsArg.attempts} attempts in ${optionsArg.elapsedMS} ms: `
+        + 'every attempt was aborted as transient; nothing was committed.',
+      { cause: optionsArg.cause },
+    );
+    this.name = 'SmartdataTransactionConflictError';
+    this.attempts = optionsArg.attempts;
+    this.elapsedMS = optionsArg.elapsedMS;
+  }
+}
+
 /**
  * The client-side deadline of a model call or transaction expired. The
  * driver's own `MongoOperationTimeoutError` stays available as `cause` when

package/ts/nosqldb/classes.session.ts

@@ -11,6 +11,7 @@ import {
 import { assertDataOptions } from './classes.operationbudget.js';
 import {
   SmartdataPersistenceError,
+  SmartdataTransactionConflictError,
   createSmartdataTimeoutError,
   isMongoDeadlineError,
   isMongoTransientTransactionError,
@@ -355,6 +356,14 @@ export class SmartdataSession {
    * committed, afterwards the commit outcome is unknown. The callback's
    * error, if it threw, is the `cause`.
    *
+   * The driver re-runs an attempt the database aborted as transient — a
+   * write conflict or another error labelled `TransientTransactionError` —
+   * until its retry window of 120 seconds closes. When every attempt was
+   * aborted that way, the call rejects with `SmartdataTransactionConflictError`
+   * (code `transaction_conflict`): nothing was committed and the transaction
+   * is safe to re-run. With `timeoutMS` the deadline is the window, and the
+   * call rejects with `timeout` instead.
+   *
    * Every rejection states whether the transaction could have committed:
    * `SmartdataSession.getCommitOutcome(error)` returns `not_committed` or
    * `unknown` for the value the call rejected with.
@@ -370,6 +379,9 @@ export class SmartdataSession {
       throw rejectTransaction(errorArg, 'not_committed');
     }
     const { binding, timeoutMS, signal } = admitted;
+    const startedAt = performance.now();
+    /** How many times the driver started the callback. */
+    let attempts = 0;
     binding.transactionActive = true;
     binding.transactionTimeoutMS = timeoutMS;
     binding.transactionSignal = signal;
@@ -385,6 +397,7 @@ export class SmartdataSession {
     const runAttempt = async () => {
       // The last attempt's slots end after this one starts, so it bumps others.
       const attemptStartedAt = performance.now();
+      attempts++;
       revisionAttempt?.finish(false);
       revisionAttempt = beginSmartdataWriteRevisionAttempt(binding.owner, attemptStartedAt);
       // The driver starts another attempt only once the last one was aborted.
@@ -511,6 +524,19 @@ export class SmartdataSession {
           outcome: commitOutcomeOfTransactionEnd(binding.transactionEnded),
         };
       }
+      // The driver re-runs every attempt aborted as transient until its retry
+      // window closes, so such an error that still reaches here exhausted it.
+      // With `timeoutMS` the driver raises a deadline error in its place.
+      if (isMongoTransientTransactionError(errorArg) && !isMongoDeadlineError(errorArg)) {
+        return {
+          error: new SmartdataTransactionConflictError({
+            attempts,
+            elapsedMS: Math.round(performance.now() - startedAt),
+            cause: errorArg,
+          }),
+          outcome: 'not_committed',
+        };
+      }
       if (errorArg === callbackError) {
         return { error: normalizeDeadlineError(errorArg), outcome: 'not_committed' };
       }

package/ts/nosqldb/index.ts

@@ -48,7 +48,7 @@ export type {
 export type {
   ISmartdataQueryPlanOptions, ISmartdataQueryPlan, ISmartdataQueryPlanStage,
 } from './classes.queryplaninspection.js';
-export { SmartdataPersistenceError } from './classes.persistence.js';
+export { SmartdataPersistenceError, SmartdataTransactionConflictError } from './classes.persistence.js';
 export type { TSmartdataPersistenceErrorCode } from './classes.persistence.js';
 export * from './classes.exactpersistence.js';
 export * from './classes.easystore.js';

package/ts/objectstorage/interfaces.ts

@@ -264,7 +264,18 @@ export interface IFastPutStreamExactOptions {
    * size (5 MiB by default).
    */
   readableStream: Readable | ReadableStream<Uint8Array>;
-  contentLength: number;
+  /**
+   * The exact source length. Exactly one of `contentLength` and
+   * `maxContentLength` must be given.
+   */
+  contentLength?: number;
+  /**
+   * The upper bound for a source of undeclared length. The part size grows so
+   * that the maximum fits in 10,000 parts, and buffering stays bounded to the
+   * planned parts in flight. A source that exceeds the maximum fails the
+   * upload, and the multipart upload is aborted instead of completed.
+   */
+  maxContentLength?: number;
   nativeMetadata?: Record<string, string>;
   /**
    * Native S3 object properties that must retain their semantic header
@@ -316,7 +327,10 @@ export type TExactUploadMultipartCleanup =
 export interface IExactUploadFailureState {
   phase: TExactUploadFailurePhase;
   destinationPath: string;
-  expectedContentLength: number;
+  /** The declared source length, when the upload declared one. */
+  expectedContentLength?: number;
+  /** The source maximum, when the upload had an undeclared length. */
+  maxContentLength?: number;
   /**
    * Whether this operation can prove that it did not publish the destination.
    * A conditional PutObject or CompleteMultipartUpload response can be lost