doxum 0.1.34 → 0.1.35

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

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" });

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" });

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);
 		} })