doxum 0.1.21 → 0.1.22

package/dist/advanced-GKZ-CZ6a.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"advanced-GKZ-CZ6a.cjs","names":["checkKey","accessOf"],"sources":["../core/src/schema.ts","../core/src/projection/contract.ts","../core/src/projection/scheduler.ts","../core/src/projection/collection-output.ts","../core/src/projection/definition.ts","../core/src/projection/advanced.ts"],"sourcesContent":["import type { Validator } from './schema-value';\nimport { checkKey } from './schema-value';\nexport type DocumentAddress = readonly string[];\n\n/** Shared payloads are immutable through every alias, including builtin methods. */\nexport type ReadonlyValue<T> = T extends (...args: never[]) => unknown\n  ? T\n  : T extends ReadonlyMap<infer K, infer V>\n    ? ReadonlyMap<ReadonlyValue<K>, ReadonlyValue<V>>\n    : T extends ReadonlySet<infer V>\n      ? ReadonlySet<ReadonlyValue<V>>\n      : T extends Date\n        ? Omit<Date, `set${string}`>\n        : T extends object\n          ? { readonly [K in keyof T]: ReadonlyValue<T[K]> }\n          : T;\n\nexport type DocumentListConfig<TItem> = {\n  readonly keyOf: (item: ReadonlyValue<TItem>) => string;\n};\nexport type DocumentTreeNode<TValue, ValueOptional extends boolean = false> = {\n  readonly parentId?: string;\n  readonly children: readonly string[];\n} & (ValueOptional extends true\n  ? { readonly value?: ReadonlyValue<TValue> }\n  : { readonly value: ReadonlyValue<TValue> });\nexport type DocumentTreeValue<TValue, ValueOptional extends boolean = false> = {\n  readonly rootId?: string;\n  readonly nodes: Readonly<Record<string, DocumentTreeNode<TValue, ValueOptional>>>;\n};\n\ntype BaseNode<K extends string> = {\n  readonly kind: K;\n  readonly optional?: boolean;\n};\nexport type FieldNode<T, Optional extends boolean = false> = BaseNode<'field'> & {\n  readonly __value?: T;\n  readonly validator?: Validator<T>;\n} & (Optional extends true ? { readonly optional: true } : { readonly optional?: false });\n/** A node with optional presence. The marker replaces, rather than intersects, a field marker. */\nexport type OptionalNode<TNode extends DocumentNode> =\n  TNode extends FieldNode<infer TValue, boolean>\n    ? FieldNode<TValue, true>\n    : TNode & { readonly optional: true };\nexport interface ObjectShape {\n  readonly [key: string]: DocumentNode;\n}\nexport type ObjectNode<TShape extends ObjectShape = ObjectShape> = BaseNode<'object'> & {\n  readonly shape: TShape;\n};\nexport interface VariantShape {\n  readonly [key: string]: ObjectNode<ObjectShape>;\n}\nexport type VariantNode<\n  TTag extends string,\n  TVariants extends VariantShape,\n> = BaseNode<'variant'> & {\n  readonly tag: TTag;\n  readonly variants: TVariants;\n};\nexport type TableNode<\n  TValue extends ObjectNode<ObjectShape> | VariantNode<string, VariantShape>,\n  TKey extends string = string,\n> = BaseNode<'table'> & {\n  readonly value: TValue;\n  readonly key?: Validator<TKey>;\n};\nexport type MapNode<\n  TValue extends ValueSchemaNode,\n  TKey extends string = string,\n> = BaseNode<'map'> & {\n  readonly value: TValue;\n  readonly key?: Validator<TKey>;\n};\nexport type ListNode<TItem> = BaseNode<'list'> & {\n  readonly value: FieldNode<TItem, false>;\n  keyOf(item: ReadonlyValue<TItem>): string;\n};\nexport type TreeNode<TValue, ValueOptional extends boolean = false> = BaseNode<'tree'> & {\n  readonly value: FieldNode<TValue, ValueOptional>;\n};\n\nexport type DocumentNode =\n  | FieldNode<unknown, false>\n  | FieldNode<unknown, true>\n  | ObjectNode<ObjectShape>\n  | VariantNode<string, VariantShape>\n  | TableNode<ObjectNode<ObjectShape> | VariantNode<string, VariantShape>>\n  | MapNode<ValueSchemaNode>\n  | ListNode<unknown>\n  | TreeNode<unknown, false>\n  | TreeNode<unknown, true>;\n\n// Flatten only schema-generated objects; user-supplied field values stay opaque.\ntype SchemaObject<T> = { [K in keyof T]: T[K] } & {};\n\n/** Infer a document or node value, including optional node presence. */\nexport type Infer<T extends DocumentNode> = T extends { readonly optional: true }\n  ? NodeValue<T> | undefined\n  : NodeValue<T>;\n\ntype NodeValue<N> =\n  N extends FieldNode<infer T, infer O>\n    ? O extends true\n      ? ReadonlyValue<T> | undefined\n      : ReadonlyValue<T>\n    : N extends ObjectNode<infer S>\n      ? ShapeValue<S>\n      : N extends VariantNode<infer T, infer V>\n        ? {\n            [K in keyof V & string]: SchemaObject<{ readonly [P in T]: K } & NodeValue<V[K]>>;\n          }[keyof V & string]\n        : N extends TableNode<infer V, infer K>\n          ? {\n              readonly ids: readonly K[];\n              readonly byId: Readonly<Record<K, NodeValue<V>>>;\n            }\n          : N extends MapNode<infer V, infer K>\n            ? Readonly<Record<K, NodeValue<V>>>\n            : N extends ListNode<infer I>\n              ? readonly ReadonlyValue<I>[]\n              : N extends TreeNode<infer T, infer O>\n                ? DocumentTreeValue<T, O>\n                : never;\n\ntype OptionalKeys<S extends ObjectShape> = {\n  [K in keyof S]: S[K] extends { readonly optional: true } ? K : never;\n}[keyof S];\ntype RequiredKeys<S extends ObjectShape> = Exclude<keyof S, OptionalKeys<S>>;\ntype ShapeValue<S extends ObjectShape> = SchemaObject<\n  { readonly [K in RequiredKeys<S>]: NodeValue<S[K]> } & {\n    readonly [K in OptionalKeys<S>]?: NodeValue<S[K]>;\n  }\n>;\n\nexport type EntitySchemaNode = ObjectNode<ObjectShape> | VariantNode<string, VariantShape>;\nexport type ValueSchemaNode = EntitySchemaNode | FieldNode<unknown, boolean>;\nexport type DocumentAnchor<K extends string = string> =\n  { readonly at: 'start' | 'end' } | { readonly before: K } | { readonly after: K };\n\nexport type TreeTarget =\n  | { readonly kind: 'root' }\n  | { readonly kind: 'nodes' }\n  | { readonly kind: 'node'; readonly id: string };\ntype TreeValueTarget = Exclude<TreeTarget, { readonly kind: 'nodes' }>;\ntype TreeCollectionTarget = Extract<TreeTarget, { readonly kind: 'nodes' }>;\n\nexport type CollectionSelector<TId extends string = string> = {\n  readonly kind: 'collection';\n  readonly schema: ObjectNode;\n  readonly address: DocumentAddress;\n  readonly tree?: TreeCollectionTarget;\n  readonly __id?: TId;\n};\nexport type ValueSelector<TResult = unknown> = {\n  readonly kind: 'value';\n  readonly schema: ObjectNode;\n  readonly address: DocumentAddress;\n  readonly tree?: TreeValueTarget;\n  readonly __value?: TResult;\n};\nexport type ImpactTarget<T = unknown> =\n  | { readonly kind: 'value'; readonly at: DocumentAddress; readonly tree?: TreeValueTarget }\n  | ValueSelector<T>\n  | {\n      readonly kind: 'collection';\n      readonly at: DocumentAddress;\n      readonly id?: string;\n    }\n  | CollectionSelector<string>;\ndeclare const pathValue: unique symbol;\ndeclare const collectionEntry: unique symbol;\ndeclare const collectionKey: unique symbol;\ntype PathMarker<TValue> = { readonly [pathValue]: TValue };\nexport type PathValueOf<T> = T extends { readonly [pathValue]: infer TValue } ? TValue : never;\n\ntype Or<A extends boolean, B extends boolean> = A extends true ? true : B;\ntype NodeAbsent<N extends DocumentNode, ParentAbsent extends boolean> = Or<\n  ParentAbsent,\n  N extends { readonly optional: true } ? true : false\n>;\ntype PathResult<N extends DocumentNode, ParentAbsent extends boolean> =\n  Infer<N> | (ParentAbsent extends true ? undefined : never);\n\ntype SchemaPathFor<\n  S extends ObjectShape = ObjectShape,\n  TValue = unknown,\n  Absent extends boolean = false,\n> = {\n  readonly [K in keyof S]: PathValue<S[K], Absent>;\n} & PathMarker<TValue | (Absent extends true ? undefined : never)>;\n\nexport type SchemaPath<S extends ObjectShape = ObjectShape> = SchemaPathFor<S, ShapeValue<S>>;\nexport type PathPick<S extends ObjectNode = ObjectNode> = (\n  path: SchemaPath<S['shape']>\n) => PathMarker<unknown>;\n\ntype VariantKeys<V extends VariantShape> = {\n  [K in keyof V & string]: keyof (V[K] extends ObjectNode<infer S> ? S : {});\n}[keyof V & string] &\n  string;\ntype VariantFieldMissing<V extends VariantShape, K extends string> = {\n  [P in keyof V & string]: V[P] extends ObjectNode<infer S> ? (K extends keyof S ? never : P) : P;\n}[keyof V & string] extends never\n  ? false\n  : true;\ntype VariantFieldPath<V extends VariantShape, K extends string, Absent extends boolean> = {\n  [P in keyof V & string]: V[P] extends ObjectNode<infer S>\n    ? K extends keyof S\n      ? PathValue<S[K], Or<Absent, VariantFieldMissing<V, K>>>\n      : never\n    : never;\n}[keyof V & string];\ntype VariantPath<T extends string, V extends VariantShape, TValue, Absent extends boolean> = {\n  readonly [K in VariantKeys<V>]: VariantFieldPath<V, K, Absent>;\n} & {\n  readonly [K in T]: PathMarker<(keyof V & string) | (Absent extends true ? undefined : never)>;\n} & PathMarker<TValue>;\nexport type CollectionPath<\n  K extends string = string,\n  TValue = unknown,\n  TEntry = unknown,\n  TItem = PathMarker<TEntry | undefined>,\n> = PathMarker<TValue> & {\n  item(id: K): TItem;\n  readonly [collectionEntry]: TEntry;\n  readonly [collectionKey]: K;\n};\ntype TreeNodesPath<TValue, ValueOptional extends boolean> = CollectionPath<\n  string,\n  Readonly<Record<string, DocumentTreeNode<TValue, ValueOptional>>>,\n  DocumentTreeNode<TValue, ValueOptional>,\n  PathMarker<DocumentTreeNode<TValue, ValueOptional> | undefined>\n>;\ntype TreePath<TValue, ValueOptional extends boolean, TValueResult> = PathMarker<TValueResult> & {\n  readonly rootId: PathMarker<string | undefined>;\n  readonly nodes: TreeNodesPath<TValue, ValueOptional>;\n};\n\ntype PathValue<N extends DocumentNode, ParentAbsent extends boolean = false> =\n  N extends ObjectNode<infer S>\n    ? SchemaPathFor<S, PathResult<N, ParentAbsent>, NodeAbsent<N, ParentAbsent>>\n    : N extends VariantNode<infer TTag, infer V>\n      ? VariantPath<TTag, V, PathResult<N, ParentAbsent>, NodeAbsent<N, ParentAbsent>>\n      : N extends TableNode<infer V, infer K>\n        ? CollectionPath<K, PathResult<N, ParentAbsent>, Infer<V>, PathValue<V, true>>\n        : N extends MapNode<infer V, infer K>\n          ? CollectionPath<K, PathResult<N, ParentAbsent>, Infer<V>, PathValue<V, true>>\n          : N extends ListNode<infer I>\n            ? CollectionPath<\n                string,\n                PathResult<N, ParentAbsent>,\n                ReadonlyValue<I>,\n                PathMarker<ReadonlyValue<I> | undefined>\n              >\n            : N extends TreeNode<infer T, infer O>\n              ? TreePath<T, O, PathResult<N, ParentAbsent>>\n              : PathMarker<PathResult<N, ParentAbsent>>;\ntype CollectionInfo<T> = T extends {\n  readonly [collectionEntry]: infer TEntry;\n  readonly [collectionKey]: infer K extends string;\n}\n  ? { readonly id: K; readonly entry: TEntry }\n  : never;\nexport type CollectionId<T> =\n  CollectionInfo<T> extends { readonly id: infer TId extends string } ? TId : string;\nexport type CollectionEntry<T> =\n  CollectionInfo<T> extends { readonly entry: infer TEntry } ? TEntry : unknown;\n\nexport const collectionEntryNode = (node: DocumentNode): ValueSchemaNode | undefined =>\n  node.kind === 'map' || node.kind === 'table' || node.kind === 'list' ? node.value : undefined;\n\nconst node = <T extends DocumentNode>(value: T): T => Object.freeze(value);\nexport const field = <T>(validator?: Validator<T>): FieldNode<T> =>\n  node({ kind: 'field', ...(validator ? { validator } : {}) });\ntype OptionalLeaf =\n  | FieldNode<unknown, boolean>\n  | VariantNode<string, VariantShape>\n  | MapNode<ValueSchemaNode>\n  | ListNode<unknown>\n  | TreeNode<unknown, false>\n  | TreeNode<unknown, true>;\nexport const optional = <T extends OptionalLeaf>(value: T): OptionalNode<T> => {\n  if (!['field', 'variant', 'map', 'list', 'tree'].includes(value.kind))\n    throw new TypeError('Only field, variant, map, list and tree nodes support optional presence.');\n  return node({ ...value, optional: true } as OptionalNode<T>);\n};\nexport const object = <S extends ObjectShape>(shape: S): ObjectNode<S> =>\n  node({ kind: 'object', shape: Object.freeze({ ...shape }) });\nexport const variant = <T extends string, V extends VariantShape>(\n  tag: T,\n  variants: V\n): VariantNode<T, V> => node({ kind: 'variant', tag, variants: Object.freeze({ ...variants }) });\nexport const table = <V extends EntitySchemaNode, K extends string = string>(\n  value: V,\n  options?: { readonly key: Validator<K> }\n): TableNode<V, K> => node({ kind: 'table', value, ...options });\nexport const map = <V extends ValueSchemaNode, K extends string = string>(\n  value: V,\n  options?: { readonly key: Validator<K> }\n): MapNode<V, K> => node({ kind: 'map', value, ...options });\nexport const list = <TItem>(\n  value: FieldNode<TItem, false>,\n  config: DocumentListConfig<TItem>\n): ListNode<TItem> => node({ kind: 'list', keyOf: config.keyOf, value });\nexport const tree = <TValue, ValueOptional extends boolean>(\n  value: FieldNode<TValue, ValueOptional>\n): TreeNode<TValue, ValueOptional> => Object.freeze({ kind: 'tree' as const, value });\n\nconst paths = new WeakMap<\n  object,\n  {\n    readonly address: DocumentAddress;\n    readonly nodes: readonly DocumentNode[];\n    readonly owner: object;\n    readonly tree?: TreeTarget;\n  }\n>();\n\nconst pathProxy = (\n  nodes: readonly DocumentNode[],\n  address: DocumentAddress,\n  owner: object,\n  treeSelection?: TreeTarget\n): object => {\n  const proxy = new Proxy(\n    {},\n    {\n      get: (_target, property: string | symbol) => {\n        if (typeof property !== 'string') return undefined;\n        const trees = nodes.every(node => node.kind === 'tree');\n        if (!treeSelection && trees && property === 'rootId')\n          return pathProxy(nodes, address, owner, { kind: 'root' });\n        if (!treeSelection && trees && property === 'nodes')\n          return pathProxy(nodes, address, owner, { kind: 'nodes' });\n        if (treeSelection?.kind === 'nodes' && property === 'item')\n          return (id: string) => {\n            if (typeof id !== 'string') throw new TypeError('Tree node keys must be strings.');\n            return pathProxy(nodes, address, owner, { kind: 'node', id });\n          };\n        if (treeSelection) throw new TypeError(`Invalid tree path segment: ${property}`);\n        const collection = nodes.every(node => collectionEntryNode(node) !== undefined);\n        if (collection && property === 'item')\n          return (id: string) => {\n            if (typeof id !== 'string') throw new TypeError('Collection keys must be strings.');\n            for (const node of nodes)\n              if (node.kind === 'table' || node.kind === 'map') {\n                const invalid = checkKey(node.key, id, [...address, id]);\n                if (invalid) throw new TypeError(invalid.message);\n              }\n            return pathProxy(\n              nodes.map(node => collectionEntryNode(node)!),\n              [...address, id],\n              owner\n            );\n          };\n        const children = nodes.flatMap(node => {\n          if (node.kind === 'object')\n            return Object.hasOwn(node.shape, property) ? [node.shape[property]] : [];\n          if (node.kind !== 'variant') return [];\n          if (property === node.tag) return [field<string>()];\n          return Object.values(node.variants).flatMap(branch =>\n            Object.hasOwn(branch.shape, property) ? [branch.shape[property]] : []\n          );\n        });\n        if (!children.length) throw new TypeError(`Invalid schema path segment: ${property}`);\n        return pathProxy(children, [...address, property], owner);\n      },\n    }\n  );\n  paths.set(proxy, { nodes, address, owner, ...(treeSelection ? { tree: treeSelection } : {}) });\n  return proxy;\n};\n\nexport const compilePath = <S extends ObjectShape>(\n  owner: ObjectNode<S>,\n  kind: 'collection' | 'value' | 'auto',\n  pick: (path: SchemaPath<S>) => unknown\n): CollectionSelector | ValueSelector => {\n  const scope = {};\n  const value = pick(pathProxy([owner], [], scope) as SchemaPath<S>);\n  const selected = typeof value === 'object' && value !== null ? paths.get(value) : undefined;\n  if (!selected || selected.owner !== scope)\n    throw new TypeError('Selector must return a path from its callback.');\n  const collection =\n    selected.tree?.kind === 'nodes' ||\n    selected.nodes.every(node => collectionEntryNode(node) !== undefined);\n  if (kind === 'collection' && !collection)\n    throw new TypeError('Collection selectors require a map, table, list or tree nodes path.');\n  const resolvedKind = kind === 'auto' ? (collection ? 'collection' : 'value') : kind;\n  const result = Object.freeze({\n    kind: resolvedKind,\n    schema: owner,\n    address: Object.freeze([...selected.address]),\n    ...(selected.tree ? { tree: Object.freeze({ ...selected.tree }) } : {}),\n  }) as CollectionSelector | ValueSelector;\n  return result;\n};\n","import type { CollectionImpact } from '../impact';\nimport type { Unsubscribe } from '../runtime/contract';\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 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 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 reset: boolean;\n  readonly cause?: unknown;\n};\n\nexport type SourceContext = ValueContext<unknown> | CollectionContext<string, unknown>;\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 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 { profile } from '../profile';\nimport type { ObserverError, Unsubscribe } from '../runtime/contract';\nimport type { BatchContext, CollectionChange, SourceContext } from './contract';\nimport { ProjectionDisposedError, ProjectionError } from './contract';\n\ntype BatchOptions = { readonly cause?: unknown };\n\ntype ProducerBase = {\n  readonly name: string;\n  readonly outputs: readonly OutputRecord[];\n  fault: ProjectionError | undefined;\n  disposed: boolean;\n  clear(): void;\n  release(): void;\n};\n\nexport type OutputRecord = {\n  readonly kind: 'value' | 'collection';\n  readonly owner: ProducerRecord;\n  readonly consumers: Set<ProcessorRecord>;\n  context(active: () => boolean): SourceContext;\n  current(): unknown;\n  revision(): number;\n  reset(): boolean;\n  subscribe(listener: (change?: CollectionChange<string, unknown>) => void): Unsubscribe;\n  emit(call: (listener: () => void) => void): void;\n  clear(): void;\n  release(): void;\n};\n\nexport type SourceBoundaryRecord = ProducerBase & {\n  readonly kind: 'source';\n  readonly outputs: readonly [OutputRecord];\n  pendingCause(): unknown;\n  recovering(): boolean;\n  prepare(cause: unknown): { readonly changed: boolean; readonly force: boolean };\n  publish(): void;\n};\n\nexport type ProcessorRecord = ProducerBase & {\n  readonly kind: 'processor';\n  readonly dependencies: readonly OutputRecord[];\n  readonly order: number;\n  evaluate(reset: boolean, cause: unknown): readonly OutputRecord[];\n  publish(): void;\n};\n\nexport type ProducerRecord = SourceBoundaryRecord | ProcessorRecord;\n\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 sources = new Set<SourceBoundaryRecord>();\n  const processors = new Set<ProcessorRecord>();\n  const pendingSources = new Set<SourceBoundaryRecord>();\n  const heap: ProcessorRecord[] = [];\n  const queued = new Set<ProcessorRecord>();\n  const completed = new Set<ProcessorRecord>();\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\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\n  const enqueue = (processor: ProcessorRecord) => {\n    if (processor.disposed || queued.has(processor)) return;\n    queued.add(processor);\n    profile.projection('scheduledNodes');\n    let index = heap.length;\n    heap.push(processor);\n    while (index > 0) {\n      const parent = (index - 1) >> 1;\n      if (heap[parent].order < processor.order) break;\n      heap[index] = heap[parent];\n      index = parent;\n    }\n    heap[index] = processor;\n  };\n\n  const pop = (): ProcessorRecord => {\n    const first = heap[0];\n    const last = heap.pop()!;\n    if (heap.length) {\n      let index = 0;\n      while (index * 2 + 1 < heap.length) {\n        let child = index * 2 + 1;\n        if (child + 1 < heap.length && heap[child + 1].order < heap[child].order) child++;\n        if (last.order < heap[child].order) break;\n        heap[index] = heap[child];\n        index = child;\n      }\n      heap[index] = last;\n    }\n    return first;\n  };\n\n  const revisionsOf = (producer: ProducerRecord): readonly number[] =>\n    producer.kind === 'processor'\n      ? producer.dependencies.map(output => output.revision())\n      : producer.outputs.map(output => output.revision());\n\n  const errorFor = (\n    producer: ProducerRecord,\n    cause: unknown,\n    kind: ProjectionError['phase'] = producer.kind === 'source' ? 'source' : 'processor'\n  ) => new ProjectionError(kind, producer.name, revisionsOf(producer), cause);\n\n  const capture = (source: SourceBoundaryRecord) => {\n    if (disposed) return;\n    if (phase !== 'idle') {\n      source.fault = errorFor(\n        source,\n        new Error('Source changed while projection was running.'),\n        'source'\n      );\n      errors.push(source.fault);\n      throw source.fault;\n    }\n    pendingSources.add(source);\n    profile.projection('sourceEvents');\n    if (source.fault) errors.push(source.fault);\n  };\n\n  const settleCause = (): unknown => {\n    if (activeBatch?.cause !== undefined) return activeBatch.cause;\n    for (const source of pendingSources) {\n      const cause = source.pendingCause();\n      if (cause !== undefined) return cause;\n    }\n    return undefined;\n  };\n\n  const settle = () => {\n    if (disposed || depth || phase !== 'idle') return;\n    phase = 'compute';\n    lock(true);\n    const cause = settleCause();\n    try {\n      for (const source of pendingSources) {\n        if (source.disposed) continue;\n        const wasFaulted = source.fault !== undefined;\n        let changed = false;\n        let force = false;\n        if (!source.fault || source.recovering()) {\n          try {\n            const prepared = source.prepare(cause);\n            changed = prepared.changed;\n            force = prepared.force;\n            source.fault = undefined;\n          } catch (failure) {\n            source.fault = errorFor(source, failure, 'source');\n            errors.push(source.fault);\n          }\n        }\n        const recovered = wasFaulted && !source.fault;\n        if (changed) source.publish();\n        if (source.fault || changed || force || recovered) {\n          const output = source.outputs[0];\n          emissions.add(output);\n          output.consumers.forEach(enqueue);\n        }\n      }\n\n      while (heap.length) {\n        const processor = pop();\n        if (processor.disposed) continue;\n        const wasFaulted = processor.fault !== undefined;\n        profile.projection('processedNodes');\n        let changedOutputs: readonly OutputRecord[] = Object.freeze([]);\n        const blocked = processor.dependencies.find(\n          output => output.owner.fault || output.owner.disposed\n        );\n        if (blocked) {\n          processor.fault = errorFor(\n            processor,\n            blocked.owner.fault ?? new ProjectionDisposedError(),\n            'blocked'\n          );\n        } else {\n          const reset = wasFaulted || processor.dependencies.some(output => output.reset());\n          try {\n            changedOutputs = processor.evaluate(reset, cause);\n            const dependencyFailure = processor.dependencies.find(output => output.owner.fault)\n              ?.owner.fault;\n            if (dependencyFailure) throw dependencyFailure;\n            processor.fault = undefined;\n          } catch (failure) {\n            const error = errorFor(processor, failure);\n            processor.fault = error;\n            if (!reset) {\n              try {\n                changedOutputs = processor.evaluate(true, cause);\n                const dependencyFailure = processor.dependencies.find(output => output.owner.fault)\n                  ?.owner.fault;\n                if (dependencyFailure) throw dependencyFailure;\n                processor.fault = undefined;\n                errors.push(error);\n              } catch (rebuildFailure) {\n                processor.fault = errorFor(processor, rebuildFailure);\n                errors.push(processor.fault);\n              }\n            } else errors.push(error);\n          }\n        }\n        completed.add(processor);\n        const recovered = wasFaulted && !processor.fault;\n        if (processor.fault) {\n          processor.outputs.forEach(output => {\n            emissions.add(output);\n            output.consumers.forEach(enqueue);\n          });\n        } else {\n          if (changedOutputs.length) {\n            processor.publish();\n            changedOutputs.forEach(output => emissions.add(output));\n          }\n          const propagated = recovered ? processor.outputs : changedOutputs;\n          propagated.forEach(output => output.consumers.forEach(enqueue));\n        }\n        if (processor.fault || changedOutputs.length) {\n          profile.projection('publishedNodes');\n        }\n      }\n    } finally {\n      lock(false);\n      phase = 'idle';\n    }\n  };\n\n  const flush = (): readonly ObserverError[] => {\n    if (disposed || depth) return [];\n    if (pendingSources.size || completed.size) 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      pendingSources.forEach(source => source.clear());\n      completed.forEach(processor => processor.clear());\n      pendingSources.clear();\n      queued.clear();\n      completed.clear();\n      emissions.clear();\n      errors.length = 0;\n      reportingFailures = reportFailures;\n      lock(false);\n      phase = 'idle';\n    }\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\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\n  const releaseProducer = (producer: ProducerRecord) => {\n    assertIdle();\n    if (producer.outputs.some(output => output.consumers.size))\n      throw new Error('Projection producer is still used by another processor.');\n    producer.disposed = true;\n    if (producer.kind === 'processor') {\n      producer.dependencies.forEach(output => output.consumers.delete(producer));\n      processors.delete(producer);\n      queued.delete(producer);\n      completed.delete(producer);\n    } else {\n      sources.delete(producer);\n      pendingSources.delete(producer);\n    }\n    producer.release();\n    producer.clear();\n    producer.outputs.forEach(output => emissions.delete(output));\n  };\n\n  return {\n    assertActive,\n    assertIdle,\n    capture,\n    settle,\n    flush,\n    run,\n    guards,\n    cleanups,\n    get active() {\n      return !disposed;\n    },\n    addSource(source: SourceBoundaryRecord) {\n      assertIdle();\n      sources.add(source);\n    },\n    addProcessor(processor: ProcessorRecord) {\n      assertIdle();\n      processors.add(processor);\n      processor.dependencies.forEach(output => output.consumers.add(processor));\n    },\n    releaseProducer,\n    order: () => sequence++,\n    initialize<T>(callback: () => T): T {\n      assertIdle();\n      phase = 'compute';\n      lock(true);\n      try {\n        return callback();\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      processors.forEach(processor => {\n        processor.disposed = true;\n        try {\n          processor.release();\n        } catch (error) {\n          failures.push(error);\n        }\n      });\n      sources.forEach(source => {\n        source.disposed = true;\n        try {\n          source.release();\n        } catch (error) {\n          failures.push(error);\n        }\n      });\n      processors.clear();\n      sources.clear();\n      pendingSources.clear();\n      heap.length = 0;\n      queued.clear();\n      completed.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};\n\nexport type Scheduler = ReturnType<typeof createScheduler>;\n\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};\n\nexport const assertScope = (active: () => boolean) => {\n  if (!active()) throw new Error('Projection reader or writer is no longer active.');\n};\n","import { profile } from '../profile';\nimport type {\n  CollectionChange,\n  CollectionContext,\n  CollectionDraft,\n  CollectionRead,\n} from './contract';\nimport { assertScope } from './scheduler';\n\ntype Entry<V> = { readonly present: true; readonly value: V } | { readonly present: false };\n\ntype TreeNode<K extends string, V> = {\n  readonly key: K;\n  readonly value: V;\n  readonly height: number;\n  readonly left?: TreeNode<K, V>;\n  readonly right?: TreeNode<K, V>;\n};\n\nconst height = <K extends string, V>(node: TreeNode<K, V> | undefined): number => node?.height ?? 0;\n\nconst makeTreeNode = <K extends string, V>(\n  key: K,\n  value: V,\n  left?: TreeNode<K, V>,\n  right?: TreeNode<K, V>\n): TreeNode<K, V> =>\n  Object.freeze({\n    key,\n    value,\n    left,\n    right,\n    height: Math.max(height(left), height(right)) + 1,\n  });\n\nconst rotateLeft = <K extends string, V>(node: TreeNode<K, V>): TreeNode<K, V> => {\n  const right = node.right!;\n  return makeTreeNode(\n    right.key,\n    right.value,\n    makeTreeNode(node.key, node.value, node.left, right.left),\n    right.right\n  );\n};\n\nconst rotateRight = <K extends string, V>(node: TreeNode<K, V>): TreeNode<K, V> => {\n  const left = node.left!;\n  return makeTreeNode(\n    left.key,\n    left.value,\n    left.left,\n    makeTreeNode(node.key, node.value, left.right, node.right)\n  );\n};\n\nconst rebalance = <K extends string, V>(node: TreeNode<K, V>): TreeNode<K, V> => {\n  const balance = height(node.left) - height(node.right);\n  if (balance > 1) {\n    if (height(node.left!.left) < height(node.left!.right))\n      return rotateRight(makeTreeNode(node.key, node.value, rotateLeft(node.left!), node.right));\n    return rotateRight(node);\n  }\n  if (balance < -1) {\n    if (height(node.right!.right) < height(node.right!.left))\n      return rotateLeft(makeTreeNode(node.key, node.value, node.left, rotateRight(node.right!)));\n    return rotateLeft(node);\n  }\n  return node;\n};\n\nconst treeSet = <K extends string, V>(\n  node: TreeNode<K, V> | undefined,\n  key: K,\n  value: V\n): TreeNode<K, V> => {\n  if (!node) return makeTreeNode(key, value);\n  if (key === node.key) return makeTreeNode(key, value, node.left, node.right);\n  if (key < node.key)\n    return rebalance(\n      makeTreeNode(node.key, node.value, treeSet(node.left, key, value), node.right)\n    );\n  return rebalance(makeTreeNode(node.key, node.value, node.left, treeSet(node.right, key, value)));\n};\n\nconst treeMin = <K extends string, V>(node: TreeNode<K, V>): TreeNode<K, V> =>\n  node.left ? treeMin(node.left) : node;\n\nconst treeRemove = <K extends string, V>(\n  node: TreeNode<K, V> | undefined,\n  key: K\n): TreeNode<K, V> | undefined => {\n  if (!node) return undefined;\n  if (key < node.key)\n    return rebalance(makeTreeNode(node.key, node.value, treeRemove(node.left, key), node.right));\n  if (key > node.key)\n    return rebalance(makeTreeNode(node.key, node.value, node.left, treeRemove(node.right, key)));\n  if (!node.left) return node.right;\n  if (!node.right) return node.left;\n  const next = treeMin(node.right);\n  return rebalance(makeTreeNode(next.key, next.value, node.left, treeRemove(node.right, next.key)));\n};\n\nconst treeGet = <K extends string, V>(node: TreeNode<K, V> | undefined, key: K): V | undefined => {\n  let current = node;\n  while (current) {\n    if (key === current.key) return current.value;\n    current = key < current.key ? current.left : current.right;\n  }\n  return undefined;\n};\n\nconst treeHas = <K extends string, V>(node: TreeNode<K, V> | undefined, key: K): boolean => {\n  let current = node;\n  while (current) {\n    if (key === current.key) return true;\n    current = key < current.key ? current.left : current.right;\n  }\n  return false;\n};\n\nconst treeFromSorted = <K extends string, V>(\n  entries: readonly (readonly [K, V])[],\n  start = 0,\n  end = entries.length\n): TreeNode<K, V> | undefined => {\n  if (start >= end) return undefined;\n  const middle = (start + end) >> 1;\n  const [key, value] = entries[middle];\n  return makeTreeNode(\n    key,\n    value,\n    treeFromSorted(entries, start, middle),\n    treeFromSorted(entries, middle + 1, end)\n  );\n};\n\nexport type CollectionOutputEvaluation<K extends string, V> = {\n  readonly previous: CollectionRead<K, V>;\n  readonly next: CollectionRead<K, V>;\n  readonly output: CollectionDraft<K, V>;\n};\n\nexport type CollectionOutputState<K extends string, V> = {\n  begin(active: () => boolean, initialize: boolean): CollectionOutputEvaluation<K, V>;\n  seal(reset: boolean, isEqual: (previous: V, next: V) => boolean): boolean;\n  context(active: () => boolean, cause: unknown): CollectionContext<K, V>;\n  current(check: () => void): CollectionRead<K, V>;\n  revision(): number;\n  reset(): boolean;\n  publish(): void;\n  emit(call: (listener: () => void) => void): void;\n  clear(): void;\n  release(): void;\n  subscribe(listener: (change: CollectionChange<K, V>) => void): void;\n  unsubscribe(listener: (change: CollectionChange<K, V>) => void): void;\n};\n\n/** Owns staged keyed intent, exact transitions and the persistent published lookup. */\nexport const createCollectionOutput = <K extends string, V>(): CollectionOutputState<K, V> => {\n  const values = new Map<K, V>();\n  let ids: readonly K[] = Object.freeze([]);\n  let staged = new Map<K, Entry<V>>();\n  let nextIds = ids;\n  let change: CollectionChange<K, V> | undefined;\n  let initialized = false;\n  let reset = false;\n  let revision = 0;\n  let publishedRoot: TreeNode<K, V> | undefined;\n  let explicitOrder: readonly K[] | undefined;\n  let cleared = false;\n  const listeners = new Set<(change: CollectionChange<K, V>) => void>();\n\n  const hasNext = (key: K): boolean =>\n    staged.has(key) ? staged.get(key)!.present : !cleared && values.has(key);\n  const getNext = (key: K): V | undefined => {\n    const entry = staged.get(key);\n    return entry\n      ? entry.present\n        ? entry.value\n        : undefined\n      : cleared\n        ? undefined\n        : values.get(key);\n  };\n  const deriveIds = (): readonly K[] => {\n    const result = cleared ? [] : ids.filter(hasNext);\n    for (const [key, entry] of staged)\n      if (entry.present && (cleared || !values.has(key))) result.push(key);\n    return result;\n  };\n\n  const begin = (active: () => boolean, initialize: boolean): CollectionOutputEvaluation<K, V> => {\n    staged = new Map();\n    nextIds = ids;\n    change = undefined;\n    explicitOrder = undefined;\n    cleared = initialize;\n    reset = initialize;\n    const read = (next: boolean): CollectionRead<K, V> => ({\n      get: key => {\n        assertScope(active);\n        return next ? getNext(key) : values.get(key);\n      },\n      has: key => {\n        assertScope(active);\n        return next ? hasNext(key) : values.has(key);\n      },\n      ids: () => {\n        assertScope(active);\n        return next ? Object.freeze(explicitOrder ? [...explicitOrder] : [...deriveIds()]) : ids;\n      },\n    });\n    const output: CollectionDraft<K, V> = {\n      set: (key, value) => {\n        assertScope(active);\n        if (typeof key !== 'string') throw new TypeError('Projection keys must be strings.');\n        staged.set(key, { present: true, value });\n      },\n      remove: key => {\n        assertScope(active);\n        staged.set(key, { present: false });\n      },\n      order: order => {\n        assertScope(active);\n        explicitOrder = Object.freeze([...order]);\n      },\n    };\n    return { previous: read(false), next: read(true), output };\n  };\n\n  const seal = (nextReset: boolean, isEqual: (previous: V, next: V) => boolean): boolean => {\n    if (cleared)\n      for (const key of values.keys()) if (!staged.has(key)) staged.set(key, { present: false });\n\n    profile.projection('touchedKeys', staged.size);\n    const added = new Set<K>();\n    const removed = new Set<K>();\n    const updated = new Set<K>();\n    for (const [key, entry] of staged) {\n      const existed = values.has(key);\n      if (entry.present) {\n        if (!existed) added.add(key);\n        else if (!isEqual(values.get(key) as V, entry.value)) updated.add(key);\n        else if (!nextReset) staged.delete(key);\n      } else if (existed) removed.add(key);\n      else staged.delete(key);\n    }\n\n    if (explicitOrder || added.size || removed.size) {\n      const order = explicitOrder ?? [...ids.filter(key => !removed.has(key)), ...added];\n      const seen = new Set(order);\n      if (\n        seen.size !== order.length ||\n        order.length !== values.size + added.size - removed.size ||\n        order.some(key => !hasNext(key))\n      )\n        throw new TypeError('Projection order must contain every key exactly once.');\n      nextIds =\n        ids.length === order.length && ids.every((key, index) => key === order[index])\n          ? ids\n          : Object.freeze([...order]);\n    } else nextIds = ids;\n\n    const changedKeys = new Set<K>([...added, ...removed, ...updated]);\n    profile.projection('changedKeys', changedKeys.size);\n    const addedEntries: { readonly key: K; readonly after: V }[] = [];\n    const updatedEntries: {\n      readonly key: K;\n      readonly before: V;\n      readonly after: V;\n    }[] = [];\n    const removedEntries: { readonly key: K; readonly before: V }[] = [];\n    for (const key of changedKeys) {\n      const beforePresent = values.has(key);\n      const afterPresent = hasNext(key);\n      if (beforePresent === afterPresent) {\n        if (!beforePresent || isEqual(values.get(key) as V, getNext(key) as V)) continue;\n      }\n      if (!beforePresent) addedEntries.push({ key, after: getNext(key) as V });\n      else if (!afterPresent) removedEntries.push({ key, before: values.get(key) as V });\n      else\n        updatedEntries.push({\n          key,\n          before: values.get(key) as V,\n          after: getNext(key) as V,\n        });\n    }\n\n    const orderChanged = nextIds !== ids;\n    if (nextReset) change = Object.freeze({ kind: 'reset' as const });\n    else if (\n      addedEntries.length ||\n      updatedEntries.length ||\n      removedEntries.length ||\n      orderChanged\n    ) {\n      let commonOrderChanged = false;\n      if (orderChanged) {\n        const before = ids.filter(key => !removed.has(key));\n        const after = nextIds.filter(key => !added.has(key));\n        commonOrderChanged = before.some((key, index) => after[index] !== key);\n      }\n      change = Object.freeze({\n        kind: 'incremental' as const,\n        added: Object.freeze(addedEntries),\n        updated: Object.freeze(updatedEntries),\n        removed: Object.freeze(removedEntries),\n        ...(commonOrderChanged\n          ? {\n              order: Object.freeze({\n                before: Object.freeze([...ids]),\n                after: Object.freeze([...nextIds]),\n              }),\n            }\n          : {}),\n      });\n    }\n    reset = nextReset;\n    return change !== undefined;\n  };\n\n  const context = (active: () => boolean, cause: unknown): CollectionContext<K, V> =>\n    Object.freeze({\n      kind: 'collection' as const,\n      read: {\n        get: key => {\n          assertScope(active);\n          return getNext(key);\n        },\n        has: key => {\n          assertScope(active);\n          return hasNext(key);\n        },\n        ids: () => {\n          assertScope(active);\n          return nextIds;\n        },\n      },\n      change,\n      revision,\n      reset,\n      cause,\n    });\n\n  const current = (check: () => void): CollectionRead<K, V> => {\n    const root = publishedRoot;\n    const publishedIds = ids;\n    return Object.freeze({\n      get: key => {\n        check();\n        return treeGet(root, key);\n      },\n      has: key => {\n        check();\n        return treeHas(root, key);\n      },\n      ids: () => {\n        check();\n        return publishedIds;\n      },\n    });\n  };\n\n  return {\n    begin,\n    seal,\n    context,\n    current,\n    revision: () => revision,\n    reset: () => reset,\n    publish: () => {\n      if (change) {\n        if (change.kind === 'reset') {\n          const entries: [K, V][] = [];\n          for (const [key, entry] of staged) if (entry.present) entries.push([key, entry.value]);\n          entries.sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0));\n          publishedRoot = treeFromSorted(entries);\n        } else {\n          for (const [key, entry] of staged)\n            publishedRoot = entry.present\n              ? treeSet(publishedRoot, key, entry.value)\n              : treeRemove(publishedRoot, key);\n        }\n      }\n      for (const [key, entry] of staged) {\n        if (entry.present) values.set(key, entry.value);\n        else values.delete(key);\n      }\n      if (change && initialized) revision++;\n      ids = nextIds;\n      initialized = true;\n    },\n    emit: call => {\n      const resetEvent = Object.freeze({ kind: 'reset' as const });\n      Array.from(listeners).forEach(listener => call(() => listener(change ?? resetEvent)));\n    },\n    clear: () => {\n      staged.clear();\n      nextIds = ids;\n      change = undefined;\n      reset = false;\n      explicitOrder = undefined;\n      cleared = false;\n    },\n    release: () => {\n      values.clear();\n      staged.clear();\n      publishedRoot = undefined;\n      listeners.clear();\n      ids = nextIds = Object.freeze([]);\n      change = undefined;\n      initialized = false;\n      revision = 0;\n      reset = false;\n      explicitOrder = undefined;\n      cleared = false;\n    },\n    subscribe: listener => listeners.add(listener),\n    unsubscribe: listener => listeners.delete(listener),\n  };\n};\n\nexport const mapRead = <K extends string, V>(value: ReadonlyMap<K, V>): CollectionRead<K, V> => ({\n  get: key => value.get(key),\n  has: key => value.has(key),\n  ids: () => Object.freeze([...value.keys()]),\n});\n\n/** Immutable map-like view over a CollectionRead. */\nexport const collectionView = <K extends string, V>(\n  read: CollectionRead<K, V>\n): ReadonlyMap<K, V> => {\n  const ids = read.ids();\n  const entries = function* (): IterableIterator<[K, V]> {\n    for (const key of ids) yield [key, read.get(key) as V];\n  };\n  const values = function* (): IterableIterator<V> {\n    for (const key of 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 ids.length;\n    },\n    keys: () => ids[Symbol.iterator](),\n    values,\n    entries,\n    forEach: (callback, thisArg) => {\n      for (const key of ids) callback.call(thisArg, read.get(key) as V, key, view);\n    },\n    [Symbol.iterator]: entries,\n  };\n  return Object.freeze(view);\n};\n\n/** Eager durable view used when a processor result may retain its dependency value. */\nexport const snapshotCollectionView = <K extends string, V>(\n  read: CollectionRead<K, V>\n): ReadonlyMap<K, V> => {\n  const ids = read.ids();\n  const values = new Map<K, V>();\n  for (const key of ids) values.set(key, read.get(key) as V);\n  return collectionView(mapRead(values));\n};\n\nexport type CollectionStageOptions<K extends string, V> = {\n  readonly reset: boolean;\n  readonly candidates?: Iterable<K>;\n  readonly orderMayChange?: boolean;\n  readonly isEqual?: (previous: V, next: V) => boolean;\n};\n\n/**\n * The one source-to-CollectionChange kernel. Candidate keys only narrow value work;\n * exact membership/value/order semantics remain owned here.\n */\nexport const stageCollectionRead = <K extends string, V>(\n  state: CollectionOutputState<K, V>,\n  read: CollectionRead<K, V>,\n  active: () => boolean,\n  options: CollectionStageOptions<K, V>\n): boolean => {\n  const evaluation = state.begin(active, options.reset);\n  if (options.reset) {\n    const ids = read.ids();\n    profile.collectionView.idsScanned(ids.length);\n    for (const key of ids) {\n      profile.collectionView.mapped();\n      evaluation.output.set(key, read.get(key) as V);\n    }\n    evaluation.output.order(ids);\n  } else {\n    const previous = state.current(() => undefined);\n    const keys = options.candidates\n      ? [...new Set(options.candidates)]\n      : [...new Set([...previous.ids(), ...read.ids()])];\n    if (!options.candidates) profile.collectionView.idsScanned(keys.length);\n    for (const key of keys) {\n      if (read.has(key)) {\n        profile.collectionView.mapped();\n        evaluation.output.set(key, read.get(key) as V);\n      } else evaluation.output.remove(key);\n    }\n    if (options.orderMayChange || !options.candidates) {\n      const ids = read.ids();\n      if (options.candidates) profile.collectionView.idsScanned(ids.length);\n      evaluation.output.order(ids);\n    }\n  }\n  return state.seal(options.reset, options.isEqual ?? Object.is);\n};\n\n/** Exact net transition between two published map-like snapshots. */\nexport const collectionChangeBetween = <K extends string, V>(\n  previous: ReadonlyMap<K, V>,\n  current: ReadonlyMap<K, V>,\n  isEqual: (previous: V, next: V) => boolean = Object.is\n): CollectionChange<K, V> | undefined => {\n  const added: { readonly key: K; readonly after: V }[] = [];\n  const removed: { readonly key: K; readonly before: V }[] = [];\n  const updated: { readonly key: K; readonly before: V; readonly after: V }[] = [];\n  for (const [key, before] of previous) {\n    if (!current.has(key)) removed.push({ key, before });\n    else {\n      const after = current.get(key) as V;\n      if (!isEqual(before, after)) updated.push({ key, before, after });\n    }\n  }\n  for (const [key, after] of current) if (!previous.has(key)) added.push({ key, after });\n  const beforeKeys = new Set(previous.keys());\n  const afterKeys = new Set(current.keys());\n  const beforeCommon = [...previous.keys()].filter(key => afterKeys.has(key));\n  const afterCommon = [...current.keys()].filter(key => beforeKeys.has(key));\n  const orderChanged = beforeCommon.some((key, index) => afterCommon[index] !== key);\n  if (!added.length && !removed.length && !updated.length && !orderChanged) return undefined;\n  return Object.freeze({\n    kind: 'incremental' as const,\n    added: Object.freeze(added),\n    updated: Object.freeze(updated),\n    removed: Object.freeze(removed),\n    ...(orderChanged\n      ? {\n          order: Object.freeze({\n            before: Object.freeze([...previous.keys()]),\n            after: Object.freeze([...current.keys()]),\n          }),\n        }\n      : {}),\n  });\n};\n","import { accessOf } from '../runtime/access';\nimport type { DocumentReadable, Synchronous } from '../runtime/contract';\nimport type {\n  CollectionEntry,\n  CollectionId,\n  CollectionPath,\n  CollectionSelector,\n  Infer,\n  ObjectNode,\n  PathValueOf,\n  ReadonlyValue,\n  SchemaPath,\n  ValueSelector,\n} from '../schema';\nimport { compilePath } from '../schema';\nimport { snapshotCollectionView } from './collection-output';\nimport type {\n  CollectionChange,\n  CollectionDraft,\n  CollectionRead,\n  ExternalCollectionSource,\n  ExternalValueSource,\n  SourceContext,\n} from './contract';\nimport type { Readable } from './readable';\nimport { assertSynchronous } from './scheduler';\n\ndeclare const projectionDefinition: unique symbol;\ndeclare const projectionChanges: unique symbol;\ndeclare const writableInput: unique symbol;\n\n/** A lazy output reference with no materialized Runtime state. */\nexport type Projection<T, C = undefined> = {\n  readonly [projectionDefinition]: T;\n  readonly [projectionChanges]: C;\n};\n\n/** A writable source projection. */\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\nexport type Equality = (a: unknown, b: unknown) => boolean;\ntype PathSelector<S extends ObjectNode> = (path: SchemaPath<S['shape']>) => unknown;\n\nexport type OutputDefinition =\n  | {\n      readonly kind: 'value';\n      readonly equality: Equality;\n      readonly path?: readonly string[];\n    }\n  | {\n      readonly kind: 'collection';\n      readonly equality: Equality;\n      readonly path?: readonly string[];\n    };\n\nexport type ValueOutputEvaluation = {\n  readonly kind: 'value';\n  readonly previous: unknown;\n  readonly next: () => unknown;\n  readonly output: { set(value: unknown): void };\n};\n\nexport type CollectionOutputEvaluation = {\n  readonly kind: 'collection';\n  readonly previous: CollectionRead<string, unknown>;\n  readonly next: CollectionRead<string, unknown>;\n  readonly output: CollectionDraft<string, unknown>;\n};\n\nexport type OutputEvaluation = ValueOutputEvaluation | CollectionOutputEvaluation;\n\nexport type ProcessorEvaluation = {\n  readonly reset: boolean;\n  readonly cause: unknown;\n  readonly sources: readonly SourceContext[];\n  readonly outputs: readonly OutputEvaluation[];\n};\n\nexport type Rebuild = { readonly kind: 'rebuild' };\n\nexport type ProcessorInstance = {\n  evaluate(input: ProcessorEvaluation): void | Rebuild;\n  release?(): void;\n};\n\ntype SourceAdapter =\n  | {\n      readonly kind: 'value-input';\n      readonly initial: unknown;\n      readonly equality: Equality;\n    }\n  | {\n      readonly kind: 'collection-input';\n      readonly initial: ReadonlyMap<string, unknown>;\n    }\n  | {\n      readonly kind: 'readable';\n      readonly readable: Readable<unknown>;\n      readonly equality: Equality;\n    }\n  | {\n      readonly kind: 'external-value';\n      readonly source: ExternalValueSource<unknown>;\n      readonly equality: Equality;\n    }\n  | {\n      readonly kind: 'external-collection';\n      readonly source: ExternalCollectionSource<string, unknown>;\n    }\n  | {\n      readonly kind: 'document';\n      readonly document: DocumentReadable<ObjectNode>;\n      readonly selector: ValueSelector | CollectionSelector;\n    };\n\nexport type SourceDefinition = {\n  readonly kind: 'source';\n  readonly source: SourceAdapter;\n  readonly output: OutputDefinition;\n  owner?: object;\n};\n\nexport type ProcessorDefinition = {\n  readonly kind: 'processor';\n  readonly dependencies: readonly Projection<unknown, unknown>[];\n  readonly outputs: readonly OutputDefinition[];\n  readonly create: () => ProcessorInstance;\n  readonly name?: string;\n  owner?: object;\n};\n\nexport type ProducerDefinition = SourceDefinition | ProcessorDefinition;\n\nexport type ProjectionRef = {\n  readonly producer: ProducerDefinition;\n  readonly output: number;\n};\n\nconst projections = new WeakMap<object, ProjectionRef>();\n\nconst defineRef = <T, C = undefined>(\n  producer: ProducerDefinition,\n  output: number\n): Projection<T, C> => {\n  const handle = Object.freeze({}) as Projection<T, C>;\n  projections.set(handle, Object.freeze({ producer, output }));\n  return handle;\n};\n\nexport const projectionRef = (projection: Projection<unknown, unknown>): ProjectionRef => {\n  const ref = projections.get(projection);\n  if (!ref) throw new TypeError('Unknown projection definition.');\n  return ref;\n};\n\nexport const producerOf = (projection: Projection<unknown, unknown>): ProducerDefinition =>\n  projectionRef(projection).producer;\n\nexport const isProjection = (value: unknown): value is Projection<unknown, unknown> =>\n  value !== null && typeof value === 'object' && projections.has(value);\n\nexport const ownProjection = <P extends Projection<unknown, unknown>>(\n  projection: P,\n  owner: object\n): P => {\n  const producer = producerOf(projection);\n  if (producer.owner !== undefined && producer.owner !== owner)\n    throw new TypeError('Projection producer already belongs to another scope.');\n  if (producer.kind === 'processor') {\n    for (const dependency of producer.dependencies) {\n      const dependencyOwner = producerOf(dependency).owner;\n      if (dependencyOwner !== undefined && dependencyOwner !== owner)\n        throw new TypeError('A scope cannot depend on another scope.');\n    }\n  }\n  producer.owner = owner;\n  return projection;\n};\n\nconst freezeOutput = (output: OutputDefinition): OutputDefinition =>\n  Object.freeze({\n    kind: output.kind,\n    equality: output.equality,\n    ...(output.path ? { path: Object.freeze([...output.path]) } : {}),\n  });\n\nexport const defineProcessor = (definition: {\n  readonly dependencies: readonly Projection<unknown, unknown>[];\n  readonly outputs: readonly OutputDefinition[];\n  readonly create: () => ProcessorInstance;\n  readonly name?: string;\n}): readonly Projection<unknown, unknown>[] => {\n  if (!Array.isArray(definition.dependencies))\n    throw new TypeError('Projection dependencies must be an array.');\n  definition.dependencies.forEach(projectionRef);\n  if (!definition.outputs.length) throw new TypeError('Projection processor requires an output.');\n  const producer: ProcessorDefinition = {\n    kind: 'processor',\n    dependencies: Object.freeze([...definition.dependencies]),\n    outputs: Object.freeze(definition.outputs.map(freezeOutput)),\n    create: definition.create,\n    ...(definition.name ? { name: definition.name } : {}),\n  };\n  return Object.freeze(\n    producer.outputs.map((_, output) => defineRef<unknown, unknown>(producer, output))\n  );\n};\n\nconst defineSource = <T, C = undefined>(\n  source: SourceAdapter,\n  output: OutputDefinition\n): Projection<T, C> => {\n  const producer: SourceDefinition = {\n    kind: 'source',\n    source,\n    output: freezeOutput(output),\n  };\n  return defineRef<T, C>(producer, 0);\n};\n\nconst sourceValue = (source: SourceContext): unknown =>\n  source.kind === 'value' ? source.value : snapshotCollectionView(source.read);\n\nconst valueInput = <T>(\n  initial: T,\n  equality: (previous: T, next: T) => boolean = Object.is\n): Input<T> =>\n  defineSource<T>(\n    { kind: 'value-input', initial, equality: equality as Equality },\n    { kind: 'value', equality: equality as Equality }\n  ) 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<string, unknown>();\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 defineSource<ReadonlyMap<K, V>, CollectionChange<K, V>>(\n    { kind: 'collection-input', initial: entries },\n    { kind: 'collection', equality: Object.is }\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<CollectionEntry<P>>>,\n  CollectionChange<CollectionId<P>, ReadonlyValue<CollectionEntry<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  source:\n    | DocumentReadable<S>\n    | Readable<unknown>\n    | ExternalValueSource<unknown>\n    | ExternalCollectionSource<string, unknown>,\n  selector?: PathSelector<S>\n): Projection<unknown, unknown> {\n  if (isExternalSource(source))\n    return source.kind === 'collection'\n      ? defineSource(\n          { kind: 'external-collection', source },\n          { kind: 'collection', equality: Object.is }\n        )\n      : defineSource(\n          { kind: 'external-value', source, equality: Object.is },\n          { kind: 'value', equality: Object.is }\n        );\n  if ('current' in source && typeof source.current === 'function')\n    return defineSource(\n      { kind: 'readable', readable: source as Readable<unknown>, equality: Object.is },\n      { kind: 'value', equality: Object.is }\n    );\n\n  const document = source as DocumentReadable<ObjectNode>;\n  const state = accessOf(document);\n  const selected = selector\n    ? compilePath(state.schema, 'auto', selector as never)\n    : (Object.freeze({\n        kind: 'value' as const,\n        schema: state.schema,\n        address: Object.freeze([]),\n      }) as ValueSelector);\n  return defineSource(\n    { kind: 'document', document, selector: selected },\n    { kind: selected.kind, equality: Object.is }\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  const [projection] = defineProcessor({\n    dependencies,\n    outputs: [{ kind: 'value', equality: equality as Equality }],\n    create: () => ({\n      evaluate: evaluation => {\n        const output = evaluation.outputs[0];\n        if (output.kind !== 'value') throw new Error('derive requires a value output.');\n        const next = compute(...(evaluation.sources.map(sourceValue) as ProjectionValues<D>));\n        assertSynchronous(next);\n        output.output.set(next);\n      },\n    }),\n  });\n  return projection as Projection<T>;\n}\n","import { collectionView } from './collection-output';\nimport type { CollectionChange, CollectionDraft, CollectionRead, SourceContext } from './contract';\nimport type {\n  CollectionOutputEvaluation,\n  OutputDefinition,\n  OutputEvaluation,\n  Projection,\n  Rebuild,\n} from './definition';\nimport { defineProcessor, projectionRef } from './definition';\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 | 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 | Rebuild;\n\ndeclare const groupOutput: unique symbol;\n\ntype GroupCollectionOutput<K extends string, V> = {\n  readonly [groupOutput]: { readonly kind: 'collection'; readonly key: K; readonly value: V };\n};\n\ntype GroupValueOutput<T> = {\n  readonly [groupOutput]: { readonly kind: 'value'; readonly value: T };\n};\n\ntype GroupOutputShape = {\n  readonly [name: string]:\n    GroupCollectionOutput<string, unknown> | GroupValueOutput<unknown> | GroupOutputShape;\n};\n\nexport type IncrementalGroupOutputTree = GroupOutputShape;\n\ntype GroupOutputBuilder = {\n  collection<K extends string, V>(\n    equality?: (previous: V, next: V) => boolean\n  ): GroupCollectionOutput<K, V>;\n  value<T>(equality?: (previous: T, next: T) => boolean): GroupValueOutput<T>;\n};\n\nexport type IncrementalGroupDefine = GroupOutputBuilder;\n\nexport type GroupProjections<O> =\n  O extends GroupCollectionOutput<infer K, infer V>\n    ? Projection<ReadonlyMap<K, V>, CollectionChange<K, V>>\n    : O extends GroupValueOutput<infer T>\n      ? Projection<T>\n      : { readonly [P in keyof O]: GroupProjections<O[P]> };\n\ntype GroupReads<O> =\n  O extends GroupCollectionOutput<infer K, infer V>\n    ? CollectionRead<K, V>\n    : O extends GroupValueOutput<infer T>\n      ? T | undefined\n      : { readonly [P in keyof O]: GroupReads<O[P]> };\n\ntype GroupDrafts<O> =\n  O extends GroupCollectionOutput<infer K, infer V>\n    ? CollectionDraft<K, V>\n    : O extends GroupValueOutput<infer T>\n      ? { set(value: T): void }\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 | Rebuild;\n\nconst resetCollectionChange = Object.freeze({ kind: 'reset' as const });\n\nconst isRebuild = (value: unknown): value is Rebuild =>\n  value !== null &&\n  typeof value === 'object' &&\n  (value as { readonly kind?: unknown }).kind === 'rebuild';\n\nconst publicValue = (source: SourceContext): unknown =>\n  source.kind === 'value' ? source.value : collectionView(source.read);\n\nconst publicInputs = (\n  sources: readonly SourceContext[],\n  reset: boolean\n): { readonly values: readonly unknown[]; readonly changes: readonly unknown[] } => ({\n  values: Object.freeze(sources.map(publicValue)),\n  changes: Object.freeze(\n    sources.map(source =>\n      source.kind === 'collection' ? (reset ? resetCollectionChange : source.change) : undefined\n    )\n  ),\n});\n\nconst validateDependencies = (dependencies: readonly Projection<unknown, unknown>[]) => {\n  if (!Array.isArray(dependencies))\n    throw new TypeError('Incremental dependencies must be projections.');\n  dependencies.forEach(projectionRef);\n};\n\nfunction createIncrementalValue<const D extends readonly Projection<unknown, unknown>[], T>(\n  dependencies: D,\n  processor: IncrementalValueProcessor<D, T>\n): Projection<T> {\n  validateDependencies(dependencies);\n  const [projection] = defineProcessor({\n    dependencies,\n    outputs: [{ kind: 'value', equality: Object.is }],\n    create: () => {\n      const state: Record<string, unknown> = Object.create(null) as Record<string, unknown>;\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, evaluation.reset);\n          const result = processor({\n            sources: 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          });\n          assertSynchronous(result);\n          if (isRebuild(result)) return result;\n          output.output.set(result as T);\n        },\n      };\n    },\n  });\n  return projection as Projection<T>;\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  validateDependencies(dependencies);\n  const [projection] = defineProcessor({\n    dependencies,\n    outputs: [{ kind: 'collection', equality: Object.is }],\n    create: () => {\n      const state: Record<string, unknown> = Object.create(null) as Record<string, unknown>;\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, evaluation.reset);\n          const result = processor({\n            sources: 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            state,\n            output: output.output as CollectionDraft<K, V>,\n          });\n          assertSynchronous(result);\n          return isRebuild(result) ? result : undefined;\n        },\n      };\n    },\n  });\n  return projection as Projection<ReadonlyMap<K, V>, CollectionChange<K, V>>;\n}\n\ntype GroupShape = number | { readonly [key: string]: GroupShape };\nconst groupOutputMetadata = new WeakMap<\n  object,\n  {\n    readonly kind: OutputDefinition['kind'];\n    readonly equality: (a: unknown, b: unknown) => boolean;\n  }\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: OutputDefinition[]\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({\n        kind: metadata.kind,\n        equality: metadata.equality,\n        path: Object.freeze([...path]),\n      });\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\nconst previousOf = (output: OutputEvaluation): unknown => output.previous;\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 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  validateDependencies(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\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 = Object.is) => {\n      if (!active) throw new TypeError('Incremental group output declarations are synchronous.');\n      const descriptor = Object.freeze({});\n      groupOutputMetadata.set(descriptor, {\n        kind: 'collection',\n        equality: equality as (a: unknown, b: unknown) => boolean,\n      });\n      declaredOutputs.add(descriptor);\n      return descriptor as GroupCollectionOutput<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      groupOutputMetadata.set(descriptor, {\n        kind: 'value',\n        equality: equality as (a: unknown, b: unknown) => boolean,\n      });\n      declaredOutputs.add(descriptor);\n      return descriptor as GroupValueOutput<T>;\n    },\n  };\n  const declared = defineOutputs(defineOutput);\n  assertSynchronous(declared);\n  active = false;\n  const outputs: OutputDefinition[] = [];\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\n  const projections = defineProcessor({\n    dependencies,\n    outputs,\n    create: () => {\n      const state: Record<string, unknown> = Object.create(null) as Record<string, unknown>;\n      return {\n        evaluate: evaluation => {\n          const publicInput = publicInputs(evaluation.sources, evaluation.reset);\n          const result = processor({\n            sources: 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            outputs: 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          });\n          assertSynchronous(result);\n          return isRebuild(result) ? result : undefined;\n        },\n      };\n    },\n    name: `processor-group:${outputs.map(output => output.path?.join('.') ?? '').join(',')}`,\n  });\n  void previousOf;\n  return hydrateGroupShape(shape, projections) as GroupProjections<O>;\n}\n\nexport const incremental = Object.assign(createIncrementalValue, {\n  collection: createIncrementalCollection,\n  group: createIncrementalGroup,\n});\n\nexport type { CollectionChange } from './contract';\n"],"mappings":";;;AA6QA,MAAa,uBAAuB,SAClC,KAAK,SAAS,SAAS,KAAK,SAAS,WAAW,KAAK,SAAS,SAAS,KAAK,QAAQ,KAAA;AAEtF,MAAM,QAAgC,UAAgB,OAAO,OAAO,MAAM;AAC1E,MAAa,SAAY,cACvB,KAAK;CAAE,MAAM;CAAS,GAAI,YAAY,EAAE,WAAW,GAAG,EAAE;CAAG,CAAC;AAQ9D,MAAa,YAAoC,UAA8B;AAC7E,KAAI,CAAC;EAAC;EAAS;EAAW;EAAO;EAAQ;EAAO,CAAC,SAAS,MAAM,KAAK,CACnE,OAAM,IAAI,UAAU,2EAA2E;AACjG,QAAO,KAAK;EAAE,GAAG;EAAO,UAAU;EAAM,CAAoB;;AAE9D,MAAa,UAAiC,UAC5C,KAAK;CAAE,MAAM;CAAU,OAAO,OAAO,OAAO,EAAE,GAAG,OAAO,CAAC;CAAE,CAAC;AAC9D,MAAa,WACX,KACA,aACsB,KAAK;CAAE,MAAM;CAAW;CAAK,UAAU,OAAO,OAAO,EAAE,GAAG,UAAU,CAAC;CAAE,CAAC;AAChG,MAAa,SACX,OACA,YACoB,KAAK;CAAE,MAAM;CAAS;CAAO,GAAG;CAAS,CAAC;AAChE,MAAa,OACX,OACA,YACkB,KAAK;CAAE,MAAM;CAAO;CAAO,GAAG;CAAS,CAAC;AAC5D,MAAa,QACX,OACA,WACoB,KAAK;CAAE,MAAM;CAAQ,OAAO,OAAO;CAAO;CAAO,CAAC;AACxE,MAAa,QACX,UACoC,OAAO,OAAO;CAAE,MAAM;CAAiB;CAAO,CAAC;AAErF,MAAM,wBAAQ,IAAI,SAQf;AAEH,MAAM,aACJ,OACA,SACA,OACA,kBACW;CACX,MAAM,QAAQ,IAAI,MAChB,EAAE,EACF,EACE,MAAM,SAAS,aAA8B;AAC3C,MAAI,OAAO,aAAa,SAAU,QAAO,KAAA;EACzC,MAAM,QAAQ,MAAM,OAAM,SAAQ,KAAK,SAAS,OAAO;AACvD,MAAI,CAAC,iBAAiB,SAAS,aAAa,SAC1C,QAAO,UAAU,OAAO,SAAS,OAAO,EAAE,MAAM,QAAQ,CAAC;AAC3D,MAAI,CAAC,iBAAiB,SAAS,aAAa,QAC1C,QAAO,UAAU,OAAO,SAAS,OAAO,EAAE,MAAM,SAAS,CAAC;AAC5D,MAAI,eAAe,SAAS,WAAW,aAAa,OAClD,SAAQ,OAAe;AACrB,OAAI,OAAO,OAAO,SAAU,OAAM,IAAI,UAAU,kCAAkC;AAClF,UAAO,UAAU,OAAO,SAAS,OAAO;IAAE,MAAM;IAAQ;IAAI,CAAC;;AAEjE,MAAI,cAAe,OAAM,IAAI,UAAU,8BAA8B,WAAW;AAEhF,MADmB,MAAM,OAAM,SAAQ,oBAAoB,KAAK,KAAK,KAAA,EACvD,IAAI,aAAa,OAC7B,SAAQ,OAAe;AACrB,OAAI,OAAO,OAAO,SAAU,OAAM,IAAI,UAAU,mCAAmC;AACnF,QAAK,MAAM,QAAQ,MACjB,KAAI,KAAK,SAAS,WAAW,KAAK,SAAS,OAAO;IAChD,MAAM,UAAUA,eAAAA,SAAS,KAAK,KAAK,IAAI,CAAC,GAAG,SAAS,GAAG,CAAC;AACxD,QAAI,QAAS,OAAM,IAAI,UAAU,QAAQ,QAAQ;;AAErD,UAAO,UACL,MAAM,KAAI,SAAQ,oBAAoB,KAAK,CAAE,EAC7C,CAAC,GAAG,SAAS,GAAG,EAChB,MACD;;EAEL,MAAM,WAAW,MAAM,SAAQ,SAAQ;AACrC,OAAI,KAAK,SAAS,SAChB,QAAO,OAAO,OAAO,KAAK,OAAO,SAAS,GAAG,CAAC,KAAK,MAAM,UAAU,GAAG,EAAE;AAC1E,OAAI,KAAK,SAAS,UAAW,QAAO,EAAE;AACtC,OAAI,aAAa,KAAK,IAAK,QAAO,CAAC,OAAe,CAAC;AACnD,UAAO,OAAO,OAAO,KAAK,SAAS,CAAC,SAAQ,WAC1C,OAAO,OAAO,OAAO,OAAO,SAAS,GAAG,CAAC,OAAO,MAAM,UAAU,GAAG,EAAE,CACtE;IACD;AACF,MAAI,CAAC,SAAS,OAAQ,OAAM,IAAI,UAAU,gCAAgC,WAAW;AACrF,SAAO,UAAU,UAAU,CAAC,GAAG,SAAS,SAAS,EAAE,MAAM;IAE5D,CACF;AACD,OAAM,IAAI,OAAO;EAAE;EAAO;EAAS;EAAO,GAAI,gBAAgB,EAAE,MAAM,eAAe,GAAG,EAAE;EAAG,CAAC;AAC9F,QAAO;;AAGT,MAAa,eACX,OACA,MACA,SACuC;CACvC,MAAM,QAAQ,EAAE;CAChB,MAAM,QAAQ,KAAK,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,MAAM,CAAkB;CAClE,MAAM,WAAW,OAAO,UAAU,YAAY,UAAU,OAAO,MAAM,IAAI,MAAM,GAAG,KAAA;AAClF,KAAI,CAAC,YAAY,SAAS,UAAU,MAClC,OAAM,IAAI,UAAU,iDAAiD;CACvE,MAAM,aACJ,SAAS,MAAM,SAAS,WACxB,SAAS,MAAM,OAAM,SAAQ,oBAAoB,KAAK,KAAK,KAAA,EAAU;AACvE,KAAI,SAAS,gBAAgB,CAAC,WAC5B,OAAM,IAAI,UAAU,sEAAsE;AAQ5F,QANe,OAAO,OAAO;EAC3B,MAFmB,SAAS,SAAU,aAAa,eAAe,UAAW;EAG7E,QAAQ;EACR,SAAS,OAAO,OAAO,CAAC,GAAG,SAAS,QAAQ,CAAC;EAC7C,GAAI,SAAS,OAAO,EAAE,MAAM,OAAO,OAAO,EAAE,GAAG,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE;EACvE,CACY;;;;AC9Sf,IAAa,kBAAb,cAAqC,MAAM;CACzC,YACE,OACA,UACA,WACA,OACA;AACA,QAAM,cAAc,MAAM,WAAW,YAAY,EAAE,OAAO,CAAC;AALlD,OAAA,QAAA;AACA,OAAA,WAAA;AACA,OAAA,YAAA;AAIT,OAAK,OAAO;;;AAIhB,IAAa,0BAAb,cAA6C,MAAM;CACjD,cAAc;AACZ,QAAM,gCAAgC;AACtC,OAAK,OAAO;;;;;AC5DhB,MAAa,mBAAmB,YAA8C;CAC5E,IAAI,WAAW;CACf,IAAI,QAAQ;CACZ,IAAI,gBAAgB;CACpB,IAAI;CACJ,IAAI,QAAuC;CAC3C,IAAI,WAAW;CACf,MAAM,0BAAU,IAAI,KAA2B;CAC/C,MAAM,6BAAa,IAAI,KAAsB;CAC7C,MAAM,iCAAiB,IAAI,KAA2B;CACtD,MAAM,OAA0B,EAAE;CAClC,MAAM,yBAAS,IAAI,KAAsB;CACzC,MAAM,4BAAY,IAAI,KAAsB;CAC5C,MAAM,4BAAY,IAAI,KAAmB;CACzC,MAAM,SAA4B,EAAE;CACpC,IAAI,oBAA+B,EAAE;CACrC,MAAM,yBAAS,IAAI,KAAgC;CACnD,MAAM,2BAAW,IAAI,KAAiB;CAEtC,MAAM,qBAAqB;AACzB,MAAI,SAAU,OAAM,IAAI,yBAAyB;;CAEnD,MAAM,mBAAmB;AACvB,gBAAc;AACd,MAAI,UAAU,OACZ,OAAM,IAAI,MAAM,qEAAqE;;CAEzF,MAAM,QAAQ,UAAmB,OAAO,SAAQ,UAAS,MAAM,MAAM,CAAC;CAEtE,MAAM,WAAW,cAA+B;AAC9C,MAAI,UAAU,YAAY,OAAO,IAAI,UAAU,CAAE;AACjD,SAAO,IAAI,UAAU;AACrB,gBAAA,QAAQ,WAAW,iBAAiB;EACpC,IAAI,QAAQ,KAAK;AACjB,OAAK,KAAK,UAAU;AACpB,SAAO,QAAQ,GAAG;GAChB,MAAM,SAAU,QAAQ,KAAM;AAC9B,OAAI,KAAK,QAAQ,QAAQ,UAAU,MAAO;AAC1C,QAAK,SAAS,KAAK;AACnB,WAAQ;;AAEV,OAAK,SAAS;;CAGhB,MAAM,YAA6B;EACjC,MAAM,QAAQ,KAAK;EACnB,MAAM,OAAO,KAAK,KAAK;AACvB,MAAI,KAAK,QAAQ;GACf,IAAI,QAAQ;AACZ,UAAO,QAAQ,IAAI,IAAI,KAAK,QAAQ;IAClC,IAAI,QAAQ,QAAQ,IAAI;AACxB,QAAI,QAAQ,IAAI,KAAK,UAAU,KAAK,QAAQ,GAAG,QAAQ,KAAK,OAAO,MAAO;AAC1E,QAAI,KAAK,QAAQ,KAAK,OAAO,MAAO;AACpC,SAAK,SAAS,KAAK;AACnB,YAAQ;;AAEV,QAAK,SAAS;;AAEhB,SAAO;;CAGT,MAAM,eAAe,aACnB,SAAS,SAAS,cACd,SAAS,aAAa,KAAI,WAAU,OAAO,UAAU,CAAC,GACtD,SAAS,QAAQ,KAAI,WAAU,OAAO,UAAU,CAAC;CAEvD,MAAM,YACJ,UACA,OACA,OAAiC,SAAS,SAAS,WAAW,WAAW,gBACtE,IAAI,gBAAgB,MAAM,SAAS,MAAM,YAAY,SAAS,EAAE,MAAM;CAE3E,MAAM,WAAW,WAAiC;AAChD,MAAI,SAAU;AACd,MAAI,UAAU,QAAQ;AACpB,UAAO,QAAQ,SACb,wBACA,IAAI,MAAM,+CAA+C,EACzD,SACD;AACD,UAAO,KAAK,OAAO,MAAM;AACzB,SAAM,OAAO;;AAEf,iBAAe,IAAI,OAAO;AAC1B,gBAAA,QAAQ,WAAW,eAAe;AAClC,MAAI,OAAO,MAAO,QAAO,KAAK,OAAO,MAAM;;CAG7C,MAAM,oBAA6B;AACjC,MAAI,aAAa,UAAU,KAAA,EAAW,QAAO,YAAY;AACzD,OAAK,MAAM,UAAU,gBAAgB;GACnC,MAAM,QAAQ,OAAO,cAAc;AACnC,OAAI,UAAU,KAAA,EAAW,QAAO;;;CAKpC,MAAM,eAAe;AACnB,MAAI,YAAY,SAAS,UAAU,OAAQ;AAC3C,UAAQ;AACR,OAAK,KAAK;EACV,MAAM,QAAQ,aAAa;AAC3B,MAAI;AACF,QAAK,MAAM,UAAU,gBAAgB;AACnC,QAAI,OAAO,SAAU;IACrB,MAAM,aAAa,OAAO,UAAU,KAAA;IACpC,IAAI,UAAU;IACd,IAAI,QAAQ;AACZ,QAAI,CAAC,OAAO,SAAS,OAAO,YAAY,CACtC,KAAI;KACF,MAAM,WAAW,OAAO,QAAQ,MAAM;AACtC,eAAU,SAAS;AACnB,aAAQ,SAAS;AACjB,YAAO,QAAQ,KAAA;aACR,SAAS;AAChB,YAAO,QAAQ,SAAS,QAAQ,SAAS,SAAS;AAClD,YAAO,KAAK,OAAO,MAAM;;IAG7B,MAAM,YAAY,cAAc,CAAC,OAAO;AACxC,QAAI,QAAS,QAAO,SAAS;AAC7B,QAAI,OAAO,SAAS,WAAW,SAAS,WAAW;KACjD,MAAM,SAAS,OAAO,QAAQ;AAC9B,eAAU,IAAI,OAAO;AACrB,YAAO,UAAU,QAAQ,QAAQ;;;AAIrC,UAAO,KAAK,QAAQ;IAClB,MAAM,YAAY,KAAK;AACvB,QAAI,UAAU,SAAU;IACxB,MAAM,aAAa,UAAU,UAAU,KAAA;AACvC,kBAAA,QAAQ,WAAW,iBAAiB;IACpC,IAAI,iBAA0C,OAAO,OAAO,EAAE,CAAC;IAC/D,MAAM,UAAU,UAAU,aAAa,MACrC,WAAU,OAAO,MAAM,SAAS,OAAO,MAAM,SAC9C;AACD,QAAI,QACF,WAAU,QAAQ,SAChB,WACA,QAAQ,MAAM,SAAS,IAAI,yBAAyB,EACpD,UACD;SACI;KACL,MAAM,QAAQ,cAAc,UAAU,aAAa,MAAK,WAAU,OAAO,OAAO,CAAC;AACjF,SAAI;AACF,uBAAiB,UAAU,SAAS,OAAO,MAAM;MACjD,MAAM,oBAAoB,UAAU,aAAa,MAAK,WAAU,OAAO,MAAM,MAAM,EAC/E,MAAM;AACV,UAAI,kBAAmB,OAAM;AAC7B,gBAAU,QAAQ,KAAA;cACX,SAAS;MAChB,MAAM,QAAQ,SAAS,WAAW,QAAQ;AAC1C,gBAAU,QAAQ;AAClB,UAAI,CAAC,MACH,KAAI;AACF,wBAAiB,UAAU,SAAS,MAAM,MAAM;OAChD,MAAM,oBAAoB,UAAU,aAAa,MAAK,WAAU,OAAO,MAAM,MAAM,EAC/E,MAAM;AACV,WAAI,kBAAmB,OAAM;AAC7B,iBAAU,QAAQ,KAAA;AAClB,cAAO,KAAK,MAAM;eACX,gBAAgB;AACvB,iBAAU,QAAQ,SAAS,WAAW,eAAe;AACrD,cAAO,KAAK,UAAU,MAAM;;UAEzB,QAAO,KAAK,MAAM;;;AAG7B,cAAU,IAAI,UAAU;IACxB,MAAM,YAAY,cAAc,CAAC,UAAU;AAC3C,QAAI,UAAU,MACZ,WAAU,QAAQ,SAAQ,WAAU;AAClC,eAAU,IAAI,OAAO;AACrB,YAAO,UAAU,QAAQ,QAAQ;MACjC;SACG;AACL,SAAI,eAAe,QAAQ;AACzB,gBAAU,SAAS;AACnB,qBAAe,SAAQ,WAAU,UAAU,IAAI,OAAO,CAAC;;AAGzD,MADmB,YAAY,UAAU,UAAU,gBACxC,SAAQ,WAAU,OAAO,UAAU,QAAQ,QAAQ,CAAC;;AAEjE,QAAI,UAAU,SAAS,eAAe,OACpC,eAAA,QAAQ,WAAW,iBAAiB;;YAGhC;AACR,QAAK,MAAM;AACX,WAAQ;;;CAIZ,MAAM,cAAwC;AAC5C,MAAI,YAAY,MAAO,QAAO,EAAE;AAChC,MAAI,eAAe,QAAQ,UAAU,KAAM,eAAA,QAAQ,WAAW,UAAU;AACxE,UAAQ;AACR,OAAK,KAAK;EACV,MAAM,iBAA4B,EAAE;AACpC,MAAI;AACF,aAAU,SAAQ,WAChB,OAAO,MAAK,aAAY;AACtB,QAAI;AACF,eAAU;aACH,OAAO;AACd,YAAO,KAAK,SAAS,OAAO,OAAO,OAAO,WAAW,CAAC;;KAExD,CACH;AACD,QAAK,MAAM,SAAS,OAAO,OAAO,CAChC,KAAI;AACF,YAAQ,MAAM;YACP,OAAO;AACd,mBAAe,KAAK,MAAM;;AAG9B,UAAO,OAAO,OAAO,CACnB,GAAG,OAAO,KAAI,UACZ,OAAO,OAAO;IACZ,OAAO,MAAM,UAAU,aAAc,aAAwB;IAC7D;IACD,CAAC,CACH,EACD,GAAG,eAAe,KAAI,UAAS,OAAO,OAAO;IAAE,OAAO;IAAqB;IAAO,CAAC,CAAC,CACrF,CAAC;YACM;AACR,kBAAe,SAAQ,WAAU,OAAO,OAAO,CAAC;AAChD,aAAU,SAAQ,cAAa,UAAU,OAAO,CAAC;AACjD,kBAAe,OAAO;AACtB,UAAO,OAAO;AACd,aAAU,OAAO;AACjB,aAAU,OAAO;AACjB,UAAO,SAAS;AAChB,uBAAoB;AACpB,QAAK,MAAM;AACX,WAAQ;;;CAIZ,MAAM,YAAY;AAChB,UAAQ;EACR,MAAM,SAAS,OAAO;EACtB,MAAM,WAAW;AACjB,sBAAoB,EAAE;AACtB,MAAI,SAAS,OAAQ,OAAM,IAAI,eAAe,UAAU,oCAAoC;AAC5F,SAAO;;CAGT,MAAM,SAAY,mBAA6C,kBAA+B;AAC5F,cAAY;EACZ,MAAM,UAAU,OAAO,sBAAsB,aAAa,KAAA,IAAY;EACtE,MAAM,WAAW,OAAO,sBAAsB,aAAa,oBAAoB;AAC/E,MAAI,CAAC,SAAU,OAAM,IAAI,UAAU,wCAAwC;AAE3E,MADc,UAAU,EAEtB,eAAc,OAAO,OAAO;GAC1B,IAAI,EAAE;GACN,GAAI,SAAS,UAAU,KAAA,IAAY,EAAE,GAAG,EAAE,OAAO,QAAQ,OAAO;GACjE,CAAC;AACJ;EACA,IAAI,SAAS;AACb,MAAI;GACF,MAAM,QAAQ,UAAU;AACxB,qBAAkB,MAAM;AACxB,UAAO;WACA,OAAO;AACd,YAAS;AACT,SAAM;YACE;AACR;AACA,OAAI,CAAC,MACH,KAAI;AACF,QAAI,OACF,KAAI;AACF,UAAK;YACC;QAGH,MAAK;aACJ;AACR,kBAAc,KAAA;;;;CAMtB,MAAM,mBAAmB,aAA6B;AACpD,cAAY;AACZ,MAAI,SAAS,QAAQ,MAAK,WAAU,OAAO,UAAU,KAAK,CACxD,OAAM,IAAI,MAAM,0DAA0D;AAC5E,WAAS,WAAW;AACpB,MAAI,SAAS,SAAS,aAAa;AACjC,YAAS,aAAa,SAAQ,WAAU,OAAO,UAAU,OAAO,SAAS,CAAC;AAC1E,cAAW,OAAO,SAAS;AAC3B,UAAO,OAAO,SAAS;AACvB,aAAU,OAAO,SAAS;SACrB;AACL,WAAQ,OAAO,SAAS;AACxB,kBAAe,OAAO,SAAS;;AAEjC,WAAS,SAAS;AAClB,WAAS,OAAO;AAChB,WAAS,QAAQ,SAAQ,WAAU,UAAU,OAAO,OAAO,CAAC;;AAG9D,QAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,IAAI,SAAS;AACX,UAAO,CAAC;;EAEV,UAAU,QAA8B;AACtC,eAAY;AACZ,WAAQ,IAAI,OAAO;;EAErB,aAAa,WAA4B;AACvC,eAAY;AACZ,cAAW,IAAI,UAAU;AACzB,aAAU,aAAa,SAAQ,WAAU,OAAO,UAAU,IAAI,UAAU,CAAC;;EAE3E;EACA,aAAa;EACb,WAAc,UAAsB;AAClC,eAAY;AACZ,WAAQ;AACR,QAAK,KAAK;AACV,OAAI;AACF,WAAO,UAAU;aACT;AACR,SAAK,MAAM;AACX,YAAQ;;;EAGZ;EACA,oBAAoB;EACpB,UAAU;AACR,OAAI,SAAU;AACd,eAAY;AACZ,cAAW;GACX,MAAM,WAAsB,EAAE;AAC9B,YAAS,SAAQ,YAAW;AAC1B,QAAI;AACF,cAAS;aACF,OAAO;AACd,cAAS,KAAK,MAAM;;KAEtB;AACF,YAAS,OAAO;AAChB,cAAW,SAAQ,cAAa;AAC9B,cAAU,WAAW;AACrB,QAAI;AACF,eAAU,SAAS;aACZ,OAAO;AACd,cAAS,KAAK,MAAM;;KAEtB;AACF,WAAQ,SAAQ,WAAU;AACxB,WAAO,WAAW;AAClB,QAAI;AACF,YAAO,SAAS;aACT,OAAO;AACd,cAAS,KAAK,MAAM;;KAEtB;AACF,cAAW,OAAO;AAClB,WAAQ,OAAO;AACf,kBAAe,OAAO;AACtB,QAAK,SAAS;AACd,UAAO,OAAO;AACd,aAAU,OAAO;AACjB,aAAU,OAAO;AACjB,UAAO,OAAO;AACd,UAAO,SAAS;AAChB,uBAAoB,EAAE;AACtB,OAAI,SAAS,OAAQ,OAAM,IAAI,eAAe,UAAU,6BAA6B;;EAExF;;AAKH,MAAa,qBAAqB,UAAyB;AACzD,KACE,SAAS,SACR,OAAO,UAAU,YAAY,OAAO,UAAU,eAC/C,UAAU,SACV,OAAO,MAAM,SAAS,WAEtB,OAAM,IAAI,UAAU,4CAA4C;;AAGpE,MAAa,eAAe,WAA0B;AACpD,KAAI,CAAC,QAAQ,CAAE,OAAM,IAAI,MAAM,mDAAmD;;;;AC7apF,MAAM,UAA+B,SAA6C,MAAM,UAAU;AAElG,MAAM,gBACJ,KACA,OACA,MACA,UAEA,OAAO,OAAO;CACZ;CACA;CACA;CACA;CACA,QAAQ,KAAK,IAAI,OAAO,KAAK,EAAE,OAAO,MAAM,CAAC,GAAG;CACjD,CAAC;AAEJ,MAAM,cAAmC,SAAyC;CAChF,MAAM,QAAQ,KAAK;AACnB,QAAO,aACL,MAAM,KACN,MAAM,OACN,aAAa,KAAK,KAAK,KAAK,OAAO,KAAK,MAAM,MAAM,KAAK,EACzD,MAAM,MACP;;AAGH,MAAM,eAAoC,SAAyC;CACjF,MAAM,OAAO,KAAK;AAClB,QAAO,aACL,KAAK,KACL,KAAK,OACL,KAAK,MACL,aAAa,KAAK,KAAK,KAAK,OAAO,KAAK,OAAO,KAAK,MAAM,CAC3D;;AAGH,MAAM,aAAkC,SAAyC;CAC/E,MAAM,UAAU,OAAO,KAAK,KAAK,GAAG,OAAO,KAAK,MAAM;AACtD,KAAI,UAAU,GAAG;AACf,MAAI,OAAO,KAAK,KAAM,KAAK,GAAG,OAAO,KAAK,KAAM,MAAM,CACpD,QAAO,YAAY,aAAa,KAAK,KAAK,KAAK,OAAO,WAAW,KAAK,KAAM,EAAE,KAAK,MAAM,CAAC;AAC5F,SAAO,YAAY,KAAK;;AAE1B,KAAI,UAAU,IAAI;AAChB,MAAI,OAAO,KAAK,MAAO,MAAM,GAAG,OAAO,KAAK,MAAO,KAAK,CACtD,QAAO,WAAW,aAAa,KAAK,KAAK,KAAK,OAAO,KAAK,MAAM,YAAY,KAAK,MAAO,CAAC,CAAC;AAC5F,SAAO,WAAW,KAAK;;AAEzB,QAAO;;AAGT,MAAM,WACJ,MACA,KACA,UACmB;AACnB,KAAI,CAAC,KAAM,QAAO,aAAa,KAAK,MAAM;AAC1C,KAAI,QAAQ,KAAK,IAAK,QAAO,aAAa,KAAK,OAAO,KAAK,MAAM,KAAK,MAAM;AAC5E,KAAI,MAAM,KAAK,IACb,QAAO,UACL,aAAa,KAAK,KAAK,KAAK,OAAO,QAAQ,KAAK,MAAM,KAAK,MAAM,EAAE,KAAK,MAAM,CAC/E;AACH,QAAO,UAAU,aAAa,KAAK,KAAK,KAAK,OAAO,KAAK,MAAM,QAAQ,KAAK,OAAO,KAAK,MAAM,CAAC,CAAC;;AAGlG,MAAM,WAAgC,SACpC,KAAK,OAAO,QAAQ,KAAK,KAAK,GAAG;AAEnC,MAAM,cACJ,MACA,QAC+B;AAC/B,KAAI,CAAC,KAAM,QAAO,KAAA;AAClB,KAAI,MAAM,KAAK,IACb,QAAO,UAAU,aAAa,KAAK,KAAK,KAAK,OAAO,WAAW,KAAK,MAAM,IAAI,EAAE,KAAK,MAAM,CAAC;AAC9F,KAAI,MAAM,KAAK,IACb,QAAO,UAAU,aAAa,KAAK,KAAK,KAAK,OAAO,KAAK,MAAM,WAAW,KAAK,OAAO,IAAI,CAAC,CAAC;AAC9F,KAAI,CAAC,KAAK,KAAM,QAAO,KAAK;AAC5B,KAAI,CAAC,KAAK,MAAO,QAAO,KAAK;CAC7B,MAAM,OAAO,QAAQ,KAAK,MAAM;AAChC,QAAO,UAAU,aAAa,KAAK,KAAK,KAAK,OAAO,KAAK,MAAM,WAAW,KAAK,OAAO,KAAK,IAAI,CAAC,CAAC;;AAGnG,MAAM,WAAgC,MAAkC,QAA0B;CAChG,IAAI,UAAU;AACd,QAAO,SAAS;AACd,MAAI,QAAQ,QAAQ,IAAK,QAAO,QAAQ;AACxC,YAAU,MAAM,QAAQ,MAAM,QAAQ,OAAO,QAAQ;;;AAKzD,MAAM,WAAgC,MAAkC,QAAoB;CAC1F,IAAI,UAAU;AACd,QAAO,SAAS;AACd,MAAI,QAAQ,QAAQ,IAAK,QAAO;AAChC,YAAU,MAAM,QAAQ,MAAM,QAAQ,OAAO,QAAQ;;AAEvD,QAAO;;AAGT,MAAM,kBACJ,SACA,QAAQ,GACR,MAAM,QAAQ,WACiB;AAC/B,KAAI,SAAS,IAAK,QAAO,KAAA;CACzB,MAAM,SAAU,QAAQ,OAAQ;CAChC,MAAM,CAAC,KAAK,SAAS,QAAQ;AAC7B,QAAO,aACL,KACA,OACA,eAAe,SAAS,OAAO,OAAO,EACtC,eAAe,SAAS,SAAS,GAAG,IAAI,CACzC;;;AAyBH,MAAa,+BAAiF;CAC5F,MAAM,yBAAS,IAAI,KAAW;CAC9B,IAAI,MAAoB,OAAO,OAAO,EAAE,CAAC;CACzC,IAAI,yBAAS,IAAI,KAAkB;CACnC,IAAI,UAAU;CACd,IAAI;CACJ,IAAI,cAAc;CAClB,IAAI,QAAQ;CACZ,IAAI,WAAW;CACf,IAAI;CACJ,IAAI;CACJ,IAAI,UAAU;CACd,MAAM,4BAAY,IAAI,KAA+C;CAErE,MAAM,WAAW,QACf,OAAO,IAAI,IAAI,GAAG,OAAO,IAAI,IAAI,CAAE,UAAU,CAAC,WAAW,OAAO,IAAI,IAAI;CAC1E,MAAM,WAAW,QAA0B;EACzC,MAAM,QAAQ,OAAO,IAAI,IAAI;AAC7B,SAAO,QACH,MAAM,UACJ,MAAM,QACN,KAAA,IACF,UACE,KAAA,IACA,OAAO,IAAI,IAAI;;CAEvB,MAAM,kBAAgC;EACpC,MAAM,SAAS,UAAU,EAAE,GAAG,IAAI,OAAO,QAAQ;AACjD,OAAK,MAAM,CAAC,KAAK,UAAU,OACzB,KAAI,MAAM,YAAY,WAAW,CAAC,OAAO,IAAI,IAAI,EAAG,QAAO,KAAK,IAAI;AACtE,SAAO;;CAGT,MAAM,SAAS,QAAuB,eAA0D;AAC9F,2BAAS,IAAI,KAAK;AAClB,YAAU;AACV,WAAS,KAAA;AACT,kBAAgB,KAAA;AAChB,YAAU;AACV,UAAQ;EACR,MAAM,QAAQ,UAAyC;GACrD,MAAK,QAAO;AACV,gBAAY,OAAO;AACnB,WAAO,OAAO,QAAQ,IAAI,GAAG,OAAO,IAAI,IAAI;;GAE9C,MAAK,QAAO;AACV,gBAAY,OAAO;AACnB,WAAO,OAAO,QAAQ,IAAI,GAAG,OAAO,IAAI,IAAI;;GAE9C,WAAW;AACT,gBAAY,OAAO;AACnB,WAAO,OAAO,OAAO,OAAO,gBAAgB,CAAC,GAAG,cAAc,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC,GAAG;;GAExF;AAgBD,SAAO;GAAE,UAAU,KAAK,MAAM;GAAE,MAAM,KAAK,KAAK;GAAE,QAAA;IAdhD,MAAM,KAAK,UAAU;AACnB,iBAAY,OAAO;AACnB,SAAI,OAAO,QAAQ,SAAU,OAAM,IAAI,UAAU,mCAAmC;AACpF,YAAO,IAAI,KAAK;MAAE,SAAS;MAAM;MAAO,CAAC;;IAE3C,SAAQ,QAAO;AACb,iBAAY,OAAO;AACnB,YAAO,IAAI,KAAK,EAAE,SAAS,OAAO,CAAC;;IAErC,QAAO,UAAS;AACd,iBAAY,OAAO;AACnB,qBAAgB,OAAO,OAAO,CAAC,GAAG,MAAM,CAAC;;IAGW;GAAE;;CAG5D,MAAM,QAAQ,WAAoB,YAAwD;AACxF,MAAI;QACG,MAAM,OAAO,OAAO,MAAM,CAAE,KAAI,CAAC,OAAO,IAAI,IAAI,CAAE,QAAO,IAAI,KAAK,EAAE,SAAS,OAAO,CAAC;;AAE5F,gBAAA,QAAQ,WAAW,eAAe,OAAO,KAAK;EAC9C,MAAM,wBAAQ,IAAI,KAAQ;EAC1B,MAAM,0BAAU,IAAI,KAAQ;EAC5B,MAAM,0BAAU,IAAI,KAAQ;AAC5B,OAAK,MAAM,CAAC,KAAK,UAAU,QAAQ;GACjC,MAAM,UAAU,OAAO,IAAI,IAAI;AAC/B,OAAI,MAAM;QACJ,CAAC,QAAS,OAAM,IAAI,IAAI;aACnB,CAAC,QAAQ,OAAO,IAAI,IAAI,EAAO,MAAM,MAAM,CAAE,SAAQ,IAAI,IAAI;aAC7D,CAAC,UAAW,QAAO,OAAO,IAAI;cAC9B,QAAS,SAAQ,IAAI,IAAI;OAC/B,QAAO,OAAO,IAAI;;AAGzB,MAAI,iBAAiB,MAAM,QAAQ,QAAQ,MAAM;GAC/C,MAAM,QAAQ,iBAAiB,CAAC,GAAG,IAAI,QAAO,QAAO,CAAC,QAAQ,IAAI,IAAI,CAAC,EAAE,GAAG,MAAM;AAElF,OACE,IAFe,IAAI,MAEf,CAAC,SAAS,MAAM,UACpB,MAAM,WAAW,OAAO,OAAO,MAAM,OAAO,QAAQ,QACpD,MAAM,MAAK,QAAO,CAAC,QAAQ,IAAI,CAAC,CAEhC,OAAM,IAAI,UAAU,wDAAwD;AAC9E,aACE,IAAI,WAAW,MAAM,UAAU,IAAI,OAAO,KAAK,UAAU,QAAQ,MAAM,OAAO,GAC1E,MACA,OAAO,OAAO,CAAC,GAAG,MAAM,CAAC;QAC1B,WAAU;EAEjB,MAAM,cAAc,IAAI,IAAO;GAAC,GAAG;GAAO,GAAG;GAAS,GAAG;GAAQ,CAAC;AAClE,gBAAA,QAAQ,WAAW,eAAe,YAAY,KAAK;EACnD,MAAM,eAAyD,EAAE;EACjE,MAAM,iBAIA,EAAE;EACR,MAAM,iBAA4D,EAAE;AACpE,OAAK,MAAM,OAAO,aAAa;GAC7B,MAAM,gBAAgB,OAAO,IAAI,IAAI;GACrC,MAAM,eAAe,QAAQ,IAAI;AACjC,OAAI,kBAAkB;QAChB,CAAC,iBAAiB,QAAQ,OAAO,IAAI,IAAI,EAAO,QAAQ,IAAI,CAAM,CAAE;;AAE1E,OAAI,CAAC,cAAe,cAAa,KAAK;IAAE;IAAK,OAAO,QAAQ,IAAI;IAAO,CAAC;YAC/D,CAAC,aAAc,gBAAe,KAAK;IAAE;IAAK,QAAQ,OAAO,IAAI,IAAI;IAAO,CAAC;OAEhF,gBAAe,KAAK;IAClB;IACA,QAAQ,OAAO,IAAI,IAAI;IACvB,OAAO,QAAQ,IAAI;IACpB,CAAC;;EAGN,MAAM,eAAe,YAAY;AACjC,MAAI,UAAW,UAAS,OAAO,OAAO,EAAE,MAAM,SAAkB,CAAC;WAE/D,aAAa,UACb,eAAe,UACf,eAAe,UACf,cACA;GACA,IAAI,qBAAqB;AACzB,OAAI,cAAc;IAChB,MAAM,SAAS,IAAI,QAAO,QAAO,CAAC,QAAQ,IAAI,IAAI,CAAC;IACnD,MAAM,QAAQ,QAAQ,QAAO,QAAO,CAAC,MAAM,IAAI,IAAI,CAAC;AACpD,yBAAqB,OAAO,MAAM,KAAK,UAAU,MAAM,WAAW,IAAI;;AAExE,YAAS,OAAO,OAAO;IACrB,MAAM;IACN,OAAO,OAAO,OAAO,aAAa;IAClC,SAAS,OAAO,OAAO,eAAe;IACtC,SAAS,OAAO,OAAO,eAAe;IACtC,GAAI,qBACA,EACE,OAAO,OAAO,OAAO;KACnB,QAAQ,OAAO,OAAO,CAAC,GAAG,IAAI,CAAC;KAC/B,OAAO,OAAO,OAAO,CAAC,GAAG,QAAQ,CAAC;KACnC,CAAC,EACH,GACD,EAAE;IACP,CAAC;;AAEJ,UAAQ;AACR,SAAO,WAAW,KAAA;;CAGpB,MAAM,WAAW,QAAuB,UACtC,OAAO,OAAO;EACZ,MAAM;EACN,MAAM;GACJ,MAAK,QAAO;AACV,gBAAY,OAAO;AACnB,WAAO,QAAQ,IAAI;;GAErB,MAAK,QAAO;AACV,gBAAY,OAAO;AACnB,WAAO,QAAQ,IAAI;;GAErB,WAAW;AACT,gBAAY,OAAO;AACnB,WAAO;;GAEV;EACD;EACA;EACA;EACA;EACD,CAAC;CAEJ,MAAM,WAAW,UAA4C;EAC3D,MAAM,OAAO;EACb,MAAM,eAAe;AACrB,SAAO,OAAO,OAAO;GACnB,MAAK,QAAO;AACV,WAAO;AACP,WAAO,QAAQ,MAAM,IAAI;;GAE3B,MAAK,QAAO;AACV,WAAO;AACP,WAAO,QAAQ,MAAM,IAAI;;GAE3B,WAAW;AACT,WAAO;AACP,WAAO;;GAEV,CAAC;;AAGJ,QAAO;EACL;EACA;EACA;EACA;EACA,gBAAgB;EAChB,aAAa;EACb,eAAe;AACb,OAAI,OACF,KAAI,OAAO,SAAS,SAAS;IAC3B,MAAM,UAAoB,EAAE;AAC5B,SAAK,MAAM,CAAC,KAAK,UAAU,OAAQ,KAAI,MAAM,QAAS,SAAQ,KAAK,CAAC,KAAK,MAAM,MAAM,CAAC;AACtF,YAAQ,MAAM,CAAC,OAAO,CAAC,WAAY,OAAO,QAAQ,KAAK,OAAO,QAAQ,IAAI,EAAG;AAC7E,oBAAgB,eAAe,QAAQ;SAEvC,MAAK,MAAM,CAAC,KAAK,UAAU,OACzB,iBAAgB,MAAM,UAClB,QAAQ,eAAe,KAAK,MAAM,MAAM,GACxC,WAAW,eAAe,IAAI;AAGxC,QAAK,MAAM,CAAC,KAAK,UAAU,OACzB,KAAI,MAAM,QAAS,QAAO,IAAI,KAAK,MAAM,MAAM;OAC1C,QAAO,OAAO,IAAI;AAEzB,OAAI,UAAU,YAAa;AAC3B,SAAM;AACN,iBAAc;;EAEhB,OAAM,SAAQ;GACZ,MAAM,aAAa,OAAO,OAAO,EAAE,MAAM,SAAkB,CAAC;AAC5D,SAAM,KAAK,UAAU,CAAC,SAAQ,aAAY,WAAW,SAAS,UAAU,WAAW,CAAC,CAAC;;EAEvF,aAAa;AACX,UAAO,OAAO;AACd,aAAU;AACV,YAAS,KAAA;AACT,WAAQ;AACR,mBAAgB,KAAA;AAChB,aAAU;;EAEZ,eAAe;AACb,UAAO,OAAO;AACd,UAAO,OAAO;AACd,mBAAgB,KAAA;AAChB,aAAU,OAAO;AACjB,SAAM,UAAU,OAAO,OAAO,EAAE,CAAC;AACjC,YAAS,KAAA;AACT,iBAAc;AACd,cAAW;AACX,WAAQ;AACR,mBAAgB,KAAA;AAChB,aAAU;;EAEZ,YAAW,aAAY,UAAU,IAAI,SAAS;EAC9C,cAAa,aAAY,UAAU,OAAO,SAAS;EACpD;;AAGH,MAAa,WAAgC,WAAoD;CAC/F,MAAK,QAAO,MAAM,IAAI,IAAI;CAC1B,MAAK,QAAO,MAAM,IAAI,IAAI;CAC1B,WAAW,OAAO,OAAO,CAAC,GAAG,MAAM,MAAM,CAAC,CAAC;CAC5C;;AAGD,MAAa,kBACX,SACsB;CACtB,MAAM,MAAM,KAAK,KAAK;CACtB,MAAM,UAAU,aAAuC;AACrD,OAAK,MAAM,OAAO,IAAK,OAAM,CAAC,KAAK,KAAK,IAAI,IAAI,CAAM;;CAExD,MAAM,SAAS,aAAkC;AAC/C,OAAK,MAAM,OAAO,IAAK,OAAM,KAAK,IAAI,IAAI;;CAE5C,MAAM,OAA0B;EAC9B,MAAK,QAAO,KAAK,IAAI,IAAI;EACzB,MAAK,QAAO,KAAK,IAAI,IAAI;EACzB,IAAI,OAAO;AACT,UAAO,IAAI;;EAEb,YAAY,IAAI,OAAO,WAAW;EAClC;EACA;EACA,UAAU,UAAU,YAAY;AAC9B,QAAK,MAAM,OAAO,IAAK,UAAS,KAAK,SAAS,KAAK,IAAI,IAAI,EAAO,KAAK,KAAK;;GAE7E,OAAO,WAAW;EACpB;AACD,QAAO,OAAO,OAAO,KAAK;;;AAI5B,MAAa,0BACX,SACsB;CACtB,MAAM,MAAM,KAAK,KAAK;CACtB,MAAM,yBAAS,IAAI,KAAW;AAC9B,MAAK,MAAM,OAAO,IAAK,QAAO,IAAI,KAAK,KAAK,IAAI,IAAI,CAAM;AAC1D,QAAO,eAAe,QAAQ,OAAO,CAAC;;;;;;AAcxC,MAAa,uBACX,OACA,MACA,QACA,YACY;CACZ,MAAM,aAAa,MAAM,MAAM,QAAQ,QAAQ,MAAM;AACrD,KAAI,QAAQ,OAAO;EACjB,MAAM,MAAM,KAAK,KAAK;AACtB,gBAAA,QAAQ,eAAe,WAAW,IAAI,OAAO;AAC7C,OAAK,MAAM,OAAO,KAAK;AACrB,iBAAA,QAAQ,eAAe,QAAQ;AAC/B,cAAW,OAAO,IAAI,KAAK,KAAK,IAAI,IAAI,CAAM;;AAEhD,aAAW,OAAO,MAAM,IAAI;QACvB;EACL,MAAM,WAAW,MAAM,cAAc,KAAA,EAAU;EAC/C,MAAM,OAAO,QAAQ,aACjB,CAAC,GAAG,IAAI,IAAI,QAAQ,WAAW,CAAC,GAChC,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,SAAS,KAAK,EAAE,GAAG,KAAK,KAAK,CAAC,CAAC,CAAC;AACpD,MAAI,CAAC,QAAQ,WAAY,eAAA,QAAQ,eAAe,WAAW,KAAK,OAAO;AACvE,OAAK,MAAM,OAAO,KAChB,KAAI,KAAK,IAAI,IAAI,EAAE;AACjB,iBAAA,QAAQ,eAAe,QAAQ;AAC/B,cAAW,OAAO,IAAI,KAAK,KAAK,IAAI,IAAI,CAAM;QACzC,YAAW,OAAO,OAAO,IAAI;AAEtC,MAAI,QAAQ,kBAAkB,CAAC,QAAQ,YAAY;GACjD,MAAM,MAAM,KAAK,KAAK;AACtB,OAAI,QAAQ,WAAY,eAAA,QAAQ,eAAe,WAAW,IAAI,OAAO;AACrE,cAAW,OAAO,MAAM,IAAI;;;AAGhC,QAAO,MAAM,KAAK,QAAQ,OAAO,QAAQ,WAAW,OAAO,GAAG;;;AAIhE,MAAa,2BACX,UACA,SACA,UAA6C,OAAO,OACb;CACvC,MAAM,QAAkD,EAAE;CAC1D,MAAM,UAAqD,EAAE;CAC7D,MAAM,UAAwE,EAAE;AAChF,MAAK,MAAM,CAAC,KAAK,WAAW,SAC1B,KAAI,CAAC,QAAQ,IAAI,IAAI,CAAE,SAAQ,KAAK;EAAE;EAAK;EAAQ,CAAC;MAC/C;EACH,MAAM,QAAQ,QAAQ,IAAI,IAAI;AAC9B,MAAI,CAAC,QAAQ,QAAQ,MAAM,CAAE,SAAQ,KAAK;GAAE;GAAK;GAAQ;GAAO,CAAC;;AAGrE,MAAK,MAAM,CAAC,KAAK,UAAU,QAAS,KAAI,CAAC,SAAS,IAAI,IAAI,CAAE,OAAM,KAAK;EAAE;EAAK;EAAO,CAAC;CACtF,MAAM,aAAa,IAAI,IAAI,SAAS,MAAM,CAAC;CAC3C,MAAM,YAAY,IAAI,IAAI,QAAQ,MAAM,CAAC;CACzC,MAAM,eAAe,CAAC,GAAG,SAAS,MAAM,CAAC,CAAC,QAAO,QAAO,UAAU,IAAI,IAAI,CAAC;CAC3E,MAAM,cAAc,CAAC,GAAG,QAAQ,MAAM,CAAC,CAAC,QAAO,QAAO,WAAW,IAAI,IAAI,CAAC;CAC1E,MAAM,eAAe,aAAa,MAAM,KAAK,UAAU,YAAY,WAAW,IAAI;AAClF,KAAI,CAAC,MAAM,UAAU,CAAC,QAAQ,UAAU,CAAC,QAAQ,UAAU,CAAC,aAAc,QAAO,KAAA;AACjF,QAAO,OAAO,OAAO;EACnB,MAAM;EACN,OAAO,OAAO,OAAO,MAAM;EAC3B,SAAS,OAAO,OAAO,QAAQ;EAC/B,SAAS,OAAO,OAAO,QAAQ;EAC/B,GAAI,eACA,EACE,OAAO,OAAO,OAAO;GACnB,QAAQ,OAAO,OAAO,CAAC,GAAG,SAAS,MAAM,CAAC,CAAC;GAC3C,OAAO,OAAO,OAAO,CAAC,GAAG,QAAQ,MAAM,CAAC,CAAC;GAC1C,CAAC,EACH,GACD,EAAE;EACP,CAAC;;;;ACvZJ,MAAM,8BAAc,IAAI,SAAgC;AAExD,MAAM,aACJ,UACA,WACqB;CACrB,MAAM,SAAS,OAAO,OAAO,EAAE,CAAC;AAChC,aAAY,IAAI,QAAQ,OAAO,OAAO;EAAE;EAAU;EAAQ,CAAC,CAAC;AAC5D,QAAO;;AAGT,MAAa,iBAAiB,eAA4D;CACxF,MAAM,MAAM,YAAY,IAAI,WAAW;AACvC,KAAI,CAAC,IAAK,OAAM,IAAI,UAAU,iCAAiC;AAC/D,QAAO;;AAGT,MAAa,cAAc,eACzB,cAAc,WAAW,CAAC;AAE5B,MAAa,gBAAgB,UAC3B,UAAU,QAAQ,OAAO,UAAU,YAAY,YAAY,IAAI,MAAM;AAEvE,MAAa,iBACX,YACA,UACM;CACN,MAAM,WAAW,WAAW,WAAW;AACvC,KAAI,SAAS,UAAU,KAAA,KAAa,SAAS,UAAU,MACrD,OAAM,IAAI,UAAU,wDAAwD;AAC9E,KAAI,SAAS,SAAS,YACpB,MAAK,MAAM,cAAc,SAAS,cAAc;EAC9C,MAAM,kBAAkB,WAAW,WAAW,CAAC;AAC/C,MAAI,oBAAoB,KAAA,KAAa,oBAAoB,MACvD,OAAM,IAAI,UAAU,0CAA0C;;AAGpE,UAAS,QAAQ;AACjB,QAAO;;AAGT,MAAM,gBAAgB,WACpB,OAAO,OAAO;CACZ,MAAM,OAAO;CACb,UAAU,OAAO;CACjB,GAAI,OAAO,OAAO,EAAE,MAAM,OAAO,OAAO,CAAC,GAAG,OAAO,KAAK,CAAC,EAAE,GAAG,EAAE;CACjE,CAAC;AAEJ,MAAa,mBAAmB,eAKe;AAC7C,KAAI,CAAC,MAAM,QAAQ,WAAW,aAAa,CACzC,OAAM,IAAI,UAAU,4CAA4C;AAClE,YAAW,aAAa,QAAQ,cAAc;AAC9C,KAAI,CAAC,WAAW,QAAQ,OAAQ,OAAM,IAAI,UAAU,2CAA2C;CAC/F,MAAM,WAAgC;EACpC,MAAM;EACN,cAAc,OAAO,OAAO,CAAC,GAAG,WAAW,aAAa,CAAC;EACzD,SAAS,OAAO,OAAO,WAAW,QAAQ,IAAI,aAAa,CAAC;EAC5D,QAAQ,WAAW;EACnB,GAAI,WAAW,OAAO,EAAE,MAAM,WAAW,MAAM,GAAG,EAAE;EACrD;AACD,QAAO,OAAO,OACZ,SAAS,QAAQ,KAAK,GAAG,WAAW,UAA4B,UAAU,OAAO,CAAC,CACnF;;AAGH,MAAM,gBACJ,QACA,WACqB;AAMrB,QAAO,UAAgB;EAJrB,MAAM;EACN;EACA,QAAQ,aAAa,OAAO;EAEC,EAAE,EAAE;;AAGrC,MAAM,eAAe,WACnB,OAAO,SAAS,UAAU,OAAO,QAAQ,uBAAuB,OAAO,KAAK;AAE9E,MAAM,cACJ,SACA,WAA8C,OAAO,OAErD,aACE;CAAE,MAAM;CAAe;CAAmB;CAAsB,EAChE;CAAE,MAAM;CAAmB;CAAsB,CAClD;AAEH,MAAM,mBACJ,0BAA6B,IAAI,KAAW,KACS;CACrD,MAAM,0BAAU,IAAI,KAAsB;AAC1C,MAAK,MAAM,CAAC,KAAK,UAAU,SAAS;AAClC,MAAI,OAAO,QAAQ,SAAU,OAAM,IAAI,UAAU,mCAAmC;AACpF,UAAQ,IAAI,KAAK,MAAM;;AAEzB,QAAO,aACL;EAAE,MAAM;EAAoB,SAAS;EAAS,EAC9C;EAAE,MAAM;EAAc,UAAU,OAAO;EAAI,CAC5C;;AAGH,MAAa,QAAQ,OAAO,OAAO,YAAY,EAAE,YAAY,iBAAiB,CAAC;AAoB/E,SAAgB,QACd,QAKA,UAC8B;AAC9B,KAAI,iBAAiB,OAAO,CAC1B,QAAO,OAAO,SAAS,eACnB,aACE;EAAE,MAAM;EAAuB;EAAQ,EACvC;EAAE,MAAM;EAAc,UAAU,OAAO;EAAI,CAC5C,GACD,aACE;EAAE,MAAM;EAAkB;EAAQ,UAAU,OAAO;EAAI,EACvD;EAAE,MAAM;EAAS,UAAU,OAAO;EAAI,CACvC;AACP,KAAI,aAAa,UAAU,OAAO,OAAO,YAAY,WACnD,QAAO,aACL;EAAE,MAAM;EAAY,UAAU;EAA6B,UAAU,OAAO;EAAI,EAChF;EAAE,MAAM;EAAS,UAAU,OAAO;EAAI,CACvC;CAEH,MAAM,WAAW;CACjB,MAAM,QAAQC,eAAAA,SAAS,SAAS;CAChC,MAAM,WAAW,WACb,YAAY,MAAM,QAAQ,QAAQ,SAAkB,GACnD,OAAO,OAAO;EACb,MAAM;EACN,QAAQ,MAAM;EACd,SAAS,OAAO,OAAO,EAAE,CAAC;EAC3B,CAAC;AACN,QAAO,aACL;EAAE,MAAM;EAAY;EAAU,UAAU;EAAU,EAClD;EAAE,MAAM,SAAS;EAAM,UAAU,OAAO;EAAI,CAC7C;;AAGH,MAAM,oBACJ,WACuF;AACvF,KAAI,CAAC,UAAU,OAAO,WAAW,SAAU,QAAO;CAClD,MAAM,YAAY;AAMlB,SACG,UAAU,SAAS,WAAW,UAAU,SAAS,iBAClD,OAAO,UAAU,YAAY,cAC7B,OAAO,UAAU,aAAa,cAC9B,OAAO,UAAU,cAAc;;AAInC,SAAgB,OACd,cACA,SACA,WAA8C,OAAO,IACtC;CACf,MAAM,CAAC,cAAc,gBAAgB;EACnC;EACA,SAAS,CAAC;GAAE,MAAM;GAAmB;GAAsB,CAAC;EAC5D,eAAe,EACb,WAAU,eAAc;GACtB,MAAM,SAAS,WAAW,QAAQ;AAClC,OAAI,OAAO,SAAS,QAAS,OAAM,IAAI,MAAM,kCAAkC;GAC/E,MAAM,OAAO,QAAQ,GAAI,WAAW,QAAQ,IAAI,YAAY,CAAyB;AACrF,qBAAkB,KAAK;AACvB,UAAO,OAAO,IAAI,KAAK;KAE1B;EACF,CAAC;AACF,QAAO;;;;AC7NT,MAAM,wBAAwB,OAAO,OAAO,EAAE,MAAM,SAAkB,CAAC;AAEvE,MAAM,aAAa,UACjB,UAAU,QACV,OAAO,UAAU,YAChB,MAAsC,SAAS;AAElD,MAAM,eAAe,WACnB,OAAO,SAAS,UAAU,OAAO,QAAQ,eAAe,OAAO,KAAK;AAEtE,MAAM,gBACJ,SACA,WACmF;CACnF,QAAQ,OAAO,OAAO,QAAQ,IAAI,YAAY,CAAC;CAC/C,SAAS,OAAO,OACd,QAAQ,KAAI,WACV,OAAO,SAAS,eAAgB,QAAQ,wBAAwB,OAAO,SAAU,KAAA,EAClF,CACF;CACF;AAED,MAAM,wBAAwB,iBAA0D;AACtF,KAAI,CAAC,MAAM,QAAQ,aAAa,CAC9B,OAAM,IAAI,UAAU,gDAAgD;AACtE,cAAa,QAAQ,cAAc;;AAGrC,SAAS,uBACP,cACA,WACe;AACf,sBAAqB,aAAa;CAClC,MAAM,CAAC,cAAc,gBAAgB;EACnC;EACA,SAAS,CAAC;GAAE,MAAM;GAAS,UAAU,OAAO;GAAI,CAAC;EACjD,cAAc;GACZ,MAAM,QAAiC,OAAO,OAAO,KAAK;AAC1D,UAAO,EACL,WAAU,eAAc;IACtB,MAAM,SAAS,WAAW,QAAQ;AAClC,QAAI,OAAO,SAAS,QAAS,OAAM,IAAI,MAAM,uCAAuC;IACpF,MAAM,cAAc,aAAa,WAAW,SAAS,WAAW,MAAM;IACtE,MAAM,SAAS,UAAU;KACvB,SAAS,YAAY;KACrB,SAAS,YAAY;KACrB,UAAU,OAAO;KACjB,OAAO,WAAW;KAClB,OAAO,WAAW;KAClB;KACD,CAAC;AACF,sBAAkB,OAAO;AACzB,QAAI,UAAU,OAAO,CAAE,QAAO;AAC9B,WAAO,OAAO,IAAI,OAAY;MAEjC;;EAEJ,CAAC;AACF,QAAO;;AAGT,SAAS,4BAKP,cACA,WACuD;AACvD,sBAAqB,aAAa;CAClC,MAAM,CAAC,cAAc,gBAAgB;EACnC;EACA,SAAS,CAAC;GAAE,MAAM;GAAc,UAAU,OAAO;GAAI,CAAC;EACtD,cAAc;GACZ,MAAM,QAAiC,OAAO,OAAO,KAAK;AAC1D,UAAO,EACL,WAAU,eAAc;IACtB,MAAM,SAAS,WAAW,QAAQ;AAClC,QAAI,OAAO,SAAS,aAClB,OAAM,IAAI,MAAM,4CAA4C;IAC9D,MAAM,cAAc,aAAa,WAAW,SAAS,WAAW,MAAM;IACtE,MAAM,SAAS,UAAU;KACvB,SAAS,YAAY;KACrB,SAAS,YAAY;KACrB,UAAU,OAAO;KACjB,MAAM,OAAO;KACb,OAAO,WAAW;KAClB,OAAO,WAAW;KAClB;KACA,QAAQ,OAAO;KAChB,CAAC;AACF,sBAAkB,OAAO;AACzB,WAAO,UAAU,OAAO,GAAG,SAAS,KAAA;MAEvC;;EAEJ,CAAC;AACF,QAAO;;AAIT,MAAM,sCAAsB,IAAI,SAM7B;AAEH,MAAM,yBAAyB,UAC7B,UAAU,QACV,OAAO,UAAU,YACjB,CAAC,oBAAoB,IAAI,MAAM,IAC/B,CAAC,MAAM,QAAQ,MAAM,KACpB,OAAO,eAAe,MAAM,KAAK,OAAO,aAAa,OAAO,eAAe,MAAM,KAAK;AAEzF,MAAM,qBACJ,OACA,MACA,iBACA,MACA,YACe;AACf,KAAI,UAAU,QAAQ,OAAO,UAAU,UAAU;EAC/C,MAAM,WAAW,oBAAoB,IAAI,MAAM;AAC/C,MAAI,UAAU;AACZ,OAAI,CAAC,gBAAgB,IAAI,MAAM,CAC7B,OAAM,IAAI,UAAU,4DAA4D;AAClF,OAAI,KAAK,IAAI,MAAM,CAAE,OAAM,IAAI,UAAU,gDAAgD;AACzF,QAAK,IAAI,MAAM;GACf,MAAM,QAAQ,QAAQ;AACtB,WAAQ,KAAK;IACX,MAAM,SAAS;IACf,UAAU,SAAS;IACnB,MAAM,OAAO,OAAO,CAAC,GAAG,KAAK,CAAC;IAC/B,CAAC;AACF,UAAO;;;AAGX,KAAI,CAAC,sBAAsB,MAAM,CAC/B,OAAM,IAAI,UAAU,0DAA0D;AAChF,MAAK,MAAM,OAAO,QAAQ,QAAQ,MAAM,EAAE;AACxC,MAAI,OAAO,QAAQ,SACjB,OAAM,IAAI,UAAU,kDAAkD;AACxE,MAAI,CAAC,OAAO,UAAU,qBAAqB,KAAK,OAAO,IAAI,CACzD,OAAM,IAAI,UAAU,mEAAmE;;CAE3F,MAAM,OAAO,OAAO,KAAK,MAAM;AAC/B,KAAI,CAAC,KAAK,OAAQ,OAAM,IAAI,UAAU,gDAAgD;CACtF,MAAM,SAAqC,OAAO,OAAO,KAAK;AAC9D,MAAK,MAAM,OAAO,MAAM;AACtB,MAAI,QAAQ,eAAe,QAAQ,eAAe,QAAQ,cACxD,OAAM,IAAI,UAAU,0CAA0C,MAAM;EACtE,MAAM,aAAa,OAAO,yBAAyB,OAAO,IAAI;AAC9D,MAAI,CAAC,cAAc,EAAE,WAAW,YAC9B,OAAM,IAAI,UAAU,yDAAyD;AAC/E,SAAO,OAAO,kBACZ,WAAW,OACX,CAAC,GAAG,MAAM,IAAI,EACd,iBACA,MACA,QACD;;AAEH,QAAO,OAAO,OAAO,OAAO;;AAG9B,MAAM,qBAAwB,OAAmB,WAAkC;AACjF,KAAI,OAAO,UAAU,SAAU,QAAO,OAAO;CAC7C,MAAM,SAAkC,EAAE;AAC1C,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,CAAE,QAAO,OAAO,kBAAkB,OAAO,OAAO;AAChG,QAAO,OAAO,OAAO,OAAO;;AAK9B,MAAM,qBACJ,OACA,SACA,SACY;AACZ,KAAI,OAAO,UAAU,UAAU;EAC7B,MAAM,SAAS,QAAQ;AACvB,SAAO,QAAQ,OAAO,SAAS,UAAU,OAAO,MAAM,GAAG,OAAO,OAAO,OAAO,OAAO;;CAEvF,MAAM,SAAkC,EAAE;AAC1C,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,CAC9C,KAAI,OAAO,UAAU,YAAY,QAAQ,QAAQ,OAAO,SAAS,QAC/D,QAAO,eAAe,QAAQ,KAAK;EACjC,YAAY;EACZ,cAAc;EACd,WAAY,QAAQ,OAAwD,MAAM;EACnF,CAAC;KACG,QAAO,OAAO,kBAAkB,OAAO,SAAS,KAAK;AAE9D,QAAO,OAAO,OAAO,OAAO;;AAG9B,SAAS,uBAIP,cACA,eACA,WACqB;AACrB,sBAAqB,aAAa;AAClC,KAAI,OAAO,kBAAkB,WAC3B,OAAM,IAAI,UAAU,4DAA4D;AAClF,KAAI,OAAO,cAAc,WACvB,OAAM,IAAI,UAAU,kDAAkD;CAExE,IAAI,SAAS;CACb,MAAM,kCAAkB,IAAI,KAAa;CAuBzC,MAAM,WAAW,cAAc;EArB7B,aAAkC,WAA8C,OAAO,OAAO;AAC5F,OAAI,CAAC,OAAQ,OAAM,IAAI,UAAU,yDAAyD;GAC1F,MAAM,aAAa,OAAO,OAAO,EAAE,CAAC;AACpC,uBAAoB,IAAI,YAAY;IAClC,MAAM;IACI;IACX,CAAC;AACF,mBAAgB,IAAI,WAAW;AAC/B,UAAO;;EAET,QAAW,WAA8C,OAAO,OAAO;AACrE,OAAI,CAAC,OAAQ,OAAM,IAAI,UAAU,yDAAyD;GAC1F,MAAM,aAAa,OAAO,OAAO,EAAE,CAAC;AACpC,uBAAoB,IAAI,YAAY;IAClC,MAAM;IACI;IACX,CAAC;AACF,mBAAgB,IAAI,WAAW;AAC/B,UAAO;;EAGgC,CAAC;AAC5C,mBAAkB,SAAS;AAC3B,UAAS;CACT,MAAM,UAA8B,EAAE;CACtC,MAAM,uBAAO,IAAI,KAAa;CAC9B,MAAM,QAAQ,kBAAkB,UAAU,EAAE,EAAE,iBAAiB,MAAM,QAAQ;AAC7E,KAAI,OAAO,UAAU,SACnB,OAAM,IAAI,UAAU,kEAAkE;AACxF,KAAI,KAAK,SAAS,KAAK,KAAK,SAAS,gBAAgB,KACnD,OAAM,IAAI,UAAU,sEAAsE;AA+B5F,QAAO,kBAAkB,OA7BL,gBAAgB;EAClC;EACA;EACA,cAAc;GACZ,MAAM,QAAiC,OAAO,OAAO,KAAK;AAC1D,UAAO,EACL,WAAU,eAAc;IACtB,MAAM,cAAc,aAAa,WAAW,SAAS,WAAW,MAAM;IACtE,MAAM,SAAS,UAAU;KACvB,SAAS,YAAY;KACrB,SAAS,YAAY;KACrB,UAAU,kBAAkB,OAAO,WAAW,SAAS,MAAM;KAC7D,MAAM,kBAAkB,OAAO,WAAW,SAAS,KAAK;KACxD,SAAS,kBACP,OACA,WAAW,QAAQ,KAAI,WAAU,OAAO,OAAO,CAChD;KACD,OAAO,WAAW;KAClB,OAAO,WAAW;KAClB;KACD,CAAC;AACF,sBAAkB,OAAO;AACzB,WAAO,UAAU,OAAO,GAAG,SAAS,KAAA;MAEvC;;EAEH,MAAM,mBAAmB,QAAQ,KAAI,WAAU,OAAO,MAAM,KAAK,IAAI,IAAI,GAAG,CAAC,KAAK,IAAI;EACvF,CAE0C,CAAC;;AAG9C,MAAa,cAAc,OAAO,OAAO,wBAAwB;CAC/D,YAAY;CACZ,OAAO;CACR,CAAC"}

package/dist/advanced.cjs

@@ -1,3 +1,3 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_advanced = require("./advanced-BRL5pN0y.cjs");
+const require_advanced = require("./advanced-GKZ-CZ6a.cjs");
 exports.incremental = require_advanced.incremental;

package/dist/advanced.d.cts

@@ -1,2 +1,2 @@
-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-DfKc7TZR.cjs";
+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-CyR5o3Xr.cjs";
 export { CollectionChange, GroupProjections, IncrementalCollectionContext, IncrementalCollectionProcessor, IncrementalGroupContext, IncrementalGroupDefine, IncrementalGroupOutputTree, IncrementalGroupProcessor, IncrementalValueContext, IncrementalValueProcessor, incremental };

package/dist/advanced.d.ts

@@ -1,2 +1,2 @@
-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-FgdTwu5b.js";
+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-CqrR_4dh.js";
 export { CollectionChange, GroupProjections, IncrementalCollectionContext, IncrementalCollectionProcessor, IncrementalGroupContext, IncrementalGroupDefine, IncrementalGroupOutputTree, IncrementalGroupProcessor, IncrementalValueContext, IncrementalValueProcessor, incremental };

package/dist/advanced.js

@@ -1,2 +1,2 @@
-import { t as incremental } from "./advanced-COFJtWMT.js";
+import { t as incremental } from "./advanced-BTStm2cW.js";
 export { incremental };

package/dist/{contract-KG5XnQZt.d.ts → contract-CRrZ-3sF.d.cts}

@@ -39,14 +39,17 @@ type ReadonlyValue<T> = T extends ((...args: never[]) => unknown) ? T : T extend
 type DocumentListConfig<TItem> = {
   readonly keyOf: (item: ReadonlyValue<TItem>) => string;
 };
-type DocumentTreeNode<TValue> = {
+type DocumentTreeNode<TValue, ValueOptional extends boolean = false> = {
   readonly parentId?: string;
   readonly children: readonly string[];
+} & (ValueOptional extends true ? {
   readonly value?: ReadonlyValue<TValue>;
-};
-type DocumentTreeValue<TValue> = {
+} : {
+  readonly value: ReadonlyValue<TValue>;
+});
+type DocumentTreeValue<TValue, ValueOptional extends boolean = false> = {
   readonly rootId?: string;
-  readonly nodes: Readonly<Record<string, DocumentTreeNode<TValue>>>;
+  readonly nodes: Readonly<Record<string, DocumentTreeNode<TValue, ValueOptional>>>;
 };
 type BaseNode<K extends string> = {
   readonly kind: K;
@@ -89,10 +92,10 @@ type ListNode<TItem> = BaseNode<'list'> & {
   readonly value: FieldNode<TItem, false>;
   keyOf(item: ReadonlyValue<TItem>): string;
 };
-type TreeNode<TValue> = BaseNode<'tree'> & {
-  readonly value: FieldNode<TValue, boolean>;
+type TreeNode<TValue, ValueOptional extends boolean = false> = BaseNode<'tree'> & {
+  readonly value: FieldNode<TValue, ValueOptional>;
 };
-type DocumentNode = FieldNode<unknown, false> | FieldNode<unknown, true> | ObjectNode<ObjectShape> | VariantNode<string, VariantShape> | TableNode<ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> | MapNode<ValueSchemaNode> | ListNode<unknown> | TreeNode<unknown>;
+type DocumentNode = FieldNode<unknown, false> | FieldNode<unknown, true> | ObjectNode<ObjectShape> | VariantNode<string, VariantShape> | TableNode<ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> | MapNode<ValueSchemaNode> | ListNode<unknown> | TreeNode<unknown, false> | TreeNode<unknown, true>;
 type SchemaObject<T> = { [K in keyof T]: T[K] } & {};
 /** Infer a document or node value, including optional node presence. */
 type Infer<T extends DocumentNode> = T extends {
@@ -101,7 +104,7 @@ type Infer<T extends DocumentNode> = T extends {
 type NodeValue<N> = N extends FieldNode<infer T, infer O> ? O extends true ? ReadonlyValue<T> | undefined : ReadonlyValue<T> : N extends ObjectNode<infer S> ? ShapeValue<S> : N extends VariantNode<infer T, infer V> ? { [K in keyof V & string]: SchemaObject<{ readonly [P in T]: K } & NodeValue<V[K]>> }[keyof V & string] : N extends TableNode<infer V, infer K> ? {
   readonly ids: readonly K[];
   readonly byId: Readonly<Record<K, NodeValue<V>>>;
-} : N extends MapNode<infer V, infer K> ? Readonly<Record<K, NodeValue<V>>> : N extends ListNode<infer I> ? readonly ReadonlyValue<I>[] : N extends TreeNode<infer T> ? DocumentTreeValue<T> : never;
+} : N extends MapNode<infer V, infer K> ? Readonly<Record<K, NodeValue<V>>> : N extends ListNode<infer I> ? readonly ReadonlyValue<I>[] : N extends TreeNode<infer T, infer O> ? DocumentTreeValue<T, O> : never;
 type OptionalKeys<S extends ObjectShape> = { [K in keyof S]: S[K] extends {
   readonly optional: true;
 } ? K : never }[keyof S];
@@ -116,29 +119,45 @@ type DocumentAnchor<K extends string = string> = {
 } | {
   readonly after: K;
 };
-type CollectionSelector<TId extends string = string, TNode extends ValueSchemaNode = ValueSchemaNode> = {
+type TreeTarget = {
+  readonly kind: 'root';
+} | {
+  readonly kind: 'nodes';
+} | {
+  readonly kind: 'node';
+  readonly id: string;
+};
+type TreeValueTarget = Exclude<TreeTarget, {
+  readonly kind: 'nodes';
+}>;
+type TreeCollectionTarget = Extract<TreeTarget, {
+  readonly kind: 'nodes';
+}>;
+type CollectionSelector<TId extends string = string> = {
   readonly kind: 'collection';
   readonly schema: ObjectNode;
   readonly address: DocumentAddress;
-  readonly __id?: TId; /** Compile-time entry schema carried by schema selectors. */
-  readonly __node?: TNode;
+  readonly tree?: TreeCollectionTarget;
+  readonly __id?: TId;
 };
 type ValueSelector<TResult = unknown> = {
   readonly kind: 'value';
   readonly schema: ObjectNode;
   readonly address: DocumentAddress;
+  readonly tree?: TreeValueTarget;
   readonly __value?: TResult;
 };
 type ImpactTarget<T = unknown> = {
   readonly kind: 'value';
   readonly at: DocumentAddress;
+  readonly tree?: TreeValueTarget;
 } | ValueSelector<T> | {
   readonly kind: 'collection';
   readonly at: DocumentAddress;
   readonly id?: string;
 } | CollectionSelector<string>;
 declare const pathValue: unique symbol;
-declare const collectionNode: unique symbol;
+declare const collectionEntry: unique symbol;
 declare const collectionKey: unique symbol;
 type PathMarker<TValue> = {
   readonly [pathValue]: TValue;
@@ -146,33 +165,44 @@ type PathMarker<TValue> = {
 type PathValueOf<T> = T extends {
   readonly [pathValue]: infer TValue;
 } ? TValue : never;
-type SchemaPathFor<S extends ObjectShape = ObjectShape, TValue = unknown> = { readonly [K in keyof S]: PathValue<S[K]> } & PathMarker<TValue>;
+type Or<A extends boolean, B extends boolean> = A extends true ? true : B;
+type NodeAbsent<N extends DocumentNode, ParentAbsent extends boolean> = Or<ParentAbsent, N extends {
+  readonly optional: true;
+} ? true : false>;
+type PathResult<N extends DocumentNode, ParentAbsent extends boolean> = Infer<N> | (ParentAbsent extends true ? undefined : never);
+type SchemaPathFor<S extends ObjectShape = ObjectShape, TValue = unknown, Absent extends boolean = false> = { readonly [K in keyof S]: PathValue<S[K], Absent> } & PathMarker<TValue | (Absent extends true ? undefined : never)>;
 type SchemaPath<S extends ObjectShape = ObjectShape> = SchemaPathFor<S, ShapeValue<S>>;
 type PathPick<S extends ObjectNode = ObjectNode> = (path: SchemaPath<S['shape']>) => PathMarker<unknown>;
 type VariantKeys<V extends VariantShape> = { [K in keyof V & string]: keyof (V[K] extends ObjectNode<infer S> ? S : {}) }[keyof V & string] & string;
-type VariantFieldPath<V extends VariantShape, K extends string> = { [P in keyof V & string]: V[P] extends ObjectNode<infer S> ? K extends keyof S ? PathValue<S[K]> : never : never }[keyof V & string];
-type VariantPath<T extends string, V extends VariantShape, TValue> = { readonly [K in VariantKeys<V>]: VariantFieldPath<V, K> } & { readonly [K in T]: PathMarker<keyof V & string> } & PathMarker<TValue>;
-type CollectionPath<N extends ValueSchemaNode = ValueSchemaNode, TValue = unknown, K extends string = string> = PathMarker<TValue> & {
-  item(id: K): PathValue<N>;
-  readonly [collectionNode]: N;
+type VariantFieldMissing<V extends VariantShape, K extends string> = { [P in keyof V & string]: V[P] extends ObjectNode<infer S> ? (K extends keyof S ? never : P) : P }[keyof V & string] extends never ? false : true;
+type VariantFieldPath<V extends VariantShape, K extends string, Absent extends boolean> = { [P in keyof V & string]: V[P] extends ObjectNode<infer S> ? K extends keyof S ? PathValue<S[K], Or<Absent, VariantFieldMissing<V, K>>> : never : never }[keyof V & string];
+type VariantPath<T extends string, V extends VariantShape, TValue, Absent extends boolean> = { readonly [K in VariantKeys<V>]: VariantFieldPath<V, K, Absent> } & { readonly [K in T]: PathMarker<(keyof V & string) | (Absent extends true ? undefined : never)> } & PathMarker<TValue>;
+type CollectionPath<K extends string = string, TValue = unknown, TEntry = unknown, TItem = PathMarker<TEntry | undefined>> = PathMarker<TValue> & {
+  item(id: K): TItem;
+  readonly [collectionEntry]: TEntry;
   readonly [collectionKey]: K;
 };
-type PathValue<N extends DocumentNode> = N extends ObjectNode<infer S> ? SchemaPathFor<S, Infer<N>> : N extends VariantNode<infer TTag, infer V> ? VariantPath<TTag, V, Infer<N>> : N extends TableNode<infer V, infer K> ? CollectionPath<V, Infer<N>, K> : N extends MapNode<infer V, infer K> ? CollectionPath<V, Infer<N>, K> : N extends ListNode<infer I> ? CollectionPath<FieldNode<I, false>, Infer<N>, string> : PathMarker<Infer<N>>;
+type TreeNodesPath<TValue, ValueOptional extends boolean> = CollectionPath<string, Readonly<Record<string, DocumentTreeNode<TValue, ValueOptional>>>, DocumentTreeNode<TValue, ValueOptional>, PathMarker<DocumentTreeNode<TValue, ValueOptional> | undefined>>;
+type TreePath<TValue, ValueOptional extends boolean, TValueResult> = PathMarker<TValueResult> & {
+  readonly rootId: PathMarker<string | undefined>;
+  readonly nodes: TreeNodesPath<TValue, ValueOptional>;
+};
+type PathValue<N extends DocumentNode, ParentAbsent extends boolean = false> = N extends ObjectNode<infer S> ? SchemaPathFor<S, PathResult<N, ParentAbsent>, NodeAbsent<N, ParentAbsent>> : N extends VariantNode<infer TTag, infer V> ? VariantPath<TTag, V, PathResult<N, ParentAbsent>, NodeAbsent<N, ParentAbsent>> : N extends TableNode<infer V, infer K> ? CollectionPath<K, PathResult<N, ParentAbsent>, Infer<V>, PathValue<V, true>> : N extends MapNode<infer V, infer K> ? CollectionPath<K, PathResult<N, ParentAbsent>, Infer<V>, PathValue<V, true>> : N extends ListNode<infer I> ? CollectionPath<string, PathResult<N, ParentAbsent>, ReadonlyValue<I>, PathMarker<ReadonlyValue<I> | undefined>> : N extends TreeNode<infer T, infer O> ? TreePath<T, O, PathResult<N, ParentAbsent>> : PathMarker<PathResult<N, ParentAbsent>>;
 type CollectionInfo<T> = T extends {
-  readonly [collectionNode]: infer TNode extends ValueSchemaNode;
+  readonly [collectionEntry]: infer TEntry;
   readonly [collectionKey]: infer K extends string;
 } ? {
   readonly id: K;
-  readonly node: TNode;
+  readonly entry: TEntry;
 } : never;
 type CollectionId<T> = CollectionInfo<T> extends {
   readonly id: infer TId extends string;
 } ? TId : string;
-type CollectionNode<T> = CollectionInfo<T> extends {
-  readonly node: infer TNode extends ValueSchemaNode;
-} ? TNode : ValueSchemaNode;
+type CollectionEntry<T> = CollectionInfo<T> extends {
+  readonly entry: infer TEntry;
+} ? TEntry : unknown;
 declare const field: <T>(validator?: Validator<T>) => FieldNode<T>;
-type OptionalLeaf = FieldNode<unknown, boolean> | VariantNode<string, VariantShape> | MapNode<ValueSchemaNode> | ListNode<unknown> | TreeNode<unknown>;
+type OptionalLeaf = FieldNode<unknown, boolean> | VariantNode<string, VariantShape> | MapNode<ValueSchemaNode> | ListNode<unknown> | TreeNode<unknown, false> | TreeNode<unknown, true>;
 declare const optional: <T extends OptionalLeaf>(value: T) => OptionalNode<T>;
 declare const object: <S extends ObjectShape>(shape: S) => ObjectNode<S>;
 declare const variant: <T extends string, V extends VariantShape>(tag: T, variants: V) => VariantNode<T, V>;
@@ -183,7 +213,7 @@ declare const map: <V extends ValueSchemaNode, K extends string = string>(value:
   readonly key: Validator<K>;
 }) => MapNode<V, K>;
 declare const list: <TItem>(value: FieldNode<TItem, false>, config: DocumentListConfig<TItem>) => ListNode<TItem>;
-declare const tree: <TValue>(value: FieldNode<TValue, boolean>) => TreeNode<TValue>;
+declare const tree: <TValue, ValueOptional extends boolean>(value: FieldNode<TValue, ValueOptional>) => TreeNode<TValue, ValueOptional>;
 //#endregion
 //#region core/src/changes.d.ts
 type ValueTransition<T = unknown> = {
@@ -213,7 +243,7 @@ type Change = {
   readonly at: DocumentAddress;
   readonly before: string | null;
   readonly after: string | null;
-  readonly nodes: readonly (ValueTransition<DocumentTreeNode<unknown>> & {
+  readonly nodes: readonly (ValueTransition<DocumentTreeNode<unknown, false> | DocumentTreeNode<unknown, true>> & {
     readonly id: string;
   })[];
 } | {
@@ -290,20 +320,20 @@ type ListAccess<T, W extends boolean> = {
   replace(value: readonly ReadonlyValue<T>[]): void;
   replace(key: string, value: ReadonlyValue<T>): void;
 } : {});
-type TreeAccess<T, W extends boolean> = {
+type TreeAccess<T, O extends boolean, W extends boolean> = {
   rootId(): string | undefined;
   get(id: string): ReadonlyValue<T> | undefined;
   has(id: string): boolean;
   parent(id: string): string | undefined;
   children(id: string): readonly string[] | undefined;
 } & (W extends true ? {
-  insert(id: string, value: ReadonlyValue<T>, position?: TreePosition): void;
+  insert(id: string, value: O extends true ? ReadonlyValue<T> | undefined : ReadonlyValue<T>, position?: TreePosition): void;
   move(id: string, position?: TreePosition): void;
   remove(id: string): void;
-  replace(value: DocumentTreeValue<T>): void;
-  replace(id: string, value: ReadonlyValue<T>): void;
+  replace(value: DocumentTreeValue<T, O>): void;
+  replace(id: string, value: O extends true ? ReadonlyValue<T> | undefined : ReadonlyValue<T>): void;
 } : {});
-type NodeAccess<N extends DocumentNode, W extends boolean> = N extends FieldNode<infer T, boolean> ? ReadonlyValue<T> : N extends ObjectNode<infer S> ? ShapeAccess<S, W> & Scoped<N, W> : N extends VariantNode<infer Tag, infer V> ? { [K in keyof V & string]: ShapeAccess<V[K]['shape'], W> & { readonly [P in Tag]: K } & Scoped<N, W, Extract<Infer<N>, Record<Tag, K>>> }[keyof V & string] : N extends MapNode<infer V, infer K> ? MapAccess<K, V, W> & Scoped<N, W> : N extends TableNode<infer V, infer K> ? TableAccess<K, V, W> & Scoped<N, W> : N extends ListNode<infer T> ? ListAccess<T, W> & Scoped<N, W> : N extends TreeNode<infer T> ? TreeAccess<T, W> & Scoped<N, W> : never;
+type NodeAccess<N extends DocumentNode, W extends boolean> = N extends FieldNode<infer T, boolean> ? ReadonlyValue<T> : N extends ObjectNode<infer S> ? ShapeAccess<S, W> & Scoped<N, W> : N extends VariantNode<infer Tag, infer V> ? { [K in keyof V & string]: ShapeAccess<V[K]['shape'], W> & { readonly [P in Tag]: K } & Scoped<N, W, Extract<Infer<N>, Record<Tag, K>>> }[keyof V & string] : N extends MapNode<infer V, infer K> ? MapAccess<K, V, W> & Scoped<N, W> : N extends TableNode<infer V, infer K> ? TableAccess<K, V, W> & Scoped<N, W> : N extends ListNode<infer T> ? ListAccess<T, W> & Scoped<N, W> : N extends TreeNode<infer T, infer O> ? TreeAccess<T, O, W> & Scoped<N, W> : never;
 type Access<N extends DocumentNode, W extends boolean> = N extends {
   readonly optional: true;
 } ? NodeAccess<N, W> | undefined : NodeAccess<N, W>;
@@ -457,5 +487,5 @@ type DocumentRuntime<S extends ObjectNode> = DocumentReadable<S> & {
   dispose(): void;
 };
 //#endregion
-export { OptionalNode as $, overlaps as A, DocumentAddress as B, Draft as C, AddressRef as D, snapshot as E, MemberChange as F, DocumentTreeValue as G, DocumentListConfig as H, ValueTransition as I, Infer as J, FieldNode as K, CollectionId as L, resolveAddress as M, Change as N, contains as O, ChangeSet as P, ObjectShape as Q, CollectionNode as R, DocumentImpact as S, replace as T, DocumentNode as U, DocumentAnchor as V, DocumentTreeNode as W, MapNode as X, ListNode as Y, ObjectNode as Z, Unsubscribe as _, Validator as _t, DocumentDisposedError as a, VariantNode as at, MutationIssueCode as b, DocumentReentrancyError as c, list as ct, LocalHistory as d, optional as dt, PathValueOf as et, ObserverError as f, table as ft, TransactionResult as g, ParseIssue as gt, TransactionRejected as h, ParseError as ht, DocumentDiagnostic as i, TreeNode as it, read as j, debugKey as k, DocumentRuntime as l, map as lt, Synchronous as m, variant as mt, CommitSource as n, SchemaPath as nt, DocumentProblem as o, VariantShape as ot, OperationResult as p, tree as pt, ImpactTarget as q, DocumentCommit as r, TableNode as rt, DocumentReadable as s, field as st, CommitListener as t, ReadonlyValue as tt, HistoryState as u, object as ut, Readable as v, parse as vt, Read as w, CollectionImpact as x, MutationIssue as y, CollectionPath as z };
-//# sourceMappingURL=contract-KG5XnQZt.d.ts.map
+export { OptionalNode as $, overlaps as A, DocumentAddress as B, Draft as C, AddressRef as D, snapshot as E, MemberChange as F, DocumentTreeValue as G, DocumentListConfig as H, ValueTransition as I, Infer as J, FieldNode as K, CollectionEntry as L, resolveAddress as M, Change as N, contains as O, ChangeSet as P, ObjectShape as Q, CollectionId as R, DocumentImpact as S, replace as T, DocumentNode as U, DocumentAnchor as V, DocumentTreeNode as W, MapNode as X, ListNode as Y, ObjectNode as Z, Unsubscribe as _, Validator as _t, DocumentDisposedError as a, VariantNode as at, MutationIssueCode as b, DocumentReentrancyError as c, list as ct, LocalHistory as d, optional as dt, PathValueOf as et, ObserverError as f, table as ft, TransactionResult as g, ParseIssue as gt, TransactionRejected as h, ParseError as ht, DocumentDiagnostic as i, TreeNode as it, read as j, debugKey as k, DocumentRuntime as l, map as lt, Synchronous as m, variant as mt, CommitSource as n, SchemaPath as nt, DocumentProblem as o, VariantShape as ot, OperationResult as p, tree as pt, ImpactTarget as q, DocumentCommit as r, TableNode as rt, DocumentReadable as s, field as st, CommitListener as t, ReadonlyValue as tt, HistoryState as u, object as ut, Readable as v, parse as vt, Read as w, CollectionImpact as x, MutationIssue as y, CollectionPath as z };
+//# sourceMappingURL=contract-CRrZ-3sF.d.cts.map