@lossless.org/nosqldb 10.5.1 → 10.6.1

package/dist_rust/rustdb_linux_amd64.tsrust-build.json

@@ -1,13 +1,13 @@
 {
   "format": "tsrust.build-provenance.v2",
-  "binarySha256": "8c37f2f7145d294c088c5d654c1b34c81defaf44de9229dbf31df5088ac21f86",
+  "binarySha256": "45c8b46b088226aabaf6b260d1b4cd33f630b9f350f412fc9526f63754ebf8ed",
   "buildInfo": {
     "projectName": "@lossless.org/nosqldb",
-    "projectVersion": "10.5.1",
-    "gitCommit": "56110dace6865cf5deb07908ba50bf3c8849621f",
+    "projectVersion": "10.6.1",
+    "gitCommit": "8a382123c5eb00f062a89c786c87f0588332f0a7",
     "gitDirty": false,
-    "builtAt": "2026-09-24T21:04:53.734Z",
-    "tsrustVersion": "1.13.2",
+    "builtAt": "2026-09-26T11:38:26.096Z",
+    "tsrustVersion": "1.15.1",
     "binary": "rustdb",
     "target": "linux_amd64"
   }

package/dist_rust/rustdb_linux_amd64_musl.tsrust-build.json

@@ -1,13 +1,13 @@
 {
   "format": "tsrust.build-provenance.v2",
-  "binarySha256": "2def4672487def714c557582068f103345e3cb82f7d529acc8507f1df1ee89da",
+  "binarySha256": "69c2b52877d8d92145f105263807d1ee7e5c41fab58ffe6adcc8ad6f4c9a6e30",
   "buildInfo": {
     "projectName": "@lossless.org/nosqldb",
-    "projectVersion": "10.5.1",
-    "gitCommit": "56110dace6865cf5deb07908ba50bf3c8849621f",
+    "projectVersion": "10.6.1",
+    "gitCommit": "8a382123c5eb00f062a89c786c87f0588332f0a7",
     "gitDirty": false,
-    "builtAt": "2026-09-24T21:04:54.616Z",
-    "tsrustVersion": "1.13.2",
+    "builtAt": "2026-09-26T11:38:26.947Z",
+    "tsrustVersion": "1.15.1",
     "binary": "rustdb",
     "target": "linux_amd64_musl"
   }

package/dist_rust/rustdb_linux_arm64.tsrust-build.json

@@ -1,13 +1,13 @@
 {
   "format": "tsrust.build-provenance.v2",
-  "binarySha256": "1c92e0c5dec9c53fc175eda8fb4fc32e78f8075672170feed3542ce58337491b",
+  "binarySha256": "bdb5b22a9d6d338e0a8474fec47233fa0da53f7a7e4771958ce32e75e6102da7",
   "buildInfo": {
     "projectName": "@lossless.org/nosqldb",
-    "projectVersion": "10.5.1",
-    "gitCommit": "56110dace6865cf5deb07908ba50bf3c8849621f",
+    "projectVersion": "10.6.1",
+    "gitCommit": "8a382123c5eb00f062a89c786c87f0588332f0a7",
     "gitDirty": false,
-    "builtAt": "2026-09-24T21:04:54.182Z",
-    "tsrustVersion": "1.13.2",
+    "builtAt": "2026-09-26T11:38:26.518Z",
+    "tsrustVersion": "1.15.1",
     "binary": "rustdb",
     "target": "linux_arm64"
   }

package/dist_rust/rustdb_linux_arm64_musl.tsrust-build.json

@@ -1,13 +1,13 @@
 {
   "format": "tsrust.build-provenance.v2",
-  "binarySha256": "0e46f1e7642c78ad1f5185ed3ede057a7885b95ff6429a58574f7df11b3105a0",
+  "binarySha256": "e08e92879b6a3c1f8f5e91a90bb0c26cf5a6500af87bbf129f4c0833a1c21a61",
   "buildInfo": {
     "projectName": "@lossless.org/nosqldb",
-    "projectVersion": "10.5.1",
-    "gitCommit": "56110dace6865cf5deb07908ba50bf3c8849621f",
+    "projectVersion": "10.6.1",
+    "gitCommit": "8a382123c5eb00f062a89c786c87f0588332f0a7",
     "gitDirty": false,
-    "builtAt": "2026-09-24T21:04:55.038Z",
-    "tsrustVersion": "1.13.2",
+    "builtAt": "2026-09-26T11:38:27.390Z",
+    "tsrustVersion": "1.15.1",
     "binary": "rustdb",
     "target": "linux_arm64_musl"
   }

package/dist_rust/rustdb_macos_amd64.tsrust-build.json

@@ -1,13 +1,13 @@
 {
   "format": "tsrust.build-provenance.v2",
-  "binarySha256": "935b424dae329677ff6fcdba1cfb2a16a6eb15e334c4fc37bbb5186cd7ba8f4f",
+  "binarySha256": "bc8d7bed405a7aea9281f786c2cb845836c109a577882403dff5cae1ddab2e3b",
   "buildInfo": {
     "projectName": "@lossless.org/nosqldb",
-    "projectVersion": "10.5.1",
-    "gitCommit": "56110dace6865cf5deb07908ba50bf3c8849621f",
+    "projectVersion": "10.6.1",
+    "gitCommit": "8a382123c5eb00f062a89c786c87f0588332f0a7",
     "gitDirty": false,
-    "builtAt": "2026-09-24T20:49:57.292Z",
-    "tsrustVersion": "1.13.2",
+    "builtAt": "2026-09-26T11:22:15.998Z",
+    "tsrustVersion": "1.15.1",
     "binary": "rustdb",
     "target": "macos_amd64"
   }

package/dist_rust/rustdb_macos_arm64.tsrust-build.json

@@ -1,13 +1,13 @@
 {
   "format": "tsrust.build-provenance.v2",
-  "binarySha256": "a1f4451de5227383ac797ec36ea255f1d281d696ad9b17efefa9244a989c3881",
+  "binarySha256": "f7b402ccadcdf3e272b82c07f1af67ebbc1556d5b6d7c974383771b643cb8f14",
   "buildInfo": {
     "projectName": "@lossless.org/nosqldb",
-    "projectVersion": "10.5.1",
-    "gitCommit": "56110dace6865cf5deb07908ba50bf3c8849621f",
+    "projectVersion": "10.6.1",
+    "gitCommit": "8a382123c5eb00f062a89c786c87f0588332f0a7",
     "gitDirty": false,
-    "builtAt": "2026-09-24T20:49:57.881Z",
-    "tsrustVersion": "1.13.2",
+    "builtAt": "2026-09-26T11:22:16.581Z",
+    "tsrustVersion": "1.15.1",
     "binary": "rustdb",
     "target": "macos_arm64"
   }

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@lossless.org/nosqldb',
-    version: '10.5.1',
+    version: '10.6.1',
     description: 'A MongoDB-compatible embedded database server with wire protocol support, backed by a high-performance Rust engine.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx1QkFBdUI7SUFDN0IsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLHFIQUFxSDtDQUNuSSxDQUFBIn0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lossless.org/nosqldb",
-  "version": "10.5.1",
+  "version": "10.6.1",
   "private": false,
   "description": "A MongoDB-compatible embedded database server with wire protocol support, backed by a high-performance Rust engine.",
   "exports": {
@@ -16,10 +16,10 @@
     "@design.estate/dees-element": "^2.2.4",
     "@git.zone/tsbuild": "^5.0.0",
     "@git.zone/tsbundle": "^2.15.0",
-    "@git.zone/tsrust": "^1.13.2",
-    "@git.zone/tstest": "^6.2.0",
+    "@git.zone/tsrust": "^1.15.1",
+    "@git.zone/tstest": "^6.3.0",
     "@lossless.org/client": "0.1.1",
-    "@types/node": "26.6.1",
+    "@types/node": "26.6.2",
     "mongodb": "^7.5.0"
   },
   "dependencies": {

package/readme.md

@@ -554,21 +554,60 @@ authority. Auth changes and the data/control records they protect share native
 atomic publications.
 
 Single-node transactions pin one committed root across namespaces and retain
-changed documents, rather than copying a database. Supported reads and writes
-see the transaction snapshot plus its staged changes. Commit validates conflicts
-and publishes atomically; abort discards staged changes. Write conflicts report
-`WriteConflict` (112) with `TransientTransactionError`.
-
-A staged write conflicts when it touches a document `_id` or a unique index key
-that another transaction or statement wrote after this transaction's snapshot:
-for example two transactions that both read a claim as absent and then insert
-it under the same `_id`, or under distinct `_id`s with the same unique key.
-Statements validate against the snapshot, so such a collision is reported when
-the loser commits; nothing of the losing transaction is published. The driver's
-`withTransaction` retries the transient error, and the retry observes the
-winner. A key already visible in the transaction's snapshot is not a conflict:
-inserting it fails the statement with `DuplicateKey` (11000), as outside a
-transaction.
+changed documents, rather than copying a database. The snapshot is pinned by
+the transaction's first statement. Supported reads and writes see the
+transaction snapshot plus its staged changes. Commit publishes atomically;
+abort discards staged changes.
+
+Write conflicts follow MongoDB: the first statement to write a document or a
+unique index key wins, and the later writer is told at its own statement.
+
+- A transaction statement that inserts, updates, replaces, deletes or upserts a
+  document, or claims or releases a unique index key, that another open
+  transaction has already written fails with `WriteConflict` (112) and
+  `TransientTransactionError`. So does a write to a document or key that was
+  published after the transaction's snapshot. The failed statement aborts the
+  transaction at once and releases everything it wrote: later statements and
+  `commitTransaction` report `NoSuchTransaction` (251), also labelled
+  `TransientTransactionError`. The transaction that wrote first keeps its
+  documents and commits. The driver's `withTransaction` retries the loser on a
+  fresh snapshot, so a transaction that writes a hot document and then does more
+  work makes progress against clients looping short transactions on it.
+- Reads never conflict: they see the snapshot, not another transaction's
+  uncommitted writes. A statement that writes nothing (a filter that matches
+  nothing in the snapshot, an update that leaves the document unchanged) does
+  not conflict either.
+- A write outside a transaction that meets an open transaction's uncommitted
+  write waits until that transaction commits or aborts, then runs on the new
+  state: after a commit it applies on top of the transaction's write, and a
+  unique key the transaction claimed becomes `DuplicateKey` (11000). The wait
+  is bounded by `maxTimeMS`, which ends it with `MaxTimeMSExpired` (50) and
+  nothing written, and holds no write worker, so the transaction can always
+  finish. Writes to other documents are not delayed. A multi-document write
+  outside a transaction stays all-or-nothing: it publishes nothing until it can
+  publish every document.
+- After a transaction has been open for 60 seconds, its uncommitted writes no
+  longer block others: the next writer that needs one of its documents aborts
+  it, and it reports `NoSuchTransaction` (251) on its next statement or commit.
+  The limit is fixed at MongoDB's default `transactionLifetimeLimitSeconds` and
+  is not configurable. A transaction nobody contends with is not
+  aborted by age alone. Ending or expiring the session, and stopping the
+  server, release a transaction's writes as well.
+- TTL expiry is not a contending writer. It leaves out the documents an open
+  transaction has written, deletes the other expired documents of the index
+  and moves past the held ones. A later pass over the index expires those
+  still expired once the transaction has ended. It never waits for a transaction and never aborts
+  one, whatever its age. MongoDB's TTL monitor instead retries a conflicting delete until
+  the transaction ends and leaves aborting it to its transaction reaper.
+- A key already visible in the transaction's snapshot is not a conflict:
+  inserting it fails the statement with `DuplicateKey` (11000), as outside a
+  transaction. A collection created inside a transaction has no stored identity
+  until commit, so two transactions creating the same collection both succeed
+  their statements and the second commit reports `WriteConflict` (112), as on
+  MongoDB 7.
+
+Write intents live in memory only; no transaction survives a restart, so
+there is nothing to recover.
 
 Commit/abort outcomes and successful retryable statement results survive file
 storage restart. Duplicate commits replay their outcome; abort after commit
@@ -1309,7 +1348,7 @@ await collection.findOneAndReplace({ _id: id }, { name: 'Replaced' }, { returnDo
 
 // Element
 { email: { $exists: true } }
-{ type: { $type: 'string' } }
+{ type: { $type: 'string' } }       { value: { $type: ['int', 'long'] } }
 
 // Array
 { tags: { $all: ['mongodb', 'database'] } }
@@ -1318,8 +1357,28 @@ await collection.findOneAndReplace({ _id: id }, { name: 'Replaced' }, { returnDo
 
 // Regex
 { name: { $regex: /^Al/i } }
+
+// Aggregation expressions
+{ owner: 'o', $expr: { $lte: [{ $add: ['$retainedBytes', '$reservedBytes', size] }, max] } }
+{ $expr: { $gt: ['$leaseExpiresAt', '$$NOW'] } }
 ```
 
+`$type` takes a type alias (`'string'`, `'number'`, …), a numeric BSON type
+code or an array of them, and matches an array field through its elements as
+well as `'array'` itself.
+
+`$expr` evaluates an aggregation expression per document in `find`, `count`,
+`distinct`, `update`, `delete`, `findAndModify` and a `$match` stage, and
+matches when the result is truthy. It accepts the operators listed under
+[Aggregation Pipeline](#aggregation-pipeline). Evaluation is charged against
+the same work budget as every other predicate, and an operator the engine does
+not implement is refused by name with `TypeMismatch` (code 14) before any
+document is read. `$$NOW` is one instant per command, as in MongoDB: the
+engine reads the clock once when the command starts, and the command's filter,
+every document of a pipeline update, every aggregation stage, `$lookup` and
+`$unionWith` sub-pipeline, and every `getMore` of its cursor see that instant.
+Filters outside a command, such as a partial index filter, have no `$$NOW`.
+
 ### Update Operators
 
 ```typescript
@@ -1356,15 +1415,57 @@ const results = await collection.aggregate([
 
 **Supported stages:** `$match`, `$project`, `$group`, `$sort`, `$limit`, `$skip`, `$unwind`, `$lookup`, `$addFields`, `$count`, `$facet`, `$replaceRoot`, `$set`, `$unionWith`, `$out`, `$merge`
 
-**Supported expression operators:** `$eq`, `$and`, `$literal`, `$map`,
-`$objectToArray`, `$setEquals`, plus `$field` paths, `$$variable` references
-including `$$ROOT`, and documents or arrays of those. Every other operator is
-refused by name with `TypeMismatch` (code 14) before any document is read; the
-engine never treats an operator it cannot execute as a literal value.
+**Supported expression operators:**
+
+| Group | Operators |
+| --- | --- |
+| Comparison | `$eq`, `$ne`, `$gt`, `$gte`, `$lt`, `$lte`, `$cmp` |
+| Arithmetic | `$add`, `$subtract`, `$multiply`, `$divide` |
+| Logical | `$and`, `$or`, `$not` |
+| Conditional and variables | `$cond` (array or `if`/`then`/`else` form), `$ifNull` (two or more operands), `$let` |
+| Type and arrays | `$isNumber`, `$type`, `$in`, `$size`, `$arrayElemAt` |
+| Dates | `$dateAdd` |
+| Collections | `$map`, `$objectToArray`, `$setEquals` |
+| Literals | `$literal` |
+
+plus `$field` paths, `$$variable` references including `$$ROOT` and `$$NOW`,
+and documents or arrays of those. Every other operator is refused by name with
+`TypeMismatch` (code 14) before any document is read; the engine never treats
+an operator it cannot execute as a literal value.
+
+Expressions follow MongoDB's value semantics. A field that is absent is
+*missing*, which is not `null`: `$type` answers `'missing'`, `$ifNull`
+replaces both, and comparisons order values as MongoDB does (MinKey, missing,
+`null`, numbers, strings, objects, arrays, binary data, ObjectIds, booleans,
+dates, timestamps, regular expressions, MaxKey), so `{ $eq: ['$absent', null] }`
+is false. Numbers compare by value across their wire types. A path through an
+array maps over its elements and always answers an array: `'$mailbox.path'`
+over one looked-up document is `['INBOX']`, so `$arrayElemAt` and `$size`
+apply to it. Arithmetic answers `null` when an operand is `null` or missing;
+an int result that overflows widens to a long and a long to a double, a double
+operand makes the result a double, and `$divide` always answers a double.
+`$add` accepts one date and answers a date; date minus date is milliseconds.
+Runtime errors keep MongoDB 7's codes: a non-numeric operand is
+`TypeMismatch` (14), `can't $divide by zero` is `BadValue` (2), a date that
+leaves the 64-bit range is `Overflow` (15), and the array and date operators
+answer MongoDB's location codes (a second date in `$add` 16612, `$in` without
+an array 40081, `$size` without an array 17124, `$arrayElemAt` 28689–28691,
+`$dateAdd` 5166403, 5166405, 5166406 and 5439013, a non-string time zone
+40517, an unknown unit `FailedToParse` (9)). Decimal128 operands in arithmetic
+are refused with `TypeMismatch` (14) — decimal arithmetic is not
+implemented. `$and`, `$or`, `$cond` and `$ifNull`
+evaluate, and charge, only the operands MongoDB evaluates, so a guard keeps an
+invalid branch from failing the statement. `$dateAdd` computes in UTC with the
+units `millisecond` to `year`, clamping `month`, `quarter` and `year` to the
+end of the target month; a `timezone` other than UTC is refused by name.
+Within a document expression a member that is missing is still written as
+`null`, where MongoDB omits the member.
 
 `$lookup` supports the equality form and a bounded correlated pipeline form with
-`let`, an optional `$match` using `$expr`/`$and`/`$eq`, and an optional following
-`$limit`. Correlated string equality predicates can use a full-key or subset
+`let`, an optional `$match` (any filter, `$expr` included), and an optional
+following `$limit`. A `let` variable that reads an absent local field is bound
+to the missing value, as in MongoDB. Correlated string equality predicates
+(`$expr` with `$eq`, optionally under `$and`) can use a full-key or subset
 foreign equality index to reduce candidates when available. Candidates are
 paged, the complete expression remains authoritative, and `$limit` counts only
 exact expression matches. Other BSON value shapes use the bounded scan path.
@@ -1379,6 +1480,18 @@ matcher cannot pre-compile fall back to the unnarrowed load, so results are
 unchanged. The materialization limit therefore applies to the matched set, which
 is what lets `countDocuments(filter)` run against collections larger than it.
 
+The scalar members of a `$in` or `$nin` list are looked up in a set built when
+the filter is validated, so a document costs the size of its value, not the
+length of the list: `countDocuments({ _id: { $in: ids } })` answers for tens of
+thousands of ids. Equality is unchanged: numbers of every type are equal by
+value (1, `NumberLong(1)`, 1.0 and `NumberDecimal("1.00")`), an array field
+matches through its elements or as a whole, and a missing field matches a list
+that holds `null`. Documents, arrays and regular expressions in a list are
+compared one by one and charged as such. A regular expression in a list is
+still compared as a value and not yet applied to strings, which differs from
+MongoDB, where it matches the strings it describes; that difference is a known
+open defect.
+
 **Group accumulators:** `$sum`, `$avg`, `$min`, `$max`, `$first`, `$last`, `$push`, `$addToSet`, `$count`
 
 `$group._id` accepts a literal (`null`, a number, a string), a `$field`
@@ -1408,12 +1521,50 @@ await collection.dropIndexes();  // drop all except _id
 > 🛡️ **Unique indexes are enforced at the engine level.** Duplicate values are rejected with a `DuplicateKey` error (code 11000) *before* the document is written to disk — on `insertOne`, `updateOne`, `findAndModify`, and upserts. Index definitions and entries are committed with native storage and survive restart.
 
 NoSQLDB supports ascending and descending index keys with `name`, `unique`,
-`sparse`, and `expireAfterSeconds` options. It accepts `background` as a
-validated no-op and index version `v: 2`. Unsupported options, including
-`partialFilterExpression`, `collation`, and `hidden`, are rejected before any
-index in the request is created. Native maintenance expires eligible BSON dates
-and date arrays in bounded batches, preserving publication holds and active
-snapshots.
+`sparse`, `partialFilterExpression` and `expireAfterSeconds` options. It
+accepts `background` as a validated no-op and index version `v: 2`.
+Unsupported options, including `collation` and `hidden`, are rejected before
+any index in the request is created. Native maintenance expires eligible BSON
+dates and date arrays in bounded batches, preserving publication holds and
+active snapshots.
+
+**Partial indexes.** An index with a `partialFilterExpression` holds only the
+documents that match the filter, and a unique partial index enforces
+uniqueness among those documents only:
+
+```typescript
+await jobs.createIndex(
+  { activeClaimKey: 1 },
+  { unique: true, partialFilterExpression: { activeClaimKey: { $exists: true } } },
+);
+await pulls.createIndex(
+  { org: 1, repo: 1, sourceRef: 1, targetRef: 1 },
+  { unique: true, partialFilterExpression: { state: 'open' } },
+);
+```
+
+The filter accepts MongoDB's subset: equality (`field: value` or `$eq`),
+`$exists: true`, `$gt`, `$gte`, `$lt`, `$lte`, `$type`, `$in`, `$and` and
+`$or`, nested at most four expression levels deep. Any other expression —
+`$exists: false`, `$ne`, `$nin`, `$not`, `$nor`, regular expressions,
+`$elemMatch`, `$size`, `$expr`, and a regular expression inside `$in` — and a
+filter combined with `sparse` are refused with `CannotCreateIndex` (code 67);
+a malformed filter is `BadValue` (2) and a non-document is `TypeMismatch` (14).
+An update that moves a document into the filter claims its key, one that moves
+it out releases it, and transactions claim keys the same way, so a racing
+claim is a `WriteConflict` (112) with `TransientTransactionError`.
+`listIndexes`, canonical export and import report the filter exactly as it was
+created. The filter identifies the index: the same name with a different
+filter is `IndexKeySpecsConflict` (86); the same key with an equivalent filter
+under another name is `IndexOptionsConflict` (85); a different filter over the
+same key under another name is a separate index. Equivalence treats implicit
+equality and `$eq`, the order of conjuncts and `$or` branches, numeric wire
+types and `$in` duplicates as MongoDB's normalised expressions do. The query
+planner never selects a partial index on its own; a `hint` naming one reads
+only its members, as MongoDB's hinted scan does. A partial TTL index expires
+only its members. Engines older than this release refuse a storage root that
+holds a partial index instead of enforcing its uniqueness over every
+document.
 
 `find()` and collection `aggregate()` accept `hint` as an index name (including
 `_id_`) or an exact ascending/descending key pattern. Key-pattern order matters;

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@lossless.org/nosqldb',
-  version: '10.5.1',
+  version: '10.6.1',
   description: 'A MongoDB-compatible embedded database server with wire protocol support, backed by a high-performance Rust engine.'
 }