doxum 0.1.36 → 0.1.37

package/dist/index.d.cts

@@ -40,7 +40,7 @@ type KeyedEntries<K extends string, V> = readonly (readonly [K, V])[];
 type Equality$2<T> = (previous: T, next: T) => boolean;
 declare function createKeyedFrom<K extends string, V>(source: Projection<readonly V[]>, keyOf: (value: NoInfer<V>) => Synchronous<K>, equality?: Equality$2<V>): KeyedProjection<K, V>;
 declare function createKeyedFrom<K extends string, V>(source: readonly V[], keyOf: (value: NoInfer<V>) => Synchronous<K>, equality?: Equality$2<V>): KeyedProjection<K, V>;
-declare function createKeyedFromEntries<const D extends ProjectionDependencies, K extends string, V>(dependencies: D, compute: (values: ProjectionValues<D>) => Synchronous<KeyedEntries<K, V>>, equality?: Equality$2<NoInfer<V>>): KeyedProjection<K, V>;
+declare function createKeyedFromEntries<const D extends ProjectionDependencies, K extends string, V>(dependencies: D, compute: (values: ProjectionValues<D>) => Synchronous<KeyedEntries<K, V>>, equality?: Equality$2<V>): KeyedProjection<K, V>;
 declare function createKeyedMerge<K extends string, V>(sources: readonly KeyedProjection<K, V>[], options: {
   readonly conflict: 'error' | 'first' | 'last';
   readonly equality?: Equality$2<V>;

package/dist/index.d.ts

@@ -40,7 +40,7 @@ type KeyedEntries<K extends string, V> = readonly (readonly [K, V])[];
 type Equality$2<T> = (previous: T, next: T) => boolean;
 declare function createKeyedFrom<K extends string, V>(source: Projection<readonly V[]>, keyOf: (value: NoInfer<V>) => Synchronous<K>, equality?: Equality$2<V>): KeyedProjection<K, V>;
 declare function createKeyedFrom<K extends string, V>(source: readonly V[], keyOf: (value: NoInfer<V>) => Synchronous<K>, equality?: Equality$2<V>): KeyedProjection<K, V>;
-declare function createKeyedFromEntries<const D extends ProjectionDependencies, K extends string, V>(dependencies: D, compute: (values: ProjectionValues<D>) => Synchronous<KeyedEntries<K, V>>, equality?: Equality$2<NoInfer<V>>): KeyedProjection<K, V>;
+declare function createKeyedFromEntries<const D extends ProjectionDependencies, K extends string, V>(dependencies: D, compute: (values: ProjectionValues<D>) => Synchronous<KeyedEntries<K, V>>, equality?: Equality$2<V>): KeyedProjection<K, V>;
 declare function createKeyedMerge<K extends string, V>(sources: readonly KeyedProjection<K, V>[], options: {
   readonly conflict: 'error' | 'first' | 'last';
   readonly equality?: Equality$2<V>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doxum",
-  "version": "0.1.36",
+  "version": "0.1.37",
   "private": false,
   "license": "MIT",
   "description": "Doxum is a typed runtime for complex mutable documents.",

package/skills/doxum-runtime/references/projections.md

@@ -200,6 +200,8 @@ const errors = derive.keyed.fromEntries(
 
 Each synchronous computation returns the **complete** finite `readonly (readonly [K, V])[]` result. The tuple order is formal output order; `[]` removes all members. Keys must be unique strings. `[key, undefined]` is a present member. A key missing from the next result is removed. Reordering alone does not invent value updates.
 
+Value inference uses both `compute` and a typed `equality` callback, including computations with empty-array branches and union values. These cases do not require an output `KeyedProjection<K, V>` annotation. Equality must accept every emitted value variant. Normal TypeScript literal widening still applies; preserve discriminants with a declared value type or `as const` when needed.
+
 Equality defaults to `Object.is` and compares values under the same key, not the outer array or tuple objects. Equality-equivalent values retain their existing reference; new value objects require stable references or a suitable equality callback. Equality cannot suppress membership/order. Callback failures, thenables, malformed tuples, duplicate keys and equality failures install no partial output and follow normal initialization/processor recovery semantics. Output definitions are lazy, reusable across runtimes and compatible with scopes and `runtime.items()`.
 
 This is **whole-result computation with incremental output publication**. Each necessary evaluation runs the callback for all inputs and scans the old/new result membership, costing O(old result size + new result size), plus callback work and keyed dependency snapshot costs. A keyed dependency is consumed as a whole: `records.get(activeId)` inside the callback does not establish an entry dependency. For precise dynamic lookup, compose the existing scalar lookup first:

package/skills/doxum-runtime/references/public-api.md

@@ -350,6 +350,7 @@ derive.keyed.from(source: Projection<readonly V[]>, keyOf, equality?): KeyedProj
 derive.keyed.from(source: readonly V[], keyOf, equality?): KeyedProjection<K,V>
 derive.keyed.fromEntries(dependencies, compute, equality?): KeyedProjection<K,V>
 // compute(readonlyNamedValues) returns Synchronous<readonly (readonly [K,V])[]>
+// V is inferred from compute and typed equality; equality must accept every emitted variant.
 derive.keyed.merge(sources, { conflict: 'error' | 'first' | 'last', equality? }): KeyedProjection<K,V>
 derive.keyed.merge(sources, { conflict: 'resolve', resolve, equality? }): KeyedProjection<K,V>
 derive.keyed.subset(source, orderedKeysOrProjection): KeyedProjection<K,V>