ompchamber 0.5.0 → 0.7.0

package/src/server/lib/lifecycle/instance.ts

@@ -0,0 +1,102 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The per-port instance record: who is serving this port, in what mode, since
+ * when.
+ *
+ * Written by the server that owns the port (not by the CLI that happened to
+ * spawn it), so a server started by `bun run dev`, by `--foreground`, or by the
+ * daemon path is discoverable the same way. Writes are best-effort: a read-only
+ * data directory must degrade `status` to a probe, never take the server down.
+ */
+
+import fs from 'fs';
+
+import { getInstancePath, getRunDir } from '@/server/lib/lifecycle/paths';
+
+export type InstanceMode = 'dev' | 'prod';
+export type InstanceLaunchMode = 'daemon' | 'foreground' | 'direct';
+
+export interface InstanceRecord {
+  pid: number;
+  port: number;
+  host: string;
+  mode: InstanceMode;
+  launchMode: InstanceLaunchMode;
+  startedAt: string;
+  version: string;
+}
+
+function isLaunchMode(value: unknown): value is InstanceLaunchMode {
+  return value === 'daemon' || value === 'foreground' || value === 'direct';
+}
+
+/** Record for `port`, or null when absent or unreadable. */
+export function readInstanceRecord(port: number | string): InstanceRecord | null {
+  try {
+    const parsed: unknown = JSON.parse(fs.readFileSync(getInstancePath(port), 'utf8'));
+    if (!parsed || typeof parsed !== 'object') return null;
+    const record = parsed as Record<string, unknown>;
+    if (typeof record.pid !== 'number' || typeof record.port !== 'number') return null;
+    return {
+      pid: record.pid,
+      port: record.port,
+      host: typeof record.host === 'string' ? record.host : 'localhost',
+      mode: record.mode === 'prod' ? 'prod' : 'dev',
+      launchMode: isLaunchMode(record.launchMode) ? record.launchMode : 'direct',
+      startedAt: typeof record.startedAt === 'string' ? record.startedAt : '',
+      version: typeof record.version === 'string' ? record.version : '',
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** Every readable record in the run directory. */
+export function listInstanceRecords(): InstanceRecord[] {
+  const records: InstanceRecord[] = [];
+  try {
+    for (const file of fs.readdirSync(getRunDir())) {
+      const match = /^(\d+)\.json$/.exec(file);
+      if (!match) continue;
+      const record = readInstanceRecord(match[1]);
+      if (record) records.push(record);
+    }
+  } catch {
+    // No run directory yet: nothing has ever been served.
+  }
+  return records;
+}
+
+/**
+ * Persist the record for its port (sibling temp file + rename, mode 0600).
+ * Returns false instead of throwing when the data directory is not writable.
+ */
+export function writeInstanceRecord(record: InstanceRecord): boolean {
+  const target = getInstancePath(record.port);
+  const temp = `${target}.${process.pid}.tmp`;
+  try {
+    fs.writeFileSync(temp, JSON.stringify(record, null, 2), { mode: 0o600 });
+    fs.renameSync(temp, target);
+    return true;
+  } catch {
+    try {
+      fs.rmSync(temp, { force: true });
+    } catch {
+      // Best-effort cleanup only.
+    }
+    return false;
+  }
+}
+
+/** Drop the record for `port`. Never throws. */
+export function removeInstanceRecord(port: number | string): void {
+  try {
+    fs.rmSync(getInstancePath(port), { force: true });
+  } catch {
+    // Best-effort: a stale record is detected by PID identity on the next read.
+  }
+}

package/src/server/lib/lifecycle/launch-mode.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from 'bun:test';
+
+import { launchModeArg, resolveLaunchMode } from '@/server/lib/lifecycle/launch-mode';
+
+const ENTRY = '/repo/src/server/index.ts';
+
+describe('resolveLaunchMode', () => {
+  test('reads the flag the CLI appends to the servers it spawns', () => {
+    expect(resolveLaunchMode(['bun', ENTRY, '--ompchamber-server', launchModeArg('daemon')])).toBe('daemon');
+    expect(resolveLaunchMode(['bun', ENTRY, '--ompchamber-server', launchModeArg('foreground')])).toBe('foreground');
+  });
+
+  test('treats a server started without the flag as direct', () => {
+    // `bun run dev`, `bun run start`, a manual run, an external supervisor.
+    expect(resolveLaunchMode(['bun', 'run', '--hot', ENTRY, '--ompchamber-server'])).toBe('direct');
+    expect(resolveLaunchMode(['bun', ENTRY, '--ompchamber-server', '--launch-mode=sideways'])).toBe('direct');
+  });
+
+  test('ignores an inherited environment marker', () => {
+    // The chamber's terminal panel runs commands with the server's own env, so
+    // a `bun run dev` started there inherits `daemon` — argv is the only
+    // trustworthy signal, and this test fails if env is ever read again.
+    const previous = Bun.env.OMPCHAMBER_LAUNCH_MODE;
+    Bun.env.OMPCHAMBER_LAUNCH_MODE = 'daemon';
+    try {
+      expect(resolveLaunchMode(['bun', ENTRY, '--ompchamber-server'])).toBe('direct');
+    } finally {
+      if (previous === undefined) delete Bun.env.OMPCHAMBER_LAUNCH_MODE;
+      else Bun.env.OMPCHAMBER_LAUNCH_MODE = previous;
+    }
+  });
+});

package/src/server/lib/lifecycle/launch-mode.ts

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * How this server was launched — the fact that decides whether an update may
+ * replace it.
+ *
+ * The marker travels as an argv flag, never as an environment variable. Env is
+ * inherited by every descendant, so a server started from a shell *inside* an
+ * OMPChamber tree — the chamber's own terminal panel runs commands with the
+ * server's environment — would inherit `daemon` and then be swapped out by the
+ * next update, killing a `bun run dev` loop OMPChamber does not own. argv
+ * belongs to the process alone.
+ */
+
+import type { InstanceLaunchMode } from '@/server/lib/lifecycle/instance';
+
+/** The argv flag the CLI appends to every server it spawns. */
+const LAUNCH_MODE_FLAG = '--launch-mode=';
+
+/**
+ * The argv entry for `mode`. Paired with `resolveLaunchMode`, so the flag
+ * spelling exists in exactly one place for the writer and the reader.
+ */
+export function launchModeArg(mode: InstanceLaunchMode): string {
+  return `${LAUNCH_MODE_FLAG}${mode}`;
+}
+
+/**
+ * Launch mode of a server invocation. Only the CLI passes the flag, so a
+ * `bun run dev`, a `bun run start`, a manual run and an externally supervised
+ * process all resolve to `direct` — the mode that is left alone.
+ */
+export function resolveLaunchMode(argv: readonly string[] = Bun.argv): InstanceLaunchMode {
+  const flag = argv.find((arg) => arg.startsWith(LAUNCH_MODE_FLAG));
+  const value = flag?.slice(LAUNCH_MODE_FLAG.length);
+  return value === 'daemon' || value === 'foreground' ? value : 'direct';
+}

package/src/server/lib/lifecycle/occupant.ts

@@ -0,0 +1,101 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Who is serving a port right now.
+ *
+ * Two independent sources answer that question, and they are deliberately
+ * combined: the instance record (written by the server itself) and the live
+ * `/api/health` probe. The record is the only source for a port whose server is
+ * deaf (hung, suspended, still starting), while the probe is the only source
+ * for a server started outside the CLI — a `bun run dev` server must be
+ * discoverable, and before this module it was invisible to every CLI command.
+ */
+
+import { getProcessState, isProcessAlive } from '@/server/lib/lifecycle/identity';
+import { readInstanceRecord } from '@/server/lib/lifecycle/instance';
+import { fetchHealth } from '@/server/lib/lifecycle/probe';
+
+export interface Occupant {
+  pid: number;
+  port: number;
+  host?: string;
+  version?: string;
+  /** `dev` | `prod` as reported by the live server, else from the record. */
+  mode?: string;
+  launchMode?: string;
+  startedAt?: string;
+  uptime?: number;
+  source: 'registry+probe' | 'probe' | 'registry';
+  /** True when the occupant answered `/api/health` as OMPChamber itself. */
+  confirmedByHealth: boolean;
+}
+
+/** The OMPChamber instance on `port`, or null when the port is free/foreign. */
+export async function findOccupant(port: number, host?: string | null): Promise<Occupant | null> {
+  const record = readInstanceRecord(port);
+  const recordIsLive = record !== null
+    && isProcessAlive(record.pid)
+    && getProcessState(record.pid) !== 'mismatched';
+
+  const health = await fetchHealth(port, record?.host ?? host);
+  const healthPid = health?.pid;
+  if (health && typeof healthPid === 'number' && isProcessAlive(healthPid)) {
+    return {
+      pid: healthPid,
+      port,
+      host: record?.host ?? host ?? undefined,
+      version: health.version ?? record?.version,
+      mode: health.mode ?? record?.mode,
+      launchMode: record?.launchMode,
+      startedAt: health.startedAt ?? record?.startedAt,
+      uptime: health.uptime,
+      source: recordIsLive && record.pid === healthPid ? 'registry+probe' : 'probe',
+      confirmedByHealth: true,
+    };
+  }
+
+  if (record && recordIsLive) {
+    return {
+      pid: record.pid,
+      port,
+      host: record.host,
+      version: record.version,
+      mode: record.mode,
+      launchMode: record.launchMode,
+      startedAt: record.startedAt,
+      source: 'registry',
+      confirmedByHealth: false,
+    };
+  }
+
+  return null;
+}
+
+/** One-line identity for logs and errors: `pid 1234 (dev, direct, v0.5.0, up 2m)`. */
+export function describeOccupant(occupant: Occupant): string {
+  const details: string[] = [];
+  if (occupant.mode) details.push(occupant.mode);
+  if (occupant.launchMode) details.push(occupant.launchMode);
+  if (occupant.version) details.push(`v${occupant.version}`);
+  const age = occupantAge(occupant);
+  if (age) details.push(`up ${age}`);
+  if (!occupant.confirmedByHealth) details.push('unconfirmed');
+  const suffix = details.length > 0 ? ` (${details.join(', ')})` : '';
+  return `pid ${occupant.pid}${suffix}`;
+}
+
+function occupantAge(occupant: Occupant): string | null {
+  const seconds = typeof occupant.uptime === 'number'
+    ? Math.round(occupant.uptime)
+    : occupant.startedAt
+      ? Math.round((Date.now() - Date.parse(occupant.startedAt)) / 1000)
+      : Number.NaN;
+  if (!Number.isFinite(seconds) || seconds < 0) return null;
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+}

package/src/server/lib/lifecycle/paths.ts

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Where OMPChamber keeps per-port runtime state.
+ *
+ * Both the server and the CLI need these paths, and they must agree: the server
+ * owns the record for the port it listens on, and the CLI reads that same record
+ * to answer `status` / `stop` / `logs`. One module is what makes the agreement
+ * structural — the previous split (CLI wrote, server never did) is why a server
+ * started outside the CLI was invisible to every CLI command.
+ */
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+/**
+ * Root of OMPChamber's own state (~/.ompchamber, or OMPCHAMBER_DATA_DIR).
+ *
+ * `os.homedir()` rather than HOME: a process started without a shell (cron,
+ * launchd, a service) has no HOME, and an empty value would silently move the
+ * data directory to a cwd-relative path.
+ */
+export function getDataDir(): string {
+  const override = (Bun.env.OMPCHAMBER_DATA_DIR ?? '').trim();
+  if (override) {
+    return path.resolve(override.startsWith('~') ? path.join(os.homedir(), override.slice(1)) : override);
+  }
+  return path.join(os.homedir(), '.ompchamber');
+}
+
+/** Directory holding per-instance records and handover locks (mode 0700). */
+export function getRunDir(): string {
+  const dir = path.join(getDataDir(), 'run');
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  return dir;
+}
+
+/** `<data>/run/<port>.json` — the record written by the server serving `port`. */
+export function getInstancePath(port: number | string): string {
+  return path.join(getRunDir(), `${port}.json`);
+}
+
+/** `<data>/run/<port>.lock` — held only while a port handover is in progress. */
+export function getLockPath(port: number | string): string {
+  return path.join(getRunDir(), `${port}.lock`);
+}

package/src/server/lib/lifecycle/port-guard.ts

@@ -0,0 +1,170 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Port guarding for a starting OMPChamber server.
+ *
+ * One port is served by exactly one process, and **a starting instance never
+ * stops another one** — not a CLI server, not a dev run. An occupant that
+ * identifies itself as OMPChamber makes the newcomer exit with the ways to pick
+ * a different port; freeing a port is what `ompchamber stop --port <port>` is
+ * for, done deliberately and per port.
+ *
+ * The refusal is load-bearing rather than defensive: a second bind is *not*
+ * refused by the runtime (Elysia's Bun adapter hardcodes `reusePort: true`), so
+ * two servers would coexist on one port and only the first-bound socket would
+ * receive connections. The newcomer would look healthy in its own log while the
+ * browser kept talking to the old build; the guard stops that state from being
+ * created in the first place.
+ */
+
+import fs from 'fs';
+
+import { getProcessState } from '@/server/lib/lifecycle/identity';
+import { describeOccupant, findOccupant } from '@/server/lib/lifecycle/occupant';
+import { getLockPath } from '@/server/lib/lifecycle/paths';
+import { isPortAvailable } from '@/server/lib/lifecycle/probe';
+
+const LOCK_WAIT_MS = 3_000;
+/** Grace period for a port that is settling (a server that just exited, or one that is starting). */
+const SETTLE_WAIT_MS = 3_000;
+
+export class PortInUseError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'PortInUseError';
+  }
+}
+
+export interface PortLock {
+  release: () => void;
+}
+
+/**
+ * Exclusive per-port startup lock.
+ *
+ * Two starters racing on one free port would each probe it as free and then
+ * fight over the bind, with the loser reporting a bare `EADDRINUSE` against a
+ * process it cannot identify yet. Holding the lock across probe-and-bind makes
+ * the loser fail with a message that names the actual situation. A lock whose
+ * holder is dead (or is not OMPChamber, i.e. a recycled PID) is reclaimed.
+ *
+ * Returns null when another starter holds the lock through the wait window.
+ */
+export async function acquirePortLock(port: number, waitMs = LOCK_WAIT_MS): Promise<PortLock | null> {
+  const lockPath = getLockPath(port);
+  const deadline = Date.now() + waitMs;
+  for (;;) {
+    try {
+      fs.writeFileSync(lockPath, String(process.pid), { flag: 'wx', mode: 0o600 });
+      return { release: () => releasePortLock(lockPath) };
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') return null;
+    }
+
+    let holder = Number.NaN;
+    try {
+      holder = Number(fs.readFileSync(lockPath, 'utf8').trim());
+    } catch {
+      continue;
+    }
+
+    const holderState = Number.isFinite(holder) && holder > 0 ? getProcessState(holder) : 'dead';
+    if (holderState === 'dead' || holderState === 'mismatched') {
+      fs.rmSync(lockPath, { force: true });
+      continue;
+    }
+    if (holder === process.pid) return { release: () => releasePortLock(lockPath) };
+    if (Date.now() >= deadline) return null;
+    await Bun.sleep(150);
+  }
+}
+
+function releasePortLock(lockPath: string): void {
+  try {
+    if (fs.readFileSync(lockPath, 'utf8').trim() === String(process.pid)) fs.rmSync(lockPath, { force: true });
+  } catch {
+    // Already gone, or never ours to remove.
+  }
+}
+
+export interface ClaimPortOptions {
+  port: number;
+  host: string;
+  /**
+   * Binds the port; must throw when the OS refuses. Retried while the port
+   * looks occupied by something that is not an identified OMPChamber instance.
+   */
+  listen: () => Promise<void>;
+}
+
+/**
+ * Bind `port`, or fail with an actionable error.
+ *
+ * The bind is the authoritative question ("can this process listen here") and
+ * `listen` is what answers it; the probe only short-circuits the common case.
+ * When either says the port is taken, the occupant is identified so the error
+ * can name it — and then the process exits, leaving every other instance
+ * running.
+ */
+export async function claimPort({ port, host, listen }: ClaimPortOptions): Promise<void> {
+  const deadline = Date.now() + SETTLE_WAIT_MS;
+  let bindError: unknown = null;
+
+  for (;;) {
+    if (await isPortAvailable(port, host)) {
+      try {
+        await listen();
+        return;
+      } catch (error) {
+        bindError = error;
+      }
+    }
+
+    const occupant = await findOccupant(port, host);
+
+    // `bun run --hot` re-evaluates this entry inside the running process, so the
+    // port is held by *us* and Bun swaps the fetch handler on the next `listen`.
+    // Treating that as a conflict would kill the dev loop on every save.
+    if (occupant && occupant.pid === process.pid) {
+      await listen();
+      return;
+    }
+
+    if (occupant) throw await buildPortInUseError(port, host, bindError);
+
+    if (Date.now() >= deadline) throw await buildPortInUseError(port, host, bindError);
+    await Bun.sleep(200);
+  }
+}
+
+/** Every way to point this server at another port. */
+function portGuidance(): string {
+  return [
+    '    ompchamber serve --port 3001',
+    '    OMPCHAMBER_PORT=3001 ompchamber serve',
+    '    PORT=3001 bun run dev          # or: PORT=3001 bun run start',
+  ].join('\n');
+}
+
+async function buildPortInUseError(port: number, host: string, bindError: unknown): Promise<PortInUseError> {
+  const occupant = await findOccupant(port, host);
+  const bindDetail = bindError instanceof Error ? `\n  Bind error: ${bindError.message}` : '';
+
+  if (occupant) {
+    return new PortInUseError(
+      `Port ${port} is already served by OMPChamber ${describeOccupant(occupant)}.\n`
+      + `  Nothing was stopped — a starting instance never stops another one.\n`
+      + `  Stop it first:  ompchamber stop --port ${port}\n`
+      + `  Or start on another port:\n${portGuidance()}`,
+    );
+  }
+
+  return new PortInUseError(
+    `Port ${port} is in use by another process (no OMPChamber instance answered on it).${bindDetail}\n`
+    + `  Find it with:  lsof -nP -iTCP:${port} -sTCP:LISTEN\n`
+    + `  Start on another port:\n${portGuidance()}`,
+  );
+}

package/src/server/lib/lifecycle/probe.ts

@@ -0,0 +1,121 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Port occupancy probing.
+ *
+ * Availability is decided by *attempting a bind*, not by inspecting a PID file.
+ * That matters on Bun: `Bun.serve` — and therefore Elysia's `listen`, which
+ * hardcodes `reusePort: true` — lets a second process bind a port already in
+ * use, so the only reliable question a starter can ask the OS is "can I bind
+ * this?" (`net.createServer` never sets SO_REUSEPORT, so a second bind fails as
+ * it should, regardless of who is already listening).
+ */
+
+import net from 'net';
+
+const HEALTH_TIMEOUT_MS = 1500;
+
+/**
+ * Address a local probe should use for a bind host.
+ *
+ * `0.0.0.0`/`::` are bind-any addresses and cannot be connected to; loopback is
+ * the address that reaches the same listener.
+ */
+export function probeHost(host?: string | null): string {
+  const value = (host ?? '').trim();
+  if (value.length === 0 || value === '0.0.0.0' || value === '::' || value === '[::]') return '127.0.0.1';
+  return value;
+}
+
+/**
+ * True when `port` can still be bound on `host`.
+ *
+ * The probe binds *the same address the server will bind* — a wildcard server
+ * is probed with a wildcard bind. Probing loopback instead would ask a
+ * different question: `net` sets SO_REUSEADDR, so a loopback bind can succeed
+ * while `0.0.0.0:<port>` is already taken, and the port would look free right
+ * up until the real `listen` failed.
+ */
+export async function isPortAvailable(port: number, host?: string | null): Promise<boolean> {
+  if (!Number.isFinite(port) || port <= 0) return false;
+  const bindHost = (host ?? '').trim() || 'localhost';
+  const { promise, resolve } = Promise.withResolvers<boolean>();
+  const probe = net.createServer();
+  probe.unref();
+  probe.once('error', () => resolve(false));
+  probe.listen({ port, host: bindHost }, () => {
+    probe.close(() => resolve(true));
+  });
+  return await promise;
+}
+
+/** Poll until the port can be bound, or the deadline passes. */
+export async function waitForPortFree(
+  port: number,
+  host: string | null | undefined,
+  timeoutMs: number,
+  intervalMs = 150,
+): Promise<boolean> {
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  for (;;) {
+    if (await isPortAvailable(port, host)) return true;
+    if (Date.now() >= deadline) return false;
+    await Bun.sleep(intervalMs);
+  }
+}
+
+export interface HealthPayload {
+  service: string;
+  pid?: number;
+  version?: string;
+  startedAt?: string;
+  uptime?: number;
+  mock?: boolean;
+  runtime?: string;
+  mode?: string;
+  port?: number;
+  host?: string;
+}
+
+/**
+ * `GET /api/health` for an OMPChamber listener, or null.
+ *
+ * Only payloads that identify themselves as OMPChamber are returned — every
+ * caller here is asking "is an OMPChamber server on this port", so a foreign
+ * HTTP service answers null rather than a half-trusted object.
+ */
+export async function fetchHealth(
+  port: number,
+  host?: string | null,
+  timeoutMs = HEALTH_TIMEOUT_MS,
+): Promise<HealthPayload | null> {
+  if (!Number.isFinite(port) || port <= 0) return null;
+  try {
+    const response = await fetch(`http://${probeHost(host)}:${port}/api/health`, {
+      headers: { accept: 'application/json' },
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!response.ok) return null;
+    const body: unknown = await response.json();
+    if (!body || typeof body !== 'object') return null;
+    const payload = body as Record<string, unknown>;
+    if (payload.service !== 'ompchamber') return null;
+    return {
+      service: 'ompchamber',
+      pid: typeof payload.pid === 'number' ? payload.pid : undefined,
+      version: typeof payload.version === 'string' ? payload.version : undefined,
+      startedAt: typeof payload.startedAt === 'string' ? payload.startedAt : undefined,
+      uptime: typeof payload.uptime === 'number' ? payload.uptime : undefined,
+      mock: typeof payload.mock === 'boolean' ? payload.mock : undefined,
+      runtime: typeof payload.runtime === 'string' ? payload.runtime : undefined,
+      mode: typeof payload.mode === 'string' ? payload.mode : undefined,
+      port: typeof payload.port === 'number' ? payload.port : undefined,
+      host: typeof payload.host === 'string' ? payload.host : undefined,
+    };
+  } catch {
+    return null;
+  }
+}

package/src/server/lib/lifecycle/restart.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, test } from 'bun:test';
+
+import { isAutoRestartable } from '@/server/lib/lifecycle/restart';
+
+// The modal update and `ompchamber update` both decide with this predicate:
+// guessing wrong here kills a `bun run dev` the user owns, or leaves a daemon
+// serving the build that was just replaced.
+describe('isAutoRestartable', () => {
+  test('restarts the instances the CLI started', () => {
+    expect(isAutoRestartable('daemon')).toBe(true);
+    expect(isAutoRestartable('foreground')).toBe(true);
+  });
+
+  test('leaves every instance OMPChamber did not start alone', () => {
+    // `bun run dev`, `bun run start`, a manual run, a systemd/pm2 unit.
+    expect(isAutoRestartable('direct')).toBe(false);
+    // A probed or unreadable record never authorises a kill either.
+    expect(isAutoRestartable('unknown')).toBe(false);
+    expect(isAutoRestartable(undefined)).toBe(false);
+  });
+});