@orpc/shared 1.14.11 → 1.14.13

package/dist/index.d.ts

@@ -1,48 +1,108 @@
-import { Arrayable, Promisable } from 'type-fest';
-export { Arrayable, IsEqual, PartialDeep, Promisable, Writable } from 'type-fest';
+import { Promisable } from 'type-fest';
+export { IsEqual, IsNever, JsonValue, PartialDeep, Promisable } from 'type-fest';
 import { Tracer, TraceAPI, ContextAPI, PropagationAPI, SpanOptions, Context, Span, AttributeValue, Exception } from '@opentelemetry/api';
-import { AsyncIteratorClass } from '@standardserver/shared';
-export { AbortError, AsyncCleanupFn, AsyncIteratorClass, AsyncIteratorClassNextFn, SequentialIdGenerator, getOrBind, isAsyncIteratorObject, isTypescriptObject, parseEmptyableJSON, sequential, sleep, stringifyJSON, toArray } from '@standardserver/shared';
+export { group, guard, mapEntries, mapValues, omit, retry, sleep } from 'radash';
 
-type MaybeOptionalOptions<TOptions> = object extends TOptions ? [options?: TOptions] : [options: TOptions];
+type MaybeOptionalOptions<TOptions> = Record<never, never> extends TOptions ? [options?: TOptions] : [options: TOptions];
 declare function resolveMaybeOptionalOptions<T>(rest: MaybeOptionalOptions<T>): T;
 
+declare function toArray<T>(value: T): T extends readonly any[] ? T : Exclude<T, undefined | null>[];
 declare function splitInHalf<T>(arr: readonly T[]): [T[], T[]];
 
 /**
- * Load Request/Response/Blob/File/.. to a buffer (Uint8Array<ArrayBuffer>).
+ * Converts Request/Response/Blob/File/.. to a buffer (ArrayBuffer or Uint8Array).
  *
  * Prefers the newer `.bytes` method when available as it more efficient but not widely supported yet.
  */
-declare function loadBytes(source: Pick<Blob, 'arrayBuffer' | 'bytes'>): ReturnType<Blob['bytes']>;
+declare function readAsBuffer(source: Pick<Blob, 'arrayBuffer' | 'bytes'>): Promise<ArrayBuffer | Uint8Array>;
+
+type AnyFunction = (...args: any[]) => any;
+declare function once<T extends () => any>(fn: T): () => ReturnType<T>;
+declare function sequential<A extends any[], R>(fn: (...args: A) => Promise<R>): (...args: A) => Promise<R>;
 /**
- * Normalize text or binary-like inputs to either:
- * - the original string value, or
- * - a Uint8Array view over the source bytes.
+ * Executes the callback function after the current call stack has been cleared.
  */
-declare function toStringOrBytes(source: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>): string | Awaited<ReturnType<Blob['bytes']>>;
+declare function defer(callback: () => void): void;
 
-declare function isDeepEqual(a: unknown, b: unknown): boolean;
+type OmitChainMethodDeep<T extends object, K extends keyof any> = {
+    [P in keyof Omit<T, K>]: T[P] extends AnyFunction ? ((...args: Parameters<T[P]>) => OmitChainMethodDeep<ReturnType<T[P]>, K>) : T[P];
+};
 
 declare const ORPC_NAME = "orpc";
+declare const ORPC_SHARED_PACKAGE_NAME = "@orpc/shared";
+declare const ORPC_SHARED_PACKAGE_VERSION = "1.14.13";
 
-declare function isAbortError(error: unknown): error is Error;
-
-type AnyFunction = (...args: any[]) => any;
-declare function once<T>(fn: () => T): () => T;
 /**
- * Executes the callback function after the current call stack has been cleared.
+ * Error thrown when an operation is aborted.
+ * Uses the standardized 'AbortError' name for consistency with JavaScript APIs.
  */
-declare function defer(callback: () => void): void;
-declare function tryOrUndefined<T>(fn: () => T): undefined | T;
+declare class AbortError extends Error {
+    constructor(...rest: ConstructorParameters<typeof Error>);
+}
 
-declare function pathToHttpPath(path: readonly string[]): `/${string}`;
-declare function normalizeHttpPath(path: string): `/${string}`;
-declare function mergeHttpPath(a: `/${string}`, b: `/${string}`): `/${string}`;
-declare function matchesHttpPathPrefix(url: `/${string}`, prefix: `/${string}`): boolean;
-declare function matchesHttpPath(url: `/${string}`, path: `/${string}`): boolean;
-declare function isCompressibleContentType(contentType: string | null | undefined): boolean;
+interface EventPublisherOptions {
+    /**
+     * Maximum number of events to buffer for async iterator subscribers.
+     *
+     * If the buffer exceeds this limit, the oldest event is dropped.
+     * This prevents unbounded memory growth if consumers process events slowly.
+     *
+     * Set to:
+     * - `0`: Disable buffering. Events must be consumed before the next one arrives.
+     * - `1`: Only keep the latest event. Useful for real-time updates where only the most recent value matters.
+     * - `Infinity`: Keep all events. Ensures no data loss, but may lead to high memory usage.
+     *
+     * @default 100
+     */
+    maxBufferedEvents?: number;
+}
+interface EventPublisherSubscribeIteratorOptions extends EventPublisherOptions {
+    /**
+     * Aborts the async iterator. Throws if aborted before or during pulling.
+     */
+    signal?: AbortSignal | undefined;
+}
+declare class EventPublisher<T extends Record<PropertyKey, any>> {
+    #private;
+    constructor(options?: EventPublisherOptions);
+    get size(): number;
+    /**
+     * Emits an event and delivers the payload to all subscribed listeners.
+     */
+    publish<K extends keyof T>(event: K, payload: T[K]): void;
+    /**
+     * Subscribes to a specific event using a callback function.
+     * Returns an unsubscribe function to remove the listener.
+     *
+     * @example
+     * ```ts
+     * const unsubscribe = publisher.subscribe('event', (payload) => {
+     *   console.log(payload)
+     * })
+     *
+     * // Later
+     * unsubscribe()
+     * ```
+     */
+    subscribe<K extends keyof T>(event: K, listener: (payload: T[K]) => void): () => void;
+    /**
+     * Subscribes to a specific event using an async iterator.
+     * Useful for `for await...of` loops with optional buffering and abort support.
+     *
+     * @example
+     * ```ts
+     * for await (const payload of publisher.subscribe('event', { signal })) {
+     *   console.log(payload)
+     * }
+     * ```
+     */
+    subscribe<K extends keyof T>(event: K, options?: EventPublisherSubscribeIteratorOptions): AsyncGenerator<T[K]> & AsyncIteratorObject<T[K]>;
+}
 
+declare class SequentialIdGenerator {
+    private index;
+    generate(): string;
+}
 /**
  * Compares two sequential IDs.
  * Returns:
@@ -52,11 +112,8 @@ declare function isCompressibleContentType(contentType: string | null | undefine
  */
 declare function compareSequentialIds(a: string, b: string): number;
 
+type SetOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 type IntersectPick<T, U> = Pick<T, keyof T & keyof U>;
-/**
- * Remove protected/private properties/methods
- */
-type Public<T> = Pick<T, keyof T>;
 type PromiseWithError<T, TError> = Promise<T> & {
     __error?: {
         type: TError;
@@ -65,13 +122,14 @@ type PromiseWithError<T, TError> = Promise<T> & {
 /**
  * The place where you can config the orpc types.
  *
- * - `ThrowableError` the error type that represent throwable errors should be `Error` or `null | undefined | {}` if you want more strict.
+ * - `throwableError` the error type that represent throwable errors should be `Error` or `null | undefined | {}` if you want more strict.
  */
 interface Registry {
 }
 type ThrowableError = Registry extends {
-    ThrowableError: infer T;
+    throwableError: infer T;
 } ? T : Error;
+type InferAsyncIterableYield<T> = T extends AsyncIterable<infer U> ? U : never;
 
 type InterceptableOptions = Record<string, any>;
 type InterceptorOptions<TOptions extends InterceptableOptions, TResult> = Omit<TOptions, 'next'> & {
@@ -79,138 +137,136 @@ type InterceptorOptions<TOptions extends InterceptableOptions, TResult> = Omit<T
 };
 type Interceptor<TOptions extends InterceptableOptions, TResult> = (options: InterceptorOptions<TOptions, TResult>) => TResult;
 /**
- * Can used for interceptors or middlewares
+ * Can be used for interceptors or middlewares
  */
 declare function onStart<T, TOptions extends {
-    next: () => any;
+    next(): any;
 }, TRest extends any[]>(callback: NoInfer<(options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => T | Promise<Awaited<ReturnType<TOptions['next']>>>;
 /**
- * Can used for interceptors or middlewares
+ * Can be used for interceptors or middlewares
  */
 declare function onSuccess<T, TOptions extends {
-    next: () => any;
+    next(): any;
 }, TRest extends any[]>(callback: NoInfer<(result: Awaited<ReturnType<TOptions['next']>>, options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => T | Promise<Awaited<ReturnType<TOptions['next']>>>;
 /**
- * Can used for interceptors or middlewares
+ * Can be used for interceptors or middlewares
  */
 declare function onError<T, TOptions extends {
-    next: () => any;
+    next(): any;
 }, TRest extends any[]>(callback: NoInfer<(error: ReturnType<TOptions['next']> extends PromiseWithError<any, infer E> ? E : ThrowableError, options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => T | Promise<Awaited<ReturnType<TOptions['next']>>>;
 type OnFinishState<TResult, TError> = [error: TError, data: undefined, isSuccess: false] | [error: null, data: TResult, isSuccess: true];
 /**
- * Can used for interceptors or middlewares
+ * Can be used for interceptors or middlewares
  */
 declare function onFinish<T, TOptions extends {
-    next: () => any;
+    next(): any;
 }, TRest extends any[]>(callback: NoInfer<(state: OnFinishState<Awaited<ReturnType<TOptions['next']>>, ReturnType<TOptions['next']> extends PromiseWithError<any, infer E> ? E : ThrowableError>, options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => T | Promise<Awaited<ReturnType<TOptions['next']>>>;
-/**
- * Creates a middleware or interceptor that invokes a callback when the returned async
- * iterator object throws an error while being consumed.
- *
- * This does not replace the `onError`. `onError` only fires on the
- * initial call (before the interceptor returns the iterator), whereas this
- * callback only fires while consuming the iterator. Use both together to
- * catch all possible errors.
- */
-declare function onAsyncIteratorObjectError<T, TOptions extends {
-    next: () => any;
-}, TRest extends any[]>(callback: NoInfer<(error: ThrowableError | (ReturnType<TOptions['next']> extends PromiseWithError<any, infer E> ? E : ThrowableError), options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => T | Promise<Awaited<ReturnType<TOptions['next']>>>;
-/**
- * Creates an interceptor that invokes a callback when the returned readable
- * stream errors while being consumed.
- *
- * This does not replace the `onError`. `onError` only fires on the
- * initial call (before the interceptor returns the stream), whereas this
- * callback only fires while consuming the stream. Use both together to catch
- * all possible errors.
- */
-declare function onReadableStreamError<T, TOptions extends {
-    next: () => any;
-}, TRest extends any[]>(callback: NoInfer<(error: ThrowableError | (ReturnType<TOptions['next']> extends PromiseWithError<any, infer E> ? E : ThrowableError), options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => T | Promise<Awaited<ReturnType<TOptions['next']>>>;
-declare function intercept<TOptions extends InterceptableOptions, TResult>(interceptors: undefined | Interceptor<TOptions, TResult>[], options: NoInfer<TOptions>, main: NoInfer<(options: TOptions) => TResult>): TResult;
+declare function intercept<TOptions extends InterceptableOptions, TResult>(interceptors: Interceptor<TOptions, TResult>[], options: NoInfer<TOptions>, main: NoInfer<(options: TOptions) => TResult>): TResult;
 
 /**
  * Only import types from @opentelemetry/api to avoid runtime dependencies.
  */
 
-interface OpenTelemetryConfig {
+interface OtelConfig {
     tracer: Tracer;
     trace: TraceAPI;
     context: ContextAPI;
+    propagation: PropagationAPI;
+}
+/**
+ * Sets the global OpenTelemetry config.
+ * Call this once at app startup. Use `undefined` to disable tracing.
+ */
+declare function setGlobalOtelConfig(config: OtelConfig | undefined): void;
+/**
+ * Gets the global OpenTelemetry config.
+ * Returns `undefined` if OpenTelemetry is not configured, initialized, or enabled.
+ */
+declare function getGlobalOtelConfig(): OtelConfig | undefined;
+/**
+ * Starts a new OpenTelemetry span with the given name and options.
+ *
+ * @returns The new span, or `undefined` if no tracer is set.
+ */
+declare function startSpan(name: string, options?: SpanOptions, context?: Context): Span | undefined;
+interface SetSpanErrorOptions {
     /**
-     * propagation is optional, can reduce bundle size in some cases.
+     * Span error status is not set if error is due to cancellation by the signal.
      */
-    propagation?: PropagationAPI | undefined;
+    signal?: AbortSignal;
 }
-declare function setOpenTelemetryConfig(config: OpenTelemetryConfig | undefined): void;
-declare function getOpenTelemetryConfig(): OpenTelemetryConfig | undefined;
-interface StartSpanOptions extends SpanOptions {
+/**
+ * Records and sets the error status on the given span.
+ * If the span is `undefined`, it does nothing.
+ */
+declare function setSpanError(span: Span | undefined, error: unknown, options?: SetSpanErrorOptions): void;
+declare function setSpanAttribute(span: Span | undefined, key: string, value: AttributeValue | undefined): void;
+/**
+ * Converts an error to an OpenTelemetry Exception.
+ */
+declare function toOtelException(error: unknown): Exclude<Exception, string>;
+/**
+ * Converts a value to a string suitable for OpenTelemetry span attributes.
+ */
+declare function toSpanAttributeValue(data: unknown): string;
+interface RunWithSpanOptions extends SpanOptions, SetSpanErrorOptions {
     /**
      * The name of the span to create.
      */
     name: string;
     /**
-     * Context to use for the created span.
+     * Context to use for the span.
      */
     context?: Context;
 }
-declare function startSpan(options: StartSpanOptions | string): Span | undefined;
-declare function recordSpanError(span: Span | undefined, error: unknown): void;
-declare function setSpanAttributeIfDefined(span: Span | undefined, key: string, value: AttributeValue | undefined): void;
-declare function toOtelException(error: unknown): Exclude<Exception, string>;
-declare function toSpanAttributeValue(data: unknown): string;
-interface RunWithSpanOptions extends StartSpanOptions {
-}
-declare function runWithSpan<T>(options: string | RunWithSpanOptions, fn: (span?: Span) => Promisable<T>): Promise<T>;
+/**
+ * Runs a function within the context of a new OpenTelemetry span.
+ * The span is ended automatically, and errors are recorded to the span.
+ */
+declare function runWithSpan<T>({ name, context, ...options }: RunWithSpanOptions, fn: (span?: Span) => Promisable<T>): Promise<T>;
+/**
+ * Runs a function within the context of an existing OpenTelemetry span.
+ */
 declare function runInSpanContext<T>(span: Span | undefined, fn: () => Promisable<T>): Promise<T>;
 
-interface WrapAsyncIteratorOptions<TYield, TReturn, TMappedYield, TMappedReturn> {
-    /**
-     * Any call to the original iterator will be executed inside this function.
-     * Useful when you want execution to happen within a specific context,
-     * such as AsyncLocalStorage.
-     */
-    runWith?: <T>(run: () => Promise<T>) => Promise<T>;
-    mapResult?: (result: IteratorResult<TYield, TReturn>) => Promisable<IteratorResult<TMappedYield, TMappedReturn>>;
-    mapError?: (error: ThrowableError) => Promisable<ThrowableError>;
-    onError?: (error: ThrowableError) => Promisable<void>;
+declare function isAsyncIteratorObject(maybe: unknown): maybe is AsyncIteratorObject<any, any, any>;
+interface AsyncIteratorClassNextFn<T, TReturn> {
+    (): Promise<IteratorResult<T, TReturn>>;
+}
+interface AsyncIteratorClassCleanupFn {
+    (reason: 'return' | 'throw' | 'next' | 'dispose'): Promise<void>;
+}
+declare const fallbackAsyncDisposeSymbol: unique symbol;
+declare const asyncDisposeSymbol: typeof Symbol extends {
+    asyncDispose: infer T;
+} ? T : typeof fallbackAsyncDisposeSymbol;
+declare class AsyncIteratorClass<T, TReturn = unknown, TNext = unknown> implements AsyncIteratorObject<T, TReturn, TNext>, AsyncGenerator<T, TReturn, TNext> {
+    #private;
+    constructor(next: AsyncIteratorClassNextFn<T, TReturn>, cleanup: AsyncIteratorClassCleanupFn);
+    next(): Promise<IteratorResult<T, TReturn>>;
+    return(value?: any): Promise<IteratorResult<T, TReturn>>;
+    throw(err: any): Promise<IteratorResult<T, TReturn>>;
     /**
-     * Execute after the stream finishes or is cancelled.
+     * asyncDispose symbol only available in esnext, we should fallback to Symbol.for('asyncDispose')
      */
-    onFinish?: () => Promisable<void>;
+    [asyncDisposeSymbol](): Promise<void>;
+    [Symbol.asyncIterator](): this;
 }
-declare function wrapAsyncIterator<TYield, TReturn, TMappedYield = TYield, TMappedReturn = TReturn>(iterator: AsyncIterator<TYield, TReturn>, { runWith, mapResult, mapError, onError, onFinish }: WrapAsyncIteratorOptions<TYield, TReturn, TMappedYield, TMappedReturn>): NoInfer<AsyncIteratorClass<TMappedYield, TMappedReturn>>;
-declare function traceAsyncIterator<T, TReturn, TNext>(options: StartSpanOptions | string, iterator: AsyncIterator<T, TReturn, TNext>): AsyncIteratorClass<T, TReturn, TNext>;
 declare function replicateAsyncIterator<T, TReturn, TNext>(source: AsyncIterator<T, TReturn, TNext>, count: number): (AsyncIteratorClass<T, TReturn, TNext>)[];
-interface ConsumeAsyncIteratorOptions<T, TReturn, TError> {
-    /**
-     * Called on each event
-     */
-    onEvent: (event: T) => void;
+interface AsyncIteratorWithSpanOptions extends SetSpanErrorOptions {
     /**
-     * Called once error happens
-     */
-    onError?: (error: TError) => void;
-    /**
-     * Called once AsyncIteratorObject is done
-     *
-     * @info If iterator is canceled, `undefined` can be passed on success
-     */
-    onSuccess?: (value: TReturn | undefined) => void;
-    /**
-     * Called once after onError or onSuccess
-     *
-     * @info If iterator is canceled, `undefined` can be passed on success
+     * The name of the span to create.
      */
-    onFinish?: (state: [error: TError, data: undefined, isSuccess: false] | [error: null, data: TReturn | undefined, isSuccess: true]) => void;
+    name: string;
 }
-/**
- * Consumes an AsyncIteratorObject with lifecycle callbacks
- *
- * @warning If no `onError` or `onFinish` is provided, error will be thrown into unhandled rejection channel.
- * @return unsubscribe callback
- */
-declare function consumeAsyncIterator<T, TReturn, TError = ThrowableError>(iterator: AsyncIterator<T, TReturn> | PromiseWithError<AsyncIterator<T, TReturn>, TError>, options: ConsumeAsyncIteratorOptions<T, TReturn, TError | ThrowableError>): () => Promise<void>;
+declare function asyncIteratorWithSpan<T, TReturn, TNext>({ name, ...options }: AsyncIteratorWithSpanOptions, iterator: AsyncIterator<T, TReturn, TNext>): AsyncIteratorClass<T, TReturn, TNext>;
+
+declare function parseEmptyableJSON(text: string | null | undefined): unknown;
+declare function stringifyJSON<T>(value: T | {
+    toJSON(): T;
+}): undefined extends T ? undefined | string : string;
+
+declare function logError(error: unknown): void;
 
 type Segment = string | number;
 declare function findDeepMatches(check: (value: unknown) => boolean, payload: unknown, segments?: Segment[], maps?: Segment[][], values?: unknown[]): {
@@ -223,72 +279,43 @@ declare function findDeepMatches(check: (value: unknown) => boolean, payload: un
  */
 declare function getConstructor(value: unknown): Function | null | undefined;
 /**
- * Checks whether a value is a plain object, including objects created with
- * `Object.create(null)`.
+ * Check if the value is an object even it created by `Object.create(null)` or more tricky way.
  */
-declare function isPlainObject(value: unknown): value is Record<PropertyKey, unknown>;
-declare function get(object: unknown, path: readonly PropertyKey[]): unknown;
+declare function isObject(value: unknown): value is Record<PropertyKey, unknown>;
 /**
- * Sets a value at the given path, creating plain objects for intermediate keys as needed.
+ * Check if the value satisfy a `object` type in typescript
  */
-declare function set(root: object, path: [PropertyKey, ...PropertyKey[]] | [...PropertyKey[], PropertyKey], value: unknown): void;
-declare function omit<T extends object, K extends keyof T>(obj: T, keys: readonly K[]): Omit<T, K>;
+declare function isTypescriptObject(value: unknown): value is object & Record<PropertyKey, unknown>;
 declare function clone<T>(value: T): T;
+declare function get(object: unknown, path: readonly PropertyKey[]): unknown;
 declare function isPropertyKey(value: unknown): value is PropertyKey;
 declare const NullProtoObj: ({
     new <T extends Record<PropertyKey, unknown>>(): T;
 });
-/**
- * Returns an object containing all methods of the given object, with each
- * method bound to the original object instance.
- *
- * Methods are collected from both the object itself and its prototype chain
- * (excluding `Object.prototype` and the `constructor` property).
- */
-declare function bindMethods<T extends object>(obj: T): Pick<T, {
-    [K in keyof T]: T[K] extends AnyFunction ? K : never;
-}[keyof T]>;
 
-interface OrderablePlugin {
-    /** Unique name of the plugin, used for ordering and identification. */
-    name: string;
-    /** Plugins this plugin should execute before. */
-    before?: string[] | undefined;
-    /** Plugins this plugin should execute after. */
-    after?: string[] | undefined;
-}
+type Value<T, TArgs extends any[] = []> = T | ((...args: TArgs) => T);
+declare function value<T, TArgs extends any[]>(value: Value<T, TArgs>, ...args: NoInfer<TArgs>): T extends Value<infer U, any> ? U : never;
 /**
- * Sorts plugins based on their `before` and `after` dependencies.
+ * Returns the value if it is defined, otherwise returns the fallback
  */
-declare function sortPlugins<T extends OrderablePlugin>(plugins: T[]): T[];
+declare function fallback<T>(value: T | undefined, fallback: T): T;
 
 /**
- * Creates a promise together with its associated `resolve` and `reject`
- * functions.
- *
- * Equivalent to `Promise.withResolvers()`, but works in environments
- * where that API is not yet available.
+ * Prevents objects from being awaitable by intercepting the `then` method
+ * when called by the native await mechanism. This is useful for preventing
+ * accidental awaiting of objects that aren't meant to be promises.
  */
-declare function promiseWithResolvers<T>(): {
-    promise: Promise<T>;
-    resolve: (v: T) => void;
-    reject: (reason: unknown) => void;
-};
-
-type Value<T, TArgs extends any[] = []> = T | ((...args: TArgs) => T);
-declare function value<T, TArgs extends any[]>(value: Value<T, TArgs>, ...args: NoInfer<TArgs>): T extends Value<infer U, any> ? U : never;
-
+declare function preventNativeAwait<T extends object>(target: T): T;
 /**
- * Creates a proxy that overlays a `partial` object on top of a `target`.
+ * Create a proxy that overlays one object (`overlay`) on top of another (`target`).
  *
- * - Properties from `partial` take precedence.
- * - Properties not present in `partial` fall back to the resolved `target`.
- * - Methods are bound to the proxy to ensure a consistent `this` context.
+ * - Properties from `overlay` take precedence.
+ * - Properties not in `overlay` fall back to `target`.
+ * - Methods from either object are bound to `overlay` so `this` is consistent.
  *
- * Useful for overriding specific properties of an object while delegating
- * all other access to the original target without needing to know its full structure.
+ * Useful when you want to override or extend behavior without fully copying/merging objects.
  */
-declare function override<T extends object, U extends object>(target: Value<T>, partial: U): U & Omit<T, keyof U>;
+declare function overlayProxy<T extends object, U extends object>(target: Value<T>, partial: U): U & Omit<T, keyof U>;
 
 interface AsyncIdQueueCloseOptions {
     id?: string;
@@ -298,57 +325,21 @@ declare class AsyncIdQueue<T> {
     private readonly openIds;
     private readonly queues;
     private readonly waiters;
-    get size(): number;
+    get length(): number;
+    get waiterIds(): string[];
+    hasBufferedItems(id: string): boolean;
     open(id: string): void;
     isOpen(id: string): boolean;
     push(id: string, item: T): void;
     pull(id: string): Promise<T>;
     close({ id, reason }?: AsyncIdQueueCloseOptions): void;
-    private assertOpen;
+    assertOpen(id: string): void;
 }
 
 /**
- * Returns a signal that aborts only after all provided signals are aborted.
- */
-declare function allAbortSignal(signals: readonly (AbortSignal | undefined)[]): AbortSignal | undefined;
-/**
- * Returns a signal that aborts as soon as any of the provided signals aborts,
- * with the same abort reason.
- */
-declare function anyAbortSignal(signals: readonly (AbortSignal | undefined)[]): AbortSignal | undefined;
-declare function runWithSignal<T>(signal: AbortSignal | undefined, fn: () => Promise<T>): Promise<T>;
-
-declare function replicateReadableStream<T>(stream: ReadableStream<T>, count: number): ReadableStream<T>[];
-type ReadableStreamReadResult<T> = {
-    done: false;
-    value: T;
-} | {
-    done: true;
-    value?: undefined | T;
-};
-interface WrapReadableStreamOptions<T, TMapped> {
-    /**
-     * Any call to the original stream reader will be executed inside this function.
-     * Useful when you want execution to happen within a specific context,
-     * such as AsyncLocalStorage.
-     */
-    runWith?: <T>(run: () => Promise<T>) => Promise<T>;
-    mapResult?: (result: ReadableStreamReadResult<T>) => Promisable<ReadableStreamReadResult<TMapped>>;
-    mapError?: (error: ThrowableError) => Promisable<ThrowableError>;
-    onError?: (error: ThrowableError) => Promisable<void>;
-    /**
-     * Guaranteed to execute exactly once after the stream finishes or is cancelled.
-     */
-    onFinish?: () => Promisable<void>;
-}
-declare function wrapReadableStream<T, TMapped = T>(stream: ReadableStream<T>, { runWith, mapResult, mapError, onError, onFinish }: WrapReadableStreamOptions<T, TMapped>): NoInfer<ReadableStream<TMapped>>;
-declare function traceReadableStream<T>(options: StartSpanOptions | string, stream: ReadableStream<T>): ReadableStream<T>;
-/**
- * Converts a {@link ReadableStream} into an {@link AsyncIteratorClass}.
+ * Converts a `ReadableStream` into an `AsyncIteratorClass`.
  */
-declare function streamToAsyncIteratorObject<T>(stream: ReadableStream<T>, { signal }?: {
-    signal?: undefined | AbortSignal;
-}): AsyncIteratorClass<T>;
+declare function streamToAsyncIteratorClass<T>(stream: ReadableStream<T>): AsyncIteratorClass<T>;
 /**
  * Converts an `AsyncIterator` into a `ReadableStream`.
  */
@@ -361,5 +352,5 @@ declare function asyncIteratorToUnproxiedDataStream<T>(iterator: AsyncIterator<T
 
 declare function tryDecodeURIComponent(value: string): string;
 
-export { AsyncIdQueue, NullProtoObj, ORPC_NAME, allAbortSignal, anyAbortSignal, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, bindMethods, clone, compareSequentialIds, consumeAsyncIterator, defer, findDeepMatches, get, getConstructor, getOpenTelemetryConfig, intercept, isAbortError, isCompressibleContentType, isDeepEqual, isPlainObject, isPropertyKey, loadBytes, matchesHttpPath, matchesHttpPathPrefix, mergeHttpPath, normalizeHttpPath, omit, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, once, override, pathToHttpPath, promiseWithResolvers, recordSpanError, replicateAsyncIterator, replicateReadableStream, resolveMaybeOptionalOptions, runInSpanContext, runWithSignal, runWithSpan, set, setOpenTelemetryConfig, setSpanAttributeIfDefined, sortPlugins, splitInHalf, startSpan, streamToAsyncIteratorObject, toOtelException, toSpanAttributeValue, toStringOrBytes, traceAsyncIterator, traceReadableStream, tryDecodeURIComponent, tryOrUndefined, value, wrapAsyncIterator, wrapReadableStream };
-export type { AnyFunction, AsyncIdQueueCloseOptions, ConsumeAsyncIteratorOptions, InterceptableOptions, Interceptor, InterceptorOptions, IntersectPick, MaybeOptionalOptions, OnFinishState, OpenTelemetryConfig, OrderablePlugin, PromiseWithError, Public, ReadableStreamReadResult, Registry, RunWithSpanOptions, Segment, StartSpanOptions, ThrowableError, Value, WrapAsyncIteratorOptions, WrapReadableStreamOptions };
+export { AbortError, AsyncIdQueue, AsyncIteratorClass, EventPublisher, NullProtoObj, ORPC_NAME, ORPC_SHARED_PACKAGE_NAME, ORPC_SHARED_PACKAGE_VERSION, SequentialIdGenerator, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, asyncIteratorWithSpan, clone, compareSequentialIds, defer, fallback, findDeepMatches, get, getConstructor, getGlobalOtelConfig, intercept, isAsyncIteratorObject, isObject, isPropertyKey, isTypescriptObject, logError, onError, onFinish, onStart, onSuccess, once, overlayProxy, parseEmptyableJSON, preventNativeAwait, readAsBuffer, replicateAsyncIterator, resolveMaybeOptionalOptions, runInSpanContext, runWithSpan, sequential, setGlobalOtelConfig, setSpanAttribute, setSpanError, splitInHalf, startSpan, streamToAsyncIteratorClass, stringifyJSON, toArray, toOtelException, toSpanAttributeValue, tryDecodeURIComponent, value };
+export type { AnyFunction, AsyncIdQueueCloseOptions, AsyncIteratorClassCleanupFn, AsyncIteratorClassNextFn, AsyncIteratorWithSpanOptions, EventPublisherOptions, EventPublisherSubscribeIteratorOptions, InferAsyncIterableYield, InterceptableOptions, Interceptor, InterceptorOptions, IntersectPick, MaybeOptionalOptions, OmitChainMethodDeep, OnFinishState, OtelConfig, PromiseWithError, Registry, RunWithSpanOptions, Segment, SetOptional, SetSpanErrorOptions, ThrowableError, Value };