tyneq 1.0.0 → 1.0.2

package/dist/{TyneqCachedTerminalOperator.d.ts → TyneqCachedTerminalOperator-BrW77zIy.d.ts}

@@ -1,6 +1,183 @@
-import { L as Constructor, M as tyneqQueryNode, S as TyneqEnumerableBase, T as QueryPlanNode, Z as Nullable, _ as TyneqCachedSequence, a as Enumerator, b as TyneqSequence, i as Enumerable, m as OrderedEnumerable, n as CachedEnumerable, o as EnumeratorFactory, p as OperatorSource, r as Comparer, t as CacheResult, tt as BaseEnumerableSorter, y as TyneqOrderedSequence } from "./core.js";
+import { y as OperatorEntry, S as SequenceConstructor, M as Maybe, b as OperatorMetadata, O as OperatorSource, j as Constructor, k as Enumerable, l as EnumeratorFactory, $ as TyneqEnumerableBase, X as TyneqOrderedSequence, T as TyneqSequence, N as Nullable, D as OrderedEnumerable, _ as tyneqQueryNode, d as QueryPlanNode, C as Comparer, E as Enumerator, a0 as BaseEnumerableSorter, V as TyneqCachedSequence, h as CachedEnumerable, g as CacheResult } from './core-C54TSmgW.js';
+
+/**
+ * Central registry for all Tyneq operators.
+ *
+ * Every registration path - `@operator`, `@terminal`, `createOperator`,
+ * `createGeneratorOperator`, `createTerminalOperator` - flows through this class.
+ * It is the single source of truth for which operators exist, their kind, and their
+ * prototype-level implementation.
+ *
+ * Internally the registry maintains two separate namespaces:
+ * - Source factories (`Tyneq.from`, `Tyneq.range`, etc.) - keyed by name alone.
+ * - Instance operators (`.where`, `.select`, etc.) - keyed by (name, targetClass).
+ *
+ * This means a source factory and an instance method can share a name without
+ * conflict (e.g. `Tyneq.concat` and `seq.concat`), and two instance operators
+ * with the same name on different prototype chains (e.g. `ordered.foo` and
+ * `cached.foo`) also coexist without conflict.
+ *
+ * @example
+ * ```ts
+ * import { OperatorRegistry } from "tyneq/plugin";
+ *
+ * OperatorRegistry.has("where"); // -> true
+ * OperatorRegistry.list(); // -> OperatorMetadata[]
+ * ```
+ *
+ * @group Classes
+ */
+declare class OperatorRegistry {
+    private static readonly _sources;
+    private static readonly _operators;
+    private static readonly _registrationHooks;
+    private static readonly _registrationGuards;
+    /**
+     * Registers an operator entry and patches the method onto `entry.metadata.targetClass.prototype`.
+     *
+     * @throws {RegistryError} When an operator with the same name is already registered on the same targetClass.
+     */
+    static register(input: OperatorEntry): void;
+    /**
+     * Removes an operator registration and deletes the prototype method for external operators.
+     *
+     * Checks the instance operator namespace first, then the source namespace.
+     *
+     * @returns `true` if the operator was found and removed; `false` if no operator with that name existed.
+     * @remarks
+     * Internal operators (source `"internal"`) are not removed from the prototype - only
+     * their registry entry is deleted.
+     *
+     * For targeted removal use {@link unregisterOperator} or {@link unregisterSource}.
+     */
+    static unregister(name: string): boolean;
+    /**
+     * Removes a specific instance operator registration for a given (name, targetClass) pair
+     * and deletes the prototype method for external operators.
+     *
+     * @returns `true` if the entry was found and removed; `false` otherwise.
+     */
+    static unregisterOperator(name: string, targetClass: SequenceConstructor): boolean;
+    /**
+     * Removes a source factory registration.
+     *
+     * @returns `true` if the source was found and removed; `false` otherwise.
+     */
+    static unregisterSource(name: string): boolean;
+    /**
+     * Registers a hook called after every successful operator registration (both namespaces).
+     *
+     * @returns A function that removes the hook when called.
+     */
+    static onRegister(hook: (entry: OperatorEntry) => void): () => void;
+    /**
+     * Registers a guard called before every registration (both namespaces).
+     * Throw from the guard to reject the registration.
+     *
+     * @returns A function that removes the guard when called.
+     */
+    static addGuard(guard: (entry: OperatorEntry) => void): () => void;
+    /**
+     * Returns `true` if a name exists in either the source or instance operator namespace.
+     * Use {@link hasSource} or {@link hasOperator} for namespace-specific checks.
+     */
+    static has(name: string): boolean;
+    /**
+     * Returns `true` if a source factory with `name` is registered.
+     */
+    static hasSource(name: string): boolean;
+    /**
+     * Returns `true` if an instance operator with `name` is registered.
+     * When `targetClass` is provided, checks only that specific (name, targetClass) pair.
+     * When omitted, returns `true` if any target has an operator with that name.
+     */
+    static hasOperator(name: string, targetClass?: SequenceConstructor): boolean;
+    /**
+     * Returns the operator entry for `name` from either namespace, or `undefined` if not found.
+     * Checks the instance operator namespace first, then the source namespace.
+     * For namespace-specific retrieval use {@link getSource} or {@link getOperator}.
+     */
+    static get(name: string): Maybe<OperatorEntry>;
+    /**
+     * Returns the source factory entry for `name`, or `undefined` if not registered.
+     */
+    static getSource(name: string): Maybe<OperatorEntry>;
+    /**
+     * Returns the instance operator entry for `name` on `targetClass`, or `undefined`.
+     * When `targetClass` is omitted, returns the first entry found across all targets.
+     */
+    static getOperator(name: string, targetClass?: SequenceConstructor): Maybe<OperatorEntry>;
+    /**
+     * Returns the metadata for `name` from either namespace, or `undefined` if not found.
+     * Checks instance operators first, then sources.
+     */
+    static getMetadata(name: string): Maybe<OperatorMetadata>;
+    /**
+     * Returns metadata for all registered operators and source factories.
+     * Use {@link listOperators} or {@link listSources} for namespace-specific lists.
+     */
+    static list(): readonly OperatorMetadata[];
+    /**
+     * Returns metadata for all registered source factories.
+     */
+    static listSources(): readonly OperatorMetadata[];
+    /**
+     * Returns metadata for all registered instance operators.
+     * When `targetClass` is provided, returns only entries for that specific target class.
+     */
+    static listOperators(targetClass?: SequenceConstructor): readonly OperatorMetadata[];
+    /** Returns metadata for all operators of `kind` across both namespaces. */
+    static listByKind(kind: OperatorMetadata["kind"]): readonly OperatorMetadata[];
+    /** Returns metadata for all operators from `source` across both namespaces. */
+    static listBySource(source: OperatorMetadata["source"]): readonly OperatorMetadata[];
+    /** Returns the total number of registered operators across both namespaces. */
+    static count(): number;
+    /**
+     * Registers a source operator (a static factory, not a prototype method).
+     *
+     * @remarks
+     * Source operators differ from prototype operators in two ways:
+     * - They are called with `null` as `this` - they have no instance.
+     * - They are looked up by the compiler via {@link getSource} rather than
+     *   being patched onto a prototype.
+     *
+     * The entry is stored in the source namespace and is never patched onto any prototype.
+     * Registration guards run for `"external"` sources (same policy as {@link register}).
+    * Guards are skipped for `"internal"` sources (same policy used for internal builtins).
+     *
+     * Third-party source operators registered here are automatically compiled by
+     * `QueryPlanCompiler` without any changes to the compiler.
+     *
+     * @param name - The operator name, matching the `operatorName` on the `QueryPlanNode`.
+     * @param factory - The factory function; receives the node args in order, `this` is `null`.
+     * @param source - Whether this is a built-in or external source operator. Defaults to `"external"`.
+     *
+     * @example
+     * ```ts
+     * import { OperatorRegistry } from "tyneq/plugin";
+     * import { Tyneq } from "tyneq";
+     *
+     * OperatorRegistry.registerSource("fibonacci", (count) => {
+     *     // return a Tyneq sequence of fibonacci numbers
+     * });
+     * ```
+     *
+     * @group Classes
+     */
+    static registerSource(name: string, factory: (...args: unknown[]) => unknown, source?: OperatorSource): void;
+    /**
+     * Records a built-in operator in the instance operator namespace without patching the prototype.
+     * Built-in operators already live as direct methods on their target class.
+     *
+     * @remarks
+     * Registration guards are intentionally skipped - builtins are internal and
+     * trusted; guards exist to validate external plugin registrations only.
+     *
+     * @internal
+     */
+    static registerBuiltin(name: string, kind: OperatorMetadata["kind"], targetClass: SequenceConstructor): void;
+}
 
-//#region src/plugin/decorators/operator.d.ts
 /**
  * Class decorator that registers a `TyneqEnumerator` subclass as an operator on every sequence.
  *
@@ -34,8 +211,7 @@ import { L as Constructor, M as tyneqQueryNode, S as TyneqEnumerableBase, T as Q
  * @group Decorators
  */
 declare function operator<TArgs extends unknown[] = never>(name: string, category: "streaming" | "buffer", validate?: (...args: TArgs) => void): <TClass extends new (...args: any[]) => any>(target: TClass, _context: ClassDecoratorContext) => TClass;
-//#endregion
-//#region src/plugin/decorators/orderedOperator.d.ts
+
 /**
  * Class decorator that registers a `TyneqOrderedEnumerator` subclass as an operator
  * available only on ordered sequences.
@@ -70,8 +246,7 @@ declare function operator<TArgs extends unknown[] = never>(name: string, categor
  * @group Decorators
  */
 declare function orderedOperator<TArgs extends unknown[] = never>(name: string, category: "streaming" | "buffer", validate?: (...args: TArgs) => void): <TClass extends Constructor<any>>(target: TClass, _context: ClassDecoratorContext<TClass>) => TClass;
-//#endregion
-//#region src/plugin/decorators/cachedOperator.d.ts
+
 /**
  * Class decorator that registers a `TyneqCachedEnumerator` subclass as an operator
  * available only on cached sequences.
@@ -104,8 +279,7 @@ declare function orderedOperator<TArgs extends unknown[] = never>(name: string,
  * @group Decorators
  */
 declare function cachedOperator<TArgs extends unknown[] = never>(name: string, category: "streaming" | "buffer", validate?: (...args: TArgs) => void): <TClass extends Constructor<any>>(target: TClass, _context: ClassDecoratorContext<TClass>) => TClass;
-//#endregion
-//#region src/plugin/decorators/terminal.d.ts
+
 /**
  * Class decorator that registers a class as a terminal operator.
  *
@@ -134,10 +308,9 @@ declare function cachedOperator<TArgs extends unknown[] = never>(name: string, c
  * @group Decorators
  */
 declare function terminal<TArgs extends unknown[] = never>(name: string, validate?: (...args: TArgs) => void): <TClass extends new (...args: any[]) => {
-  process(): unknown;
+    process(): unknown;
 }>(target: TClass, _context: ClassDecoratorContext) => TClass;
-//#endregion
-//#region src/plugin/decorators/orderedTerminal.d.ts
+
 /**
  * Class decorator that registers a `TyneqOrderedTerminalOperator` subclass as a terminal
  * operator available only on ordered sequences.
@@ -165,10 +338,9 @@ declare function terminal<TArgs extends unknown[] = never>(name: string, validat
  * @group Decorators
  */
 declare function orderedTerminal<TArgs extends unknown[] = never>(name: string, validate?: (...args: TArgs) => void): <TClass extends Constructor<{
-  process(): unknown;
+    process(): unknown;
 }>>(target: TClass, _context: ClassDecoratorContext<TClass>) => TClass;
-//#endregion
-//#region src/plugin/decorators/cachedTerminal.d.ts
+
 /**
  * Class decorator that registers a `TyneqCachedTerminalOperator` subclass as a terminal
  * operator available only on cached sequences.
@@ -192,10 +364,9 @@ declare function orderedTerminal<TArgs extends unknown[] = never>(name: string,
  * @group Decorators
  */
 declare function cachedTerminal<TArgs extends unknown[] = never>(name: string, validate?: (...args: TArgs) => void): <TClass extends Constructor<{
-  process(): unknown;
+    process(): unknown;
 }>>(target: TClass, _context: ClassDecoratorContext<TClass>) => TClass;
-//#endregion
-//#region src/plugin/registration/createOperator.d.ts
+
 /**
  * Registers a streaming or buffering operator using a factory function.
  *
@@ -238,14 +409,13 @@ declare function cachedTerminal<TArgs extends unknown[] = never>(name: string, v
  * @group Factory Functions
  */
 declare function createOperator<TSource, TArgs extends unknown[], TResult>(config: {
-  name: string;
-  category: "streaming" | "buffer";
-  factory: (source: Enumerable<TSource>, ...args: TArgs) => EnumeratorFactory<TResult>;
-  validate?: (...args: NoInfer<TArgs>) => void;
-  source?: OperatorSource;
+    name: string;
+    category: "streaming" | "buffer";
+    factory: (source: Enumerable<TSource>, ...args: TArgs) => EnumeratorFactory<TResult>;
+    validate?: (...args: NoInfer<TArgs>) => void;
+    source?: OperatorSource;
 }): void;
-//#endregion
-//#region src/plugin/registration/createGeneratorOperator.d.ts
+
 /**
  * Registers an operator using a generator function.
  *
@@ -299,14 +469,13 @@ declare function createOperator<TSource, TArgs extends unknown[], TResult>(confi
  * @group Factory Functions
  */
 declare function createGeneratorOperator<TSource, TArgs extends unknown[], TResult>(config: {
-  name: string;
-  category?: "streaming" | "buffer";
-  generator: (source: Iterable<TSource>, ...args: TArgs) => IterableIterator<TResult>;
-  validate?: (...args: NoInfer<TArgs>) => void;
-  source?: OperatorSource;
+    name: string;
+    category?: "streaming" | "buffer";
+    generator: (source: Iterable<TSource>, ...args: TArgs) => IterableIterator<TResult>;
+    validate?: (...args: NoInfer<TArgs>) => void;
+    source?: OperatorSource;
 }): void;
-//#endregion
-//#region src/core/ordering/TyneqOrderedEnumerable.d.ts
+
 /**
  * Concrete implementation of {@link TyneqOrderedSequence}.
  *
@@ -317,25 +486,24 @@ declare function createGeneratorOperator<TSource, TArgs extends unknown[], TResu
  * @internal
  */
 declare class TyneqOrderedEnumerable<TSource, TKey> extends TyneqEnumerableBase<TSource> implements TyneqOrderedSequence<TSource> {
-  private readonly keySelector;
-  private readonly comparer;
-  private readonly descending;
-  readonly source: TyneqSequence<TSource>;
-  readonly parent: Nullable<OrderedEnumerable<TSource>>;
-  readonly [tyneqQueryNode]: Nullable<QueryPlanNode>;
-  constructor(source: TyneqSequence<TSource>, keySelector: (item: TSource) => TKey, comparer: Comparer<TKey>, descending: boolean, parent?: OrderedEnumerable<TSource>, node?: Nullable<QueryPlanNode>);
-  asc(): TyneqOrderedSequence<TSource>;
-  desc(): TyneqOrderedSequence<TSource>;
-  getEnumerator(): Enumerator<TSource>;
-  getSorter(next: Nullable<BaseEnumerableSorter<TSource>>): BaseEnumerableSorter<TSource>;
-  thenBy<UKey>(keySelector: (item: TSource) => UKey, comparer?: Comparer<UKey>): TyneqOrderedSequence<TSource>;
-  thenByDescending<UKey>(keySelector: (item: TSource) => UKey, comparer?: Comparer<UKey>): TyneqOrderedSequence<TSource>;
-  protected createEnumerable<TResult>(factory: EnumeratorFactory<TResult>, node: Nullable<QueryPlanNode>): TyneqSequence<TResult>;
-  protected createOrderedEnumerable<TKey>(keySelector: (x: TSource) => TKey, comparer: Comparer<TKey>, descending: boolean, node: Nullable<QueryPlanNode>): TyneqOrderedSequence<TSource>;
-  protected createCachedEnumerable(source: TyneqSequence<TSource>, node: Nullable<QueryPlanNode>): TyneqCachedSequence<TSource>;
+    private readonly keySelector;
+    private readonly comparer;
+    private readonly descending;
+    readonly source: TyneqSequence<TSource>;
+    readonly parent: Nullable<OrderedEnumerable<TSource>>;
+    readonly [tyneqQueryNode]: Nullable<QueryPlanNode>;
+    constructor(source: TyneqSequence<TSource>, keySelector: (item: TSource) => TKey, comparer: Comparer<TKey>, descending: boolean, parent?: OrderedEnumerable<TSource>, node?: Nullable<QueryPlanNode>);
+    asc(): TyneqOrderedSequence<TSource>;
+    desc(): TyneqOrderedSequence<TSource>;
+    getEnumerator(): Enumerator<TSource>;
+    getSorter(next: Nullable<BaseEnumerableSorter<TSource>>): BaseEnumerableSorter<TSource>;
+    thenBy<UKey>(keySelector: (item: TSource) => UKey, comparer?: Comparer<UKey>): TyneqOrderedSequence<TSource>;
+    thenByDescending<UKey>(keySelector: (item: TSource) => UKey, comparer?: Comparer<UKey>): TyneqOrderedSequence<TSource>;
+    protected createEnumerable<TResult>(factory: EnumeratorFactory<TResult>, node: Nullable<QueryPlanNode>): TyneqSequence<TResult>;
+    protected createOrderedEnumerable<TKey>(keySelector: (x: TSource) => TKey, comparer: Comparer<TKey>, descending: boolean, node: Nullable<QueryPlanNode>): TyneqOrderedSequence<TSource>;
+    protected createCachedEnumerable(source: TyneqSequence<TSource>, node: Nullable<QueryPlanNode>): TyneqCachedSequence<TSource>;
 }
-//#endregion
-//#region src/plugin/registration/createOrderedOperator.d.ts
+
 /**
  * Registers a factory function as an operator available only on ordered sequences,
  * where the factory fully controls the return type.
@@ -376,14 +544,13 @@ declare class TyneqOrderedEnumerable<TSource, TKey> extends TyneqEnumerableBase<
  * @group Factory Functions
  */
 declare function createOrderedOperator<TSource, TArgs extends unknown[]>(config: {
-  name: string;
-  category: "streaming" | "buffer";
-  factory: (source: TyneqOrderedEnumerable<TSource, unknown>, node: QueryPlanNode, ...args: TArgs) => TyneqOrderedSequence<TSource>;
-  validate?: (...args: NoInfer<TArgs>) => void;
-  source?: OperatorSource;
+    name: string;
+    category: "streaming" | "buffer";
+    factory: (source: TyneqOrderedEnumerable<TSource, unknown>, node: QueryPlanNode, ...args: TArgs) => TyneqOrderedSequence<TSource>;
+    validate?: (...args: NoInfer<TArgs>) => void;
+    source?: OperatorSource;
 }): void;
-//#endregion
-//#region src/core/TyneqCachedEnumerable.d.ts
+
 /**
  * Concrete implementation of {@link TyneqCachedSequence} - caches elements incrementally.
  *
@@ -395,21 +562,20 @@ declare function createOrderedOperator<TSource, TArgs extends unknown[]>(config:
  * @internal
  */
 declare class TyneqCachedEnumerable<TSource> extends TyneqEnumerableBase<TSource> implements TyneqCachedSequence<TSource>, CachedEnumerable<TSource> {
-  private source;
-  private cache;
-  private done;
-  private sourceEnumerator;
-  readonly [tyneqQueryNode]: Nullable<QueryPlanNode>;
-  constructor(source: TyneqSequence<TSource>, node?: Nullable<QueryPlanNode>);
-  getEnumerator(): Enumerator<TSource>;
-  refresh(): TyneqCachedSequence<TSource>;
-  tryGetAtFromCache(index: number): CacheResult<TSource>;
-  protected createEnumerable<TResult>(factory: EnumeratorFactory<TResult>, node: Nullable<QueryPlanNode>): TyneqSequence<TResult>;
-  protected createOrderedEnumerable<TKey>(keySelector: (x: TSource) => TKey, comparer: Comparer<TKey>, descending: boolean, node: Nullable<QueryPlanNode>): TyneqOrderedSequence<TSource>;
-  protected createCachedEnumerable(source: TyneqSequence<TSource>, node: Nullable<QueryPlanNode>): TyneqCachedSequence<TSource>;
+    private source;
+    private cache;
+    private done;
+    private sourceEnumerator;
+    readonly [tyneqQueryNode]: Nullable<QueryPlanNode>;
+    constructor(source: TyneqSequence<TSource>, node?: Nullable<QueryPlanNode>);
+    getEnumerator(): Enumerator<TSource>;
+    refresh(): TyneqCachedSequence<TSource>;
+    tryGetAtFromCache(index: number): CacheResult<TSource>;
+    protected createEnumerable<TResult>(factory: EnumeratorFactory<TResult>, node: Nullable<QueryPlanNode>): TyneqSequence<TResult>;
+    protected createOrderedEnumerable<TKey>(keySelector: (x: TSource) => TKey, comparer: Comparer<TKey>, descending: boolean, node: Nullable<QueryPlanNode>): TyneqOrderedSequence<TSource>;
+    protected createCachedEnumerable(source: TyneqSequence<TSource>, node: Nullable<QueryPlanNode>): TyneqCachedSequence<TSource>;
 }
-//#endregion
-//#region src/plugin/registration/createCachedOperator.d.ts
+
 /**
  * Registers a factory function as an operator available only on cached sequences,
  * where the factory fully controls the return type.
@@ -443,14 +609,13 @@ declare class TyneqCachedEnumerable<TSource> extends TyneqEnumerableBase<TSource
  * @group Factory Functions
  */
 declare function createCachedOperator<TSource, TArgs extends unknown[]>(config: {
-  name: string;
-  category: "streaming" | "buffer";
-  factory: (source: TyneqCachedEnumerable<TSource>, node: QueryPlanNode, ...args: TArgs) => TyneqCachedSequence<TSource>;
-  validate?: (...args: NoInfer<TArgs>) => void;
-  source?: OperatorSource;
+    name: string;
+    category: "streaming" | "buffer";
+    factory: (source: TyneqCachedEnumerable<TSource>, node: QueryPlanNode, ...args: TArgs) => TyneqCachedSequence<TSource>;
+    validate?: (...args: NoInfer<TArgs>) => void;
+    source?: OperatorSource;
 }): void;
-//#endregion
-//#region src/plugin/registration/createTerminalOperator.d.ts
+
 /**
  * Registers a terminal operator using a plain function.
  *
@@ -478,13 +643,12 @@ declare function createCachedOperator<TSource, TArgs extends unknown[]>(config:
  * @group Factory Functions
  */
 declare function createTerminalOperator<TSource, TArgs extends unknown[], TResult>(config: {
-  name: string;
-  execute: (source: Enumerable<TSource>, ...args: TArgs) => TResult;
-  validate?: (...args: NoInfer<TArgs>) => void;
-  source?: OperatorSource;
+    name: string;
+    execute: (source: Enumerable<TSource>, ...args: TArgs) => TResult;
+    validate?: (...args: NoInfer<TArgs>) => void;
+    source?: OperatorSource;
 }): void;
-//#endregion
-//#region src/plugin/registration/createOrderedTerminalOperator.d.ts
+
 /**
  * Registers a terminal operator available only on ordered sequences.
  *
@@ -512,13 +676,12 @@ declare function createTerminalOperator<TSource, TArgs extends unknown[], TResul
  * @group Factory Functions
  */
 declare function createOrderedTerminalOperator<TSource, TArgs extends unknown[], TResult>(config: {
-  name: string;
-  execute: (source: OrderedEnumerable<TSource>, ...args: TArgs) => TResult;
-  validate?: (...args: NoInfer<TArgs>) => void;
-  source?: OperatorSource;
+    name: string;
+    execute: (source: OrderedEnumerable<TSource>, ...args: TArgs) => TResult;
+    validate?: (...args: NoInfer<TArgs>) => void;
+    source?: OperatorSource;
 }): void;
-//#endregion
-//#region src/plugin/registration/createCachedTerminalOperator.d.ts
+
 /**
  * Registers a terminal operator available only on cached sequences.
  *
@@ -542,13 +705,12 @@ declare function createOrderedTerminalOperator<TSource, TArgs extends unknown[],
  * @group Factory Functions
  */
 declare function createCachedTerminalOperator<TSource, TArgs extends unknown[], TResult>(config: {
-  name: string;
-  execute: (source: CachedEnumerable<TSource>, ...args: TArgs) => TResult;
-  validate?: (...args: NoInfer<TArgs>) => void;
-  source?: OperatorSource;
+    name: string;
+    execute: (source: CachedEnumerable<TSource>, ...args: TArgs) => TResult;
+    validate?: (...args: NoInfer<TArgs>) => void;
+    source?: OperatorSource;
 }): void;
-//#endregion
-//#region src/core/enumerators/TyneqBaseEnumerator.d.ts
+
 /**
  * Abstract base class implementing the pull-iterator lifecycle for all Tyneq enumerators.
  *
@@ -569,50 +731,49 @@ declare function createCachedTerminalOperator<TSource, TArgs extends unknown[],
  * @group Plugin
  */
 declare abstract class TyneqBaseEnumerator<TInput, TOutput = TInput> implements Enumerator<TOutput> {
-  private _initialized;
-  private _completed;
-  constructor();
-  /** Advances the iterator, calling `initialize()` on first call. Idempotent after completion. */
-  next(): IteratorResult<TOutput>;
-  /** Terminates iteration early, disposes resources, and marks completed. Idempotent. */
-  return(value?: unknown): IteratorResult<TOutput>;
-  /** Called once before the first `handleNext()` invocation. Override to set up state. */
-  protected initialize(): void;
-  /** Wraps `value` in a non-done `IteratorResult`. */
-  protected yield(value: TOutput): IteratorResult<TOutput>;
-  /** Returns a done `IteratorResult`. */
-  protected done(): IteratorResult<TOutput>;
-  /**
-   * Marks the enumerator completed and yields `value` as the final element.
-   *
-   * @remarks
-   * Use when the last element must be emitted together with completion in one step.
-   */
-  protected doneWithYield(value: TOutput): IteratorResult<TOutput>;
-  /**
-   * Disposes resources, marks completed, and returns a done result.
-   *
-   * @remarks
-   * Use inside `handleNext()` to terminate iteration before the source is exhausted.
-   */
-  protected earlyComplete(reason?: unknown): IteratorResult<TOutput>;
-  /** Calls `disposeSource()` then `disposeAdditional()`. */
-  protected dispose(value?: unknown): void;
-  /** Override to dispose the upstream source enumerator. */
-  protected disposeSource(): void;
-  /**
-   * Override to release any additional resources.
-   *
-   * @remarks
-   * Called after `disposeSource()`. `value` is the return value passed to `return()`.
-   * Must be idempotent and must not throw.
-   */
-  protected disposeAdditional(_value?: unknown): void;
-  /** Produces the next element. Return `{ done: true }` to signal exhaustion. */
-  protected abstract handleNext(): IteratorResult<TOutput>;
+    private _initialized;
+    private _completed;
+    constructor();
+    /** Advances the iterator, calling `initialize()` on first call. Idempotent after completion. */
+    next(): IteratorResult<TOutput>;
+    /** Terminates iteration early, disposes resources, and marks completed. Idempotent. */
+    return(value?: unknown): IteratorResult<TOutput>;
+    /** Called once before the first `handleNext()` invocation. Override to set up state. */
+    protected initialize(): void;
+    /** Wraps `value` in a non-done `IteratorResult`. */
+    protected yield(value: TOutput): IteratorResult<TOutput>;
+    /** Returns a done `IteratorResult`. */
+    protected done(): IteratorResult<TOutput>;
+    /**
+     * Marks the enumerator completed and yields `value` as the final element.
+     *
+     * @remarks
+     * Use when the last element must be emitted together with completion in one step.
+     */
+    protected doneWithYield(value: TOutput): IteratorResult<TOutput>;
+    /**
+     * Disposes resources, marks completed, and returns a done result.
+     *
+     * @remarks
+     * Use inside `handleNext()` to terminate iteration before the source is exhausted.
+     */
+    protected earlyComplete(reason?: unknown): IteratorResult<TOutput>;
+    /** Calls `disposeSource()` then `disposeAdditional()`. */
+    protected dispose(value?: unknown): void;
+    /** Override to dispose the upstream source enumerator. */
+    protected disposeSource(): void;
+    /**
+     * Override to release any additional resources.
+     *
+     * @remarks
+     * Called after `disposeSource()`. `value` is the return value passed to `return()`.
+     * Must be idempotent and must not throw.
+     */
+    protected disposeAdditional(_value?: unknown): void;
+    /** Produces the next element. Return `{ done: true }` to signal exhaustion. */
+    protected abstract handleNext(): IteratorResult<TOutput>;
 }
-//#endregion
-//#region src/core/enumerators/TyneqEnumerator.d.ts
+
 /**
  * Base class for all pipeline operator enumerators (streaming and buffering).
  *
@@ -626,13 +787,12 @@ declare abstract class TyneqBaseEnumerator<TInput, TOutput = TInput> implements
  * @group Plugin
  */
 declare abstract class TyneqEnumerator<TInput, TOutput = TInput> extends TyneqBaseEnumerator<TInput, TOutput> {
-  protected readonly sourceEnumerator: Enumerator<TInput>;
-  private sourceDisposed;
-  constructor(sourceEnumerator: Enumerator<TInput>);
-  protected disposeSource(): void;
+    protected readonly sourceEnumerator: Enumerator<TInput>;
+    private sourceDisposed;
+    constructor(sourceEnumerator: Enumerator<TInput>);
+    protected disposeSource(): void;
 }
-//#endregion
-//#region src/core/enumerators/TyneqOrderedEnumerator.d.ts
+
 /**
  * Base class for enumerators that need the full ordered sequence (not just an Enumerator<T>).
  * Lifecycle of the source is owned by the sequence, not the enumerator.
@@ -641,12 +801,11 @@ declare abstract class TyneqEnumerator<TInput, TOutput = TInput> extends TyneqBa
  * @internal
  */
 declare abstract class TyneqOrderedEnumerator<TSource> extends TyneqBaseEnumerator<TSource> {
-  protected readonly orderedSource: OrderedEnumerable<TSource>;
-  constructor(orderedSource: OrderedEnumerable<TSource>);
-  protected disposeSource(): void;
+    protected readonly orderedSource: OrderedEnumerable<TSource>;
+    constructor(orderedSource: OrderedEnumerable<TSource>);
+    protected disposeSource(): void;
 }
-//#endregion
-//#region src/core/enumerators/TyneqCachedEnumerator.d.ts
+
 /**
  * Base class for enumerators that need the full cached sequence (not just an Enumerator<T>).
  * Lifecycle of the source is owned by the sequence, not the enumerator.
@@ -655,12 +814,11 @@ declare abstract class TyneqOrderedEnumerator<TSource> extends TyneqBaseEnumerat
  * @internal
  */
 declare abstract class TyneqCachedEnumerator<TSource> extends TyneqBaseEnumerator<TSource> {
-  protected readonly cachedSource: CachedEnumerable<TSource>;
-  constructor(cachedSource: CachedEnumerable<TSource>);
-  protected disposeSource(): void;
+    protected readonly cachedSource: CachedEnumerable<TSource>;
+    constructor(cachedSource: CachedEnumerable<TSource>);
+    protected disposeSource(): void;
 }
-//#endregion
-//#region src/core/terminal/TyneqTerminalOperator.d.ts
+
 /**
  * Abstract base for all terminal operators.
  *
@@ -674,13 +832,12 @@ declare abstract class TyneqCachedEnumerator<TSource> extends TyneqBaseEnumerato
  * @group Plugin
  */
 declare abstract class TyneqTerminalOperator<TSource, TResult = TSource> {
-  protected readonly source: Enumerable<TSource>;
-  constructor(source: Enumerable<TSource>);
-  /** Executes the terminal operation and returns the result. */
-  abstract process(): TResult;
+    protected readonly source: Enumerable<TSource>;
+    constructor(source: Enumerable<TSource>);
+    /** Executes the terminal operation and returns the result. */
+    abstract process(): TResult;
 }
-//#endregion
-//#region src/core/terminal/TyneqOrderedTerminalOperator.d.ts
+
 /**
  * Abstract base for terminal operators that require a fully ordered sequence.
  *
@@ -694,13 +851,12 @@ declare abstract class TyneqTerminalOperator<TSource, TResult = TSource> {
  * @group Plugin
  */
 declare abstract class TyneqOrderedTerminalOperator<TSource, TResult = TSource> {
-  protected readonly source: OrderedEnumerable<TSource>;
-  constructor(source: OrderedEnumerable<TSource>);
-  /** Executes the terminal operation and returns the result. */
-  abstract process(): TResult;
+    protected readonly source: OrderedEnumerable<TSource>;
+    constructor(source: OrderedEnumerable<TSource>);
+    /** Executes the terminal operation and returns the result. */
+    abstract process(): TResult;
 }
-//#endregion
-//#region src/core/terminal/TyneqCachedTerminalOperator.d.ts
+
 /**
  * Abstract base for terminal operators that require a fully cached sequence.
  *
@@ -714,11 +870,10 @@ declare abstract class TyneqOrderedTerminalOperator<TSource, TResult = TSource>
  * @group Plugin
  */
 declare abstract class TyneqCachedTerminalOperator<TSource, TResult = TSource> {
-  protected readonly source: CachedEnumerable<TSource>;
-  constructor(source: CachedEnumerable<TSource>);
-  /** Executes the terminal operation and returns the result. */
-  abstract process(): TResult;
+    protected readonly source: CachedEnumerable<TSource>;
+    constructor(source: CachedEnumerable<TSource>);
+    /** Executes the terminal operation and returns the result. */
+    abstract process(): TResult;
 }
-//#endregion
-export { operator as S, cachedTerminal as _, TyneqOrderedEnumerator as a, cachedOperator as b, createCachedTerminalOperator as c, createCachedOperator as d, TyneqCachedEnumerable as f, createOperator as g, createGeneratorOperator as h, TyneqCachedEnumerator as i, createOrderedTerminalOperator as l, TyneqOrderedEnumerable as m, TyneqOrderedTerminalOperator as n, TyneqEnumerator as o, createOrderedOperator as p, TyneqTerminalOperator as r, TyneqBaseEnumerator as s, TyneqCachedTerminalOperator as t, createTerminalOperator as u, orderedTerminal as v, orderedOperator as x, terminal as y };
-//# sourceMappingURL=TyneqCachedTerminalOperator.d.ts.map
+
+export { OperatorRegistry as O, TyneqBaseEnumerator as T, TyneqCachedEnumerator as a, TyneqCachedTerminalOperator as b, TyneqEnumerator as c, TyneqOrderedEnumerator as d, TyneqOrderedTerminalOperator as e, TyneqTerminalOperator as f, cachedOperator as g, cachedTerminal as h, createCachedOperator as i, createCachedTerminalOperator as j, createGeneratorOperator as k, createOperator as l, createOrderedOperator as m, createOrderedTerminalOperator as n, createTerminalOperator as o, operator as p, orderedOperator as q, orderedTerminal as r, TyneqCachedEnumerable as s, terminal as t, TyneqOrderedEnumerable as u };