doxum 0.1.27 → 0.1.28

package/README.md

@@ -276,8 +276,8 @@ runtime.dispose();
 
 The stable vocabulary is `read` for a synchronous current value, `select` for a
 `Readable`, and `observe` for declaring a lazy source boundary. `ProjectionRuntime`
-exposes `read`, `select`, `update`, `batch`, `scope` and `dispose`.
-`ProjectionScope` mirrors `read`, `select`, `update`, `batch` and `dispose`, plus
+exposes `read`, `select`, `items`, `update`, `batch`, `scope` and `dispose`.
+`ProjectionScope` mirrors `read`, `select`, `items`, `update`, `batch` and `dispose`, plus
 `own(definitionOrTree)` for lifecycle ownership of lazy projection definitions.
 
 ### Keyed projection
@@ -298,19 +298,31 @@ The same family covers standard keyed structure reads and membership-changing de
 ```ts
 const ids = derive.keyed.keys(records);
 const all = derive.keyed.values(records);
+const entries = derive.keyed.entries(records);
+const active = derive.keyed.get(records, activeRecordId);
 const visible = derive.keyed.filter(records, record => record.visible);
 const orderedVisible = derive.keyed.subset(records, visibleIds);
 const definedContent = derive.keyed.compact(records, record => record.content);
+const recordsBySection = derive.keyed.groupBy(records, record => record.sectionId);
+const activeAsCollection = derive.keyed.singleton(activeRecord, record => record.id);
 ```
 
 `keys` publishes only for membership/order/reset changes; value-only updates keep the
-same array reference and revision. `values` follows the formal keyed order. `subset`
+same array reference and revision. `values` and `entries` follow the formal keyed order;
+`entries` publishes readonly `[key, value]` tuples and reuses unchanged tuple references.
+`get` is a scalar dynamic lookup: it depends only on the selected key, keeps a missing
+key bound for later adds, and accepts optional result equality. `subset`
 uses the supplied ordered keys as both membership selection and output order, ignoring
 currently missing source keys until they appear. `filter` preserves source values and
 source-relative order. `compact` omits keys whose selected value is `undefined` and
 uses its optional equality for present values. `filter` and `compact` support the same
 named global/dynamic keyed dependency object as ordinary `derive.keyed`.
 
+`groupBy` is the general reverse-index primitive. A source entry may return one group
+key or several; each output bucket contains source keys in the source's formal order,
+and group order follows first appearance in that same order. `singleton` converts an
+optional scalar projection into a zero-or-one keyed projection.
+
 All keyed projection producers use the public `KeyedProjection<K,V>` handle, including
 collection `observe`, `derive.keyed`, `incremental.collection`, and collection leaves
 from `incremental.group`. `CollectionInput<K,V>` is the writable Runtime-local form of
@@ -338,6 +350,30 @@ bound, so adding it later invalidates the dependent output keys. An ordinary pro
 dependency invalidates the driver key set when its value changes. Processor code never
 performs imperative Runtime reads to discover dependencies.
 
+Use `{ source, keys }` when one driver key depends on several keys from another keyed
+projection. The callback returns a duplicate-free ordered key array; the dependency
+value is a readonly map containing the currently present selected entries in that order.
+Source-key changes invalidate only the driver keys reverse-bound to that key.
+
+### Keyed Readables
+
+Use `runtime.items(projection)` when a consumer needs stable per-key `Readable`
+identities instead of a whole-collection selector:
+
+```ts
+const recordItems = runtime.items(records);
+const orderedIds = recordItems.keys;
+const record = recordItems.get(recordId); // Readable<Record | undefined>
+```
+
+One family is cached per Runtime/scope lifetime and materialized keyed output. `keys`
+publishes only for membership/order changes. While a key remains a published member,
+`get(key)` returns the same Readable identity and value-only updates notify only that
+item. Removal publishes `undefined` to that generation and retires it; adding the same
+key later creates a new generation. A subscribed missing item stays latent and activates
+if the key is later added. Runtime batches follow the net published membership, so a
+remove/add collapsed to an update does not create a false lifecycle break.
+
 ### Runtime-local keyed state
 
 Use `input.collection` for selection, expanded state, local overrides and other
@@ -432,8 +468,35 @@ const doubled = incremental.collection(
 );
 ```
 
+For retained state that belongs independently to each driver key, use
+`incremental.keyed`:
+
+```ts
+const sectionTotals = incremental.keyed(
+  sections,
+  {
+    records: { source: records, keys: section => section.recordIds },
+  },
+  {
+    state: () => ({ runs: 0 }),
+    process: ({ value, dependencies, state }) => {
+      state.runs++;
+      return [...dependencies.records.values()].reduce((sum, record) => sum + record.score, 0);
+    },
+  }
+);
+```
+
+The driver exclusively owns output membership/order. Each membership owns its retained
+state; removing a key releases that state and a later re-add starts a new membership
+lifecycle. Scalar dependencies invalidate all current driver keys, while singular or
+plural keyed dependencies use reverse routing to run only affected keys. The processor
+returns only its own output value and does not receive a collection draft.
+
 `incremental(...)` produces one scalar value projection.
 `incremental.collection(...)` exposes keyed `previous`, `next` and `output`.
+`incremental.keyed(...)` preserves one driver's keys/order with independent per-key
+retained state and precise dynamic keyed invalidation.
 `incremental.group(...)` runs one processor for several atomic output leaves:
 
 ```ts

package/dist/advanced.cjs

@@ -1,9 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_scheduler = require("./scheduler-k1ZGR1PG.cjs");
+const require_transform = require("./transform-DUleAsG0.cjs");
 const require_record = require("./record-ChYUi8PP.cjs");
 //#region core/src/projection/advanced.ts
 const resetCollectionChange = Object.freeze({ kind: "reset" });
-const publicValue = (source) => source.kind === "value" ? source.value : require_scheduler.collectionView(source.read);
+const publicValue = (source) => source.kind === "value" ? source.value : require_transform.collectionView(source.read);
 const publicInputs = (sources, names, reset) => {
 	const values = Object.create(null);
 	const changes = Object.create(null);
@@ -32,15 +32,15 @@ const validateRetainedState = (definition, label) => {
 const initializeRetainedState = (definition) => {
 	if (definition.state === void 0) return Object.freeze({});
 	const state = definition.state();
-	require_scheduler.assertSynchronous(state);
+	require_transform.assertSynchronous(state);
 	return Object.freeze({ state });
 };
 function createIncrementalValue(dependencies, definition) {
-	const compiled = require_scheduler.compileProjectionDependencies(dependencies, "Incremental");
+	const compiled = require_transform.compileProjectionDependencies(dependencies, "Incremental");
 	validateDefinition(definition, ["state", "process"], "Incremental value");
 	validateRetainedState(definition, "Incremental value");
 	if (typeof definition.process !== "function") throw new TypeError("Incremental value definition requires a process function.");
-	const [projection] = require_scheduler.defineProcessor({
+	const [projection] = require_transform.defineProcessor({
 		dependencies: compiled.projections,
 		outputs: [{
 			kind: "value",
@@ -60,7 +60,7 @@ function createIncrementalValue(dependencies, definition) {
 					cause: evaluation.cause,
 					...state
 				});
-				require_scheduler.assertSynchronous(result);
+				require_transform.assertSynchronous(result);
 				output.output.set(result);
 			} };
 		}
@@ -68,11 +68,11 @@ function createIncrementalValue(dependencies, definition) {
 	return projection;
 }
 function createIncrementalCollection(dependencies, definition) {
-	const compiled = require_scheduler.compileProjectionDependencies(dependencies, "Incremental");
+	const compiled = require_transform.compileProjectionDependencies(dependencies, "Incremental");
 	validateDefinition(definition, ["state", "process"], "Incremental collection");
 	validateRetainedState(definition, "Incremental collection");
 	if (typeof definition.process !== "function") throw new TypeError("Incremental collection definition requires a process function.");
-	const [projection] = require_scheduler.defineProcessor({
+	const [projection] = require_transform.defineProcessor({
 		dependencies: compiled.projections,
 		outputs: [{
 			kind: "collection",
@@ -84,7 +84,7 @@ function createIncrementalCollection(dependencies, definition) {
 				const output = evaluation.outputs[0];
 				if (output.kind !== "collection") throw new Error("Incremental collection output is invalid.");
 				const publicInput = publicInputs(evaluation.sources, compiled.names, evaluation.reset);
-				require_scheduler.assertSynchronous(definition.process({
+				require_transform.assertSynchronous(definition.process({
 					values: publicInput.values,
 					changes: publicInput.changes,
 					previous: output.previous,
@@ -99,6 +99,31 @@ function createIncrementalCollection(dependencies, definition) {
 	});
 	return projection;
 }
+function createIncrementalKeyed(driver, dependencies, definition) {
+	validateDefinition(definition, [
+		"state",
+		"equality",
+		"process"
+	], "Incremental keyed");
+	if (definition.state !== void 0 && typeof definition.state !== "function") throw new TypeError("Incremental keyed state must be a function when provided.");
+	if (definition.equality !== void 0 && typeof definition.equality !== "function") throw new TypeError("Incremental keyed equality must be a function when provided.");
+	if (typeof definition.process !== "function") throw new TypeError("Incremental keyed definition requires a process function.");
+	return require_transform.createKeyedTransform({
+		source: driver,
+		dependencies,
+		equality: definition.equality,
+		name: "incremental.keyed",
+		...definition.state ? { state: definition.state } : {},
+		evaluate: ({ key, value, dependencies: values, state, reset, cause }) => definition.process({
+			key,
+			value,
+			dependencies: values,
+			reset,
+			cause,
+			...definition.state ? { state } : {}
+		})
+	});
+}
 const isPlainGroupNamespace = (value, metadata) => require_record.isPlainObject(value) && !metadata.has(value);
 const compileGroupShape = (value, path, metadata, used, outputs) => {
 	if (value !== null && typeof value === "object") {
@@ -152,7 +177,7 @@ const hydrateGroupReads = (shape, outputs, next) => {
 	return Object.freeze(result);
 };
 function createIncrementalGroup(dependencies, definition) {
-	const compiled = require_scheduler.compileProjectionDependencies(dependencies, "Incremental");
+	const compiled = require_transform.compileProjectionDependencies(dependencies, "Incremental");
 	validateDefinition(definition, [
 		"output",
 		"state",
@@ -182,21 +207,21 @@ function createIncrementalGroup(dependencies, definition) {
 			return descriptor;
 		}
 	});
-	require_scheduler.assertSynchronous(declared);
+	require_transform.assertSynchronous(declared);
 	active = false;
 	const outputs = [];
 	const used = /* @__PURE__ */ new Set();
 	const shape = compileGroupShape(declared, [], metadata, used, outputs);
 	if (typeof shape === "number") throw new TypeError("Incremental group declarations must return an output namespace.");
 	if (used.size === 0 || used.size !== metadata.size) throw new TypeError("Every incremental group output must be returned by the declaration.");
-	return hydrateGroupShape(shape, require_scheduler.defineProcessor({
+	return hydrateGroupShape(shape, require_transform.defineProcessor({
 		dependencies: compiled.projections,
 		outputs,
 		create: () => {
 			const state = initializeRetainedState(definition);
 			return { evaluate: (evaluation) => {
 				const publicInput = publicInputs(evaluation.sources, compiled.names, evaluation.reset);
-				require_scheduler.assertSynchronous(definition.process({
+				require_transform.assertSynchronous(definition.process({
 					values: publicInput.values,
 					changes: publicInput.changes,
 					previous: hydrateGroupReads(shape, evaluation.outputs, false),
@@ -213,10 +238,11 @@ function createIncrementalGroup(dependencies, definition) {
 }
 const incremental = Object.assign(createIncrementalValue, {
 	collection: createIncrementalCollection,
+	keyed: createIncrementalKeyed,
 	group: createIncrementalGroup
 });
 //#endregion
-exports.collectionChange = require_scheduler.collectionChange;
+exports.collectionChange = require_transform.collectionChange;
 exports.incremental = incremental;
 
 //# sourceMappingURL=advanced.cjs.map

package/dist/advanced.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"advanced.cjs","names":["collectionView","isPlainObject","compileProjectionDependencies","defineProcessor"],"sources":["../core/src/projection/advanced.ts"],"sourcesContent":["import { collectionView } from './collection/view';\nimport type { CollectionChange, CollectionDraft, CollectionRead, SourceContext } from './contract';\nimport type {\n  KeyedProjection,\n  OutputDefinition,\n  OutputEvaluation,\n  Projection,\n  ProjectionChange,\n} from './definition';\nimport { defineProcessor } from './definition';\nimport { compileProjectionDependencies } from './dependency';\nimport { assertSynchronous } from './graph/scheduler';\nimport { isPlainObject } from '../value/record';\n\ntype ProjectionDependencies = Readonly<Record<string, Projection<unknown>>>;\n\ntype ProjectionValues<D extends ProjectionDependencies> = {\n  readonly [K in keyof D]: D[K] extends Projection<infer T> ? T : never;\n};\n\ntype ProjectionChanges<D extends ProjectionDependencies> = {\n  readonly [K in keyof D]: ProjectionChange<D[K]> extends undefined\n    ? undefined\n    : ProjectionChange<D[K]> | undefined;\n};\n\ntype RetainedStateContext<State> = [State] extends [never] ? {} : { readonly state: State };\ntype RetainedStateDefinition<State> = [State] extends [never]\n  ? { readonly state?: never }\n  : { readonly state: () => State };\n\nexport type IncrementalValueContext<D extends ProjectionDependencies, T, State = never> = {\n  readonly values: ProjectionValues<D>;\n  readonly changes: ProjectionChanges<D>;\n  readonly previous: T | undefined;\n  readonly reset: boolean;\n  readonly cause: unknown;\n} & RetainedStateContext<State>;\n\nexport type IncrementalValueDefinition<D extends ProjectionDependencies, T, State = never> = {\n  readonly process: (context: IncrementalValueContext<D, T, State>) => T;\n} & RetainedStateDefinition<State>;\n\nexport type IncrementalCollectionContext<\n  D extends ProjectionDependencies,\n  K extends string,\n  V,\n  State = never,\n> = {\n  readonly values: ProjectionValues<D>;\n  readonly changes: ProjectionChanges<D>;\n  readonly previous: CollectionRead<K, V>;\n  readonly next: CollectionRead<K, V>;\n  readonly reset: boolean;\n  readonly cause: unknown;\n  readonly output: CollectionDraft<K, V>;\n} & RetainedStateContext<State>;\n\nexport type IncrementalCollectionDefinition<\n  D extends ProjectionDependencies,\n  K extends string,\n  V,\n  State = never,\n> = {\n  readonly process: (context: IncrementalCollectionContext<D, K, V, State>) => void;\n} & RetainedStateDefinition<State>;\n\ndeclare const groupOutput: unique symbol;\n\n/** Type-only declaration token used by incremental.group output builders. */\nexport type IncrementalGroupOutput<P extends Projection<unknown>> = {\n  readonly [groupOutput]: P;\n};\n\ntype GroupOutputShape = {\n  readonly [name: string]: IncrementalGroupOutput<Projection<unknown>> | GroupOutputShape;\n};\n\ntype GroupOutputBuilder = {\n  collection<K extends string, V>(\n    equality?: (previous: V, next: V) => boolean\n  ): IncrementalGroupOutput<KeyedProjection<K, V>>;\n  value<T>(equality?: (previous: T, next: T) => boolean): IncrementalGroupOutput<Projection<T>>;\n};\n\n/** Portable projection tree returned from an incremental.group declaration. */\nexport type IncrementalGroupResult<O> =\n  O extends IncrementalGroupOutput<infer P>\n    ? P\n    : O extends Readonly<Record<string, unknown>>\n      ? { readonly [K in keyof O]: IncrementalGroupResult<O[K]> }\n      : never;\n\ntype GroupReads<O> =\n  O extends IncrementalGroupOutput<infer P>\n    ? P extends KeyedProjection<infer K, infer V>\n      ? CollectionRead<K, V>\n      : P extends Projection<infer T>\n        ? T | undefined\n        : never\n    : { readonly [K in keyof O]: GroupReads<O[K]> };\n\ntype GroupDrafts<O> =\n  O extends IncrementalGroupOutput<infer P>\n    ? P extends KeyedProjection<infer K, infer V>\n      ? CollectionDraft<K, V>\n      : P extends Projection<infer T>\n        ? { set(value: T): void }\n        : never\n    : { readonly [K in keyof O]: GroupDrafts<O[K]> };\n\nexport type IncrementalGroupContext<\n  D extends ProjectionDependencies,\n  O extends GroupOutputShape,\n  State = never,\n> = {\n  readonly values: ProjectionValues<D>;\n  readonly changes: ProjectionChanges<D>;\n  readonly previous: GroupReads<O>;\n  readonly next: GroupReads<O>;\n  readonly output: GroupDrafts<O>;\n  readonly reset: boolean;\n  readonly cause: unknown;\n} & RetainedStateContext<State>;\n\ntype IncrementalGroupDefinition<\n  D extends ProjectionDependencies,\n  O extends GroupOutputShape,\n  State = never,\n> = {\n  readonly output: (define: GroupOutputBuilder) => O;\n  readonly process: (context: IncrementalGroupContext<D, O, State>) => void;\n} & RetainedStateDefinition<State>;\n\nconst resetCollectionChange = Object.freeze({ kind: 'reset' as const });\n\nconst publicValue = (source: SourceContext): unknown =>\n  source.kind === 'value' ? source.value : collectionView(source.read);\n\nconst publicInputs = (\n  sources: readonly SourceContext[],\n  names: readonly string[],\n  reset: boolean\n): {\n  readonly values: Readonly<Record<string, unknown>>;\n  readonly changes: Readonly<Record<string, unknown>>;\n} => {\n  const values: Record<string, unknown> = Object.create(null) as Record<string, unknown>;\n  const changes: Record<string, unknown> = Object.create(null) as Record<string, unknown>;\n  for (let index = 0; index < names.length; index++) {\n    const source = sources[index];\n    values[names[index]] = publicValue(source);\n    changes[names[index]] =\n      source.kind === 'collection' ? (reset ? resetCollectionChange : source.change) : undefined;\n  }\n  return Object.freeze({ values: Object.freeze(values), changes: Object.freeze(changes) });\n};\n\nfunction validateDefinition(\n  definition: unknown,\n  allowed: readonly string[],\n  label: string\n): asserts definition is Record<string, unknown> {\n  if (!isPlainObject(definition))\n    throw new TypeError(`${label} definition must be a plain object.`);\n  const allowedKeys = new Set(allowed);\n  for (const key of Reflect.ownKeys(definition)) {\n    if (typeof key !== 'string' || !allowedKeys.has(key))\n      throw new TypeError(`${label} definition contains an unknown property.`);\n    const descriptor = Object.getOwnPropertyDescriptor(definition, key);\n    if (!descriptor?.enumerable || !('value' in descriptor))\n      throw new TypeError(`${label} definition must contain enumerable data properties.`);\n  }\n}\n\nconst validateRetainedState = (definition: Record<string, unknown>, label: string): void => {\n  if (\n    Object.prototype.hasOwnProperty.call(definition, 'state') &&\n    typeof definition.state !== 'function'\n  )\n    throw new TypeError(`${label} state must be a function when provided.`);\n};\n\nconst initializeRetainedState = (definition: {\n  readonly state?: () => unknown;\n}): Readonly<Record<string, unknown>> => {\n  if (definition.state === undefined) return Object.freeze({});\n  const state = definition.state();\n  assertSynchronous(state);\n  return Object.freeze({ state });\n};\n\ntype RuntimeIncrementalDefinition<Result> = {\n  readonly state?: () => unknown;\n  readonly process: (context: never) => Result;\n};\n\nfunction createIncrementalValue<const D extends ProjectionDependencies, T>(\n  dependencies: D,\n  definition: IncrementalValueDefinition<D, T>\n): Projection<T>;\nfunction createIncrementalValue<const D extends ProjectionDependencies, T, State>(\n  dependencies: D,\n  definition: {\n    readonly state: () => State;\n    readonly process: (context: IncrementalValueContext<D, T, State>) => T;\n  }\n): Projection<T>;\nfunction createIncrementalValue<const D extends ProjectionDependencies, T>(\n  dependencies: D,\n  definition: RuntimeIncrementalDefinition<T>\n): Projection<T> {\n  const compiled = compileProjectionDependencies(dependencies, 'Incremental');\n  validateDefinition(definition, ['state', 'process'], 'Incremental value');\n  validateRetainedState(definition, 'Incremental value');\n  if (typeof definition.process !== 'function')\n    throw new TypeError('Incremental value definition requires a process function.');\n  const [projection] = defineProcessor({\n    dependencies: compiled.projections,\n    outputs: [{ kind: 'value', equality: Object.is }],\n    create: () => {\n      const state = initializeRetainedState(definition);\n      return {\n        evaluate: evaluation => {\n          const output = evaluation.outputs[0];\n          if (output.kind !== 'value') throw new Error('Incremental value output is invalid.');\n          const publicInput = publicInputs(evaluation.sources, compiled.names, evaluation.reset);\n          const result = definition.process({\n            values: publicInput.values as ProjectionValues<D>,\n            changes: publicInput.changes as ProjectionChanges<D>,\n            previous: output.previous as T | undefined,\n            reset: evaluation.reset,\n            cause: evaluation.cause,\n            ...state,\n          } as never);\n          assertSynchronous(result);\n          output.output.set(result);\n        },\n      };\n    },\n  });\n  return projection as Projection<T>;\n}\n\nfunction createIncrementalCollection<const D extends ProjectionDependencies, K extends string, V>(\n  dependencies: D,\n  definition: IncrementalCollectionDefinition<D, K, V>\n): KeyedProjection<K, V>;\nfunction createIncrementalCollection<\n  const D extends ProjectionDependencies,\n  K extends string,\n  V,\n  State,\n>(\n  dependencies: D,\n  definition: {\n    readonly state: () => State;\n    readonly process: (context: IncrementalCollectionContext<D, K, V, State>) => void;\n  }\n): KeyedProjection<K, V>;\nfunction createIncrementalCollection<const D extends ProjectionDependencies, K extends string, V>(\n  dependencies: D,\n  definition: RuntimeIncrementalDefinition<void>\n): KeyedProjection<K, V> {\n  const compiled = compileProjectionDependencies(dependencies, 'Incremental');\n  validateDefinition(definition, ['state', 'process'], 'Incremental collection');\n  validateRetainedState(definition, 'Incremental collection');\n  if (typeof definition.process !== 'function')\n    throw new TypeError('Incremental collection definition requires a process function.');\n  const [projection] = defineProcessor({\n    dependencies: compiled.projections,\n    outputs: [{ kind: 'collection', equality: Object.is }],\n    create: () => {\n      const state = initializeRetainedState(definition);\n      return {\n        evaluate: evaluation => {\n          const output = evaluation.outputs[0];\n          if (output.kind !== 'collection')\n            throw new Error('Incremental collection output is invalid.');\n          const publicInput = publicInputs(evaluation.sources, compiled.names, evaluation.reset);\n          const result = definition.process({\n            values: publicInput.values as ProjectionValues<D>,\n            changes: publicInput.changes as ProjectionChanges<D>,\n            previous: output.previous as CollectionRead<K, V>,\n            next: output.next as CollectionRead<K, V>,\n            reset: evaluation.reset,\n            cause: evaluation.cause,\n            output: output.output as CollectionDraft<K, V>,\n            ...state,\n          } as never);\n          assertSynchronous(result);\n        },\n      };\n    },\n  });\n  return projection as KeyedProjection<K, V>;\n}\n\ntype GroupShape = number | { readonly [key: string]: GroupShape };\ntype GroupOutputMetadata = {\n  readonly kind: OutputDefinition['kind'];\n  readonly equality: (a: unknown, b: unknown) => boolean;\n};\n\nconst isPlainGroupNamespace = (\n  value: unknown,\n  metadata: ReadonlyMap<object, GroupOutputMetadata>\n): value is Record<string, unknown> => isPlainObject(value) && !metadata.has(value);\n\nconst compileGroupShape = (\n  value: unknown,\n  path: readonly string[],\n  metadata: ReadonlyMap<object, GroupOutputMetadata>,\n  used: Set<object>,\n  outputs: OutputDefinition[]\n): GroupShape => {\n  if (value !== null && typeof value === 'object') {\n    const output = metadata.get(value);\n    if (output) {\n      if (used.has(value)) throw new TypeError('An incremental group output cannot be reused.');\n      used.add(value);\n      const index = outputs.length;\n      outputs.push({\n        kind: output.kind,\n        equality: output.equality,\n        path: Object.freeze([...path]),\n      });\n      return index;\n    }\n  }\n  if (!isPlainGroupNamespace(value, metadata))\n    throw new TypeError('Incremental group outputs must be a static object tree.');\n  for (const key of Reflect.ownKeys(value)) {\n    if (typeof key !== 'string')\n      throw new TypeError('Incremental group output names must be strings.');\n    if (!Object.prototype.propertyIsEnumerable.call(value, key))\n      throw new TypeError('Incremental group namespaces must contain enumerable properties.');\n  }\n  const keys = Object.keys(value);\n  if (!keys.length) throw new TypeError('Incremental group namespaces cannot be empty.');\n  const result: Record<string, GroupShape> = Object.create(null) as Record<string, GroupShape>;\n  for (const key of keys) {\n    if (key === '__proto__' || key === 'prototype' || key === 'constructor')\n      throw new TypeError(`Invalid incremental group output name: ${key}`);\n    const descriptor = Object.getOwnPropertyDescriptor(value, key);\n    if (!descriptor || !('value' in descriptor))\n      throw new TypeError('Incremental group namespaces cannot contain accessors.');\n    result[key] = compileGroupShape(descriptor.value, [...path, key], metadata, used, outputs);\n  }\n  return Object.freeze(result);\n};\n\nconst hydrateGroupShape = <T>(shape: GroupShape, values: readonly T[]): unknown => {\n  if (typeof shape === 'number') return values[shape];\n  const result: Record<string, unknown> = {};\n  for (const [key, child] of Object.entries(shape)) result[key] = hydrateGroupShape(child, values);\n  return Object.freeze(result);\n};\n\nconst hydrateGroupReads = (\n  shape: GroupShape,\n  outputs: readonly OutputEvaluation[],\n  next: boolean\n): unknown => {\n  if (typeof shape === 'number') {\n    const output = outputs[shape];\n    return next && output.kind === 'value' ? output.next() : next ? output.next : output.previous;\n  }\n  const result: Record<string, unknown> = {};\n  for (const [key, child] of Object.entries(shape)) {\n    if (typeof child === 'number' && next && outputs[child].kind === 'value') {\n      Object.defineProperty(result, key, {\n        enumerable: true,\n        configurable: false,\n        get: () => (outputs[child] as Extract<OutputEvaluation, { kind: 'value' }>).next(),\n      });\n    } else result[key] = hydrateGroupReads(child, outputs, next);\n  }\n  return Object.freeze(result);\n};\n\nfunction createIncrementalGroup<\n  const D extends ProjectionDependencies,\n  const O extends GroupOutputShape,\n>(dependencies: D, definition: IncrementalGroupDefinition<D, O>): IncrementalGroupResult<O>;\nfunction createIncrementalGroup<\n  const D extends ProjectionDependencies,\n  const O extends GroupOutputShape,\n  State,\n>(\n  dependencies: D,\n  definition: {\n    readonly output: (define: GroupOutputBuilder) => O;\n    readonly state: () => State;\n    readonly process: (context: IncrementalGroupContext<D, O, State>) => void;\n  }\n): IncrementalGroupResult<O>;\nfunction createIncrementalGroup<\n  const D extends ProjectionDependencies,\n  const O extends GroupOutputShape,\n>(\n  dependencies: D,\n  definition: RuntimeIncrementalDefinition<void> & {\n    readonly output: (define: GroupOutputBuilder) => O;\n  }\n): IncrementalGroupResult<O> {\n  const compiled = compileProjectionDependencies(dependencies, 'Incremental');\n  validateDefinition(definition, ['output', 'state', 'process'], 'Incremental group');\n  validateRetainedState(definition, 'Incremental group');\n  if (typeof definition.output !== 'function' || typeof definition.process !== 'function')\n    throw new TypeError('Incremental group definition requires output and process functions.');\n\n  let active = true;\n  const metadata = new Map<object, GroupOutputMetadata>();\n  const defineOutput: GroupOutputBuilder = {\n    collection: <K extends string, V>(equality: (previous: V, next: V) => boolean = Object.is) => {\n      if (!active) throw new TypeError('Incremental group output declarations are synchronous.');\n      const descriptor = Object.freeze({});\n      metadata.set(descriptor, {\n        kind: 'collection',\n        equality: equality as (a: unknown, b: unknown) => boolean,\n      });\n      return descriptor as IncrementalGroupOutput<KeyedProjection<K, V>>;\n    },\n    value: <T>(equality: (previous: T, next: T) => boolean = Object.is) => {\n      if (!active) throw new TypeError('Incremental group output declarations are synchronous.');\n      const descriptor = Object.freeze({});\n      metadata.set(descriptor, {\n        kind: 'value',\n        equality: equality as (a: unknown, b: unknown) => boolean,\n      });\n      return descriptor as IncrementalGroupOutput<Projection<T>>;\n    },\n  };\n  const declared = definition.output(defineOutput);\n  assertSynchronous(declared);\n  active = false;\n  const outputs: OutputDefinition[] = [];\n  const used = new Set<object>();\n  const shape = compileGroupShape(declared, [], metadata, used, outputs);\n  if (typeof shape === 'number')\n    throw new TypeError('Incremental group declarations must return an output namespace.');\n  if (used.size === 0 || used.size !== metadata.size)\n    throw new TypeError('Every incremental group output must be returned by the declaration.');\n\n  const projections = defineProcessor({\n    dependencies: compiled.projections,\n    outputs,\n    create: () => {\n      const state = initializeRetainedState(definition);\n      return {\n        evaluate: evaluation => {\n          const publicInput = publicInputs(evaluation.sources, compiled.names, evaluation.reset);\n          const result = definition.process({\n            values: publicInput.values as ProjectionValues<D>,\n            changes: publicInput.changes as ProjectionChanges<D>,\n            previous: hydrateGroupReads(shape, evaluation.outputs, false) as GroupReads<O>,\n            next: hydrateGroupReads(shape, evaluation.outputs, true) as GroupReads<O>,\n            output: hydrateGroupShape(\n              shape,\n              evaluation.outputs.map(output => output.output)\n            ) as GroupDrafts<O>,\n            reset: evaluation.reset,\n            cause: evaluation.cause,\n            ...state,\n          } as never);\n          assertSynchronous(result);\n        },\n      };\n    },\n    name: `processor-group:${outputs.map(output => output.path?.join('.') ?? '').join(',')}`,\n  });\n  return hydrateGroupShape(shape, projections) as IncrementalGroupResult<O>;\n}\n\nexport const incremental = Object.assign(createIncrementalValue, {\n  collection: createIncrementalCollection,\n  group: createIncrementalGroup,\n});\n\nexport { collectionChange } from './collection/change';\nexport type { CollectionChange } from './contract';\n"],"mappings":"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"}
+{"version":3,"file":"advanced.cjs","names":["collectionView","isPlainObject","compileProjectionDependencies","defineProcessor","createKeyedTransform"],"sources":["../core/src/projection/advanced.ts"],"sourcesContent":["import { collectionView } from '@/projection/collection/view';\nimport type { CollectionChange, CollectionDraft, CollectionRead, SourceContext } from './contract';\nimport type {\n  KeyedProjection,\n  OutputDefinition,\n  OutputEvaluation,\n  Projection,\n  ProjectionChange,\n} from './definition';\nimport { defineProcessor } from './definition';\nimport { compileProjectionDependencies } from './dependency';\nimport { assertSynchronous } from '@/projection/graph/scheduler';\nimport { isPlainObject } from '@/value/record';\nimport type {\n  KeyedDependencies,\n  KeyedDependencyRecord,\n  KeyedDependencyValues,\n} from '@/projection/keyed/dependency';\nimport { createKeyedTransform } from '@/projection/keyed/transform';\n\ntype ProjectionDependencies = Readonly<Record<string, Projection<unknown>>>;\n\ntype ProjectionValues<D extends ProjectionDependencies> = {\n  readonly [K in keyof D]: D[K] extends Projection<infer T> ? T : never;\n};\n\ntype ProjectionChanges<D extends ProjectionDependencies> = {\n  readonly [K in keyof D]: ProjectionChange<D[K]> extends undefined\n    ? undefined\n    : ProjectionChange<D[K]> | undefined;\n};\n\ntype RetainedStateContext<State> = [State] extends [never] ? {} : { readonly state: State };\ntype RetainedStateDefinition<State> = [State] extends [never]\n  ? { readonly state?: never }\n  : { readonly state: () => State };\n\nexport type IncrementalValueContext<D extends ProjectionDependencies, T, State = never> = {\n  readonly values: ProjectionValues<D>;\n  readonly changes: ProjectionChanges<D>;\n  readonly previous: T | undefined;\n  readonly reset: boolean;\n  readonly cause: unknown;\n} & RetainedStateContext<State>;\n\nexport type IncrementalValueDefinition<D extends ProjectionDependencies, T, State = never> = {\n  readonly process: (context: IncrementalValueContext<D, T, State>) => T;\n} & RetainedStateDefinition<State>;\n\nexport type IncrementalCollectionContext<\n  D extends ProjectionDependencies,\n  K extends string,\n  V,\n  State = never,\n> = {\n  readonly values: ProjectionValues<D>;\n  readonly changes: ProjectionChanges<D>;\n  readonly previous: CollectionRead<K, V>;\n  readonly next: CollectionRead<K, V>;\n  readonly reset: boolean;\n  readonly cause: unknown;\n  readonly output: CollectionDraft<K, V>;\n} & RetainedStateContext<State>;\n\nexport type IncrementalCollectionDefinition<\n  D extends ProjectionDependencies,\n  K extends string,\n  V,\n  State = never,\n> = {\n  readonly process: (context: IncrementalCollectionContext<D, K, V, State>) => void;\n} & RetainedStateDefinition<State>;\n\nexport type IncrementalKeyedContext<K extends string, V, D extends object, State = never> = {\n  readonly key: K;\n  readonly value: V;\n  readonly dependencies: KeyedDependencyValues<D>;\n  readonly reset: boolean;\n  readonly cause: unknown;\n} & RetainedStateContext<State>;\n\nexport type IncrementalKeyedDefinition<K extends string, V, D extends object, T, State = never> = {\n  readonly equality?: (previous: T, next: T) => boolean;\n  readonly process: (context: IncrementalKeyedContext<K, V, D, State>) => T;\n} & ([State] extends [never]\n  ? { readonly state?: never }\n  : { readonly state: (value: V, key: K) => State });\n\ndeclare const groupOutput: unique symbol;\n\n/** Type-only declaration token used by incremental.group output builders. */\nexport type IncrementalGroupOutput<P extends Projection<unknown>> = {\n  readonly [groupOutput]: P;\n};\n\ntype GroupOutputShape = {\n  readonly [name: string]: IncrementalGroupOutput<Projection<unknown>> | GroupOutputShape;\n};\n\ntype GroupOutputBuilder = {\n  collection<K extends string, V>(\n    equality?: (previous: V, next: V) => boolean\n  ): IncrementalGroupOutput<KeyedProjection<K, V>>;\n  value<T>(equality?: (previous: T, next: T) => boolean): IncrementalGroupOutput<Projection<T>>;\n};\n\n/** Portable projection tree returned from an incremental.group declaration. */\nexport type IncrementalGroupResult<O> =\n  O extends IncrementalGroupOutput<infer P>\n    ? P\n    : O extends Readonly<Record<string, unknown>>\n      ? { readonly [K in keyof O]: IncrementalGroupResult<O[K]> }\n      : never;\n\ntype GroupReads<O> =\n  O extends IncrementalGroupOutput<infer P>\n    ? P extends KeyedProjection<infer K, infer V>\n      ? CollectionRead<K, V>\n      : P extends Projection<infer T>\n        ? T | undefined\n        : never\n    : { readonly [K in keyof O]: GroupReads<O[K]> };\n\ntype GroupDrafts<O> =\n  O extends IncrementalGroupOutput<infer P>\n    ? P extends KeyedProjection<infer K, infer V>\n      ? CollectionDraft<K, V>\n      : P extends Projection<infer T>\n        ? { set(value: T): void }\n        : never\n    : { readonly [K in keyof O]: GroupDrafts<O[K]> };\n\nexport type IncrementalGroupContext<\n  D extends ProjectionDependencies,\n  O extends GroupOutputShape,\n  State = never,\n> = {\n  readonly values: ProjectionValues<D>;\n  readonly changes: ProjectionChanges<D>;\n  readonly previous: GroupReads<O>;\n  readonly next: GroupReads<O>;\n  readonly output: GroupDrafts<O>;\n  readonly reset: boolean;\n  readonly cause: unknown;\n} & RetainedStateContext<State>;\n\ntype IncrementalGroupDefinition<\n  D extends ProjectionDependencies,\n  O extends GroupOutputShape,\n  State = never,\n> = {\n  readonly output: (define: GroupOutputBuilder) => O;\n  readonly process: (context: IncrementalGroupContext<D, O, State>) => void;\n} & RetainedStateDefinition<State>;\n\nconst resetCollectionChange = Object.freeze({ kind: 'reset' as const });\n\nconst publicValue = (source: SourceContext): unknown =>\n  source.kind === 'value' ? source.value : collectionView(source.read);\n\nconst publicInputs = (\n  sources: readonly SourceContext[],\n  names: readonly string[],\n  reset: boolean\n): {\n  readonly values: Readonly<Record<string, unknown>>;\n  readonly changes: Readonly<Record<string, unknown>>;\n} => {\n  const values: Record<string, unknown> = Object.create(null) as Record<string, unknown>;\n  const changes: Record<string, unknown> = Object.create(null) as Record<string, unknown>;\n  for (let index = 0; index < names.length; index++) {\n    const source = sources[index];\n    values[names[index]] = publicValue(source);\n    changes[names[index]] =\n      source.kind === 'collection' ? (reset ? resetCollectionChange : source.change) : undefined;\n  }\n  return Object.freeze({ values: Object.freeze(values), changes: Object.freeze(changes) });\n};\n\nfunction validateDefinition(\n  definition: unknown,\n  allowed: readonly string[],\n  label: string\n): asserts definition is Record<string, unknown> {\n  if (!isPlainObject(definition))\n    throw new TypeError(`${label} definition must be a plain object.`);\n  const allowedKeys = new Set(allowed);\n  for (const key of Reflect.ownKeys(definition)) {\n    if (typeof key !== 'string' || !allowedKeys.has(key))\n      throw new TypeError(`${label} definition contains an unknown property.`);\n    const descriptor = Object.getOwnPropertyDescriptor(definition, key);\n    if (!descriptor?.enumerable || !('value' in descriptor))\n      throw new TypeError(`${label} definition must contain enumerable data properties.`);\n  }\n}\n\nconst validateRetainedState = (definition: Record<string, unknown>, label: string): void => {\n  if (\n    Object.prototype.hasOwnProperty.call(definition, 'state') &&\n    typeof definition.state !== 'function'\n  )\n    throw new TypeError(`${label} state must be a function when provided.`);\n};\n\nconst initializeRetainedState = (definition: {\n  readonly state?: () => unknown;\n}): Readonly<Record<string, unknown>> => {\n  if (definition.state === undefined) return Object.freeze({});\n  const state = definition.state();\n  assertSynchronous(state);\n  return Object.freeze({ state });\n};\n\ntype RuntimeIncrementalDefinition<Result> = {\n  readonly state?: () => unknown;\n  readonly process: (context: never) => Result;\n};\n\nfunction createIncrementalValue<const D extends ProjectionDependencies, T>(\n  dependencies: D,\n  definition: IncrementalValueDefinition<D, T>\n): Projection<T>;\nfunction createIncrementalValue<const D extends ProjectionDependencies, T, State>(\n  dependencies: D,\n  definition: {\n    readonly state: () => State;\n    readonly process: (context: IncrementalValueContext<D, T, State>) => T;\n  }\n): Projection<T>;\nfunction createIncrementalValue<const D extends ProjectionDependencies, T>(\n  dependencies: D,\n  definition: RuntimeIncrementalDefinition<T>\n): Projection<T> {\n  const compiled = compileProjectionDependencies(dependencies, 'Incremental');\n  validateDefinition(definition, ['state', 'process'], 'Incremental value');\n  validateRetainedState(definition, 'Incremental value');\n  if (typeof definition.process !== 'function')\n    throw new TypeError('Incremental value definition requires a process function.');\n  const [projection] = defineProcessor({\n    dependencies: compiled.projections,\n    outputs: [{ kind: 'value', equality: Object.is }],\n    create: () => {\n      const state = initializeRetainedState(definition);\n      return {\n        evaluate: evaluation => {\n          const output = evaluation.outputs[0];\n          if (output.kind !== 'value') throw new Error('Incremental value output is invalid.');\n          const publicInput = publicInputs(evaluation.sources, compiled.names, evaluation.reset);\n          const result = definition.process({\n            values: publicInput.values as ProjectionValues<D>,\n            changes: publicInput.changes as ProjectionChanges<D>,\n            previous: output.previous as T | undefined,\n            reset: evaluation.reset,\n            cause: evaluation.cause,\n            ...state,\n          } as never);\n          assertSynchronous(result);\n          output.output.set(result);\n        },\n      };\n    },\n  });\n  return projection as Projection<T>;\n}\n\nfunction createIncrementalCollection<const D extends ProjectionDependencies, K extends string, V>(\n  dependencies: D,\n  definition: IncrementalCollectionDefinition<D, K, V>\n): KeyedProjection<K, V>;\nfunction createIncrementalCollection<\n  const D extends ProjectionDependencies,\n  K extends string,\n  V,\n  State,\n>(\n  dependencies: D,\n  definition: {\n    readonly state: () => State;\n    readonly process: (context: IncrementalCollectionContext<D, K, V, State>) => void;\n  }\n): KeyedProjection<K, V>;\nfunction createIncrementalCollection<const D extends ProjectionDependencies, K extends string, V>(\n  dependencies: D,\n  definition: RuntimeIncrementalDefinition<void>\n): KeyedProjection<K, V> {\n  const compiled = compileProjectionDependencies(dependencies, 'Incremental');\n  validateDefinition(definition, ['state', 'process'], 'Incremental collection');\n  validateRetainedState(definition, 'Incremental collection');\n  if (typeof definition.process !== 'function')\n    throw new TypeError('Incremental collection definition requires a process function.');\n  const [projection] = defineProcessor({\n    dependencies: compiled.projections,\n    outputs: [{ kind: 'collection', equality: Object.is }],\n    create: () => {\n      const state = initializeRetainedState(definition);\n      return {\n        evaluate: evaluation => {\n          const output = evaluation.outputs[0];\n          if (output.kind !== 'collection')\n            throw new Error('Incremental collection output is invalid.');\n          const publicInput = publicInputs(evaluation.sources, compiled.names, evaluation.reset);\n          const result = definition.process({\n            values: publicInput.values as ProjectionValues<D>,\n            changes: publicInput.changes as ProjectionChanges<D>,\n            previous: output.previous as CollectionRead<K, V>,\n            next: output.next as CollectionRead<K, V>,\n            reset: evaluation.reset,\n            cause: evaluation.cause,\n            output: output.output as CollectionDraft<K, V>,\n            ...state,\n          } as never);\n          assertSynchronous(result);\n        },\n      };\n    },\n  });\n  return projection as KeyedProjection<K, V>;\n}\n\nfunction createIncrementalKeyed<K extends string, V, const D extends object, T, State>(\n  driver: KeyedProjection<K, V>,\n  dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>,\n  definition: {\n    readonly state: (value: NoInfer<V>, key: NoInfer<K>) => State;\n    readonly equality?: (previous: T, next: T) => boolean;\n    readonly process: (context: IncrementalKeyedContext<NoInfer<K>, NoInfer<V>, D, State>) => T;\n  }\n): KeyedProjection<K, T>;\nfunction createIncrementalKeyed<K extends string, V, const D extends object, T>(\n  driver: KeyedProjection<K, V>,\n  dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>,\n  definition: {\n    readonly equality?: (previous: T, next: T) => boolean;\n    readonly process: (context: IncrementalKeyedContext<NoInfer<K>, NoInfer<V>, D>) => T;\n  }\n): KeyedProjection<K, T>;\nfunction createIncrementalKeyed<K extends string, V, T>(\n  driver: KeyedProjection<K, V>,\n  dependencies: KeyedDependencyRecord<K, V>,\n  definition: {\n    readonly state?: (value: V, key: K) => unknown;\n    readonly equality?: (previous: T, next: T) => boolean;\n    readonly process: (context: never) => T;\n  }\n): KeyedProjection<K, T> {\n  validateDefinition(definition, ['state', 'equality', 'process'], 'Incremental keyed');\n  if (definition.state !== undefined && typeof definition.state !== 'function')\n    throw new TypeError('Incremental keyed state must be a function when provided.');\n  if (definition.equality !== undefined && typeof definition.equality !== 'function')\n    throw new TypeError('Incremental keyed equality must be a function when provided.');\n  if (typeof definition.process !== 'function')\n    throw new TypeError('Incremental keyed definition requires a process function.');\n\n  return createKeyedTransform<K, V, T, unknown>({\n    source: driver,\n    dependencies,\n    equality: definition.equality,\n    name: 'incremental.keyed',\n    ...(definition.state ? { state: definition.state } : {}),\n    evaluate: ({ key, value, dependencies: values, state, reset, cause }) =>\n      definition.process({\n        key,\n        value,\n        dependencies: values,\n        reset,\n        cause,\n        ...(definition.state ? { state } : {}),\n      } as never),\n  });\n}\n\ntype GroupShape = number | { readonly [key: string]: GroupShape };\ntype GroupOutputMetadata = {\n  readonly kind: OutputDefinition['kind'];\n  readonly equality: (a: unknown, b: unknown) => boolean;\n};\n\nconst isPlainGroupNamespace = (\n  value: unknown,\n  metadata: ReadonlyMap<object, GroupOutputMetadata>\n): value is Record<string, unknown> => isPlainObject(value) && !metadata.has(value);\n\nconst compileGroupShape = (\n  value: unknown,\n  path: readonly string[],\n  metadata: ReadonlyMap<object, GroupOutputMetadata>,\n  used: Set<object>,\n  outputs: OutputDefinition[]\n): GroupShape => {\n  if (value !== null && typeof value === 'object') {\n    const output = metadata.get(value);\n    if (output) {\n      if (used.has(value)) throw new TypeError('An incremental group output cannot be reused.');\n      used.add(value);\n      const index = outputs.length;\n      outputs.push({\n        kind: output.kind,\n        equality: output.equality,\n        path: Object.freeze([...path]),\n      });\n      return index;\n    }\n  }\n  if (!isPlainGroupNamespace(value, metadata))\n    throw new TypeError('Incremental group outputs must be a static object tree.');\n  for (const key of Reflect.ownKeys(value)) {\n    if (typeof key !== 'string')\n      throw new TypeError('Incremental group output names must be strings.');\n    if (!Object.prototype.propertyIsEnumerable.call(value, key))\n      throw new TypeError('Incremental group namespaces must contain enumerable properties.');\n  }\n  const keys = Object.keys(value);\n  if (!keys.length) throw new TypeError('Incremental group namespaces cannot be empty.');\n  const result: Record<string, GroupShape> = Object.create(null) as Record<string, GroupShape>;\n  for (const key of keys) {\n    if (key === '__proto__' || key === 'prototype' || key === 'constructor')\n      throw new TypeError(`Invalid incremental group output name: ${key}`);\n    const descriptor = Object.getOwnPropertyDescriptor(value, key);\n    if (!descriptor || !('value' in descriptor))\n      throw new TypeError('Incremental group namespaces cannot contain accessors.');\n    result[key] = compileGroupShape(descriptor.value, [...path, key], metadata, used, outputs);\n  }\n  return Object.freeze(result);\n};\n\nconst hydrateGroupShape = <T>(shape: GroupShape, values: readonly T[]): unknown => {\n  if (typeof shape === 'number') return values[shape];\n  const result: Record<string, unknown> = {};\n  for (const [key, child] of Object.entries(shape)) result[key] = hydrateGroupShape(child, values);\n  return Object.freeze(result);\n};\n\nconst hydrateGroupReads = (\n  shape: GroupShape,\n  outputs: readonly OutputEvaluation[],\n  next: boolean\n): unknown => {\n  if (typeof shape === 'number') {\n    const output = outputs[shape];\n    return next && output.kind === 'value' ? output.next() : next ? output.next : output.previous;\n  }\n  const result: Record<string, unknown> = {};\n  for (const [key, child] of Object.entries(shape)) {\n    if (typeof child === 'number' && next && outputs[child].kind === 'value') {\n      Object.defineProperty(result, key, {\n        enumerable: true,\n        configurable: false,\n        get: () => (outputs[child] as Extract<OutputEvaluation, { kind: 'value' }>).next(),\n      });\n    } else result[key] = hydrateGroupReads(child, outputs, next);\n  }\n  return Object.freeze(result);\n};\n\nfunction createIncrementalGroup<\n  const D extends ProjectionDependencies,\n  const O extends GroupOutputShape,\n>(dependencies: D, definition: IncrementalGroupDefinition<D, O>): IncrementalGroupResult<O>;\nfunction createIncrementalGroup<\n  const D extends ProjectionDependencies,\n  const O extends GroupOutputShape,\n  State,\n>(\n  dependencies: D,\n  definition: {\n    readonly output: (define: GroupOutputBuilder) => O;\n    readonly state: () => State;\n    readonly process: (context: IncrementalGroupContext<D, O, State>) => void;\n  }\n): IncrementalGroupResult<O>;\nfunction createIncrementalGroup<\n  const D extends ProjectionDependencies,\n  const O extends GroupOutputShape,\n>(\n  dependencies: D,\n  definition: RuntimeIncrementalDefinition<void> & {\n    readonly output: (define: GroupOutputBuilder) => O;\n  }\n): IncrementalGroupResult<O> {\n  const compiled = compileProjectionDependencies(dependencies, 'Incremental');\n  validateDefinition(definition, ['output', 'state', 'process'], 'Incremental group');\n  validateRetainedState(definition, 'Incremental group');\n  if (typeof definition.output !== 'function' || typeof definition.process !== 'function')\n    throw new TypeError('Incremental group definition requires output and process functions.');\n\n  let active = true;\n  const metadata = new Map<object, GroupOutputMetadata>();\n  const defineOutput: GroupOutputBuilder = {\n    collection: <K extends string, V>(equality: (previous: V, next: V) => boolean = Object.is) => {\n      if (!active) throw new TypeError('Incremental group output declarations are synchronous.');\n      const descriptor = Object.freeze({});\n      metadata.set(descriptor, {\n        kind: 'collection',\n        equality: equality as (a: unknown, b: unknown) => boolean,\n      });\n      return descriptor as IncrementalGroupOutput<KeyedProjection<K, V>>;\n    },\n    value: <T>(equality: (previous: T, next: T) => boolean = Object.is) => {\n      if (!active) throw new TypeError('Incremental group output declarations are synchronous.');\n      const descriptor = Object.freeze({});\n      metadata.set(descriptor, {\n        kind: 'value',\n        equality: equality as (a: unknown, b: unknown) => boolean,\n      });\n      return descriptor as IncrementalGroupOutput<Projection<T>>;\n    },\n  };\n  const declared = definition.output(defineOutput);\n  assertSynchronous(declared);\n  active = false;\n  const outputs: OutputDefinition[] = [];\n  const used = new Set<object>();\n  const shape = compileGroupShape(declared, [], metadata, used, outputs);\n  if (typeof shape === 'number')\n    throw new TypeError('Incremental group declarations must return an output namespace.');\n  if (used.size === 0 || used.size !== metadata.size)\n    throw new TypeError('Every incremental group output must be returned by the declaration.');\n\n  const projections = defineProcessor({\n    dependencies: compiled.projections,\n    outputs,\n    create: () => {\n      const state = initializeRetainedState(definition);\n      return {\n        evaluate: evaluation => {\n          const publicInput = publicInputs(evaluation.sources, compiled.names, evaluation.reset);\n          const result = definition.process({\n            values: publicInput.values as ProjectionValues<D>,\n            changes: publicInput.changes as ProjectionChanges<D>,\n            previous: hydrateGroupReads(shape, evaluation.outputs, false) as GroupReads<O>,\n            next: hydrateGroupReads(shape, evaluation.outputs, true) as GroupReads<O>,\n            output: hydrateGroupShape(\n              shape,\n              evaluation.outputs.map(output => output.output)\n            ) as GroupDrafts<O>,\n            reset: evaluation.reset,\n            cause: evaluation.cause,\n            ...state,\n          } as never);\n          assertSynchronous(result);\n        },\n      };\n    },\n    name: `processor-group:${outputs.map(output => output.path?.join('.') ?? '').join(',')}`,\n  });\n  return hydrateGroupShape(shape, projections) as IncrementalGroupResult<O>;\n}\n\nexport const incremental = Object.assign(createIncrementalValue, {\n  collection: createIncrementalCollection,\n  keyed: createIncrementalKeyed,\n  group: createIncrementalGroup,\n});\n\nexport { collectionChange } from '@/projection/collection/change';\nexport type { CollectionChange } from './contract';\n"],"mappings":"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"}

package/dist/advanced.d.cts

@@ -1,4 +1,4 @@
-import { a as Projection, c as CollectionDraft, i as KeyedProjection, l as CollectionRead, o as ProjectionChange, s as CollectionChange } from "./definition-CDOuvb5C.cjs";
+import { c as ProjectionChange, d as CollectionRead, l as CollectionChange, n as KeyedDependencyValues, o as KeyedProjection, s as Projection, t as KeyedDependencies, u as CollectionDraft } from "./dependency-B3E65M1E.cjs";
 
 //#region core/src/projection/collection/change.d.ts
 declare const collectionChange: {
@@ -41,6 +41,21 @@ type IncrementalCollectionContext<D extends ProjectionDependencies, K extends st
 type IncrementalCollectionDefinition<D extends ProjectionDependencies, K extends string, V, State = never> = {
   readonly process: (context: IncrementalCollectionContext<D, K, V, State>) => void;
 } & RetainedStateDefinition<State>;
+type IncrementalKeyedContext<K extends string, V, D extends object, State = never> = {
+  readonly key: K;
+  readonly value: V;
+  readonly dependencies: KeyedDependencyValues<D>;
+  readonly reset: boolean;
+  readonly cause: unknown;
+} & RetainedStateContext<State>;
+type IncrementalKeyedDefinition<K extends string, V, D extends object, T, State = never> = {
+  readonly equality?: (previous: T, next: T) => boolean;
+  readonly process: (context: IncrementalKeyedContext<K, V, D, State>) => T;
+} & ([State] extends [never] ? {
+  readonly state?: never;
+} : {
+  readonly state: (value: V, key: K) => State;
+});
 declare const groupOutput: unique symbol;
 /** Type-only declaration token used by incremental.group output builders. */
 type IncrementalGroupOutput<P extends Projection<unknown>> = {
@@ -82,6 +97,15 @@ declare function createIncrementalCollection<const D extends ProjectionDependenc
   readonly state: () => State;
   readonly process: (context: IncrementalCollectionContext<D, K, V, State>) => void;
 }): KeyedProjection<K, V>;
+declare function createIncrementalKeyed<K extends string, V, const D extends object, T, State>(driver: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, definition: {
+  readonly state: (value: NoInfer<V>, key: NoInfer<K>) => State;
+  readonly equality?: (previous: T, next: T) => boolean;
+  readonly process: (context: IncrementalKeyedContext<NoInfer<K>, NoInfer<V>, D, State>) => T;
+}): KeyedProjection<K, T>;
+declare function createIncrementalKeyed<K extends string, V, const D extends object, T>(driver: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, definition: {
+  readonly equality?: (previous: T, next: T) => boolean;
+  readonly process: (context: IncrementalKeyedContext<NoInfer<K>, NoInfer<V>, D>) => T;
+}): KeyedProjection<K, T>;
 declare function createIncrementalGroup<const D extends ProjectionDependencies, const O extends GroupOutputShape>(dependencies: D, definition: IncrementalGroupDefinition<D, O>): IncrementalGroupResult<O>;
 declare function createIncrementalGroup<const D extends ProjectionDependencies, const O extends GroupOutputShape, State>(dependencies: D, definition: {
   readonly output: (define: GroupOutputBuilder) => O;
@@ -90,8 +114,9 @@ declare function createIncrementalGroup<const D extends ProjectionDependencies,
 }): IncrementalGroupResult<O>;
 declare const incremental: typeof createIncrementalValue & {
   collection: typeof createIncrementalCollection;
+  keyed: typeof createIncrementalKeyed;
   group: typeof createIncrementalGroup;
 };
 //#endregion
-export { type CollectionChange, IncrementalCollectionContext, IncrementalCollectionDefinition, IncrementalGroupContext, IncrementalGroupOutput, IncrementalGroupResult, IncrementalValueContext, IncrementalValueDefinition, collectionChange, incremental };
+export { type CollectionChange, IncrementalCollectionContext, IncrementalCollectionDefinition, IncrementalGroupContext, IncrementalGroupOutput, IncrementalGroupResult, IncrementalKeyedContext, IncrementalKeyedDefinition, IncrementalValueContext, IncrementalValueDefinition, collectionChange, incremental };
 //# sourceMappingURL=advanced.d.cts.map

package/dist/advanced.d.ts

@@ -1,4 +1,4 @@
-import { a as Projection, c as CollectionDraft, i as KeyedProjection, l as CollectionRead, o as ProjectionChange, s as CollectionChange } from "./definition-xgk3YNBp.js";
+import { c as ProjectionChange, d as CollectionRead, l as CollectionChange, n as KeyedDependencyValues, o as KeyedProjection, s as Projection, t as KeyedDependencies, u as CollectionDraft } from "./dependency-BYbdDHNa.js";
 
 //#region core/src/projection/collection/change.d.ts
 declare const collectionChange: {
@@ -41,6 +41,21 @@ type IncrementalCollectionContext<D extends ProjectionDependencies, K extends st
 type IncrementalCollectionDefinition<D extends ProjectionDependencies, K extends string, V, State = never> = {
   readonly process: (context: IncrementalCollectionContext<D, K, V, State>) => void;
 } & RetainedStateDefinition<State>;
+type IncrementalKeyedContext<K extends string, V, D extends object, State = never> = {
+  readonly key: K;
+  readonly value: V;
+  readonly dependencies: KeyedDependencyValues<D>;
+  readonly reset: boolean;
+  readonly cause: unknown;
+} & RetainedStateContext<State>;
+type IncrementalKeyedDefinition<K extends string, V, D extends object, T, State = never> = {
+  readonly equality?: (previous: T, next: T) => boolean;
+  readonly process: (context: IncrementalKeyedContext<K, V, D, State>) => T;
+} & ([State] extends [never] ? {
+  readonly state?: never;
+} : {
+  readonly state: (value: V, key: K) => State;
+});
 declare const groupOutput: unique symbol;
 /** Type-only declaration token used by incremental.group output builders. */
 type IncrementalGroupOutput<P extends Projection<unknown>> = {
@@ -82,6 +97,15 @@ declare function createIncrementalCollection<const D extends ProjectionDependenc
   readonly state: () => State;
   readonly process: (context: IncrementalCollectionContext<D, K, V, State>) => void;
 }): KeyedProjection<K, V>;
+declare function createIncrementalKeyed<K extends string, V, const D extends object, T, State>(driver: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, definition: {
+  readonly state: (value: NoInfer<V>, key: NoInfer<K>) => State;
+  readonly equality?: (previous: T, next: T) => boolean;
+  readonly process: (context: IncrementalKeyedContext<NoInfer<K>, NoInfer<V>, D, State>) => T;
+}): KeyedProjection<K, T>;
+declare function createIncrementalKeyed<K extends string, V, const D extends object, T>(driver: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, definition: {
+  readonly equality?: (previous: T, next: T) => boolean;
+  readonly process: (context: IncrementalKeyedContext<NoInfer<K>, NoInfer<V>, D>) => T;
+}): KeyedProjection<K, T>;
 declare function createIncrementalGroup<const D extends ProjectionDependencies, const O extends GroupOutputShape>(dependencies: D, definition: IncrementalGroupDefinition<D, O>): IncrementalGroupResult<O>;
 declare function createIncrementalGroup<const D extends ProjectionDependencies, const O extends GroupOutputShape, State>(dependencies: D, definition: {
   readonly output: (define: GroupOutputBuilder) => O;
@@ -90,8 +114,9 @@ declare function createIncrementalGroup<const D extends ProjectionDependencies,
 }): IncrementalGroupResult<O>;
 declare const incremental: typeof createIncrementalValue & {
   collection: typeof createIncrementalCollection;
+  keyed: typeof createIncrementalKeyed;
   group: typeof createIncrementalGroup;
 };
 //#endregion
-export { type CollectionChange, IncrementalCollectionContext, IncrementalCollectionDefinition, IncrementalGroupContext, IncrementalGroupOutput, IncrementalGroupResult, IncrementalValueContext, IncrementalValueDefinition, collectionChange, incremental };
+export { type CollectionChange, IncrementalCollectionContext, IncrementalCollectionDefinition, IncrementalGroupContext, IncrementalGroupOutput, IncrementalGroupResult, IncrementalKeyedContext, IncrementalKeyedDefinition, IncrementalValueContext, IncrementalValueDefinition, collectionChange, incremental };
 //# sourceMappingURL=advanced.d.ts.map

package/dist/advanced.js

@@ -1,4 +1,4 @@
-import { f as collectionView, h as defineProcessor, n as assertSynchronous, o as collectionChange, u as compileProjectionDependencies } from "./scheduler-vzf3OcjT.js";
+import { S as defineProcessor, _ as compileProjectionDependencies, l as assertSynchronous, p as collectionChange, t as createKeyedTransform, y as collectionView } from "./transform-B4T3AcJr.js";
 import { n as isPlainObject } from "./record-B2yRhYsc.js";
 //#region core/src/projection/advanced.ts
 const resetCollectionChange = Object.freeze({ kind: "reset" });
@@ -98,6 +98,31 @@ function createIncrementalCollection(dependencies, definition) {
 	});
 	return projection;
 }
+function createIncrementalKeyed(driver, dependencies, definition) {
+	validateDefinition(definition, [
+		"state",
+		"equality",
+		"process"
+	], "Incremental keyed");
+	if (definition.state !== void 0 && typeof definition.state !== "function") throw new TypeError("Incremental keyed state must be a function when provided.");
+	if (definition.equality !== void 0 && typeof definition.equality !== "function") throw new TypeError("Incremental keyed equality must be a function when provided.");
+	if (typeof definition.process !== "function") throw new TypeError("Incremental keyed definition requires a process function.");
+	return createKeyedTransform({
+		source: driver,
+		dependencies,
+		equality: definition.equality,
+		name: "incremental.keyed",
+		...definition.state ? { state: definition.state } : {},
+		evaluate: ({ key, value, dependencies: values, state, reset, cause }) => definition.process({
+			key,
+			value,
+			dependencies: values,
+			reset,
+			cause,
+			...definition.state ? { state } : {}
+		})
+	});
+}
 const isPlainGroupNamespace = (value, metadata) => isPlainObject(value) && !metadata.has(value);
 const compileGroupShape = (value, path, metadata, used, outputs) => {
 	if (value !== null && typeof value === "object") {
@@ -212,6 +237,7 @@ function createIncrementalGroup(dependencies, definition) {
 }
 const incremental = Object.assign(createIncrementalValue, {
 	collection: createIncrementalCollection,
+	keyed: createIncrementalKeyed,
 	group: createIncrementalGroup
 });
 //#endregion