mixdog 0.9.51 → 0.9.52

package/src/standalone/channel-daemon-client.mjs

@@ -6,6 +6,7 @@
 // worker->parent notify path arrives on a persistent SSE stream (GET /events),
 // replacing the old node-IPC `{type:'notify'}` messages.
 import http from 'node:http';
+import { randomUUID } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 
 function parsePid(value) {
@@ -41,7 +42,29 @@ export function readDaemonDiscovery(discoveryPath) {
 function request({ port, method = 'GET', path = '/', token, body = null, timeoutMs = 10_000 }) {
   return new Promise((resolve, reject) => {
     const payload = body == null ? null : JSON.stringify(body);
-    const req = http.request({
+    let req = null;
+    let response = null;
+    let ended = false;
+    let settled = false;
+    const finish = (fn, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(deadline);
+      fn(value);
+    };
+    const fail = (error) => finish(reject, error instanceof Error ? error : new Error(String(error)));
+    const lifecycleTimeout = () => {
+      const error = new Error(`daemon request timed out: ${method} ${path}`);
+      fail(error);
+      try { response?.destroy?.(error); } catch {}
+      try { req?.destroy?.(error); } catch {}
+    };
+    // http.request's timeout is socket-idle only. This deadline covers headers
+    // and the entire response body so a truncated post-header response cannot
+    // leave reconnect registration pending forever.
+    const deadline = setTimeout(lifecycleTimeout, timeoutMs);
+    deadline.unref?.();
+    req = http.request({
       hostname: '127.0.0.1',
       port,
       path,
@@ -54,23 +77,31 @@ function request({ port, method = 'GET', path = '/', token, body = null, timeout
       },
       timeout: timeoutMs,
     }, (res) => {
+      response = res;
+      if (settled) { try { res.resume?.(); } catch {} return; }
       let data = '';
       res.setEncoding('utf8');
-      res.on('data', (chunk) => { data += chunk; });
-      res.on('end', () => {
+      res.on('data', (chunk) => { if (!settled) data += chunk; });
+      res.once('aborted', () => fail(new Error(`daemon response aborted: ${method} ${path}`)));
+      res.once('error', (error) => fail(error));
+      res.once('end', () => {
+        ended = true;
         let parsed = null;
         try { parsed = data ? JSON.parse(data) : null; } catch {}
         if (res.statusCode && res.statusCode >= 400) {
           const err = new Error(parsed?.error || data || `HTTP ${res.statusCode}`);
           err.statusCode = res.statusCode;
-          reject(err);
+          fail(err);
           return;
         }
-        resolve(parsed ?? {});
+        finish(resolve, parsed ?? {});
+      });
+      res.once('close', () => {
+        if (!ended && !settled) fail(new Error(`daemon response closed before end: ${method} ${path}`));
       });
     });
-    req.on('error', reject);
-    req.on('timeout', () => { req.destroy(); reject(new Error(`daemon request timed out: ${method} ${path}`)); });
+    req.on('error', fail);
+    req.on('timeout', lifecycleTimeout);
     if (payload) req.write(payload);
     req.end();
   });
@@ -96,29 +127,104 @@ export async function attachToDaemon({
   log = () => {},
   onFatal = () => {},
 } = {}) {
-  if (!discovery?.port || !discovery?.token) throw new Error('daemon discovery {port, token} required');
+  const expectedPid = parsePid(discovery?.pid);
+  if (!discovery?.port || !discovery?.token || !expectedPid) throw new Error('daemon discovery {port, pid, token} required');
   const { port, token: serverToken } = discovery;
+  const staleDiscoveryError = (reason) => {
+    const err = new Error(reason);
+    err.daemonDiscoveryStale = true;
+    return err;
+  };
+  const isExpectedDaemon = (health) => Number(health?.pid) === expectedPid;
 
-  const reg = await request({
-    port,
-    token: serverToken,
-    method: 'POST',
-    path: '/client/register',
-    body: { leadPid, cwd },
-    timeoutMs: 3000,
-  });
+  const initialHealth = await probeDaemonHealth({ port, token: serverToken, timeoutMs: 800 });
+  if (!isExpectedDaemon(initialHealth)) throw staleDiscoveryError('daemon discovery pid does not match health');
+
+  let reg;
+  try {
+    reg = await request({
+      port,
+      token: serverToken,
+      method: 'POST',
+      path: '/client/register',
+      body: { leadPid, cwd },
+      timeoutMs: 3000,
+    });
+  } catch (err) {
+    if (err?.statusCode === 401 || err?.statusCode === 403) {
+      const stale = staleDiscoveryError(`daemon register rejected (${err.statusCode})`);
+      stale.daemonAuthRejected = true;
+      throw stale;
+    }
+    throw err;
+  }
   let clientToken = reg?.token;
   if (!clientToken) throw new Error('daemon register returned no client token');
 
   let sseReq = null;
   let closed = false;
+  let fatal = false;
   let reconnectTimer = null;
-  // Bounded SSE reconnect: after repeated failures (daemon dead/restarted) give
-  // up and signal the owner via onFatal so it can invalidate the cached attach
-  // and re-attach fresh (re-read discovery, respawn-if-dead) rather than spin
-  // forever against a dead port.
+  let reconnectProbe = false;
+  let reconnectRegistration = null;
+  let reconnectRegistrationId = null;
+  let reconnectReplaceToken = null;
+  let lifecycle = 0;
+  let stableTimer = null;
+  let closePromise = null;
+  // Bounded reconnect is only for a verified-live daemon's transient SSE loss.
+  // A stale/dead endpoint signals onFatal immediately so the owner re-reads
+  // discovery instead of spinning against the captured port.
   let reconnectAttempts = 0;
   const MAX_RECONNECTS = 5;
+  const STABLE_STREAM_MS = 5_000;
+
+  async function deregister(token, { registrationId = null, replaceToken = null } = {}) {
+    if (!token) return;
+    try {
+      await request({
+        port, token: serverToken, method: 'POST', path: '/client/deregister',
+        body: {
+          token,
+          ...(registrationId ? { registrationId, replaceToken, leadPid, cwd } : {}),
+        },
+        timeoutMs: 1500,
+      });
+    } catch { /* best-effort; daemon sweep reaps us */ }
+  }
+
+  function clearStableTimer() {
+    if (stableTimer) { try { clearTimeout(stableTimer); } catch {} stableTimer = null; }
+  }
+
+  function signalFatal(reason) {
+    if (closed || fatal) return;
+    fatal = true;
+    closed = true;
+    lifecycle++;
+    if (reconnectTimer) { try { clearTimeout(reconnectTimer); } catch {} reconnectTimer = null; }
+    clearStableTimer();
+    try { sseReq?.destroy?.(); } catch {}
+    log(`sse stale endpoint (${reason}); signalling re-attach`);
+    try { onFatal(reason); } catch {}
+  }
+
+  // A stream ending can be a transient connection loss, but must not leave this
+  // client retrying a dead discovery endpoint. Verify that the original daemon
+  // is still alive before spending the bounded reconnect budget on it.
+  function handleStreamLoss(reason) {
+    if (closed || fatal || reconnectTimer || reconnectProbe) return;
+    reconnectProbe = true;
+    void probeDaemonHealth({ port, token: serverToken, timeoutMs: 800 }).then((health) => {
+      reconnectProbe = false;
+      if (closed || fatal) return;
+      if (!isExpectedDaemon(health)) {
+        signalFatal(reason);
+        return;
+      }
+      scheduleReconnect(reason);
+    });
+  }
 
   function openStream() {
     if (closed) return;
@@ -129,15 +235,29 @@ export async function attachToDaemon({
       method: 'GET',
       headers: { Accept: 'text/event-stream', 'X-Mixdog-Daemon-Token': serverToken },
     }, (res) => {
+      if (req !== sseReq || closed) { res.resume(); return; }
       if (res.statusCode !== 200) {
         res.resume();
-        scheduleReconnect('bad sse status ' + res.statusCode);
+        // A token rejection means this port now belongs to a different daemon;
+        // re-read discovery now rather than re-registering against it.
+        if (res.statusCode === 401 || res.statusCode === 403) {
+          signalFatal('bad sse status ' + res.statusCode);
+        } else {
+          handleStreamLoss('bad sse status ' + res.statusCode);
+        }
         return;
       }
       res.setEncoding('utf8');
-      reconnectAttempts = 0; // a live stream resets the failure budget
+      // A bare 200 followed by an immediate end is not a stable stream. Only
+      // reset the bounded reconnect budget after this exact stream stays live.
+      clearStableTimer();
+      stableTimer = setTimeout(() => {
+        if (!closed && !fatal && req === sseReq) reconnectAttempts = 0;
+      }, STABLE_STREAM_MS);
+      stableTimer.unref?.();
       let buf = '';
       res.on('data', (chunk) => {
+        if (req !== sseReq || closed) return;
         buf += chunk;
         let idx;
         while ((idx = buf.indexOf('\n\n')) >= 0) {
@@ -153,35 +273,67 @@ export async function attachToDaemon({
           }
         }
       });
-      res.on('end', () => scheduleReconnect('sse ended'));
-      res.on('error', () => scheduleReconnect('sse error'));
+      res.on('end', () => {
+        if (req === sseReq) {
+          clearStableTimer();
+          handleStreamLoss('sse ended');
+        }
+      });
+      res.on('error', () => {
+        if (req === sseReq) {
+          clearStableTimer();
+          handleStreamLoss('sse error');
+        }
+      });
+    });
+    req.on('error', () => {
+      if (req === sseReq) signalFatal('sse req error');
     });
-    req.on('error', () => scheduleReconnect('sse req error'));
-    req.end();
     sseReq = req;
+    req.end();
   }
 
   function scheduleReconnect(reason) {
     if (closed || reconnectTimer) return;
     if (++reconnectAttempts > MAX_RECONNECTS) {
-      log(`sse giving up after ${reconnectAttempts} attempts (${reason}); signalling re-attach`);
-      closed = true;
-      try { sseReq?.destroy?.(); } catch {}
-      try { onFatal(reason); } catch {}
+      signalFatal(`giving up after ${reconnectAttempts} attempts (${reason})`);
       return;
     }
     log(`sse reconnect scheduled (${reason}, attempt ${reconnectAttempts})`);
     reconnectTimer = setTimeout(() => {
       reconnectTimer = null;
+      if (closed || fatal) return;
       // Re-register (the daemon may have pruned us) then reopen the stream.
       // Re-register mints a fresh client token (the old one was pruned); adopt
       // it so the reopened stream and subsequent calls target the live entry.
       // reattach:true — a reconnect is NOT a new terminal, so it must NOT steal
       // the ownership seat (last-wins is reserved for genuine fresh registers).
-      request({ port, token: serverToken, method: 'POST', path: '/client/register', body: { leadPid, cwd, reattach: true }, timeoutMs: 3000 })
-        .then((r) => { if (r?.token) clientToken = r.token; })
-        .catch(() => {})
-        .finally(() => openStream());
+      const generation = lifecycle;
+      const registrationId = reconnectRegistrationId ||= randomUUID();
+      const replaceToken = reconnectReplaceToken ||= clientToken;
+      const registration = request({
+        port, token: serverToken, method: 'POST', path: '/client/register',
+        body: {
+          leadPid, cwd, reattach: true, replaceToken,
+          registrationId,
+        }, timeoutMs: 3000,
+      }).then(async (r) => {
+        const freshToken = r?.token;
+        if (!freshToken) return false;
+        if (closed || fatal || generation !== lifecycle) {
+          await deregister(freshToken);
+          return false;
+        }
+        clientToken = freshToken;
+        reconnectRegistrationId = null;
+        reconnectReplaceToken = null;
+        return true;
+      }).catch(() => false);
+      reconnectRegistration = registration;
+      void registration.finally(() => {
+        if (reconnectRegistration === registration) reconnectRegistration = null;
+        if (!closed && !fatal && generation === lifecycle) openStream();
+      });
     }, 1000);
     reconnectTimer.unref?.();
   }
@@ -213,13 +365,23 @@ export async function attachToDaemon({
   }
 
   async function close(reason = 'client close') {
+    if (closePromise) return closePromise;
     closed = true;
+    lifecycle++;
     if (reconnectTimer) { try { clearTimeout(reconnectTimer); } catch {} reconnectTimer = null; }
+    clearStableTimer();
     try { sseReq?.destroy?.(); } catch {}
-    try {
-      await request({ port, token: serverToken, method: 'POST', path: '/client/deregister', body: { token: clientToken }, timeoutMs: 1500 });
-    } catch { /* best-effort; daemon sweep reaps us */ }
-    log(`detached (${reason})`);
+    // A re-register already in flight can mint a fresh token after close().
+    // Await it so its stale branch deregisters that token before close resolves.
+    const pendingRegistration = reconnectRegistration;
+    const registrationId = reconnectRegistrationId;
+    const replaceToken = reconnectReplaceToken;
+    closePromise = (async () => {
+      if (pendingRegistration) await pendingRegistration;
+      await deregister(clientToken, { registrationId, replaceToken });
+      log(`detached (${reason})`);
+    })();
+    return closePromise;
   }
 
   return { call, close, clientToken, port };

package/src/standalone/channel-daemon-transport.mjs

@@ -46,6 +46,7 @@ export function createChannelDaemonTransport({
   onClientsEmpty = null,
   getStatus = () => ({}),
   dispatchBind = null,
+  registrationReplayTtlMs = 60_000,
 } = {}) {
   if (typeof handleCall !== 'function') throw new Error('handleCall is required');
 
@@ -72,6 +73,11 @@ export function createChannelDaemonTransport({
   // retry never double-runs a non-idempotent tool (e.g. reply). Short TTL.
   const callCache = new Map();
   const CALL_CACHE_TTL_MS = 60_000;
+  // Reconnect register replay: a server may commit replacement just before its
+  // HTTP response is lost. The retry supplies this stable id and receives the
+  // already-created fresh token instead of creating an orphan replacement.
+  const registrationReplays = new Map(); // registrationId -> { token, leadPid, cwd, replaceToken, responseFinished }
+  const registrationReplayTtl = Math.max(1, Number(registrationReplayTtlMs) || 60_000);
   let server = null;
   let graceTimer = null;
   let sweepTimer = null;
@@ -103,8 +109,7 @@ export function createChannelDaemonTransport({
     const c = clients.get(token);
     if (!c) return;
     const wasPointer = pointerToken === token;
-    clients.delete(token);
-    try { c.sse?.end?.(); } catch {}
+    removeClientRecord(token);
     if (pointerToken === token) pointerToken = null;
     log(`client ${token} (lead=${c.leadPid}) removed: ${reason}`);
     // Pointer client death → hand the seat to a survivor (last-wins among the
@@ -115,6 +120,62 @@ export function createChannelDaemonTransport({
     maybeArmGrace('client removed');
   }
 
+  function removeRegistrationReplay(registrationId, replay = registrationReplays.get(registrationId)) {
+    if (!replay || registrationReplays.get(registrationId) !== replay) return;
+    registrationReplays.delete(registrationId);
+    try { clearTimeout(replay.timer); } catch {}
+  }
+
+  // Every removal path uses this primitive, including replacement's deliberate
+  // no-failover retirement, so replay records/timers never target absent tokens.
+  function removeClientRecord(token) {
+    const c = clients.get(token);
+    if (!c) return null;
+    clients.delete(token);
+    for (const [registrationId, replay] of registrationReplays) {
+      if (replay.token === token) removeRegistrationReplay(registrationId, replay);
+    }
+    try { c.sse?.end?.(); } catch {}
+    return c;
+  }
+
+  function clearRegistrationReplays() {
+    for (const [registrationId, replay] of registrationReplays) removeRegistrationReplay(registrationId, replay);
+  }
+
+  function armRegistrationReplay(replayId, replay) {
+    try { clearTimeout(replay.timer); } catch {}
+    replay.timer = setTimeout(() => {
+      if (registrationReplays.get(replayId) !== replay) return;
+      // A successfully flushed register response creates a valid client even
+      // if its SSE/call is delayed. TTL only bounds cancellation metadata.
+      removeRegistrationReplay(replayId, replay);
+      if (!replay.responseFinished && clients.has(replay.token)) {
+        dropClient(replay.token, 'unflushed registration replay expired');
+      }
+    }, registrationReplayTtl);
+    replay.timer.unref?.();
+  }
+
+  function markRegistrationResponseFinished(registrationId, token) {
+    const replay = registrationId ? registrationReplays.get(registrationId) : null;
+    if (replay && replay.token === token) replay.responseFinished = true;
+  }
+
+  // A response-loss close knows only its retired token + stable registration id.
+  // Bind cancellation to every logical-client field before retiring the fresh
+  // token; malformed/mismatched cancellation can never affect another client.
+  function cancelReplacementRegistration({ token, registrationId, replaceToken, leadPid, cwd }) {
+    const replayId = registrationId ? String(registrationId).slice(0, 200) : null;
+    const replay = replayId ? registrationReplays.get(replayId) : null;
+    if (!replay) return 'missing';
+    const retiredToken = token ? String(token) : null;
+    if (retiredToken !== replay.replaceToken || String(replaceToken || '') !== replay.replaceToken ||
+        parsePid(leadPid) !== replay.leadPid || (cwd || null) !== replay.cwd) return 'forbidden';
+    dropClient(replay.token, 'replacement deregister');
+    return 'cancelled';
+  }
+
   // Pointer failover on owner death. Move the pointer to the most-recently-seen
   // LIVE client (reason 'failover'), deliver the sticky 'acquired' badge to it
   // (pending-buffered if it has no SSE yet), and re-dispatch ITS stored bind
@@ -304,8 +365,25 @@ export function createChannelDaemonTransport({
     }
   }
 
-  function registerClient({ leadPid, cwd, reattach = false }) {
+  function registerClient({ leadPid, cwd, reattach = false, replaceToken = null, registrationId = null }) {
     const pid = parsePid(leadPid) ?? 0;
+    const replacementToken = replaceToken ? String(replaceToken) : null;
+    const replayId = reattach && registrationId ? String(registrationId).slice(0, 200) : null;
+    const existingReplay = replayId ? registrationReplays.get(replayId) : null;
+    if (existingReplay) {
+      if (existingReplay.leadPid === pid && existingReplay.cwd === (cwd || null) &&
+          existingReplay.replaceToken === replacementToken && clients.has(existingReplay.token)) {
+        armRegistrationReplay(replayId, existingReplay);
+        log(`client reconnect replay token=${existingReplay.token} lead=${pid}`);
+        return existingReplay.token;
+      }
+      if (clients.has(existingReplay.token)) {
+        const err = new Error('registration replay identity mismatch');
+        err.statusCode = 409;
+        throw err;
+      }
+      removeRegistrationReplay(replayId, existingReplay);
+    }
     const token = randomUUID();
     clients.set(token, {
       token,
@@ -320,6 +398,34 @@ export function createChannelDaemonTransport({
     cancelGrace();
     startSweep();
     log(`client registered token=${token} lead=${pid} cwd=${cwd || '-'}`);
+    const rememberReplacement = (freshToken) => {
+      if (!replayId) return freshToken;
+      const replay = {
+        token: freshToken, leadPid: pid, cwd: cwd || null, replaceToken: replacementToken,
+        responseFinished: false, timer: null,
+      };
+      registrationReplays.set(replayId, replay);
+      armRegistrationReplay(replayId, replay);
+      return freshToken;
+    };
+    // A reconnect names the exact token it replaces. Retire it even when it is
+    // not the pointer: retaining a non-owner old token would let it later call,
+    // steal ownership, or accumulate a buffered frame after the fresh client
+    // has gone away. Token replacement never crosses leadPid boundaries.
+    const replaced = reattach && replacementToken ? clients.get(replacementToken) : null;
+    if (replaced && replaced.leadPid === pid) {
+      const fresh = clients.get(token);
+      const replacedWasPointer = pointerToken === replaced.token;
+      // Token-scoped state belongs to the logical client, not only the owner.
+      // A non-owner can hold a buffered superseded frame or stored bind intent.
+      if (replaced.pending?.length) fresh.pending.push(...replaced.pending.splice(0));
+      if (replaced.lastBind) fresh.lastBind = replaced.lastBind;
+      if (replacedWasPointer) pointerToken = token;
+      removeClientRecord(replaced.token);
+      log(`client reconnect replaced token=${replaced.token} -> ${token} lead=${pid}`);
+      if (replacedWasPointer) redispatchPointerBind(fresh, 'reconnect');
+      return rememberReplacement(token);
+    }
     // Pointer-follows-pid: if the current pointer client shares this leadPid AND
     // has no live SSE, it is the SAME terminal re-registering after its stream
     // dropped. That old entry is a dead-stream blackhole — pid-prune never reaps
@@ -335,15 +441,14 @@ export function createChannelDaemonTransport({
         const fresh = clients.get(token);
         if (old.pending?.length) fresh.pending.push(...old.pending.splice(0));
         if (old.lastBind) fresh.lastBind = old.lastBind;
-        clients.delete(pointerToken);
-        try { old.sse?.end?.(); } catch {}
+        removeClientRecord(pointerToken);
         pointerToken = token;
         log(`pointer follows reconnect -> token=${token} lead=${pid} (old entry dropped)`);
         // The fresh token inherited the old entry's bind intent but never went
         // through movePointer — re-dispatch it so the forwarder rebinds to this
         // reconnected terminal's transcript (guarded/no-op when no lastBind).
         redispatchPointerBind(fresh, 'reconnect');
-        return token;
+        return rememberReplacement(token);
       }
     }
     if (reattach) {
@@ -356,12 +461,17 @@ export function createChannelDaemonTransport({
       // ownership seat, and the displaced owner is told it lost (superseded).
       movePointer(token, 'register');
     }
-    return token;
+    return rememberReplacement(token);
   }
 
   function attachSse(token, res) {
     const c = clients.get(token);
     if (!c) return false;
+    // A live stream proves the client learned its fresh token, so response-loss
+    // cancellation is no longer needed for this logical registration.
+    for (const [registrationId, replay] of registrationReplays) {
+      if (replay.token === token) removeRegistrationReplay(registrationId, replay);
+    }
     res.writeHead(200, {
       'Content-Type': 'text/event-stream; charset=utf-8',
       'Cache-Control': 'no-cache, no-transform',
@@ -417,12 +527,23 @@ export function createChannelDaemonTransport({
 
       if (req.method === 'POST' && pathName === '/client/register') {
         const body = await readBody(req);
-        const clientToken = registerClient({ leadPid: body.leadPid, cwd: body.cwd, reattach: body.reattach === true });
+        const clientToken = registerClient({
+          leadPid: body.leadPid, cwd: body.cwd, reattach: body.reattach === true,
+          replaceToken: body.replaceToken, registrationId: body.registrationId,
+        });
+        const replayId = body.reattach === true && body.registrationId ? String(body.registrationId).slice(0, 200) : null;
+        res.once('finish', () => markRegistrationResponseFinished(replayId, clientToken));
         sendJson(res, { token: clientToken, pid: process.pid });
         return;
       }
       if (req.method === 'POST' && pathName === '/client/deregister') {
         const body = await readBody(req);
+        if (body.registrationId) {
+          const cancelled = cancelReplacementRegistration(body);
+          if (cancelled === 'forbidden') { sendError(res, 'forbidden replacement deregister', 403); return; }
+          sendJson(res, { ok: true, cancelled: cancelled === 'cancelled' });
+          return;
+        }
         if (body.token) dropClient(body.token, 'deregister');
         sendJson(res, { ok: true });
         return;
@@ -436,7 +557,11 @@ export function createChannelDaemonTransport({
         const body = await readBody(req);
         const clientToken = body.token || null;
         const c = clientToken ? clients.get(clientToken) : null;
-        if (c) c.lastSeen = nowMs();
+        if (!c) { sendError(res, 'unknown client token', 404); return; }
+        for (const [registrationId, replay] of registrationReplays) {
+          if (replay.token === clientToken) removeRegistrationReplay(registrationId, replay);
+        }
+        c.lastSeen = nowMs();
         const name = String(body.name || '');
         // Bind-intent calls re-point routing at the caller BEFORE dispatch, so a
         // notify emitted synchronously during the call already targets it.
@@ -526,6 +651,7 @@ export function createChannelDaemonTransport({
     cancelGrace();
     if (sweepTimer) { try { clearInterval(sweepTimer); } catch {} sweepTimer = null; }
     for (const [token] of clients) dropClient(token, 'transport stop');
+    clearRegistrationReplays();
     if (discoveryPath) { try { rmSync(discoveryPath, { force: true }); } catch {} }
     if (server) {
       await new Promise((resolve) => { try { server.close(() => resolve()); } catch { resolve(); } });
@@ -540,6 +666,7 @@ export function createChannelDaemonTransport({
     get port() { return boundPort; },
     get token() { return serverToken; },
     _clientsForTest: clients,
+    _registrationReplaysForTest: registrationReplays,
     _resolveTargetForTest: resolveTarget,
   };
 }