fix(client): route and split the raw cluster sendCommand path correctly

The policy refactor folded the raw cluster sendCommand into
_executeWithPolicies but built its parser wrong, regressing behaviour
master got right by routing on the explicit firstKey:

- firstKey was prepended to args, so redisArgs[0] became a key instead
  of the command name (breaking policy resolution) and no key was ever
  marked, leaving parser.firstKey unset so routing fell back to
  undefined.
- makeFn ignored the per-entry sub-parser and always sent the original
  args, so a split multi_shard command sent the full command to every
  shard.

Build redisArgs as an exact copy of args (command name at index 0) and
register the caller's firstKey via a new BasicCommandParser.markRoutingKey,
which records the key for routing without re-appending it to redisArgs.
Send p.redisArgs from the closure so split sub-commands each carry their
own slot's arguments. A known multi_shard command sent raw now splits
correctly, since the resolver supplies its key specs and the splitter
operates on the flat redisArgs.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: nkaradzhov

packages/client/lib/client/parser.spec.ts

@@ -0,0 +1,35 @@
+import { strict as assert } from 'node:assert';
+import { BasicCommandParser } from './parser';
+
+describe('BasicCommandParser', () => {
+  describe('markRoutingKey', () => {
+    it('sets firstKey without appending to redisArgs', () => {
+      const parser = new BasicCommandParser();
+      parser.push('MGET', 'k1', 'k2');
+      parser.markRoutingKey('k1');
+
+      // redisArgs stays an exact copy of what was pushed (the wire command).
+      assert.deepEqual(parser.redisArgs, ['MGET', 'k1', 'k2']);
+      // ...but the key is registered for routing.
+      assert.deepEqual(parser.keys, ['k1']);
+      assert.equal(parser.firstKey, 'k1');
+    });
+
+    it('leaves keys empty when never called (keyless raw command)', () => {
+      const parser = new BasicCommandParser();
+      parser.push('PING');
+
+      assert.deepEqual(parser.redisArgs, ['PING']);
+      assert.deepEqual(parser.keys, []);
+      assert.equal(parser.firstKey, undefined);
+    });
+
+    it('keeps commandIdentifier pointing at the command name', () => {
+      const parser = new BasicCommandParser();
+      parser.push('GET', 'k1');
+      parser.markRoutingKey('k1');
+
+      assert.deepEqual(parser.commandIdentifier, { command: 'GET', subcommand: 'k1' });
+    });
+  });
+});

packages/client/lib/client/parser.ts

@@ -94,6 +94,17 @@ export class BasicCommandParser implements CommandParser {
     this.#redisArgs.push(key);
   }
 
+  /**
+   * Records a routing key whose value is already present in the pushed args,
+   * without appending it again. Used by the raw cluster `sendCommand` path,
+   * where the caller supplies the routing key separately from the full,
+   * already-assembled argument list — so `firstKey` resolves for routing while
+   * `redisArgs` stays an exact copy of the command sent on the wire.
+   */
+  markRoutingKey(key: RedisArgument) {
+    this.#keys.push(key);
+  }
+
   pushKeysLength(keys: RedisVariadicArgument) {
     if (Array.isArray(keys)) {
       this.#redisArgs.push(keys.length.toString());

packages/client/lib/cluster/index.ts

@@ -617,17 +617,23 @@ export default class RedisCluster<
       ...options
     }
 
+    // `args` is the full command as sent on the wire (name at index 0), so it
+    // becomes `redisArgs` verbatim — policy resolution reads the command name
+    // and the multi_shard splitter's key-spec offsets line up. The caller's
+    // `firstKey` is marked for routing without re-appending it.
     const parser = new BasicCommandParser();
-    if (firstKey) parser.push(firstKey);
     args.forEach(arg => parser.push(arg));
+    if (firstKey !== undefined) parser.markRoutingKey(firstKey);
 
     // Raw path: no command object, so readonly-ness stays an explicit caller
-    // argument and the reply is returned untransformed.
+    // argument and the reply is returned untransformed. The closure sends the
+    // per-entry parser's args, so split multi_shard sub-commands each carry
+    // their own slot's arguments (and the unsplit case sends `args` unchanged).
     return this._self._executeWithPolicies(
       parser,
       isReadonly,
       opts,
-      () => (client, opts) => client.sendCommand(args, opts)
+      p => (client, opts) => client.sendCommand(p.redisArgs as CommandArguments, opts)
     );
   }