doxum 0.1.19 → 0.1.21

package/dist/advanced-BYZCjNWL.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"advanced-BYZCjNWL.js","names":[],"sources":["../core/src/projection/definition.ts","../core/src/projection/contract.ts","../core/src/projection/scheduler.ts","../core/src/projection/advanced.ts"],"sourcesContent":["import type { DocumentReadable, Synchronous } from '../runtime/contract';\nimport type {\n  CollectionId,\n  CollectionPath,\n  CollectionNode as SchemaCollectionNode,\n  Infer,\n  ObjectNode,\n  ReadonlyValue,\n  SchemaPath,\n  PathValueOf,\n} from '../schema';\nimport type { Readable } from './readable';\nimport type {\n  CollectionChange,\n  ExternalCollectionSource,\n  ExternalValueSource,\n  GraphSources,\n} from './contract';\n\ndeclare const projectionDefinition: unique symbol;\ndeclare const projectionChanges: unique symbol;\ndeclare const writableInput: unique symbol;\n\n/** A lazy definition with no materialized state; root definitions are reusable. */\nexport type Projection<T, C = undefined> = {\n  readonly [projectionDefinition]: T;\n  readonly [projectionChanges]: C;\n};\n\n/** A runtime-local writable projection definition. */\nexport type Input<T, C = undefined> = Projection<T, C> & { readonly [writableInput]: true };\n\ntype ProjectionValues<D extends readonly Projection<unknown, unknown>[]> = {\n  readonly [K in keyof D]: D[K] extends Projection<infer T, unknown> ? T : never;\n};\n\ntype Equality = (a: unknown, b: unknown) => boolean;\ntype PathSelector<S extends ObjectNode> = (path: SchemaPath<S['shape']>) => unknown;\n\nexport type IncrementalGroupDefinition = {\n  readonly dependencies: GraphSources;\n  readonly outputs: readonly {\n    readonly path: readonly string[];\n    readonly isEqual?: Equality;\n  }[];\n  readonly build: (...args: never[]) => unknown;\n  readonly projections: readonly Projection<\n    ReadonlyMap<string, unknown>,\n    CollectionChange<string, unknown>\n  >[];\n};\n\ntype Definition =\n  | { readonly kind: 'input'; readonly initial: unknown; readonly isEqual?: Equality }\n  | { readonly kind: 'collection-input'; readonly initial: ReadonlyMap<string, unknown> }\n  | { readonly kind: 'readable'; readonly readable: Readable<unknown>; readonly isEqual?: Equality }\n  | { readonly kind: 'source-value'; readonly source: ExternalValueSource<unknown> }\n  | {\n      readonly kind: 'source-collection';\n      readonly source: ExternalCollectionSource<string, unknown>;\n    }\n  | {\n      readonly kind: 'document';\n      readonly document: DocumentReadable<ObjectNode>;\n      readonly selector?: PathSelector<ObjectNode>;\n    }\n  | {\n      readonly kind: 'derive';\n      readonly dependencies: readonly Projection<unknown, unknown>[];\n      readonly compute: (...values: readonly unknown[]) => unknown;\n      readonly isEqual?: Equality;\n    }\n  | {\n      readonly kind: 'incremental-value';\n      readonly dependencies: GraphSources;\n      readonly build: (...args: never[]) => unknown;\n      readonly isEqual?: Equality;\n      readonly name?: string;\n    }\n  | {\n      readonly kind: 'incremental-collection';\n      readonly dependencies: GraphSources;\n      readonly build: (...args: never[]) => unknown;\n      readonly isEqual?: Equality;\n      readonly name?: string;\n    }\n  | {\n      readonly kind: 'incremental-group-output';\n      readonly group: IncrementalGroupDefinition;\n      readonly output: number;\n    };\n\ntype DefinitionProjection = Projection<unknown, unknown>;\nconst definitions = new WeakMap<object, Definition>();\nconst owners = new WeakMap<object, object>();\n\nconst define = <T, C = undefined>(definition: Definition): Projection<T, C> => {\n  const handle = Object.freeze({}) as Projection<T, C>;\n  definitions.set(handle, definition);\n  return handle;\n};\n\nexport const definitionOf = (projection: DefinitionProjection): Definition => {\n  const definition = definitions.get(projection);\n  if (!definition) throw new TypeError('Unknown projection definition.');\n  return definition;\n};\n\nexport const isProjection = (value: unknown): value is DefinitionProjection =>\n  value !== null && typeof value === 'object' && definitions.has(value);\n\nexport const ownerOf = (projection: DefinitionProjection): object | undefined =>\n  owners.get(projection);\n\nexport const ownDefinition = <T, C>(\n  projection: Projection<T, C>,\n  owner: object\n): Projection<T, C> => {\n  if (!definitions.has(projection) || owners.has(projection))\n    throw new TypeError('Projection definition already has an owner.');\n  owners.set(projection, owner);\n  return projection;\n};\n\nconst valueInput = <T>(\n  initial: T,\n  equality: (previous: T, next: T) => boolean = Object.is\n): Input<T> => define<T>({ kind: 'input', initial, isEqual: equality as Equality }) as Input<T>;\n\nconst collectionInput = <K extends string, V>(\n  initial: ReadonlyMap<K, V> = new Map<K, V>()\n): Input<ReadonlyMap<K, V>, CollectionChange<K, V>> => {\n  const entries = new Map<K, V>();\n  for (const [key, value] of initial) {\n    if (typeof key !== 'string') throw new TypeError('Projection keys must be strings.');\n    entries.set(key, value);\n  }\n  return define<ReadonlyMap<K, V>, CollectionChange<K, V>>({\n    kind: 'collection-input',\n    initial: entries,\n  }) as Input<ReadonlyMap<K, V>, CollectionChange<K, V>>;\n};\n\nexport const input = Object.assign(valueInput, { collection: collectionInput });\n\n/** Establish a lazy reactive boundary from a document, readable, or external source. */\nexport function observe<S extends ObjectNode>(document: DocumentReadable<S>): Projection<Infer<S>>;\nexport function observe<T>(source: ExternalValueSource<T>): Projection<T>;\nexport function observe<K extends string, V>(\n  source: ExternalCollectionSource<K, V>\n): Projection<ReadonlyMap<K, V>, CollectionChange<K, V>>;\nexport function observe<T>(readable: Readable<T>): Projection<T>;\nexport function observe<S extends ObjectNode, P extends CollectionPath>(\n  document: DocumentReadable<S>,\n  selector: (path: SchemaPath<S['shape']>) => P\n): Projection<\n  ReadonlyMap<CollectionId<P>, ReadonlyValue<Infer<SchemaCollectionNode<P>>>>,\n  CollectionChange<CollectionId<P>, ReadonlyValue<Infer<SchemaCollectionNode<P>>>>\n>;\nexport function observe<S extends ObjectNode, P>(\n  document: DocumentReadable<S>,\n  selector: (path: SchemaPath<S['shape']>) => P\n): Projection<PathValueOf<P>>;\nexport function observe<S extends ObjectNode>(\n  document:\n    | DocumentReadable<S>\n    | Readable<unknown>\n    | ExternalValueSource<unknown>\n    | ExternalCollectionSource<string, unknown>,\n  selector?: PathSelector<S>\n): Projection<unknown, unknown> {\n  if (isExternalSource(document))\n    return document.kind === 'collection'\n      ? defineExternalCollection(document)\n      : defineExternalValue(document);\n  if ('current' in document && typeof document.current === 'function')\n    return defineReadable(document as Readable<unknown>);\n  return define({\n    kind: 'document',\n    document: document as DocumentReadable<ObjectNode>,\n    selector: selector as PathSelector<ObjectNode> | undefined,\n  });\n}\n\nconst isExternalSource = (\n  source: unknown\n): source is ExternalValueSource<unknown> | ExternalCollectionSource<string, unknown> => {\n  if (!source || typeof source !== 'object') return false;\n  const candidate = source as {\n    readonly kind?: unknown;\n    readonly current?: unknown;\n    readonly revision?: unknown;\n    readonly subscribe?: unknown;\n  };\n  return (\n    (candidate.kind === 'value' || candidate.kind === 'collection') &&\n    typeof candidate.current === 'function' &&\n    typeof candidate.revision === 'function' &&\n    typeof candidate.subscribe === 'function'\n  );\n};\n\nexport function derive<const D extends readonly Projection<unknown, unknown>[], T>(\n  dependencies: D,\n  compute: (...values: ProjectionValues<D>) => Synchronous<T>,\n  equality: (previous: T, next: T) => boolean = Object.is\n): Projection<T> {\n  if (!Array.isArray(dependencies) || dependencies.some(value => !definitions.has(value)))\n    throw new TypeError('derive dependencies must be projections.');\n  const frozen = Object.freeze([...dependencies]) as readonly Projection<unknown, unknown>[];\n  return define<T>({\n    kind: 'derive',\n    dependencies: frozen,\n    compute: compute as (...values: readonly unknown[]) => unknown,\n    isEqual: equality as Equality,\n  });\n}\n\nexport const defineReadable = <T>(\n  readable: Readable<T>,\n  equality: (a: T, b: T) => boolean = Object.is\n): Projection<T> => define<T>({ kind: 'readable', readable, isEqual: equality as Equality });\n\nexport const defineExternalValue = <T>(source: ExternalValueSource<T>): Projection<T> =>\n  define<T>({ kind: 'source-value', source: source as ExternalValueSource<unknown> });\n\nexport const defineExternalCollection = <K extends string, V>(\n  source: ExternalCollectionSource<K, V>\n): Projection<ReadonlyMap<K, V>, CollectionChange<K, V>> =>\n  define<ReadonlyMap<K, V>, CollectionChange<K, V>>({\n    kind: 'source-collection',\n    source: source as unknown as ExternalCollectionSource<string, unknown>,\n  });\n\nexport const defineIncrementalValue = <T>(definition: {\n  readonly dependencies: GraphSources;\n  readonly build: (...args: never[]) => unknown;\n  readonly isEqual?: (a: T, b: T) => boolean;\n  readonly name?: string;\n}): Projection<T> =>\n  define<T>({\n    kind: 'incremental-value',\n    dependencies: definition.dependencies,\n    build: definition.build,\n    isEqual: definition.isEqual as Equality | undefined,\n    name: definition.name,\n  });\n\nexport const defineIncrementalCollection = <K extends string, V>(definition: {\n  readonly dependencies: GraphSources;\n  readonly build: (...args: never[]) => unknown;\n  readonly isEqual?: (a: V, b: V) => boolean;\n  readonly name?: string;\n}): Projection<ReadonlyMap<K, V>, CollectionChange<K, V>> =>\n  define<ReadonlyMap<K, V>, CollectionChange<K, V>>({\n    kind: 'incremental-collection',\n    dependencies: definition.dependencies,\n    build: definition.build,\n    isEqual: definition.isEqual as Equality | undefined,\n    name: definition.name,\n  });\n\nexport const defineIncrementalGroup = (definition: {\n  readonly dependencies: GraphSources;\n  readonly outputs: readonly {\n    readonly path: readonly string[];\n    readonly isEqual?: Equality;\n  }[];\n  readonly build: (...args: never[]) => unknown;\n}): IncrementalGroupDefinition => {\n  const group = {\n    dependencies: definition.dependencies,\n    outputs: Object.freeze(\n      definition.outputs.map(output =>\n        Object.freeze({ path: Object.freeze([...output.path]), isEqual: output.isEqual })\n      )\n    ),\n    build: definition.build,\n    projections: [] as Projection<\n      ReadonlyMap<string, unknown>,\n      CollectionChange<string, unknown>\n    >[],\n  };\n  const projections = group.outputs.map((_, output) =>\n    define<ReadonlyMap<string, unknown>, CollectionChange<string, unknown>>({\n      kind: 'incremental-group-output',\n      group,\n      output,\n    })\n  );\n  group.projections = Object.freeze(projections) as typeof group.projections;\n  return Object.freeze(group);\n};\n","import type { Read } from '../access/scope';\nimport type { CollectionImpact } from '../impact';\nimport type { DocumentReadable, Unsubscribe } from '../runtime/contract';\nimport type {\n  CollectionNode as SchemaCollectionNode,\n  CollectionId,\n  CollectionPath,\n  ObjectNode,\n  PathPick,\n  SchemaPath,\n} from '../schema';\nimport type { Readable } from './readable';\n\ndeclare const sourceContext: unique symbol;\nexport type GraphSource<T> = { readonly [sourceContext]: T };\nexport type GraphSources = Readonly<Record<string, GraphSource<unknown>>>;\nexport type InputHandles<S extends GraphSources> = {\n  readonly [K in keyof S]: S[K] extends GraphSource<infer T> ? T : never;\n};\n\n/** Scheduler-owned metadata for one Runtime batch. */\nexport type BatchContext = {\n  readonly id: number;\n  readonly cause?: unknown;\n};\n\n/** The one processor-facing collection transition protocol. */\nexport type CollectionChange<K extends string, V> =\n  | { readonly kind: 'reset' }\n  | {\n      readonly kind: 'incremental';\n      readonly added: readonly { readonly key: K; readonly after: V }[];\n      readonly updated: readonly {\n        readonly key: K;\n        readonly before: V;\n        readonly after: V;\n      }[];\n      readonly removed: readonly { readonly key: K; readonly before: V }[];\n      readonly order?: {\n        readonly before: readonly K[];\n        readonly after: readonly K[];\n      };\n    };\n\nexport type DocumentContext<S extends ObjectNode> = {\n  readonly kind: 'document';\n  readonly read: Read<S>;\n  readonly revision: number;\n  readonly reset: boolean;\n  readonly cause?: unknown;\n};\n\nexport type DocumentHandle<S extends ObjectNode> = GraphSource<DocumentContext<S>> & {\n  collection<P extends CollectionPath>(\n    pick: (path: SchemaPath<S['shape']>) => P\n  ): GraphSource<CollectionContext<CollectionId<P>, Read<SchemaCollectionNode<P>>>>;\n  targets(...targets: readonly [PathPick<S>, ...PathPick<S>[]]): GraphSource<DocumentContext<S>>;\n};\n\nexport type ValueContext<T> = {\n  readonly kind: 'value';\n  readonly value: T;\n  readonly revision: number;\n  readonly reset: boolean;\n  readonly cause?: unknown;\n};\n\nexport type InputHandle<T> = {\n  readonly source: GraphSource<ValueContext<T>>;\n  set(value: T): void;\n};\n\nexport type NodeUpdate<T> =\n  | { readonly kind: 'unchanged' }\n  | { readonly kind: 'changed'; readonly value: T }\n  | { readonly kind: 'rebuild' };\n\nexport type ValueNodeSpec<S extends GraphSources, T> = {\n  readonly name?: string;\n  readonly sources: S;\n  readonly build: (sources: InputHandles<S>) => {\n    readonly value: T;\n    readonly update: (sources: InputHandles<S>) => NodeUpdate<NoInfer<T>>;\n  };\n};\n\nexport type ValueNode<T> = Readable<T> & GraphSource<ValueContext<T>> & { readonly kind: 'value' };\n\nexport type CollectionRead<K extends string, V> = {\n  get(key: K): V | undefined;\n  has(key: K): boolean;\n  ids(): readonly K[];\n};\n\nexport type ExternalCollectionRead<K extends string, V> = {\n  readonly get: (key: K) => V | undefined;\n  readonly has: (key: K) => boolean;\n  readonly ids: () => readonly K[];\n};\n\nexport type CollectionContext<K extends string, V> = {\n  readonly kind: 'collection';\n  readonly read: CollectionRead<K, V>;\n  readonly change: CollectionChange<K, V> | undefined;\n  readonly revision: number;\n  readonly cause?: unknown;\n};\n\nexport type CollectionNode<K extends string, V> = GraphSource<CollectionContext<K, V>> & {\n  readonly kind: 'collection';\n  current(): CollectionRead<K, V>;\n  revision(): number;\n  subscribe(listener: (change: CollectionChange<K, V>) => void): Unsubscribe;\n};\n\nexport type ExternalValueSource<T> = {\n  readonly kind: 'value';\n  current(): T;\n  revision(): number;\n  subscribe(listener: (event: ExternalValueEvent<T>) => void): Unsubscribe;\n};\n\nexport type ExternalCollectionSource<K extends string, V> = {\n  readonly kind: 'collection';\n  current(): ExternalCollectionRead<K, V>;\n  revision(): number;\n  subscribe(listener: (event: ExternalCollectionEvent<K, V>) => void): Unsubscribe;\n};\n\nexport type ExternalValueEvent<T> = {\n  readonly value: T;\n  readonly revision: number;\n  readonly reset?: boolean;\n  readonly cause?: unknown;\n};\n\nexport type ExternalCollectionEvent<K extends string, V> = {\n  /** Stable read from the source before this event or external batch. */\n  readonly previous: ExternalCollectionRead<K, V>;\n  readonly revision: number;\n  /** Optional document-style hint; the adapter resolves the canonical change. */\n  readonly impact?: CollectionImpact<K>;\n  readonly cause?: unknown;\n};\n\nexport type CollectionDraft<K extends string, V> = {\n  set(key: K, value: V): void;\n  remove(key: K): void;\n  order(ids: readonly K[]): void;\n};\n\nexport type CollectionProcess<S extends GraphSources, K extends string, V> = {\n  readonly sources: InputHandles<S>;\n  readonly previous: CollectionRead<K, V>;\n  readonly next: CollectionRead<K, V>;\n  readonly output: CollectionDraft<K, V>;\n};\n\nexport type CollectionNodeSpec<S extends GraphSources, K extends string, V> = {\n  readonly name?: string;\n  readonly sources: S;\n  readonly isEqual?: (previous: V, next: V) => boolean;\n  readonly build: (input: CollectionProcess<S, K, V>) => {\n    readonly update: (input: CollectionProcess<S, K, V>) => void | { readonly kind: 'rebuild' };\n  };\n};\n\n/** Internal graph boundary for one atomic multi-output collection processor. */\nexport type CollectionGroupSpec = {\n  readonly sources: GraphSources;\n  readonly outputs: readonly {\n    readonly path: readonly string[];\n    readonly isEqual?: (previous: unknown, next: unknown) => boolean;\n  }[];\n  readonly build: (input: {\n    readonly sources: Record<string, unknown>;\n    readonly previous: readonly CollectionRead<string, unknown>[];\n    readonly next: readonly CollectionRead<string, unknown>[];\n    readonly outputs: readonly CollectionDraft<string, unknown>[];\n  }) => {\n    readonly update: (input: {\n      readonly sources: Record<string, unknown>;\n      readonly previous: readonly CollectionRead<string, unknown>[];\n      readonly next: readonly CollectionRead<string, unknown>[];\n      readonly outputs: readonly CollectionDraft<string, unknown>[];\n    }) => void | { readonly kind: 'rebuild' };\n  };\n};\n\nexport class ProjectionError extends Error {\n  constructor(\n    readonly phase: 'processor' | 'listener' | 'source' | 'blocked',\n    readonly identity: string,\n    readonly revisions: readonly number[],\n    cause: unknown\n  ) {\n    super(`Projection ${phase} failed: ${identity}`, { cause });\n    this.name = 'ProjectionError';\n  }\n}\n\nexport class ProjectionDisposedError extends Error {\n  constructor() {\n    super('Projection has been disposed.');\n    this.name = 'ProjectionDisposedError';\n  }\n}\n","import type { ObserverError } from '../runtime/contract';\nimport { ProjectionDisposedError, ProjectionError, type BatchContext } from './contract';\nimport { profile } from '../profile';\n\ntype BatchOptions = { readonly cause?: unknown };\n\nexport type SourceRecord = {\n  readonly consumers: Set<NodeRecord>;\n  context(active: () => boolean): unknown;\n  revision(): number;\n  reset(): boolean;\n  shouldSettle?(): boolean;\n  fault: ProjectionError | undefined;\n  disposed: boolean;\n  clear(): void;\n};\nexport type OutputRecord = SourceRecord & {\n  readonly owner: NodeRecord;\n  emit(call: (listener: () => void) => void): void;\n};\nexport type NodeRecord = SourceRecord & {\n  readonly owner: NodeRecord;\n  readonly order: number;\n  readonly name: string;\n  readonly sources: readonly SourceRecord[];\n  readonly outputs?: readonly OutputRecord[];\n  readonly changedOutputs?: () => readonly OutputRecord[];\n  evaluate(build: boolean): boolean;\n  publish(): void;\n  emit(call: (listener: () => void) => void): void;\n  release(): void;\n};\n\n// Sources and nodes share one registry. Public structural lookalikes are never accepted.\nexport const projectionHandles = new WeakSet<object>();\nexport const createScheduler = (onError: (error: ProjectionError) => void) => {\n  let disposed = false;\n  let depth = 0;\n  let batchSequence = 0;\n  let activeBatch: BatchContext | undefined;\n  let phase: 'idle' | 'compute' | 'notify' = 'idle';\n  let sequence = 0;\n  const records = new Map<object, SourceRecord>();\n  const nodes = new Set<NodeRecord>();\n  const pending = new Set<SourceRecord>();\n  const heap: NodeRecord[] = [];\n  const queued = new Set<NodeRecord>();\n  const completed: NodeRecord[] = [];\n  const emissions = new Set<OutputRecord>();\n  const errors: ProjectionError[] = [];\n  let reportingFailures: unknown[] = [];\n  const guards = new Set<(locked: boolean) => void>();\n  const cleanups = new Set<() => void>();\n  const assertActive = () => {\n    if (disposed) throw new ProjectionDisposedError();\n  };\n  const assertIdle = () => {\n    assertActive();\n    if (phase !== 'idle')\n      throw new Error('Projection cannot be re-entered during processing or notification.');\n  };\n  const lock = (value: boolean) => guards.forEach(guard => guard(value));\n  const enqueue = (node: NodeRecord) => {\n    if (node.disposed || queued.has(node)) return;\n    queued.add(node);\n    profile.projection('scheduledNodes');\n    let i = heap.length;\n    heap.push(node);\n    while (i > 0) {\n      const p = (i - 1) >> 1;\n      if (heap[p].order < node.order) break;\n      heap[i] = heap[p];\n      i = p;\n    }\n    heap[i] = node;\n  };\n  const pop = () => {\n    const first = heap[0];\n    const last = heap.pop()!;\n    if (heap.length) {\n      let i = 0;\n      while (i * 2 + 1 < heap.length) {\n        let c = i * 2 + 1;\n        if (c + 1 < heap.length && heap[c + 1].order < heap[c].order) c++;\n        if (last.order < heap[c].order) break;\n        heap[i] = heap[c];\n        i = c;\n      }\n      heap[i] = last;\n    }\n    return first;\n  };\n  const errorFor = (\n    node: NodeRecord,\n    cause: unknown,\n    kind: ProjectionError['phase'] = 'processor'\n  ) =>\n    new ProjectionError(\n      kind,\n      node.name,\n      node.sources.map(source => source.revision()),\n      cause\n    );\n  const capture = (source: SourceRecord) => {\n    if (disposed) return;\n    if (phase !== 'idle') {\n      source.fault = new ProjectionError(\n        'source',\n        'reentrant source',\n        [source.revision()],\n        new Error('Source changed while projection was running.')\n      );\n      errors.push(source.fault);\n      throw source.fault;\n    }\n    pending.add(source);\n    profile.projection('sourceEvents');\n    if (source.fault) errors.push(source.fault);\n  };\n  const settle = () => {\n    if (disposed || depth || phase !== 'idle') return;\n    phase = 'compute';\n    lock(true);\n    try {\n      pending.forEach(source => {\n        if (source.shouldSettle?.() ?? true) source.consumers.forEach(enqueue);\n      });\n      while (heap.length) {\n        const node = pop();\n        if (node.disposed) continue;\n        const wasFaulted = node.fault !== undefined;\n        profile.projection('processedNodes');\n        let changed = false;\n        const blocked = node.sources.find(source => source.fault || source.disposed);\n        if (blocked) {\n          node.fault = errorFor(node, blocked.fault ?? new ProjectionDisposedError(), 'blocked');\n        } else {\n          const build = wasFaulted || node.sources.some(source => source.reset());\n          try {\n            changed = node.evaluate(build);\n            const failure = node.sources.find(source => source.fault)?.fault;\n            if (failure) throw failure;\n            node.fault = undefined;\n          } catch (cause) {\n            const error = errorFor(node, cause);\n            node.fault = error;\n            if (!build) {\n              try {\n                changed = node.evaluate(true);\n                const failure = node.sources.find(source => source.fault)?.fault;\n                if (failure) throw failure;\n                node.fault = undefined;\n                errors.push(error);\n              } catch (cause) {\n                node.fault = errorFor(node, cause);\n                errors.push(node.fault);\n              }\n            } else errors.push(error);\n          }\n        }\n        completed.push(node);\n        const outputs = node.changedOutputs?.() ?? (changed ? [node as OutputRecord] : []);\n        const affected = node.fault\n          ? (node.outputs ?? [node as OutputRecord])\n          : outputs.length\n            ? outputs\n            : wasFaulted\n              ? (node.outputs ?? [node as OutputRecord])\n              : [];\n        if (affected.length) {\n          profile.projection('publishedNodes');\n          node.publish();\n          affected.forEach(output => {\n            emissions.add(output);\n            output.consumers.forEach(enqueue);\n          });\n        }\n      }\n    } finally {\n      lock(false);\n      phase = 'idle';\n    }\n  };\n  const flush = (): readonly ObserverError[] => {\n    if (disposed || depth) return [];\n    if (pending.size || completed.length) profile.projection('flushes');\n    phase = 'notify';\n    lock(true);\n    const reportFailures: unknown[] = [];\n    try {\n      emissions.forEach(output =>\n        output.emit(listener => {\n          try {\n            listener();\n          } catch (cause) {\n            errors.push(errorFor(output.owner, cause, 'listener'));\n          }\n        })\n      );\n      for (const error of errors.slice()) {\n        try {\n          onError(error);\n        } catch (cause) {\n          reportFailures.push(cause);\n        }\n      }\n      return Object.freeze([\n        ...errors.map(error =>\n          Object.freeze({\n            phase: error.phase === 'listener' ? ('listener' as const) : ('processor' as const),\n            error,\n          })\n        ),\n        ...reportFailures.map(error => Object.freeze({ phase: 'listener' as const, error })),\n      ]);\n    } finally {\n      pending.forEach(source => source.clear());\n      completed.forEach(node => node.clear());\n      pending.clear();\n      queued.clear();\n      completed.length = 0;\n      emissions.clear();\n      errors.length = 0;\n      reportingFailures = reportFailures;\n      lock(false);\n      phase = 'idle';\n    }\n  };\n  const run = () => {\n    settle();\n    const result = flush();\n    const failures = reportingFailures;\n    reportingFailures = [];\n    if (failures.length) throw new AggregateError(failures, 'Projection error reporter failed.');\n    return result;\n  };\n  const batch = <T>(optionsOrCallback: BatchOptions | (() => T), maybeCallback?: () => T): T => {\n    assertIdle();\n    const options = typeof optionsOrCallback === 'function' ? undefined : optionsOrCallback;\n    const callback = typeof optionsOrCallback === 'function' ? optionsOrCallback : maybeCallback;\n    if (!callback) throw new TypeError('Projection batch requires a callback.');\n    const outer = depth === 0;\n    if (outer)\n      activeBatch = Object.freeze({\n        id: ++batchSequence,\n        ...(options?.cause === undefined ? {} : { cause: options.cause }),\n      });\n    depth++;\n    let failed = false;\n    try {\n      const value = callback();\n      assertSynchronous(value);\n      return value;\n    } catch (error) {\n      failed = true;\n      throw error;\n    } finally {\n      depth--;\n      if (!depth) {\n        try {\n          if (failed) {\n            try {\n              run();\n            } catch {\n              /* The original application error retains priority. */\n            }\n          } else run();\n        } finally {\n          activeBatch = undefined;\n        }\n      }\n    }\n  };\n  return {\n    assertActive,\n    assertIdle,\n    capture,\n    settle,\n    flush,\n    run,\n    records,\n    guards,\n    cleanups,\n    get active() {\n      return !disposed;\n    },\n    register(handle: object, record: SourceRecord) {\n      assertIdle();\n      records.set(handle, record);\n      projectionHandles.add(handle);\n    },\n    unregisterSource(handle: object) {\n      const record = records.get(handle);\n      if (record) {\n        assertIdle();\n        if (record.consumers.size) throw new Error('Projection source is still used by a node.');\n        record.disposed = true;\n        pending.delete(record);\n        record.clear();\n        records.delete(handle);\n      }\n    },\n    releaseNode(handle: object) {\n      assertIdle();\n      const record = records.get(handle);\n      const node =\n        record && 'owner' in record\n          ? (record as SourceRecord & { readonly owner: NodeRecord }).owner\n          : (record as NodeRecord | undefined);\n      if (!node || !nodes.has(node)) throw new Error('Unknown projection node.');\n      if ((node.outputs ?? [node as OutputRecord]).some(output => output.consumers.size))\n        throw new Error('Projection node is still used by another node.');\n      node.disposed = true;\n      node.sources.forEach(source => source.consumers.delete(node));\n      node.release();\n      node.clear();\n      nodes.delete(node);\n      for (const [registered, value] of records)\n        if (value === node || ('owner' in value && value.owner === node))\n          records.delete(registered);\n      pending.delete(node);\n      queued.delete(node);\n      for (const output of node.outputs ?? [node as OutputRecord]) emissions.delete(output);\n    },\n    source(handle: object) {\n      assertActive();\n      const source = records.get(handle);\n      if (!source || source.disposed)\n        throw new Error('Unknown, disposed, or foreign projection source.');\n      return source;\n    },\n    addNode(node: NodeRecord) {\n      nodes.add(node);\n      node.sources.forEach(source => source.consumers.add(node));\n    },\n    order: () => sequence++,\n    initialize<T>(run: () => T): T {\n      assertIdle();\n      phase = 'compute';\n      lock(true);\n      try {\n        return run();\n      } finally {\n        lock(false);\n        phase = 'idle';\n      }\n    },\n    batch,\n    batchContext: () => activeBatch,\n    dispose() {\n      if (disposed) return;\n      assertIdle();\n      disposed = true;\n      const failures: unknown[] = [];\n      cleanups.forEach(cleanup => {\n        try {\n          cleanup();\n        } catch (error) {\n          failures.push(error);\n        }\n      });\n      cleanups.clear();\n      nodes.forEach(node => {\n        node.disposed = true;\n        node.release();\n        node.consumers.clear();\n      });\n      records.forEach(source => {\n        source.disposed = true;\n        source.consumers.clear();\n        source.clear();\n      });\n      nodes.clear();\n      records.clear();\n      pending.clear();\n      heap.length = 0;\n      completed.length = 0;\n      queued.clear();\n      emissions.clear();\n      guards.clear();\n      errors.length = 0;\n      reportingFailures = [];\n      if (failures.length) throw new AggregateError(failures, 'Projection cleanup failed.');\n    },\n  };\n};\nexport type Scheduler = ReturnType<typeof createScheduler>;\nexport const assertSynchronous = (value: unknown): void => {\n  if (\n    value != null &&\n    (typeof value === 'object' || typeof value === 'function') &&\n    'then' in value &&\n    typeof value.then === 'function'\n  )\n    throw new TypeError('Projection callbacks must be synchronous.');\n};\nexport const assertScope = (active: () => boolean) => {\n  if (!active()) throw new Error('Projection reader or writer is no longer active.');\n};\n","import type { Projection } from './definition';\nimport {\n  defineIncrementalCollection,\n  defineIncrementalGroup,\n  defineIncrementalValue,\n  definitionOf,\n} from './definition';\nimport type { CollectionChange, CollectionDraft, CollectionRead, GraphSources } from './contract';\nimport { snapshot } from '../access/scope';\nimport { assertSynchronous } from './scheduler';\n\ntype ProjectionValues<D extends readonly Projection<unknown, unknown>[]> = {\n  readonly [K in keyof D]: D[K] extends Projection<infer T, unknown> ? T : never;\n};\n\ntype ProjectionChanges<D extends readonly Projection<unknown, unknown>[]> = {\n  readonly [K in keyof D]: D[K] extends Projection<unknown, infer C>\n    ? [C] extends [undefined]\n      ? undefined\n      : C | undefined\n    : undefined;\n};\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: Record<string, unknown>;\n};\n\nexport type IncrementalValueProcessor<D extends readonly Projection<unknown, unknown>[], T> = (\n  context: IncrementalValueContext<D, T>\n) => T | { 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: Record<string, unknown>;\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\ndeclare const groupOutput: unique symbol;\n\ntype GroupOutput<K extends string, V> = {\n  readonly [groupOutput]: { readonly key: K; readonly value: V };\n};\n\ntype GroupOutputShape = {\n  readonly [name: string]: GroupOutput<string, unknown> | GroupOutputShape;\n};\n\nexport type IncrementalGroupOutputTree = GroupOutputShape;\n\ntype GroupOutputBuilder = {\n  collection<K extends string, V>(equality?: (previous: V, next: V) => boolean): GroupOutput<K, V>;\n};\n\nexport type IncrementalGroupDefine = GroupOutputBuilder;\n\nexport type GroupProjections<O> =\n  O extends GroupOutput<infer K, infer V>\n    ? Projection<ReadonlyMap<K, V>, CollectionChange<K, V>>\n    : { readonly [P in keyof O]: GroupProjections<O[P]> };\n\ntype GroupReads<O> =\n  O extends GroupOutput<infer K, infer V>\n    ? CollectionRead<K, V>\n    : { readonly [P in keyof O]: GroupReads<O[P]> };\n\ntype GroupDrafts<O> =\n  O extends GroupOutput<infer K, infer V>\n    ? CollectionDraft<K, V>\n    : { readonly [P in keyof O]: GroupDrafts<O[P]> };\n\nexport type IncrementalGroupContext<\n  D extends readonly Projection<unknown, unknown>[],\n  O extends GroupOutputShape,\n> = {\n  readonly sources: ProjectionValues<D>;\n  readonly changes: ProjectionChanges<D>;\n  readonly previous: GroupReads<O>;\n  readonly next: GroupReads<O>;\n  readonly outputs: GroupDrafts<O>;\n  readonly reset: boolean;\n  readonly cause: unknown;\n  readonly state: Record<string, unknown>;\n};\n\nexport type IncrementalGroupProcessor<\n  D extends readonly Projection<unknown, unknown>[],\n  O extends GroupOutputShape,\n> = (context: IncrementalGroupContext<D, O>) => void | { readonly kind: 'rebuild' };\n\nconst resetCollectionChange = Object.freeze({ kind: 'reset' as const });\n\nconst isRebuild = (value: unknown): value is { readonly kind: 'rebuild' } =>\n  value !== null &&\n  typeof value === 'object' &&\n  (value as { readonly kind?: unknown }).kind === 'rebuild';\n\nconst collectionChange = (source: unknown): CollectionChange<string, unknown> | undefined => {\n  if (!source || typeof source !== 'object' || !('kind' in source)) return undefined;\n  if (source.kind !== 'collection') return undefined;\n  return (source as { readonly change?: CollectionChange<string, unknown> }).change;\n};\n\nconst sourceCause = (sources: Record<string, unknown>): unknown => {\n  for (const source of Object.values(sources)) {\n    if (source && typeof source === 'object' && 'kind' in source) {\n      const cause = (source as { readonly cause?: unknown }).cause;\n      if (cause !== undefined) return cause;\n    }\n  }\n  return undefined;\n};\n\nconst collectionView = <K extends string, V>(read: CollectionRead<K, V>): ReadonlyMap<K, V> => {\n  const entries = function* (): IterableIterator<[K, V]> {\n    for (const key of read.ids()) yield [key, read.get(key) as V];\n  };\n  const values = function* (): IterableIterator<V> {\n    for (const key of read.ids()) yield read.get(key) as V;\n  };\n  const view: ReadonlyMap<K, V> = {\n    get: key => read.get(key),\n    has: key => read.has(key),\n    get size() {\n      return read.ids().length;\n    },\n    keys: () => read.ids()[Symbol.iterator](),\n    values,\n    entries,\n    forEach: (callback, thisArg) => {\n      for (const key of read.ids()) callback.call(thisArg, read.get(key) as V, key, view);\n    },\n    [Symbol.iterator]: entries,\n  };\n  return Object.freeze(view);\n};\n\nconst publicSource = (source: unknown): unknown => {\n  if (!source || typeof source !== 'object') return source;\n  if (!('kind' in source)) return source;\n  if (source.kind === 'value') return (source as unknown as { readonly value: unknown }).value;\n  if (source.kind === 'document')\n    return snapshot((source as unknown as { readonly read: unknown }).read as never);\n  if (source.kind === 'collection') {\n    const read = (source as unknown as { readonly read: CollectionRead<string, unknown> }).read;\n    return collectionView(read);\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 &&\n        source &&\n        typeof source === 'object' &&\n        'kind' in source &&\n        source.kind === 'collection'\n        ? resetCollectionChange\n        : collectionChange(source)\n    );\n  }\n  return { values, changes };\n};\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  const build = (sources: Record<string, unknown>) => {\n    const state: Record<string, unknown> = Object.create(null) as Record<string, unknown>;\n    let current!: T;\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 (isRebuild(result)) throw new TypeError('Initial incremental processor cannot rebuild.');\n    current = result as T;\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 (isRebuild(next)) return next;\n        current = next as T;\n        return { kind: 'changed', value: current } as const;\n      },\n    };\n  };\n  return defineIncrementalValue({ dependencies: dependencyMap, build: build as never });\n}\n\nfunction dependenciesOf<D extends readonly Projection<unknown, unknown>[]>(\n  dependencies: D\n): GraphSources {\n  if (!Array.isArray(dependencies))\n    throw new TypeError('Incremental dependencies must be projections.');\n  dependencies.forEach(dependency => definitionOf(dependency));\n  return Object.freeze(\n    Object.fromEntries(dependencies.map((dependency, index) => [`d${index}`, dependency]))\n  ) as unknown as GraphSources;\n}\n\nfunction createIncrementalCollection<\n  const D extends readonly Projection<unknown, unknown>[],\n  K extends string,\n  V,\n>(\n  dependencies: D,\n  processor: IncrementalCollectionProcessor<D, K, V>\n): Projection<ReadonlyMap<K, V>, CollectionChange<K, V>> {\n  const dependencyMap = dependenciesOf(dependencies);\n  const build = (input: {\n    readonly sources: Record<string, unknown>;\n    readonly previous: CollectionRead<K, V>;\n    readonly next: CollectionRead<K, V>;\n    readonly output: CollectionDraft<K, V>;\n  }) => {\n    const state: Record<string, unknown> = Object.create(null) as Record<string, unknown>;\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.output,\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.output,\n        });\n      },\n    };\n  };\n  return defineIncrementalCollection({ dependencies: dependencyMap, build: build as never });\n}\n\ntype GroupShape = number | { readonly [key: string]: GroupShape };\nconst groupOutputMetadata = new WeakMap<\n  object,\n  { readonly isEqual?: (a: unknown, b: unknown) => boolean }\n>();\n\nconst isPlainGroupNamespace = (value: unknown): value is Record<string, unknown> =>\n  value !== null &&\n  typeof value === 'object' &&\n  !groupOutputMetadata.has(value) &&\n  !Array.isArray(value) &&\n  (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);\n\nconst compileGroupShape = (\n  value: unknown,\n  path: readonly string[],\n  declaredOutputs: ReadonlySet<object>,\n  used: Set<object>,\n  outputs: {\n    readonly path: readonly string[];\n    readonly isEqual?: (a: unknown, b: unknown) => boolean;\n  }[]\n): GroupShape => {\n  if (value !== null && typeof value === 'object') {\n    const metadata = groupOutputMetadata.get(value);\n    if (metadata) {\n      if (!declaredOutputs.has(value))\n        throw new TypeError('Incremental group outputs must be declared by this group.');\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({ path: Object.freeze([...path]), isEqual: metadata.isEqual });\n      return index;\n    }\n  }\n  if (!isPlainGroupNamespace(value))\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(\n      descriptor.value,\n      [...path, key],\n      declaredOutputs,\n      used,\n      outputs\n    );\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\nfunction createIncrementalGroup<\n  const D extends readonly Projection<unknown, unknown>[],\n  const O extends GroupOutputShape,\n>(\n  dependencies: D,\n  defineOutputs: (define: GroupOutputBuilder) => O,\n  processor: IncrementalGroupProcessor<D, O>\n): GroupProjections<O> {\n  const dependencyMap = dependenciesOf(dependencies);\n  if (typeof defineOutputs !== 'function')\n    throw new TypeError('Incremental group outputs must be declared by a callback.');\n  if (typeof processor !== 'function')\n    throw new TypeError('Incremental group processor must be a function.');\n  let active = true;\n  const declaredOutputs = new Set<object>();\n  const defineOutput: GroupOutputBuilder = {\n    collection: <K extends string, V>(equality?: (previous: V, next: V) => boolean) => {\n      if (!active) throw new TypeError('Incremental group output declarations are synchronous.');\n      const descriptor = Object.freeze({});\n      groupOutputMetadata.set(descriptor, {\n        isEqual: equality as ((a: unknown, b: unknown) => boolean) | undefined,\n      });\n      declaredOutputs.add(descriptor);\n      return descriptor as GroupOutput<K, V>;\n    },\n  };\n  const declared = defineOutputs(defineOutput);\n  assertSynchronous(declared);\n  active = false;\n  const outputs: {\n    readonly path: readonly string[];\n    readonly isEqual?: (a: unknown, b: unknown) => boolean;\n  }[] = [];\n  const used = new Set<object>();\n  const shape = compileGroupShape(declared, [], declaredOutputs, 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 !== declaredOutputs.size)\n    throw new TypeError('Every incremental group output must be returned by the declaration.');\n  const stateFactory = () => Object.create(null) as Record<string, unknown>;\n  const build = (input: {\n    readonly sources: Record<string, unknown>;\n    readonly previous: readonly CollectionRead<string, unknown>[];\n    readonly next: readonly CollectionRead<string, unknown>[];\n    readonly outputs: readonly CollectionDraft<string, unknown>[];\n  }) => {\n    const state = stateFactory();\n    const run = (nextInput: typeof input, reset: boolean) => {\n      const publicInput = publicInputs(nextInput.sources, reset);\n      const result = processor({\n        sources: publicInput.values as ProjectionValues<D>,\n        changes: publicInput.changes as ProjectionChanges<D>,\n        previous: hydrateGroupShape(shape, nextInput.previous) as GroupReads<O>,\n        next: hydrateGroupShape(shape, nextInput.next) as GroupReads<O>,\n        outputs: hydrateGroupShape(shape, nextInput.outputs) as GroupDrafts<O>,\n        reset,\n        cause: sourceCause(nextInput.sources),\n        state,\n      });\n      assertSynchronous(result);\n      return result;\n    };\n    const result = run(input, true);\n    if (isRebuild(result))\n      throw new TypeError('Initial incremental group processor cannot rebuild.');\n    return {\n      update: (nextInput: typeof input) => {\n        const result = run(nextInput, false);\n        return isRebuild(result) ? result : undefined;\n      },\n    };\n  };\n  const group = defineIncrementalGroup({\n    dependencies: dependencyMap,\n    outputs,\n    build: build as never,\n  });\n  const materialized = hydrateGroupShape(shape, group.projections) as GroupProjections<O>;\n  return materialized;\n}\n\nexport const incremental = Object.assign(createIncrementalValue, {\n  collection: createIncrementalCollection,\n  group: createIncrementalGroup,\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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"}