serverless-ircd 0.10.0 → 0.11.0

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

@@ -1,6 +1,7 @@
 import {
   type AwayStore,
   CapturingLogger,
+  type CertIdentity,
   type ChanName,
   type ChanSnapshot,
   type ChannelDelta,
@@ -18,12 +19,14 @@ import {
   InMemoryServicesStore,
   LogLevel,
   type Logger,
+  MAX_TAGS,
   type MessageStore,
   type MonitorStore,
   type MtlsIdentityProvider,
   type Nick,
   type NickHistoryStore,
   Numerics,
+  OperFailureStats,
   type RawLine,
   SequentialIdFactory,
   type ServerConfig,
@@ -32,6 +35,7 @@ import {
   type ServicesStore,
   type StoredMessage,
   applyChannelDelta as applyDelta,
+  certIdentityFromSubject,
   createChannel,
   createConnection,
   encodeBase64,
@@ -113,6 +117,9 @@ class FakeRuntime implements IrcRuntime {
   async broadcastWallops(lines: RawLine[], except?: ConnId): Promise<void> {
     this.calls.push({ method: 'broadcastWallops', args: [lines, except] });
   }
+  async broadcastOperNotice(lines: RawLine[], except?: ConnId): Promise<void> {
+    this.calls.push({ method: 'broadcastOperNotice', args: [lines, except] });
+  }
   async disconnect(conn: ConnId, reason?: string): Promise<void> {
     this.calls.push({ method: 'disconnect', args: [conn, reason] });
   }
@@ -226,6 +233,8 @@ function makeActor(opts: {
   monitor?: MonitorStore;
   away?: AwayStore;
   services?: ServicesStore;
+  operFailures?: OperFailureStats;
+  sasl?: ServerConfig['sasl'];
 }): { actor: ConnectionActor; runtime: FakeRuntime; conn: ConnectionState } {
   const clock = opts.clock ?? new FakeClock(1_000);
   const conn = createConnection({ id: 'c1', connectedSince: 0 });
@@ -252,6 +261,7 @@ function makeActor(opts: {
     quitMessage: 'Client Quit',
     ...(opts.floodControl !== undefined ? { floodControl: opts.floodControl } : {}),
     ...(opts.operCreds !== undefined ? { operCreds: opts.operCreds } : {}),
+    ...(opts.sasl !== undefined ? { sasl: opts.sasl } : {}),
   };
   const ids = new SequentialIdFactory();
   type ActorOpts = ConstructorParameters<typeof ConnectionActor>[0];
@@ -303,6 +313,9 @@ function makeActor(opts: {
   if (opts.services !== undefined) {
     finalOpts.services = opts.services;
   }
+  if (opts.operFailures !== undefined) {
+    finalOpts.operFailures = opts.operFailures;
+  }
   const actor = new ConnectionActor(finalOpts);
   return { actor, runtime, conn };
 }
@@ -581,6 +594,27 @@ describe('ConnectionActor — malformed input', () => {
     expect(firstLines[0]?.text).toContain('BOGUS');
   });
 
+  it('emits 421 with the too-many-tags reason for a 16-tag frame and continues', async () => {
+    const logger = new CapturingLogger();
+    const { actor, runtime } = makeActor({ logger });
+    const tags = Array.from({ length: MAX_TAGS + 1 }, (_, i) => `t${i}`);
+    await actor.receiveTextFrame(`@${tags.join(';')} PRIVMSG #foo :hi\r\nPING :tok\r\n`);
+
+    // Parse-error log carries the stable reason code, never the raw line
+    // (the tag section is attacker-controlled payload).
+    const errs = logger.records.filter((r) => r.msg === 'frame.parse-error');
+    expect(errs).toHaveLength(1);
+    expect(errs[0]?.fields?.reason).toBe('too-many-tags');
+    expect(JSON.stringify(errs[0])).not.toContain('PRIVMSG');
+    // Connection continues: 421 for the offending frame, PONG for the next.
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(2);
+    const firstLines = sends[0]?.args[1] as RawLine[];
+    expect(firstLines[0]?.text).toContain('421');
+    const secondLines = sends[1]?.args[1] as RawLine[];
+    expect(secondLines[0]?.text).toBe('PONG :tok');
+  });
+
   it('does not crash when the frame is an empty string', async () => {
     const { actor, runtime } = makeActor({});
     await expect(actor.receiveTextFrame('')).resolves.toBeUndefined();
@@ -643,6 +677,147 @@ describe('ConnectionActor — routing', () => {
   });
 });
 
+describe('ConnectionActor — maxTargetsPerCommand cap on multi-target commands', () => {
+  // makeActor() configures serverConfig.maxTargetsPerCommand = 10.
+  const CAP = 10;
+  const OVER = 27;
+
+  /** Builds a comma-separated target list of `count` `<prefix><NN>` names. */
+  function csv(count: number, prefix: string): string {
+    return Array.from(
+      { length: count },
+      (_, i) => `${prefix}${String(i + 1).padStart(2, '0')}`,
+    ).join(',');
+  }
+
+  /** Same list, space-separated (USERHOST/ISON take separate params). */
+  function spaced(count: number, prefix: string): string {
+    return csv(count, prefix).split(',').join(' ');
+  }
+
+  /** Collects the `send` payloads whose lines carry the 407 numeric. */
+  function tooManyTargetSends(runtime: FakeRuntime): RawLine[][] {
+    return runtime.calls
+      .filter(
+        (c) =>
+          c.method === 'send' && (c.args[1] as RawLine[]).some((l) => l.text.includes(' 407 ')),
+      )
+      .map((c) => c.args[1] as RawLine[]);
+  }
+
+  it('caps multi-target PRIVMSG at maxTargetsPerCommand and 407s the dropped targets', async () => {
+    // Flood control disabled: the default token bucket would otherwise
+    // silently drop per-target reducer calls past its capacity, masking
+    // the target cap under test.
+    const { actor, runtime } = makeActor({ floodControl: null });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame(`PRIVMSG ${csv(OVER, 'n')} :hi\r\n`);
+
+    // Only the first CAP targets fan out.
+    const sendsToNick = runtime.calls.filter((c) => c.method === 'sendToNick');
+    expect(sendsToNick).toHaveLength(CAP);
+    expect(sendsToNick[0]?.args[0]).toBe('n01');
+    expect(sendsToNick[CAP - 1]?.args[0]).toBe('n10');
+
+    // Each dropped target gets a dedicated 407 ERR_TOOMANYTARGETS line.
+    const drops = tooManyTargetSends(runtime);
+    expect(drops).toHaveLength(OVER - CAP);
+    expect(drops[0]?.[0]?.text).toContain(' 407 alice n11 ');
+    expect(drops[0]?.[0]?.text).toContain(':Too many targets');
+    expect(drops[OVER - CAP - 1]?.[0]?.text).toContain('n27');
+  });
+
+  it('multi-target PRIVMSG below the cap is unaffected (no 407)', async () => {
+    const { actor, runtime } = makeActor({ floodControl: null });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('PRIVMSG a,b,c :hi\r\n');
+
+    expect(runtime.calls.filter((c) => c.method === 'sendToNick')).toHaveLength(3);
+    expect(tooManyTargetSends(runtime)).toHaveLength(0);
+  });
+
+  it('caps multi-target NOTICE at maxTargetsPerCommand and 407s the dropped targets', async () => {
+    const { actor, runtime } = makeActor({ floodControl: null });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame(`NOTICE ${csv(OVER, 'n')} :hi\r\n`);
+
+    expect(runtime.calls.filter((c) => c.method === 'sendToNick')).toHaveLength(CAP);
+    const drops = tooManyTargetSends(runtime);
+    expect(drops).toHaveLength(OVER - CAP);
+    expect(drops[0]?.[0]?.text).toContain(' 407 alice n11 ');
+  });
+
+  it('caps multi-target TAGMSG at maxTargetsPerCommand and 407s the dropped targets', async () => {
+    const { actor, runtime } = makeActor({
+      floodControl: null,
+      conn: { caps: new Set<string>(['message-tags']) },
+    });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame(`@+typing=active TAGMSG ${csv(OVER, 'n')}\r\n`);
+
+    expect(runtime.calls.filter((c) => c.method === 'sendToNick')).toHaveLength(CAP);
+    expect(tooManyTargetSends(runtime)).toHaveLength(OVER - CAP);
+  });
+
+  it('caps multi-channel PART at maxTargetsPerCommand and 407s the dropped channels', async () => {
+    const { actor, runtime } = makeActor({ floodControl: null });
+    for (let i = 1; i <= OVER; i++) {
+      const name = `#c${String(i).padStart(2, '0')}` as ChanName;
+      await runtime.applyChannelDelta(name, {
+        memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+      });
+    }
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame(`PART ${csv(OVER, '#c')} :bye\r\n`);
+
+    // Only the first CAP parts apply.
+    const parts = runtime.calls.filter((c) => c.method === 'applyChannelDelta');
+    expect(parts).toHaveLength(CAP);
+    const drops = tooManyTargetSends(runtime);
+    expect(drops).toHaveLength(OVER - CAP);
+    expect(drops[0]?.[0]?.text).toContain(' 407 alice #c11 ');
+  });
+
+  it('407s dropped targets with the * placeholder when the connection has no nick yet', async () => {
+    const { actor, runtime, conn } = makeActor({ floodControl: null });
+    conn.registration = 'pre-registration';
+    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes
+    delete conn.nick;
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame(`NOTICE ${csv(OVER, 'n')} :hi\r\n`);
+
+    const drops = tooManyTargetSends(runtime);
+    expect(drops).toHaveLength(OVER - CAP);
+    expect(drops[0]?.[0]?.text).toContain(' 407 * n11 ');
+  });
+
+  it('USERHOST still resolves at most maxTargetsPerCommand nicks (regression guard)', async () => {
+    const { actor, runtime } = makeActor({ floodControl: null });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame(`USERHOST ${spaced(OVER, 'n')}\r\n`);
+
+    expect(runtime.calls.filter((c) => c.method === 'lookupNick')).toHaveLength(CAP);
+    expect(tooManyTargetSends(runtime)).toHaveLength(0);
+  });
+
+  it('ISON still resolves at most maxTargetsPerCommand nicks (regression guard)', async () => {
+    const { actor, runtime } = makeActor({ floodControl: null });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame(`ISON ${spaced(OVER, 'n')}\r\n`);
+
+    expect(runtime.calls.filter((c) => c.method === 'lookupNick')).toHaveLength(CAP);
+    expect(tooManyTargetSends(runtime)).toHaveLength(0);
+  });
+});
+
 describe('ConnectionActor — secure transport (user mode `S`)', () => {
   it('marks the connection state secure when constructed with secure: true', () => {
     const { conn } = makeActor({ secure: true });
@@ -1276,6 +1451,53 @@ describe('ConnectionActor — additional routing', () => {
     }
   });
 
+  it('rejects pre-registration OPER with 451 ERR_NOTREGISTERED without granting oper', async () => {
+    const { actor, runtime, conn } = makeActor({
+      conn: { registration: 'pre-registration' },
+      operCreds: [{ user: 'alice', password: 'secret' }],
+    });
+    // Strip the registration handshake fields: a genuine pre-registration
+    // client has no nick/user yet. Object.assign is the exactOptionalPropertyTypes
+    // escape hatch (a `nick: undefined` literal or `delete` is rejected).
+    Object.assign(conn, { nick: undefined, user: undefined });
+    runtime.calls.length = 0;
+
+    // Valid credentials: without the gate the reducer would grant oper here.
+    await actor.receiveTextFrame('OPER alice secret\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(1);
+    const lines = sends[0]?.args[1] as RawLine[];
+    expect(lines[0]?.text).toBe(':irc.example.com 451 * :You have not registered');
+    expect(conn.userModes.oper).toBe(false);
+  });
+
+  it('grants oper with 381 once the same connection completes registration after a gated attempt', async () => {
+    const { actor, runtime, conn } = makeActor({
+      conn: { registration: 'pre-registration' },
+      operCreds: [{ user: 'alice', password: 'secret' }],
+    });
+    Object.assign(conn, { nick: undefined, user: undefined });
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('OPER alice secret\r\n');
+    expect(conn.userModes.oper).toBe(false);
+
+    // Complete the handshake; the gate must not stick.
+    await actor.receiveTextFrame('NICK alice\r\n');
+    await actor.receiveTextFrame('USER alice 0 * :Alice\r\n');
+    expect(conn.registration).toBe('registered');
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('OPER alice secret\r\n');
+
+    const sends = runtime.calls.filter((c) => c.method === 'send');
+    expect(sends).toHaveLength(2);
+    const firstLines = sends[0]?.args[1] as RawLine[];
+    expect(firstLines[0]?.text).toBe(':irc.example.com 381 alice :You are now an IRC operator');
+    expect(conn.userModes.oper).toBe(true);
+  });
+
   it('emits 421 with empty command when routeSingleChannel gets no channel (TOPIC)', async () => {
     const { actor, runtime } = makeActor({});
     await actor.receiveTextFrame('TOPIC\r\n');
@@ -1379,6 +1601,56 @@ describe('ConnectionActor — additional routing', () => {
     }
   });
 
+  it('threads the shared per-IP OPER failure tracker: 3 failures then 491 + broadcastOperNotice', async () => {
+    const clock = new FakeClock(1_000);
+    const tracker = new OperFailureStats(clock);
+    const { actor, runtime } = makeActor({
+      clock,
+      operCreds: [{ user: 'alice', password: 'secret' }],
+      operFailures: tracker,
+    });
+
+    for (let i = 0; i < 3; i++) {
+      runtime.calls.length = 0;
+      await actor.receiveTextFrame(`OPER alice :wrong-${i}\r\n`);
+      const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+      expect(sends).toHaveLength(1);
+      expect((sends[0]?.args[1] as RawLine[])[0]?.text).toContain(' 464 ');
+      // No oper notice until the lockout actually trips.
+      expect(runtime.calls.some((c) => c.method === 'broadcastOperNotice')).toBe(false);
+    }
+
+    runtime.calls.length = 0;
+    await actor.receiveTextFrame('OPER alice :secret\r\n');
+
+    // Locked out: 491 to the connection (never 464 — the credential store
+    // was not consulted) and one oper-notice fanout to every +o connection.
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    expect(sends).toHaveLength(1);
+    expect((sends[0]?.args[1] as RawLine[])[0]?.text).toBe(
+      ':irc.example.com 491 alice :No O-lines for your host',
+    );
+    const notices = runtime.calls.filter((c) => c.method === 'broadcastOperNotice');
+    expect(notices).toHaveLength(1);
+    const lines = notices[0]?.args[0] as RawLine[];
+    expect(lines[0]?.text).toBe(
+      ':irc.example.com NOTICE * :OPER lockout triggered for example.com',
+    );
+  });
+
+  it('keeps OPER unlocked when no tracker is bound to the actor', async () => {
+    const { actor, runtime } = makeActor({
+      operCreds: [{ user: 'alice', password: 'secret' }],
+    });
+    for (let i = 0; i < 5; i++) {
+      await actor.receiveTextFrame('OPER alice :wrong\r\n');
+    }
+    runtime.calls.length = 0;
+    await actor.receiveTextFrame('OPER alice :secret\r\n');
+    const sends = runtime.calls.filter((c) => c.method === 'send' && c.args[0] === 'c1');
+    expect((sends[0]?.args[1] as RawLine[])[0]?.text).toContain(' 381 ');
+  });
+
   it('routes REHASH from an oper through rehashReducer (382, never 421) and re-invokes the loader', async () => {
     const { actor, runtime, conn } = makeActor({
       conn: {
@@ -1892,7 +2164,7 @@ describe('ConnectionActor — observability', () => {
     }
   });
 
-  it('emits a warn-level frame.parse-error record on a malformed line', async () => {
+  it('emits a warn-level frame.parse-error record with token/length/reason', async () => {
     const logger = new CapturingLogger();
     const { actor } = makeActor({ logger, traceId: 't1' });
 
@@ -1903,7 +2175,53 @@ describe('ConnectionActor — observability', () => {
     expect(errs).toHaveLength(1);
     expect(errs[0]?.level).toBe(LogLevel.Warn);
     expect(errs[0]?.traceId).toBe('t1');
-    expect(typeof errs[0]?.fields?.line).toBe('string');
+    expect(errs[0]?.fields?.token).toBe('12345');
+    expect(errs[0]?.fields?.length).toBe('12345'.length);
+    expect(errs[0]?.fields?.reason).toBe('invalid-command-token');
+  });
+
+  it('never includes the raw line in a frame.parse-error record', async () => {
+    const logger = new CapturingLogger();
+    const { actor } = makeActor({ logger, traceId: 't2' });
+
+    // The 5-digit command trips the parser while the trailing PASS
+    // payload carries a credential: a hostile client can smuggle secret
+    // material into the warn record unless the payload is scrubbed. The
+    // record must carry no `line` field and no trace of the secret.
+    await actor.receiveTextFrame('12345 PASS hunter2\r\n');
+
+    const errs = logger.records.filter((r) => r.msg === 'frame.parse-error');
+    expect(errs).toHaveLength(1);
+    expect(errs[0]?.fields?.line).toBeUndefined();
+    expect(JSON.stringify(errs[0])).not.toContain('hunter2');
+  });
+
+  it('truncates an over-long leading token in a parse-error record', async () => {
+    const logger = new CapturingLogger();
+    const { actor } = makeActor({ logger, traceId: 't3' });
+
+    // 32 letters + a digit is an illegal command token (mixed) AND the
+    // 33-char token exceeds the 32-char log cap.
+    await actor.receiveTextFrame(`${'X'.repeat(32)}9 PASS hunter2\r\n`);
+
+    const errs = logger.records.filter((r) => r.msg === 'frame.parse-error');
+    expect(errs).toHaveLength(1);
+    expect(errs[0]?.fields?.token).toBe(`${'X'.repeat(32)}...`);
+    expect(JSON.stringify(errs[0])).not.toContain('hunter2');
+  });
+
+  it('reports the input-cap reason for an over-long line', async () => {
+    const logger = new CapturingLogger();
+    const { actor } = makeActor({ logger, traceId: 't4' });
+
+    // 600 bytes exceeds the 512-byte input cap → the byte-cap branch of
+    // the parser fires before the command-token check.
+    await actor.receiveTextFrame(`${'A'.repeat(600)}\r\n`);
+
+    const errs = logger.records.filter((r) => r.msg === 'frame.parse-error');
+    expect(errs).toHaveLength(1);
+    expect(errs[0]?.fields?.reason).toBe('input-cap-exceeded');
+    expect(errs[0]?.fields?.length).toBe(600);
   });
 
   it('falls back to a NoopLogger and unknown traceId when omitted', async () => {
@@ -2204,10 +2522,10 @@ describe('ConnectionActor — SASL ServicesStore plumbing', () => {
 });
 
 describe('ConnectionActor — SASL EXTERNAL + mTLS plumbing', () => {
-  /** Fake MtlsIdentityProvider returning a canned subject for 'c1'. */
+  /** Fake MtlsIdentityProvider returning a canned cert identity for 'c1'. */
   class FakeMtlsProvider implements MtlsIdentityProvider {
-    constructor(private readonly identity: string | undefined) {}
-    getIdentity(connId: string): string | undefined {
+    constructor(private readonly identity: CertIdentity | undefined) {}
+    getIdentity(connId: string): CertIdentity | undefined {
       return connId === 'c1' ? this.identity : undefined;
     }
   }
@@ -2220,15 +2538,19 @@ describe('ConnectionActor — SASL EXTERNAL + mTLS plumbing', () => {
     };
   }
 
-  it('completes SASL EXTERNAL with 900/903 when mTLS provider and store accept', async () => {
+  it('completes SASL EXTERNAL with 900/903 when mTLS provider, operator opt-in, secure transport, and store accept', async () => {
     const services = new InMemoryServicesStore({ clock: new FakeClock(0) });
     services.registerNick('alice', 'secret', 'alice@example.com');
     services.addCertFP('alice', 'CN=alice');
-    const mtlsIdentity = new FakeMtlsProvider('CN=alice');
+    const mtlsIdentity = new FakeMtlsProvider(certIdentityFromSubject('CN=alice'));
     const { actor, runtime, conn } = makeActor({
       conn: saslReadyConn(),
       services,
       mtlsIdentity,
+      // The EXTERNAL triple gate: mTLS provider bound (above) +
+      // operator opt-in + a secure (TLS) connection.
+      sasl: { externalEnabled: true },
+      secure: true,
     });
     conn.nick = 'alice';
     runtime.calls.length = 0;
@@ -2264,6 +2586,31 @@ describe('ConnectionActor — SASL EXTERNAL + mTLS plumbing', () => {
     expect(lines.some((l) => l.text.includes(' 904 '))).toBe(false);
     expect(conn.account).toBeUndefined();
   });
+
+  it('answers 908 when the operator opt-in is missing even with mTLS and a secure connection', async () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(0) });
+    services.registerNick('alice', 'secret', 'alice@example.com');
+    services.addCertFP('alice', 'CN=alice');
+    const mtlsIdentity = new FakeMtlsProvider(certIdentityFromSubject('CN=alice'));
+    // mTLS provider bound + secure connection, but sasl.externalEnabled
+    // left at the default (off) → EXTERNAL is refused with 908.
+    const { actor, runtime, conn } = makeActor({
+      conn: saslReadyConn(),
+      services,
+      mtlsIdentity,
+      secure: true,
+    });
+    conn.nick = 'alice';
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('AUTHENTICATE EXTERNAL\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(' 908 '))).toBe(true);
+    expect(lines.some((l) => l.text.includes(' 904 '))).toBe(false);
+    expect(conn.account).toBeUndefined();
+  });
 });
 
 describe('ConnectionActor — server-info commands (VERSION/TIME/ADMIN/INFO/USERHOST/ISON)', () => {
@@ -3971,6 +4318,196 @@ describe('ConnectionActor — draft/multiline BATCH', () => {
     ).accumulateMultilineLine({ command: 'PRIVMSG', params: ['#foo', 'hi'] });
     expect(result).toEqual([]);
   });
+
+  it('aborts the batch mid-stream when an inner line pushes it over the byte budget (no close needed)', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline', 'standard-replies']);
+    // Tiny budget: 6 bytes + separator + 6 bytes = 13 > 10 on the second push.
+    (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 :aaaaaa\r\n');
+    // No `BATCH -m1` close — the over-budget push itself must abort the batch.
+    await actor.receiveTextFrame('PRIVMSG #foo :bbbbbb\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    // A synthesized `BATCH -m1` closes the aborted batch client-side...
+    expect(aliceLines.some((l) => l.text === 'BATCH -m1')).toBe(true);
+    // ...followed by the FAIL rejection.
+    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);
+    // Nothing was relayed to the channel.
+    expect(runtime.calls.some((c) => c.method === 'broadcast')).toBe(false);
+    // The accumulator is gone: a late `BATCH -m1` close hits the unknown-id 421 path.
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+    expect(sentTo(runtime, 'c1').some((l) => l.text.includes(' 421 '))).toBe(true);
+  });
+
+  it('accepts an inner line that lands exactly at the byte budget (boundary is inclusive)', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    // Budget 13: 6 bytes + separator + 6 bytes = 13 → accepted.
+    (actor as unknown as { serverConfig: ServerConfig }).serverConfig = {
+      ...(actor as unknown as { serverConfig: ServerConfig }).serverConfig,
+      multilineMaxBytes: 13,
+    };
+    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 :aaaaaa\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :cccccc\r\n');
+    expect(sentTo(runtime, 'c1').some((l) => l.text.includes('FAIL BATCH'))).toBe(false);
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    // The at-budget batch finalizes normally: bob gets the joined PRIVMSG.
+    const bobLines = sentTo(runtime, 'c2');
+    expect(
+      bobLines.some((l) => l.text === ':alice!alice@example.com PRIVMSG #foo :aaaaaa\ncccccc'),
+    ).toBe(true);
+  });
+
+  it('rejects the 101st inner line by entry count even when under the byte budget', 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');
+    // 100 single-byte entries: joined bytes 199 < 4096, all accepted.
+    await actor.receiveTextFrame('PRIVMSG #foo :x\r\n'.repeat(100));
+    expect(sentTo(runtime, 'c1').some((l) => l.text.includes('FAIL BATCH'))).toBe(false);
+
+    // The 101st push trips the defense-in-depth entry cap.
+    await actor.receiveTextFrame('PRIVMSG #foo :x\r\n');
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text === 'BATCH -m1')).toBe(true);
+    expect(
+      aliceLines.some(
+        (l) =>
+          l.text ===
+          ':irc.example.com FAIL BATCH MULTILINE_MAX_LINES #foo :Multi-line batch exceeds the 100 line limit',
+      ),
+    ).toBe(true);
+
+    // The accumulator is gone: a normal PRIVMSG now delivers instead of
+    // accumulating into the aborted batch.
+    runtime.calls.length = 0;
+    await actor.receiveTextFrame('PRIVMSG #foo :plain\r\n');
+    expect(
+      sentTo(runtime, 'c2').some((l) => l.text === ':alice!alice@example.com PRIVMSG #foo :plain'),
+    ).toBe(true);
+  });
+
+  it('honours a configured multilineMaxEntries override', 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,
+      multilineMaxEntries: 2,
+    };
+    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 :one\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :two\r\n');
+    await actor.receiveTextFrame('PRIVMSG #foo :three\r\n');
+
+    const aliceLines = sentTo(runtime, 'c1');
+    expect(aliceLines.some((l) => l.text === 'BATCH -m1')).toBe(true);
+    expect(
+      aliceLines.some(
+        (l) =>
+          l.text ===
+          ':irc.example.com FAIL BATCH MULTILINE_MAX_LINES #foo :Multi-line batch exceeds the 2 line limit',
+      ),
+    ).toBe(true);
+  });
+
+  it('clears an abandoned open batch on connection teardown (dispose)', 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 :partial\r\n');
+    expect((actor as unknown as { openMultilineBatch?: unknown }).openMultilineBatch).toBeDefined();
+
+    actor.dispose();
+
+    expect(
+      (actor as unknown as { openMultilineBatch?: unknown }).openMultilineBatch,
+    ).toBeUndefined();
+    // Post-teardown traffic delivers normally — nothing leaks into a stale batch.
+    await actor.receiveTextFrame('PRIVMSG #foo :after\r\n');
+    expect(
+      sentTo(runtime, 'c2').some((l) => l.text === ':alice!alice@example.com PRIVMSG #foo :after'),
+    ).toBe(true);
+  });
+
+  it('dispose() is a safe no-op when no batch is open', () => {
+    const { actor } = makeActor({});
+    expect(() => actor.dispose()).not.toThrow();
+    expect(
+      (actor as unknown as { openMultilineBatch?: unknown }).openMultilineBatch,
+    ).toBeUndefined();
+  });
+
+  it('nick-target close still rejects an over-budget batch (close-time guard survives the incremental check)', async () => {
+    const { actor, runtime, conn } = makeActor({});
+    conn.caps = new Set<string>(['batch', 'draft/multiline']);
+    (actor as unknown as { serverConfig: ServerConfig }).serverConfig = {
+      ...(actor as unknown as { serverConfig: ServerConfig }).serverConfig,
+      multilineMaxBytes: 5,
+    };
+    // The incremental accumulator aborts over-budget pushes before close, so
+    // the close-time guard only fires when the budget shrinks under an open
+    // batch (e.g. a REHASH between BATCH +id and BATCH -id). Inject the
+    // over-budget batch directly and close it through the real route.
+    (actor as unknown as { openMultilineBatch: unknown }).openMultilineBatch = {
+      id: 'm1',
+      target: 'bob',
+      command: 'PRIVMSG',
+      entries: [{ text: 'aaaaaaaaaa' }],
+    };
+    runtime.calls.length = 0;
+
+    await actor.receiveTextFrame('BATCH -m1\r\n');
+
+    expect(
+      sentTo(runtime, 'c1').some(
+        (l) =>
+          l.text ===
+          ':irc.example.com FAIL BATCH MULTILINE_MAX_BYTES bob :Multi-line batch exceeds the 5 byte limit',
+      ),
+    ).toBe(true);
+  });
 });
 
 // ---------------------------------------------------------------------------