serverless-ircd 0.5.0 → 0.7.0

package/packages/irc-server/tests/actor.test.ts

@@ -1,5 +1,6 @@
 import {
   type AccountStore,
+  type AwayStore,
   CapturingLogger,
   type ChanName,
   type ChanSnapshot,
@@ -11,16 +12,21 @@ import {
   EmptyMotdProvider,
   FakeClock,
   type FloodControlConfig,
+  InMemoryAwayStore,
   InMemoryMessageStore,
+  InMemoryMonitorStore,
   InMemoryNickHistoryStore,
+  InMemoryReadMarkerStore,
   LogLevel,
   type Logger,
   type MessageStore,
+  type MonitorStore,
   type MtlsIdentityProvider,
   type Nick,
   type NickHistoryStore,
   Numerics,
   type RawLine,
+  type ReadMarkerStore,
   type SaslPayload,
   type SaslResult,
   SequentialIdFactory,
@@ -122,14 +128,27 @@ class FakeRuntime implements IrcRuntime {
   }
   async reserveNick(nick: Nick, conn: ConnId): Promise<{ ok: true } | { ok: false }> {
     this.calls.push({ method: 'reserveNick', args: [nick, conn] });
+    const key = nick.toLowerCase();
+    const existing = this.nicks.get(key);
+    if (existing !== undefined && existing !== conn) {
+      return { ok: false };
+    }
+    this.nicks.set(key, conn);
     return { ok: true };
   }
   async changeNick(conn: ConnId, oldNick: Nick, newNick: Nick): Promise<boolean> {
     this.calls.push({ method: 'changeNick', args: [conn, oldNick, newNick] });
+    const newKey = newNick.toLowerCase();
+    const oldKey = oldNick.toLowerCase();
+    const owner = this.nicks.get(newKey);
+    if (owner !== undefined && owner !== conn) return false;
+    this.nicks.set(newKey, conn);
+    if (this.nicks.get(oldKey) === conn) this.nicks.delete(oldKey);
     return true;
   }
   async releaseNick(nick: Nick): Promise<void> {
     this.calls.push({ method: 'releaseNick', args: [nick] });
+    this.nicks.delete(nick.toLowerCase());
   }
   async applyChannelDelta(chan: ChanName, delta: ChannelDelta): Promise<void> {
     this.calls.push({ method: 'applyChannelDelta', args: [chan, delta] });
@@ -206,6 +225,10 @@ function makeActor(opts: {
   operCreds?: ReadonlyArray<{ user: string; password: string }>;
   transport?: Transport;
   configSource?: string;
+  secure?: boolean;
+  monitor?: MonitorStore;
+  away?: AwayStore;
+  readMarkers?: ReadMarkerStore;
 }): { actor: ConnectionActor; runtime: FakeRuntime; conn: ConnectionState } {
   const clock = opts.clock ?? new FakeClock(1_000);
   const conn = createConnection({ id: 'c1', connectedSince: 0 });
@@ -274,6 +297,18 @@ function makeActor(opts: {
   if (opts.configSource !== undefined) {
     finalOpts.configSource = opts.configSource;
   }
+  if (opts.secure !== undefined) {
+    finalOpts.secure = opts.secure;
+  }
+  if (opts.monitor !== undefined) {
+    finalOpts.monitor = opts.monitor;
+  }
+  if (opts.away !== undefined) {
+    finalOpts.away = opts.away;
+  }
+  if (opts.readMarkers !== undefined) {
+    finalOpts.readMarkers = opts.readMarkers;
+  }
   const actor = new ConnectionActor(finalOpts);
   return { actor, runtime, conn };
 }
@@ -283,23 +318,75 @@ void isChannelTarget;
 
 describe('ConnectionActor — framing', () => {
   it('processes one PRIVMSG in a single text frame into one broadcast', async () => {
+    const bobConn = createConnection({ id: 'c2', connectedSince: 0 });
+    bobConn.nick = 'bob';
+    bobConn.user = 'bob';
+    bobConn.host = 'example.org';
+    bobConn.registration = 'registered';
     const { actor, runtime } = makeActor({});
+    runtime.addConnection(bobConn);
     // Pre-add the connection to the channel so the broadcast excludes the sender.
     await runtime.applyChannelDelta('#foo', {
-      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+      memberships: [
+        { type: 'add', conn: 'c1', nick: 'alice' },
+        { type: 'add', conn: 'c2', nick: 'bob' },
+      ],
     });
     runtime.calls.length = 0;
 
     await actor.receiveTextFrame('PRIVMSG #foo :hello\r\n');
 
-    const broadcasts = runtime.calls.filter((c) => c.method === 'broadcast');
-    expect(broadcasts).toHaveLength(1);
-    expect(broadcasts[0]?.args[0]).toBe('#foo');
-    expect(broadcasts[0]?.args[2]).toBe('c1'); // except sender
-    const lines = broadcasts[0]?.args[1] as RawLine[];
+    // Channel PRIVMSG fans out cap-split (msgid): dispatch resolves each
+    // member's caps and sends per-recipient. bob (no msgid cap) gets the bare
+    // line; the sender (c1) is excluded.
+    const toBob = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c2');
+    expect(toBob).toHaveLength(1);
+    expect(toBob[0]?.args[0]).toBe('c2');
+    const lines = toBob[0]?.args[1] as RawLine[];
     expect(lines[0]?.text).toBe(':alice!alice@example.com PRIVMSG #foo :hello');
   });
 
+  it('delivers @msgid=<id> to a msgid-cap peer and the bare line to a non-cap peer', async () => {
+    const bobConn = createConnection({ id: 'c2', connectedSince: 0 });
+    bobConn.nick = 'bob';
+    bobConn.user = 'bob';
+    bobConn.host = 'example.org';
+    bobConn.registration = 'registered';
+    bobConn.caps = new Set<string>(['msgid']);
+    const carolConn = createConnection({ id: 'c3', connectedSince: 0 });
+    carolConn.nick = 'carol';
+    carolConn.user = 'carol';
+    carolConn.host = 'example.net';
+    carolConn.registration = 'registered';
+    const { actor, runtime } = makeActor({});
+    runtime.addConnection(bobConn);
+    runtime.addConnection(carolConn);
+    await runtime.applyChannelDelta('#foo', {
+      memberships: [
+        { type: 'add', conn: 'c1', nick: 'alice' },
+        { type: 'add', conn: 'c2', nick: 'bob' },
+        { type: 'add', conn: 'c3', nick: 'carol' },
+      ],
+    });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('PRIVMSG #foo :hi\r\n');
+
+    // bob (msgid cap) receives the decorated line; carol (no cap) receives
+    // the bare line. The sender (c1) is excluded from both.
+    const toBob = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c2');
+    const toCarol = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c3');
+    expect(toBob).toHaveLength(1);
+    expect(toCarol).toHaveLength(1);
+    const bobLine = (toBob[0]?.args[1] as RawLine[])[0]?.text ?? '';
+    // bob sees the msgid-tagged line; carol sees the bare line. The msgid
+    // value is opaque (an IdFactory nonce), so match the shape not the value.
+    expect(bobLine).toMatch(/^@msgid=nonce-\d+ :alice!alice@example\.com PRIVMSG #foo :hi$/);
+    expect((toCarol[0]?.args[1] as RawLine[])[0]?.text).toBe(
+      ':alice!alice@example.com PRIVMSG #foo :hi',
+    );
+  });
+
   it('tolerates a frame without a trailing CRLF', async () => {
     const { actor, runtime } = makeActor({});
     await actor.receiveTextFrame('PING :tok');
@@ -339,9 +426,18 @@ describe('ConnectionActor — framing', () => {
 
 describe('ConnectionActor — TCP byte-stream transport seam', () => {
   it('two TCP chunks split mid-line produce exactly one PRIVMSG broadcast', async () => {
+    const bobConn = createConnection({ id: 'c2', connectedSince: 0 });
+    bobConn.nick = 'bob';
+    bobConn.user = 'bob';
+    bobConn.host = 'example.org';
+    bobConn.registration = 'registered';
     const { actor, runtime } = makeActor({ transport: new TcpByteStreamTransport() });
+    runtime.addConnection(bobConn);
     await runtime.applyChannelDelta('#foo', {
-      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+      memberships: [
+        { type: 'add', conn: 'c1', nick: 'alice' },
+        { type: 'add', conn: 'c2', nick: 'bob' },
+      ],
     });
     runtime.calls.length = 0;
 
@@ -351,10 +447,10 @@ describe('ConnectionActor — TCP byte-stream transport seam', () => {
     expect(runtime.calls).toHaveLength(0);
     await actor.receive('lo\r\n');
 
-    const broadcasts = runtime.calls.filter((c) => c.method === 'broadcast');
-    expect(broadcasts).toHaveLength(1);
-    expect(broadcasts[0]?.args[0]).toBe('#foo');
-    const lines = broadcasts[0]?.args[1] as RawLine[];
+    // Exactly one fanout to bob (cap-split dispatch sends per-recipient).
+    const toBob = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c2');
+    expect(toBob).toHaveLength(1);
+    const lines = toBob[0]?.args[1] as RawLine[];
     expect(lines[0]?.text).toBe(':alice!alice@example.com PRIVMSG #foo :hello');
   });
 
@@ -365,8 +461,17 @@ describe('ConnectionActor — TCP byte-stream transport seam', () => {
     const wsSetup = makeActor({});
     const tcpSetup = makeActor({ transport: new TcpByteStreamTransport() });
     for (const rt of [wsSetup.runtime, tcpSetup.runtime]) {
+      const bobConn = createConnection({ id: 'c2', connectedSince: 0 });
+      bobConn.nick = 'bob';
+      bobConn.user = 'bob';
+      bobConn.host = 'example.org';
+      bobConn.registration = 'registered';
+      rt.addConnection(bobConn);
       await rt.applyChannelDelta('#foo', {
-        memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+        memberships: [
+          { type: 'add', conn: 'c1', nick: 'alice' },
+          { type: 'add', conn: 'c2', nick: 'bob' },
+        ],
       });
     }
     wsSetup.runtime.calls.length = 0;
@@ -379,18 +484,30 @@ describe('ConnectionActor — TCP byte-stream transport seam', () => {
       await tcpSetup.actor.receive(stream.slice(i, i + 4));
     }
 
-    const wsBroadcast = wsSetup.runtime.calls.filter((c) => c.method === 'broadcast');
-    const tcpBroadcast = tcpSetup.runtime.calls.filter((c) => c.method === 'broadcast');
-    expect(tcpBroadcast).toHaveLength(wsBroadcast.length);
-    expect((tcpBroadcast[0]?.args[1] as RawLine[])[0]?.text).toBe(
-      (wsBroadcast[0]?.args[1] as RawLine[])[0]?.text,
+    // Both transports deliver exactly one fanout to bob with identical bytes.
+    const wsSends = wsSetup.runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c2');
+    const tcpSends = tcpSetup.runtime.calls.filter(
+      (c) => c.method === 'send' && c.args[0] === 'c2',
+    );
+    expect(tcpSends).toHaveLength(wsSends.length);
+    expect((tcpSends[0]?.args[1] as RawLine[])[0]?.text).toBe(
+      (wsSends[0]?.args[1] as RawLine[])[0]?.text,
     );
   });
 
   it('buffers a partial line across multiple chunks with no loss or duplication', async () => {
+    const bobConn = createConnection({ id: 'c2', connectedSince: 0 });
+    bobConn.nick = 'bob';
+    bobConn.user = 'bob';
+    bobConn.host = 'example.org';
+    bobConn.registration = 'registered';
     const { actor, runtime } = makeActor({ transport: new TcpByteStreamTransport() });
+    runtime.addConnection(bobConn);
     await runtime.applyChannelDelta('#foo', {
-      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+      memberships: [
+        { type: 'add', conn: 'c1', nick: 'alice' },
+        { type: 'add', conn: 'c2', nick: 'bob' },
+      ],
     });
     runtime.calls.length = 0;
 
@@ -400,13 +517,14 @@ describe('ConnectionActor — TCP byte-stream transport seam', () => {
     for (const ch of stream) {
       await actor.receive(ch);
     }
-    const sends = runtime.calls.filter((c) => c.method === 'send');
-    const broadcasts = runtime.calls.filter((c) => c.method === 'broadcast');
-    expect(sends).toHaveLength(2); // PONG :a, PONG :c
-    expect((sends[0]?.args[1] as RawLine[])[0]?.text).toBe('PONG :a');
-    expect((sends[1]?.args[1] as RawLine[])[0]?.text).toBe('PONG :c');
-    expect(broadcasts).toHaveLength(1); // PRIVMSG #foo :b
-    expect((broadcasts[0]?.args[1] as RawLine[])[0]?.text).toBe(
+    const pongs = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    expect(pongs).toHaveLength(2); // PONG :a, PONG :c
+    expect((pongs[0]?.args[1] as RawLine[])[0]?.text).toBe('PONG :a');
+    expect((pongs[1]?.args[1] as RawLine[])[0]?.text).toBe('PONG :c');
+    // PRIVMSG fans out to bob exactly once (cap-split per-recipient send).
+    const toBob = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c2');
+    expect(toBob).toHaveLength(1); // PRIVMSG #foo :b
+    expect((toBob[0]?.args[1] as RawLine[])[0]?.text).toBe(
       ':alice!alice@example.com PRIVMSG #foo :b',
     );
   });
@@ -531,6 +649,50 @@ describe('ConnectionActor — routing', () => {
   });
 });
 
+describe('ConnectionActor — secure transport (user mode `S`)', () => {
+  it('marks the connection state secure when constructed with secure: true', () => {
+    const { conn } = makeActor({ secure: true });
+    expect(conn.secure).toBe(true);
+  });
+
+  it('defaults to insecure when secure is omitted', () => {
+    const { conn } = makeActor({});
+    expect(conn.secure).toBe(false);
+  });
+
+  it('sets user mode `S` at registration when constructed with secure: true', async () => {
+    const { actor, conn } = makeActor({ secure: true });
+    // Reset to pre-registration so the NICK/USER handshake drives welcome.
+    conn.registration = 'pre-registration';
+    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes
+    delete conn.nick;
+    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes
+    delete conn.user;
+
+    await actor.receiveTextFrame('USER alice 0 * :Alice\r\n');
+    await actor.receiveTextFrame('NICK alice\r\n');
+
+    expect(conn.registration).toBe('registered');
+    expect(conn.userModes.tls).toBe(true);
+    expect(conn.secure).toBe(true);
+  });
+
+  it('does not set user mode `S` when constructed without secure', async () => {
+    const { actor, conn } = makeActor({});
+    conn.registration = 'pre-registration';
+    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes
+    delete conn.nick;
+    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes
+    delete conn.user;
+
+    await actor.receiveTextFrame('USER alice 0 * :Alice\r\n');
+    await actor.receiveTextFrame('NICK alice\r\n');
+
+    expect(conn.registration).toBe('registered');
+    expect(conn.userModes.tls).toBe(false);
+  });
+});
+
 describe('ConnectionActor — additional routing', () => {
   it('routes PART through routeMultiChannel (one channel per invocation)', async () => {
     const { actor, runtime } = makeActor({});
@@ -652,7 +814,9 @@ describe('ConnectionActor — additional routing', () => {
     });
     runtime.calls.length = 0;
     await actor.receiveTextFrame('NOTICE #foo :note\r\n');
-    expect(runtime.calls.filter((c) => c.method === 'broadcast')).toHaveLength(1);
+    // NOTICE channel fanout is cap-split (msgid) so dispatch resolves via
+    // getChannelSnapshot rather than the fast-path broadcast.
+    expect(runtime.calls.filter((c) => c.method === 'getChannelSnapshot')).toHaveLength(1);
   });
 
   it('routes TAGMSG to a channel broadcast (never 421) when message-tags cap is present', async () => {
@@ -713,8 +877,8 @@ describe('ConnectionActor — additional routing', () => {
     });
     runtime.calls.length = 0;
     await actor.receiveTextFrame('PRIVMSG #foo,bob :hi\r\n');
-    // One broadcast (channel) + one sendToNick (user).
-    expect(runtime.calls.filter((c) => c.method === 'broadcast')).toHaveLength(1);
+    // One channel fanout (cap-split → getChannelSnapshot) + one sendToNick.
+    expect(runtime.calls.filter((c) => c.method === 'getChannelSnapshot')).toHaveLength(1);
     expect(runtime.calls.filter((c) => c.method === 'sendToNick')).toHaveLength(1);
   });
 
@@ -1136,7 +1300,15 @@ describe('ConnectionActor — additional routing', () => {
 
   it('routes WALLOPS from an oper through wallopsReducer (broadcastWallops, never 421)', async () => {
     const { actor, runtime } = makeActor({
-      conn: { userModes: { invisible: false, oper: true, wallops: false, serverNotices: false } },
+      conn: {
+        userModes: {
+          invisible: false,
+          oper: true,
+          wallops: false,
+          serverNotices: false,
+          tls: false,
+        },
+      },
     });
     runtime.calls.length = 0;
 
@@ -1180,7 +1352,15 @@ describe('ConnectionActor — additional routing', () => {
 
   it('routes WALLOPS with no message through wallopsReducer (412, never 421)', async () => {
     const { actor, runtime } = makeActor({
-      conn: { userModes: { invisible: false, oper: true, wallops: false, serverNotices: false } },
+      conn: {
+        userModes: {
+          invisible: false,
+          oper: true,
+          wallops: false,
+          serverNotices: false,
+          tls: false,
+        },
+      },
     });
     runtime.calls.length = 0;
 
@@ -1200,7 +1380,15 @@ describe('ConnectionActor — additional routing', () => {
 
   it('routes REHASH from an oper through rehashReducer (382, never 421) and re-invokes the loader', async () => {
     const { actor, runtime, conn } = makeActor({
-      conn: { userModes: { invisible: false, oper: true, wallops: false, serverNotices: false } },
+      conn: {
+        userModes: {
+          invisible: false,
+          oper: true,
+          wallops: false,
+          serverNotices: false,
+          tls: false,
+        },
+      },
       configSource: 'KV',
     });
     runtime.reloadConfigResult = {
@@ -1261,7 +1449,15 @@ describe('ConnectionActor — additional routing', () => {
 
   it('keeps the oper connected and retains the prior config when the loader rejects', async () => {
     const { actor, runtime } = makeActor({
-      conn: { userModes: { invisible: false, oper: true, wallops: false, serverNotices: false } },
+      conn: {
+        userModes: {
+          invisible: false,
+          oper: true,
+          wallops: false,
+          serverNotices: false,
+          tls: false,
+        },
+      },
       configSource: 'KV',
     });
     runtime.reloadConfigError = new Error('store unreachable');
@@ -1292,7 +1488,15 @@ describe('ConnectionActor — additional routing', () => {
 
   it('stringifies a non-Error rejection in the graceful 382 suffix', async () => {
     const { actor, runtime } = makeActor({
-      conn: { userModes: { invisible: false, oper: true, wallops: false, serverNotices: false } },
+      conn: {
+        userModes: {
+          invisible: false,
+          oper: true,
+          wallops: false,
+          serverNotices: false,
+          tls: false,
+        },
+      },
       configSource: 'KV',
     });
     // A non-Error throw exercises the `String(err)` branch of the suffix
@@ -1317,7 +1521,15 @@ describe('ConnectionActor — additional routing', () => {
     // sets the nick before OPER can succeed) but the actor must still
     // format a valid numeric addressed to "*" rather than crash.
     const { actor, runtime, conn } = makeActor({
-      conn: { userModes: { invisible: false, oper: true, wallops: false, serverNotices: false } },
+      conn: {
+        userModes: {
+          invisible: false,
+          oper: true,
+          wallops: false,
+          serverNotices: false,
+          tls: false,
+        },
+      },
       configSource: 'KV',
     });
     // Clear the nick post-construction (exactOptionalPropertyTypes forbids
@@ -1606,10 +1818,11 @@ describe('ConnectionActor — flood control', () => {
       await actor.receiveTextFrame('PRIVMSG #foo :flood\r\n');
     }
 
-    // Disabled → every frame reaches the inner reducer and broadcasts; the
-    // close path is never invoked.
+    // Disabled → every frame reaches the inner reducer and fans out; the
+    // close path is never invoked. Channel PRIVMSG dispatches cap-split
+    // (msgid) via getChannelSnapshot, once per accepted message.
     expect(runtime.calls.filter((c) => c.method === 'disconnect')).toHaveLength(0);
-    expect(runtime.calls.filter((c) => c.method === 'broadcast')).toHaveLength(20);
+    expect(runtime.calls.filter((c) => c.method === 'getChannelSnapshot')).toHaveLength(20);
   });
 
   it('does not let an interleaved PING advance the bucket (control-plane exemption plumbed through)', async () => {
@@ -1893,8 +2106,9 @@ describe('ConnectionActor — CHATHISTORY', () => {
 
     await actor.receiveTextFrame('PRIVMSG #foo :hello\r\n');
 
-    // Broadcast still happens (the message is delivered live)…
-    expect(runtime.calls.filter((c) => c.method === 'broadcast')).toHaveLength(1);
+    // Broadcast still happens (the message is delivered live). Channel
+    // PRIVMSG fans out cap-split (msgid) via getChannelSnapshot…
+    expect(runtime.calls.filter((c) => c.method === 'getChannelSnapshot')).toHaveLength(1);
     // …but there is no store to record into.
   });
 });
@@ -2974,3 +3188,1182 @@ describe('ConnectionActor — WHOIS channel list', () => {
     }
   });
 });
+
+// ============================================================================
+// MONITOR (IRCv3) — synchronous reducer + async push hook
+// ============================================================================
+
+describe('ConnectionActor — MONITOR (synchronous reducer + async push hook)', () => {
+  /**
+   * Builds two actors (alice on c1, bob on c2) sharing a single
+   * {@link InMemoryMonitorStore} and the same FakeRuntime. Mirrors the
+   * production wiring where every ConnectionActor in a deployment shares
+   * one monitor store.
+   */
+  function makeMonitorPair(): {
+    alice: ConnectionActor;
+    bob: ConnectionActor;
+    runtime: FakeRuntime;
+    aliceState: ConnectionState;
+    bobState: ConnectionState;
+    monitor: InMemoryMonitorStore;
+  } {
+    const clock = new FakeClock(1_000);
+    const aliceState = createConnection({ id: 'c1', connectedSince: 0 });
+    aliceState.nick = 'alice';
+    aliceState.user = 'alice';
+    aliceState.host = 'example.com';
+    aliceState.realname = 'Alice';
+    aliceState.registration = 'registered';
+    const bobState = createConnection({ id: 'c2', connectedSince: 0 });
+    bobState.user = 'bob';
+    bobState.host = 'example.com';
+    bobState.realname = 'Bob';
+    // bob is pre-registration so we can drive him through NICK to test the
+    // reserve-time 730 push.
+    const runtime = new FakeRuntime(clock);
+    runtime.addConnection(aliceState);
+    const monitor = new InMemoryMonitorStore();
+    const serverConfig: ServerConfig = {
+      serverName: 'irc.example.com',
+      networkName: 'ExampleNet',
+      maxChannelsPerUser: 30,
+      maxTargetsPerCommand: 10,
+      maxListEntries: 50,
+      nickLen: 30,
+      channelLen: 50,
+      topicLen: 390,
+      quitMessage: 'Client Quit',
+    };
+    const ids = new SequentialIdFactory();
+    type ActorOpts = ConstructorParameters<typeof ConnectionActor>[0];
+    type Mutable<T> = { -readonly [K in keyof T]: T[K] };
+    const aliceOpts: Mutable<ActorOpts> = {
+      state: aliceState,
+      runtime,
+      channels: runtime,
+      serverConfig,
+      clock,
+      ids,
+      motd: EmptyMotdProvider,
+      monitor,
+    };
+    const bobOpts: Mutable<ActorOpts> = {
+      state: bobState,
+      runtime,
+      channels: runtime,
+      serverConfig,
+      clock,
+      ids,
+      motd: EmptyMotdProvider,
+      monitor,
+    };
+    return {
+      alice: new ConnectionActor(aliceOpts),
+      bob: new ConnectionActor(bobOpts),
+      runtime,
+      aliceState,
+      bobState,
+      monitor,
+    };
+  }
+
+  it('MONITOR + offline nick emits 731 RPL_MONOFFLINE (synchronous path)', async () => {
+    const { alice, runtime } = makeMonitorPair();
+    runtime.calls.length = 0;
+
+    await alice.receiveTextFrame('MONITOR + bob\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(lines.some((l) => l.text === ':irc.example.com 731 alice :bob')).toBe(true);
+  });
+
+  it('MONITOR + online nick emits 730 RPL_MONONLINE (synchronous path)', async () => {
+    // Drive bob through the actor's NICK reservation so the dispatch hook
+    // fires monitor.onNickOnline('bob'). Then alice's MONITOR + bob sees
+    // him online via the runtime nick registry (resolveOnlineMap) and
+    // emits 730 synchronously.
+    const { alice, bob, runtime, bobState } = makeMonitorPair();
+    runtime.addConnection(bobState);
+    await bob.receiveTextFrame('NICK bob\r\n');
+    runtime.calls.length = 0;
+
+    await alice.receiveTextFrame('MONITOR + bob\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(lines.some((l) => l.text === ':irc.example.com 730 alice :bob')).toBe(true);
+  });
+
+  it('alice MONITOR + bob (offline) then bob connects → 730 pushed to alice', async () => {
+    const { alice, bob, runtime, bobState } = makeMonitorPair();
+    // alice subscribes to bob while bob is offline.
+    runtime.calls.length = 0;
+    await alice.receiveTextFrame('MONITOR + bob\r\n');
+    // Sanity: 731 emitted for the offline state.
+    {
+      const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+      const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+      expect(lines.some((l) => l.text === ':irc.example.com 731 alice :bob')).toBe(true);
+    }
+
+    // bob now registers — NICK bob reserves the nick. The dispatch hook
+    // fires monitor.onNickOnline('bob'), and bob's actor's post-dispatch
+    // drain emits a Send to alice's connId.
+    runtime.addConnection(bobState);
+    runtime.calls.length = 0;
+    await bob.receiveTextFrame('NICK bob\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(lines.some((l) => l.text === ':irc.example.com 730 alice :bob')).toBe(true);
+  });
+
+  it('bob quits after being monitored → 731 pushed to alice', async () => {
+    const { alice, bob, runtime, bobState } = makeMonitorPair();
+    // Bring bob online through the actor so the dispatch hook fires
+    // monitor.onNickOnline('bob') on reserveNick.
+    runtime.addConnection(bobState);
+    await bob.receiveTextFrame('NICK bob\r\n');
+    runtime.calls.length = 0;
+    // alice subscribes while bob is online.
+    await alice.receiveTextFrame('MONITOR + bob\r\n');
+    runtime.calls.length = 0;
+
+    await bob.receiveTextFrame('QUIT :gone\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(lines.some((l) => l.text === ':irc.example.com 731 alice :bob')).toBe(true);
+  });
+
+  it('unmatched MONITOR subcommand yields 461 (never 421)', async () => {
+    const { alice, runtime } = makeMonitorPair();
+    runtime.calls.length = 0;
+
+    await alice.receiveTextFrame('MONITOR Z\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(lines.some((l) => l.text.includes(' 461 '))).toBe(true);
+    for (const line of lines) {
+      expect(line.text).not.toContain(' 421 ');
+    }
+  });
+
+  it('MONITOR L lists the watchlist then 733 terminator', async () => {
+    const { alice, runtime } = makeMonitorPair();
+    await alice.receiveTextFrame('MONITOR + bob,carol\r\n');
+    runtime.calls.length = 0;
+
+    await alice.receiveTextFrame('MONITOR L\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(lines.some((l) => l.text === ':irc.example.com 732 alice :bob')).toBe(true);
+    expect(lines.some((l) => l.text === ':irc.example.com 732 alice :carol')).toBe(true);
+    expect(lines.some((l) => l.text === ':irc.example.com 733 alice :End of MONITOR list')).toBe(
+      true,
+    );
+  });
+
+  it('MONITOR C empties the watchlist silently', async () => {
+    const { alice, runtime, aliceState } = makeMonitorPair();
+    await alice.receiveTextFrame('MONITOR + bob\r\n');
+    expect(aliceState.monitorList?.has('bob')).toBe(true);
+    runtime.calls.length = 0;
+
+    await alice.receiveTextFrame('MONITOR C\r\n');
+
+    expect(aliceState.monitorList?.size ?? 0).toBe(0);
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    expect(sends).toHaveLength(0);
+  });
+
+  it('works without a bound MonitorStore (synchronous path only, no push fanout)', async () => {
+    // No `monitor:` option → the actor still routes the reducer but skips
+    // the post-dispatch push drain. Covers the `this.monitor === undefined`
+    // branches in routeMonitor and drainMonitorPushes.
+    const { actor, runtime } = makeActor({});
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('MONITOR + bob\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(lines.some((l) => l.text === ':irc.example.com 731 alice :bob')).toBe(true);
+  });
+
+  it('skips a nick whose connection has torn down between lookupNick and getConnection (race)', async () => {
+    // Covers the `conn?.nick !== undefined` false branch in
+    // resolveOnlineMap: lookupNick resolves but getConnection returns null.
+    const { alice, runtime, bobState } = makeMonitorPair();
+    runtime.addConnection(bobState);
+    await alice.receiveTextFrame('MONITOR + bob\r\n');
+    runtime.calls.length = 0;
+    // Drop bob's live connection while leaving the nick map intact so
+    // lookupNick still resolves.
+    runtime.dropConnection('c2');
+
+    await alice.receiveTextFrame('MONITOR S\r\n');
+
+    // 730 absent (bob no longer reachable); 731 present instead.
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(lines.some((l) => l.text.includes(' 731 '))).toBe(true);
+    for (const line of lines) {
+      expect(line.text).not.toContain(' 730 ');
+    }
+  });
+
+  it('skips a nick whose live connection has no nick set (defensive)', async () => {
+    // Covers the `conn.nick !== undefined` false branch in resolveOnlineMap:
+    // lookupNick resolves but the connection state at that id has no nick
+    // (should not happen under correct runtime invariants — defensive).
+    const { alice, runtime, bobState } = makeMonitorPair();
+    runtime.addConnection(bobState);
+    await alice.receiveTextFrame('MONITOR + bob\r\n');
+    runtime.calls.length = 0;
+    // Manually clear bob's nick while leaving the registry intact.
+    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes forbids `= undefined`.
+    delete bobState.nick;
+
+    await alice.receiveTextFrame('MONITOR S\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    for (const line of lines) {
+      expect(line.text).not.toContain(' 730 ');
+    }
+  });
+
+  it('push to a watcher whose live connection has torn down uses * as nick placeholder', async () => {
+    // Covers the `watcher?.nick ?? '*'` `??` branch in drainMonitorPushes:
+    // getConnection returns null → watcherNick falls back to '*'.
+    const { alice, bob, runtime, bobState } = makeMonitorPair();
+    runtime.addConnection(bobState);
+    await alice.receiveTextFrame('MONITOR + bob\r\n');
+    runtime.calls.length = 0;
+    // Drop alice's live connection so the post-QUIT drain cannot resolve
+    // her nick. The push is still attempted; the wire line uses '*'.
+    runtime.dropConnection('c1');
+
+    await bob.receiveTextFrame('NICK bob\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    expect(lines.some((l) => l.text.includes(' 730 * :bob'))).toBe(true);
+  });
+
+  it('reserveNick failure does not fan out a 730 (collision)', async () => {
+    // Two actors racing for the same nick: the second reserve returns
+    // { ok: false } so the dispatch handler must NOT call
+    // monitor.onNickOnline. Covers the `if (result.ok)` false branch.
+    const { alice, bob, runtime, bobState } = makeMonitorPair();
+    runtime.addConnection(bobState);
+    // alice subscribes to bob.
+    await alice.receiveTextFrame('MONITOR + bob\r\n');
+    runtime.calls.length = 0;
+
+    // Pre-reserve bob under alice's connId so bob's NICK collides.
+    await runtime.reserveNick('bob', 'c1');
+    void bob;
+    await bob.receiveTextFrame('NICK bob\r\n');
+
+    // No 730 push should reach alice (the reserve failed).
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    for (const line of lines) {
+      expect(line.text).not.toContain(' 730 ');
+    }
+  });
+
+  it('changeNick failure does not fan out push effects', async () => {
+    // Covers the `if (ok)` false branch in changeNickEtc: changeNick
+    // returns false on collision; monitor hooks must NOT fire.
+    const { alice, bob, runtime } = makeMonitorPair();
+    // bob subscribes to alice; alice then tries NICK <occupied>.
+    await bob.receiveTextFrame('MONITOR + alice\r\n');
+    // Seed both nicks: alice and bob both registered.
+    const bobState2 = createConnection({ id: 'c2', connectedSince: 0 });
+    bobState2.nick = 'bob';
+    bobState2.registration = 'registered';
+    runtime.addConnection(bobState2);
+    runtime.calls.length = 0;
+
+    // alice attempts NICK bob — bob is taken, changeNick fails.
+    await alice.receiveTextFrame('NICK bob\r\n');
+
+    // No push to the bob watcher: changeNick failed.
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c2');
+    const lines = sends.flatMap((s) => s.args[1] as RawLine[]);
+    for (const line of lines) {
+      expect(line.text).not.toMatch(/ 73[01] /u);
+    }
+  });
+});
+
+// ===========================================================================
+// ConnectionActor — IRCv3 labeled-response
+//
+// A client tags an inbound message with `+label=<id>`; the server wraps every
+// reply caused by that message (addressed back to the requester) in a single
+// `BATCH +id labeled-response … BATCH -id`. No-reply requests emit an empty
+// batch so the client can still correlate the label.
+// ===========================================================================
+
+describe('ConnectionActor — IRCv3 labeled-response', () => {
+  /** Caps a labeled-response-capable client negotiates (batch is required). */
+  const LABELED_CAPS = new Set<string>(['batch', 'labeled-response']);
+
+  /** echo-message + labeled caps — a client that sees its own echoed replies. */
+  const ECHO_LABELED_CAPS = new Set<string>(['echo-message', 'batch', 'labeled-response']);
+
+  function makeOnlineConn(id: string, nick: string): ConnectionState {
+    const c = createConnection({ id, connectedSince: 0 });
+    c.nick = nick;
+    c.user = nick;
+    c.host = `${nick}.org`;
+    c.realname = nick;
+    c.registration = 'registered';
+    return c;
+  }
+
+  it('wraps the echo of a labeled PRIVMSG in a BATCH +label labeled-response frame', async () => {
+    const { actor, runtime, conn } = makeActor({ conn: { caps: ECHO_LABELED_CAPS } });
+    runtime.addConnection(makeOnlineConn('c2', 'bob'));
+    // Put alice on #foo so the channel PRIVMSG is accepted.
+    await runtime.applyChannelDelta('#foo', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+    runtime.calls.length = 0;
+    void conn;
+
+    await actor.receiveTextFrame('@+label=foo PRIVMSG #foo :hi\r\n');
+
+    const toAlice = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    expect(toAlice).toHaveLength(1);
+    const lines = toAlice[0]?.args[1] as RawLine[];
+    expect(lines.map((l) => l.text)).toEqual([
+      'BATCH +foo labeled-response',
+      ':alice!alice@example.com PRIVMSG #foo :hi',
+      'BATCH -foo',
+    ]);
+  });
+
+  it('emits an empty labeled batch when the labeled request produces no reply', async () => {
+    // NOTICE (no echo-message) is fire-and-forget for the sender: only a
+    // broadcast to peers, no Send back to the requester.
+    const { actor, runtime } = makeActor({ conn: { caps: LABELED_CAPS } });
+    runtime.addConnection(makeOnlineConn('c2', 'bob'));
+    await runtime.applyChannelDelta('#foo', {
+      memberships: [
+        { type: 'add', conn: 'c1', nick: 'alice' },
+        { type: 'add', conn: 'c2', nick: 'bob' },
+      ],
+    });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('@+label=empty NOTICE #foo :hi\r\n');
+
+    // The requester receives ONLY the empty labeled batch (start + end).
+    const toAlice = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    expect(toAlice).toHaveLength(1);
+    const lines = toAlice[0]?.args[1] as RawLine[];
+    expect(lines.map((l) => l.text)).toEqual(['BATCH +empty labeled-response', 'BATCH -empty']);
+  });
+
+  it('accumulates every reply to the requester under a single labeled batch', async () => {
+    // Multi-target PRIVMSG with echo-message produces one echo Send-to-self
+    // per target; all echoes must land inside ONE labeled batch.
+    const { actor, runtime } = makeActor({ conn: { caps: ECHO_LABELED_CAPS } });
+    runtime.addConnection(makeOnlineConn('c2', 'bob'));
+    runtime.addConnection(makeOnlineConn('c3', 'carol'));
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('@+label=m PRIVMSG bob,carol :hi\r\n');
+
+    const toAlice = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    expect(toAlice).toHaveLength(1);
+    const lines = toAlice[0]?.args[1] as RawLine[];
+    expect(lines.map((l) => l.text)).toEqual([
+      'BATCH +m labeled-response',
+      ':alice!alice@example.com PRIVMSG bob :hi',
+      ':alice!alice@example.com PRIVMSG carol :hi',
+      'BATCH -m',
+    ]);
+  });
+
+  it('wraps an error numeric (403) in the labeled batch', async () => {
+    // JOIN <invalid-name> (no # prefix) yields 403 ERR_NOSUCHCHANNEL, which
+    // must still be wrapped so the requester can correlate the failure.
+    const { actor, runtime } = makeActor({ conn: { caps: LABELED_CAPS } });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('@+label=e JOIN badname\r\n');
+
+    const toAlice = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    expect(toAlice).toHaveLength(1);
+    const lines = toAlice[0]?.args[1] as RawLine[];
+    expect(lines.map((l) => l.text)).toEqual([
+      'BATCH +e labeled-response',
+      ':irc.example.com 403 alice badname :No such channel',
+      'BATCH -e',
+    ]);
+  });
+
+  it('does NOT wrap when the labeled-response cap is absent', async () => {
+    const { actor, runtime } = makeActor({
+      conn: { caps: new Set<string>(['echo-message', 'batch']) },
+    });
+    runtime.addConnection(makeOnlineConn('c2', 'bob'));
+    await runtime.applyChannelDelta('#foo', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('@+label=foo PRIVMSG #foo :hi\r\n');
+
+    const toAlice = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    expect(toAlice).toHaveLength(1);
+    const lines = toAlice[0]?.args[1] as RawLine[];
+    // No batch markers — the echo is delivered bare.
+    expect(lines.map((l) => l.text)).toEqual([':alice!alice@example.com PRIVMSG #foo :hi']);
+  });
+
+  it('does NOT wrap when the batch cap is absent (labeled-response requires batch)', async () => {
+    const { actor, runtime } = makeActor({
+      conn: { caps: new Set<string>(['echo-message', 'labeled-response']) },
+    });
+    runtime.addConnection(makeOnlineConn('c2', 'bob'));
+    await runtime.applyChannelDelta('#foo', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('@+label=foo PRIVMSG #foo :hi\r\n');
+
+    const toAlice = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    expect(toAlice).toHaveLength(1);
+    const lines = toAlice[0]?.args[1] as RawLine[];
+    expect(lines.map((l) => l.text)).toEqual([':alice!alice@example.com PRIVMSG #foo :hi']);
+  });
+
+  it('does NOT wrap an unlabeled PRIVMSG even when both caps are negotiated', async () => {
+    const { actor, runtime } = makeActor({ conn: { caps: ECHO_LABELED_CAPS } });
+    runtime.addConnection(makeOnlineConn('c2', 'bob'));
+    await runtime.applyChannelDelta('#foo', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('PRIVMSG #foo :hi\r\n');
+
+    const toAlice = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    expect(toAlice).toHaveLength(1);
+    const lines = toAlice[0]?.args[1] as RawLine[];
+    expect(lines.map((l) => l.text)).toEqual([':alice!alice@example.com PRIVMSG #foo :hi']);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// draft/multiline BATCH (multi-line batching)
+// ---------------------------------------------------------------------------
+
+/**
+ * Builds a channel with the supplied members and returns per-connection
+ * capture filters. Mirrors the setup used by the framing / msgid tests.
+ */
+async function setupMultilineChannel(
+  runtime: FakeRuntime,
+  members: Array<{ conn: ConnId; nick: string; caps?: ReadonlyArray<string> }>,
+): Promise<void> {
+  await runtime.applyChannelDelta('#foo', {
+    memberships: members.map((m) => ({ type: 'add' as const, conn: m.conn, nick: m.nick })),
+  });
+  for (const m of members) {
+    const conn = createConnection({ id: m.conn, connectedSince: 0 });
+    conn.nick = m.nick;
+    conn.user = m.nick;
+    conn.host = `${m.nick}.example`;
+    conn.registration = 'registered';
+    if (m.caps !== undefined) conn.caps = new Set<string>(m.caps);
+    runtime.addConnection(conn);
+  }
+}
+
+function sentTo(runtime: FakeRuntime, connId: ConnId): RawLine[] {
+  return runtime.calls
+    .filter((c) => c.method === 'send' && c.args[0] === connId)
+    .flatMap((c) => c.args[1] as RawLine[]);
+}
+
+describe('ConnectionActor — draft/multiline BATCH', () => {
+  it('strips the +draft/multiline tag for a non-message-tags legacy peer', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+      { conn: 'c2', nick: 'bob' },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line one\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    // Bob has no caps → bare joined PRIVMSG, no `@+draft/multiline` prefix.
+    const bobLines = sentTo(runtime, 'c2');
+    expect(
+      bobLines.some((l) => l.text === ':alice!alice@example.com PRIVMSG #foo :line one\nline two'),
+    ).toBe(true);
+    expect(bobLines.some((l) => l.text.startsWith('@+draft/multiline'))).toBe(false);
+  });
+
+  it('preserves the +draft/multiline tag for a message-tags-only peer', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+      { conn: 'c4', nick: 'dave', caps: ['message-tags'] },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line one\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    // Dave has message-tags but NOT draft/multiline → tagged joined PRIVMSG.
+    const daveLines = sentTo(runtime, 'c4');
+    expect(
+      daveLines.some(
+        (l) =>
+          l.text === '@+draft/multiline :alice!alice@example.com PRIVMSG #foo :line one\nline two',
+      ),
+    ).toBe(true);
+  });
+
+  it('relays a 2-line batch to a multiline-capable peer as a BATCH frame', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+      { conn: 'c3', nick: 'carol', caps: ['batch', 'draft/multiline'] },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line one\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    // Multiline-capable carol receives the replayed BATCH framing. The batch
+    // ref id is allocated from the shared id factory (offset by per-frame
+    // trace ids), so match the shape rather than the exact id.
+    const carolLines = sentTo(runtime, 'c3');
+    const joined = carolLines.map((l) => l.text).join('|');
+    expect(joined).toMatch(/BATCH \+batch-\d+ draft\/multiline #foo/);
+    expect(joined).toContain(':alice!alice@example.com PRIVMSG #foo :line one');
+    expect(joined).toContain(':alice!alice@example.com PRIVMSG #foo :line two');
+    expect(joined).toMatch(/BATCH -batch-\d+/);
+    // And she does NOT receive the legacy joined form.
+    expect(carolLines.some((l) => l.text.startsWith('@+draft/multiline'))).toBe(false);
+  });
+
+  it('rejects an over-budget batch with FAIL and relays nothing', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline', 'standard-replies']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+      { conn: 'c2', nick: 'bob' },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :aaaaaaaaaa\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :bbbbbbbbbb\r\n');
+    // Two 10-char lines => joined 10 + 1 + 10 = 21 bytes. The actor uses the
+    // default 4096 budget; force a tiny budget via a config-override actor.
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    // With the default budget this is accepted; assert no FAIL on this path.
+    expect(sentTo(runtime, 'c1').some((l) => l.text.includes('FAIL BATCH'))).toBe(false);
+  });
+
+  it('rejects an over-budget batch with FAIL when the configured budget is small', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline', 'standard-replies']);
+    // Override the actor's config to advertise a tiny multiline budget.
+    (actor as unknown as { serverConfig: ServerConfig }).serverConfig = {
+      ...(actor as unknown as { serverConfig: ServerConfig }).serverConfig,
+      multilineMaxBytes: 10,
+    };
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+      { conn: 'c2', nick: 'bob' },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :hello\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :world\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    // Sender receives the FAIL; no broadcast to bob.
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(
+      aliceLines.some(
+        (l) =>
+          l.text ===
+          ':irc.example.com FAIL BATCH MULTILINE_MAX_BYTES #foo :Multi-line batch exceeds the 10 byte limit',
+      ),
+    ).toBe(true);
+    expect(runtime.calls.some((c) => c.method === 'broadcast')).toBe(false);
+  });
+
+  it('ignores a BATCH open from a client without the draft/multiline cap (421)', async () => {
+    const { actor, runtime } = makeActor({});
+    // Sender has batch but NOT draft/multiline.
+    await setupMultilineChannel(runtime, [{ conn: 'c1', nick: 'alice', caps: ['batch'] }]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+
+    // Falls back to 421 ERR_UNKNOWNCOMMAND for an unsupported batch open.
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text.includes(' 421 '))).toBe(true);
+  });
+
+  it('ignores inner PRIVMSG while no multiline batch is open (normal delivery)', async () => {
+    const { actor, runtime } = makeActor({});
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice' },
+      { conn: 'c2', nick: 'bob' },
+    ]);
+    runtime.calls.length = 0;
+
+    // A standalone PRIVMSG (no open batch) is delivered as a normal channel
+    // message, not swallowed by the multiline accumulator.
+    await actor.receiveTextFrame('PRIVMSG #foo :plain\r\n');
+
+    const bobLines = sentTo(runtime, 'c2');
+    expect(bobLines.some((l) => l.text === ':alice!alice@example.com PRIVMSG #foo :plain')).toBe(
+      true,
+    );
+  });
+
+  it('falls back to 421 when closing a batch with an unknown id', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+    ]);
+    runtime.calls.length = 0;
+
+    // No batch is open; `BATCH -nope` hits the unknown-id path.
+    await actor.receiveTextFrame('BATCH -nope\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text.includes(' 421 '))).toBe(true);
+  });
+
+  it('aborts the batch with FAIL when an inner line targets a different channel', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #bar :wrong target\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(
+      aliceLines.some((l) => l.text.includes('FAIL BATCH MULTILINE_INVALID_TARGET #foo')),
+    ).toBe(true);
+  });
+
+  it('aborts the batch with FAIL when inner lines mix PRIVMSG and NOTICE', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :first\r\n');
+    await actor.receiveTextFrame('NOTICE #foo :mixed\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(
+      aliceLines.some((l) => l.text.includes('FAIL BATCH MULTILINE_MIXED_COMMANDS #foo')),
+    ).toBe(true);
+  });
+
+  it('falls back to 421 for a BATCH frame with a malformed marker', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    runtime.calls.length = 0;
+
+    // Neither `+id` nor `-id` — the marker is a bare word.
+    await actor.receiveTextFrame('BATCH bogus\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text.includes(' 421 '))).toBe(true);
+  });
+
+  it('falls back to 421 for a BATCH open with the wrong batch type', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 netsplit :#foo\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text.includes(' 421 '))).toBe(true);
+  });
+
+  it('falls back to 421 when opening a second batch before the first closes', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    // Re-open without closing the first.
+    await actor.receiveTextFrame('BATCH +m2 draft/multiline :#foo\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text.includes(' 421 '))).toBe(true);
+  });
+
+  it('falls back to 421 for a BATCH frame with no params', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text.includes(' 421 '))).toBe(true);
+  });
+
+  it('accumulates an inner PRIVMSG with no trailing text as empty', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+      { conn: 'c2', nick: 'bob' },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    // Inner PRIVMSG with no trailing parameter — exercises the `?? ''` fallback.
+    await actor.receiveTextFrame('PRIVMSG #foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :real text\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    // The batch still finalizes; bob receives the joined content (empty + real).
+    const bobLines = sentTo(runtime, 'c2');
+    expect(bobLines.some((l) => l.text.includes('PRIVMSG #foo :'))).toBe(true);
+  });
+
+  it('treats accumulateMultilineLine as a no-op when no batch is open (defensive guard)', () => {
+    const { actor } = makeActor({});
+    // route() only dispatches PRIVMSG/NOTICE here while a batch is open; the
+    // method still guards defensively so a future caller cannot crash. Pin
+    // that no-op contract by invoking the private method with no batch open.
+    const result = (
+      actor as unknown as {
+        accumulateMultilineLine: (msg: { command: string; params: string[] }) => unknown[];
+      }
+    ).accumulateMultilineLine({ command: 'PRIVMSG', params: ['#foo', 'hi'] });
+    expect(result).toEqual([]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// draft/multiline BATCH — nick-target routing
+//
+// A batch whose target is a nick (not a channel) must be delivered to that
+// nick only. The pure reducer is channel-focused (Broadcast); nick-target
+// delivery requires actor-side per-recipient cap resolution.
+// ---------------------------------------------------------------------------
+
+describe('ConnectionActor — ctx store plumbing (draft/pre-away, draft/read-marker)', () => {
+  it('persists an AWAY reason to the bound AwayStore for an identified connection', async () => {
+    const away = new InMemoryAwayStore();
+    const { actor, conn } = makeActor({ away, conn: { account: 'alice' } });
+
+    await actor.receiveTextFrame('AWAY :gone fishing\r\n');
+
+    expect(conn.away).toBe('gone fishing');
+    expect(away.get('alice')).toBe('gone fishing');
+  });
+
+  it('does not persist AWAY to the store when the connection is unidentified', async () => {
+    const away = new InMemoryAwayStore();
+    const { actor, conn } = makeActor({ away });
+
+    await actor.receiveTextFrame('AWAY :gone fishing\r\n');
+
+    // In-memory session state still tracks the reason; the persisted store
+    // stays empty because the connection has no account.
+    expect(conn.away).toBe('gone fishing');
+    expect(away.get('alice')).toBeUndefined();
+  });
+
+  it('persists a +draft/read-marker TAGMSG to the bound ReadMarkerStore for an identified member', async () => {
+    const readMarkers = new InMemoryReadMarkerStore();
+    const { actor, runtime, conn } = makeActor({ readMarkers });
+    conn.account = 'alice';
+    conn.caps = new Set<string>(['message-tags', 'draft/read-marker']);
+    await setupMultilineChannel(runtime, [{ conn: 'c1', nick: 'alice' }]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('@+draft/read-marker=msg-42 TAGMSG #foo\r\n');
+
+    expect(readMarkers.get('alice', '#foo')).toBe('msg-42');
+  });
+});
+
+describe('ConnectionActor — draft/multiline BATCH to a nick target', () => {
+  function addRecipient(
+    runtime: FakeRuntime,
+    conn: ConnId,
+    nick: string,
+    caps?: ReadonlyArray<string>,
+  ): ConnectionState {
+    const state = createConnection({ id: conn, connectedSince: 0 });
+    state.nick = nick;
+    state.user = nick;
+    state.host = `${nick}.example`;
+    state.registration = 'registered';
+    if (caps !== undefined) state.caps = new Set<string>(caps);
+    runtime.addConnection(state);
+    return state;
+  }
+
+  it('delivers a nick-target batch to a multiline-capable recipient as a BATCH frame', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    addRecipient(runtime, 'c2', 'bob', ['batch', 'draft/multiline']);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line one\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    const bobLines = sentTo(runtime, 'c2');
+    const joined = bobLines.map((l) => l.text).join('|');
+    expect(joined).toMatch(/BATCH \+batch-\d+ draft\/multiline bob/);
+    expect(joined).toContain(':alice!alice@example.com PRIVMSG bob :line one');
+    expect(joined).toContain(':alice!alice@example.com PRIVMSG bob :line two');
+    expect(joined).toMatch(/BATCH -batch-\d+/);
+  });
+
+  it('delivers a nick-target batch to a legacy recipient as a single joined PRIVMSG', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    addRecipient(runtime, 'c2', 'bob');
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line one\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    const bobLines = sentTo(runtime, 'c2');
+    expect(
+      bobLines.some((l) => l.text === ':alice!alice@example.com PRIVMSG bob :line one\nline two'),
+    ).toBe(true);
+  });
+
+  it('delivers a nick-target batch to a message-tags recipient as a tagged joined PRIVMSG', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    addRecipient(runtime, 'c2', 'bob', ['message-tags']);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line one\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    const bobLines = sentTo(runtime, 'c2');
+    expect(
+      bobLines.some(
+        (l) =>
+          l.text === '@+draft/multiline :alice!alice@example.com PRIVMSG bob :line one\nline two',
+      ),
+    ).toBe(true);
+  });
+
+  it('does not broadcast a nick-target batch to other connections', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    addRecipient(runtime, 'c2', 'bob', ['batch', 'draft/multiline']);
+    addRecipient(runtime, 'c3', 'carol', ['batch', 'draft/multiline']);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line one\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    // Carol is NOT the nick target and must not receive the batch.
+    const carolLines = sentTo(runtime, 'c3');
+    expect(carolLines).toHaveLength(0);
+  });
+
+  it('surfaces 401 ERR_NOSUCHNICK for a nick-target PRIVMSG when the recipient is offline', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    // bob is NOT registered → lookupNick returns null.
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line one\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text.includes(' 401 '))).toBe(true);
+    expect(aliceLines.some((l) => l.text.includes('bob'))).toBe(true);
+  });
+
+  it('omits 401 for a nick-target NOTICE when the recipient is offline', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('NOTICE bob :quiet one\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text.includes(' 401 '))).toBe(false);
+  });
+
+  it('delivers nothing for an empty nick-target batch', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    const bobConn = createConnection({ id: 'c2', connectedSince: 0 });
+    bobConn.nick = 'bob';
+    bobConn.user = 'bob';
+    bobConn.host = 'bob.example';
+    bobConn.registration = 'registered';
+    bobConn.caps = new Set<string>(['batch', 'draft/multiline']);
+    runtime.addConnection(bobConn);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    expect(sentTo(runtime, 'c2')).toHaveLength(0);
+  });
+
+  it('rejects an over-budget nick-target batch with FAIL', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline', 'standard-replies']);
+    (actor as unknown as { serverConfig: ServerConfig }).serverConfig = {
+      ...(actor as unknown as { serverConfig: ServerConfig }).serverConfig,
+      multilineMaxBytes: 5,
+    };
+    const bobConn = createConnection({ id: 'c2', connectedSince: 0 });
+    bobConn.nick = 'bob';
+    bobConn.user = 'bob';
+    bobConn.host = 'bob.example';
+    bobConn.registration = 'registered';
+    runtime.addConnection(bobConn);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :hello world\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(
+      aliceLines.some(
+        (l) =>
+          l.text ===
+          ':irc.example.com FAIL BATCH MULTILINE_MAX_BYTES bob :Multi-line batch exceeds the 5 byte limit',
+      ),
+    ).toBe(true);
+    expect(sentTo(runtime, 'c2')).toHaveLength(0);
+  });
+
+  it('surfaces 401 when the recipient connection is gone mid-flight', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    const bobConn = createConnection({ id: 'c2', connectedSince: 0 });
+    bobConn.nick = 'bob';
+    bobConn.user = 'bob';
+    bobConn.host = 'bob.example';
+    bobConn.registration = 'registered';
+    runtime.addConnection(bobConn);
+    // Drop the connection AFTER nick registration so lookupNick resolves but
+    // getConnection returns null (the "gone between the two awaits" race).
+    runtime.dropConnection('c2');
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line one\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text.includes(' 401 '))).toBe(true);
+  });
+
+  it('uses "?" and "*" fallbacks when the sender has no nick', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    // A connection that negotiated caps but has no NICK set — exercises the
+    // hostmask `?? '?'` and numeric `?? '*'` fallbacks. `delete` is required
+    // because `exactOptionalPropertyTypes` forbids `= undefined`.
+    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes requires delete
+    delete conn.nick;
+    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes requires delete
+    delete conn.user;
+    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes requires delete
+    delete conn.host;
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    const bobConn = createConnection({ id: 'c2', connectedSince: 0 });
+    bobConn.nick = 'bob';
+    bobConn.user = 'bob';
+    bobConn.host = 'bob.example';
+    bobConn.registration = 'registered';
+    bobConn.caps = new Set<string>(['batch', 'draft/multiline']);
+    runtime.addConnection(bobConn);
+    runtime.calls.length = 0;
+
+    // Online recipient → hostmask falls back to "?".
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :line one\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    const bobLines = sentTo(runtime, 'c2');
+    expect(bobLines.some((l) => l.text.startsWith(':? PRIVMSG bob :line one'))).toBe(true);
+
+    // Offline recipient → numeric falls back to "*".
+    runtime.calls.length = 0;
+    await actor.receiveTextFrame('BATCH +m2 draft/multiline :carol\r\n');
+    await actor.receiveTextFrame('PRIVMSG carol :no recipient\r\n');
+    await actor.receiveTextFrame('BATCH -m2\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text.includes(' 401 * carol'))).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// draft/multiline BATCH — chathistory recording
+//
+// A finalized multi-line batch must be recorded once into the bound
+// MessageStore so CHATHISTORY AFTER/BEFORE/LATEST return exactly one entry
+// per batch, carrying the joined body, the assigned msgid, and the
+// +draft/multiline client tag.
+// ---------------------------------------------------------------------------
+
+describe('ConnectionActor — draft/multiline chathistory recording', () => {
+  it('records the joined channel batch into the MessageStore', async () => {
+    const store = new InMemoryMessageStore();
+    const { actor, runtime, conn } = makeActor({ messages: store });
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line one\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    const recorded = store.query({ chan: '#foo', direction: 'latest', limit: 10 });
+    expect(recorded).toHaveLength(1);
+    expect(recorded[0]?.text).toBe('line one\nline two');
+    expect(recorded[0]?.command).toBe('PRIVMSG');
+    expect(recorded[0]?.nick).toBe('alice');
+    expect(recorded[0]?.msgid).toMatch(/^[A-Za-z0-9_-]+$/);
+  });
+
+  it('CHATHISTORY replay carries the +draft/multiline tag on the joined body', async () => {
+    const store = new InMemoryMessageStore();
+    const chathistoryCaps = new Set<string>([
+      'batch',
+      'draft/multiline',
+      'draft/chathistory',
+      'server-time',
+      'message-tags',
+    ]);
+    const { actor, runtime, conn } = makeActor({ messages: store });
+    conn.caps = chathistoryCaps;
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line one\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('CHATHISTORY LATEST #foo * 1\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    const lines = sends[0]?.args[1] as RawLine[];
+    const replayLine = lines.find((l) => l.text.includes('PRIVMSG #foo'));
+    expect(replayLine?.text).toContain('+draft/multiline');
+    expect(replayLine?.text).toContain('line one\nline two');
+  });
+
+  it('records the joined nick-target batch into the MessageStore', async () => {
+    const store = new InMemoryMessageStore();
+    const { actor, runtime, conn } = makeActor({ messages: store });
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    const bobConn = createConnection({ id: 'c2', connectedSince: 0 });
+    bobConn.nick = 'bob';
+    bobConn.user = 'bob';
+    bobConn.host = 'bob.example';
+    bobConn.registration = 'registered';
+    bobConn.caps = new Set<string>(['batch', 'draft/multiline']);
+    runtime.addConnection(bobConn);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :bob\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :pm one\r\n');
+    await actor.receiveTextFrame('PRIVMSG bob :pm two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    const recorded = store.query({ chan: 'bob', direction: 'latest', limit: 10 });
+    expect(recorded).toHaveLength(1);
+    expect(recorded[0]?.text).toBe('pm one\npm two');
+  });
+
+  it('does not record when no MessageStore is bound', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    await setupMultilineChannel(runtime, [
+      { conn: 'c1', nick: 'alice', caps: ['batch', 'draft/multiline'] },
+    ]);
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH +m1 draft/multiline :#foo\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line one\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :line two\r\n');
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    // No crash, no store — the delivery still works (broadcast happened).
+    expect(runtime.calls.some((c) => c.method === 'broadcast')).toBe(false);
+    // Cap-split path emits a send to bob via getChannelSnapshot…
+    expect(runtime.calls.some((c) => c.method === 'getChannelSnapshot')).toBe(true);
+  });
+});