doxum 0.1.34 → 0.1.36

package/README.md

@@ -432,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
@@ -654,6 +666,13 @@ round trips and repeated tree edits to expose costs hidden by commit-only benchm
 Builds produce root `dist` ESM/CJS/declarations for `doxum`,
 `doxum/local-sync`, `doxum/react` and `doxum/advanced`. Source ownership is described in
 [architecture](docs/architecture.md) and [AGENTS.md](AGENTS.md).
+Release builds keep JavaScript readable and omit source maps. Use `pnpm run build:debug`
+to generate a separate `.debug/dist` build with embedded-source maps for source-level
+debugging; it does not replace `dist` and is excluded from publication. Published
+packages include both module formats, their declarations and the runtime skill.
+`pnpm run check:package` inspects the actual npm file list, checks required artifacts
+and reports packed/unpacked sizes. It runs as part of `build`, including releases,
+and rejects accidental debug artifacts or dangling source-map references.
 The runtime shares one transaction lifecycle; complete mutation operations are
 organized by domain under `core/src/mutation/operations`, with access, first-touch
 recording and publication retaining their own responsibilities.

package/dist/advanced.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_transform = require("./transform-Bt1Mwgrj.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" });
@@ -244,5 +244,3 @@ const incremental = Object.assign(createIncrementalValue, {
 //#endregion
 exports.collectionChange = require_transform.collectionChange;
 exports.incremental = incremental;
-
-//# sourceMappingURL=advanced.cjs.map

package/dist/advanced.d.cts

@@ -118,5 +118,4 @@ declare const incremental: typeof createIncrementalValue & {
   group: typeof createIncrementalGroup;
 };
 //#endregion
-export { type CollectionChange, IncrementalCollectionContext, IncrementalCollectionDefinition, IncrementalGroupContext, IncrementalGroupOutput, IncrementalGroupResult, IncrementalKeyedContext, IncrementalKeyedDefinition, IncrementalValueContext, IncrementalValueDefinition, collectionChange, incremental };
-//# sourceMappingURL=advanced.d.cts.map
+export { type CollectionChange, IncrementalCollectionContext, IncrementalCollectionDefinition, IncrementalGroupContext, IncrementalGroupOutput, IncrementalGroupResult, IncrementalKeyedContext, IncrementalKeyedDefinition, IncrementalValueContext, IncrementalValueDefinition, collectionChange, incremental };

package/dist/advanced.d.ts

@@ -118,5 +118,4 @@ declare const incremental: typeof createIncrementalValue & {
   group: typeof createIncrementalGroup;
 };
 //#endregion
-export { type CollectionChange, IncrementalCollectionContext, IncrementalCollectionDefinition, IncrementalGroupContext, IncrementalGroupOutput, IncrementalGroupResult, IncrementalKeyedContext, IncrementalKeyedDefinition, IncrementalValueContext, IncrementalValueDefinition, collectionChange, incremental };
-//# sourceMappingURL=advanced.d.ts.map
+export { type CollectionChange, IncrementalCollectionContext, IncrementalCollectionDefinition, IncrementalGroupContext, IncrementalGroupOutput, IncrementalGroupResult, IncrementalKeyedContext, IncrementalKeyedDefinition, IncrementalValueContext, IncrementalValueDefinition, collectionChange, incremental };

package/dist/advanced.js

@@ -1,4 +1,4 @@
-import { D as defineProcessor, S as compileProjectionDependencies, _ as assertSynchronous, r as collectionChange, t as createKeyedTransform, w as collectionView } from "./transform-RghG_Qxs.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" });
@@ -242,5 +242,3 @@ const incremental = Object.assign(createIncrementalValue, {
 });
 //#endregion
 export { collectionChange, incremental };
-
-//# sourceMappingURL=advanced.js.map

package/dist/contract-CNR6BS75.d.cts

@@ -617,5 +617,4 @@ type DocumentRuntime<S extends ObjectSchema<object>> = ReadonlyDocument<S> & {
   dispose(): void;
 };
 //#endregion
-export { table as $, ParseError as A, DocumentListConfig as B, Read as C, ChangeSet as D, Change as E, CollectionPath as F, ReadonlyValue as G, DocumentTreeValue as H, PathValueOf as I, field as J, Schema as K, SchemaPath as L, parse as M, CollectionEntry as N, MemberChange as O, CollectionId as P, optional as Q, DocumentAddress as R, Draft as S, snapshot as T, Infer as U, DocumentTreeNode as V, ObjectSchema as W, map as X, list as Y, object as Z, Unsubscribe as _, DocumentProblem as a, CollectionImpact as b, HistoryState as c, OperationResult as d, tree as et, ReadonlyDocument as f, Readable as g, TransactionResult as h, DocumentDisposedError as i, ParseIssue as j, ValueTransition as k, LocalHistory as l, TransactionRejected as m, DocumentCommit as n, DocumentReentrancyError as o, Synchronous as p, Validator as q, DocumentDiagnostic as r, DocumentRuntime as s, CommitSource as t, variant as tt, ObserverError as u, MutationIssue as v, replace as w, DocumentImpact as x, MutationIssueCode as y, DocumentAnchor as z };
-//# sourceMappingURL=contract-CNR6BS75.d.cts.map
+export { table as $, ParseError as A, DocumentListConfig as B, Read as C, ChangeSet as D, Change as E, CollectionPath as F, ReadonlyValue as G, DocumentTreeValue as H, PathValueOf as I, field as J, Schema as K, SchemaPath as L, parse as M, CollectionEntry as N, MemberChange as O, CollectionId as P, optional as Q, DocumentAddress as R, Draft as S, snapshot as T, Infer as U, DocumentTreeNode as V, ObjectSchema as W, map as X, list as Y, object as Z, Unsubscribe as _, DocumentProblem as a, CollectionImpact as b, HistoryState as c, OperationResult as d, tree as et, ReadonlyDocument as f, Readable as g, TransactionResult as h, DocumentDisposedError as i, ParseIssue as j, ValueTransition as k, LocalHistory as l, TransactionRejected as m, DocumentCommit as n, DocumentReentrancyError as o, Synchronous as p, Validator as q, DocumentDiagnostic as r, DocumentRuntime as s, CommitSource as t, variant as tt, ObserverError as u, MutationIssue as v, replace as w, DocumentImpact as x, MutationIssueCode as y, DocumentAnchor as z };

package/dist/contract-COgxO5sv.d.ts

@@ -617,5 +617,4 @@ type DocumentRuntime<S extends ObjectSchema<object>> = ReadonlyDocument<S> & {
   dispose(): void;
 };
 //#endregion
-export { table as $, ParseError as A, DocumentListConfig as B, Read as C, ChangeSet as D, Change as E, CollectionPath as F, ReadonlyValue as G, DocumentTreeValue as H, PathValueOf as I, field as J, Schema as K, SchemaPath as L, parse as M, CollectionEntry as N, MemberChange as O, CollectionId as P, optional as Q, DocumentAddress as R, Draft as S, snapshot as T, Infer as U, DocumentTreeNode as V, ObjectSchema as W, map as X, list as Y, object as Z, Unsubscribe as _, DocumentProblem as a, CollectionImpact as b, HistoryState as c, OperationResult as d, tree as et, ReadonlyDocument as f, Readable as g, TransactionResult as h, DocumentDisposedError as i, ParseIssue as j, ValueTransition as k, LocalHistory as l, TransactionRejected as m, DocumentCommit as n, DocumentReentrancyError as o, Synchronous as p, Validator as q, DocumentDiagnostic as r, DocumentRuntime as s, CommitSource as t, variant as tt, ObserverError as u, MutationIssue as v, replace as w, DocumentImpact as x, MutationIssueCode as y, DocumentAnchor as z };
-//# sourceMappingURL=contract-COgxO5sv.d.ts.map
+export { table as $, ParseError as A, DocumentListConfig as B, Read as C, ChangeSet as D, Change as E, CollectionPath as F, ReadonlyValue as G, DocumentTreeValue as H, PathValueOf as I, field as J, Schema as K, SchemaPath as L, parse as M, CollectionEntry as N, MemberChange as O, CollectionId as P, optional as Q, DocumentAddress as R, Draft as S, snapshot as T, Infer as U, DocumentTreeNode as V, ObjectSchema as W, map as X, list as Y, object as Z, Unsubscribe as _, DocumentProblem as a, CollectionImpact as b, HistoryState as c, OperationResult as d, tree as et, ReadonlyDocument as f, Readable as g, TransactionResult as h, DocumentDisposedError as i, ParseIssue as j, ValueTransition as k, LocalHistory as l, TransactionRejected as m, DocumentCommit as n, DocumentReentrancyError as o, Synchronous as p, Validator as q, DocumentDiagnostic as r, DocumentRuntime as s, CommitSource as t, variant as tt, ObserverError as u, MutationIssue as v, replace as w, DocumentImpact as x, MutationIssueCode as y, DocumentAnchor as z };

package/dist/dependency-Cbf3C8eJ.d.cts

@@ -143,5 +143,4 @@ type KeyedDependencyValues<D extends object> = { readonly [P in keyof D]: D[P] e
   readonly source: KeyedProjection<infer _K extends string, infer V>;
 } ? V | undefined : D[P] extends Projection<infer T> ? T : never };
 //#endregion
-export { ProjectionDisposedError as _, Input as a, ProjectionChange as c, CollectionRead as d, ExternalCollectionEvent as f, ExternalValueSource as g, ExternalValueEvent as h, CollectionInputDraft as i, CollectionChange as l, ExternalCollectionSource as m, KeyedDependencyValues as n, KeyedProjection as o, ExternalCollectionRead as p, CollectionInput as r, Projection as s, KeyedDependencies as t, CollectionDraft as u, ProjectionError as v };
-//# sourceMappingURL=dependency-Cbf3C8eJ.d.cts.map
+export { ProjectionDisposedError as _, Input as a, ProjectionChange as c, CollectionRead as d, ExternalCollectionEvent as f, ExternalValueSource as g, ExternalValueEvent as h, CollectionInputDraft as i, CollectionChange as l, ExternalCollectionSource as m, KeyedDependencyValues as n, KeyedProjection as o, ExternalCollectionRead as p, CollectionInput as r, Projection as s, KeyedDependencies as t, CollectionDraft as u, ProjectionError as v };

package/dist/dependency-DzxXGYe1.d.ts

@@ -143,5 +143,4 @@ type KeyedDependencyValues<D extends object> = { readonly [P in keyof D]: D[P] e
   readonly source: KeyedProjection<infer _K extends string, infer V>;
 } ? V | undefined : D[P] extends Projection<infer T> ? T : never };
 //#endregion
-export { ProjectionDisposedError as _, Input as a, ProjectionChange as c, CollectionRead as d, ExternalCollectionEvent as f, ExternalValueSource as g, ExternalValueEvent as h, CollectionInputDraft as i, CollectionChange as l, ExternalCollectionSource as m, KeyedDependencyValues as n, KeyedProjection as o, ExternalCollectionRead as p, CollectionInput as r, Projection as s, KeyedDependencies as t, CollectionDraft as u, ProjectionError as v };
-//# sourceMappingURL=dependency-DzxXGYe1.d.ts.map
+export { ProjectionDisposedError as _, Input as a, ProjectionChange as c, CollectionRead as d, ExternalCollectionEvent as f, ExternalValueSource as g, ExternalValueEvent as h, CollectionInputDraft as i, CollectionChange as l, ExternalCollectionSource as m, KeyedDependencyValues as n, KeyedProjection as o, ExternalCollectionRead as p, CollectionInput as r, Projection as s, KeyedDependencies as t, CollectionDraft as u, ProjectionError as v };

package/dist/driver-B7RR-VfX.js

@@ -400,5 +400,3 @@ const installRuntimeWriteDriver = (runtime, driver) => {
 };
 //#endregion
 export { changeCount as a, AddressIndex as c, invalidValue as d, children as f, validate as g, parent as h, contextOf as i, MutationRejected as l, is as m, installRuntimeWriteDriver as n, decodeChanges as o, contains as p, bindContext as r, sealChanges as s, assertRuntimeWritable as t, fail as u };
-
-//# sourceMappingURL=driver-B7RR-VfX.js.map

package/dist/driver-CN3dGxQI.cjs

@@ -495,5 +495,3 @@ Object.defineProperty(exports, "validate", {
 		return validate;
 	}
 });
-
-//# sourceMappingURL=driver-CN3dGxQI.cjs.map

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_transform = require("./transform-Bt1Mwgrj.cjs");
+const require_transform = require("./transform-D45KWMzj.cjs");
 const require_record = require("./record-ChYUi8PP.cjs");
 const require_driver = require("./driver-CN3dGxQI.cjs");
 //#region core/src/schema/model.ts
@@ -2775,6 +2775,12 @@ const isExternalSource = (source) => {
 	return (candidate.kind === "value" || candidate.kind === "collection") && typeof candidate.current === "function" && typeof candidate.revision === "function" && typeof candidate.subscribe === "function";
 };
 //#endregion
+//#region core/src/projection/keyed/entries.ts
+/** Shared entry boundary; membership and duplicate policy belong to each operation. */
+function assertKeyedEntry(entry, name) {
+	if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string") throw new TypeError(`${name} entries must be [string key, value] tuples.`);
+}
+//#endregion
 //#region core/src/projection/keyed/flat-map.ts
 function createKeyedFlatMap(source, dependenciesOrSelect, selectOrEquality, maybeEquality) {
 	const name = "derive.keyed.flatMap";
@@ -2821,7 +2827,7 @@ function createKeyedFlatMap(source, dependenciesOrSelect, selectOrEquality, mayb
 						if (!Array.isArray(entries)) throw new TypeError(`${name} selector must return an array of entries.`);
 						const keys = [];
 						for (const entry of entries) {
-							if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string") throw new TypeError(`${name} entries must be [string key, value] tuples.`);
+							assertKeyedEntry(entry, name);
 							const [key, child] = entry;
 							const owner = ownerByOutput.get(key);
 							if (proposals.has(key) || owner !== void 0 && !replaced.has(owner)) throw new TypeError(`${name} duplicate key ${JSON.stringify(key)}.`);
@@ -2908,6 +2914,25 @@ const assertCollectionSources = (sources, expected) => {
 	if (sources.length !== expected) throw new Error("derive.keyed.merge resolved an invalid dependency count.");
 	for (const source of sources) if (source.kind !== "collection") throw new Error("derive.keyed.merge requires collection inputs.");
 };
+/** Complete ordered result reconciliation, without retaining a second member/value cache. */
+const stageKeyedSnapshot = (values, output, keyOf, valueOf, name) => {
+	const seen = /* @__PURE__ */ new Set();
+	const order = new Array(values.length);
+	const previous = output.previous.ids();
+	require_transform.profile.collectionView.idsScanned(values.length + previous.length);
+	for (let index = 0; index < values.length; index++) {
+		const value = values[index];
+		const key = keyOf(value);
+		require_transform.assertSynchronous(key);
+		if (typeof key !== "string") throw new TypeError(`${name} key selector must return a string.`);
+		if (seen.has(key)) throw new TypeError(`${name} duplicate key ${JSON.stringify(key)}.`);
+		seen.add(key);
+		order[index] = key;
+		output.output.set(key, valueOf(value));
+	}
+	for (const key of previous) if (!seen.has(key)) output.output.remove(key);
+	output.output.order(order);
+};
 function createKeyedFrom(source, keyOf, equality) {
 	if (typeof keyOf !== "function") throw new TypeError("derive.keyed.from requires a key selector.");
 	const outputEquality = assertEquality(equality, "derive.keyed.from");
@@ -2937,25 +2962,38 @@ function createKeyedFrom(source, keyOf, equality) {
 				values = scalar.value;
 			}
 			if (!values) throw new Error("derive.keyed.from has no source values.");
-			const seen = /* @__PURE__ */ new Set();
-			const order = new Array(values.length);
-			for (let index = 0; index < values.length; index++) {
-				const value = values[index];
-				const key = keyOf(value);
-				require_transform.assertSynchronous(key);
-				if (typeof key !== "string") throw new TypeError("derive.keyed.from key selector must return a string.");
-				if (seen.has(key)) throw new TypeError(`derive.keyed.from duplicate key ${JSON.stringify(key)}.`);
-				seen.add(key);
-				order[index] = key;
-				output.output.set(key, value);
-			}
-			for (const previousKey of output.previous.ids()) if (!seen.has(previousKey)) output.output.remove(previousKey);
-			output.output.order(order);
+			stageKeyedSnapshot(values, output, keyOf, (value) => value, "derive.keyed.from");
 		} }),
 		name: "derive.keyed.from"
 	});
 	return projection;
 }
+function createKeyedFromEntries(dependencies, compute, equality) {
+	const name = "derive.keyed.fromEntries";
+	const compiled = require_transform.compileProjectionDependencies(dependencies, name);
+	if (typeof compute !== "function") throw new TypeError(`${name} requires a compute callback.`);
+	const outputEquality = assertEquality(equality, name);
+	const [projection] = require_transform.defineProcessor({
+		dependencies: compiled.projections,
+		outputs: [{
+			kind: "collection",
+			equality: outputEquality
+		}],
+		name,
+		create: () => ({ evaluate: (evaluation) => {
+			const output = evaluation.outputs[0];
+			if (output.kind !== "collection") throw new Error(`${name} requires a collection output.`);
+			const entries = compute(require_transform.snapshotProjectionValues(compiled.names, evaluation.sources));
+			require_transform.assertSynchronous(entries);
+			if (!Array.isArray(entries)) throw new TypeError(`${name} compute must return an array of entries.`);
+			stageKeyedSnapshot(entries, output, (entry) => {
+				assertKeyedEntry(entry, name);
+				return entry[0];
+			}, (entry) => entry[1], name);
+		} })
+	});
+	return projection;
+}
 function createKeyedMerge(sources, options) {
 	if (!Array.isArray(sources)) throw new TypeError("derive.keyed.merge sources must be an array of keyed projections.");
 	const capturedSources = require_transform.snapshotArray(sources);
@@ -3584,6 +3622,7 @@ const keyedDerive = Object.assign(createKeyedDerive, {
 	entries: createKeyedEntries,
 	get: createKeyedGet,
 	from: createKeyedFrom,
+	fromEntries: createKeyedFromEntries,
 	merge: createKeyedMerge,
 	groupBy: createKeyedGroupBy,
 	flatMap: createKeyedFlatMap,
@@ -3607,9 +3646,7 @@ function createValueDerive(dependencies, compute, equality = Object.is) {
 		create: () => ({ evaluate: (evaluation) => {
 			const output = evaluation.outputs[0];
 			if (output.kind !== "value") throw new Error("derive requires a value output.");
-			const values = Object.create(null);
-			for (let index = 0; index < names.length; index++) values[names[index]] = require_transform.snapshotDependencyValue(evaluation.sources[index]);
-			const next = compute(Object.freeze(values));
+			const next = compute(require_transform.snapshotProjectionValues(names, evaluation.sources));
 			require_transform.assertSynchronous(next);
 			output.output.set(next);
 		} })
@@ -6430,5 +6467,3 @@ exports.snapshot = snapshot;
 exports.table = table;
 exports.tree = tree;
 exports.variant = variant;
-
-//# sourceMappingURL=index.cjs.map

package/dist/index.d.cts

@@ -29,10 +29,18 @@ declare function observe<T>(readable: Readable<T>): Projection<T>;
 declare function observe<S extends ObjectSchema<object>, P extends CollectionPath>(document: ReadonlyDocument<S>, selector: (path: SchemaPath<S>) => P): KeyedProjection<CollectionId<P>, ReadonlyValue<CollectionEntry<P>>>;
 declare function observe<S extends ObjectSchema<object>, P>(document: ReadonlyDocument<S>, selector: (path: SchemaPath<S>) => P): Projection<PathValueOf<P>>;
 //#endregion
+//#region core/src/projection/dependency.d.ts
+type ProjectionDependencies = Readonly<Record<string, Projection<unknown>>> & Partial<Record<keyof Projection<unknown>, never>>;
+type ProjectionValues<D extends ProjectionDependencies> = { readonly [K in keyof D]: D[K] extends Projection<infer T> ? T : never };
+//#endregion
+//#region core/src/projection/keyed/entries.d.ts
+type KeyedEntries<K extends string, V> = readonly (readonly [K, V])[];
+//#endregion
 //#region core/src/projection/keyed/composition.d.ts
 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 createKeyedMerge<K extends string, V>(sources: readonly KeyedProjection<K, V>[], options: {
   readonly conflict: 'error' | 'first' | 'last';
   readonly equality?: Equality$2<V>;
@@ -47,14 +55,11 @@ declare function createKeyedMerge<K extends string, V>(sources: readonly KeyedPr
 }): KeyedProjection<K, V>;
 //#endregion
 //#region core/src/projection/keyed/flat-map.d.ts
-type Entries<K extends string, V> = readonly (readonly [K, V])[];
 type Equality$1<V> = (previous: V, next: V) => boolean;
-declare function createKeyedFlatMap<K extends string, V, O extends string, T>(source: KeyedProjection<K, V>, select: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<Entries<O, T>>, equality?: Equality$1<T>): KeyedProjection<O, T>;
-declare function createKeyedFlatMap<K extends string, V, const D extends object, O extends string, T>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, select: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<Entries<O, T>>, equality?: Equality$1<T>): KeyedProjection<O, T>;
+declare function createKeyedFlatMap<K extends string, V, O extends string, T>(source: KeyedProjection<K, V>, select: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<KeyedEntries<O, T>>, equality?: Equality$1<T>): KeyedProjection<O, T>;
+declare function createKeyedFlatMap<K extends string, V, const D extends object, O extends string, T>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, select: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<KeyedEntries<O, T>>, equality?: Equality$1<T>): KeyedProjection<O, T>;
 //#endregion
 //#region core/src/projection/derive.d.ts
-type ProjectionDependencies = Readonly<Record<string, Projection<unknown>>>;
-type ProjectionValues<D extends ProjectionDependencies> = { readonly [K in keyof D]: D[K] extends Projection<infer T> ? T : never };
 type Equality<T> = (previous: T, next: T) => boolean;
 declare function createValueDerive<const D extends ProjectionDependencies, T>(dependencies: D, compute: (values: ProjectionValues<D>) => Synchronous<T>, equality?: Equality<T>): Projection<T>;
 declare const derive: typeof createValueDerive & {
@@ -67,6 +72,7 @@ declare const derive: typeof createValueDerive & {
     entries: <K extends string, V>(source: KeyedProjection<K, V>) => Projection<readonly (readonly [K, V])[]>;
     get: <K extends string, V>(source: KeyedProjection<K, V>, key: Projection<NoInfer<K> | undefined>, equality?: (previous: V | undefined, next: V | undefined) => boolean) => Projection<V | undefined>;
     from: typeof createKeyedFrom;
+    fromEntries: typeof createKeyedFromEntries;
     merge: typeof createKeyedMerge;
     groupBy: {
       <K extends string, V, G extends string>(source: KeyedProjection<K, V>, selector: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<G | readonly G[]>): KeyedProjection<G, readonly K[]>;
@@ -127,5 +133,4 @@ declare const createProjectionRuntime: (options?: {
   readonly onError?: (error: ProjectionError) => void;
 }) => ProjectionRuntime;
 //#endregion
-export { type Change, type ChangeSet, type CollectionImpact, type CollectionInput, type CollectionInputDraft, type CommitSource, type DocumentAddress, type DocumentAnchor, type DocumentCommit, type DocumentDiagnostic, DocumentDisposedError, type DocumentImpact, type DocumentListConfig, type DocumentProblem, DocumentReentrancyError, type DocumentRuntime, type DocumentSelector, type DocumentTreeNode, type DocumentTreeValue, type Draft, type ExternalCollectionEvent, type ExternalCollectionRead, type ExternalCollectionSource, type ExternalValueEvent, type ExternalValueSource, type HistoryState, type Infer, type Input, type KeyedProjection, type LocalHistory, type MemberChange, type MutationIssue, type MutationIssueCode, type ObjectSchema, type ObserverError, type OperationResult, ParseError, type ParseIssue, type PathValueOf, type Projection, ProjectionDisposedError, ProjectionError, type ProjectionItems, type ProjectionRuntime, type ProjectionScope, type Read, type Readable, type ReadonlyDocument, type ReadonlyValue, type Schema, type SchemaPath, TransactionRejected, type TransactionResult, type Unsubscribe, type Validator, type ValueTransition, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, select, snapshot, table, tree, variant };
-//# sourceMappingURL=index.d.cts.map
+export { type Change, type ChangeSet, type CollectionImpact, type CollectionInput, type CollectionInputDraft, type CommitSource, type DocumentAddress, type DocumentAnchor, type DocumentCommit, type DocumentDiagnostic, DocumentDisposedError, type DocumentImpact, type DocumentListConfig, type DocumentProblem, DocumentReentrancyError, type DocumentRuntime, type DocumentSelector, type DocumentTreeNode, type DocumentTreeValue, type Draft, type ExternalCollectionEvent, type ExternalCollectionRead, type ExternalCollectionSource, type ExternalValueEvent, type ExternalValueSource, type HistoryState, type Infer, type Input, type KeyedProjection, type LocalHistory, type MemberChange, type MutationIssue, type MutationIssueCode, type ObjectSchema, type ObserverError, type OperationResult, ParseError, type ParseIssue, type PathValueOf, type Projection, ProjectionDisposedError, ProjectionError, type ProjectionItems, type ProjectionRuntime, type ProjectionScope, type Read, type Readable, type ReadonlyDocument, type ReadonlyValue, type Schema, type SchemaPath, TransactionRejected, type TransactionResult, type Unsubscribe, type Validator, type ValueTransition, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, select, snapshot, table, tree, variant };

package/dist/index.d.ts

@@ -29,10 +29,18 @@ declare function observe<T>(readable: Readable<T>): Projection<T>;
 declare function observe<S extends ObjectSchema<object>, P extends CollectionPath>(document: ReadonlyDocument<S>, selector: (path: SchemaPath<S>) => P): KeyedProjection<CollectionId<P>, ReadonlyValue<CollectionEntry<P>>>;
 declare function observe<S extends ObjectSchema<object>, P>(document: ReadonlyDocument<S>, selector: (path: SchemaPath<S>) => P): Projection<PathValueOf<P>>;
 //#endregion
+//#region core/src/projection/dependency.d.ts
+type ProjectionDependencies = Readonly<Record<string, Projection<unknown>>> & Partial<Record<keyof Projection<unknown>, never>>;
+type ProjectionValues<D extends ProjectionDependencies> = { readonly [K in keyof D]: D[K] extends Projection<infer T> ? T : never };
+//#endregion
+//#region core/src/projection/keyed/entries.d.ts
+type KeyedEntries<K extends string, V> = readonly (readonly [K, V])[];
+//#endregion
 //#region core/src/projection/keyed/composition.d.ts
 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 createKeyedMerge<K extends string, V>(sources: readonly KeyedProjection<K, V>[], options: {
   readonly conflict: 'error' | 'first' | 'last';
   readonly equality?: Equality$2<V>;
@@ -47,14 +55,11 @@ declare function createKeyedMerge<K extends string, V>(sources: readonly KeyedPr
 }): KeyedProjection<K, V>;
 //#endregion
 //#region core/src/projection/keyed/flat-map.d.ts
-type Entries<K extends string, V> = readonly (readonly [K, V])[];
 type Equality$1<V> = (previous: V, next: V) => boolean;
-declare function createKeyedFlatMap<K extends string, V, O extends string, T>(source: KeyedProjection<K, V>, select: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<Entries<O, T>>, equality?: Equality$1<T>): KeyedProjection<O, T>;
-declare function createKeyedFlatMap<K extends string, V, const D extends object, O extends string, T>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, select: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<Entries<O, T>>, equality?: Equality$1<T>): KeyedProjection<O, T>;
+declare function createKeyedFlatMap<K extends string, V, O extends string, T>(source: KeyedProjection<K, V>, select: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<KeyedEntries<O, T>>, equality?: Equality$1<T>): KeyedProjection<O, T>;
+declare function createKeyedFlatMap<K extends string, V, const D extends object, O extends string, T>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, select: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<KeyedEntries<O, T>>, equality?: Equality$1<T>): KeyedProjection<O, T>;
 //#endregion
 //#region core/src/projection/derive.d.ts
-type ProjectionDependencies = Readonly<Record<string, Projection<unknown>>>;
-type ProjectionValues<D extends ProjectionDependencies> = { readonly [K in keyof D]: D[K] extends Projection<infer T> ? T : never };
 type Equality<T> = (previous: T, next: T) => boolean;
 declare function createValueDerive<const D extends ProjectionDependencies, T>(dependencies: D, compute: (values: ProjectionValues<D>) => Synchronous<T>, equality?: Equality<T>): Projection<T>;
 declare const derive: typeof createValueDerive & {
@@ -67,6 +72,7 @@ declare const derive: typeof createValueDerive & {
     entries: <K extends string, V>(source: KeyedProjection<K, V>) => Projection<readonly (readonly [K, V])[]>;
     get: <K extends string, V>(source: KeyedProjection<K, V>, key: Projection<NoInfer<K> | undefined>, equality?: (previous: V | undefined, next: V | undefined) => boolean) => Projection<V | undefined>;
     from: typeof createKeyedFrom;
+    fromEntries: typeof createKeyedFromEntries;
     merge: typeof createKeyedMerge;
     groupBy: {
       <K extends string, V, G extends string>(source: KeyedProjection<K, V>, selector: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<G | readonly G[]>): KeyedProjection<G, readonly K[]>;
@@ -127,5 +133,4 @@ declare const createProjectionRuntime: (options?: {
   readonly onError?: (error: ProjectionError) => void;
 }) => ProjectionRuntime;
 //#endregion
-export { type Change, type ChangeSet, type CollectionImpact, type CollectionInput, type CollectionInputDraft, type CommitSource, type DocumentAddress, type DocumentAnchor, type DocumentCommit, type DocumentDiagnostic, DocumentDisposedError, type DocumentImpact, type DocumentListConfig, type DocumentProblem, DocumentReentrancyError, type DocumentRuntime, type DocumentSelector, type DocumentTreeNode, type DocumentTreeValue, type Draft, type ExternalCollectionEvent, type ExternalCollectionRead, type ExternalCollectionSource, type ExternalValueEvent, type ExternalValueSource, type HistoryState, type Infer, type Input, type KeyedProjection, type LocalHistory, type MemberChange, type MutationIssue, type MutationIssueCode, type ObjectSchema, type ObserverError, type OperationResult, ParseError, type ParseIssue, type PathValueOf, type Projection, ProjectionDisposedError, ProjectionError, type ProjectionItems, type ProjectionRuntime, type ProjectionScope, type Read, type Readable, type ReadonlyDocument, type ReadonlyValue, type Schema, type SchemaPath, TransactionRejected, type TransactionResult, type Unsubscribe, type Validator, type ValueTransition, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, select, snapshot, table, tree, variant };
-//# sourceMappingURL=index.d.ts.map
+export { type Change, type ChangeSet, type CollectionImpact, type CollectionInput, type CollectionInputDraft, type CommitSource, type DocumentAddress, type DocumentAnchor, type DocumentCommit, type DocumentDiagnostic, DocumentDisposedError, type DocumentImpact, type DocumentListConfig, type DocumentProblem, DocumentReentrancyError, type DocumentRuntime, type DocumentSelector, type DocumentTreeNode, type DocumentTreeValue, type Draft, type ExternalCollectionEvent, type ExternalCollectionRead, type ExternalCollectionSource, type ExternalValueEvent, type ExternalValueSource, type HistoryState, type Infer, type Input, type KeyedProjection, type LocalHistory, type MemberChange, type MutationIssue, type MutationIssueCode, type ObjectSchema, type ObserverError, type OperationResult, ParseError, type ParseIssue, type PathValueOf, type Projection, ProjectionDisposedError, ProjectionError, type ProjectionItems, type ProjectionRuntime, type ProjectionScope, type Read, type Readable, type ReadonlyDocument, type ReadonlyValue, type Schema, type SchemaPath, TransactionRejected, type TransactionResult, type Unsubscribe, type Validator, type ValueTransition, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, select, snapshot, table, tree, variant };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { A as ownProjections, C as snapshotDependencyValue, D as defineProcessor, E as snapshotCollectionView, M as projectionRef, N as profile, O as defineSource, S as compileProjectionDependencies, T as mapRead, _ as assertSynchronous, a as collectionChangeTouchesKey, b as ProjectionError, c as assertKeyedProjection, d as outputKind, f as createKeyRelation, g as assertScope, h as snapshotArray, i as collectionChangeIntersects, j as producerOf, k as isProjection, l as compileKeyedDependencies, m as sameArray, n as keyedAbsent, o as collectionHasStructuralChange, p as iterableMatchesArray, s as createCollectionChange, t as createKeyedTransform, u as createKeyedDependencyRuntime, v as createScheduler, w as collectionView, x as collectKeyedInvalidation, y as ProjectionDisposedError } from "./transform-RghG_Qxs.js";
+import { A as ownProjections, C as snapshotProjectionValues, D as defineProcessor, E as snapshotCollectionView, M as projectionRef, N as profile, O as defineSource, S as compileProjectionDependencies, T as mapRead, _ as assertSynchronous, a as collectionChangeTouchesKey, b as ProjectionError, c as assertKeyedProjection, d as outputKind, f as createKeyRelation, g as assertScope, h as snapshotArray, i as collectionChangeIntersects, j as producerOf, k as isProjection, l as compileKeyedDependencies, m as sameArray, n as keyedAbsent, o as collectionHasStructuralChange, p as iterableMatchesArray, s as createCollectionChange, t as createKeyedTransform, u as createKeyedDependencyRuntime, v as createScheduler, w as collectionView, x as collectKeyedInvalidation, y as ProjectionDisposedError } from "./transform-3mj0eStL.js";
 import { n as isPlainObject, r as isRecord, t as installOwn } from "./record-B2yRhYsc.js";
 import { c as AddressIndex, d as invalidValue, f as children, g as validate, h as parent, i as contextOf, l as MutationRejected, m as is, o as decodeChanges, p as contains$1, r as bindContext, s as sealChanges, t as assertRuntimeWritable, u as fail } from "./driver-B7RR-VfX.js";
 //#region core/src/schema/model.ts
@@ -2774,6 +2774,12 @@ const isExternalSource = (source) => {
 	return (candidate.kind === "value" || candidate.kind === "collection") && typeof candidate.current === "function" && typeof candidate.revision === "function" && typeof candidate.subscribe === "function";
 };
 //#endregion
+//#region core/src/projection/keyed/entries.ts
+/** Shared entry boundary; membership and duplicate policy belong to each operation. */
+function assertKeyedEntry(entry, name) {
+	if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string") throw new TypeError(`${name} entries must be [string key, value] tuples.`);
+}
+//#endregion
 //#region core/src/projection/keyed/flat-map.ts
 function createKeyedFlatMap(source, dependenciesOrSelect, selectOrEquality, maybeEquality) {
 	const name = "derive.keyed.flatMap";
@@ -2820,7 +2826,7 @@ function createKeyedFlatMap(source, dependenciesOrSelect, selectOrEquality, mayb
 						if (!Array.isArray(entries)) throw new TypeError(`${name} selector must return an array of entries.`);
 						const keys = [];
 						for (const entry of entries) {
-							if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string") throw new TypeError(`${name} entries must be [string key, value] tuples.`);
+							assertKeyedEntry(entry, name);
 							const [key, child] = entry;
 							const owner = ownerByOutput.get(key);
 							if (proposals.has(key) || owner !== void 0 && !replaced.has(owner)) throw new TypeError(`${name} duplicate key ${JSON.stringify(key)}.`);
@@ -2907,6 +2913,25 @@ const assertCollectionSources = (sources, expected) => {
 	if (sources.length !== expected) throw new Error("derive.keyed.merge resolved an invalid dependency count.");
 	for (const source of sources) if (source.kind !== "collection") throw new Error("derive.keyed.merge requires collection inputs.");
 };
+/** Complete ordered result reconciliation, without retaining a second member/value cache. */
+const stageKeyedSnapshot = (values, output, keyOf, valueOf, name) => {
+	const seen = /* @__PURE__ */ new Set();
+	const order = new Array(values.length);
+	const previous = output.previous.ids();
+	profile.collectionView.idsScanned(values.length + previous.length);
+	for (let index = 0; index < values.length; index++) {
+		const value = values[index];
+		const key = keyOf(value);
+		assertSynchronous(key);
+		if (typeof key !== "string") throw new TypeError(`${name} key selector must return a string.`);
+		if (seen.has(key)) throw new TypeError(`${name} duplicate key ${JSON.stringify(key)}.`);
+		seen.add(key);
+		order[index] = key;
+		output.output.set(key, valueOf(value));
+	}
+	for (const key of previous) if (!seen.has(key)) output.output.remove(key);
+	output.output.order(order);
+};
 function createKeyedFrom(source, keyOf, equality) {
 	if (typeof keyOf !== "function") throw new TypeError("derive.keyed.from requires a key selector.");
 	const outputEquality = assertEquality(equality, "derive.keyed.from");
@@ -2936,25 +2961,38 @@ function createKeyedFrom(source, keyOf, equality) {
 				values = scalar.value;
 			}
 			if (!values) throw new Error("derive.keyed.from has no source values.");
-			const seen = /* @__PURE__ */ new Set();
-			const order = new Array(values.length);
-			for (let index = 0; index < values.length; index++) {
-				const value = values[index];
-				const key = keyOf(value);
-				assertSynchronous(key);
-				if (typeof key !== "string") throw new TypeError("derive.keyed.from key selector must return a string.");
-				if (seen.has(key)) throw new TypeError(`derive.keyed.from duplicate key ${JSON.stringify(key)}.`);
-				seen.add(key);
-				order[index] = key;
-				output.output.set(key, value);
-			}
-			for (const previousKey of output.previous.ids()) if (!seen.has(previousKey)) output.output.remove(previousKey);
-			output.output.order(order);
+			stageKeyedSnapshot(values, output, keyOf, (value) => value, "derive.keyed.from");
 		} }),
 		name: "derive.keyed.from"
 	});
 	return projection;
 }
+function createKeyedFromEntries(dependencies, compute, equality) {
+	const name = "derive.keyed.fromEntries";
+	const compiled = compileProjectionDependencies(dependencies, name);
+	if (typeof compute !== "function") throw new TypeError(`${name} requires a compute callback.`);
+	const outputEquality = assertEquality(equality, name);
+	const [projection] = defineProcessor({
+		dependencies: compiled.projections,
+		outputs: [{
+			kind: "collection",
+			equality: outputEquality
+		}],
+		name,
+		create: () => ({ evaluate: (evaluation) => {
+			const output = evaluation.outputs[0];
+			if (output.kind !== "collection") throw new Error(`${name} requires a collection output.`);
+			const entries = compute(snapshotProjectionValues(compiled.names, evaluation.sources));
+			assertSynchronous(entries);
+			if (!Array.isArray(entries)) throw new TypeError(`${name} compute must return an array of entries.`);
+			stageKeyedSnapshot(entries, output, (entry) => {
+				assertKeyedEntry(entry, name);
+				return entry[0];
+			}, (entry) => entry[1], name);
+		} })
+	});
+	return projection;
+}
 function createKeyedMerge(sources, options) {
 	if (!Array.isArray(sources)) throw new TypeError("derive.keyed.merge sources must be an array of keyed projections.");
 	const capturedSources = snapshotArray(sources);
@@ -3583,6 +3621,7 @@ const keyedDerive = Object.assign(createKeyedDerive, {
 	entries: createKeyedEntries,
 	get: createKeyedGet,
 	from: createKeyedFrom,
+	fromEntries: createKeyedFromEntries,
 	merge: createKeyedMerge,
 	groupBy: createKeyedGroupBy,
 	flatMap: createKeyedFlatMap,
@@ -3606,9 +3645,7 @@ function createValueDerive(dependencies, compute, equality = Object.is) {
 		create: () => ({ evaluate: (evaluation) => {
 			const output = evaluation.outputs[0];
 			if (output.kind !== "value") throw new Error("derive requires a value output.");
-			const values = Object.create(null);
-			for (let index = 0; index < names.length; index++) values[names[index]] = snapshotDependencyValue(evaluation.sources[index]);
-			const next = compute(Object.freeze(values));
+			const next = compute(snapshotProjectionValues(names, evaluation.sources));
 			assertSynchronous(next);
 			output.output.set(next);
 		} })
@@ -6406,5 +6443,3 @@ const createProjectionRuntime = (options) => {
 };
 //#endregion
 export { DocumentDisposedError, DocumentReentrancyError, ParseError, ProjectionDisposedError, ProjectionError, TransactionRejected, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, select, snapshot, table, tree, variant };
-
-//# sourceMappingURL=index.js.map

package/dist/local-sync.cjs

@@ -514,5 +514,3 @@ const attachLocalSync = async (input) => {
 exports.LocalSyncError = LocalSyncError;
 exports.attachLocalSync = attachLocalSync;
 exports.defaultJsonChangeLimits = defaultJsonChangeLimits;
-
-//# sourceMappingURL=local-sync.cjs.map

package/dist/local-sync.d.cts

@@ -58,5 +58,4 @@ type AttachLocalSyncOptions<TSchema extends ObjectSchema<object>> = {
 //#region core/src/local-sync/session.d.ts
 declare const attachLocalSync: <TSchema extends ObjectSchema<object>>(input: AttachLocalSyncOptions<TSchema>) => Promise<LocalSync>;
 //#endregion
-export { type AttachLocalSyncOptions, type JsonChangeLimits, type JsonPrimitive, type JsonValue, type LocalSync, LocalSyncError, type LocalSyncErrorCode, type LocalSyncState, attachLocalSync, defaultJsonChangeLimits };
-//# sourceMappingURL=local-sync.d.cts.map
+export { type AttachLocalSyncOptions, type JsonChangeLimits, type JsonPrimitive, type JsonValue, type LocalSync, LocalSyncError, type LocalSyncErrorCode, type LocalSyncState, attachLocalSync, defaultJsonChangeLimits };

package/dist/local-sync.d.ts

@@ -58,5 +58,4 @@ type AttachLocalSyncOptions<TSchema extends ObjectSchema<object>> = {
 //#region core/src/local-sync/session.d.ts
 declare const attachLocalSync: <TSchema extends ObjectSchema<object>>(input: AttachLocalSyncOptions<TSchema>) => Promise<LocalSync>;
 //#endregion
-export { type AttachLocalSyncOptions, type JsonChangeLimits, type JsonPrimitive, type JsonValue, type LocalSync, LocalSyncError, type LocalSyncErrorCode, type LocalSyncState, attachLocalSync, defaultJsonChangeLimits };
-//# sourceMappingURL=local-sync.d.ts.map
+export { type AttachLocalSyncOptions, type JsonChangeLimits, type JsonPrimitive, type JsonValue, type LocalSync, LocalSyncError, type LocalSyncErrorCode, type LocalSyncState, attachLocalSync, defaultJsonChangeLimits };

package/dist/local-sync.js

@@ -511,5 +511,3 @@ const attachLocalSync = async (input) => {
 };
 //#endregion
 export { LocalSyncError, attachLocalSync, defaultJsonChangeLimits };
-
-//# sourceMappingURL=local-sync.js.map

package/dist/react.cjs

@@ -57,5 +57,3 @@ exports.useHistory = useHistory;
 exports.useInput = useInput;
 exports.useProjection = useProjection;
 exports.useReadable = useReadable;
-
-//# sourceMappingURL=react.cjs.map

package/dist/react.d.cts

@@ -14,5 +14,4 @@ declare function useHistory<TCommit>(history: LocalHistory<TCommit>): HistorySta
   redo(): OperationResult<TCommit>;
 };
 //#endregion
-export { ProjectionProvider, useDocumentSelector, useHistory, useInput, useProjection, useReadable };
-//# sourceMappingURL=react.d.cts.map
+export { ProjectionProvider, useDocumentSelector, useHistory, useInput, useProjection, useReadable };

package/dist/react.d.ts

@@ -14,5 +14,4 @@ declare function useHistory<TCommit>(history: LocalHistory<TCommit>): HistorySta
   redo(): OperationResult<TCommit>;
 };
 //#endregion
-export { ProjectionProvider, useDocumentSelector, useHistory, useInput, useProjection, useReadable };
-//# sourceMappingURL=react.d.ts.map
+export { ProjectionProvider, useDocumentSelector, useHistory, useInput, useProjection, useReadable };

package/dist/react.js

@@ -51,5 +51,3 @@ function useHistory(history) {
 }
 //#endregion
 export { ProjectionProvider, useDocumentSelector, useHistory, useInput, useProjection, useReadable };
-
-//# sourceMappingURL=react.js.map

package/dist/record-B2yRhYsc.js

@@ -24,5 +24,3 @@ const installOwn = (parent, key, present, value) => {
 };
 //#endregion
 export { isPlainObject as n, isRecord as r, installOwn as t };
-
-//# sourceMappingURL=record-B2yRhYsc.js.map

package/dist/record-ChYUi8PP.cjs

@@ -41,5 +41,3 @@ Object.defineProperty(exports, "isRecord", {
 		return isRecord;
 	}
 });
-
-//# sourceMappingURL=record-ChYUi8PP.cjs.map

package/dist/{transform-RghG_Qxs.js → transform-3mj0eStL.js}

@@ -185,6 +185,12 @@ const readNamedDependencyEntries = (dependencies, label) => {
 };
 /** Creates the durable dependency value exposed to pure derive callbacks. */
 const snapshotDependencyValue = (source) => source.kind === "value" ? source.value : snapshotCollectionView(source.read);
+/** Builds the same readonly named value boundary for scalar and keyed pure computations. */
+const snapshotProjectionValues = (names, sources) => {
+	const values = Object.create(null);
+	for (let index = 0; index < names.length; index++) values[names[index]] = snapshotDependencyValue(sources[index]);
+	return Object.freeze(values);
+};
 /** Compiles the shared named Projection dependency declaration contract. */
 const compileProjectionDependencies = (dependencies, label) => {
 	const names = [];
@@ -1083,6 +1089,4 @@ const createKeyedTransform = (definition) => {
 	return projection;
 };
 //#endregion
-export { ownProjections as A, snapshotDependencyValue as C, defineProcessor as D, snapshotCollectionView as E, projectionRef as M, profile as N, defineSource as O, compileProjectionDependencies as S, mapRead as T, assertSynchronous as _, collectionChangeTouchesKey as a, ProjectionError as b, assertKeyedProjection as c, outputKind as d, createKeyRelation as f, assertScope as g, snapshotArray as h, collectionChangeIntersects as i, producerOf as j, isProjection as k, compileKeyedDependencies as l, sameArray as m, keyedAbsent as n, collectionHasStructuralChange as o, iterableMatchesArray as p, collectionChange as r, createCollectionChange as s, createKeyedTransform as t, createKeyedDependencyRuntime as u, createScheduler as v, collectionView as w, collectKeyedInvalidation as x, ProjectionDisposedError as y };
-
-//# sourceMappingURL=transform-RghG_Qxs.js.map
+export { ownProjections as A, snapshotProjectionValues as C, defineProcessor as D, snapshotCollectionView as E, projectionRef as M, profile as N, defineSource as O, compileProjectionDependencies as S, mapRead as T, assertSynchronous as _, collectionChangeTouchesKey as a, ProjectionError as b, assertKeyedProjection as c, outputKind as d, createKeyRelation as f, assertScope as g, snapshotArray as h, collectionChangeIntersects as i, producerOf as j, isProjection as k, compileKeyedDependencies as l, sameArray as m, keyedAbsent as n, collectionHasStructuralChange as o, iterableMatchesArray as p, collectionChange as r, createCollectionChange as s, createKeyedTransform as t, createKeyedDependencyRuntime as u, createScheduler as v, collectionView as w, collectKeyedInvalidation as x, ProjectionDisposedError as y };