tyneq 1.0.0 → 1.0.2

package/dist/utility/index.d.cts

@@ -1,2 +1,312 @@
-import { a as reflect, c as MemberDescriptor, d as ArgumentUtility, i as ReflectionContext, l as MethodDescriptor, n as Lazy, o as AccessorDescriptor, r as TypeGuardUtility, s as DataDescriptor, t as ValidationBuilder, u as ReflectOptions } from "../ValidationBuilder.cjs";
-export { type AccessorDescriptor, ArgumentUtility, type DataDescriptor, Lazy, type MemberDescriptor, type MethodDescriptor, type ReflectOptions, ReflectionContext, TypeGuardUtility, ValidationBuilder, reflect };
+import { N as Nullable, M as Maybe, a as Optional, H as HasLength, k as Enumerable, E as Enumerator, F as Factory } from '../core-C54TSmgW.cjs';
+
+/**
+ * Facade for all argument validation guards.
+ *
+ * Every method accepts either a single-property object (`{ count }`) - where the
+ * property name becomes the error message's parameter name - or a raw value with
+ * an explicit `paramName` string. Prefer the object form; the name is inferred
+ * automatically via `nameof`.
+ *
+ * @example
+ * ```ts
+ * import { ArgumentUtility } from "tyneq/utility";
+ *
+ * function take(count: number) {
+ *     ArgumentUtility.checkNonNegative({ count });   // throws ArgumentOutOfRangeError if count < 0
+ *     ArgumentUtility.checkInteger({ count });       // throws ArgumentError if count is not an integer
+ * }
+ * ```
+ *
+ * @group Utilities
+ */
+declare class ArgumentUtility {
+    private constructor();
+    static checkNotNull<T>(param: Record<string, Nullable<T>>): asserts param is Record<string, T>;
+    static checkNotNull<T>(param: Nullable<T>, paramName: string): asserts param is T;
+    static checkNotUndefined<T>(param: Record<string, Maybe<T>>): asserts param is Record<string, T>;
+    static checkNotUndefined<T>(param: Maybe<T>, paramName: string): asserts param is T;
+    static checkNotOptional<T>(param: Record<string, Optional<T>>): asserts param is Record<string, T>;
+    static checkNotOptional<T>(param: Optional<T>, paramName: string): asserts param is T;
+    static checkNotNullOrEmpty<T extends HasLength>(param: Record<string, Nullable<T>>): asserts param is Record<string, T>;
+    static checkNotNullOrEmpty<T extends HasLength>(param: Nullable<T>, paramName: string): asserts param is T;
+    static checkNotOptionalOrEmpty<T extends HasLength>(param: Record<string, Optional<T>>): asserts param is Record<string, T>;
+    static checkNotOptionalOrEmpty<T extends HasLength>(param: Optional<T>, paramName: string): asserts param is T;
+    static checkNotNullOrWhiteSpace(param: Record<string, Optional<string>>): asserts param is Record<string, string>;
+    static checkNotNullOrWhiteSpace(param: Optional<string>, paramName: string): asserts param is string;
+    static checkNonNegative(param: Record<string, number>): void;
+    static checkNonNegative(param: number, paramName: string): void;
+    static checkPositive(param: Record<string, number>): void;
+    static checkPositive(param: number, paramName: string): void;
+    static checkNegative(param: Record<string, number>): void;
+    static checkNegative(param: number, paramName: string): void;
+    static checkNonPositive(param: Record<string, number>): void;
+    static checkNonPositive(param: number, paramName: string): void;
+    static checkInRange(param: Record<string, number>, min: number, max: number): void;
+    static checkInRange(param: number, min: number, max: number, paramName: string): void;
+    static checkInteger(param: Record<string, number>): void;
+    static checkInteger(param: number, paramName: string): void;
+    static checkFinite(param: Record<string, number>): void;
+    static checkFinite(param: number, paramName: string): void;
+    static checkNotNaN(param: Record<string, number>): void;
+    static checkNotNaN(param: number, paramName: string): void;
+    static checkSafeInteger(param: Record<string, number>): void;
+    static checkSafeInteger(param: number, paramName: string): void;
+    static checkArrayIndex(param: Record<string, number>, arrayLength?: number): void;
+    static checkArrayIndex(param: number, paramName: string, arrayLength?: number): void;
+    static checkFunction(param: Record<string, unknown>): asserts param is Record<string, Function>;
+    static checkFunction(param: unknown, paramName: string): asserts param is Function;
+    static checkIterable<T = unknown>(param: Record<string, unknown>): asserts param is Record<string, Iterable<T>>;
+    static checkIterable<T = unknown>(param: unknown, paramName: string): asserts param is Iterable<T>;
+    static checkIterator<T = unknown>(param: Record<string, unknown>): asserts param is Record<string, Iterator<T>>;
+    static checkIterator<T = unknown>(param: unknown, paramName: string): asserts param is Iterator<T>;
+    static checkEnumerable<T = unknown>(param: Record<string, unknown>): asserts param is Record<string, Enumerable<T>>;
+    static checkEnumerable<T = unknown>(param: unknown, paramName: string): asserts param is Enumerable<T>;
+    static checkEnumerator<T = unknown>(param: Record<string, unknown>): asserts param is Record<string, Enumerator<T>>;
+    static checkEnumerator<T = unknown>(param: unknown, paramName: string): asserts param is Enumerator<T>;
+    static checkInstanceOf<T>(param: Record<string, unknown>, constructor: new (...args: any[]) => T): asserts param is Record<string, T>;
+    static checkInstanceOf<T>(param: unknown, constructor: new (...args: any[]) => T, paramName: string): asserts param is T;
+    static checkHasLength(param: Record<string, unknown>): asserts param is Record<string, HasLength>;
+    static checkHasLength(param: unknown, paramName: string): asserts param is HasLength;
+    static check<T>(param: Record<string, T>, predicate: (v: T) => boolean, message: string): void;
+    static check<T>(param: T, paramName: string, predicate: (v: T) => boolean, message: string): void;
+    private static extractParameter;
+}
+
+/**
+ * Describes a method (function-valued own property) on a reflected target.
+ *
+ * @group Reflection
+ */
+interface MethodDescriptor {
+    readonly kind: "method";
+    readonly name: string | symbol;
+    /** The raw function value. */
+    readonly value: Function;
+    /** Calls the method with the given `this` context and arguments. */
+    readonly invoke: (thisArg: unknown, ...args: unknown[]) => unknown;
+}
+/**
+ * Describes a data property (non-function own value property) on a reflected target.
+ *
+ * @group Reflection
+ */
+interface DataDescriptor {
+    readonly kind: "data";
+    readonly name: string | symbol;
+    readonly value: unknown;
+    readonly writable: boolean;
+    readonly configurable: boolean;
+    readonly enumerable: boolean;
+}
+/**
+ * Describes an accessor property (get and/or set) on a reflected target.
+ *
+ * @group Reflection
+ */
+interface AccessorDescriptor {
+    readonly kind: "accessor";
+    readonly name: string | symbol;
+    readonly get: Maybe<() => unknown>;
+    readonly set: Maybe<(value: unknown) => void>;
+    readonly configurable: boolean;
+    readonly enumerable: boolean;
+    /** `true` if the accessor defines a getter. */
+    readonly canRead: boolean;
+    /** `true` if the accessor defines a setter. */
+    readonly canWrite: boolean;
+}
+/**
+ * A discriminated union of all member descriptor types returned by {@link ReflectionContext}.
+ *
+ * Use `descriptor.kind` to narrow to the specific descriptor type.
+ *
+ * @group Reflection
+ */
+type MemberDescriptor = MethodDescriptor | DataDescriptor | AccessorDescriptor;
+/**
+ * Options for the {@link reflect} factory.
+ *
+ * @group Reflection
+ */
+interface ReflectOptions {
+    /**
+     * When `true`, walks the full prototype chain and includes inherited members
+     * up to (but not including) `Object.prototype`.
+     *
+     * Equivalent to C# `BindingFlags.FlattenHierarchy`.
+     *
+     * @defaultValue false
+     */
+    readonly inherited?: boolean;
+    /**
+     * When `true`, includes Symbol-keyed members in addition to string-keyed members.
+     *
+     * @defaultValue false
+     */
+    readonly symbols?: boolean;
+}
+
+/**
+ * The result of a {@link reflect} call. Provides typed access to the members of
+ * the reflected target.
+ *
+ * @group Reflection
+ */
+declare class ReflectionContext<_T extends object> {
+    private readonly proto;
+    private readonly options;
+    /** @internal */
+    constructor(proto: object, options: ReflectOptions);
+    /**
+     * Returns descriptors for all own (and optionally inherited) members,
+     * excluding `constructor`.
+     */
+    members(): readonly MemberDescriptor[];
+    /**
+     * Returns descriptors for all method members (function-valued own properties),
+     * excluding `constructor`.
+     */
+    methods(): readonly MethodDescriptor[];
+    /**
+     * Returns descriptors for all data members (non-function value properties).
+     */
+    fields(): readonly DataDescriptor[];
+    /**
+     * Returns descriptors for all accessor members (get/set properties).
+     */
+    accessors(): readonly AccessorDescriptor[];
+    /**
+     * Returns the descriptor for the named member, or `undefined` if not found.
+     */
+    get(name: string | symbol): Maybe<MemberDescriptor>;
+    /**
+     * Returns `true` if a member with the given name exists on the target.
+     */
+    has(name: string | symbol): boolean;
+    /**
+     * Returns the method descriptor for `name`, or throws {@link ReflectionError}
+     * if the member does not exist or is not a method.
+     *
+     * @throws {ReflectionError} when the member is absent or is not a method.
+     */
+    getMethod(name: string | symbol): MethodDescriptor;
+    /**
+     * Returns the accessor descriptor for `name`, or throws {@link ReflectionError}
+     * if the member does not exist or is not an accessor.
+     *
+     * @throws {ReflectionError} when the member is absent or is not an accessor.
+     */
+    getAccessor(name: string | symbol): AccessorDescriptor;
+    /**
+     * Returns `true` if a method with the given name exists on the target.
+     *
+     * Unlike {@link has}, this returns `false` if the member exists but is an accessor or data property.
+     */
+    hasMethod(name: string | symbol): boolean;
+    /**
+     * Returns the method descriptor for `name`, or `undefined` if the member does not
+     * exist or is not a method. Never throws.
+     */
+    tryGetMethod(name: string | symbol): Maybe<MethodDescriptor>;
+    private findDescriptor;
+    private collectDescriptors;
+}
+/**
+ * Creates a {@link ReflectionContext} for the given target.
+ *
+ * The `target` can be:
+ * - A **constructor function** - reflects the class prototype (instance members). Preferred form.
+ * - A **prototype object** (`MyClass.prototype`) - reflects it directly.
+ * - Any **object** - reflects the object's own properties directly.
+ *
+ * @example
+ * ```ts
+ * import { reflect } from "tyneq/utility";
+ *
+ * class Service {
+ *     public name = "svc";
+ *     public get label(): string { return this.name; }
+ *     public run(): void { /* ... *\/ }
+ * }
+ *
+ * const ctx = reflect(Service);
+ *
+ * ctx.methods();   // -> [{ kind: "method", name: "run", ... }]
+ * ctx.accessors(); // -> [{ kind: "accessor", name: "label", canRead: true, canWrite: false, ... }]
+ *
+ * const m = ctx.getMethod("run");
+ * m.invoke(new Service()); // calls run()
+ * ```
+ *
+ * Walk the full prototype chain:
+ *
+ * ```ts
+ * const ctx = reflect(DerivedClass, { inherited: true });
+ * ctx.members(); // includes members from base classes too
+ * ```
+ *
+ * @group Reflection
+ */
+declare function reflect<T extends object>(target: (new (...args: any[]) => T) | T, options?: ReflectOptions): ReflectionContext<T>;
+
+/**
+ * Type guard predicates for Tyneq's core protocol types.
+ *
+ * @group Utilities
+ */
+declare class TypeGuardUtility {
+    private constructor();
+    static isIterable<T = unknown>(value: unknown): value is Iterable<T>;
+    static isIterator<T = unknown>(value: unknown): value is Iterator<T>;
+    static isIterableIterator<T = unknown>(value: unknown): value is IterableIterator<T>;
+    static isEnumerator<T = unknown>(value: unknown): value is Enumerator<T>;
+    static isEnumerable<T = unknown>(value: unknown): value is Enumerable<T>;
+}
+
+/**
+ * Utility class for lazy initialization of values.
+ *
+ * @group Utilities
+ */
+declare class Lazy<T> {
+    private readonly factory;
+    /** The lazily initialized value, or `undefined` if not yet initialized. */
+    private lazyValue;
+    /** Indicates whether the value has been initialized. */
+    private initialized;
+    constructor(factory: Factory<T, []>);
+    /** Returns the lazily initialized value, initializing it if necessary. */
+    get value(): T;
+}
+
+/**
+ * Accumulates validation errors and throws a single `ValidationError` containing all of them.
+ *
+ * Use when multiple independent arguments must be validated together so callers see all
+ * failures in one throw rather than one at a time.
+ *
+ * @example
+ * ```ts
+ * new ValidationBuilder()
+ *     .check(() => ArgumentUtility.checkNotOptional({ selector }))
+ *     .check(() => ArgumentUtility.checkPositive({ count }))
+ *     .throwIfAny();
+ * ```
+ *
+ * @group Utilities
+ */
+declare class ValidationBuilder {
+    private readonly errors;
+    /**
+     * Runs `fn` and collects any thrown error message. Returns `this` for chaining.
+     */
+    check(fn: () => void): this;
+    /**
+     * Throws a `ValidationError` with all collected messages if any `check` calls failed.
+     * Does nothing when no errors were collected.
+     */
+    throwIfAny(): void;
+}
+
+export { type AccessorDescriptor, ArgumentUtility, type DataDescriptor, Lazy, type MemberDescriptor, type MethodDescriptor, type ReflectOptions, ReflectionContext, TypeGuardUtility, ValidationBuilder, reflect };

package/dist/utility/index.d.ts

@@ -1,2 +1,312 @@
-import { a as reflect, c as MemberDescriptor, d as ArgumentUtility, i as ReflectionContext, l as MethodDescriptor, n as Lazy, o as AccessorDescriptor, r as TypeGuardUtility, s as DataDescriptor, t as ValidationBuilder, u as ReflectOptions } from "../ValidationBuilder.js";
-export { type AccessorDescriptor, ArgumentUtility, type DataDescriptor, Lazy, type MemberDescriptor, type MethodDescriptor, type ReflectOptions, ReflectionContext, TypeGuardUtility, ValidationBuilder, reflect };
+import { N as Nullable, M as Maybe, a as Optional, H as HasLength, k as Enumerable, E as Enumerator, F as Factory } from '../core-C54TSmgW.js';
+
+/**
+ * Facade for all argument validation guards.
+ *
+ * Every method accepts either a single-property object (`{ count }`) - where the
+ * property name becomes the error message's parameter name - or a raw value with
+ * an explicit `paramName` string. Prefer the object form; the name is inferred
+ * automatically via `nameof`.
+ *
+ * @example
+ * ```ts
+ * import { ArgumentUtility } from "tyneq/utility";
+ *
+ * function take(count: number) {
+ *     ArgumentUtility.checkNonNegative({ count });   // throws ArgumentOutOfRangeError if count < 0
+ *     ArgumentUtility.checkInteger({ count });       // throws ArgumentError if count is not an integer
+ * }
+ * ```
+ *
+ * @group Utilities
+ */
+declare class ArgumentUtility {
+    private constructor();
+    static checkNotNull<T>(param: Record<string, Nullable<T>>): asserts param is Record<string, T>;
+    static checkNotNull<T>(param: Nullable<T>, paramName: string): asserts param is T;
+    static checkNotUndefined<T>(param: Record<string, Maybe<T>>): asserts param is Record<string, T>;
+    static checkNotUndefined<T>(param: Maybe<T>, paramName: string): asserts param is T;
+    static checkNotOptional<T>(param: Record<string, Optional<T>>): asserts param is Record<string, T>;
+    static checkNotOptional<T>(param: Optional<T>, paramName: string): asserts param is T;
+    static checkNotNullOrEmpty<T extends HasLength>(param: Record<string, Nullable<T>>): asserts param is Record<string, T>;
+    static checkNotNullOrEmpty<T extends HasLength>(param: Nullable<T>, paramName: string): asserts param is T;
+    static checkNotOptionalOrEmpty<T extends HasLength>(param: Record<string, Optional<T>>): asserts param is Record<string, T>;
+    static checkNotOptionalOrEmpty<T extends HasLength>(param: Optional<T>, paramName: string): asserts param is T;
+    static checkNotNullOrWhiteSpace(param: Record<string, Optional<string>>): asserts param is Record<string, string>;
+    static checkNotNullOrWhiteSpace(param: Optional<string>, paramName: string): asserts param is string;
+    static checkNonNegative(param: Record<string, number>): void;
+    static checkNonNegative(param: number, paramName: string): void;
+    static checkPositive(param: Record<string, number>): void;
+    static checkPositive(param: number, paramName: string): void;
+    static checkNegative(param: Record<string, number>): void;
+    static checkNegative(param: number, paramName: string): void;
+    static checkNonPositive(param: Record<string, number>): void;
+    static checkNonPositive(param: number, paramName: string): void;
+    static checkInRange(param: Record<string, number>, min: number, max: number): void;
+    static checkInRange(param: number, min: number, max: number, paramName: string): void;
+    static checkInteger(param: Record<string, number>): void;
+    static checkInteger(param: number, paramName: string): void;
+    static checkFinite(param: Record<string, number>): void;
+    static checkFinite(param: number, paramName: string): void;
+    static checkNotNaN(param: Record<string, number>): void;
+    static checkNotNaN(param: number, paramName: string): void;
+    static checkSafeInteger(param: Record<string, number>): void;
+    static checkSafeInteger(param: number, paramName: string): void;
+    static checkArrayIndex(param: Record<string, number>, arrayLength?: number): void;
+    static checkArrayIndex(param: number, paramName: string, arrayLength?: number): void;
+    static checkFunction(param: Record<string, unknown>): asserts param is Record<string, Function>;
+    static checkFunction(param: unknown, paramName: string): asserts param is Function;
+    static checkIterable<T = unknown>(param: Record<string, unknown>): asserts param is Record<string, Iterable<T>>;
+    static checkIterable<T = unknown>(param: unknown, paramName: string): asserts param is Iterable<T>;
+    static checkIterator<T = unknown>(param: Record<string, unknown>): asserts param is Record<string, Iterator<T>>;
+    static checkIterator<T = unknown>(param: unknown, paramName: string): asserts param is Iterator<T>;
+    static checkEnumerable<T = unknown>(param: Record<string, unknown>): asserts param is Record<string, Enumerable<T>>;
+    static checkEnumerable<T = unknown>(param: unknown, paramName: string): asserts param is Enumerable<T>;
+    static checkEnumerator<T = unknown>(param: Record<string, unknown>): asserts param is Record<string, Enumerator<T>>;
+    static checkEnumerator<T = unknown>(param: unknown, paramName: string): asserts param is Enumerator<T>;
+    static checkInstanceOf<T>(param: Record<string, unknown>, constructor: new (...args: any[]) => T): asserts param is Record<string, T>;
+    static checkInstanceOf<T>(param: unknown, constructor: new (...args: any[]) => T, paramName: string): asserts param is T;
+    static checkHasLength(param: Record<string, unknown>): asserts param is Record<string, HasLength>;
+    static checkHasLength(param: unknown, paramName: string): asserts param is HasLength;
+    static check<T>(param: Record<string, T>, predicate: (v: T) => boolean, message: string): void;
+    static check<T>(param: T, paramName: string, predicate: (v: T) => boolean, message: string): void;
+    private static extractParameter;
+}
+
+/**
+ * Describes a method (function-valued own property) on a reflected target.
+ *
+ * @group Reflection
+ */
+interface MethodDescriptor {
+    readonly kind: "method";
+    readonly name: string | symbol;
+    /** The raw function value. */
+    readonly value: Function;
+    /** Calls the method with the given `this` context and arguments. */
+    readonly invoke: (thisArg: unknown, ...args: unknown[]) => unknown;
+}
+/**
+ * Describes a data property (non-function own value property) on a reflected target.
+ *
+ * @group Reflection
+ */
+interface DataDescriptor {
+    readonly kind: "data";
+    readonly name: string | symbol;
+    readonly value: unknown;
+    readonly writable: boolean;
+    readonly configurable: boolean;
+    readonly enumerable: boolean;
+}
+/**
+ * Describes an accessor property (get and/or set) on a reflected target.
+ *
+ * @group Reflection
+ */
+interface AccessorDescriptor {
+    readonly kind: "accessor";
+    readonly name: string | symbol;
+    readonly get: Maybe<() => unknown>;
+    readonly set: Maybe<(value: unknown) => void>;
+    readonly configurable: boolean;
+    readonly enumerable: boolean;
+    /** `true` if the accessor defines a getter. */
+    readonly canRead: boolean;
+    /** `true` if the accessor defines a setter. */
+    readonly canWrite: boolean;
+}
+/**
+ * A discriminated union of all member descriptor types returned by {@link ReflectionContext}.
+ *
+ * Use `descriptor.kind` to narrow to the specific descriptor type.
+ *
+ * @group Reflection
+ */
+type MemberDescriptor = MethodDescriptor | DataDescriptor | AccessorDescriptor;
+/**
+ * Options for the {@link reflect} factory.
+ *
+ * @group Reflection
+ */
+interface ReflectOptions {
+    /**
+     * When `true`, walks the full prototype chain and includes inherited members
+     * up to (but not including) `Object.prototype`.
+     *
+     * Equivalent to C# `BindingFlags.FlattenHierarchy`.
+     *
+     * @defaultValue false
+     */
+    readonly inherited?: boolean;
+    /**
+     * When `true`, includes Symbol-keyed members in addition to string-keyed members.
+     *
+     * @defaultValue false
+     */
+    readonly symbols?: boolean;
+}
+
+/**
+ * The result of a {@link reflect} call. Provides typed access to the members of
+ * the reflected target.
+ *
+ * @group Reflection
+ */
+declare class ReflectionContext<_T extends object> {
+    private readonly proto;
+    private readonly options;
+    /** @internal */
+    constructor(proto: object, options: ReflectOptions);
+    /**
+     * Returns descriptors for all own (and optionally inherited) members,
+     * excluding `constructor`.
+     */
+    members(): readonly MemberDescriptor[];
+    /**
+     * Returns descriptors for all method members (function-valued own properties),
+     * excluding `constructor`.
+     */
+    methods(): readonly MethodDescriptor[];
+    /**
+     * Returns descriptors for all data members (non-function value properties).
+     */
+    fields(): readonly DataDescriptor[];
+    /**
+     * Returns descriptors for all accessor members (get/set properties).
+     */
+    accessors(): readonly AccessorDescriptor[];
+    /**
+     * Returns the descriptor for the named member, or `undefined` if not found.
+     */
+    get(name: string | symbol): Maybe<MemberDescriptor>;
+    /**
+     * Returns `true` if a member with the given name exists on the target.
+     */
+    has(name: string | symbol): boolean;
+    /**
+     * Returns the method descriptor for `name`, or throws {@link ReflectionError}
+     * if the member does not exist or is not a method.
+     *
+     * @throws {ReflectionError} when the member is absent or is not a method.
+     */
+    getMethod(name: string | symbol): MethodDescriptor;
+    /**
+     * Returns the accessor descriptor for `name`, or throws {@link ReflectionError}
+     * if the member does not exist or is not an accessor.
+     *
+     * @throws {ReflectionError} when the member is absent or is not an accessor.
+     */
+    getAccessor(name: string | symbol): AccessorDescriptor;
+    /**
+     * Returns `true` if a method with the given name exists on the target.
+     *
+     * Unlike {@link has}, this returns `false` if the member exists but is an accessor or data property.
+     */
+    hasMethod(name: string | symbol): boolean;
+    /**
+     * Returns the method descriptor for `name`, or `undefined` if the member does not
+     * exist or is not a method. Never throws.
+     */
+    tryGetMethod(name: string | symbol): Maybe<MethodDescriptor>;
+    private findDescriptor;
+    private collectDescriptors;
+}
+/**
+ * Creates a {@link ReflectionContext} for the given target.
+ *
+ * The `target` can be:
+ * - A **constructor function** - reflects the class prototype (instance members). Preferred form.
+ * - A **prototype object** (`MyClass.prototype`) - reflects it directly.
+ * - Any **object** - reflects the object's own properties directly.
+ *
+ * @example
+ * ```ts
+ * import { reflect } from "tyneq/utility";
+ *
+ * class Service {
+ *     public name = "svc";
+ *     public get label(): string { return this.name; }
+ *     public run(): void { /* ... *\/ }
+ * }
+ *
+ * const ctx = reflect(Service);
+ *
+ * ctx.methods();   // -> [{ kind: "method", name: "run", ... }]
+ * ctx.accessors(); // -> [{ kind: "accessor", name: "label", canRead: true, canWrite: false, ... }]
+ *
+ * const m = ctx.getMethod("run");
+ * m.invoke(new Service()); // calls run()
+ * ```
+ *
+ * Walk the full prototype chain:
+ *
+ * ```ts
+ * const ctx = reflect(DerivedClass, { inherited: true });
+ * ctx.members(); // includes members from base classes too
+ * ```
+ *
+ * @group Reflection
+ */
+declare function reflect<T extends object>(target: (new (...args: any[]) => T) | T, options?: ReflectOptions): ReflectionContext<T>;
+
+/**
+ * Type guard predicates for Tyneq's core protocol types.
+ *
+ * @group Utilities
+ */
+declare class TypeGuardUtility {
+    private constructor();
+    static isIterable<T = unknown>(value: unknown): value is Iterable<T>;
+    static isIterator<T = unknown>(value: unknown): value is Iterator<T>;
+    static isIterableIterator<T = unknown>(value: unknown): value is IterableIterator<T>;
+    static isEnumerator<T = unknown>(value: unknown): value is Enumerator<T>;
+    static isEnumerable<T = unknown>(value: unknown): value is Enumerable<T>;
+}
+
+/**
+ * Utility class for lazy initialization of values.
+ *
+ * @group Utilities
+ */
+declare class Lazy<T> {
+    private readonly factory;
+    /** The lazily initialized value, or `undefined` if not yet initialized. */
+    private lazyValue;
+    /** Indicates whether the value has been initialized. */
+    private initialized;
+    constructor(factory: Factory<T, []>);
+    /** Returns the lazily initialized value, initializing it if necessary. */
+    get value(): T;
+}
+
+/**
+ * Accumulates validation errors and throws a single `ValidationError` containing all of them.
+ *
+ * Use when multiple independent arguments must be validated together so callers see all
+ * failures in one throw rather than one at a time.
+ *
+ * @example
+ * ```ts
+ * new ValidationBuilder()
+ *     .check(() => ArgumentUtility.checkNotOptional({ selector }))
+ *     .check(() => ArgumentUtility.checkPositive({ count }))
+ *     .throwIfAny();
+ * ```
+ *
+ * @group Utilities
+ */
+declare class ValidationBuilder {
+    private readonly errors;
+    /**
+     * Runs `fn` and collects any thrown error message. Returns `this` for chaining.
+     */
+    check(fn: () => void): this;
+    /**
+     * Throws a `ValidationError` with all collected messages if any `check` calls failed.
+     * Does nothing when no errors were collected.
+     */
+    throwIfAny(): void;
+}
+
+export { type AccessorDescriptor, ArgumentUtility, type DataDescriptor, Lazy, type MemberDescriptor, type MethodDescriptor, type ReflectOptions, ReflectionContext, TypeGuardUtility, ValidationBuilder, reflect };

package/dist/utility/index.js

@@ -1,3 +1,18 @@
-import { a as ArgumentUtility, n as ReflectionContext, o as TypeGuardUtility, r as reflect, t as Lazy } from "../Lazy.js";
-import { t as ValidationBuilder } from "../ValidationBuilder.js";
-export { ArgumentUtility, Lazy, ReflectionContext, TypeGuardUtility, ValidationBuilder, reflect };
+import {
+  ValidationBuilder
+} from "../chunk-PCBN5AFG.js";
+import {
+  ArgumentUtility,
+  Lazy,
+  ReflectionContext,
+  TypeGuardUtility,
+  reflect
+} from "../chunk-5R4AALC7.js";
+export {
+  ArgumentUtility,
+  Lazy,
+  ReflectionContext,
+  TypeGuardUtility,
+  ValidationBuilder,
+  reflect
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tyneq",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Lazy query pipelines for TypeScript.",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -28,8 +28,8 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsc --noEmit && eslint src tests && tsdown",
-    "dev": "tsdown --watch",
+    "build": "tsc --noEmit && eslint src tests && tsup",
+    "dev": "tsup --watch",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
@@ -65,7 +65,7 @@
   "author": "chrisitopherus",
   "license": "MIT",
   "engines": {
-    "node": ">=20.19.0"
+    "node": ">=18"
   },
   "sideEffects": [
     "./dist/index.js",
@@ -84,7 +84,7 @@
     "eslint": "^10.0.3",
     "gh-pages": "^6.3.0",
     "jiti": "^2.6.1",
-    "tsdown": "^0.21.10",
+    "tsup": "8.5.1",
     "tsx": "^4.21.0",
     "typedoc": "^0.28.13",
     "typedoc-plugin-markdown": "^4.9.0",