doxum 0.1.5 → 0.1.6

package/README.md

@@ -239,11 +239,52 @@ views, materialized views, and history state.
 
 ## Derived Views
 
-`createCollectionView` incrementally projects one table or map into `ids`,
-`all`, and cached `item(id)` readables. `createMaterializedView` is for
-indexes and aggregates that need custom incremental update logic. A materialized
-view may depend on earlier views from the same runtime; Doxum settles that graph
-before notifying external listeners.
+`createProjectionRuntime` owns an explicit graph of derived values and keyed
+collections. It combines document runtimes and external values without owning
+their mutations or history.
+
+```ts
+const projection = createProjectionRuntime({ onError: error => console.error(error) });
+const document = projection.document(runtime);
+const taskTitles = projection.map(
+  document.collection(path => path.tasks),
+  (_id, task) => task.title.get()
+);
+const taskCount = projection.value({
+  sources: { tasks: taskTitles },
+  build: ({ tasks }) => ({
+    value: tasks.ids().length,
+    update: ({ tasks }) => ({ kind: 'changed', value: tasks.ids().length }),
+  }),
+});
+```
+
+`projection.collection(spec)` handles custom incremental algorithms. Its scoped
+writer supports `set`, `remove`, `order`, and `replace`; `previous` and `next`
+provide scoped reads. Declare all sources and use their native commit impacts
+or upstream collection changes to choose candidate keys. Doxum stages writes,
+applies equality, and publishes exact `CollectionImpact` changes. It does not
+automatically track item dependencies. `ids`, lazy `all`, and cached `item(id)`
+implement `Readable` and work with `useReadable`.
+
+Use `projection.input(initial, { isEqual })` for boundary values such as container
+size. Its application-owned `set` updates a read-only `source`. Use
+`projection.fromReadable(existing, { isEqual })` for an existing external source.
+Neither replaces a document with domain mutation semantics.
+
+Wrap the entire synchronous application action in `projection.batch(() => ...)`
+before its first document commit to combine document changes and editor cleanup.
+Batches nest, preserve committed source changes on exceptions, and provide no
+cross-document rollback. Projection reads inside a batch return the last
+published state. Document listeners still run synchronously.
+
+All affected nodes settle before listeners. Output revisions change only when
+their output changes. Update failures discard the processor instance and attempt
+one fresh build; persistent faults block descendants, while independent branches
+continue. Errors reach `onError` and, when inside document notification, the
+committed result's `observerErrors`. Manual `rebuild()` uses the same graph.
+Dispose the projection with its service; component unmount only unsubscribes.
+Disposing a node with consumers is rejected, and disposed handles throw.
 
 ## Data Ownership
 

package/dist/{contract-4E3moCbY.d.ts → contract-I99DUMbN.d.ts}

@@ -549,4 +549,4 @@ type DocumentRuntime<TSchema extends DocumentSchema> = DocumentReadable<TSchema>
 };
 //#endregion
 export { EntityEntry as $, tree as $t, MutationIssue as A, MapNode as At, CollectionReader as B, ValueSelector as Bt, contains as C, DocumentTreeValue as Ct, resolveAddress as D, FieldNode as Dt, read as E, EntitySchemaNode as Et, FieldWriter as F, RecordNode as Ft, TreeReader as G, list as Gt, FieldReader as H, VariantShape as Ht, ListWriter as I, SchemaPath as It, DictSetOperation as J, optional as Jt, DictDeleteOperation as K, map as Kt, MapWriter as L, SingleNode as Lt, CollectionWriter as M, ObjectShape as Mt, DictionaryWriter as N, OptionalNode as Nt, CollectionImpact as O, ImpactTarget as Ot, DocumentWriter as P, ReadonlyDocument as Pt, EntityCreateOperation as Q, table as Qt, TreeWriter as R, TableNode as Rt, AddressRef as S, DocumentTreeNode as St, overlaps as T, DocumentValueOfShape as Tt, ListReader as U, dict as Ut, DocumentReader as V, VariantNode as Vt, ReaderOfNode as W, field as Wt, DocumentOperation as X, schema as Xt, DocumentAnchor as Y, record as Yt, DocumentOperationUnion as Z, single as Zt, CommandFootprint as _, DictNode as _t, DocumentProblem as a, ListMoveOperation as at, decodeCommandFootprint as b, DocumentNode as bt, DocumentRuntime as c, TreeInsertOperation as ct, LocalHistory as d, TreeReplaceOperation as dt, variant as en, EntityMoveOperation as et, ObserverError as f, TreeSetOperation as ft, Unsubscribe as g, CollectionSelector as gt, TransactionResult as h, CollectionNode as ht, DocumentDisposedError as i, ListInsertOperation as it, MutationIssueCode as j, ObjectNode as jt, DocumentImpact as k, ListNode as kt, DocumentTransaction as l, TreeMoveOperation as lt, PreparedUpdateResult as m, VariantReplaceOperation as mt, DocumentCommit as n, FieldClearOperation as nt, DocumentReadable as o, ListRemoveOperation as ot, OperationResult as p, ValueClearOperation as pt, DictReplaceOperation as q, object as qt, DocumentDiagnostic as r, FieldSetOperation as rt, DocumentReentrancyError as s, ListReplaceOperation as st, CommitSource as t, EntityRemoveOperation as tt, HistoryState as u, TreeRemoveOperation as ut, CommandFootprintTarget as v, DocumentAddress as vt, debugKey as w, DocumentValueOfNode as wt, footprintsOverlap as x, DocumentSchema as xt, commandFootprint as y, DocumentListConfig as yt, WriterOfNode as z, TreeNode as zt };
-//# sourceMappingURL=contract-4E3moCbY.d.ts.map
+//# sourceMappingURL=contract-I99DUMbN.d.ts.map