doxum 0.1.23 → 0.1.26

package/dist/advanced.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"advanced.cjs","names":["collectionView","isPlainObject","isProjection","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, isProjection, projectionRef } from './definition';\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 compileDependencies = <D extends ProjectionDependencies>(dependencies: D) => {\n  if (!isPlainObject(dependencies) || isProjection(dependencies))\n    throw new TypeError('Incremental dependencies must be a plain object.');\n  const names: string[] = [];\n  const projections: Projection<unknown>[] = [];\n  for (const key of Reflect.ownKeys(dependencies)) {\n    if (typeof key !== 'string')\n      throw new TypeError('Incremental dependency names must be strings.');\n    const descriptor = Object.getOwnPropertyDescriptor(dependencies, key);\n    if (!descriptor?.enumerable || !('value' in descriptor))\n      throw new TypeError('Incremental dependencies must be enumerable data properties.');\n    projectionRef(descriptor.value as Projection<unknown>);\n    names.push(key);\n    projections.push(descriptor.value as Projection<unknown>);\n  }\n  return Object.freeze({ names: Object.freeze(names), projections: Object.freeze(projections) });\n};\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 = compileDependencies(dependencies);\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 = compileDependencies(dependencies);\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 = compileDependencies(dependencies);\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 type { CollectionChange } from './contract';\n"],"mappings":"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"}

package/dist/advanced.d.cts

@@ -1,2 +1,90 @@
-import { a as IncrementalGroupDefine, c as IncrementalValueContext, g as CollectionChange, i as IncrementalGroupContext, l as IncrementalValueProcessor, n as IncrementalCollectionContext, o as IncrementalGroupOutputTree, r as IncrementalCollectionProcessor, s as IncrementalGroupProcessor, t as GroupProjections, u as incremental } from "./advanced-CLJCWkHa.cjs";
-export { CollectionChange, GroupProjections, IncrementalCollectionContext, IncrementalCollectionProcessor, IncrementalGroupContext, IncrementalGroupDefine, IncrementalGroupOutputTree, IncrementalGroupProcessor, IncrementalValueContext, IncrementalValueProcessor, incremental };
+import { a as Projection, c as CollectionDraft, i as KeyedProjection, l as CollectionRead, o as ProjectionChange, s as CollectionChange } from "./definition-CDOuvb5C.cjs";
+
+//#region core/src/projection/advanced.d.ts
+type ProjectionDependencies = Readonly<Record<string, Projection<unknown>>>;
+type ProjectionValues<D extends ProjectionDependencies> = { readonly [K in keyof D]: D[K] extends Projection<infer T> ? T : never };
+type ProjectionChanges<D extends ProjectionDependencies> = { readonly [K in keyof D]: ProjectionChange<D[K]> extends undefined ? undefined : ProjectionChange<D[K]> | undefined };
+type RetainedStateContext<State> = [State] extends [never] ? {} : {
+  readonly state: State;
+};
+type RetainedStateDefinition<State> = [State] extends [never] ? {
+  readonly state?: never;
+} : {
+  readonly state: () => State;
+};
+type IncrementalValueContext<D extends ProjectionDependencies, T, State = never> = {
+  readonly values: ProjectionValues<D>;
+  readonly changes: ProjectionChanges<D>;
+  readonly previous: T | undefined;
+  readonly reset: boolean;
+  readonly cause: unknown;
+} & RetainedStateContext<State>;
+type IncrementalValueDefinition<D extends ProjectionDependencies, T, State = never> = {
+  readonly process: (context: IncrementalValueContext<D, T, State>) => T;
+} & RetainedStateDefinition<State>;
+type IncrementalCollectionContext<D extends ProjectionDependencies, K extends string, V, State = never> = {
+  readonly values: ProjectionValues<D>;
+  readonly changes: ProjectionChanges<D>;
+  readonly previous: CollectionRead<K, V>;
+  readonly next: CollectionRead<K, V>;
+  readonly reset: boolean;
+  readonly cause: unknown;
+  readonly output: CollectionDraft<K, V>;
+} & RetainedStateContext<State>;
+type IncrementalCollectionDefinition<D extends ProjectionDependencies, K extends string, V, State = never> = {
+  readonly process: (context: IncrementalCollectionContext<D, K, V, State>) => void;
+} & RetainedStateDefinition<State>;
+declare const groupOutput: unique symbol;
+/** Type-only declaration token used by incremental.group output builders. */
+type IncrementalGroupOutput<P extends Projection<unknown>> = {
+  readonly [groupOutput]: P;
+};
+type GroupOutputShape = {
+  readonly [name: string]: IncrementalGroupOutput<Projection<unknown>> | GroupOutputShape;
+};
+type GroupOutputBuilder = {
+  collection<K extends string, V>(equality?: (previous: V, next: V) => boolean): IncrementalGroupOutput<KeyedProjection<K, V>>;
+  value<T>(equality?: (previous: T, next: T) => boolean): IncrementalGroupOutput<Projection<T>>;
+};
+/** Portable projection tree returned from an incremental.group declaration. */
+type IncrementalGroupResult<O> = O extends IncrementalGroupOutput<infer P> ? P : O extends Readonly<Record<string, unknown>> ? { readonly [K in keyof O]: IncrementalGroupResult<O[K]> } : never;
+type GroupReads<O> = O extends IncrementalGroupOutput<infer P> ? P extends KeyedProjection<infer K, infer V> ? CollectionRead<K, V> : P extends Projection<infer T> ? T | undefined : never : { readonly [K in keyof O]: GroupReads<O[K]> };
+type GroupDrafts<O> = O extends IncrementalGroupOutput<infer P> ? P extends KeyedProjection<infer K, infer V> ? CollectionDraft<K, V> : P extends Projection<infer T> ? {
+  set(value: T): void;
+} : never : { readonly [K in keyof O]: GroupDrafts<O[K]> };
+type IncrementalGroupContext<D extends ProjectionDependencies, O extends GroupOutputShape, State = never> = {
+  readonly values: ProjectionValues<D>;
+  readonly changes: ProjectionChanges<D>;
+  readonly previous: GroupReads<O>;
+  readonly next: GroupReads<O>;
+  readonly output: GroupDrafts<O>;
+  readonly reset: boolean;
+  readonly cause: unknown;
+} & RetainedStateContext<State>;
+type IncrementalGroupDefinition<D extends ProjectionDependencies, O extends GroupOutputShape, State = never> = {
+  readonly output: (define: GroupOutputBuilder) => O;
+  readonly process: (context: IncrementalGroupContext<D, O, State>) => void;
+} & RetainedStateDefinition<State>;
+declare function createIncrementalValue<const D extends ProjectionDependencies, T>(dependencies: D, definition: IncrementalValueDefinition<D, T>): Projection<T>;
+declare function createIncrementalValue<const D extends ProjectionDependencies, T, State>(dependencies: D, definition: {
+  readonly state: () => State;
+  readonly process: (context: IncrementalValueContext<D, T, State>) => T;
+}): Projection<T>;
+declare function createIncrementalCollection<const D extends ProjectionDependencies, K extends string, V>(dependencies: D, definition: IncrementalCollectionDefinition<D, K, V>): KeyedProjection<K, V>;
+declare function createIncrementalCollection<const D extends ProjectionDependencies, K extends string, V, State>(dependencies: D, definition: {
+  readonly state: () => State;
+  readonly process: (context: IncrementalCollectionContext<D, K, V, State>) => void;
+}): KeyedProjection<K, V>;
+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;
+  readonly state: () => State;
+  readonly process: (context: IncrementalGroupContext<D, O, State>) => void;
+}): IncrementalGroupResult<O>;
+declare const incremental: typeof createIncrementalValue & {
+  collection: typeof createIncrementalCollection;
+  group: typeof createIncrementalGroup;
+};
+//#endregion
+export { type CollectionChange, IncrementalCollectionContext, IncrementalCollectionDefinition, IncrementalGroupContext, IncrementalGroupOutput, IncrementalGroupResult, IncrementalValueContext, IncrementalValueDefinition, incremental };
+//# sourceMappingURL=advanced.d.cts.map

package/dist/advanced.d.ts

@@ -1,2 +1,90 @@
-import { a as IncrementalGroupDefine, c as IncrementalValueContext, g as CollectionChange, i as IncrementalGroupContext, l as IncrementalValueProcessor, n as IncrementalCollectionContext, o as IncrementalGroupOutputTree, r as IncrementalCollectionProcessor, s as IncrementalGroupProcessor, t as GroupProjections, u as incremental } from "./advanced-d6J61er9.js";
-export { CollectionChange, GroupProjections, IncrementalCollectionContext, IncrementalCollectionProcessor, IncrementalGroupContext, IncrementalGroupDefine, IncrementalGroupOutputTree, IncrementalGroupProcessor, IncrementalValueContext, IncrementalValueProcessor, incremental };
+import { a as Projection, c as CollectionDraft, i as KeyedProjection, l as CollectionRead, o as ProjectionChange, s as CollectionChange } from "./definition-xgk3YNBp.js";
+
+//#region core/src/projection/advanced.d.ts
+type ProjectionDependencies = Readonly<Record<string, Projection<unknown>>>;
+type ProjectionValues<D extends ProjectionDependencies> = { readonly [K in keyof D]: D[K] extends Projection<infer T> ? T : never };
+type ProjectionChanges<D extends ProjectionDependencies> = { readonly [K in keyof D]: ProjectionChange<D[K]> extends undefined ? undefined : ProjectionChange<D[K]> | undefined };
+type RetainedStateContext<State> = [State] extends [never] ? {} : {
+  readonly state: State;
+};
+type RetainedStateDefinition<State> = [State] extends [never] ? {
+  readonly state?: never;
+} : {
+  readonly state: () => State;
+};
+type IncrementalValueContext<D extends ProjectionDependencies, T, State = never> = {
+  readonly values: ProjectionValues<D>;
+  readonly changes: ProjectionChanges<D>;
+  readonly previous: T | undefined;
+  readonly reset: boolean;
+  readonly cause: unknown;
+} & RetainedStateContext<State>;
+type IncrementalValueDefinition<D extends ProjectionDependencies, T, State = never> = {
+  readonly process: (context: IncrementalValueContext<D, T, State>) => T;
+} & RetainedStateDefinition<State>;
+type IncrementalCollectionContext<D extends ProjectionDependencies, K extends string, V, State = never> = {
+  readonly values: ProjectionValues<D>;
+  readonly changes: ProjectionChanges<D>;
+  readonly previous: CollectionRead<K, V>;
+  readonly next: CollectionRead<K, V>;
+  readonly reset: boolean;
+  readonly cause: unknown;
+  readonly output: CollectionDraft<K, V>;
+} & RetainedStateContext<State>;
+type IncrementalCollectionDefinition<D extends ProjectionDependencies, K extends string, V, State = never> = {
+  readonly process: (context: IncrementalCollectionContext<D, K, V, State>) => void;
+} & RetainedStateDefinition<State>;
+declare const groupOutput: unique symbol;
+/** Type-only declaration token used by incremental.group output builders. */
+type IncrementalGroupOutput<P extends Projection<unknown>> = {
+  readonly [groupOutput]: P;
+};
+type GroupOutputShape = {
+  readonly [name: string]: IncrementalGroupOutput<Projection<unknown>> | GroupOutputShape;
+};
+type GroupOutputBuilder = {
+  collection<K extends string, V>(equality?: (previous: V, next: V) => boolean): IncrementalGroupOutput<KeyedProjection<K, V>>;
+  value<T>(equality?: (previous: T, next: T) => boolean): IncrementalGroupOutput<Projection<T>>;
+};
+/** Portable projection tree returned from an incremental.group declaration. */
+type IncrementalGroupResult<O> = O extends IncrementalGroupOutput<infer P> ? P : O extends Readonly<Record<string, unknown>> ? { readonly [K in keyof O]: IncrementalGroupResult<O[K]> } : never;
+type GroupReads<O> = O extends IncrementalGroupOutput<infer P> ? P extends KeyedProjection<infer K, infer V> ? CollectionRead<K, V> : P extends Projection<infer T> ? T | undefined : never : { readonly [K in keyof O]: GroupReads<O[K]> };
+type GroupDrafts<O> = O extends IncrementalGroupOutput<infer P> ? P extends KeyedProjection<infer K, infer V> ? CollectionDraft<K, V> : P extends Projection<infer T> ? {
+  set(value: T): void;
+} : never : { readonly [K in keyof O]: GroupDrafts<O[K]> };
+type IncrementalGroupContext<D extends ProjectionDependencies, O extends GroupOutputShape, State = never> = {
+  readonly values: ProjectionValues<D>;
+  readonly changes: ProjectionChanges<D>;
+  readonly previous: GroupReads<O>;
+  readonly next: GroupReads<O>;
+  readonly output: GroupDrafts<O>;
+  readonly reset: boolean;
+  readonly cause: unknown;
+} & RetainedStateContext<State>;
+type IncrementalGroupDefinition<D extends ProjectionDependencies, O extends GroupOutputShape, State = never> = {
+  readonly output: (define: GroupOutputBuilder) => O;
+  readonly process: (context: IncrementalGroupContext<D, O, State>) => void;
+} & RetainedStateDefinition<State>;
+declare function createIncrementalValue<const D extends ProjectionDependencies, T>(dependencies: D, definition: IncrementalValueDefinition<D, T>): Projection<T>;
+declare function createIncrementalValue<const D extends ProjectionDependencies, T, State>(dependencies: D, definition: {
+  readonly state: () => State;
+  readonly process: (context: IncrementalValueContext<D, T, State>) => T;
+}): Projection<T>;
+declare function createIncrementalCollection<const D extends ProjectionDependencies, K extends string, V>(dependencies: D, definition: IncrementalCollectionDefinition<D, K, V>): KeyedProjection<K, V>;
+declare function createIncrementalCollection<const D extends ProjectionDependencies, K extends string, V, State>(dependencies: D, definition: {
+  readonly state: () => State;
+  readonly process: (context: IncrementalCollectionContext<D, K, V, State>) => void;
+}): KeyedProjection<K, V>;
+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;
+  readonly state: () => State;
+  readonly process: (context: IncrementalGroupContext<D, O, State>) => void;
+}): IncrementalGroupResult<O>;
+declare const incremental: typeof createIncrementalValue & {
+  collection: typeof createIncrementalCollection;
+  group: typeof createIncrementalGroup;
+};
+//#endregion
+export { type CollectionChange, IncrementalCollectionContext, IncrementalCollectionDefinition, IncrementalGroupContext, IncrementalGroupOutput, IncrementalGroupResult, IncrementalValueContext, IncrementalValueDefinition, incremental };
+//# sourceMappingURL=advanced.d.ts.map

package/dist/advanced.js

@@ -1,2 +1,237 @@
-import { t as incremental } from "./advanced-CRNHfJBu.js";
+import { d as isProjection, l as defineProcessor, m as projectionRef, n as assertSynchronous, o as collectionView } from "./scheduler--137L3j-.js";
+import { n as isPlainObject } from "./record-B2yRhYsc.js";
+//#region core/src/projection/advanced.ts
+const resetCollectionChange = Object.freeze({ kind: "reset" });
+const publicValue = (source) => source.kind === "value" ? source.value : collectionView(source.read);
+const compileDependencies = (dependencies) => {
+	if (!isPlainObject(dependencies) || isProjection(dependencies)) throw new TypeError("Incremental dependencies must be a plain object.");
+	const names = [];
+	const projections = [];
+	for (const key of Reflect.ownKeys(dependencies)) {
+		if (typeof key !== "string") throw new TypeError("Incremental dependency names must be strings.");
+		const descriptor = Object.getOwnPropertyDescriptor(dependencies, key);
+		if (!descriptor?.enumerable || !("value" in descriptor)) throw new TypeError("Incremental dependencies must be enumerable data properties.");
+		projectionRef(descriptor.value);
+		names.push(key);
+		projections.push(descriptor.value);
+	}
+	return Object.freeze({
+		names: Object.freeze(names),
+		projections: Object.freeze(projections)
+	});
+};
+const publicInputs = (sources, names, reset) => {
+	const values = Object.create(null);
+	const changes = Object.create(null);
+	for (let index = 0; index < names.length; index++) {
+		const source = sources[index];
+		values[names[index]] = publicValue(source);
+		changes[names[index]] = source.kind === "collection" ? reset ? resetCollectionChange : source.change : void 0;
+	}
+	return Object.freeze({
+		values: Object.freeze(values),
+		changes: Object.freeze(changes)
+	});
+};
+function validateDefinition(definition, allowed, label) {
+	if (!isPlainObject(definition)) throw new TypeError(`${label} definition must be a plain object.`);
+	const allowedKeys = new Set(allowed);
+	for (const key of Reflect.ownKeys(definition)) {
+		if (typeof key !== "string" || !allowedKeys.has(key)) throw new TypeError(`${label} definition contains an unknown property.`);
+		const descriptor = Object.getOwnPropertyDescriptor(definition, key);
+		if (!descriptor?.enumerable || !("value" in descriptor)) throw new TypeError(`${label} definition must contain enumerable data properties.`);
+	}
+}
+const validateRetainedState = (definition, label) => {
+	if (Object.prototype.hasOwnProperty.call(definition, "state") && typeof definition.state !== "function") throw new TypeError(`${label} state must be a function when provided.`);
+};
+const initializeRetainedState = (definition) => {
+	if (definition.state === void 0) return Object.freeze({});
+	const state = definition.state();
+	assertSynchronous(state);
+	return Object.freeze({ state });
+};
+function createIncrementalValue(dependencies, definition) {
+	const compiled = compileDependencies(dependencies);
+	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] = defineProcessor({
+		dependencies: compiled.projections,
+		outputs: [{
+			kind: "value",
+			equality: Object.is
+		}],
+		create: () => {
+			const state = initializeRetainedState(definition);
+			return { evaluate: (evaluation) => {
+				const output = evaluation.outputs[0];
+				if (output.kind !== "value") throw new Error("Incremental value output is invalid.");
+				const publicInput = publicInputs(evaluation.sources, compiled.names, evaluation.reset);
+				const result = definition.process({
+					values: publicInput.values,
+					changes: publicInput.changes,
+					previous: output.previous,
+					reset: evaluation.reset,
+					cause: evaluation.cause,
+					...state
+				});
+				assertSynchronous(result);
+				output.output.set(result);
+			} };
+		}
+	});
+	return projection;
+}
+function createIncrementalCollection(dependencies, definition) {
+	const compiled = compileDependencies(dependencies);
+	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] = defineProcessor({
+		dependencies: compiled.projections,
+		outputs: [{
+			kind: "collection",
+			equality: Object.is
+		}],
+		create: () => {
+			const state = initializeRetainedState(definition);
+			return { evaluate: (evaluation) => {
+				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);
+				assertSynchronous(definition.process({
+					values: publicInput.values,
+					changes: publicInput.changes,
+					previous: output.previous,
+					next: output.next,
+					reset: evaluation.reset,
+					cause: evaluation.cause,
+					output: output.output,
+					...state
+				}));
+			} };
+		}
+	});
+	return projection;
+}
+const isPlainGroupNamespace = (value, metadata) => isPlainObject(value) && !metadata.has(value);
+const compileGroupShape = (value, path, metadata, used, outputs) => {
+	if (value !== null && typeof value === "object") {
+		const output = metadata.get(value);
+		if (output) {
+			if (used.has(value)) throw new TypeError("An incremental group output cannot be reused.");
+			used.add(value);
+			const index = outputs.length;
+			outputs.push({
+				kind: output.kind,
+				equality: output.equality,
+				path: Object.freeze([...path])
+			});
+			return index;
+		}
+	}
+	if (!isPlainGroupNamespace(value, metadata)) throw new TypeError("Incremental group outputs must be a static object tree.");
+	for (const key of Reflect.ownKeys(value)) {
+		if (typeof key !== "string") throw new TypeError("Incremental group output names must be strings.");
+		if (!Object.prototype.propertyIsEnumerable.call(value, key)) throw new TypeError("Incremental group namespaces must contain enumerable properties.");
+	}
+	const keys = Object.keys(value);
+	if (!keys.length) throw new TypeError("Incremental group namespaces cannot be empty.");
+	const result = Object.create(null);
+	for (const key of keys) {
+		if (key === "__proto__" || key === "prototype" || key === "constructor") throw new TypeError(`Invalid incremental group output name: ${key}`);
+		const descriptor = Object.getOwnPropertyDescriptor(value, key);
+		if (!descriptor || !("value" in descriptor)) throw new TypeError("Incremental group namespaces cannot contain accessors.");
+		result[key] = compileGroupShape(descriptor.value, [...path, key], metadata, used, outputs);
+	}
+	return Object.freeze(result);
+};
+const hydrateGroupShape = (shape, values) => {
+	if (typeof shape === "number") return values[shape];
+	const result = {};
+	for (const [key, child] of Object.entries(shape)) result[key] = hydrateGroupShape(child, values);
+	return Object.freeze(result);
+};
+const hydrateGroupReads = (shape, outputs, next) => {
+	if (typeof shape === "number") {
+		const output = outputs[shape];
+		return next && output.kind === "value" ? output.next() : next ? output.next : output.previous;
+	}
+	const result = {};
+	for (const [key, child] of Object.entries(shape)) if (typeof child === "number" && next && outputs[child].kind === "value") Object.defineProperty(result, key, {
+		enumerable: true,
+		configurable: false,
+		get: () => outputs[child].next()
+	});
+	else result[key] = hydrateGroupReads(child, outputs, next);
+	return Object.freeze(result);
+};
+function createIncrementalGroup(dependencies, definition) {
+	const compiled = compileDependencies(dependencies);
+	validateDefinition(definition, [
+		"output",
+		"state",
+		"process"
+	], "Incremental group");
+	validateRetainedState(definition, "Incremental group");
+	if (typeof definition.output !== "function" || typeof definition.process !== "function") throw new TypeError("Incremental group definition requires output and process functions.");
+	let active = true;
+	const metadata = /* @__PURE__ */ new Map();
+	const declared = definition.output({
+		collection: (equality = Object.is) => {
+			if (!active) throw new TypeError("Incremental group output declarations are synchronous.");
+			const descriptor = Object.freeze({});
+			metadata.set(descriptor, {
+				kind: "collection",
+				equality
+			});
+			return descriptor;
+		},
+		value: (equality = Object.is) => {
+			if (!active) throw new TypeError("Incremental group output declarations are synchronous.");
+			const descriptor = Object.freeze({});
+			metadata.set(descriptor, {
+				kind: "value",
+				equality
+			});
+			return descriptor;
+		}
+	});
+	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, defineProcessor({
+		dependencies: compiled.projections,
+		outputs,
+		create: () => {
+			const state = initializeRetainedState(definition);
+			return { evaluate: (evaluation) => {
+				const publicInput = publicInputs(evaluation.sources, compiled.names, evaluation.reset);
+				assertSynchronous(definition.process({
+					values: publicInput.values,
+					changes: publicInput.changes,
+					previous: hydrateGroupReads(shape, evaluation.outputs, false),
+					next: hydrateGroupReads(shape, evaluation.outputs, true),
+					output: hydrateGroupShape(shape, evaluation.outputs.map((output) => output.output)),
+					reset: evaluation.reset,
+					cause: evaluation.cause,
+					...state
+				}));
+			} };
+		},
+		name: `processor-group:${outputs.map((output) => output.path?.join(".") ?? "").join(",")}`
+	}));
+}
+const incremental = Object.assign(createIncrementalValue, {
+	collection: createIncrementalCollection,
+	group: createIncrementalGroup
+});
+//#endregion
 export { incremental };
+
+//# sourceMappingURL=advanced.js.map

package/dist/advanced.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"advanced.js","names":[],"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, isProjection, projectionRef } from './definition';\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 compileDependencies = <D extends ProjectionDependencies>(dependencies: D) => {\n  if (!isPlainObject(dependencies) || isProjection(dependencies))\n    throw new TypeError('Incremental dependencies must be a plain object.');\n  const names: string[] = [];\n  const projections: Projection<unknown>[] = [];\n  for (const key of Reflect.ownKeys(dependencies)) {\n    if (typeof key !== 'string')\n      throw new TypeError('Incremental dependency names must be strings.');\n    const descriptor = Object.getOwnPropertyDescriptor(dependencies, key);\n    if (!descriptor?.enumerable || !('value' in descriptor))\n      throw new TypeError('Incremental dependencies must be enumerable data properties.');\n    projectionRef(descriptor.value as Projection<unknown>);\n    names.push(key);\n    projections.push(descriptor.value as Projection<unknown>);\n  }\n  return Object.freeze({ names: Object.freeze(names), projections: Object.freeze(projections) });\n};\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 = compileDependencies(dependencies);\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 = compileDependencies(dependencies);\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 = compileDependencies(dependencies);\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 type { CollectionChange } from './contract';\n"],"mappings":"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"}