@lossless.org/client 1.19.0 → 1.20.1

package/dist_ts/nosqldb/connectionstring.js

@@ -0,0 +1,194 @@
+import * as plugins from './plugins.js';
+const redactionMarker = '<redacted>';
+/**
+ * The URL the driver connects with: `mongoDbUrl` with its first `<USERNAME>`/`<USER>`,
+ * `<PASSWORD>` and `<DBNAME>` placeholder of each case replaced by the URL-encoded
+ * user, password and the database name.
+ */
+export const buildSmartdataConnectionUrl = (optionsArg) => {
+    const encodedUser = optionsArg.mongoDbUser ? encodeURIComponent(optionsArg.mongoDbUser) : '';
+    const encodedPass = optionsArg.mongoDbPass ? encodeURIComponent(optionsArg.mongoDbPass) : '';
+    return optionsArg.mongoDbUrl
+        .replace('<USERNAME>', encodedUser)
+        .replace('<username>', encodedUser)
+        .replace('<USER>', encodedUser)
+        .replace('<user>', encodedUser)
+        .replace('<PASSWORD>', encodedPass)
+        .replace('<password>', encodedPass)
+        .replace('<DBNAME>', optionsArg.mongoDbName || '')
+        .replace('<dbname>', optionsArg.mongoDbName || '');
+};
+/**
+ * The URI options whose value is a secret, by the driver's option table
+ * (`mongodb/src/connection_string.ts` `OPTIONS`): the `auth` credentials, the
+ * `authMechanismProperties` (for example `AWS_SESSION_TOKEN`), the SOCKS5 proxy
+ * login, the key file password, and the TLS key material the driver passes through.
+ * Lower-cased, because the driver reads option names case-insensitively.
+ */
+const secretUriOptionNames = new Set([
+    'auth',
+    'authMechanismProperties',
+    'proxyUsername',
+    'proxyPassword',
+    'tlsCertificateKeyFilePassword',
+    'key',
+    'passphrase',
+    'pfx',
+].map((nameArg) => nameArg.toLowerCase()));
+/** Its value is a `KEY:value,KEY:value` list, and the driver quotes single values of it. */
+const mechanismPropertiesOptionName = 'authmechanismproperties';
+/**
+ * The `authMechanismProperties` entries whose value is a secret, by the driver's
+ * `AuthMechanismProperties` (`mongodb/src/cmap/auth/mongo_credentials.ts`).
+ */
+const secretMechanismPropertyNames = new Set(['AWS_SESSION_TOKEN']);
+/** A credential as written, URL-encoded, URL-decoded and query-decoded: a driver message may quote any of them. */
+const spellingsOf = (credentialArg) => [
+    credentialArg,
+    ...[
+        encodeURIComponent,
+        decodeURIComponent,
+        (textArg) => decodeURIComponent(textArg.replaceAll('+', ' ')),
+    ].flatMap((transformArg) => {
+        try {
+            return [transformArg(credentialArg)];
+        }
+        catch {
+            // A spelling the credential cannot be transformed into cannot be quoted either.
+            return [];
+        }
+    }),
+];
+/**
+ * The userinfo of a connection string, as a whole and as its user and password halves.
+ * A string the driver refuses is malformed by definition, so it is read generously:
+ * everything between `://` and the last `@`.
+ */
+const userinfoCredentialsOf = (urlArg) => {
+    const userinfo = /^[^:/?#]*:\/\/(.*)@/s.exec(urlArg)?.[1];
+    if (userinfo === undefined)
+        return [];
+    const separator = userinfo.indexOf(':');
+    return separator < 0
+        ? [userinfo]
+        : [userinfo, userinfo.slice(0, separator), userinfo.slice(separator + 1)];
+};
+/**
+ * The `name=value` pairs of a connection string's query, read generously: a pair
+ * starts after any `?`, `&` or `;`, and its value runs to the next `&`, as the driver
+ * splits, and also to the next `;`, the legacy separator, so both readings are covered.
+ */
+const uriOptionsOf = (urlArg) => [...urlArg.matchAll(/(?<=[?&;])([^?&;=]*)=(?=([^&]*))/g)].flatMap(([, name, value]) => [value, value.split(';')[0]].map((valueArg) => ({ name, value: valueArg })));
+/** The secret entry values in every spelling of an `authMechanismProperties` value, split as the driver splits it. */
+const secretMechanismPropertyValuesOf = (valueArg) => spellingsOf(valueArg).flatMap((spellingArg) => spellingArg.split(',').flatMap((entryArg) => {
+    const separator = entryArg.indexOf(':');
+    return separator >= 0 && secretMechanismPropertyNames.has(entryArg.slice(0, separator).toUpperCase())
+        ? [entryArg.slice(separator + 1)]
+        : [];
+}));
+/** The values of a connection string's secret-bearing URI options, under any spelling of their name. */
+const uriOptionCredentialsOf = (urlArg) => uriOptionsOf(urlArg).flatMap(({ name, value }) => {
+    const names = spellingsOf(name).map((spellingArg) => spellingArg.toLowerCase());
+    if (!names.some((nameArg) => secretUriOptionNames.has(nameArg)))
+        return [];
+    return names.includes(mechanismPropertiesOptionName) ? [value, ...secretMechanismPropertyValuesOf(value)] : [value];
+});
+/**
+ * Every credential spelling the options carry, in the connection string as given and as
+ * built, longest first so the longest credential starting at a position is the one found.
+ */
+const connectionCredentialsOf = (optionsArg) => {
+    const credentials = [
+        ...[optionsArg.mongoDbUrl, buildSmartdataConnectionUrl(optionsArg)].flatMap((urlArg) => [
+            ...userinfoCredentialsOf(urlArg),
+            ...uriOptionCredentialsOf(urlArg),
+        ]),
+        optionsArg.mongoDbUser,
+        optionsArg.mongoDbPass,
+    ].filter((credentialArg) => Boolean(credentialArg));
+    return [...new Set(credentials.flatMap(spellingsOf))]
+        .filter((spellingArg) => spellingArg.length > 0)
+        .sort((leftArg, rightArg) => rightArg.length - leftArg.length);
+};
+// `RegExp.escape` is ES2025, beyond the ES2024 target.
+const escapeRegExp = (textArg) => textArg.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
+/**
+ * Where credentials occur in a text, overlapping occurrences merged into one span.
+ * The pattern only looks ahead, so it reports every start, overlapping ones included.
+ */
+const credentialSpansIn = (textArg, occurrenceArg) => {
+    const spans = [];
+    for (const { index, 1: credential } of textArg.matchAll(occurrenceArg)) {
+        const end = index + credential.length;
+        const previous = spans.at(-1);
+        if (previous !== undefined && index < previous.end)
+            previous.end = Math.max(previous.end, end);
+        else
+            spans.push({ start: index, end });
+    }
+    return spans;
+};
+const withSpansRedacted = (textArg, spansArg) => {
+    let redacted = '';
+    let copiedUntil = 0;
+    for (const { start, end } of spansArg) {
+        redacted += textArg.slice(copiedUntil, start) + redactionMarker;
+        copiedUntil = end;
+    }
+    return redacted + textArg.slice(copiedUntil);
+};
+/**
+ * Redacts in one pass over the original text, so no credential is matched inside
+ * a marker another credential left and overlapping credentials leave no fragment.
+ */
+const redactorFor = (credentialsArg) => {
+    if (credentialsArg.length === 0)
+        return (textArg) => textArg;
+    const occurrence = new RegExp(`(?=(${credentialsArg.map(escapeRegExp).join('|')}))`, 'g');
+    return (textArg) => withSpansRedacted(textArg, credentialSpansIn(textArg, occurrence));
+};
+/** Only these named fields: any other field, such as Node's `ERR_INVALID_URL` `input`, may hold the connection string. */
+const preservedFieldsOf = (errorArg, redactArg) => {
+    const fields = {};
+    const code = 'code' in errorArg ? errorArg.code : undefined;
+    if (typeof code === 'number')
+        fields.code = code;
+    if (typeof code === 'string')
+        fields.code = redactArg(code);
+    const codeName = 'codeName' in errorArg ? errorArg.codeName : undefined;
+    if (typeof codeName === 'string')
+        fields.codeName = redactArg(codeName);
+    if (errorArg instanceof plugins.mongodb.MongoError)
+        fields.errorLabels = errorArg.errorLabels.map(redactArg);
+    return fields;
+};
+/**
+ * A copy of a thrown value that keeps its error name, its detail, its stack frames,
+ * its preserved fields, its cause chain and its aggregated errors, with every
+ * credential replaced. Only an error that is its own ancestor is left out, so a
+ * cyclic chain still ends.
+ */
+const copyRedacted = (thrownArg, redactArg, ancestorsArg) => {
+    if (!(thrownArg instanceof Error))
+        return new Error(redactArg(String(thrownArg)));
+    ancestorsArg.add(thrownArg);
+    const copyInner = (innerArg) => innerArg instanceof Error && ancestorsArg.has(innerArg) ? [] : [copyRedacted(innerArg, redactArg, ancestorsArg)];
+    const [cause] = thrownArg.cause === undefined ? [] : copyInner(thrownArg.cause);
+    const options = cause === undefined ? undefined : { cause };
+    const message = redactArg(thrownArg.message);
+    const copy = thrownArg instanceof AggregateError
+        ? new AggregateError(thrownArg.errors.flatMap((innerArg) => copyInner(innerArg)), message, options)
+        : new Error(message, options);
+    ancestorsArg.delete(thrownArg);
+    copy.name = redactArg(thrownArg.name);
+    if (thrownArg.stack !== undefined)
+        copy.stack = redactArg(thrownArg.stack);
+    return Object.assign(copy, preservedFieldsOf(thrownArg, redactArg));
+};
+/**
+ * What a connection failure may show: the driver's error, copied with every
+ * credential of the options replaced by `<redacted>`. The original is never
+ * attached, because printing an error prints its whole cause chain.
+ */
+export const redactSmartdataConnectionError = (thrownArg, optionsArg) => copyRedacted(thrownArg, redactorFor(connectionCredentialsOf(optionsArg)), new Set());
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connectionstring.js","sourceRoot":"","sources":["../../ts/nosqldb/connectionstring.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lossless.org/client",
-  "version": "1.19.0",
+  "version": "1.20.1",
   "private": false,
   "description": "One typed client for NoSQLDB, MongoDB, SQLDB, MariaDB, ClickHouse and S3 object storage.",
   "exports": {
@@ -81,9 +81,9 @@
     "@aws-sdk/client-s3": "^3.1039.0",
     "@clickhouse/client": "1.23.1",
     "@git.zone/tsbuild": "5.1.2",
-    "@git.zone/tsbundle": "3.1.3",
+    "@git.zone/tsbundle": "3.1.4",
     "@git.zone/tsrun": "3.0.2",
-    "@git.zone/tstest": "7.1.0",
+    "@git.zone/tstest": "7.2.0",
     "@lossless.org/nosqldb": "8.0.2",
     "@lossless.org/nosqldb-qualified": "npm:@lossless.org/nosqldb@10.7.2",
     "@lossless.org/objectstorage": "10.3.1",

package/readme.md

@@ -116,6 +116,7 @@ Family imports preserve the established SmartData and SmartBucket names and cons
 | 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 |
 | Per-instance model binding | `bindDocToManager(manager, Model)` returns a subclass of a model declared with `@managed()` and no manager argument, named like the model and bound to that manager, so several databases use the same models at once; any other binding is refused with `invalid_configuration` |
 | Subclasses need their own binding | a subclass of a bound model that declares decorators or a persistence policy of its own and no `@Collection()`, `@managed()` or `defineCollectionModel()` binding is refused with `invalid_configuration` on every read and write, so it never writes through the parent's schema; an undecorated subclass keeps the inherited binding |
+| Observing this process's writes | `db.observeWrites({ fields, listener })` — one frozen report per acknowledged model write, `{ collection, kind, documents, anchors }` with the requested top-level fields of the written documents and of the selector's equality anchors; writes inside a `db.createSession()` transaction are reported after the commit, never after a rollback; works on NoSQLDB, where `watch()` is unsupported |
 | 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.
@@ -146,7 +147,7 @@ The document model runs on both NoSQLDB and MongoDB, but several APIs do not mea
 | `getGroupedTotals()` / `getGroupedTotalsPage()` / `iterateGroupedTotals()` with one `groupBy` field | exact, including `sums`, declared nested paths, `unwind` of a declared array and declared fields of its element, `elementFilter`, group key order and `cursor` paging, on 8.0.2 and 10.7.2 alike | exact |
 | the same with **two** `groupBy` fields | exact, `sums`, nested paths, `unwind`, two element fields of one unwound array (`lines.accountNumber` with `lines.side`), `elementFilter` and `cursor` paging 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; the client wraps each key member in `$ifNull`, because MongoDB leaves a missing member out of the key and would otherwise report it as a second null group |
 | 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 |
+| `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. `db.observeWrites()` reports the process's own model writes on both backends | 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.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.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 |
@@ -222,7 +223,7 @@ SmartClickHouse migration changes: replace RxJS `next/complete` insertion with a
 
 `@lossless.org/client/nosqldb` is a fork of @push.rocks/smartdata 11.14.2 (commit `9868817a63de72caef787bd8e68bac3deb9d6131`), taken on 2026-09-10; this repository continues that package's git history, so every upstream fix up to and including 11.14.2 is present here. `nosqldbLineage`, exported from the family entry point, carries the same baseline for runtime and tooling checks, and `docs/source/smartdata` keeps the upstream readme, hints and changelog.
 
-The fork departs from that baseline in five places: `NoSqlConnection` adds the client backend, capability and readiness contract; the family entry point exports it together with `nosqldbLineage`; `watch()` refuses to open a change stream when the connected backend reports change streams as unsupported; `init()` identifies the engine and states the capabilities that identity implies; and two-field grouped totals are refused on a backend that does not group composite keys exactly. The package version file was dropped, because versioning belongs to `@lossless.org/client`. Document-model capabilities added after the fork — `$max`/`$min`, identity seeding through `$setOnInsert`, `atomicUpsertMany()` and `identityAsDocumentId` — are this package's own additions and have no upstream counterpart.
+The fork departs from that baseline in six places: `NoSqlConnection` adds the client backend, capability and readiness contract; the family entry point exports it together with `nosqldbLineage`; `watch()` refuses to open a change stream when the connected backend reports change streams as unsupported; `init()` identifies the engine and states the capabilities that identity implies; a failed `init()` rejects with `SmartdataPersistenceError` (`unsupported_operation`) instead of the driver's own error, and without a deadline carries that error as `cause`, copied with every connection credential redacted, so code that matched the driver's error class (`MongoServerSelectionError`, …) reads `cause.name` (a cleanup that fails as well makes the rejection an `AggregateError` of both); and two-field grouped totals are refused on a backend that does not group composite keys exactly. The package version file was dropped, because versioning belongs to `@lossless.org/client`. Document-model capabilities added after the fork — `$max`/`$min`, identity seeding through `$setOnInsert`, `atomicUpsertMany()` and `identityAsDocumentId` — are this package's own additions and have no upstream counterpart.
 
 Fixes land here. @push.rocks/smartdata is no longer a release channel for this implementation, so a later upstream version is not a source to merge from and not an upgrade path for consumers of this package.
 

package/ts/00_commitinfo_data.ts

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

package/ts/nosqldb/classes.atomicdelete.ts

@@ -1,6 +1,7 @@
 import * as plugins from './plugins.js';
 import type { SmartdataCollection } from './classes.collection.js';
 import {
+  reportSmartdataCollectionWrite,
   runWithOrdinarySmartdataSession,
   type TSmartdataOrdinarySession,
 } from './classes.session.js';
@@ -31,13 +32,17 @@ export const executeAtomicDelete = async <T>(
     },
     async (rawSessionArg, deadlineArg) => {
       await deadlineArg.join(collectionArg.init());
-      return collectionArg.mongoDbCollection.deleteOne(
+      const result = await collectionArg.mongoDbCollection.deleteOne(
         filterArg,
         {
           session: rawSessionArg,
           ...deadlineArg.commandOptions(),
         },
       );
+      if (result.deletedCount > 0) {
+        reportSmartdataCollectionWrite(collectionArg, optsArg?.session, 'delete', null, filterArg);
+      }
+      return result;
     },
   );
 };
@@ -71,13 +76,17 @@ export const executeAtomicDeleteMany = async <T>(
     },
     async (rawSessionArg, deadlineArg) => {
       await deadlineArg.join(collectionArg.init());
-      return collectionArg.mongoDbCollection.deleteMany(
+      const result = await collectionArg.mongoDbCollection.deleteMany(
         filterArg,
         {
           session: rawSessionArg,
           ...deadlineArg.commandOptions(),
         },
       );
+      if (result.deletedCount > 0) {
+        reportSmartdataCollectionWrite(collectionArg, optsArg?.session, 'delete', null, filterArg);
+      }
+      return result;
     },
   );
 };

package/ts/nosqldb/classes.atomicfindoneandupdate.ts

@@ -5,6 +5,7 @@ import {
   SmartdataPersistenceError,
 } from './classes.persistence.js';
 import {
+  reportSmartdataCollectionWrite,
   runWithOrdinarySmartdataSession,
   isSmartdataSession,
   failSmartdataTransaction,
@@ -138,6 +139,15 @@ export const executeAtomicFindOneAndUpdate = async <T>(
               classified.document, policy, collectionArg.getBoundModelSchema()!.persistedFields,
             ) as TRawDocument;
           }
+          if (classified.status !== 'not_matched') {
+            reportSmartdataCollectionWrite(
+              collectionArg,
+              optionsArg.session,
+              classified.status === 'upserted' ? 'insert' : 'update',
+              classified.document ? [classified.document] : null,
+              filterArg,
+            );
+          }
           return classified;
         } catch (errorArg) {
           if (policy) {
@@ -213,6 +223,18 @@ export const executeAtomicFindOneAndReplace = async <T>(
           // Unreachable: this operation never requests an upsert.
           return unsupportedResult();
         }
+        if (classified.status === 'matched') {
+          // A before image leaves the replacement as the only image of the new state.
+          reportSmartdataCollectionWrite(
+            collectionArg,
+            optionsArg.session,
+            'replace',
+            optionsArg.returnDocument === 'after'
+              ? [classified.document]
+              : [classified.document, replacementArg],
+            filterArg,
+          );
+        }
         return classified;
       } catch (errorArg) {
         return normalizeOrdinaryPersistenceError(

package/ts/nosqldb/classes.atomicupdate.ts

@@ -1,7 +1,11 @@
 import * as plugins from './plugins.js';
 import type { SmartdataCollection } from './classes.collection.js';
-import { normalizeOrdinaryPersistenceError } from './classes.persistence.js';
 import {
+  getMongoBulkWriteErrorIndexes,
+  normalizeOrdinaryPersistenceError,
+} from './classes.persistence.js';
+import {
+  reportSmartdataCollectionWrite,
   runWithOrdinarySmartdataSession,
   type TSmartdataOrdinarySession,
 } from './classes.session.js';
@@ -21,6 +25,8 @@ export const executeAtomicUpdate = async <T>(
     upsert?: boolean;
     session?: TSmartdataOrdinarySession;
     timeoutMS?: number;
+    /** The document image the update writes, when the caller holds one: a fenced save's instance. */
+    observedDocument?: object;
   },
 ): Promise<plugins.mongodb.UpdateResult> => {
   return runWithOrdinarySmartdataSession(
@@ -35,7 +41,7 @@ export const executeAtomicUpdate = async <T>(
     async (rawSessionArg, deadlineArg) => {
       await deadlineArg.join(collectionArg.init());
       try {
-        return await collectionArg.mongoDbCollection.updateOne(
+        const result = await collectionArg.mongoDbCollection.updateOne(
           filterArg,
           updateArg,
           {
@@ -44,6 +50,16 @@ export const executeAtomicUpdate = async <T>(
             ...deadlineArg.commandOptions(),
           },
         );
+        if (result.upsertedCount > 0 || result.matchedCount > 0) {
+          reportSmartdataCollectionWrite(
+            collectionArg,
+            optsArg?.session,
+            result.upsertedCount > 0 ? 'insert' : 'update',
+            optsArg?.observedDocument ? [optsArg.observedDocument] : null,
+            filterArg,
+          );
+        }
+        return result;
       } catch (errorArg) {
         return normalizeOrdinaryPersistenceError(
           errorArg,
@@ -90,6 +106,25 @@ export const executeAtomicUpsertMany = async <T>(
     },
     async (rawSessionArg, deadlineArg) => {
       await deadlineArg.join(collectionArg.init());
+      /**
+       * Every entry upserts, so an entry that neither inserted nor failed
+       * matched its document.
+       */
+      const reportEntries = (
+        upsertedIdsArg: Record<number, unknown> | undefined,
+        failedIndexesArg: ReadonlySet<number>,
+      ): void => {
+        operationsArg.forEach((operationArg, indexArg) => {
+          if (failedIndexesArg.has(indexArg)) return;
+          reportSmartdataCollectionWrite(
+            collectionArg,
+            optsArg?.session,
+            Object.hasOwn(upsertedIdsArg ?? {}, indexArg) ? 'insert' : 'update',
+            null,
+            operationArg.filter,
+          );
+        });
+      };
       try {
         const result = await collectionArg.mongoDbCollection.bulkWrite(
           operationsArg.map((operationArg) => ({
@@ -105,6 +140,9 @@ export const executeAtomicUpsertMany = async <T>(
             ...deadlineArg.commandOptions(),
           },
         );
+        if (result.isOk()) {
+          reportEntries(result.upsertedIds, new Set());
+        }
         return {
           acknowledged: result.isOk(),
           matchedCount: result.matchedCount,
@@ -112,6 +150,14 @@ export const executeAtomicUpsertMany = async <T>(
           upsertedCount: result.upsertedCount,
         };
       } catch (errorArg) {
+        // An unordered batch that failed on write errors attempted every entry.
+        const failedIndexes = getMongoBulkWriteErrorIndexes(errorArg);
+        if (failedIndexes) {
+          reportEntries(
+            (errorArg as plugins.mongodb.MongoBulkWriteError).result?.upsertedIds,
+            failedIndexes,
+          );
+        }
         return normalizeOrdinaryPersistenceError(
           errorArg,
           `Atomic upsert-many conflicts with a unique index in collection "${collectionArg.collectionName}".`,
@@ -151,7 +197,7 @@ export const executeAtomicUpdateMany = async <T>(
     async (rawSessionArg, deadlineArg) => {
       await deadlineArg.join(collectionArg.init());
       try {
-        return await collectionArg.mongoDbCollection.updateMany(
+        const result = await collectionArg.mongoDbCollection.updateMany(
           filterArg,
           updateArg,
           {
@@ -159,6 +205,10 @@ export const executeAtomicUpdateMany = async <T>(
             ...deadlineArg.commandOptions(),
           },
         );
+        if (result.matchedCount > 0) {
+          reportSmartdataCollectionWrite(collectionArg, optsArg?.session, 'update', null, filterArg);
+        }
+        return result;
       } catch (errorArg) {
         return normalizeOrdinaryPersistenceError(
           errorArg,

package/ts/nosqldb/classes.bootstraprecord.ts

@@ -6,6 +6,7 @@ import { snapshotBoundedBsonDocument } from './classes.bsonsnapshot.js';
 import { validateOrdinaryStoredDocument } from './classes.ordinarypersistence.js';
 import { SmartdataPersistenceError, isMongoDuplicateKeyError } from './classes.persistence.js';
 import { readBoundedInspectionCursor } from './classes.namespaceinspection.js';
+import { reportSmartdataWrite } from './classes.session.js';
 import {
   collectionModelSchemaResolverSymbol, collectionTopologyDbInspectionSymbol,
   getExpectedCollectionTopologyForSchema, inspectCollectionTopologySnapshot,
@@ -96,7 +97,12 @@ export const insertBootstrapRecord = async (
         dispatched ? 'Bootstrap insertion outcome is uncertain; inspect its explicit ID before proceeding.'
           : 'Bootstrap insertion could not inspect the current database connection.');
     }
-    if (outcome === 'inserted') return Object.freeze({ acknowledged: true, insertedId: document._id as string });
+    if (outcome === 'inserted') {
+      reportSmartdataWrite(dbArg, undefined, {
+        collection: schema.collectionName, kind: 'insert', documents: [document],
+      });
+      return Object.freeze({ acknowledged: true, insertedId: document._id as string });
+    }
     const messages = {
       unique_conflict: 'Bootstrap record conflicts with a unique index.',
       invalid_configuration: 'Bootstrap insertion requires absent or exact primary-only collection topology.',

package/ts/nosqldb/classes.collection.ts

@@ -24,13 +24,16 @@ import { CollectionFactory } from './classes.collectionfactory.js';
 import { logger } from './logging.js';
 import {
   SmartdataPersistenceError,
+  getMongoBulkWriteErrorIndexes,
   isMongoIndexConflictError,
   normalizeOrdinaryPersistenceError,
 } from './classes.persistence.js';
 import { notifyCollectionReconnect } from './classes.collectionlifecycle.js';
 import type { SmartdataOperationDeadline } from './classes.operationdeadline.js';
+import { hasSmartdataWriteObservers } from './classes.writeobserver.js';
 import {
   leaseOrdinarySmartdataSession,
+  reportSmartdataCollectionWrite,
   runWithOrdinarySmartdataSession,
   type TSmartdataOrdinarySession,
 } from './classes.session.js';
@@ -2595,10 +2598,14 @@ export class SmartdataCollection<T> {
 
         const saveableObject = preparedObject ?? await dbDocArg.createSavableObject();
         try {
-          return await this.mongoDbCollection.insertOne(saveableObject, {
+          const result = await this.mongoDbCollection.insertOne(saveableObject, {
             session: rawSessionArg,
             ...deadlineArg.commandOptions(),
           });
+          if (result.acknowledged) {
+            reportSmartdataCollectionWrite(this, opts?.session, 'insert', [saveableObject]);
+          }
+          return result;
         } catch (err: any) {
           return normalizeOrdinaryPersistenceError(
             err,
@@ -2707,13 +2714,29 @@ export class SmartdataCollection<T> {
             saveableObjects.push(await dbDocArg.createSavableObject());
           }
         }
+        const reportInserted = (insertedIdsArg: Record<number, unknown> | undefined): void => {
+          const inserted = Object.keys(insertedIdsArg ?? {})
+            .map((indexArg) => saveableObjects[Number(indexArg)])
+            .filter((documentArg) => documentArg !== undefined);
+          if (inserted.length > 0) {
+            reportSmartdataCollectionWrite(this, opts?.session, 'insert', inserted);
+          }
+        };
         try {
-          return await this.mongoDbCollection.insertMany(saveableObjects, {
+          const result = await this.mongoDbCollection.insertMany(saveableObjects, {
             session: rawSessionArg,
             ordered: opts?.ordered !== false,
             ...deadlineArg.commandOptions(),
           });
+          if (result.acknowledged) {
+            reportInserted(result.insertedIds);
+          }
+          return result;
         } catch (err: any) {
+          // A batch that failed on write errors names the documents it still inserted.
+          if (getMongoBulkWriteErrorIndexes(err)) {
+            reportInserted((err as plugins.mongodb.MongoBulkWriteError).result?.insertedIds);
+          }
           return normalizeOrdinaryPersistenceError(
             err,
             `Insert conflicts with a unique index in collection "${this.collectionName}".`,
@@ -2756,6 +2779,14 @@ export class SmartdataCollection<T> {
       // seeded body must not repeat the immutable primary key: MongoDB derives
       // it from the filter's equality condition on the insert branch.
       const documentIdIdentity = this.modelSchema?.identityAsDocumentId === identityFieldArg;
+      const reportUpserted = (upsertedIdsArg: Record<number, unknown> | undefined): void => {
+        const inserted = Object.keys(upsertedIdsArg ?? {})
+          .map((indexArg) => prepared[Number(indexArg)])
+          .filter((documentArg) => documentArg !== undefined);
+        if (inserted.length > 0) {
+          reportSmartdataCollectionWrite(this, optsArg.session, 'insert', inserted);
+        }
+      };
       try {
         const result = await this.mongoDbCollection.bulkWrite(prepared.map((document) => {
           const { _id: storedId, ...body } = document as Record<string, unknown>;
@@ -2769,12 +2800,16 @@ export class SmartdataCollection<T> {
             },
           };
         }), { ordered: false, session: rawSessionArg, ...deadlineArg.commandOptions() });
+        reportUpserted(result.upsertedIds);
         if (result.upsertedCount + result.matchedCount !== prepared.length) {
           throw new SmartdataPersistenceError('unsupported_operation',
             'insertManyIfAbsent requires an acknowledged result for every identity.');
         }
         return { insertedCount: result.upsertedCount, matchedCount: result.matchedCount };
       } catch (errorArg) {
+        if (getMongoBulkWriteErrorIndexes(errorArg)) {
+          reportUpserted((errorArg as plugins.mongodb.MongoBulkWriteError).result?.upsertedIds);
+        }
         return normalizeOrdinaryPersistenceError(errorArg,
           `Insert conflicts with a unique index in collection "${this.collectionName}".`);
       }
@@ -2825,7 +2860,7 @@ export class SmartdataCollection<T> {
           updateableObject[key] = saveableObject[key];
         }
         try {
-          return await this.mongoDbCollection.updateOne(
+          const result = await this.mongoDbCollection.updateOne(
             identifiableObject,
             {
               $set: updateableObject,
@@ -2835,6 +2870,16 @@ export class SmartdataCollection<T> {
             },
             { upsert: true, session: rawSessionArg, ...deadlineArg.commandOptions() },
           );
+          if (result.upsertedCount > 0 || result.matchedCount > 0) {
+            reportSmartdataCollectionWrite(
+              this,
+              opts?.session,
+              result.upsertedCount > 0 ? 'insert' : 'update',
+              [saveableObject],
+              identifiableObject,
+            );
+          }
+          return result;
         } catch (errorArg) {
           return normalizeOrdinaryPersistenceError(
             errorArg,
@@ -2857,10 +2902,24 @@ export class SmartdataCollection<T> {
         await this.checkDoc(dbDocArg);
         const identifiableObject = await dbDocArg.createIdentifiableObject();
         this.assertConstrainingIdentifiableObject(identifiableObject, 'delete');
-        return this.mongoDbCollection.deleteOne(identifiableObject, {
+        // Serialized before the delete, so a failing serializer never fails an acknowledged delete.
+        const observedDocument = hasSmartdataWriteObservers(this.smartdataDb)
+          ? await dbDocArg.createSavableObject() as object
+          : undefined;
+        const result = await this.mongoDbCollection.deleteOne(identifiableObject, {
           session: rawSessionArg,
           ...deadlineArg.commandOptions(),
         });
+        if (result.deletedCount > 0) {
+          reportSmartdataCollectionWrite(
+            this,
+            opts?.session,
+            'delete',
+            observedDocument ? [observedDocument] : null,
+            identifiableObject,
+          );
+        }
+        return result;
       },
     );
   }