@antelopejs/interface-database 0.1.4 → 0.1.5

package/docs/1.query_types/9.valueproxy.md

@@ -44,7 +44,10 @@ Logical operators for combining boolean expressions.
 
 ```typescript
 const canAccess = user.key("active").and(user.key("verified"));
-const isSpecial = user.key("role").eq("admin").or(user.key("plan").eq("premium"));
+const isSpecial = user
+  .key("role")
+  .eq("admin")
+  .or(user.key("plan").eq("premium"));
 const isInactive = user.key("active").not();
 ```
 
@@ -97,12 +100,12 @@ const isRecent = date.ge(new Date("2024-01-01"));
 const isBefore = date.lt(deadline);
 ```
 
-| Method   | Description            |
-| -------- | ---------------------- |
-| `gt(v)`  | Greater than           |
-| `ge(v)`  | Greater than or equal  |
-| `lt(v)`  | Less than              |
-| `le(v)`  | Less than or equal     |
+| Method  | Description           |
+| ------- | --------------------- |
+| `gt(v)` | Greater than          |
+| `ge(v)` | Greater than or equal |
+| `lt(v)` | Less than             |
+| `le(v)` | Less than or equal    |
 
 ## Date Operations
 
@@ -127,7 +130,7 @@ const h = created.hours();
 const min = created.minutes();
 const sec = created.seconds();
 const tod = created.timeofday(); // seconds since midnight
-const epoch = created.epoch();   // seconds since UNIX epoch
+const epoch = created.epoch(); // seconds since UNIX epoch
 ```
 
 ### Range Check
@@ -152,14 +155,14 @@ const len = name.strlen();
 const matches = email.match("^.*@gmail\\.com$");
 ```
 
-| Method              | Description                    |
-| ------------------- | ------------------------------ |
-| `upcase()`          | Convert to uppercase           |
-| `downcase()`        | Convert to lowercase           |
-| `split(sep, max?)`  | Split by separator             |
-| `concat(other)`     | Concatenate with another string|
-| `strlen()`          | Number of Unicode codepoints   |
-| `match(regex)`      | Test against a regex pattern   |
+| Method             | Description                     |
+| ------------------ | ------------------------------- |
+| `upcase()`         | Convert to uppercase            |
+| `downcase()`       | Convert to lowercase            |
+| `split(sep, max?)` | Split by separator              |
+| `concat(other)`    | Concatenate with another string |
+| `strlen()`         | Number of Unicode codepoints    |
+| `match(regex)`     | Test against a regex pattern    |
 
 ## Array Operations
 
@@ -179,19 +182,19 @@ const lowest = scores.min();
 const highest = scores.max();
 ```
 
-| Method           | Description                        |
-| ---------------- | ---------------------------------- |
-| `index(n)`       | Element at position `n`            |
-| `includes(val)`  | Check if the array contains a value|
-| `slice(s, e?)`   | Extract a sub-array                |
-| `map(fn)`        | Transform each element             |
-| `filter(fn)`     | Keep elements matching a predicate |
-| `isempty()`      | Check if the array is empty        |
-| `count()`        | Number of elements                 |
-| `sum()`          | Sum of numeric elements            |
-| `avg()`          | Average of numeric elements        |
-| `min()`          | Minimum of numeric elements        |
-| `max()`          | Maximum of numeric elements        |
+| Method          | Description                         |
+| --------------- | ----------------------------------- |
+| `index(n)`      | Element at position `n`             |
+| `includes(val)` | Check if the array contains a value |
+| `slice(s, e?)`  | Extract a sub-array                 |
+| `map(fn)`       | Transform each element              |
+| `filter(fn)`    | Keep elements matching a predicate  |
+| `isempty()`     | Check if the array is empty         |
+| `count()`       | Number of elements                  |
+| `sum()`         | Sum of numeric elements             |
+| `avg()`         | Average of numeric elements         |
+| `min()`         | Minimum of numeric elements         |
+| `max()`         | Maximum of numeric elements         |
 
 ## Object Operations
 
@@ -206,13 +209,13 @@ const fieldValues = user.values();
 const hasRequired = user.hasfields("email", "name");
 ```
 
-| Method             | Description                          |
-| ------------------ | ------------------------------------ |
-| `key(k, def?)`     | Access a field, with optional default|
-| `merge(other)`     | Merge with another object            |
-| `keys()`           | Array of field names                 |
-| `values()`         | Array of field values                |
-| `hasfields(...fs)` | Check if all specified fields exist  |
+| Method             | Description                           |
+| ------------------ | ------------------------------------- |
+| `key(k, def?)`     | Access a field, with optional default |
+| `merge(other)`     | Merge with another object             |
+| `keys()`           | Array of field names                  |
+| `values()`         | Array of field values                 |
+| `hasfields(...fs)` | Check if all specified fields exist   |
 
 ## Compose Expressions
 
@@ -220,11 +223,10 @@ ValueProxy methods are chainable, enabling complex expressions within query call
 
 ```typescript
 const result = await users.filter((user) =>
-  user.key("age").ge(18)
+  user
+    .key("age")
+    .ge(18)
     .and(user.key("status").eq("active"))
-    .and(
-      user.key("role").eq("admin")
-        .or(user.key("plan").eq("premium")),
-    ),
+    .and(user.key("role").eq("admin").or(user.key("plan").eq("premium"))),
 );
 ```

package/docs/2.operations/2.database_management.md

@@ -37,8 +37,8 @@ interface TableDefinition {
 }
 
 interface IndexDefinition {
-  fields?: string[];  // For compound indexes
-  multi?: boolean;    // Multi-valued index
+  fields?: string[]; // For compound indexes
+  multi?: boolean; // Multi-valued index
 }
 ```
 

package/docs/2.operations/3.table_operations.md

@@ -30,7 +30,7 @@ const users = db.table<User>("users");
 
 // TypeScript now validates field names and types
 const user = await users.get("user-123"); // user is User | null
-const emails = await users.key("email");  // string[]
+const emails = await users.key("email"); // string[]
 ```
 
 ## Basic Operations

package/docs/2.operations/4.crud.md

@@ -89,8 +89,7 @@ const recent = await users.between(
 ```typescript
 // Filter with a predicate function
 const active = await users.filter((user) =>
-  user.key("status").eq("active")
-    .and(user.key("age").ge(18)),
+  user.key("status").eq("active").and(user.key("age").ge(18)),
 );
 ```
 

package/docs/2.operations/5.indexes.md

@@ -13,8 +13,8 @@ const schema = new Schema("myapp", {
   users: {
     fields: { name: "string", email: "string", role: "string", age: "number" },
     indexes: {
-      email: {},                           // Simple index on the "email" field
-      role: {},                            // Simple index on the "role" field
+      email: {}, // Simple index on the "email" field
+      role: {}, // Simple index on the "role" field
       name_age: { fields: ["name", "age"] }, // Compound index
     },
   },
@@ -25,8 +25,8 @@ const schema = new Schema("myapp", {
 
 ```typescript
 interface IndexDefinition {
-  fields?: string[];  // Fields for compound indexes (omit for single-field)
-  multi?: boolean;    // Whether this is a multi-valued index
+  fields?: string[]; // Fields for compound indexes (omit for single-field)
+  multi?: boolean; // Whether this is a multi-valued index
 }
 ```
 

package/docs/2.operations/6.filtering.md

@@ -14,9 +14,7 @@ const users = schema.instance().table("users");
 Use the `filter` method with a predicate function. The callback receives a `ValueProxy<T>` representing each document.
 
 ```typescript
-const active = await users.filter((user) =>
-  user.key("status").eq("active"),
-);
+const active = await users.filter((user) => user.key("status").eq("active"));
 ```
 
 ## Comparison Operators
@@ -53,17 +51,14 @@ const important = await users.filter((u) =>
 );
 
 // NOT
-const standard = await users.filter((u) =>
-  u.key("plan").eq("premium").not(),
-);
+const standard = await users.filter((u) => u.key("plan").eq("premium").not());
 
 // Complex combinations
 const target = await users.filter((u) =>
-  u.key("status").eq("active")
-    .and(
-      u.key("plan").eq("premium")
-        .or(u.key("totalPurchases").gt(500)),
-    ),
+  u
+    .key("status")
+    .eq("active")
+    .and(u.key("plan").eq("premium").or(u.key("totalPurchases").gt(500))),
 );
 ```
 
@@ -71,9 +66,7 @@ const target = await users.filter((u) =>
 
 ```typescript
 // Case-insensitive match
-const bobs = await users.filter((u) =>
-  u.key("name").downcase().eq("bob"),
-);
+const bobs = await users.filter((u) => u.key("name").downcase().eq("bob"));
 
 // Regex matching
 const gmailUsers = await users.filter((u) =>
@@ -96,7 +89,9 @@ const newUsers = await users.filter((u) =>
 );
 
 const q1Users = await users.filter((u) =>
-  u.key("createdAt").ge(new Date("2024-01-01"))
+  u
+    .key("createdAt")
+    .ge(new Date("2024-01-01"))
     .and(u.key("createdAt").lt(new Date("2024-04-01"))),
 );
 ```
@@ -104,9 +99,7 @@ const q1Users = await users.filter((u) =>
 ### Date Components
 
 ```typescript
-const thisYear = await users.filter((u) =>
-  u.key("createdAt").year().eq(2024),
-);
+const thisYear = await users.filter((u) => u.key("createdAt").year().eq(2024));
 
 const morningLogins = await users.filter((u) =>
   u.key("lastLogin").hours().lt(12),
@@ -117,19 +110,22 @@ const morningLogins = await users.filter((u) =>
 
 ```typescript
 // Check array contents
-const jsPosts = await schema.instance().table("posts").filter((post) =>
-  post.key("tags").includes("javascript"),
-);
+const jsPosts = await schema
+  .instance()
+  .table("posts")
+  .filter((post) => post.key("tags").includes("javascript"));
 
 // Check array length
-const wellTagged = await schema.instance().table("posts").filter((post) =>
-  post.key("tags").count().gt(3),
-);
+const wellTagged = await schema
+  .instance()
+  .table("posts")
+  .filter((post) => post.key("tags").count().gt(3));
 
 // Check if empty
-const untagged = await schema.instance().table("posts").filter((post) =>
-  post.key("tags").isempty(),
-);
+const untagged = await schema
+  .instance()
+  .table("posts")
+  .filter((post) => post.key("tags").isempty());
 ```
 
 ## Default Values in Filters

package/docs/2.operations/7.lookup.md

@@ -4,11 +4,11 @@ The `lookup` method performs a foreign key join, replacing a field in your docum
 
 ## Parameters
 
-| Parameter  | Type           | Description                                          |
-| ---------- | -------------- | ---------------------------------------------------- |
-| `other`    | `Selection<U>` | The table containing the referenced documents        |
+| Parameter  | Type           | Description                                               |
+| ---------- | -------------- | --------------------------------------------------------- |
+| `other`    | `Selection<U>` | The table containing the referenced documents             |
 | `localKey` | `keyof T`      | The field in the current document holding the foreign key |
-| `otherKey` | `keyof U`      | The field in the other table to match against        |
+| `otherKey` | `keyof U`      | The field in the other table to match against             |
 
 ## Behavior
 
@@ -122,16 +122,14 @@ const withLookup = await db
 // order.customerId is now the full customer object
 
 // Join: custom output structure
-const withJoin = await db
-  .table("orders")
-  .joinInner(
-    db.table("customers"),
-    (order, customer) => order.key("customerId").eq(customer.key("_id")),
-    (order, customer) => ({
-      orderId: order.key("_id"),
-      orderTotal: order.key("total"),
-      customerName: customer.key("name"),
-    }),
-  );
+const withJoin = await db.table("orders").joinInner(
+  db.table("customers"),
+  (order, customer) => order.key("customerId").eq(customer.key("_id")),
+  (order, customer) => ({
+    orderId: order.key("_id"),
+    orderTotal: order.key("total"),
+    customerName: customer.key("name"),
+  }),
+);
 // Result is a custom object with selected fields from both tables
 ```

package/docs/2.operations/8.atomic_mutations.md

@@ -0,0 +1,71 @@
+# Atomic single-record mutations
+
+`Table.atomicMutation(id, request)` checks one immutable, instance-scoped record identity and one condition inside the database mutation. It returns `Query<AtomicMutationOutcome>`. It does not provide multi-record transactions, a lock service, receipts, or external-effect coordination.
+
+Generic `filter(...).update(...)` and `filter(...).delete()` do **not** promise this guarantee. Use a direct `schema.instance(instanceId).table(tableId)` with one literal string identity. The default instance is supported; `CROSS_INSTANCE`, filtered selections, expression keys, cursors, and upserts are not.
+
+## Compare a revision
+
+Public types are exported from `@antelopejs/interface-database` and `@antelopejs/interface-database/atomic`. An update checks the current revision and installs the patch and next revision together. A delete checks the revision inside the deletion.
+
+```ts
+const outcome = await table.atomicMutation(recordId, {
+  type: "update",
+  revisionField: "revision",
+  expectedRevision: observed.revision,
+  nextRevision: freshRevision,
+  patch: { title: "Updated title" },
+});
+
+const deletion = await table.atomicMutation(recordId, {
+  type: "delete",
+  revisionField: "revision",
+  expectedRevision: observed.revision,
+});
+```
+
+Revision tokens are nonempty strings. Each update must install a changed token that the caller guarantees has never been used for that identity. All writers of protected state must advance the revision; otherwise a successful comparison does not prove that the observed state is current. Initialize new records with fresh revisions and use a new identity for each incarnation, including recreation after deletion.
+
+`expectedRevision: { kind: "missing" }` matches an **absent revision field on an existing record**. It does not match a stored `null`, an empty string, or a missing record. An update can use this expectation to bootstrap legacy data atomically; a delete can use it when the domain permits deleting an unversioned record. A backend that cannot distinguish absence from null must reject this expectation rather than weaken it. In PostgreSQL, declared SQL columns collapse this distinction; an overflow JSON field can preserve it. Review mapper serialization before choosing revision storage.
+
+## Patch semantics
+
+The patch replaces each supplied top-level field. Nested objects and arrays replace their entire previous values; they do not merge recursively. Unspecified fields remain unchanged, and `null` stores null rather than removing the field. There is no unset operation.
+
+Patches contain only constant strings, booleans, finite numbers, null, valid Dates, dense arrays, and plain objects. Undefined, functions, query proxies, cycles, and operator/path field names are rejected. The patch cannot contain `id`, `_id`, the revision field, or adapter-owned scope fields. Adapters must preserve their normal Date storage representation without interpreting objects that resemble query stages as executable expressions.
+
+## Delete by one observed scalar
+
+`deleteIfEqual` provides a narrower condition for domains where one field equality is sufficient, such as deletion of an expired record whose observed timestamp remains unchanged.
+
+```ts
+const outcome = await table.atomicMutation(recordId, {
+  type: "deleteIfEqual",
+  field: "lastSeenAt",
+  expectedValue: observed.lastSeenAt,
+});
+```
+
+`expectedValue` accepts a string, finite number, boolean, or valid Date. Equality is exact and type-sensitive, with Dates compared by their stored instant; scalar equality must not match an array containing that scalar. Missing fields never match. Null, objects, arrays, identity fields, and scope fields are not supported.
+
+This variant does not check or advance a revision and does not prevent ABA: a value can change and later return to its observed value. The domain must prove that equality alone authorizes deletion. It is not a substitute for revision checks on state transitions.
+
+## Handle all outcomes
+
+| Outcome       | Meaning                                                                                                              |
+| ------------- | -------------------------------------------------------------------------------------------------------------------- |
+| `applied`     | The adapter received definitive acknowledgement that the one mutation applied.                                       |
+| `not-applied` | The adapter received definitive acknowledgement that the target was missing or its scope or condition did not match. |
+| `unknown`     | The adapter cannot determine whether the mutation applied, including acknowledgement loss.                           |
+
+Definitive validation and unsupported-operation errors throw. Neither an exception nor `unknown` means mismatch. The interface rejects invalid adapter results, including `undefined`, zero, and generic modified counts, with `AtomicMutationUnsupportedError`; adapters must reject unsupported stages explicitly. There is no fallback to generic filtered writes and no separate capability probe. Use an adapter whose implementation has been verified before relying on this API.
+
+The interface and adapter must not automatically retry an uncertain mutation. Do not repeat external effects or infer failure from a later mismatch. Domain-specific recovery can reconcile durable evidence and receipts, but a fresh read alone cannot prove whether an earlier operation or external effect occurred. Any deliberate replay requires a domain proof and does not turn `not-applied` into evidence about the original attempt.
+
+## Adapter contract
+
+The canonical terminal stage is `{ stage: "atomicMutation", options: undefined, args: [id, request] }`, immediately after `schema`, `instance`, and `table`. `AtomicMutation<T>` is the union of `AtomicUpdate<T>`, `AtomicDelete<T>`, and `AtomicDeleteIfEqual<T>`.
+
+Adapters can reuse `ValidateAtomicMutation(id, request, protectedFields)` and `ValidateAtomicMutationTable(prefixStages)`. They must additionally validate the terminal envelope and schema-specific restrictions. Scope, immutable identity, and the revision or equality condition must participate in the target-local native mutation, not only an earlier selection or identity subquery. Backend tests must prove contention, scope isolation, missing/null distinction, top-level replacement, and acknowledgement-loss behavior.
+
+This API remains unpublished during adapter and consumer verification. Package metadata alone does not establish capability; do not infer support from the unchanged development package version.

package/docs/3.results/3.index_changes.md

@@ -6,8 +6,8 @@ In AQL, indexes are defined as part of the schema definition rather than created
 
 ```typescript
 interface IndexDefinition {
-  fields?: string[];  // Fields for compound indexes
-  multi?: boolean;    // Multi-valued index
+  fields?: string[]; // Fields for compound indexes
+  multi?: boolean; // Multi-valued index
 }
 ```
 
@@ -22,8 +22,8 @@ const schema = new Schema("myapp", {
   users: {
     fields: { name: "string", email: "string", role: "string" },
     indexes: {
-      email: {},                              // Simple index (field name = index name)
-      role: {},                               // Simple index
+      email: {}, // Simple index (field name = index name)
+      role: {}, // Simple index
       name_role: { fields: ["name", "role"] }, // Compound index
     },
   },
@@ -72,7 +72,11 @@ const users = db.table("users");
 const admins = await users.getAll("admin", "role");
 
 // Range query on an indexed field
-const recent = await users.between("createdAt", new Date("2024-01-01"), new Date());
+const recent = await users.between(
+  "createdAt",
+  new Date("2024-01-01"),
+  new Date(),
+);
 ```
 
 For more details, see [Index Management](../2.operations/5.indexes.md).

package/docs/3.results/4.table_changes.md

@@ -17,10 +17,10 @@ Field types describe the structure of each field:
 
 ```typescript
 type FieldType =
-  | string                              // Primitive type name (e.g., "string", "number")
-  | Array<StringFieldType>              // Array of a given type
+  | string // Primitive type name (e.g., "string", "number")
+  | Array<StringFieldType> // Array of a given type
   | { [subfield: string]: StringFieldType } // Nested object
-  | import("io-ts").Mixed;              // io-ts codec at the field root
+  | import("io-ts").Mixed; // io-ts codec at the field root
 ```
 
 A field can be described either with the string-token vocabulary (primitives, arrays, nested records) or with a single [io-ts](https://github.com/gcanti/io-ts) codec at the root of the field. Codecs are not mixed inside string-tree records — use io-ts combinators (`t.type`, `t.array`, …) to nest within a codec.

package/docs/3.results/6.value_changes.md

@@ -14,11 +14,11 @@ interface Changes<T> {
 
 ## Properties
 
-| Property     | Type                                     | Description                                          |
-| ------------ | ---------------------------------------- | ---------------------------------------------------- |
-| `changeType` | `"added" \| "removed" \| "modified"`    | The kind of change that occurred.                    |
-| `oldValue`   | `T \| undefined`                        | The document before the change. Undefined for inserts.|
-| `newValue`   | `T \| undefined`                        | The document after the change. Undefined for deletes. |
+| Property     | Type                                 | Description                                            |
+| ------------ | ------------------------------------ | ------------------------------------------------------ |
+| `changeType` | `"added" \| "removed" \| "modified"` | The kind of change that occurred.                      |
+| `oldValue`   | `T \| undefined`                     | The document before the change. Undefined for inserts. |
+| `newValue`   | `T \| undefined`                     | The document after the change. Undefined for deletes.  |
 
 ## Determine the Change Type
 

package/docs/index.md

@@ -25,6 +25,7 @@ The Database interface provides AQL (Antelope Query Language), a database-agnost
   - [Index Management](./2.operations/5.indexes.md) - Define and use secondary indexes
   - [Filtering and Querying](./2.operations/6.filtering.md) - Filter, compare, and transform data
   - [Lookup](./2.operations/7.lookup.md) - Foreign key joins and data population
+  - [Atomic Mutations](./2.operations/8.atomic_mutations.md) - Conditional single-record mutations and outcomes
 
 - [**3. Results**](./3.results/1.index.md) - Result types and handling:
   - [Insert Results](./3.results/2.write_results.md) - Results from insert operations

package/package.json

@@ -1,30 +1,61 @@
 {
   "name": "@antelopejs/interface-database",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "AntelopeJS interface for database-agnostic query operations",
   "keywords": [
     "antelopejs",
-    "interface",
-    "database"
+    "database",
+    "interface"
   ],
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/AntelopeJS/interface-database.git"
   },
-  "license": "Apache-2.0",
-  "packageManager": "pnpm@10.6.5",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
   "files": [
     "dist",
     "docs",
     "skills"
   ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "atomic": [
+        "dist/atomic.d.ts"
+      ],
+      "common": [
+        "dist/common.d.ts"
+      ],
+      "datum": [
+        "dist/datum.d.ts"
+      ],
+      "query": [
+        "dist/query.d.ts"
+      ],
+      "schema": [
+        "dist/schema.d.ts"
+      ],
+      "selection": [
+        "dist/selection.d.ts"
+      ],
+      "stream": [
+        "dist/stream.d.ts"
+      ],
+      "valueproxy": [
+        "dist/valueproxy.d.ts"
+      ]
+    }
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./atomic": {
+      "types": "./dist/atomic.d.ts",
+      "default": "./dist/atomic.js"
+    },
     "./common": {
       "types": "./dist/common.d.ts",
       "default": "./dist/common.js"
@@ -55,26 +86,37 @@
     },
     "./package.json": "./package.json"
   },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "scripts": {
     "build": "rimraf dist && tsc",
-    "format": "biome format --write .",
-    "lint:fix": "biome check --write .",
-    "lint": "biome check .",
+    "format": "oxfmt .",
+    "lint:fix": "oxlint --fix",
+    "lint": "oxlint",
     "prepack": "pnpm run build",
     "release": "pnpm run lint && pnpm run prepack && release-it",
-    "test": "pnpm run build && ajs module test ."
+    "test": "pnpm run build && ajs module test .",
+    "format:check": "oxfmt --check .",
+    "knip": "knip"
   },
   "devDependencies": {
     "@antelopejs/interface-core": ">=0.0.3 <1.0.0",
-    "@biomejs/biome": "2.3.2",
+    "@antelopejs/tooling-configs": "^0.0.4",
     "@types/chai": "^4.3.20",
     "@types/mocha": "^10.0.10",
     "@types/node": "^22.19.15",
     "@types/semver": "^7.7.1",
     "chai": "^4.5.0",
+    "eslint-plugin-perfectionist": "^5.11.0",
     "fp-ts": "^2.16.0",
     "io-ts": "^2.2.0",
+    "knip": "^6.34.0",
     "mongodb-memory-server-core": "^11.0.1",
+    "oxfmt": "^0.66.0",
+    "oxlint": "1.81.0",
+    "oxlint-tsgolint": "^7.0.2001",
     "release-it": "^19.2.4",
     "release-it-changelogen": "^0.1.0",
     "rimraf": "^6.1.3",
@@ -83,34 +125,7 @@
   "peerDependencies": {
     "@antelopejs/interface-core": ">=0.0.3 <1.0.0"
   },
-  "publishConfig": {
-    "access": "public"
-  },
-  "typesVersions": {
-    "*": {
-      "common": [
-        "dist/common.d.ts"
-      ],
-      "datum": [
-        "dist/datum.d.ts"
-      ],
-      "query": [
-        "dist/query.d.ts"
-      ],
-      "schema": [
-        "dist/schema.d.ts"
-      ],
-      "selection": [
-        "dist/selection.d.ts"
-      ],
-      "stream": [
-        "dist/stream.d.ts"
-      ],
-      "valueproxy": [
-        "dist/valueproxy.d.ts"
-      ]
-    }
-  },
+  "packageManager": "pnpm@10.6.5",
   "antelopeJs": {
     "test": "src/antelope.test.ts",
     "skills": [