js-valkey-server 0.3.0

package/dist/core.d.ts

@@ -0,0 +1,651 @@
+import { F as FeatureId, V as VersionGate, a6 as ExecutionPolicy, a7 as RedisClusterTopology, a8 as RedisClientSession, a as RedisServerState, d as CommandExecutor, a9 as RedisClusterNodeRole, aa as ParkHandler, ab as RedisTurnQueue, ac as ClientSessionMode, ad as RespVersion, ae as RedisDatabase, af as CommandPlan, ag as RedisResult, ah as Unsubscribe, ai as ExecutorResult, aj as RedisTurnHandle, ak as RedisMonitorContext, al as RedisExecutionContext, L as Logger, am as RespEncodeOptions, an as CommandDefinition, C as CompatibilitySpec, f as CompatibilityProfile, ao as CommandRegistry } from './redis-error-C96iHLJ-.js';
+export { ap as AtLeastOneInputKeyError, aq as BitOffsetError, ar as BitOpNotSingleKeyError, as as BitPosBitError, at as BitValueError, au as BitfieldOverflowTypeError, av as BitfieldRoGetOnlyError, aw as BitfieldTypeError, ax as CommandCapabilities, ay as CommandExecutionResult, az as CommandFlag, aA as CommandSchema, g as CountGreaterThanZeroError, aB as DbIndexOutOfRangeError, D as DiscardWithoutMultiError, aC as ExecCommandAbortError, E as ExecWithoutMultiError, h as ExpectedFloatError, i as ExpectedIntegerError, aD as ExpirationState, aE as ExpireGtLtConflictError, aF as ExpireNxXxGtLtConflictError, aG as GeoAnyRequiresCountError, aH as GeoBoxNegativeError, aI as GeoCountNotPositiveError, aJ as GeoHeightNotNumericError, aK as GeoMissingMemberError, aL as GeoRadiusNegativeError, aM as GeoRadiusNotNumericError, aN as GeoRadiusStoreWithOptionsError, aO as GeoSearchStoreWithOptionsError, aP as GeoUnsupportedUnitError, aQ as GeoWidthNotNumericError, H as HashValueNotFloatError, j as HashValueNotIntegerError, aR as HelloProtocolNotIntegerError, aS as IncrByFloatNanOrInfinityError, aT as IncrDecrOverflowError, I as IndexOutOfRangeError, aU as InferSchema, k as InvalidExpireTimeError, aV as InvalidHllError, aW as InvalidLexRangeError, aX as InvalidLongitudeLatitudeError, aY as InvalidStreamIdError, aZ as KeyspaceEntry, l as LimitCantBeNegativeError, a_ as LposCountNegativeError, a$ as LposMaxlenNegativeError, b0 as LposRankZeroError, b1 as LuaReplyValue, M as MinMaxNotFloatError, N as NoAuthError, m as NoPasswordConfiguredError, b2 as NoProtoError, n as NoScriptError, o as NoSuchKeyError, p as NumKeysGreaterThanZeroError, O as OffsetOutOfRangeError, b3 as ParkRequest, b4 as ParseContext, b5 as ParseNodeResult, P as PositiveCountError, b6 as REDIS_CLUSTER_SLOT_COUNT, R as RedisCluster, q as RedisClusterDownError, b7 as RedisClusterNode, b as RedisClusterNodeHandle, r as RedisClusterOptions, s as RedisCommandError, t as RedisCrossSlotError, b8 as RedisDataTypeName, b9 as RedisDataValue, u as RedisFlavor, ba as RedisFunctionRegistry, bb as RedisHashData, bc as RedisHashField, bd as RedisKeyspace, be as RedisListData, bf as RedisLuaRuntime, bg as RedisMonitorCommandEvent, bh as RedisMonitorCommandListener, bi as RedisMonitorFeed, v as RedisMovedError, bj as RedisMutationBus, bk as RedisMutationEvent, bl as RedisMutationListener, bm as RedisPubSubBroker, bn as RedisResultOptions, bo as RedisScriptCache, bp as RedisServerStateOptions, bq as RedisSetData, br as RedisSortedSetData, bs as RedisSortedSetMember, bt as RedisStreamData, bu as RedisStringData, w as RedisSyntaxError, e as RedisValue, c as Resp2Server, bv as Resp2ServerOptions, bw as ResponseStream, x as ResultingScoreNaNError, bx as SameObjectError, S as ScriptCallNoCommandError, y as ScriptDebugModeError, z as ScriptFlushOptionError, by as ScriptNotAllowedCommandError, A as ScriptUnknownCommandError, bz as SerialTurnQueue, bA as SetOptions, bB as SortScoreNotDoubleError, B as StreamElementTooLargeError, bC as StreamIdEqualOrSmallerError, G as StreamIdExhaustedError, bD as StreamIdNotGreaterThanZeroError, bE as StreamLimitNegativeError, bF as StreamLimitRequiresApproxError, bG as TimeoutNegativeError, bH as TimeoutNotFloatError, T as TransactionDiscardedError, U as UnknownClusterSubcommandError, J as UnknownRedisCommandError, K as UnknownScriptSubcommandError, bI as UnsupportedOptionError, W as WatchInsideMultiError, bJ as WeightNotFloatError, Q as WrongNumberOfArgumentsError, X as WrongNumberOfKeysError, Y as WrongPassError, bK as WrongRedisTypeError, Z as WrongTypeRedisError, _ as ZaddGtLtNxConflictError, $ as ZaddIncrPairError, a0 as ZaddNxXxConflictError, bL as ZrangeLimitWithoutByError, bM as ZrangeWithScoresByLexError, a1 as buildRedisCluster, bN as cloneRedisDataValue, a2 as computeSlotRange, bO as createDefaultParkHandler, bP as createHashData, bQ as createListData, bR as createNonBlockingParkHandler, bS as createNoopParkHandler, a3 as createRedisCluster, bT as createRedisLuaRuntime, bU as createSetData, bV as createSortedSetData, bW as createStringData, bX as defineCommand, bY as encodeRedisResult, bZ as encodeRedisValue, a4 as gateSatisfied, b_ as isResponseStream, b$ as luaReplyToRedisValue, c0 as parseCommandArgs, c1 as parseVersion, a5 as resolveCompatibilityProfile, c2 as setLuaWasmLoadOptions, c3 as t } from './redis-error-C96iHLJ-.js';
+import { Socket } from 'net';
+import { Duplex } from 'node:stream';
+import 'lua-redis-wasm';
+
+declare const FEATURE_GATES: Record<FeatureId, VersionGate>;
+
+declare function createTransactionPolicy(): ExecutionPolicy;
+
+/**
+ * Enforces `requirepass`: when the server is password-protected and the session
+ * has not yet authenticated, every command outside {@link NO_AUTH_COMMANDS} is
+ * short-circuited with `-NOAUTH Authentication required.`. When no password is
+ * configured the policy is a no-op, so the default `nopass` user can run
+ * anything.
+ */
+declare function createAuthPolicy(): ExecutionPolicy;
+
+type ClusterPolicyOptions = {
+    localNodeId: string;
+    topology?: RedisClusterTopology;
+};
+declare function createClusterPolicy(options: ClusterPolicyOptions): ExecutionPolicy;
+
+type ClientSessionOptions = {
+    id?: string;
+    clientAddress?: string;
+    server: RedisServerState;
+    executor: CommandExecutor;
+    database?: number;
+    nodeRole?: RedisClusterNodeRole;
+    signal?: AbortSignal;
+    park?: ParkHandler;
+    turnQueue?: RedisTurnQueue;
+    closeConnection?: (reason?: string) => void;
+};
+/**
+ * Mutable view of the turn currently held by an in-flight command. A blocking
+ * command suspends its turn while parked and is later resumed on a *new* handle,
+ * so the holder must be able to both read the current turn and swap it.
+ */
+type TurnAccess = {
+    get(): RedisTurnHandle | undefined;
+    set(turn: RedisTurnHandle | undefined): void;
+};
+/**
+ * Per-connection server state and the concrete {@link RedisClientSession}.
+ *
+ * One instance exists per connected client and owns everything that is scoped
+ * to that connection rather than to the shared server:
+ *  - the selected database index and the resolved {@link RedisDatabase};
+ *  - the session {@link ClientSessionMode} (normal / transaction / subscribed);
+ *  - the negotiated RESP protocol version (HELLO);
+ *  - the cluster READONLY flag (replica reads via READONLY/READWRITE);
+ *  - the MULTI command queue and its dirty bit;
+ *  - WATCH key registrations for optimistic locking.
+ *
+ * Commands are serialized through a per-database turn queue so that, even though
+ * execution is async, only one command mutates a given database at a time. This
+ * is also what makes blocking commands (BLPOP, ...) cooperate instead of
+ * deadlock — see {@link createTurnAwareParkHandler}.
+ */
+declare class ClientSession implements RedisClientSession {
+    private static nextId;
+    readonly id: string;
+    readonly clientAddress?: string;
+    readonly connectedAtMs: number;
+    readonly server: RedisServerState;
+    /** Aborted when the connection closes; threaded into every command's ctx. */
+    readonly signal: AbortSignal;
+    private readonly executor;
+    private readonly signalSource?;
+    private readonly nodeRole?;
+    private readonly parkHandler;
+    private readonly turnQueueOverride?;
+    private readonly closeConnection?;
+    /**
+     * The turn handle of the command currently executing on this session,
+     * exposed so {@link executeTransaction} can hand the turn off to another
+     * database's queue when a queued SELECT switches databases mid-EXEC.
+     */
+    private activeTurnAccess?;
+    private selectedDatabaseId;
+    private sessionMode;
+    private respVersion;
+    private authenticated;
+    /** Set by READONLY, cleared by READWRITE/RESET; lets a replica serve reads. */
+    private clusterReadOnlyMode;
+    /** Commands buffered between MULTI and EXEC, in submission order. */
+    private transactionPlans;
+    /** True once a queued command errored — forces EXEC to abort with EXECABORT. */
+    private transactionDirty;
+    /** Active WATCH registrations, keyed by `db:keyHex`. */
+    private readonly watches;
+    /** Subset of watched keys mutated since WATCH — non-empty fails the next EXEC. */
+    private readonly dirtyWatches;
+    private readonly pubsubChannels;
+    private readonly pubsubShardChannels;
+    private readonly pubsubPatterns;
+    private readonly pushQueue;
+    private readonly pushWaiters;
+    private deferredPushes;
+    private pushQueueClosed;
+    private readonly responseStreamCleanups;
+    private unregisterClientSession?;
+    constructor(options: ClientSessionOptions);
+    get selectedDatabase(): number;
+    get mode(): ClientSessionMode;
+    get protocolVersion(): RespVersion;
+    get usesSubscribedReplyMode(): boolean;
+    get clusterReadOnly(): boolean;
+    get isAuthenticated(): boolean;
+    get pubsubChannelCount(): number;
+    get pubsubShardChannelCount(): number;
+    get pubsubPatternCount(): number;
+    get pubsubRegularSubscriptionCount(): number;
+    get pubsubSubscriptionCount(): number;
+    setAuthenticated(value: boolean): void;
+    /** The live database object for the currently selected index. */
+    get db(): RedisDatabase;
+    setProtocolVersion(version: RespVersion): void;
+    /** Toggle replica read mode for this connection (READONLY / READWRITE). */
+    setClusterReadOnly(value: boolean): void;
+    selectDatabase(database: number): void;
+    /** MULTI: enter transaction mode. Redis forbids nesting. */
+    beginTransaction(): void;
+    /** Buffer one command while in MULTI; replies "+QUEUED" to the client. */
+    queueTransaction(plan: CommandPlan): void;
+    /**
+     * EXEC step 1: hand back the queued plans and atomically reset the session to
+     * normal mode (clearing the queue, dirty bit, and WATCHes). The caller is
+     * responsible for actually running the returned plans via
+     * {@link executeTransaction}. Returns an empty list if not in MULTI.
+     */
+    drainTransaction(): CommandPlan[];
+    /** DISCARD: drop the queued commands and leave transaction mode. */
+    discardTransaction(): void;
+    /** Flag the transaction as poisoned (a queued command failed). No-op outside MULTI. */
+    markTransactionDirty(): void;
+    isTransactionDirty(): boolean;
+    /**
+     * EXEC step 2: run the drained plans in order and collect their replies into a
+     * single array reply. Each command runs in its own fresh execution context.
+     * Streaming commands (SUBSCRIBE/MONITOR) are not permitted inside a
+     * transaction: the stream is closed immediately and replaced with an error
+     * entry so the array stays positionally aligned with the queued commands.
+     */
+    executeTransaction(plans: readonly CommandPlan[]): Promise<RedisResult>;
+    private appendTransactionValue;
+    /**
+     * Release the currently held serialization turn and acquire a fresh one on
+     * the selected database's queue. Called when a queued SELECT switches
+     * databases mid-EXEC so subsequent commands run under the correct
+     * per-database turn (see {@link executeTransaction}).
+     *
+     * No-op when a fixed turn-queue override is in force (a single queue already
+     * serializes every database) or when no managed turn is active.
+     */
+    private handoffTurnToSelectedDb;
+    /**
+     * WATCH the given keys for optimistic locking. Each key is subscribed in the
+     * keyspace; any mutation flips its entry into {@link dirtyWatches}, which a
+     * subsequent EXEC checks via {@link isWatchDirty}. Already-watched keys are
+     * skipped so re-WATCHing is idempotent.
+     */
+    watch(keys: readonly Buffer[]): void;
+    /** UNWATCH / cleanup: drop every keyspace subscription and clear dirty state. */
+    unwatch(): void;
+    /** True if any watched key was mutated since WATCH — EXEC must return nil. */
+    isWatchDirty(): boolean;
+    subscribePubSubChannels(channels: readonly Buffer[]): RedisResult[];
+    unsubscribePubSubChannels(channels: readonly Buffer[]): RedisResult[];
+    subscribePubSubShardChannels(channels: readonly Buffer[]): RedisResult[];
+    unsubscribePubSubShardChannels(channels: readonly Buffer[]): RedisResult[];
+    subscribePubSubPatterns(patterns: readonly Buffer[]): RedisResult[];
+    unsubscribePubSubPatterns(patterns: readonly Buffer[]): RedisResult[];
+    resetPubSub(): void;
+    deferPushesUntilAfterReply(): () => void;
+    registerResponseStreamCleanup(cleanup: () => void): Unsubscribe;
+    resetResponseStreams(): void;
+    enqueuePush(result: RedisResult): void;
+    readPushes(signal: AbortSignal): AsyncIterable<RedisResult>;
+    /**
+     * Public entry point for executing one client command.
+     *
+     * Acquires a turn on the database's turn queue before running, guaranteeing
+     * serialized access to the keyspace, and always releases it afterward. The
+     * acquired turn is exposed to the command via a turn-aware park handler so a
+     * blocking command can yield the turn while parked (see
+     * {@link createTurnAwareParkHandler}); `turn` is reassigned through the
+     * {@link TurnAccess} closure because suspending returns a *new* handle.
+     */
+    execute(rawCommand: Buffer | string, rawArgs: readonly Buffer[]): Promise<ExecutorResult>;
+    /**
+     * Build the {@link RedisExecutionContext} passed to a command's `execute`.
+     * When a turn is supplied (the normal client path) the context gets a
+     * turn-aware park handler so blocking commands release their turn while
+     * waiting; without one (e.g. nested transaction execution) the plain park
+     * handler is used.
+     */
+    createExecutionContext(turnAccess?: TurnAccess, parkOverride?: ParkHandler, monitor?: RedisMonitorContext, transactionReplay?: boolean): RedisExecutionContext;
+    /** Tear down the session: abort in-flight work and reset all per-connection state. */
+    close(): void;
+    disconnect(reason?: string): void;
+    /**
+     * Wrap the base park handler so that parking also yields the command's turn.
+     *
+     * Blocking commands (BLPOP, BRPOP, ...) must not hold the database turn while
+     * they wait, or no other client could ever produce the value that unblocks
+     * them — a deadlock. The flow:
+     *  1. Start the underlying park, capturing its eventual value.
+     *  2. Clear the local turn and call `turn.suspend(parked)`, which releases the
+     *     turn back to the queue and resolves with a fresh turn once the park
+     *     settles and this session is scheduled again.
+     *  3. Store the new turn (so `finally`/subsequent parks see it) and return the
+     *     parked value.
+     *
+     * If there is no current turn, fall back to plain parking.
+     */
+    private createTurnAwareParkHandler;
+    private refreshPubSubMode;
+    private waitForPush;
+    private closePushQueue;
+    private wakePushWaiters;
+}
+
+type ConnectionTransportEvent = 'close' | 'drain' | 'error';
+type ConnectionTransportListener = (error?: Error) => void;
+type ConnectionTransportUnsubscribe = () => void;
+interface ConnectionTransport {
+    readonly id: string;
+    readonly signal: AbortSignal;
+    read(): AsyncIterable<Buffer>;
+    write(chunk: Buffer): void | Promise<void>;
+    close(reason?: string): void;
+    on(event: ConnectionTransportEvent, listener: ConnectionTransportListener): ConnectionTransportUnsubscribe;
+}
+
+type SocketConnectionTransportOptions = {
+    id?: string;
+};
+declare class SocketConnectionTransport implements ConnectionTransport {
+    private readonly socket;
+    private static nextId;
+    readonly id: string;
+    readonly signal: AbortSignal;
+    private readonly controller;
+    private closed;
+    constructor(socket: Socket, options?: SocketConnectionTransportOptions);
+    read(): AsyncIterable<Buffer>;
+    write(chunk: Buffer): Promise<void>;
+    close(_reason?: string): void;
+    on(event: ConnectionTransportEvent, listener: ConnectionTransportListener): ConnectionTransportUnsubscribe;
+    private abort;
+}
+
+type Resp2CommandFrame = {
+    command: Buffer;
+    args: Buffer[];
+};
+type Resp2DecodeResult = {
+    frames: Resp2CommandFrame[];
+    error?: Resp2ParseError;
+};
+declare class Resp2ParseError extends Error {
+    constructor(message: string);
+}
+declare class Resp2CommandDecoder {
+    private buffered;
+    push(chunk: Buffer): Resp2DecodeResult;
+    private parseFrame;
+    private parseArrayFrame;
+    private parseInlineFrame;
+}
+
+type Resp2SessionAdapterOptions = {
+    transport: ConnectionTransport;
+    session: ClientSession;
+    logger?: Pick<Logger, 'error'>;
+    encoder?: RespEncodeOptions;
+};
+declare class Resp2SessionAdapter {
+    private readonly decoder;
+    private readonly transport;
+    private readonly session;
+    private readonly logger?;
+    private readonly encoder?;
+    private writeChain;
+    private readonly activeStreams;
+    constructor(options: Resp2SessionAdapterOptions);
+    run(): Promise<void>;
+    private handleFrame;
+    private writeExecutorResult;
+    private spawnStreamDrain;
+    private drainStream;
+    private writeRedisResult;
+    private writeSessionPushes;
+    private writeError;
+}
+
+declare const pingCommand: CommandDefinition<{
+    message: Buffer<ArrayBufferLike> | undefined;
+}>;
+declare const quitCommand: CommandDefinition<{}>;
+declare const selectCommand: CommandDefinition<{
+    database: number;
+}>;
+declare const clientCommand: CommandDefinition<{
+    subcommand: string;
+    args: Buffer<ArrayBufferLike>[];
+}>;
+declare const aclCommand: CommandDefinition<{
+    subcommand: string;
+    args: Buffer<ArrayBufferLike>[];
+}>;
+declare const slowlogCommand: CommandDefinition<{
+    subcommand: string;
+    args: Buffer<ArrayBufferLike>[];
+}>;
+declare const shutdownCommand: CommandDefinition<{
+    args: Buffer<ArrayBufferLike>[];
+}>;
+declare const connectionCommands: CommandDefinition<{}>[];
+
+declare const monitorCommand: CommandDefinition<{}>;
+declare const monitorCommands: CommandDefinition<{}>[];
+
+declare function createClusterCommands(localNodeId: string): readonly CommandDefinition[];
+declare const readonlyCommand: CommandDefinition<{}>;
+declare const readwriteCommand: CommandDefinition<{}>;
+
+declare const commandCommand: CommandDefinition<{
+    subcommand: string | undefined;
+    args: Buffer<ArrayBufferLike>[];
+}>;
+
+type SetCondition = 'NX' | 'XX';
+type SetArgs = {
+    key: Buffer;
+    value: Buffer;
+    condition?: SetCondition;
+    expiresAt?: number;
+    keepTtl?: boolean;
+    get?: boolean;
+};
+declare const getCommand: CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+}>;
+declare const setCommand: CommandDefinition<SetArgs>;
+declare const mgetCommand: CommandDefinition<{
+    keys: Buffer<ArrayBufferLike>[];
+}>;
+declare const stringsCommands: (CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+}> | CommandDefinition<{
+    keys: Buffer<ArrayBufferLike>[];
+}> | CommandDefinition<KeyValuePair[]>)[];
+type KeyValuePair = {
+    key: Buffer;
+    value: Buffer;
+};
+
+declare const multiCommand: CommandDefinition<{}>;
+declare const execCommand: CommandDefinition<{}>;
+declare const discardCommand: CommandDefinition<{}>;
+declare const watchCommand: CommandDefinition<{
+    keys: Buffer<ArrayBufferLike>[];
+}>;
+declare const unwatchCommand: CommandDefinition<{}>;
+declare const transactionCommands: CommandDefinition<{}>[];
+
+declare const delCommand: CommandDefinition<{
+    keys: Buffer<ArrayBufferLike>[];
+}>;
+declare const existsCommand: CommandDefinition<{
+    keys: Buffer<ArrayBufferLike>[];
+}>;
+declare const typeCommand: CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+}>;
+declare const dbsizeCommand: CommandDefinition<{}>;
+declare const randomkeyCommand: CommandDefinition<{}>;
+declare const ttlCommand: CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+}>;
+declare const pttlCommand: CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+}>;
+declare const expiretimeCommand: CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+}>;
+declare const pexpiretimeCommand: CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+}>;
+type ExpireCondition = 'NX' | 'XX';
+type ExpireComparison = 'GT' | 'LT';
+type ExpireOptions = {
+    condition?: ExpireCondition;
+    comparison?: ExpireComparison;
+};
+declare const expireCommand: CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+    seconds: number;
+    options: ExpireOptions;
+}>;
+declare const pexpireCommand: CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+    milliseconds: number;
+    options: ExpireOptions;
+}>;
+declare const persistCommand: CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+}>;
+declare const flushdbCommand: CommandDefinition<{
+    mode: "async" | "sync" | undefined;
+}>;
+declare const flushallCommand: CommandDefinition<{
+    mode: "async" | "sync" | undefined;
+}>;
+type CopyOptions = {
+    db?: number;
+    replace: boolean;
+};
+declare const copyCommand: CommandDefinition<{
+    source: Buffer<ArrayBufferLike>;
+    destination: Buffer<ArrayBufferLike>;
+    options: CopyOptions;
+}>;
+declare const keysCommands: CommandDefinition<{}>[];
+
+type ScanOptions = {
+    cursor: bigint;
+    match?: Buffer;
+    count?: number;
+    type?: string;
+    noValues?: boolean;
+};
+type KeyedScanOptions = {
+    key: Buffer;
+    cursor: bigint;
+    match?: Buffer;
+    count?: number;
+    noValues?: boolean;
+};
+declare const keysCommand: CommandDefinition<{
+    pattern: Buffer<ArrayBufferLike>;
+}>;
+declare const scanCommand: CommandDefinition<ScanOptions>;
+declare const hscanCommand: CommandDefinition<KeyedScanOptions>;
+declare const sscanCommand: CommandDefinition<KeyedScanOptions>;
+declare const zscanCommand: CommandDefinition<KeyedScanOptions>;
+declare const scanCommands: (CommandDefinition<{
+    pattern: Buffer<ArrayBufferLike>;
+}> | CommandDefinition<ScanOptions> | CommandDefinition<KeyedScanOptions>)[];
+
+type EvalArgs = {
+    script: Buffer;
+    numKeys: number;
+    rest: Buffer[];
+};
+type EvalShaArgs = {
+    sha: string;
+    numKeys: number;
+    rest: Buffer[];
+};
+type FunctionArgs = {
+    subcommand: string;
+    rest: Buffer[];
+};
+type FcallArgs = {
+    functionName: string;
+    numKeys: number;
+    rest: Buffer[];
+};
+declare const scriptCommand: CommandDefinition<{
+    subcommand: string;
+    rest: Buffer<ArrayBufferLike>[];
+}>;
+declare const evalCommand: CommandDefinition<EvalArgs>;
+declare const evalshaCommand: CommandDefinition<EvalShaArgs>;
+declare const evalRoCommand: CommandDefinition<EvalArgs>;
+declare const evalshaRoCommand: CommandDefinition<EvalShaArgs>;
+declare const functionCommand: CommandDefinition<FunctionArgs>;
+declare const fcallCommand: CommandDefinition<FcallArgs>;
+declare const fcallRoCommand: CommandDefinition<FcallArgs>;
+declare const scriptsCommands: (CommandDefinition<{
+    subcommand: string;
+    rest: Buffer<ArrayBufferLike>[];
+}> | CommandDefinition<EvalArgs> | CommandDefinition<EvalShaArgs> | CommandDefinition<FcallArgs>)[];
+
+declare const redisCommandDefinitions: readonly CommandDefinition[];
+declare function createRedisCommandRegistry(extraCommands?: readonly CommandDefinition[], profile?: CompatibilityProfile): CommandRegistry;
+declare function createRedisCommandExecutor(options?: {
+    extraCommands?: readonly CommandDefinition[];
+    policies?: readonly ExecutionPolicy[];
+    compatibility?: CompatibilitySpec;
+}): CommandExecutor;
+
+declare class InMemoryConnectionTransport implements ConnectionTransport {
+    private static nextId;
+    readonly id: string;
+    readonly signal: AbortSignal;
+    private readonly controller;
+    private readonly incoming;
+    private readonly written;
+    private readonly listeners;
+    private readonly waiters;
+    private inputEnded;
+    private readerActive;
+    private closed;
+    constructor(id?: string);
+    feed(chunk: Buffer): void;
+    endRead(): void;
+    read(): AsyncIterable<Buffer>;
+    write(chunk: Buffer): void;
+    getWritten(): Buffer[];
+    getWrittenBuffer(): Buffer;
+    clearWritten(): void;
+    close(_reason?: string): void;
+    on(event: ConnectionTransportEvent, listener: ConnectionTransportListener): ConnectionTransportUnsubscribe;
+    private waitForInput;
+    private wakeReaders;
+    private emit;
+}
+
+type AttachSessionOptions = {
+    state: RedisServerState;
+    executor: CommandExecutor;
+    nodeRole?: RedisClusterNodeRole;
+    logger?: Pick<Logger, 'error'>;
+    encoder?: RespEncodeOptions;
+    clientAddress?: string;
+};
+type AttachedSession = {
+    session: ClientSession;
+    adapter: Resp2SessionAdapter;
+    /** Resolves once the adapter's read/write loop finishes (transport closed). */
+    done: Promise<void>;
+    /** Tear down the transport (which aborts the adapter and closes the session). */
+    close(): void;
+};
+/**
+ * Wire a {@link ConnectionTransport} to a fresh {@link ClientSession} driven by
+ * a {@link Resp2SessionAdapter}, kicking off the adapter's run loop.
+ *
+ * This is the transport-agnostic core extracted from `Resp2Server.handleConnection`:
+ * the socket-backed server and the in-memory virtual connection share it, so the
+ * RESP framing / session lifecycle never diverges between them. The returned
+ * `done` promise settles when the adapter loop ends; `close()` closes the
+ * transport, which aborts the adapter and (via the adapter's `finally`) the
+ * session.
+ */
+declare function attachSession(transport: ConnectionTransport, opts: AttachSessionOptions): AttachedSession;
+
+type CreateVirtualConnectionOptions = {
+    state: RedisServerState;
+    executor: CommandExecutor;
+    nodeRole?: RedisClusterNodeRole;
+    logger?: Pick<Logger, 'error'>;
+    encoder?: RespEncodeOptions;
+    /** Synthetic remote address reported to the client lib. Default 127.0.0.1. */
+    remoteAddress?: string;
+    /** Synthetic remote port reported to the client lib. Default 6379. */
+    remotePort?: number;
+};
+type VirtualConnection = {
+    /** The fake `net.Socket`-shaped stream handed to the client library. */
+    clientSocket: VirtualClientSocket;
+    /** Resolves once the server-side adapter loop ends and the session is closed. */
+    done: Promise<void>;
+    /** Tear down both ends of the wire and the server-side session. */
+    close(): void;
+};
+/**
+ * A `net.Socket`-compatible {@link Duplex} handed to a client library (ioredis)
+ * as its connection stream. Only the surface the client touches is implemented:
+ * duplex read/write, the no-op socket tuning methods, the `remoteAddress` /
+ * `remotePort` getters, and the `'connect'` event (emitted on `nextTick`, like
+ * ioredis' `StandaloneConnector`). Bytes written by the client are forwarded to
+ * the server side via {@link feedServer}; bytes from the server are pushed back
+ * out as `'data'`.
+ */
+declare class VirtualClientSocket extends Duplex {
+    readonly remoteAddress: string;
+    readonly remotePort: number;
+    readonly localAddress = "127.0.0.1";
+    readonly localPort = 0;
+    /** Called with each chunk the client writes; set by the wiring below. */
+    private onClientWrite?;
+    /** Called once when the client side initiates teardown. */
+    private onClientDestroy?;
+    constructor(remoteAddress: string, remotePort: number);
+    /** @internal Wire the server-bound write + destroy hooks. */
+    bindServer(hooks: {
+        onClientWrite: (chunk: Buffer) => void;
+        onClientDestroy: () => void;
+    }): void;
+    /** @internal Push a chunk produced by the server out to the client reader. */
+    feedClient(chunk: Buffer): void;
+    /** @internal Signal the client reader that the server closed the wire. */
+    endClient(): void;
+    _read(): void;
+    _write(chunk: Buffer | string, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+    _destroy(error: Error | null, callback: (error: Error | null) => void): void;
+    setNoDelay(): this;
+    setKeepAlive(): this;
+    setTimeout(): this;
+    ref(): this;
+    unref(): this;
+}
+/**
+ * Build an in-process virtual connection: a fake client-facing `net.Socket`
+ * already wired to a fresh server-side {@link ClientSession}. The reusable
+ * primitive behind {@link createIoredisMock} — no TCP socket, no port bind.
+ *
+ * Bytes the client writes flow into a {@link DuplexConnectionTransport} that
+ * {@link attachSession} drives exactly like a real socket connection; the
+ * server's replies are pushed back out as `'data'` on the client socket. Tearing
+ * down either end (client `destroy()` or {@link VirtualConnection.close}) closes
+ * the transport, which aborts the adapter and the session.
+ */
+declare function createVirtualConnection(opts: CreateVirtualConnectionOptions): VirtualConnection;
+
+/**
+ * The in-memory pipeline behind one synthetic `host:port`: the node's keyspace
+ * state, its command executor (cluster-aware for cluster nodes), and its role.
+ */
+type NodePipeline = {
+    state: RedisServerState;
+    executor: CommandExecutor;
+    nodeRole?: RedisClusterNodeRole;
+};
+type RegisteredNode = NodePipeline & {
+    host: string;
+    port: number;
+};
+/**
+ * Maps a synthetic `host:port` to its in-memory {@link NodePipeline} so a client
+ * library's per-node connections resolve to the right state/executor without any
+ * TCP socket. A standalone mock registers a single entry; a cluster mock
+ * registers one entry per node (the synthetic ports advertised by CLUSTER SLOTS).
+ */
+declare class InMemoryNodeRegistry {
+    private readonly nodesByAddress;
+    register(host: string, port: number, pipeline: NodePipeline): void;
+    resolve(host: string, port: number): NodePipeline | undefined;
+    nodes(): readonly RegisteredNode[];
+}
+
+export { type AttachSessionOptions, type AttachedSession, ClientSession, ClientSessionMode, type ClientSessionOptions, CommandDefinition, CommandExecutor, CommandPlan, CommandRegistry, CompatibilityProfile, CompatibilitySpec, type ConnectionTransport, type ConnectionTransportEvent, type ConnectionTransportListener, type ConnectionTransportUnsubscribe, type CreateVirtualConnectionOptions, ExecutorResult, FEATURE_GATES, FeatureId, InMemoryConnectionTransport, InMemoryNodeRegistry, type NodePipeline, ParkHandler, RedisClientSession, RedisClusterNodeRole, RedisClusterTopology, RedisDatabase, RedisExecutionContext, RedisResult, RedisServerState, RedisTurnHandle, RedisTurnQueue, type RegisteredNode, Resp2CommandDecoder, type Resp2CommandFrame, Resp2ParseError, Resp2SessionAdapter, type Resp2SessionAdapterOptions, RespEncodeOptions, RespVersion, SocketConnectionTransport, type SocketConnectionTransportOptions, Unsubscribe, VersionGate, VirtualClientSocket, type VirtualConnection, aclCommand, attachSession, clientCommand, commandCommand, connectionCommands, copyCommand, createAuthPolicy, createClusterCommands, createClusterPolicy, createRedisCommandExecutor, createRedisCommandRegistry, createTransactionPolicy, createVirtualConnection, dbsizeCommand, delCommand, discardCommand, evalCommand, evalRoCommand, evalshaCommand, evalshaRoCommand, execCommand, existsCommand, expireCommand, expiretimeCommand, fcallCommand, fcallRoCommand, flushallCommand, flushdbCommand, functionCommand, getCommand, hscanCommand, keysCommand, keysCommands, mgetCommand, monitorCommand, monitorCommands, multiCommand, persistCommand, pexpireCommand, pexpiretimeCommand, pingCommand, pttlCommand, quitCommand, randomkeyCommand, readonlyCommand, readwriteCommand, redisCommandDefinitions, scanCommand, scanCommands, scriptCommand, scriptsCommands, selectCommand, setCommand, shutdownCommand, slowlogCommand, sscanCommand, stringsCommands, transactionCommands, ttlCommand, typeCommand, unwatchCommand, watchCommand, zscanCommand };