js-redis-server 0.0.1 → 0.0.3

package/dist/core/command-definition.d.ts

@@ -0,0 +1,64 @@
+import type { CommandSchema } from './command-schema';
+import type { RedisExecutionContext } from './redis-context';
+import type { RedisResult } from './redis-result';
+import type { ResponseStream } from './response-stream';
+export type CommandFlag = 'readonly' | 'write' | 'denyoom' | 'admin' | 'noscript' | 'random' | 'blocking' | 'fast' | 'movablekeys' | 'transaction' | 'pubsub' | 'subscribed';
+export type CommandCapabilities = {
+    blocking?: boolean;
+    pushOnly?: boolean;
+    movableKeys?: boolean;
+    scriptKeys?: boolean;
+};
+export type CommandKeySpec = {
+    flags: readonly string[];
+    beginSearchIndex: number;
+    lastKey: number;
+    keyStep: number;
+    limit?: number;
+    notes?: string;
+};
+export type CommandDocumentation = {
+    summary: string;
+    since?: string;
+    group: string;
+    complexity?: string;
+    arguments?: readonly CommandDocumentationArgument[];
+};
+export type CommandDocumentationArgument = {
+    name: string;
+    type: string;
+    keySpecIndex?: number;
+    token?: string;
+    flags?: readonly string[];
+};
+export type CommandIntrospection = {
+    name?: string;
+    arity: number;
+    flags?: readonly string[];
+    firstKey?: number;
+    lastKey?: number;
+    keyStep?: number;
+    categories?: readonly string[];
+    tips?: readonly string[];
+    keySpecs?: readonly CommandKeySpec[];
+    subcommands?: readonly CommandIntrospection[];
+    docs?: CommandDocumentation;
+};
+export type CommandExecutionResult = RedisResult | Promise<RedisResult> | ResponseStream;
+export interface CommandDefinition<TArgs = unknown> {
+    readonly name: string;
+    readonly schema: CommandSchema<TArgs>;
+    readonly flags: readonly CommandFlag[];
+    readonly capabilities?: CommandCapabilities;
+    readonly introspection?: CommandIntrospection;
+    keys(args: TArgs): readonly Buffer[];
+    execute(args: TArgs, ctx: RedisExecutionContext): CommandExecutionResult;
+}
+export type CommandPlan<TArgs = unknown> = {
+    definition: CommandDefinition<TArgs>;
+    args: TArgs;
+    keys: readonly Buffer[];
+    flags: readonly CommandFlag[];
+};
+export declare function defineCommand<TArgs>(definition: CommandDefinition<TArgs>): CommandDefinition<TArgs>;
+//# sourceMappingURL=command-definition.d.ts.map

package/dist/core/command-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-definition.d.ts","sourceRoot":"","sources":["../../src/core/command-definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AACrD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAA;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEvD,MAAM,MAAM,WAAW,GACnB,UAAU,GACV,OAAO,GACP,SAAS,GACT,OAAO,GACP,UAAU,GACV,QAAQ,GACR,UAAU,GACV,MAAM,GACN,aAAa,GACb,aAAa,GACb,QAAQ,GACR,YAAY,CAAA;AAEhB,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;IACxB,gBAAgB,EAAE,MAAM,CAAA;IACxB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,SAAS,CAAC,EAAE,SAAS,4BAA4B,EAAE,CAAA;CACpD,CAAA;AAED,MAAM,MAAM,4BAA4B,GAAG;IACzC,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC9B,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACxB,QAAQ,CAAC,EAAE,SAAS,cAAc,EAAE,CAAA;IACpC,WAAW,CAAC,EAAE,SAAS,oBAAoB,EAAE,CAAA;IAC7C,IAAI,CAAC,EAAE,oBAAoB,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,sBAAsB,GAC9B,WAAW,GACX,OAAO,CAAC,WAAW,CAAC,GACpB,cAAc,CAAA;AAElB,MAAM,WAAW,iBAAiB,CAAC,KAAK,GAAG,OAAO;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,CAAA;IACrC,QAAQ,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,CAAA;IACtC,QAAQ,CAAC,YAAY,CAAC,EAAE,mBAAmB,CAAA;IAC3C,QAAQ,CAAC,aAAa,CAAC,EAAE,oBAAoB,CAAA;IAC7C,IAAI,CAAC,IAAI,EAAE,KAAK,GAAG,SAAS,MAAM,EAAE,CAAA;IACpC,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,qBAAqB,GAAG,sBAAsB,CAAA;CACzE;AAED,MAAM,MAAM,WAAW,CAAC,KAAK,GAAG,OAAO,IAAI;IACzC,UAAU,EAAE,iBAAiB,CAAC,KAAK,CAAC,CAAA;IACpC,IAAI,EAAE,KAAK,CAAA;IACX,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;IACvB,KAAK,EAAE,SAAS,WAAW,EAAE,CAAA;CAC9B,CAAA;AAED,wBAAgB,aAAa,CAAC,KAAK,EACjC,UAAU,EAAE,iBAAiB,CAAC,KAAK,CAAC,GACnC,iBAAiB,CAAC,KAAK,CAAC,CAK1B"}

package/dist/core/command-definition.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineCommand = defineCommand;
+function defineCommand(definition) {
+    return {
+        ...definition,
+        name: definition.name.toLowerCase(),
+    };
+}
+//# sourceMappingURL=command-definition.js.map

package/dist/core/command-definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-definition.js","sourceRoot":"","sources":["../../src/core/command-definition.ts"],"names":[],"mappings":";;AAuFA,sCAOC;AAPD,SAAgB,aAAa,CAC3B,UAAoC;IAEpC,OAAO;QACL,GAAG,UAAU;QACb,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC,WAAW,EAAE;KACpC,CAAA;AACH,CAAC"}

package/dist/core/command-executor.d.ts

@@ -0,0 +1,103 @@
+import { CommandDefinition, CommandPlan } from './command-definition';
+import { CommandRegistry } from './command-registry';
+import type { ExecutionPolicy } from './execution-policies';
+import type { RedisExecutionContext } from './redis-context';
+import { RedisResult } from './redis-result';
+import { ResponseStream } from './response-stream';
+/**
+ * The result of running a command: either a finished {@link RedisResult} or a
+ * long-lived {@link ResponseStream} (e.g. SUBSCRIBE / MONITOR) whose frames the
+ * transport drains over time.
+ */
+export type ExecutorResult = RedisResult | ResponseStream;
+export type CommandExecutorOptions = {
+    registry: CommandRegistry;
+    policies?: readonly ExecutionPolicy[];
+};
+/**
+ * Central command pipeline shared by every client session.
+ *
+ * Responsibilities:
+ *  1. Resolve a raw command name to a {@link CommandDefinition} (case-insensitive).
+ *  2. Parse raw argument buffers into typed args and extract routing keys,
+ *     producing a {@link CommandPlan}.
+ *  3. Run the configured {@link ExecutionPolicy} chain around the command's own
+ *     `execute`, giving policies (transaction, cluster, ...) a chance to
+ *     short-circuit, rewrite, or wrap the result.
+ *
+ * Two execution paths exist on purpose:
+ *  - {@link executePlan} / {@link executeRaw} — async, used for real network
+ *    clients; may return a {@link ResponseStream} and may await async commands.
+ *  - {@link executePlanSync} — synchronous mirror used by the Lua runtime, where
+ *    `redis.call` must complete in a single tick. Streams and promises are
+ *    rejected rather than awaited.
+ *
+ * The executor is stateless per-call: all mutable state lives on the
+ * {@link RedisExecutionContext} (and the session it carries).
+ */
+export declare class CommandExecutor {
+    private readonly registry;
+    private readonly policies;
+    constructor(options: CommandExecutorOptions);
+    getCommandDefinition(name: string): CommandDefinition<unknown> | undefined;
+    getCommandDefinitions(): readonly CommandDefinition<unknown>[];
+    /**
+     * Resolve a raw command + args into a {@link CommandPlan} without executing it.
+     * The command name is matched case-insensitively against the registry.
+     *
+     * @throws {UnknownRedisCommandError} if no command is registered under the name.
+     */
+    plan(rawCommand: Buffer | string, rawArgs: readonly Buffer[]): CommandPlan;
+    /**
+     * Plan and execute a raw command in one step — the normal entry point for a
+     * network client.
+     *
+     * Errors thrown during *planning* (unknown command, arity/parse failures) are
+     * caught here and converted into a RESP error reply. Such a failure also marks
+     * any open MULTI transaction dirty so a later EXEC is aborted, matching Redis:
+     * a command that cannot even be parsed must not silently vanish from the queue.
+     * Execution-time errors are handled inside {@link executePlan}.
+     */
+    executeRaw(rawCommand: Buffer | string, rawArgs: readonly Buffer[], ctx: RedisExecutionContext): Promise<ExecutorResult>;
+    private static normalizeCommandName;
+    /**
+     * Run a pre-built plan through the full async pipeline.
+     *
+     * Order of operations:
+     *  1. `beforeExecute` for each policy. The first policy that returns a result
+     *     short-circuits execution (e.g. the transaction policy queues the command
+     *     and returns "+QUEUED"; the cluster policy returns a MOVED/CROSSSLOT
+     *     error). A short-circuit error during MULTI also dirties the transaction.
+     *  2. The command's own `execute`.
+     *  3. If a {@link ResponseStream} is produced, run it through every policy's
+     *     `onStream` hook; otherwise await the value and run it through every
+     *     `afterExecute` hook (each may replace the result).
+     *
+     * Execution-time {@link RedisCommandError}s become RESP error replies (and
+     * dirty an open transaction when appropriate). Non-Redis errors propagate.
+     */
+    executePlan(plan: CommandPlan, ctx: RedisExecutionContext): Promise<ExecutorResult>;
+    /**
+     * Synchronous counterpart to {@link executePlan}, used by the Lua runtime for
+     * `redis.call` / `redis.pcall`. Lua expects each nested command to resolve
+     * immediately, so anything that would require awaiting — a command that
+     * returns a promise, a {@link ResponseStream}, or an async policy hook — is
+     * rejected with a {@link RedisCommandError} instead of being awaited. Async
+     * command definitions are rejected before invocation so they cannot leave
+     * orphaned work running after the script error (see
+     * {@link assertSyncCommandDefinition}, {@link assertSyncCommandResult}, and
+     * {@link assertSyncPolicyResult}).
+     *
+     * The policy chain and transaction-dirty handling otherwise mirror the async
+     * path exactly.
+     */
+    executePlanSync(plan: CommandPlan, ctx: RedisExecutionContext): RedisResult;
+    /**
+     * Build a {@link CommandPlan} from a resolved definition: parse the raw buffers
+     * against the command's schema (may throw arity/type errors) and extract the
+     * routing keys used for cluster slot validation. Flags are copied onto the plan
+     * so policies can inspect them without re-resolving the definition.
+     */
+    private createPlan;
+}
+//# sourceMappingURL=command-executor.d.ts.map

package/dist/core/command-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-executor.d.ts","sourceRoot":"","sources":["../../src/core/command-executor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAEpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAO3D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAA;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,EAAoB,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEpE;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,cAAc,CAAA;AAEzD,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,EAAE,eAAe,CAAA;IACzB,QAAQ,CAAC,EAAE,SAAS,eAAe,EAAE,CAAA;CACtC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiB;IAC1C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4B;gBAEzC,OAAO,EAAE,sBAAsB;IAK3C,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAAC,OAAO,CAAC,GAAG,SAAS;IAI1E,qBAAqB,IAAI,SAAS,iBAAiB,CAAC,OAAO,CAAC,EAAE;IAI9D;;;;;OAKG;IACH,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,WAAW;IAW1E;;;;;;;;;OASG;IACG,UAAU,CACd,UAAU,EAAE,MAAM,GAAG,MAAM,EAC3B,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,GAAG,EAAE,qBAAqB,GACzB,OAAO,CAAC,cAAc,CAAC;IA2B1B,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAMnC;;;;;;;;;;;;;;;OAeG;IACG,WAAW,CACf,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,qBAAqB,GACzB,OAAO,CAAC,cAAc,CAAC;IAgD1B;;;;;;;;;;;;;OAaG;IACH,eAAe,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,EAAE,qBAAqB,GAAG,WAAW;IA6C3E;;;;;OAKG;IACH,OAAO,CAAC,UAAU;CAcnB"}

package/dist/core/command-executor.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandExecutor = void 0;
+const command_schema_1 = require("./command-schema");
+const redis_error_1 = require("./redis-error");
+const redis_result_1 = require("./redis-result");
+const response_stream_1 = require("./response-stream");
+/**
+ * Central command pipeline shared by every client session.
+ *
+ * Responsibilities:
+ *  1. Resolve a raw command name to a {@link CommandDefinition} (case-insensitive).
+ *  2. Parse raw argument buffers into typed args and extract routing keys,
+ *     producing a {@link CommandPlan}.
+ *  3. Run the configured {@link ExecutionPolicy} chain around the command's own
+ *     `execute`, giving policies (transaction, cluster, ...) a chance to
+ *     short-circuit, rewrite, or wrap the result.
+ *
+ * Two execution paths exist on purpose:
+ *  - {@link executePlan} / {@link executeRaw} — async, used for real network
+ *    clients; may return a {@link ResponseStream} and may await async commands.
+ *  - {@link executePlanSync} — synchronous mirror used by the Lua runtime, where
+ *    `redis.call` must complete in a single tick. Streams and promises are
+ *    rejected rather than awaited.
+ *
+ * The executor is stateless per-call: all mutable state lives on the
+ * {@link RedisExecutionContext} (and the session it carries).
+ */
+class CommandExecutor {
+    registry;
+    policies;
+    constructor(options) {
+        this.registry = options.registry;
+        this.policies = options.policies ?? [];
+    }
+    getCommandDefinition(name) {
+        return this.registry.get(name);
+    }
+    getCommandDefinitions() {
+        return this.registry.getAll();
+    }
+    /**
+     * Resolve a raw command + args into a {@link CommandPlan} without executing it.
+     * The command name is matched case-insensitively against the registry.
+     *
+     * @throws {UnknownRedisCommandError} if no command is registered under the name.
+     */
+    plan(rawCommand, rawArgs) {
+        const commandName = CommandExecutor.normalizeCommandName(rawCommand);
+        const definition = this.registry.get(commandName);
+        if (!definition) {
+            throw new redis_error_1.UnknownRedisCommandError(rawCommand, rawArgs);
+        }
+        return this.createPlan(definition, rawArgs);
+    }
+    /**
+     * Plan and execute a raw command in one step — the normal entry point for a
+     * network client.
+     *
+     * Errors thrown during *planning* (unknown command, arity/parse failures) are
+     * caught here and converted into a RESP error reply. Such a failure also marks
+     * any open MULTI transaction dirty so a later EXEC is aborted, matching Redis:
+     * a command that cannot even be parsed must not silently vanish from the queue.
+     * Execution-time errors are handled inside {@link executePlan}.
+     */
+    async executeRaw(rawCommand, rawArgs, ctx) {
+        try {
+            return await this.executePlan(this.plan(rawCommand, rawArgs), ctx);
+        }
+        catch (err) {
+            if (err instanceof redis_error_1.RedisCommandError) {
+                // EXEC itself with bad arity (e.g. `EXEC foo`) discards the
+                // transaction immediately and replies EXECABORT, matching Redis'
+                // execCommandAbort — distinct from a *queued* command's arity error,
+                // which only dirties the transaction for a later, well-formed EXEC.
+                if (err instanceof redis_error_1.WrongNumberOfArgumentsError &&
+                    ctx.session.mode === 'transaction' &&
+                    CommandExecutor.normalizeCommandName(rawCommand) === 'exec') {
+                    ctx.session.discardTransaction();
+                    const abortError = new redis_error_1.ExecCommandAbortError(err.message);
+                    return redis_result_1.RedisResult.error(abortError.message, abortError.code);
+                }
+                ctx.session.markTransactionDirty();
+                return redis_result_1.RedisResult.error(err.message, err.code);
+            }
+            throw err;
+        }
+    }
+    static normalizeCommandName(rawCommand) {
+        return typeof rawCommand === 'string'
+            ? rawCommand.toLowerCase()
+            : rawCommand.toString().toLowerCase();
+    }
+    /**
+     * Run a pre-built plan through the full async pipeline.
+     *
+     * Order of operations:
+     *  1. `beforeExecute` for each policy. The first policy that returns a result
+     *     short-circuits execution (e.g. the transaction policy queues the command
+     *     and returns "+QUEUED"; the cluster policy returns a MOVED/CROSSSLOT
+     *     error). A short-circuit error during MULTI also dirties the transaction.
+     *  2. The command's own `execute`.
+     *  3. If a {@link ResponseStream} is produced, run it through every policy's
+     *     `onStream` hook; otherwise await the value and run it through every
+     *     `afterExecute` hook (each may replace the result).
+     *
+     * Execution-time {@link RedisCommandError}s become RESP error replies (and
+     * dirty an open transaction when appropriate). Non-Redis errors propagate.
+     */
+    async executePlan(plan, ctx) {
+        try {
+            for (const policy of this.policies) {
+                const policyResult = await policy.beforeExecute?.(plan, ctx);
+                if (policyResult) {
+                    if (isTransactionQueueError(plan, ctx, policyResult)) {
+                        ctx.session.markTransactionDirty();
+                    }
+                    return policyResult;
+                }
+            }
+            const rawResult = plan.definition.execute(plan.args, ctx);
+            if ((0, response_stream_1.isResponseStream)(rawResult)) {
+                let finalStream = ensureNonThenableStream(rawResult);
+                for (const policy of this.policies) {
+                    finalStream =
+                        (await policy.onStream?.(plan, ctx, finalStream)) ?? finalStream;
+                    finalStream = ensureNonThenableStream(finalStream);
+                }
+                return finalStream;
+            }
+            const result = await rawResult;
+            let finalResult = result;
+            for (const policy of this.policies) {
+                finalResult =
+                    (await policy.afterExecute?.(plan, ctx, finalResult)) ?? finalResult;
+            }
+            return finalResult;
+        }
+        catch (err) {
+            if (err instanceof redis_error_1.RedisCommandError) {
+                if (shouldDirtyTransaction(plan, ctx)) {
+                    ctx.session.markTransactionDirty();
+                }
+                return redis_result_1.RedisResult.error(err.message, err.code);
+            }
+            throw err;
+        }
+    }
+    /**
+     * Synchronous counterpart to {@link executePlan}, used by the Lua runtime for
+     * `redis.call` / `redis.pcall`. Lua expects each nested command to resolve
+     * immediately, so anything that would require awaiting — a command that
+     * returns a promise, a {@link ResponseStream}, or an async policy hook — is
+     * rejected with a {@link RedisCommandError} instead of being awaited. Async
+     * command definitions are rejected before invocation so they cannot leave
+     * orphaned work running after the script error (see
+     * {@link assertSyncCommandDefinition}, {@link assertSyncCommandResult}, and
+     * {@link assertSyncPolicyResult}).
+     *
+     * The policy chain and transaction-dirty handling otherwise mirror the async
+     * path exactly.
+     */
+    executePlanSync(plan, ctx) {
+        try {
+            for (const policy of this.policies) {
+                const policyResult = assertSyncPolicyResult(policy.name, 'beforeExecute', policy.beforeExecute?.(plan, ctx));
+                if (policyResult) {
+                    if (isTransactionQueueError(plan, ctx, policyResult)) {
+                        ctx.session.markTransactionDirty();
+                    }
+                    return policyResult;
+                }
+            }
+            assertSyncCommandDefinition(plan);
+            const rawResult = plan.definition.execute(plan.args, ctx);
+            const result = assertSyncCommandResult(plan, rawResult);
+            let finalResult = result;
+            for (const policy of this.policies) {
+                finalResult =
+                    assertSyncPolicyResult(policy.name, 'afterExecute', policy.afterExecute?.(plan, ctx, finalResult)) ?? finalResult;
+            }
+            return finalResult;
+        }
+        catch (err) {
+            if (err instanceof redis_error_1.RedisCommandError) {
+                if (shouldDirtyTransaction(plan, ctx)) {
+                    ctx.session.markTransactionDirty();
+                }
+                return redis_result_1.RedisResult.error(err.message, err.code);
+            }
+            throw err;
+        }
+    }
+    /**
+     * Build a {@link CommandPlan} from a resolved definition: parse the raw buffers
+     * against the command's schema (may throw arity/type errors) and extract the
+     * routing keys used for cluster slot validation. Flags are copied onto the plan
+     * so policies can inspect them without re-resolving the definition.
+     */
+    createPlan(definition, rawArgs) {
+        const args = (0, command_schema_1.parseCommandArgs)(definition.schema, rawArgs, definition.name);
+        const keys = definition.keys(args);
+        return {
+            definition,
+            args,
+            keys,
+            flags: definition.flags,
+        };
+    }
+}
+exports.CommandExecutor = CommandExecutor;
+/**
+ * A policy's `onStream` hook may return an object that is both a
+ * {@link ResponseStream} and thenable (e.g. an async wrapper). Callers `await`
+ * the executor result, and awaiting a thenable stream would unwrap it into its
+ * resolved value, breaking streaming. This re-wraps such a stream in a plain,
+ * non-thenable object so it survives the surrounding `await` untouched.
+ */
+function ensureNonThenableStream(stream) {
+    if (!('then' in stream)) {
+        return stream;
+    }
+    return {
+        kind: 'response-stream',
+        get closed() {
+            return stream.closed;
+        },
+        frames: signal => stream.frames(signal),
+        close: reason => stream.close(reason),
+    };
+}
+/**
+ * Guard for the synchronous (Lua) path: a command's result must be a ready
+ * {@link RedisResult}. Streaming commands and async commands are not callable
+ * from scripts, so a stream is closed and both cases are surfaced as a
+ * script-facing {@link RedisCommandError}.
+ */
+function assertSyncCommandResult(plan, result) {
+    if ((0, response_stream_1.isResponseStream)(result)) {
+        result.close('Lua redis.call cannot run streaming commands');
+        throw new redis_error_1.RedisCommandError(`${plan.definition.name.toUpperCase()} is not allowed from scripts`);
+    }
+    if (isThenable(result)) {
+        throw new redis_error_1.RedisCommandError(`${plan.definition.name.toUpperCase()} cannot run asynchronously from scripts`);
+    }
+    return result;
+}
+function assertSyncCommandDefinition(plan) {
+    if (!isAsyncFunction(plan.definition.execute)) {
+        return;
+    }
+    throw new redis_error_1.RedisCommandError(`${plan.definition.name.toUpperCase()} cannot run asynchronously from scripts`);
+}
+/**
+ * Same idea as {@link assertSyncCommandResult} but for policy hooks: an async
+ * hook result cannot be awaited on the Lua path, so it is rejected with a
+ * descriptive {@link RedisCommandError} naming the offending policy and hook.
+ */
+function assertSyncPolicyResult(policyName, hookName, value) {
+    if (isThenable(value)) {
+        throw new redis_error_1.RedisCommandError(`Execution policy '${policyName}' ${hookName} hook cannot run asynchronously from scripts`);
+    }
+    return value;
+}
+function isThenable(value) {
+    if (value === null || value === undefined) {
+        return false;
+    }
+    if (typeof value !== 'object' && typeof value !== 'function') {
+        return false;
+    }
+    return typeof value.then === 'function';
+}
+function isAsyncFunction(value) {
+    return (typeof value === 'function' && value.constructor?.name === 'AsyncFunction');
+}
+/**
+ * True when a policy short-circuit returned an error while queuing a command in
+ * MULTI — i.e. the command was rejected at queue time. Redis aborts the whole
+ * transaction on EXEC in that case, so the session must be marked dirty.
+ */
+function isTransactionQueueError(plan, ctx, result) {
+    return shouldDirtyTransaction(plan, ctx) && result.value.kind === 'error';
+}
+/**
+ * Whether an error on this plan should dirty the current transaction.
+ *
+ * Only meaningful while the session is in `transaction` mode. Commands flagged
+ * `transaction` are the control commands themselves (MULTI/EXEC/DISCARD/WATCH);
+ * their errors must not abort the transaction, so they are excluded.
+ */
+function shouldDirtyTransaction(plan, ctx) {
+    return (ctx.session.mode === 'transaction' && !plan.flags.includes('transaction'));
+}
+//# sourceMappingURL=command-executor.js.map

package/dist/core/command-executor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-executor.js","sourceRoot":"","sources":["../../src/core/command-executor.ts"],"names":[],"mappings":"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"}

package/dist/core/command-registry.d.ts

@@ -0,0 +1,16 @@
+import type { CommandDefinition } from './command-definition';
+export declare class CommandRegistry {
+    private readonly commands;
+    register<TArgs>(definition: CommandDefinition<TArgs>, options?: {
+        override?: boolean;
+    }): void;
+    override<TArgs>(definition: CommandDefinition<TArgs>): void;
+    registerAll(definitions: readonly CommandDefinition<unknown>[], options?: {
+        override?: boolean;
+    }): void;
+    get(name: string): CommandDefinition<unknown> | undefined;
+    has(name: string): boolean;
+    getAll(): CommandDefinition<unknown>[];
+    getNames(): string[];
+}
+//# sourceMappingURL=command-registry.d.ts.map

package/dist/core/command-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-registry.d.ts","sourceRoot":"","sources":["../../src/core/command-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAE7D,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgD;IAEzE,QAAQ,CAAC,KAAK,EACZ,UAAU,EAAE,iBAAiB,CAAC,KAAK,CAAC,EACpC,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GAC/B,IAAI;IASP,QAAQ,CAAC,KAAK,EAAE,UAAU,EAAE,iBAAiB,CAAC,KAAK,CAAC,GAAG,IAAI;IAI3D,WAAW,CACT,WAAW,EAAE,SAAS,iBAAiB,CAAC,OAAO,CAAC,EAAE,EAClD,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GAC/B,IAAI;IAMP,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAAC,OAAO,CAAC,GAAG,SAAS;IAIzD,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B,MAAM,IAAI,iBAAiB,CAAC,OAAO,CAAC,EAAE;IAItC,QAAQ,IAAI,MAAM,EAAE;CAGrB"}

package/dist/core/command-registry.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandRegistry = void 0;
+class CommandRegistry {
+    commands = new Map();
+    register(definition, options) {
+        const name = definition.name.toLowerCase();
+        if (!options?.override && this.commands.has(name)) {
+            throw new Error(`Command '${name}' is already registered`);
+        }
+        this.commands.set(name, definition);
+    }
+    override(definition) {
+        this.register(definition, { override: true });
+    }
+    registerAll(definitions, options) {
+        for (const definition of definitions) {
+            this.register(definition, options);
+        }
+    }
+    get(name) {
+        return this.commands.get(name.toLowerCase());
+    }
+    has(name) {
+        return this.commands.has(name.toLowerCase());
+    }
+    getAll() {
+        return Array.from(this.commands.values());
+    }
+    getNames() {
+        return Array.from(this.commands.keys());
+    }
+}
+exports.CommandRegistry = CommandRegistry;
+//# sourceMappingURL=command-registry.js.map

package/dist/core/command-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-registry.js","sourceRoot":"","sources":["../../src/core/command-registry.ts"],"names":[],"mappings":";;;AAEA,MAAa,eAAe;IACT,QAAQ,GAAG,IAAI,GAAG,EAAsC,CAAA;IAEzE,QAAQ,CACN,UAAoC,EACpC,OAAgC;QAEhC,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,WAAW,EAAE,CAAA;QAC1C,IAAI,CAAC,OAAO,EAAE,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YAClD,MAAM,IAAI,KAAK,CAAC,YAAY,IAAI,yBAAyB,CAAC,CAAA;QAC5D,CAAC;QAED,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,UAAwC,CAAC,CAAA;IACnE,CAAC;IAED,QAAQ,CAAQ,UAAoC;QAClD,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAA;IAC/C,CAAC;IAED,WAAW,CACT,WAAkD,EAClD,OAAgC;QAEhC,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE,CAAC;YACrC,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC,CAAA;QACpC,CAAC;IACH,CAAC;IAED,GAAG,CAAC,IAAY;QACd,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAA;IAC9C,CAAC;IAED,GAAG,CAAC,IAAY;QACd,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAA;IAC9C,CAAC;IAED,MAAM;QACJ,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAA;IAC3C,CAAC;IAED,QAAQ;QACN,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;IACzC,CAAC;CACF;AA3CD,0CA2CC"}

package/dist/core/command-schema.d.ts

@@ -0,0 +1,43 @@
+export type ParseContext = {
+    commandName: string;
+};
+export type ParseNodeResult<TValue> = {
+    value: TValue;
+    nextIndex: number;
+};
+export interface CommandSchema<TValue> {
+    parse(input: readonly Buffer[], index: number, ctx: ParseContext): ParseNodeResult<TValue>;
+}
+export type InferSchema<TSchema> = TSchema extends CommandSchema<infer TValue> ? TValue : never;
+type SchemaShape = Record<string, CommandSchema<unknown>>;
+type InferShape<TShape extends SchemaShape> = {
+    [K in keyof TShape]: InferSchema<TShape[K]>;
+};
+export declare class SchemaMismatchError extends Error {
+    constructor();
+}
+export declare function parseCommandArgs<TArgs>(schema: CommandSchema<TArgs>, input: readonly Buffer[], commandName: string): TArgs;
+export declare const t: {
+    custom<TValue>(parse: CommandSchema<TValue>["parse"]): CommandSchema<TValue>;
+    key(): CommandSchema<Buffer>;
+    bulk(): CommandSchema<Buffer>;
+    string(): CommandSchema<string>;
+    integer(options?: {
+        min?: number;
+        max?: number;
+    }): CommandSchema<number>;
+    bigInteger(options?: {
+        min?: bigint;
+        max?: bigint;
+    }): CommandSchema<bigint>;
+    float(): CommandSchema<number>;
+    keyword<TKeyword extends string>(expected: TKeyword): CommandSchema<TKeyword>;
+    optional<TValue>(schema: CommandSchema<TValue>): CommandSchema<TValue | undefined>;
+    variadic<TValue>(schema: CommandSchema<TValue>, options?: {
+        min?: number;
+    }): CommandSchema<TValue[]>;
+    object<TShape extends SchemaShape>(shape: TShape): CommandSchema<InferShape<TShape>>;
+    union<TValue>(schemas: readonly CommandSchema<TValue>[]): CommandSchema<TValue>;
+};
+export {};
+//# sourceMappingURL=command-schema.d.ts.map

package/dist/core/command-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-schema.d.ts","sourceRoot":"","sources":["../../src/core/command-schema.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,YAAY,GAAG;IACzB,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,eAAe,CAAC,MAAM,IAAI;IACpC,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,MAAM,WAAW,aAAa,CAAC,MAAM;IACnC,KAAK,CACH,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,YAAY,GAChB,eAAe,CAAC,MAAM,CAAC,CAAA;CAC3B;AAED,MAAM,MAAM,WAAW,CAAC,OAAO,IAC7B,OAAO,SAAS,aAAa,CAAC,MAAM,MAAM,CAAC,GAAG,MAAM,GAAG,KAAK,CAAA;AAE9D,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC,CAAA;AAEzD,KAAK,UAAU,CAAC,MAAM,SAAS,WAAW,IAAI;KAC3C,CAAC,IAAI,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;CAC5C,CAAA;AAQD,qBAAa,mBAAoB,SAAQ,KAAK;;CAI7C;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EACpC,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,EAC5B,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,WAAW,EAAE,MAAM,GAClB,KAAK,CAmBP;AAqBD,eAAO,MAAM,CAAC;WACL,MAAM,SAAS,aAAa,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,GAAG,aAAa,CAAC,MAAM,CAAC;WAIrE,aAAa,CAAC,MAAM,CAAC;YAIpB,aAAa,CAAC,MAAM,CAAC;cAOnB,aAAa,CAAC,MAAM,CAAC;sBAOb;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,aAAa,CAAC,MAAM,CAAC;yBAwBnD;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,aAAa,CAAC,MAAM,CAAC;aAqBlE,aAAa,CAAC,MAAM,CAAC;YAWtB,QAAQ,SAAS,MAAM,YACnB,QAAQ,GACjB,aAAa,CAAC,QAAQ,CAAC;aAWjB,MAAM,UACL,aAAa,CAAC,MAAM,CAAC,GAC5B,aAAa,CAAC,MAAM,GAAG,SAAS,CAAC;aAkB3B,MAAM,UACL,aAAa,CAAC,MAAM,CAAC,YACnB;QAAE,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,GACzB,aAAa,CAAC,MAAM,EAAE,CAAC;WAqBnB,MAAM,SAAS,WAAW,SACxB,MAAM,GACZ,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;UAkB9B,MAAM,WACD,SAAS,aAAa,CAAC,MAAM,CAAC,EAAE,GACxC,aAAa,CAAC,MAAM,CAAC;CAyBzB,CAAA"}