doxum 0.1.15 → 0.1.16

package/README.md

@@ -254,6 +254,12 @@ const doubled = incremental.collection([tasks], ({ sources, output }) => {
 });
 ```
 
+Incremental processors receive a dependency-aligned `changes` tuple. Collection
+entries carry discriminated `added`/`updated`/`removed` transitions with complete
+`before`/`after` values, so a processor can patch indexes without rescanning the
+collection; scalar dependencies use `undefined` and the initial collection build
+reports `{ kind: 'reset' }`.
+
 In React, `useProjection(projection)` reads a value and
 `useProjection(projection, selector, equality?)` tracks keyed reads such as
 `tasks => tasks.get(taskId)`. Unrelated key changes do not execute that selector;

package/dist/advanced.cjs

@@ -3,8 +3,39 @@ const require_scope = require("./scope-Ezs-Y3TY.cjs");
 const require_definition = require("./definition-Z6TagMup.cjs");
 //#region core/src/projection/advanced.ts
 const dependenciesOf = (dependencies) => Object.fromEntries(dependencies.map((dependency, index) => [`d${index}`, dependency]));
-const sourceChange = (sources) => {
-	for (const source of Object.values(sources)) if (source && typeof source === "object" && "change" in source && source.change !== void 0) return source.change;
+const resetCollectionChange = Object.freeze({ kind: "reset" });
+const isCollectionSource = (source) => Boolean(source && typeof source === "object" && "ids" in source && typeof source.ids === "function" && "previous" in source && "transitions" in source && typeof source.transitions === "function");
+const collectionChange = (source) => {
+	if (!isCollectionSource(source)) return void 0;
+	if (source.reset || source.change?.kind === "reset") return resetCollectionChange;
+	const impact = source.change;
+	if (!impact) return void 0;
+	const added = [];
+	const updated = [];
+	const removed = [];
+	for (const transition of source.transitions()) if (transition.kind === "added") added.push({
+		key: transition.key,
+		kind: transition.kind,
+		after: transition.after
+	});
+	else if (transition.kind === "updated") updated.push(transition);
+	else removed.push({
+		key: transition.key,
+		kind: transition.kind,
+		before: transition.before
+	});
+	const order = impact.orderChanged ? {
+		before: Object.freeze([...source.previous.ids()]),
+		after: Object.freeze([...source.ids()])
+	} : void 0;
+	if (!added.length && !updated.length && !removed.length && !order) return void 0;
+	return Object.freeze({
+		kind: "incremental",
+		added: Object.freeze(added),
+		updated: Object.freeze(updated),
+		removed: Object.freeze(removed),
+		...order ? { order: Object.freeze(order) } : {}
+	});
 };
 const sourceCause = (sources) => {
 	for (const source of Object.values(sources)) if (source && typeof source === "object" && "cause" in source && source.cause !== void 0) return source.cause;
@@ -29,7 +60,19 @@ const publicSource = (source) => {
 	}
 	return source;
 };
-const publicTuple = (sources) => Object.keys(sources).sort((left, right) => Number(left.slice(1)) - Number(right.slice(1))).map((key) => publicSource(sources[key]));
+const publicInputs = (sources, initial = false) => {
+	const values = [];
+	const changes = [];
+	for (const key of Object.keys(sources).sort((left, right) => Number(left.slice(1)) - Number(right.slice(1)))) {
+		const source = sources[key];
+		values.push(publicSource(source));
+		changes.push(initial && isCollectionSource(source) ? resetCollectionChange : collectionChange(source));
+	}
+	return {
+		values,
+		changes
+	};
+};
 const normalizeValue = (result) => result && typeof result === "object" && result.kind === "value" ? {
 	value: result.value,
 	state: result.state
@@ -40,11 +83,12 @@ function createIncrementalValue(dependencies, processor) {
 	let current;
 	const build = (sources) => {
 		state = Object.create(null);
+		const publicInputsForBuild = publicInputs(sources, true);
 		const result = processor({
-			sources: publicTuple(sources),
+			sources: publicInputsForBuild.values,
+			changes: publicInputsForBuild.changes,
 			previous: void 0,
 			reset: true,
-			change: void 0,
 			cause: sourceCause(sources),
 			state
 		});
@@ -55,11 +99,12 @@ function createIncrementalValue(dependencies, processor) {
 		return {
 			value: current,
 			update: (nextSources) => {
+				const publicInputsForUpdate = publicInputs(nextSources);
 				const next = processor({
-					sources: publicTuple(nextSources),
+					sources: publicInputsForUpdate.values,
+					changes: publicInputsForUpdate.changes,
 					previous: current,
 					reset: false,
-					change: sourceChange(nextSources),
 					cause: sourceCause(nextSources),
 					state
 				});
@@ -84,26 +129,30 @@ function createIncrementalCollection(dependencies, processor) {
 	let state = Object.create(null);
 	const build = (input) => {
 		state = Object.create(null);
+		const publicInputsForBuild = publicInputs(input.sources, true);
 		if (processor({
-			sources: publicTuple(input.sources),
+			sources: publicInputsForBuild.values,
+			changes: publicInputsForBuild.changes,
 			previous: input.previous,
 			next: input.next,
 			reset: true,
-			change: void 0,
 			cause: sourceCause(input.sources),
 			state,
 			output: input.writer
 		})?.kind === "rebuild") throw new TypeError("Initial incremental collection processor cannot rebuild.");
-		return { update: (nextInput) => processor({
-			sources: publicTuple(nextInput.sources),
-			previous: nextInput.previous,
-			next: nextInput.next,
-			reset: false,
-			change: sourceChange(nextInput.sources),
-			cause: sourceCause(nextInput.sources),
-			state,
-			output: nextInput.writer
-		}) };
+		return { update: (nextInput) => {
+			const publicInputsForUpdate = publicInputs(nextInput.sources);
+			return processor({
+				sources: publicInputsForUpdate.values,
+				changes: publicInputsForUpdate.changes,
+				previous: nextInput.previous,
+				next: nextInput.next,
+				reset: false,
+				cause: sourceCause(nextInput.sources),
+				state,
+				output: nextInput.writer
+			});
+		} };
 	};
 	return require_definition.defineIncrementalCollection({
 		dependencies: dependencyMap,

package/dist/advanced.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"advanced.cjs","names":["snapshot","defineIncrementalValue","defineIncrementalCollection"],"sources":["../core/src/projection/advanced.ts"],"sourcesContent":["import type { Projection, ProjectionValues, PublicCollection } from './definition';\nimport { defineIncrementalCollection, defineIncrementalValue } from './definition';\nimport type { CollectionDraft, CollectionRead, GraphSources } from './contract';\nimport { snapshot } from '../access/scope';\n\nexport type IncrementalState = Record<string, unknown>;\n\nexport type IncrementalValueContext<S, T> = {\n  readonly sources: S;\n  readonly previous: T | undefined;\n  readonly reset: boolean;\n  readonly change: unknown;\n  readonly cause: unknown;\n  readonly state: IncrementalState;\n};\n\nexport type IncrementalValueProcessor<S, T> = (\n  context: IncrementalValueContext<S, T>\n) =>\n  | T\n  | { readonly kind: 'value'; readonly value: T; readonly state?: IncrementalState }\n  | { readonly kind: 'rebuild' };\n\nexport type IncrementalCollectionContext<S, K extends string, V> = {\n  readonly sources: S;\n  readonly previous: CollectionRead<K, V>;\n  readonly next: CollectionRead<K, V>;\n  readonly change: unknown;\n  readonly reset: boolean;\n  readonly cause: unknown;\n  readonly state: IncrementalState;\n  readonly output: CollectionDraft<K, V>;\n};\n\nexport type IncrementalCollectionProcessor<S, K extends string, V> = (\n  context: IncrementalCollectionContext<S, K, V>\n) => void | { readonly kind: 'rebuild' };\n\ntype DependencyMap<D extends readonly Projection<unknown>[]> = {\n  readonly [K in keyof D as `d${Extract<K, number>}`]: D[K];\n};\n\nconst dependenciesOf = <D extends readonly Projection<unknown>[]>(dependencies: D): GraphSources =>\n  Object.fromEntries(\n    dependencies.map((dependency, index) => [`d${index}`, dependency])\n  ) as unknown as GraphSources;\n\nconst sourceChange = (sources: Record<string, unknown>): unknown => {\n  for (const source of Object.values(sources)) {\n    if (\n      source &&\n      typeof source === 'object' &&\n      'change' in source &&\n      (source as { readonly change?: unknown }).change !== undefined\n    )\n      return (source as { readonly change?: unknown }).change;\n  }\n  return undefined;\n};\n\nconst sourceCause = (sources: Record<string, unknown>): unknown => {\n  for (const source of Object.values(sources)) {\n    if (\n      source &&\n      typeof source === 'object' &&\n      'cause' in source &&\n      (source as { readonly cause?: unknown }).cause !== undefined\n    )\n      return (source as { readonly cause?: unknown }).cause;\n  }\n  return undefined;\n};\n\nconst publicSource = (source: unknown): unknown => {\n  if (!source || typeof source !== 'object') return source;\n  if ('value' in source) return (source as { readonly value: unknown }).value;\n  if ('read' in source) {\n    const read = (source as { readonly read: unknown }).read;\n    if (\n      read &&\n      typeof read === 'object' &&\n      'ids' in read &&\n      typeof (read as { ids?: unknown }).ids === 'function'\n    ) {\n      const result = new Map<string, unknown>();\n      for (const id of (read as CollectionRead<string, unknown>).ids())\n        result.set(id, (read as CollectionRead<string, unknown>).get(id));\n      return result;\n    }\n    return snapshot(read);\n  }\n  if ('ids' in source && typeof (source as { ids?: unknown }).ids === 'function') {\n    const result = new Map<string, unknown>();\n    const read = source as CollectionRead<string, unknown>;\n    for (const id of read.ids()) result.set(id, read.get(id));\n    return result;\n  }\n  return source;\n};\n\nconst publicTuple = (sources: Record<string, unknown>): readonly unknown[] =>\n  Object.keys(sources)\n    .sort((left, right) => Number(left.slice(1)) - Number(right.slice(1)))\n    .map(key => publicSource(sources[key]));\n\nconst normalizeValue = <T>(\n  result: T | { readonly kind: 'value'; readonly value: T; readonly state?: IncrementalState }\n): { value: T; state?: IncrementalState } =>\n  result && typeof result === 'object' && (result as { readonly kind?: unknown }).kind === 'value'\n    ? {\n        value: (result as { readonly value: T }).value,\n        state: (result as { readonly state?: IncrementalState }).state,\n      }\n    : { value: result as T };\n\nfunction createIncrementalValue<const D extends readonly Projection<unknown>[], T>(\n  dependencies: D,\n  processor: IncrementalValueProcessor<ProjectionValues<D>, T>\n): Projection<T> {\n  const dependencyMap = dependenciesOf(dependencies);\n  let state: IncrementalState = Object.create(null) as IncrementalState;\n  let current!: T;\n  const build = (sources: Record<string, unknown>) => {\n    state = Object.create(null) as IncrementalState;\n    const result = processor({\n      sources: publicTuple(sources) as ProjectionValues<D>,\n      previous: undefined,\n      reset: true,\n      change: undefined,\n      cause: sourceCause(sources),\n      state,\n    });\n    if (result && typeof result === 'object' && 'kind' in result)\n      throw new TypeError('Initial incremental processor cannot rebuild.');\n    const normalized = normalizeValue(result as T);\n    current = normalized.value;\n    if (normalized.state) state = normalized.state;\n    return {\n      value: current,\n      update: (nextSources: Record<string, unknown>) => {\n        const next = processor({\n          sources: publicTuple(nextSources) as ProjectionValues<D>,\n          previous: current,\n          reset: false,\n          change: sourceChange(nextSources),\n          cause: sourceCause(nextSources),\n          state,\n        });\n        if (next && typeof next === 'object' && 'kind' in next) return next;\n        const nextValue = normalizeValue(next as T);\n        current = nextValue.value;\n        if (nextValue.state) state = nextValue.state;\n        return { kind: 'changed', value: current } as const;\n      },\n    };\n  };\n  return defineIncrementalValue({ dependencies: dependencyMap, build: build as never });\n}\n\nfunction createIncrementalCollection<\n  const D extends readonly Projection<unknown>[],\n  K extends string,\n  V,\n>(\n  dependencies: D,\n  processor: IncrementalCollectionProcessor<ProjectionValues<D>, K, V>\n): Projection<PublicCollection<K, V>> {\n  const dependencyMap = dependenciesOf(dependencies);\n  let state: IncrementalState = Object.create(null) as IncrementalState;\n  const build = (input: {\n    readonly sources: Record<string, unknown>;\n    readonly previous: CollectionRead<K, V>;\n    readonly next: CollectionRead<K, V>;\n    readonly writer: CollectionDraft<K, V>;\n  }) => {\n    state = Object.create(null) as IncrementalState;\n    const result = processor({\n      sources: publicTuple(input.sources) as ProjectionValues<D>,\n      previous: input.previous,\n      next: input.next,\n      reset: true,\n      change: undefined,\n      cause: sourceCause(input.sources),\n      state,\n      output: input.writer,\n    });\n    if (result?.kind === 'rebuild')\n      throw new TypeError('Initial incremental collection processor cannot rebuild.');\n    return {\n      update: (nextInput: typeof input) =>\n        processor({\n          sources: publicTuple(nextInput.sources) as ProjectionValues<D>,\n          previous: nextInput.previous,\n          next: nextInput.next,\n          reset: false,\n          change: sourceChange(nextInput.sources),\n          cause: sourceCause(nextInput.sources),\n          state,\n          output: nextInput.writer,\n        }),\n    };\n  };\n  return defineIncrementalCollection({ dependencies: dependencyMap, build: build as never });\n}\n\nexport const incremental = Object.assign(createIncrementalValue, {\n  collection: createIncrementalCollection,\n});\n\nexport type IncrementalDependencies<D extends readonly Projection<unknown>[]> = DependencyMap<D>;\n"],"mappings":"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"}
+{"version":3,"file":"advanced.cjs","names":["snapshot","defineIncrementalValue","defineIncrementalCollection"],"sources":["../core/src/projection/advanced.ts"],"sourcesContent":["import type {\n  Projection,\n  CollectionProjection,\n  ProjectionChanges,\n  ProjectionValues,\n  PublicCollection,\n} from './definition';\nimport { defineIncrementalCollection, defineIncrementalValue } from './definition';\nimport type {\n  CollectionChange,\n  CollectionDraft,\n  CollectionEntryTransition,\n  CollectionRead,\n  GraphSources,\n} from './contract';\nimport { snapshot } from '../access/scope';\n\nexport type IncrementalState = Record<string, unknown>;\n\nexport type IncrementalValueContext<D extends readonly Projection<unknown, unknown>[], T> = {\n  readonly sources: ProjectionValues<D>;\n  readonly changes: ProjectionChanges<D>;\n  readonly previous: T | undefined;\n  readonly reset: boolean;\n  readonly cause: unknown;\n  readonly state: IncrementalState;\n};\n\nexport type IncrementalValueProcessor<D extends readonly Projection<unknown, unknown>[], T> = (\n  context: IncrementalValueContext<D, T>\n) =>\n  | T\n  | { readonly kind: 'value'; readonly value: T; readonly state?: IncrementalState }\n  | { readonly kind: 'rebuild' };\n\nexport type IncrementalCollectionContext<\n  D extends readonly Projection<unknown, unknown>[],\n  K extends string,\n  V,\n> = {\n  readonly sources: 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 state: IncrementalState;\n  readonly output: CollectionDraft<K, V>;\n};\n\nexport type IncrementalCollectionProcessor<\n  D extends readonly Projection<unknown, unknown>[],\n  K extends string,\n  V,\n> = (context: IncrementalCollectionContext<D, K, V>) => void | { readonly kind: 'rebuild' };\n\ntype DependencyMap<D extends readonly Projection<unknown, unknown>[]> = {\n  readonly [K in keyof D as `d${Extract<K, number>}`]: D[K];\n};\n\nconst dependenciesOf = <D extends readonly Projection<unknown, unknown>[]>(\n  dependencies: D\n): GraphSources =>\n  Object.fromEntries(\n    dependencies.map((dependency, index) => [`d${index}`, dependency])\n  ) as unknown as GraphSources;\n\ntype RuntimeCollectionSource = {\n  readonly ids: () => readonly string[];\n  readonly previous: CollectionRead<string, unknown>;\n  readonly reset: boolean;\n  readonly change?: { readonly kind: 'reset' | 'incremental'; readonly orderChanged?: boolean };\n  readonly transitions: () => readonly CollectionEntryTransition<string, unknown>[];\n};\nconst resetCollectionChange = Object.freeze({ kind: 'reset' as const });\ntype IncrementalCollectionChange = Extract<\n  CollectionChange<string, unknown>,\n  { readonly kind: 'incremental' }\n>;\n\nconst isCollectionSource = (source: unknown): source is RuntimeCollectionSource =>\n  Boolean(\n    source &&\n    typeof source === 'object' &&\n    'ids' in source &&\n    typeof (source as { readonly ids?: unknown }).ids === 'function' &&\n    'previous' in source &&\n    'transitions' in source &&\n    typeof (source as { readonly transitions?: unknown }).transitions === 'function'\n  );\n\nconst collectionChange = (source: unknown): CollectionChange<string, unknown> | undefined => {\n  if (!isCollectionSource(source)) return undefined;\n  if (source.reset || source.change?.kind === 'reset') return resetCollectionChange;\n  const impact = source.change;\n  if (!impact) return undefined;\n  const added: IncrementalCollectionChange['added'][number][] = [];\n  const updated: IncrementalCollectionChange['updated'][number][] = [];\n  const removed: IncrementalCollectionChange['removed'][number][] = [];\n  for (const transition of source.transitions()) {\n    if (transition.kind === 'added')\n      added.push({ key: transition.key, kind: transition.kind, after: transition.after });\n    else if (transition.kind === 'updated') updated.push(transition);\n    else removed.push({ key: transition.key, kind: transition.kind, before: transition.before });\n  }\n  const order = impact.orderChanged\n    ? {\n        before: Object.freeze([...source.previous.ids()]),\n        after: Object.freeze([...source.ids()]),\n      }\n    : undefined;\n  if (!added.length && !updated.length && !removed.length && !order) return undefined;\n  return Object.freeze({\n    kind: 'incremental' as const,\n    added: Object.freeze(added),\n    updated: Object.freeze(updated),\n    removed: Object.freeze(removed),\n    ...(order ? { order: Object.freeze(order) } : {}),\n  });\n};\n\nconst sourceCause = (sources: Record<string, unknown>): unknown => {\n  for (const source of Object.values(sources)) {\n    if (\n      source &&\n      typeof source === 'object' &&\n      'cause' in source &&\n      (source as { readonly cause?: unknown }).cause !== undefined\n    )\n      return (source as { readonly cause?: unknown }).cause;\n  }\n  return undefined;\n};\n\nconst publicSource = (source: unknown): unknown => {\n  if (!source || typeof source !== 'object') return source;\n  if ('value' in source) return (source as { readonly value: unknown }).value;\n  if ('read' in source) {\n    const read = (source as { readonly read: unknown }).read;\n    if (\n      read &&\n      typeof read === 'object' &&\n      'ids' in read &&\n      typeof (read as { ids?: unknown }).ids === 'function'\n    ) {\n      const result = new Map<string, unknown>();\n      for (const id of (read as CollectionRead<string, unknown>).ids())\n        result.set(id, (read as CollectionRead<string, unknown>).get(id));\n      return result;\n    }\n    return snapshot(read);\n  }\n  if ('ids' in source && typeof (source as { ids?: unknown }).ids === 'function') {\n    const result = new Map<string, unknown>();\n    const read = source as CollectionRead<string, unknown>;\n    for (const id of read.ids()) result.set(id, read.get(id));\n    return result;\n  }\n  return source;\n};\n\nconst publicInputs = (\n  sources: Record<string, unknown>,\n  initial = false\n): { readonly values: readonly unknown[]; readonly changes: readonly unknown[] } => {\n  const values: unknown[] = [];\n  const changes: unknown[] = [];\n  for (const key of Object.keys(sources).sort(\n    (left, right) => Number(left.slice(1)) - Number(right.slice(1))\n  )) {\n    const source = sources[key];\n    values.push(publicSource(source));\n    changes.push(\n      initial && isCollectionSource(source) ? resetCollectionChange : collectionChange(source)\n    );\n  }\n  return { values, changes };\n};\n\nconst normalizeValue = <T>(\n  result: T | { readonly kind: 'value'; readonly value: T; readonly state?: IncrementalState }\n): { value: T; state?: IncrementalState } =>\n  result && typeof result === 'object' && (result as { readonly kind?: unknown }).kind === 'value'\n    ? {\n        value: (result as { readonly value: T }).value,\n        state: (result as { readonly state?: IncrementalState }).state,\n      }\n    : { value: result as T };\n\nfunction createIncrementalValue<const D extends readonly Projection<unknown, unknown>[], T>(\n  dependencies: D,\n  processor: IncrementalValueProcessor<D, T>\n): Projection<T> {\n  const dependencyMap = dependenciesOf(dependencies);\n  let state: IncrementalState = Object.create(null) as IncrementalState;\n  let current!: T;\n  const build = (sources: Record<string, unknown>) => {\n    state = Object.create(null) as IncrementalState;\n    const publicInputsForBuild = publicInputs(sources, true);\n    const result = processor({\n      sources: publicInputsForBuild.values as ProjectionValues<D>,\n      changes: publicInputsForBuild.changes as ProjectionChanges<D>,\n      previous: undefined,\n      reset: true,\n      cause: sourceCause(sources),\n      state,\n    });\n    if (result && typeof result === 'object' && 'kind' in result)\n      throw new TypeError('Initial incremental processor cannot rebuild.');\n    const normalized = normalizeValue(result as T);\n    current = normalized.value;\n    if (normalized.state) state = normalized.state;\n    return {\n      value: current,\n      update: (nextSources: Record<string, unknown>) => {\n        const publicInputsForUpdate = publicInputs(nextSources);\n        const next = processor({\n          sources: publicInputsForUpdate.values as ProjectionValues<D>,\n          changes: publicInputsForUpdate.changes as ProjectionChanges<D>,\n          previous: current,\n          reset: false,\n          cause: sourceCause(nextSources),\n          state,\n        });\n        if (next && typeof next === 'object' && 'kind' in next) return next;\n        const nextValue = normalizeValue(next as T);\n        current = nextValue.value;\n        if (nextValue.state) state = nextValue.state;\n        return { kind: 'changed', value: current } as const;\n      },\n    };\n  };\n  return defineIncrementalValue({ dependencies: dependencyMap, build: build as never });\n}\n\nfunction createIncrementalCollection<\n  const D extends readonly Projection<unknown, unknown>[],\n  K extends string,\n  V,\n>(dependencies: D, processor: IncrementalCollectionProcessor<D, K, V>): CollectionProjection<K, V> {\n  const dependencyMap = dependenciesOf(dependencies);\n  let state: IncrementalState = Object.create(null) as IncrementalState;\n  const build = (input: {\n    readonly sources: Record<string, unknown>;\n    readonly previous: CollectionRead<K, V>;\n    readonly next: CollectionRead<K, V>;\n    readonly writer: CollectionDraft<K, V>;\n  }) => {\n    state = Object.create(null) as IncrementalState;\n    const publicInputsForBuild = publicInputs(input.sources, true);\n    const result = processor({\n      sources: publicInputsForBuild.values as ProjectionValues<D>,\n      changes: publicInputsForBuild.changes as ProjectionChanges<D>,\n      previous: input.previous,\n      next: input.next,\n      reset: true,\n      cause: sourceCause(input.sources),\n      state,\n      output: input.writer,\n    });\n    if (result?.kind === 'rebuild')\n      throw new TypeError('Initial incremental collection processor cannot rebuild.');\n    return {\n      update: (nextInput: typeof input) => {\n        const publicInputsForUpdate = publicInputs(nextInput.sources);\n        return processor({\n          sources: publicInputsForUpdate.values as ProjectionValues<D>,\n          changes: publicInputsForUpdate.changes as ProjectionChanges<D>,\n          previous: nextInput.previous,\n          next: nextInput.next,\n          reset: false,\n          cause: sourceCause(nextInput.sources),\n          state,\n          output: nextInput.writer,\n        });\n      },\n    };\n  };\n  return defineIncrementalCollection({ dependencies: dependencyMap, build: build as never });\n}\n\nexport const incremental = Object.assign(createIncrementalValue, {\n  collection: createIncrementalCollection,\n});\n\nexport type IncrementalDependencies<D extends readonly Projection<unknown, unknown>[]> =\n  DependencyMap<D>;\n\nexport type { CollectionChange } from './contract';\n"],"mappings":"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"}

package/dist/advanced.d.cts

@@ -1,42 +1,42 @@
-import { i as PublicCollection, l as CollectionDraft, n as Projection, r as ProjectionValues, u as CollectionRead } from "./definition-DN6yW2vi.cjs";
+import { a as ProjectionValues, d as CollectionChange, f as CollectionDraft, i as ProjectionChanges, p as CollectionRead, r as Projection, t as CollectionProjection } from "./definition-C__VJqA4.cjs";
 
 //#region core/src/projection/advanced.d.ts
 type IncrementalState = Record<string, unknown>;
-type IncrementalValueContext<S, T> = {
-  readonly sources: S;
+type IncrementalValueContext<D extends readonly Projection<unknown, unknown>[], T> = {
+  readonly sources: ProjectionValues<D>;
+  readonly changes: ProjectionChanges<D>;
   readonly previous: T | undefined;
   readonly reset: boolean;
-  readonly change: unknown;
   readonly cause: unknown;
   readonly state: IncrementalState;
 };
-type IncrementalValueProcessor<S, T> = (context: IncrementalValueContext<S, T>) => T | {
+type IncrementalValueProcessor<D extends readonly Projection<unknown, unknown>[], T> = (context: IncrementalValueContext<D, T>) => T | {
   readonly kind: 'value';
   readonly value: T;
   readonly state?: IncrementalState;
 } | {
   readonly kind: 'rebuild';
 };
-type IncrementalCollectionContext<S, K extends string, V> = {
-  readonly sources: S;
+type IncrementalCollectionContext<D extends readonly Projection<unknown, unknown>[], K extends string, V> = {
+  readonly sources: ProjectionValues<D>;
+  readonly changes: ProjectionChanges<D>;
   readonly previous: CollectionRead<K, V>;
   readonly next: CollectionRead<K, V>;
-  readonly change: unknown;
   readonly reset: boolean;
   readonly cause: unknown;
   readonly state: IncrementalState;
   readonly output: CollectionDraft<K, V>;
 };
-type IncrementalCollectionProcessor<S, K extends string, V> = (context: IncrementalCollectionContext<S, K, V>) => void | {
+type IncrementalCollectionProcessor<D extends readonly Projection<unknown, unknown>[], K extends string, V> = (context: IncrementalCollectionContext<D, K, V>) => void | {
   readonly kind: 'rebuild';
 };
-type DependencyMap<D extends readonly Projection<unknown>[]> = { readonly [K in keyof D as `d${Extract<K, number>}`]: D[K] };
-declare function createIncrementalValue<const D extends readonly Projection<unknown>[], T>(dependencies: D, processor: IncrementalValueProcessor<ProjectionValues<D>, T>): Projection<T>;
-declare function createIncrementalCollection<const D extends readonly Projection<unknown>[], K extends string, V>(dependencies: D, processor: IncrementalCollectionProcessor<ProjectionValues<D>, K, V>): Projection<PublicCollection<K, V>>;
+type DependencyMap<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D as `d${Extract<K, number>}`]: D[K] };
+declare function createIncrementalValue<const D extends readonly Projection<unknown, unknown>[], T>(dependencies: D, processor: IncrementalValueProcessor<D, T>): Projection<T>;
+declare function createIncrementalCollection<const D extends readonly Projection<unknown, unknown>[], K extends string, V>(dependencies: D, processor: IncrementalCollectionProcessor<D, K, V>): CollectionProjection<K, V>;
 declare const incremental: typeof createIncrementalValue & {
   collection: typeof createIncrementalCollection;
 };
-type IncrementalDependencies<D extends readonly Projection<unknown>[]> = DependencyMap<D>;
+type IncrementalDependencies<D extends readonly Projection<unknown, unknown>[]> = DependencyMap<D>;
 //#endregion
-export { IncrementalCollectionContext, IncrementalCollectionProcessor, IncrementalDependencies, IncrementalState, IncrementalValueContext, IncrementalValueProcessor, incremental };
+export { type CollectionChange, IncrementalCollectionContext, IncrementalCollectionProcessor, IncrementalDependencies, IncrementalState, IncrementalValueContext, IncrementalValueProcessor, incremental };
 //# sourceMappingURL=advanced.d.cts.map

package/dist/advanced.d.ts

@@ -1,42 +1,42 @@
-import { i as PublicCollection, l as CollectionDraft, n as Projection, r as ProjectionValues, u as CollectionRead } from "./definition-B6J0SSNa.js";
+import { a as ProjectionValues, d as CollectionChange, f as CollectionDraft, i as ProjectionChanges, p as CollectionRead, r as Projection, t as CollectionProjection } from "./definition-Dc1Udkop.js";
 
 //#region core/src/projection/advanced.d.ts
 type IncrementalState = Record<string, unknown>;
-type IncrementalValueContext<S, T> = {
-  readonly sources: S;
+type IncrementalValueContext<D extends readonly Projection<unknown, unknown>[], T> = {
+  readonly sources: ProjectionValues<D>;
+  readonly changes: ProjectionChanges<D>;
   readonly previous: T | undefined;
   readonly reset: boolean;
-  readonly change: unknown;
   readonly cause: unknown;
   readonly state: IncrementalState;
 };
-type IncrementalValueProcessor<S, T> = (context: IncrementalValueContext<S, T>) => T | {
+type IncrementalValueProcessor<D extends readonly Projection<unknown, unknown>[], T> = (context: IncrementalValueContext<D, T>) => T | {
   readonly kind: 'value';
   readonly value: T;
   readonly state?: IncrementalState;
 } | {
   readonly kind: 'rebuild';
 };
-type IncrementalCollectionContext<S, K extends string, V> = {
-  readonly sources: S;
+type IncrementalCollectionContext<D extends readonly Projection<unknown, unknown>[], K extends string, V> = {
+  readonly sources: ProjectionValues<D>;
+  readonly changes: ProjectionChanges<D>;
   readonly previous: CollectionRead<K, V>;
   readonly next: CollectionRead<K, V>;
-  readonly change: unknown;
   readonly reset: boolean;
   readonly cause: unknown;
   readonly state: IncrementalState;
   readonly output: CollectionDraft<K, V>;
 };
-type IncrementalCollectionProcessor<S, K extends string, V> = (context: IncrementalCollectionContext<S, K, V>) => void | {
+type IncrementalCollectionProcessor<D extends readonly Projection<unknown, unknown>[], K extends string, V> = (context: IncrementalCollectionContext<D, K, V>) => void | {
   readonly kind: 'rebuild';
 };
-type DependencyMap<D extends readonly Projection<unknown>[]> = { readonly [K in keyof D as `d${Extract<K, number>}`]: D[K] };
-declare function createIncrementalValue<const D extends readonly Projection<unknown>[], T>(dependencies: D, processor: IncrementalValueProcessor<ProjectionValues<D>, T>): Projection<T>;
-declare function createIncrementalCollection<const D extends readonly Projection<unknown>[], K extends string, V>(dependencies: D, processor: IncrementalCollectionProcessor<ProjectionValues<D>, K, V>): Projection<PublicCollection<K, V>>;
+type DependencyMap<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D as `d${Extract<K, number>}`]: D[K] };
+declare function createIncrementalValue<const D extends readonly Projection<unknown, unknown>[], T>(dependencies: D, processor: IncrementalValueProcessor<D, T>): Projection<T>;
+declare function createIncrementalCollection<const D extends readonly Projection<unknown, unknown>[], K extends string, V>(dependencies: D, processor: IncrementalCollectionProcessor<D, K, V>): CollectionProjection<K, V>;
 declare const incremental: typeof createIncrementalValue & {
   collection: typeof createIncrementalCollection;
 };
-type IncrementalDependencies<D extends readonly Projection<unknown>[]> = DependencyMap<D>;
+type IncrementalDependencies<D extends readonly Projection<unknown, unknown>[]> = DependencyMap<D>;
 //#endregion
-export { IncrementalCollectionContext, IncrementalCollectionProcessor, IncrementalDependencies, IncrementalState, IncrementalValueContext, IncrementalValueProcessor, incremental };
+export { type CollectionChange, IncrementalCollectionContext, IncrementalCollectionProcessor, IncrementalDependencies, IncrementalState, IncrementalValueContext, IncrementalValueProcessor, incremental };
 //# sourceMappingURL=advanced.d.ts.map

package/dist/advanced.js

@@ -2,8 +2,39 @@ import { i as snapshot } from "./scope-d-L87NeC.js";
 import { n as defineIncrementalValue, t as defineIncrementalCollection } from "./definition-c6XQXzvK.js";
 //#region core/src/projection/advanced.ts
 const dependenciesOf = (dependencies) => Object.fromEntries(dependencies.map((dependency, index) => [`d${index}`, dependency]));
-const sourceChange = (sources) => {
-	for (const source of Object.values(sources)) if (source && typeof source === "object" && "change" in source && source.change !== void 0) return source.change;
+const resetCollectionChange = Object.freeze({ kind: "reset" });
+const isCollectionSource = (source) => Boolean(source && typeof source === "object" && "ids" in source && typeof source.ids === "function" && "previous" in source && "transitions" in source && typeof source.transitions === "function");
+const collectionChange = (source) => {
+	if (!isCollectionSource(source)) return void 0;
+	if (source.reset || source.change?.kind === "reset") return resetCollectionChange;
+	const impact = source.change;
+	if (!impact) return void 0;
+	const added = [];
+	const updated = [];
+	const removed = [];
+	for (const transition of source.transitions()) if (transition.kind === "added") added.push({
+		key: transition.key,
+		kind: transition.kind,
+		after: transition.after
+	});
+	else if (transition.kind === "updated") updated.push(transition);
+	else removed.push({
+		key: transition.key,
+		kind: transition.kind,
+		before: transition.before
+	});
+	const order = impact.orderChanged ? {
+		before: Object.freeze([...source.previous.ids()]),
+		after: Object.freeze([...source.ids()])
+	} : void 0;
+	if (!added.length && !updated.length && !removed.length && !order) return void 0;
+	return Object.freeze({
+		kind: "incremental",
+		added: Object.freeze(added),
+		updated: Object.freeze(updated),
+		removed: Object.freeze(removed),
+		...order ? { order: Object.freeze(order) } : {}
+	});
 };
 const sourceCause = (sources) => {
 	for (const source of Object.values(sources)) if (source && typeof source === "object" && "cause" in source && source.cause !== void 0) return source.cause;
@@ -28,7 +59,19 @@ const publicSource = (source) => {
 	}
 	return source;
 };
-const publicTuple = (sources) => Object.keys(sources).sort((left, right) => Number(left.slice(1)) - Number(right.slice(1))).map((key) => publicSource(sources[key]));
+const publicInputs = (sources, initial = false) => {
+	const values = [];
+	const changes = [];
+	for (const key of Object.keys(sources).sort((left, right) => Number(left.slice(1)) - Number(right.slice(1)))) {
+		const source = sources[key];
+		values.push(publicSource(source));
+		changes.push(initial && isCollectionSource(source) ? resetCollectionChange : collectionChange(source));
+	}
+	return {
+		values,
+		changes
+	};
+};
 const normalizeValue = (result) => result && typeof result === "object" && result.kind === "value" ? {
 	value: result.value,
 	state: result.state
@@ -39,11 +82,12 @@ function createIncrementalValue(dependencies, processor) {
 	let current;
 	const build = (sources) => {
 		state = Object.create(null);
+		const publicInputsForBuild = publicInputs(sources, true);
 		const result = processor({
-			sources: publicTuple(sources),
+			sources: publicInputsForBuild.values,
+			changes: publicInputsForBuild.changes,
 			previous: void 0,
 			reset: true,
-			change: void 0,
 			cause: sourceCause(sources),
 			state
 		});
@@ -54,11 +98,12 @@ function createIncrementalValue(dependencies, processor) {
 		return {
 			value: current,
 			update: (nextSources) => {
+				const publicInputsForUpdate = publicInputs(nextSources);
 				const next = processor({
-					sources: publicTuple(nextSources),
+					sources: publicInputsForUpdate.values,
+					changes: publicInputsForUpdate.changes,
 					previous: current,
 					reset: false,
-					change: sourceChange(nextSources),
 					cause: sourceCause(nextSources),
 					state
 				});
@@ -83,26 +128,30 @@ function createIncrementalCollection(dependencies, processor) {
 	let state = Object.create(null);
 	const build = (input) => {
 		state = Object.create(null);
+		const publicInputsForBuild = publicInputs(input.sources, true);
 		if (processor({
-			sources: publicTuple(input.sources),
+			sources: publicInputsForBuild.values,
+			changes: publicInputsForBuild.changes,
 			previous: input.previous,
 			next: input.next,
 			reset: true,
-			change: void 0,
 			cause: sourceCause(input.sources),
 			state,
 			output: input.writer
 		})?.kind === "rebuild") throw new TypeError("Initial incremental collection processor cannot rebuild.");
-		return { update: (nextInput) => processor({
-			sources: publicTuple(nextInput.sources),
-			previous: nextInput.previous,
-			next: nextInput.next,
-			reset: false,
-			change: sourceChange(nextInput.sources),
-			cause: sourceCause(nextInput.sources),
-			state,
-			output: nextInput.writer
-		}) };
+		return { update: (nextInput) => {
+			const publicInputsForUpdate = publicInputs(nextInput.sources);
+			return processor({
+				sources: publicInputsForUpdate.values,
+				changes: publicInputsForUpdate.changes,
+				previous: nextInput.previous,
+				next: nextInput.next,
+				reset: false,
+				cause: sourceCause(nextInput.sources),
+				state,
+				output: nextInput.writer
+			});
+		} };
 	};
 	return defineIncrementalCollection({
 		dependencies: dependencyMap,

package/dist/advanced.js.map

@@ -1 +1 @@
-{"version":3,"file":"advanced.js","names":[],"sources":["../core/src/projection/advanced.ts"],"sourcesContent":["import type { Projection, ProjectionValues, PublicCollection } from './definition';\nimport { defineIncrementalCollection, defineIncrementalValue } from './definition';\nimport type { CollectionDraft, CollectionRead, GraphSources } from './contract';\nimport { snapshot } from '../access/scope';\n\nexport type IncrementalState = Record<string, unknown>;\n\nexport type IncrementalValueContext<S, T> = {\n  readonly sources: S;\n  readonly previous: T | undefined;\n  readonly reset: boolean;\n  readonly change: unknown;\n  readonly cause: unknown;\n  readonly state: IncrementalState;\n};\n\nexport type IncrementalValueProcessor<S, T> = (\n  context: IncrementalValueContext<S, T>\n) =>\n  | T\n  | { readonly kind: 'value'; readonly value: T; readonly state?: IncrementalState }\n  | { readonly kind: 'rebuild' };\n\nexport type IncrementalCollectionContext<S, K extends string, V> = {\n  readonly sources: S;\n  readonly previous: CollectionRead<K, V>;\n  readonly next: CollectionRead<K, V>;\n  readonly change: unknown;\n  readonly reset: boolean;\n  readonly cause: unknown;\n  readonly state: IncrementalState;\n  readonly output: CollectionDraft<K, V>;\n};\n\nexport type IncrementalCollectionProcessor<S, K extends string, V> = (\n  context: IncrementalCollectionContext<S, K, V>\n) => void | { readonly kind: 'rebuild' };\n\ntype DependencyMap<D extends readonly Projection<unknown>[]> = {\n  readonly [K in keyof D as `d${Extract<K, number>}`]: D[K];\n};\n\nconst dependenciesOf = <D extends readonly Projection<unknown>[]>(dependencies: D): GraphSources =>\n  Object.fromEntries(\n    dependencies.map((dependency, index) => [`d${index}`, dependency])\n  ) as unknown as GraphSources;\n\nconst sourceChange = (sources: Record<string, unknown>): unknown => {\n  for (const source of Object.values(sources)) {\n    if (\n      source &&\n      typeof source === 'object' &&\n      'change' in source &&\n      (source as { readonly change?: unknown }).change !== undefined\n    )\n      return (source as { readonly change?: unknown }).change;\n  }\n  return undefined;\n};\n\nconst sourceCause = (sources: Record<string, unknown>): unknown => {\n  for (const source of Object.values(sources)) {\n    if (\n      source &&\n      typeof source === 'object' &&\n      'cause' in source &&\n      (source as { readonly cause?: unknown }).cause !== undefined\n    )\n      return (source as { readonly cause?: unknown }).cause;\n  }\n  return undefined;\n};\n\nconst publicSource = (source: unknown): unknown => {\n  if (!source || typeof source !== 'object') return source;\n  if ('value' in source) return (source as { readonly value: unknown }).value;\n  if ('read' in source) {\n    const read = (source as { readonly read: unknown }).read;\n    if (\n      read &&\n      typeof read === 'object' &&\n      'ids' in read &&\n      typeof (read as { ids?: unknown }).ids === 'function'\n    ) {\n      const result = new Map<string, unknown>();\n      for (const id of (read as CollectionRead<string, unknown>).ids())\n        result.set(id, (read as CollectionRead<string, unknown>).get(id));\n      return result;\n    }\n    return snapshot(read);\n  }\n  if ('ids' in source && typeof (source as { ids?: unknown }).ids === 'function') {\n    const result = new Map<string, unknown>();\n    const read = source as CollectionRead<string, unknown>;\n    for (const id of read.ids()) result.set(id, read.get(id));\n    return result;\n  }\n  return source;\n};\n\nconst publicTuple = (sources: Record<string, unknown>): readonly unknown[] =>\n  Object.keys(sources)\n    .sort((left, right) => Number(left.slice(1)) - Number(right.slice(1)))\n    .map(key => publicSource(sources[key]));\n\nconst normalizeValue = <T>(\n  result: T | { readonly kind: 'value'; readonly value: T; readonly state?: IncrementalState }\n): { value: T; state?: IncrementalState } =>\n  result && typeof result === 'object' && (result as { readonly kind?: unknown }).kind === 'value'\n    ? {\n        value: (result as { readonly value: T }).value,\n        state: (result as { readonly state?: IncrementalState }).state,\n      }\n    : { value: result as T };\n\nfunction createIncrementalValue<const D extends readonly Projection<unknown>[], T>(\n  dependencies: D,\n  processor: IncrementalValueProcessor<ProjectionValues<D>, T>\n): Projection<T> {\n  const dependencyMap = dependenciesOf(dependencies);\n  let state: IncrementalState = Object.create(null) as IncrementalState;\n  let current!: T;\n  const build = (sources: Record<string, unknown>) => {\n    state = Object.create(null) as IncrementalState;\n    const result = processor({\n      sources: publicTuple(sources) as ProjectionValues<D>,\n      previous: undefined,\n      reset: true,\n      change: undefined,\n      cause: sourceCause(sources),\n      state,\n    });\n    if (result && typeof result === 'object' && 'kind' in result)\n      throw new TypeError('Initial incremental processor cannot rebuild.');\n    const normalized = normalizeValue(result as T);\n    current = normalized.value;\n    if (normalized.state) state = normalized.state;\n    return {\n      value: current,\n      update: (nextSources: Record<string, unknown>) => {\n        const next = processor({\n          sources: publicTuple(nextSources) as ProjectionValues<D>,\n          previous: current,\n          reset: false,\n          change: sourceChange(nextSources),\n          cause: sourceCause(nextSources),\n          state,\n        });\n        if (next && typeof next === 'object' && 'kind' in next) return next;\n        const nextValue = normalizeValue(next as T);\n        current = nextValue.value;\n        if (nextValue.state) state = nextValue.state;\n        return { kind: 'changed', value: current } as const;\n      },\n    };\n  };\n  return defineIncrementalValue({ dependencies: dependencyMap, build: build as never });\n}\n\nfunction createIncrementalCollection<\n  const D extends readonly Projection<unknown>[],\n  K extends string,\n  V,\n>(\n  dependencies: D,\n  processor: IncrementalCollectionProcessor<ProjectionValues<D>, K, V>\n): Projection<PublicCollection<K, V>> {\n  const dependencyMap = dependenciesOf(dependencies);\n  let state: IncrementalState = Object.create(null) as IncrementalState;\n  const build = (input: {\n    readonly sources: Record<string, unknown>;\n    readonly previous: CollectionRead<K, V>;\n    readonly next: CollectionRead<K, V>;\n    readonly writer: CollectionDraft<K, V>;\n  }) => {\n    state = Object.create(null) as IncrementalState;\n    const result = processor({\n      sources: publicTuple(input.sources) as ProjectionValues<D>,\n      previous: input.previous,\n      next: input.next,\n      reset: true,\n      change: undefined,\n      cause: sourceCause(input.sources),\n      state,\n      output: input.writer,\n    });\n    if (result?.kind === 'rebuild')\n      throw new TypeError('Initial incremental collection processor cannot rebuild.');\n    return {\n      update: (nextInput: typeof input) =>\n        processor({\n          sources: publicTuple(nextInput.sources) as ProjectionValues<D>,\n          previous: nextInput.previous,\n          next: nextInput.next,\n          reset: false,\n          change: sourceChange(nextInput.sources),\n          cause: sourceCause(nextInput.sources),\n          state,\n          output: nextInput.writer,\n        }),\n    };\n  };\n  return defineIncrementalCollection({ dependencies: dependencyMap, build: build as never });\n}\n\nexport const incremental = Object.assign(createIncrementalValue, {\n  collection: createIncrementalCollection,\n});\n\nexport type IncrementalDependencies<D extends readonly Projection<unknown>[]> = DependencyMap<D>;\n"],"mappings":"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"}
+{"version":3,"file":"advanced.js","names":[],"sources":["../core/src/projection/advanced.ts"],"sourcesContent":["import type {\n  Projection,\n  CollectionProjection,\n  ProjectionChanges,\n  ProjectionValues,\n  PublicCollection,\n} from './definition';\nimport { defineIncrementalCollection, defineIncrementalValue } from './definition';\nimport type {\n  CollectionChange,\n  CollectionDraft,\n  CollectionEntryTransition,\n  CollectionRead,\n  GraphSources,\n} from './contract';\nimport { snapshot } from '../access/scope';\n\nexport type IncrementalState = Record<string, unknown>;\n\nexport type IncrementalValueContext<D extends readonly Projection<unknown, unknown>[], T> = {\n  readonly sources: ProjectionValues<D>;\n  readonly changes: ProjectionChanges<D>;\n  readonly previous: T | undefined;\n  readonly reset: boolean;\n  readonly cause: unknown;\n  readonly state: IncrementalState;\n};\n\nexport type IncrementalValueProcessor<D extends readonly Projection<unknown, unknown>[], T> = (\n  context: IncrementalValueContext<D, T>\n) =>\n  | T\n  | { readonly kind: 'value'; readonly value: T; readonly state?: IncrementalState }\n  | { readonly kind: 'rebuild' };\n\nexport type IncrementalCollectionContext<\n  D extends readonly Projection<unknown, unknown>[],\n  K extends string,\n  V,\n> = {\n  readonly sources: 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 state: IncrementalState;\n  readonly output: CollectionDraft<K, V>;\n};\n\nexport type IncrementalCollectionProcessor<\n  D extends readonly Projection<unknown, unknown>[],\n  K extends string,\n  V,\n> = (context: IncrementalCollectionContext<D, K, V>) => void | { readonly kind: 'rebuild' };\n\ntype DependencyMap<D extends readonly Projection<unknown, unknown>[]> = {\n  readonly [K in keyof D as `d${Extract<K, number>}`]: D[K];\n};\n\nconst dependenciesOf = <D extends readonly Projection<unknown, unknown>[]>(\n  dependencies: D\n): GraphSources =>\n  Object.fromEntries(\n    dependencies.map((dependency, index) => [`d${index}`, dependency])\n  ) as unknown as GraphSources;\n\ntype RuntimeCollectionSource = {\n  readonly ids: () => readonly string[];\n  readonly previous: CollectionRead<string, unknown>;\n  readonly reset: boolean;\n  readonly change?: { readonly kind: 'reset' | 'incremental'; readonly orderChanged?: boolean };\n  readonly transitions: () => readonly CollectionEntryTransition<string, unknown>[];\n};\nconst resetCollectionChange = Object.freeze({ kind: 'reset' as const });\ntype IncrementalCollectionChange = Extract<\n  CollectionChange<string, unknown>,\n  { readonly kind: 'incremental' }\n>;\n\nconst isCollectionSource = (source: unknown): source is RuntimeCollectionSource =>\n  Boolean(\n    source &&\n    typeof source === 'object' &&\n    'ids' in source &&\n    typeof (source as { readonly ids?: unknown }).ids === 'function' &&\n    'previous' in source &&\n    'transitions' in source &&\n    typeof (source as { readonly transitions?: unknown }).transitions === 'function'\n  );\n\nconst collectionChange = (source: unknown): CollectionChange<string, unknown> | undefined => {\n  if (!isCollectionSource(source)) return undefined;\n  if (source.reset || source.change?.kind === 'reset') return resetCollectionChange;\n  const impact = source.change;\n  if (!impact) return undefined;\n  const added: IncrementalCollectionChange['added'][number][] = [];\n  const updated: IncrementalCollectionChange['updated'][number][] = [];\n  const removed: IncrementalCollectionChange['removed'][number][] = [];\n  for (const transition of source.transitions()) {\n    if (transition.kind === 'added')\n      added.push({ key: transition.key, kind: transition.kind, after: transition.after });\n    else if (transition.kind === 'updated') updated.push(transition);\n    else removed.push({ key: transition.key, kind: transition.kind, before: transition.before });\n  }\n  const order = impact.orderChanged\n    ? {\n        before: Object.freeze([...source.previous.ids()]),\n        after: Object.freeze([...source.ids()]),\n      }\n    : undefined;\n  if (!added.length && !updated.length && !removed.length && !order) return undefined;\n  return Object.freeze({\n    kind: 'incremental' as const,\n    added: Object.freeze(added),\n    updated: Object.freeze(updated),\n    removed: Object.freeze(removed),\n    ...(order ? { order: Object.freeze(order) } : {}),\n  });\n};\n\nconst sourceCause = (sources: Record<string, unknown>): unknown => {\n  for (const source of Object.values(sources)) {\n    if (\n      source &&\n      typeof source === 'object' &&\n      'cause' in source &&\n      (source as { readonly cause?: unknown }).cause !== undefined\n    )\n      return (source as { readonly cause?: unknown }).cause;\n  }\n  return undefined;\n};\n\nconst publicSource = (source: unknown): unknown => {\n  if (!source || typeof source !== 'object') return source;\n  if ('value' in source) return (source as { readonly value: unknown }).value;\n  if ('read' in source) {\n    const read = (source as { readonly read: unknown }).read;\n    if (\n      read &&\n      typeof read === 'object' &&\n      'ids' in read &&\n      typeof (read as { ids?: unknown }).ids === 'function'\n    ) {\n      const result = new Map<string, unknown>();\n      for (const id of (read as CollectionRead<string, unknown>).ids())\n        result.set(id, (read as CollectionRead<string, unknown>).get(id));\n      return result;\n    }\n    return snapshot(read);\n  }\n  if ('ids' in source && typeof (source as { ids?: unknown }).ids === 'function') {\n    const result = new Map<string, unknown>();\n    const read = source as CollectionRead<string, unknown>;\n    for (const id of read.ids()) result.set(id, read.get(id));\n    return result;\n  }\n  return source;\n};\n\nconst publicInputs = (\n  sources: Record<string, unknown>,\n  initial = false\n): { readonly values: readonly unknown[]; readonly changes: readonly unknown[] } => {\n  const values: unknown[] = [];\n  const changes: unknown[] = [];\n  for (const key of Object.keys(sources).sort(\n    (left, right) => Number(left.slice(1)) - Number(right.slice(1))\n  )) {\n    const source = sources[key];\n    values.push(publicSource(source));\n    changes.push(\n      initial && isCollectionSource(source) ? resetCollectionChange : collectionChange(source)\n    );\n  }\n  return { values, changes };\n};\n\nconst normalizeValue = <T>(\n  result: T | { readonly kind: 'value'; readonly value: T; readonly state?: IncrementalState }\n): { value: T; state?: IncrementalState } =>\n  result && typeof result === 'object' && (result as { readonly kind?: unknown }).kind === 'value'\n    ? {\n        value: (result as { readonly value: T }).value,\n        state: (result as { readonly state?: IncrementalState }).state,\n      }\n    : { value: result as T };\n\nfunction createIncrementalValue<const D extends readonly Projection<unknown, unknown>[], T>(\n  dependencies: D,\n  processor: IncrementalValueProcessor<D, T>\n): Projection<T> {\n  const dependencyMap = dependenciesOf(dependencies);\n  let state: IncrementalState = Object.create(null) as IncrementalState;\n  let current!: T;\n  const build = (sources: Record<string, unknown>) => {\n    state = Object.create(null) as IncrementalState;\n    const publicInputsForBuild = publicInputs(sources, true);\n    const result = processor({\n      sources: publicInputsForBuild.values as ProjectionValues<D>,\n      changes: publicInputsForBuild.changes as ProjectionChanges<D>,\n      previous: undefined,\n      reset: true,\n      cause: sourceCause(sources),\n      state,\n    });\n    if (result && typeof result === 'object' && 'kind' in result)\n      throw new TypeError('Initial incremental processor cannot rebuild.');\n    const normalized = normalizeValue(result as T);\n    current = normalized.value;\n    if (normalized.state) state = normalized.state;\n    return {\n      value: current,\n      update: (nextSources: Record<string, unknown>) => {\n        const publicInputsForUpdate = publicInputs(nextSources);\n        const next = processor({\n          sources: publicInputsForUpdate.values as ProjectionValues<D>,\n          changes: publicInputsForUpdate.changes as ProjectionChanges<D>,\n          previous: current,\n          reset: false,\n          cause: sourceCause(nextSources),\n          state,\n        });\n        if (next && typeof next === 'object' && 'kind' in next) return next;\n        const nextValue = normalizeValue(next as T);\n        current = nextValue.value;\n        if (nextValue.state) state = nextValue.state;\n        return { kind: 'changed', value: current } as const;\n      },\n    };\n  };\n  return defineIncrementalValue({ dependencies: dependencyMap, build: build as never });\n}\n\nfunction createIncrementalCollection<\n  const D extends readonly Projection<unknown, unknown>[],\n  K extends string,\n  V,\n>(dependencies: D, processor: IncrementalCollectionProcessor<D, K, V>): CollectionProjection<K, V> {\n  const dependencyMap = dependenciesOf(dependencies);\n  let state: IncrementalState = Object.create(null) as IncrementalState;\n  const build = (input: {\n    readonly sources: Record<string, unknown>;\n    readonly previous: CollectionRead<K, V>;\n    readonly next: CollectionRead<K, V>;\n    readonly writer: CollectionDraft<K, V>;\n  }) => {\n    state = Object.create(null) as IncrementalState;\n    const publicInputsForBuild = publicInputs(input.sources, true);\n    const result = processor({\n      sources: publicInputsForBuild.values as ProjectionValues<D>,\n      changes: publicInputsForBuild.changes as ProjectionChanges<D>,\n      previous: input.previous,\n      next: input.next,\n      reset: true,\n      cause: sourceCause(input.sources),\n      state,\n      output: input.writer,\n    });\n    if (result?.kind === 'rebuild')\n      throw new TypeError('Initial incremental collection processor cannot rebuild.');\n    return {\n      update: (nextInput: typeof input) => {\n        const publicInputsForUpdate = publicInputs(nextInput.sources);\n        return processor({\n          sources: publicInputsForUpdate.values as ProjectionValues<D>,\n          changes: publicInputsForUpdate.changes as ProjectionChanges<D>,\n          previous: nextInput.previous,\n          next: nextInput.next,\n          reset: false,\n          cause: sourceCause(nextInput.sources),\n          state,\n          output: nextInput.writer,\n        });\n      },\n    };\n  };\n  return defineIncrementalCollection({ dependencies: dependencyMap, build: build as never });\n}\n\nexport const incremental = Object.assign(createIncrementalValue, {\n  collection: createIncrementalCollection,\n});\n\nexport type IncrementalDependencies<D extends readonly Projection<unknown, unknown>[]> =\n  DependencyMap<D>;\n\nexport type { CollectionChange } from './contract';\n"],"mappings":"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"}

package/dist/{definition-DN6yW2vi.d.cts → definition-C__VJqA4.d.cts}

@@ -6,6 +6,40 @@ type Cause = unknown;
 type BatchOptions = {
   readonly cause?: Cause;
 };
+type CollectionEntryTransition<K extends string, V> = {
+  readonly key: K;
+  readonly kind: 'added';
+  readonly before: undefined;
+  readonly after: V;
+} | {
+  readonly key: K;
+  readonly kind: 'updated';
+  readonly before: V;
+  readonly after: V;
+} | {
+  readonly key: K;
+  readonly kind: 'removed';
+  readonly before: V;
+  readonly after: undefined;
+};
+type CollectionChange<K extends string, V> = {
+  readonly kind: 'reset';
+} | {
+  readonly kind: 'incremental';
+  readonly added: readonly Omit<Extract<CollectionEntryTransition<K, V>, {
+    readonly kind: 'added';
+  }>, 'before'>[];
+  readonly updated: readonly Extract<CollectionEntryTransition<K, V>, {
+    readonly kind: 'updated';
+  }>[];
+  readonly removed: readonly Omit<Extract<CollectionEntryTransition<K, V>, {
+    readonly kind: 'removed';
+  }>, 'after'>[];
+  readonly order?: {
+    readonly before: readonly K[];
+    readonly after: readonly K[];
+  };
+};
 type CollectionRead<K extends string, V> = {
   get(key: K): V | undefined;
   has(key: K): boolean;
@@ -69,18 +103,21 @@ declare class ProjectionDisposedError extends Error {
 //#endregion
 //#region core/src/projection/definition.d.ts
 declare const projectionDefinition: unique symbol;
+declare const projectionChanges: unique symbol;
 declare const writableInput: unique symbol;
 /** A lazy, reusable projection definition. Its value is materialized per runtime. */
-type Projection<T> = {
+type Projection<T, C = undefined> = {
   readonly [projectionDefinition]: T;
+  readonly [projectionChanges]: C;
 };
 /** A runtime-local writable projection definition. */
 type Input<T> = Projection<T> & {
   readonly [writableInput]: true;
 };
-type ProjectionValues<D extends readonly Projection<unknown>[]> = { readonly [K in keyof D]: D[K] extends Projection<infer T> ? T : never };
+type ProjectionValues<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D]: D[K] extends Projection<infer T, unknown> ? T : never };
+type ProjectionChanges<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D]: D[K] extends Projection<unknown, infer C> ? [C] extends [undefined] ? undefined : C | undefined : undefined };
 type PublicCollection<K extends string, V> = ReadonlyMap<K, V>;
-type ObservedCollection<P extends CollectionPath> = PublicCollection<CollectionId<P>, ReadonlyValue<Infer<CollectionNode<P>>>>;
+type CollectionProjection<K extends string, V> = Projection<PublicCollection<K, V>, CollectionChange<K, V>>;
 declare const input: <T>(initial: T, equality?: (previous: T, next: T) => boolean) => Input<T>;
 /**
  * Establishes a reactive boundary from a document, readable, or external
@@ -89,11 +126,11 @@ declare const input: <T>(initial: T, equality?: (previous: T, next: T) => boolea
  */
 declare function observe<S extends ObjectNode>(document: DocumentReadable<S>): Projection<Infer<S>>;
 declare function observe<T, D>(source: ExternalValueSource<T, D>): Projection<T>;
-declare function observe<K extends string, V, D>(source: ExternalCollectionSource<K, V, D>): Projection<PublicCollection<K, V>>;
+declare function observe<K extends string, V, D>(source: ExternalCollectionSource<K, V, D>): CollectionProjection<K, V>;
 declare function observe<T>(readable: Readable<T>): Projection<T>;
-declare function observe<S extends ObjectNode, P extends CollectionPath>(document: DocumentReadable<S>, selector: (path: SchemaPath<S['shape']>) => P): Projection<ObservedCollection<P>>;
+declare function observe<S extends ObjectNode, P extends CollectionPath>(document: DocumentReadable<S>, selector: (path: SchemaPath<S['shape']>) => P): CollectionProjection<CollectionId<P>, ReadonlyValue<Infer<CollectionNode<P>>>>;
 declare function observe<S extends ObjectNode, P>(document: DocumentReadable<S>, selector: (path: SchemaPath<S['shape']>) => P): Projection<PathValueOf<P>>;
-declare function derive<const D extends readonly Projection<unknown>[], T>(dependencies: D, compute: (...values: ProjectionValues<D>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): Projection<T>;
+declare function derive<const D extends readonly Projection<unknown, unknown>[], T>(dependencies: D, compute: (...values: ProjectionValues<D>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): Projection<T>;
 //#endregion
-export { ProjectionError as _, derive as a, BatchOptions as c, ExternalCollectionEvent as d, ExternalCollectionRead as f, ProjectionDisposedError as g, ExternalValueSource as h, PublicCollection as i, CollectionDraft as l, ExternalValueEvent as m, Projection as n, input as o, ExternalCollectionSource as p, ProjectionValues as r, observe as s, Input as t, CollectionRead as u };
-//# sourceMappingURL=definition-DN6yW2vi.d.cts.map
+export { ExternalValueEvent as _, ProjectionValues as a, ProjectionError as b, input as c, CollectionChange as d, CollectionDraft as f, ExternalCollectionSource as g, ExternalCollectionRead as h, ProjectionChanges as i, observe as l, ExternalCollectionEvent as m, Input as n, PublicCollection as o, CollectionRead as p, Projection as r, derive as s, CollectionProjection as t, BatchOptions as u, ExternalValueSource as v, ProjectionDisposedError as y };
+//# sourceMappingURL=definition-C__VJqA4.d.cts.map