doxum 0.1.33 → 0.1.35

package/README.md

@@ -282,26 +282,25 @@ exposes `read`, `select`, `items`, `update`, `batch`, `scope` and `dispose`.
 
 ### Commands inside a batch
 
-Ordinary reads use `runtime.read`. A batch can read the latest accepted input state through its callback while projection readers keep the last published view:
+`runtime.read` and `Readable.current()` read current state, including inside a batch. Derived reads evaluate necessary stale dependencies on demand; batch defers external notifications.
 
 ```ts
 const count = input(0);
 const doubled = derive({ count }, ({ count }) => count * 2);
 
 function increment() {
-  runtime.batch(read => {
-    runtime.update(count, read(count) + 1);
-  });
+  runtime.update(count, runtime.read(count) + 1);
 }
 
 runtime.batch(() => {
   increment();
+  runtime.read(doubled); // 2
   increment();
+  runtime.read(doubled); // 4
 });
-runtime.read(doubled); // 4
 ```
 
-The borrowed reader supports scalar and collection inputs and expires with its callback. Nested batches settle at the outer boundary. Cross-input commands can read several latest source values without mirrors. Input equality is checked before acceptance; a failed edit leaves earlier successes intact. A batch is not a transaction. See [batch source reads](docs/projections.md#batch-source-reads) for snapshots, errors and lifecycle.
+Nested batches notify at the outer boundary. Cross-input commands use the same reads without mirrors or borrowed reader parameters. Input equality is checked before acceptance; a failed edit leaves earlier successes intact. A batch is not a transaction, and intermediate reads may advance retained processors more than once. See [current reads and batching](docs/projections.md#current-reads-and-batching) for snapshots, net notifications and lifecycle.
 
 ### Keyed projection
 
@@ -433,6 +432,18 @@ const lines = derive.keyed.flatMap(orders, order =>
 
 Each parent returns ordered `[globalKey, value]` tuples, including zero entries. `flatMap` reuses named/dynamic keyed dependencies and only recomputes invalidated parents. Formal output order follows parent order then child order; parent-only reordering runs no selectors. Duplicate final output keys are errors, and present `undefined` is valid. Same-batch transfers preserve a global key's membership identity. Structural changes can rebuild full order; this is not a claim that every operation costs only the changed entries.
 
+### Compute a keyed result from named inputs
+
+```ts
+const errors = derive.keyed.fromEntries(
+  { form: formState, rules: validationRules },
+  ({ form, rules }) => validateForm(form, rules).map(error => [error.id, error]),
+  (before, after) => before.message === after.message && before.field === after.field
+);
+```
+
+`fromEntries` uses the same named dependencies as `derive`, including the single-source form `{ form }`. The synchronous callback returns the complete ordered `[key, value]` array: `[]` is empty, missing keys are removed, and `[key, undefined]` is present. Duplicate keys are errors. Per-entry equality preserves equivalent value references while membership/order changes remain observable. It computes and scans the full result, then publishes exact changes; use `flatMap` for per-parent incremental computation or `derive.keyed.get` as an input for precise active-entry dependencies. See [Projection API](docs/projections.md#keyed-results-from-named-dependencies).
+
 ### Runtime-local keyed state
 
 Use `input.collection` for selection, expanded state, local overrides and other
@@ -454,7 +465,7 @@ Its state is owned by the `ProjectionRuntime`, not the document, history or pers
 Updates are synchronous and atomic. It publishes exact keyed `CollectionChange`
 transitions and preserves order. The optional per-entry equality defaults to `Object.is`
 and suppresses equivalent `set` operations. Callback and equality failures leave both
-the published value and the next draft unchanged.
+the current value and the next draft unchanged.
 
 The processor-facing `CollectionChange` type and `collectionChange.keys(...)` utility
 are exported by `doxum/advanced`. The utility lazily iterates incremental added,

package/dist/advanced.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_transform = require("./transform-CSPGdBe5.cjs");
+const require_transform = require("./transform-D45KWMzj.cjs");
 const require_record = require("./record-ChYUi8PP.cjs");
 //#region core/src/projection/advanced.ts
 const resetCollectionChange = Object.freeze({ kind: "reset" });

package/dist/advanced.js

@@ -1,4 +1,4 @@
-import { C as compileProjectionDependencies, O as defineProcessor, T as collectionView, r as collectionChange, t as createKeyedTransform, v as assertSynchronous } from "./transform-A9Lx5R2l.js";
+import { D as defineProcessor, S as compileProjectionDependencies, _ as assertSynchronous, r as collectionChange, t as createKeyedTransform, w as collectionView } from "./transform-3mj0eStL.js";
 import { n as isPlainObject } from "./record-B2yRhYsc.js";
 //#region core/src/projection/advanced.ts
 const resetCollectionChange = Object.freeze({ kind: "reset" });